Overview | Package | Class | Tree | Deprecated | Index | Help
| SSJ V. 2.1.1.
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## umontreal.iro.lecuyer.util
Class ArithmeticMod

    java.lang.Object
      umontreal.iro.lecuyer.util.ArithmeticMod

    public class ArithmeticMod

extends 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
`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 `A`c 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 `A`2`e` 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 `A`2`e` 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 `A`c 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

Overview | Package | Class | Tree | Deprecated | Index | Help
| SSJ V. 2.1.1.
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

To submit a bug or ask questions, send an e-mail to Pierre L'Ecuyer.