ArithmeticMod
umontreal.iro.lecuyer.util

## Class ArithmeticMod

• `public class ArithmeticModextends Object`
This class provides facilities to compute multiplications of scalars, of vectors and of matrices modulo m. All algorithms are present in three different versions. These allow operations on double, int and long. The int and long versions work exactly like the double ones.
• ### Method Summary

Methods
Modifier and TypeMethod and Description
`static void``matMatModM(double[][] A, double[][] B, double[][] C, double m)`
Computes A×B mod m and puts the result in C.
`static void``matMatModM(int[][] A, int[][] B, int[][] C, int m)`
Exactly like `matMatModM` using double, but with int instead of double.
`static void``matMatModM(long[][] A, long[][] B, long[][] C, long m)`
Exactly like `matMatModM` using double, but with long instead of double.
`static void``matPowModM(double[][] A, double[][] B, double m, int c)`
Computes Ac mod m and puts the result in B.
`static void``matPowModM(int[][] A, int[][] B, int m, int c)`
Exactly like `matPowModM` using double, but with int instead of double.
`static void``matPowModM(long[][] A, long[][] B, long m, int c)`
Exactly like `matPowModM` using double, but with long instead of double.
`static void``matTwoPowModM(double[][] A, double[][] B, double m, int e)`
Computes A2e mod m and puts the result in B.
`static void``matTwoPowModM(int[][] A, int[][] B, int m, int e)`
Exactly like `matTwoPowModM` using double, but with int instead of double.
`static void``matTwoPowModM(long[][] A, long[][] B, long m, int e)`
Exactly like `matTwoPowModM` using double, but with long instead of double.
`static void``matVecModM(double[][] A, double[] s, double[] v, double m)`
Computes the result of A×s mod m and puts the result in v.
`static void``matVecModM(int[][] A, int[] s, int[] v, int m)`
Exactly like `matVecModM` using double, but with int instead of double.
`static void``matVecModM(long[][] A, long[] s, long[] v, long m)`
Exactly like `matVecModM` using double, but with long instead of double.
`static double``multModM(double a, double s, double c, double m)`
Computes (a×s + c) mod m.
`static int``multModM(int a, int s, int c, int m)`
Computes (a×s + c) mod m.
`static long``multModM(long a, long s, long c, long m)`
Computes (a×s + c) mod m.
• ### Methods inherited from class java.lang.Object

`equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`
• ### Method Detail

• #### multModM

`public static double multModM(double a,              double s,              double c,              double m)`
Computes (a×s + c) mod m. Where m must be smaller than 235. Works also if s or c are negative. The result is always positive (and thus always between 0 and m - 1).
Parameters:
`a` - the first factor of the multiplication
`s` - the second factor of the multiplication
`c` - the second term of the addition
`m` - the modulus
Returns:
the result of the multiplication and the addition modulo m
• #### matVecModM

`public static void matVecModM(double[][] A,              double[] s,              double[] v,              double m)`
Computes the result of A×s mod m and puts the result in v. Where s and v are both column vectors. This method works even if s = v.
Parameters:
`A` - the multiplication matrix
`s` - the multiplied vector
`v` - the result of the multiplication
`m` - the modulus
• #### matMatModM

`public static void matMatModM(double[][] A,              double[][] B,              double[][] C,              double m)`
Computes A×B mod m and puts the result in C. Works even if A = C, B = C or A = B = C.
Parameters:
`A` - the first factor of the multiplication
`B` - the second factor of the multiplication
`C` - the result of the multiplication
`m` - the modulus
• #### matTwoPowModM

`public static void matTwoPowModM(double[][] A,                 double[][] B,                 double m,                 int e)`
Computes A2e mod m and puts the result in B. Works even if A = B.
Parameters:
`A` - the matrix to raise to a power
`B` - the result of exponentiation
`m` - the modulus
`e` - the log2 of the exponent
• #### matPowModM

`public static void matPowModM(double[][] A,              double[][] B,              double m,              int c)`
Computes Ac mod m and puts the result in B. Works even if A = B.
Parameters:
`A` - the matrix to raise to a power
`B` - the result of the exponentiation
`m` - the modulus
`c` - the exponent
• #### multModM

`public static int multModM(int a,           int s,           int c,           int m)`
Computes (a×s + c) mod m. Works also if s or c are negative. The result is always positive (and thus always between 0 and m - 1).
Parameters:
`a` - the first factor of the multiplication
`s` - the second factor of the multiplication
`c` - the second term of the addition
`m` - the modulus
Returns:
the result of the multiplication and the addition modulo m
• #### matVecModM

`public static void matVecModM(int[][] A,              int[] s,              int[] v,              int m)`
Exactly like `matVecModM` using double, but with int instead of double.
Parameters:
`A` - the multiplication matrix
`s` - the multiplied vector
`v` - the result of the multiplication
`m` - the modulus
• #### matMatModM

`public static void matMatModM(int[][] A,              int[][] B,              int[][] C,              int m)`
Exactly like `matMatModM` using double, but with int instead of double.
Parameters:
`A` - the first factor of the multiplication
`B` - the second factor of the multiplication
`C` - the result of the multiplication
`m` - the modulus
• #### matTwoPowModM

`public static void matTwoPowModM(int[][] A,                 int[][] B,                 int m,                 int e)`
Exactly like `matTwoPowModM` using double, but with int instead of double.
Parameters:
`A` - the matrix to raise to a power
`B` - the result of exponentiation
`m` - the modulus
`e` - the log2 of the exponent
• #### matPowModM

`public static void matPowModM(int[][] A,              int[][] B,              int m,              int c)`
Exactly like `matPowModM` using double, but with int instead of double.
Parameters:
`A` - the matrix to raise to a power
`B` - the result of the exponentiation
`m` - the modulus
`c` - the exponent
• #### multModM

`public static long multModM(long a,            long s,            long c,            long m)`
Computes (a×s + c) mod m. Works also if s or c are negative. The result is always positive (and thus always between 0 and m - 1).
Parameters:
`a` - the first factor of the multiplication
`s` - the second factor of the multiplication
`c` - the second term of the addition
`m` - the modulus
Returns:
the result of the multiplication and the addition modulo m
• #### matVecModM

`public static void matVecModM(long[][] A,              long[] s,              long[] v,              long m)`
Exactly like `matVecModM` using double, but with long instead of double.
Parameters:
`A` - the multiplication matrix
`s` - the multiplied vector
`v` - the result of the multiplication
`m` - the modulus
• #### matMatModM

`public static void matMatModM(long[][] A,              long[][] B,              long[][] C,              long m)`
Exactly like `matMatModM` using double, but with long instead of double.
Parameters:
`A` - the first factor of the multiplication
`B` - the second factor of the multiplication
`C` - the result of the multiplication
`m` - the modulus
• #### matTwoPowModM

`public static void matTwoPowModM(long[][] A,                 long[][] B,                 long m,                 int e)`
Exactly like `matTwoPowModM` using double, but with long instead of double.
Parameters:
`A` - the matrix to raise to a power
`B` - the result of exponentiation
`m` - the modulus
`e` - the log2 of the exponent
• #### matPowModM

`public static void matPowModM(long[][] A,              long[][] B,              long m,              int c)`
Exactly like `matPowModM` using double, but with long instead of double.
Parameters:
`A` - the matrix to raise to a power
`B` - the result of the exponentiation
`m` - the modulus
`c` - the exponent