cern.colt.matrix.doublealgo

## Class Transform

- java.lang.Object
- - cern.colt.PersistentObject
  - - cern.colt.matrix.doublealgo.Transform

- All Implemented Interfaces:
    java.io.Serializable, java.lang.Cloneable

  Deprecated.

      public class Transform
      extends PersistentObject

  Deprecated; Basic element-by-element transformations on `DoubleMatrix1D` and `DoubleMatrix2D`. All transformations modify the first argument matrix to hold the result of the transformation. Use idioms like `result = mult(matrix.copy(),5)` to leave source matrices unaffected.

  If your favourite transformation is not provided by this class, consider using method `assign` in combination with prefabricated function objects of `Functions`, using idioms like

      cern.jet.math.Functions F = cern.jet.math.Functions.functions; // alias
      matrix.assign(F.square);
      matrix.assign(F.sqrt);
      matrix.assign(F.sin);
      matrix.assign(F.log);
      matrix.assign(F.log(b));
      matrix.assign(otherMatrix, F.min);
      matrix.assign(otherMatrix, F.max);

  Here are some other examples.

  Implementation: Performance optimized for medium to very large matrices. In fact, there is now nomore a performance advantage in using this class; The assign (transform) methods directly defined on matrices are now just as fast. Thus, this class will soon be removed altogether.

  Version:
    1.0, 09/24/99
  See Also:
    Serialized Form

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `static Transform` | `transform` Deprecated. Little trick to allow for "aliasing", that is, renaming this class.

    - ### Fields inherited from class cern.colt.PersistentObject

      `serialVersionUID`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `static DoubleMatrix1D` | `abs(DoubleMatrix1D A)` Deprecated. `A[i] = Math.abs(A[i])`.
    `static DoubleMatrix2D` | `abs(DoubleMatrix2D A)` Deprecated. `A[row,col] = Math.abs(A[row,col])`.
    `static DoubleMatrix1D` | `div(DoubleMatrix1D A, double s)` Deprecated. `A = A / s <=> A[i] = A[i] / s`.
    `static DoubleMatrix1D` | `div(DoubleMatrix1D A, DoubleMatrix1D B)` Deprecated. `A = A / B <=> A[i] = A[i] / B[i]`.
    `static DoubleMatrix2D` | `div(DoubleMatrix2D A, double s)` Deprecated. `A = A / s <=> A[row,col] = A[row,col] / s`.
    `static DoubleMatrix2D` | `div(DoubleMatrix2D A, DoubleMatrix2D B)` Deprecated. `A = A / B <=> A[row,col] = A[row,col] / B[row,col]`.
    `static DoubleMatrix2D` | `equals(DoubleMatrix2D A, double s)` Deprecated. `A[row,col] = A[row,col] == s ? 1 : 0`; ignores tolerance.
    `static DoubleMatrix2D` | `equals(DoubleMatrix2D A, DoubleMatrix2D B)` Deprecated. `A[row,col] = A[row,col] == B[row,col] ? 1 : 0`; ignores tolerance.
    `static DoubleMatrix2D` | `greater(DoubleMatrix2D A, double s)` Deprecated. `A[row,col] = A[row,col] > s ? 1 : 0`.
    `static DoubleMatrix2D` | `greater(DoubleMatrix2D A, DoubleMatrix2D B)` Deprecated. `A[row,col] = A[row,col] > B[row,col] ? 1 : 0`.
    `static DoubleMatrix2D` | `less(DoubleMatrix2D A, double s)` Deprecated. `A[row,col] = A[row,col] < s ? 1 : 0`.
    `static DoubleMatrix2D` | `less(DoubleMatrix2D A, DoubleMatrix2D B)` Deprecated. `A[row,col] = A[row,col] < B[row,col] ? 1 : 0`.
    `static DoubleMatrix1D` | `minus(DoubleMatrix1D A, double s)` Deprecated. `A = A - s <=> A[i] = A[i] - s`.
    `static DoubleMatrix1D` | `minus(DoubleMatrix1D A, DoubleMatrix1D B)` Deprecated. `A = A - B <=> A[i] = A[i] - B[i]`.
    `static DoubleMatrix2D` | `minus(DoubleMatrix2D A, double s)` Deprecated. `A = A - s <=> A[row,col] = A[row,col] - s`.
    `static DoubleMatrix2D` | `minus(DoubleMatrix2D A, DoubleMatrix2D B)` Deprecated. `A = A - B <=> A[row,col] = A[row,col] - B[row,col]`.
    `static DoubleMatrix1D` | `minusMult(DoubleMatrix1D A, DoubleMatrix1D B, double s)` Deprecated. `A = A - B*s <=> A[i] = A[i] - B[i]*s`.
    `static DoubleMatrix2D` | `minusMult(DoubleMatrix2D A, DoubleMatrix2D B, double s)` Deprecated. `A = A - B*s <=> A[row,col] = A[row,col] - B[row,col]*s`.
    `static DoubleMatrix1D` | `mult(DoubleMatrix1D A, double s)` Deprecated. `A = A * s <=> A[i] = A[i] * s`.
    `static DoubleMatrix1D` | `mult(DoubleMatrix1D A, DoubleMatrix1D B)` Deprecated. `A = A * B <=> A[i] = A[i] * B[i]`.
    `static DoubleMatrix2D` | `mult(DoubleMatrix2D A, double s)` Deprecated. `A = A * s <=> A[row,col] = A[row,col] * s`.
    `static DoubleMatrix2D` | `mult(DoubleMatrix2D A, DoubleMatrix2D B)` Deprecated. `A = A * B <=> A[row,col] = A[row,col] * B[row,col]`.
    `static DoubleMatrix1D` | `negate(DoubleMatrix1D A)` Deprecated. `A = -A <=> A[i] = -A[i]` for all cells.
    `static DoubleMatrix2D` | `negate(DoubleMatrix2D A)` Deprecated. `A = -A <=> A[row,col] = -A[row,col]`.
    `static DoubleMatrix1D` | `plus(DoubleMatrix1D A, double s)` Deprecated. `A = A + s <=> A[i] = A[i] + s`.
    `static DoubleMatrix1D` | `plus(DoubleMatrix1D A, DoubleMatrix1D B)` Deprecated. `A = A + B <=> A[i] = A[i] + B[i]`.
    `static DoubleMatrix2D` | `plus(DoubleMatrix2D A, double s)` Deprecated. `A = A + s <=> A[row,col] = A[row,col] + s`.
    `static DoubleMatrix2D` | `plus(DoubleMatrix2D A, DoubleMatrix2D B)` Deprecated. `A = A + B <=> A[row,col] = A[row,col] + B[row,col]`.
    `static DoubleMatrix1D` | `plusMult(DoubleMatrix1D A, DoubleMatrix1D B, double s)` Deprecated. `A = A + B*s<=> A[i] = A[i] + B[i]*s`.
    `static DoubleMatrix2D` | `plusMult(DoubleMatrix2D A, DoubleMatrix2D B, double s)` Deprecated. `A = A + B*s <=> A[row,col] = A[row,col] + B[row,col]*s`.
    `static DoubleMatrix1D` | `pow(DoubleMatrix1D A, double s)` Deprecated. `A = As <=> A[i] = Math.pow(A[i], s)`.
    `static DoubleMatrix1D` | `pow(DoubleMatrix1D A, DoubleMatrix1D B)` Deprecated. `A = AB <=> A[i] = Math.pow(A[i], B[i])`.
    `static DoubleMatrix2D` | `pow(DoubleMatrix2D A, double s)` Deprecated. `A = As <=> A[row,col] = Math.pow(A[row,col], s)`.
    `static DoubleMatrix2D` | `pow(DoubleMatrix2D A, DoubleMatrix2D B)` Deprecated. `A = AB <=> A[row,col] = Math.pow(A[row,col], B[row,col])`.

    - ### Methods inherited from class cern.colt.PersistentObject

      `clone`

    - ### Methods inherited from class java.lang.Object

      `equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Field Detail

    - #### transform

          public static final Transform transform

      Deprecated.
      Little trick to allow for "aliasing", that is, renaming this class. Normally you would write

           Transform.mult(myMatrix,2);
           Transform.plus(myMatrix,5);

      Since this class has only static methods, but no instance methods you can also shorten the name "DoubleTransform" to a name that better suits you, for example "Trans".

           Transform T = Transform.transform; // kind of "alias"
           T.mult(myMatrix,2);
           T.plus(myMatrix,5);

  - ### Method Detail

    - #### abs

          public static DoubleMatrix1D abs(DoubleMatrix1D A)

      Deprecated.
      `A[i] = Math.abs(A[i])`.
      Parameters:
        `A` - the matrix to modify.
      Returns:
        `A` (for convenience only).

    - #### abs

          public static DoubleMatrix2D abs(DoubleMatrix2D A)

      Deprecated.
      `A[row,col] = Math.abs(A[row,col])`.
      Parameters:
        `A` - the matrix to modify.
      Returns:
        `A` (for convenience only).

    - #### div

          public static DoubleMatrix1D div(DoubleMatrix1D A,
                           double s)

      Deprecated.
      `A = A / s <=> A[i] = A[i] / s`.
      Parameters:
        `A` - the matrix to modify.
        `s` - the scalar; can have any value.
      Returns:
        `A` (for convenience only).

    - #### div

          public static DoubleMatrix1D div(DoubleMatrix1D A,
                           DoubleMatrix1D B)

      Deprecated.
      `A = A / B <=> A[i] = A[i] / B[i]`.
      Parameters:
        `A` - the matrix to modify.
        `B` - the matrix to stay unaffected.
      Returns:
        `A` (for convenience only).

    - #### div

          public static DoubleMatrix2D div(DoubleMatrix2D A,
                           double s)

      Deprecated.
      `A = A / s <=> A[row,col] = A[row,col] / s`.
      Parameters:
        `A` - the matrix to modify.
        `s` - the scalar; can have any value.
      Returns:
        `A` (for convenience only).

    - #### div

          public static DoubleMatrix2D div(DoubleMatrix2D A,
                           DoubleMatrix2D B)

      Deprecated.
      `A = A / B <=> A[row,col] = A[row,col] / B[row,col]`.
      Parameters:
        `A` - the matrix to modify.
        `B` - the matrix to stay unaffected.
      Returns:
        `A` (for convenience only).

    - #### equals

          public static DoubleMatrix2D equals(DoubleMatrix2D A,
                              double s)

      Deprecated.
      `A[row,col] = A[row,col] == s ? 1 : 0`; ignores tolerance.
      Parameters:
        `A` - the matrix to modify.
        `s` - the scalar; can have any value.
      Returns:
        `A` (for convenience only).

    - #### equals

          public static DoubleMatrix2D equals(DoubleMatrix2D A,
                              DoubleMatrix2D B)

      Deprecated.
      `A[row,col] = A[row,col] == B[row,col] ? 1 : 0`; ignores tolerance.
      Parameters:
        `A` - the matrix to modify.
        `B` - the matrix to stay unaffected.
      Returns:
        `A` (for convenience only).

    - #### greater

          public static DoubleMatrix2D greater(DoubleMatrix2D A,
                               double s)

      Deprecated.
      `A[row,col] = A[row,col] > s ? 1 : 0`.
      Parameters:
        `A` - the matrix to modify.
        `s` - the scalar; can have any value.
      Returns:
        `A` (for convenience only).

    - #### greater

          public static DoubleMatrix2D greater(DoubleMatrix2D A,
                               DoubleMatrix2D B)

      Deprecated.
      `A[row,col] = A[row,col] > B[row,col] ? 1 : 0`.
      Parameters:
        `A` - the matrix to modify.
        `B` - the matrix to stay unaffected.
      Returns:
        `A` (for convenience only).

    - #### less

          public static DoubleMatrix2D less(DoubleMatrix2D A,
                            double s)

      Deprecated.
      `A[row,col] = A[row,col] < s ? 1 : 0`.
      Parameters:
        `A` - the matrix to modify.
        `s` - the scalar; can have any value.
      Returns:
        `A` (for convenience only).

    - #### less

          public static DoubleMatrix2D less(DoubleMatrix2D A,
                            DoubleMatrix2D B)

      Deprecated.
      `A[row,col] = A[row,col] < B[row,col] ? 1 : 0`.
      Parameters:
        `A` - the matrix to modify.
        `B` - the matrix to stay unaffected.
      Returns:
        `A` (for convenience only).

    - #### minus

          public static DoubleMatrix1D minus(DoubleMatrix1D A,
                             double s)

      Deprecated.
      `A = A - s <=> A[i] = A[i] - s`.
      Parameters:
        `A` - the matrix to modify.
        `s` - the scalar; can have any value.
      Returns:
        `A` (for convenience only).

    - #### minus

          public static DoubleMatrix1D minus(DoubleMatrix1D A,
                             DoubleMatrix1D B)

      Deprecated.
      `A = A - B <=> A[i] = A[i] - B[i]`.
      Parameters:
        `A` - the matrix to modify.
        `B` - the matrix to stay unaffected.
      Returns:
        `A` (for convenience only).

    - #### minus

          public static DoubleMatrix2D minus(DoubleMatrix2D A,
                             double s)

      Deprecated.
      `A = A - s <=> A[row,col] = A[row,col] - s`.
      Parameters:
        `A` - the matrix to modify.
        `s` - the scalar; can have any value.
      Returns:
        `A` (for convenience only).

    - #### minus

          public static DoubleMatrix2D minus(DoubleMatrix2D A,
                             DoubleMatrix2D B)

      Deprecated.
      `A = A - B <=> A[row,col] = A[row,col] - B[row,col]`.
      Parameters:
        `A` - the matrix to modify.
        `B` - the matrix to stay unaffected.
      Returns:
        `A` (for convenience only).

    - #### minusMult

          public static DoubleMatrix1D minusMult(DoubleMatrix1D A,
                                 DoubleMatrix1D B,
                                 double s)

      Deprecated.
      `A = A - B*s <=> A[i] = A[i] - B[i]*s`.
      Parameters:
        `A` - the matrix to modify.
        `B` - the matrix to stay unaffected.
        `s` - the scalar; can have any value.
      Returns:
        `A` (for convenience only).

    - #### minusMult

          public static DoubleMatrix2D minusMult(DoubleMatrix2D A,
                                 DoubleMatrix2D B,
                                 double s)

      Deprecated.
      `A = A - B*s <=> A[row,col] = A[row,col] - B[row,col]*s`.
      Parameters:
        `A` - the matrix to modify.
        `B` - the matrix to stay unaffected.
        `s` - the scalar; can have any value.
      Returns:
        `A` (for convenience only).

    - #### mult

          public static DoubleMatrix1D mult(DoubleMatrix1D A,
                            double s)

      Deprecated.
      `A = A * s <=> A[i] = A[i] * s`.
      Parameters:
        `A` - the matrix to modify.
        `s` - the scalar; can have any value.
      Returns:
        `A` (for convenience only).

    - #### mult

          public static DoubleMatrix1D mult(DoubleMatrix1D A,
                            DoubleMatrix1D B)

      Deprecated.
      `A = A * B <=> A[i] = A[i] * B[i]`.
      Parameters:
        `A` - the matrix to modify.
        `B` - the matrix to stay unaffected.
      Returns:
        `A` (for convenience only).

    - #### mult

          public static DoubleMatrix2D mult(DoubleMatrix2D A,
                            double s)

      Deprecated.
      `A = A * s <=> A[row,col] = A[row,col] * s`.
      Parameters:
        `A` - the matrix to modify.
        `s` - the scalar; can have any value.
      Returns:
        `A` (for convenience only).

    - #### mult

          public static DoubleMatrix2D mult(DoubleMatrix2D A,
                            DoubleMatrix2D B)

      Deprecated.
      `A = A * B <=> A[row,col] = A[row,col] * B[row,col]`.
      Parameters:
        `A` - the matrix to modify.
        `B` - the matrix to stay unaffected.
      Returns:
        `A` (for convenience only).

    - #### negate

          public static DoubleMatrix1D negate(DoubleMatrix1D A)

      Deprecated.
      `A = -A <=> A[i] = -A[i]` for all cells.
      Returns:
        `A` (for convenience only).

    - #### negate

          public static DoubleMatrix2D negate(DoubleMatrix2D A)

      Deprecated.
      `A = -A <=> A[row,col] = -A[row,col]`.
      Returns:
        `A` (for convenience only).

    - #### plus

          public static DoubleMatrix1D plus(DoubleMatrix1D A,
                            double s)

      Deprecated.
      `A = A + s <=> A[i] = A[i] + s`.
      Parameters:
        `A` - the matrix to modify.
        `s` - the scalar; can have any value.
      Returns:
        `A` (for convenience only).

    - #### plus

          public static DoubleMatrix1D plus(DoubleMatrix1D A,
                            DoubleMatrix1D B)

      Deprecated.
      `A = A + B <=> A[i] = A[i] + B[i]`.
      Parameters:
        `A` - the matrix to modify.
        `B` - the matrix to stay unaffected.
      Returns:
        `A` (for convenience only).

    - #### plus

          public static DoubleMatrix2D plus(DoubleMatrix2D A,
                            double s)

      Deprecated.
      `A = A + s <=> A[row,col] = A[row,col] + s`.
      Parameters:
        `A` - the matrix to modify.
        `s` - the scalar; can have any value.
      Returns:
        `A` (for convenience only).

    - #### plus

          public static DoubleMatrix2D plus(DoubleMatrix2D A,
                            DoubleMatrix2D B)

      Deprecated.
      `A = A + B <=> A[row,col] = A[row,col] + B[row,col]`.
      Parameters:
        `A` - the matrix to modify.
        `B` - the matrix to stay unaffected.
      Returns:
        `A` (for convenience only).

    - #### plusMult

          public static DoubleMatrix1D plusMult(DoubleMatrix1D A,
                                DoubleMatrix1D B,
                                double s)

      Deprecated.
      `A = A + B*s<=> A[i] = A[i] + B[i]*s`.
      Parameters:
        `A` - the matrix to modify.
        `B` - the matrix to stay unaffected.
        `s` - the scalar; can have any value.
      Returns:
        `A` (for convenience only).

    - #### plusMult

          public static DoubleMatrix2D plusMult(DoubleMatrix2D A,
                                DoubleMatrix2D B,
                                double s)

      Deprecated.
      `A = A + B*s <=> A[row,col] = A[row,col] + B[row,col]*s`.
      Parameters:
        `A` - the matrix to modify.
        `B` - the matrix to stay unaffected.
        `s` - the scalar; can have any value.
      Returns:
        `A` (for convenience only).

    - #### pow

          public static DoubleMatrix1D pow(DoubleMatrix1D A,
                           double s)

      Deprecated.
      `A = As <=> A[i] = Math.pow(A[i], s)`.
      Parameters:
        `A` - the matrix to modify.
        `s` - the scalar; can have any value.
      Returns:
        `A` (for convenience only).

    - #### pow

          public static DoubleMatrix1D pow(DoubleMatrix1D A,
                           DoubleMatrix1D B)

      Deprecated.
      `A = AB <=> A[i] = Math.pow(A[i], B[i])`.
      Parameters:
        `A` - the matrix to modify.
        `B` - the matrix to stay unaffected.
      Returns:
        `A` (for convenience only).

    - #### pow

          public static DoubleMatrix2D pow(DoubleMatrix2D A,
                           double s)

      Deprecated.
      `A = As <=> A[row,col] = Math.pow(A[row,col], s)`.
      Parameters:
        `A` - the matrix to modify.
        `s` - the scalar; can have any value.
      Returns:
        `A` (for convenience only).

    - #### pow

          public static DoubleMatrix2D pow(DoubleMatrix2D A,
                           DoubleMatrix2D B)

      Deprecated.
      `A = AB <=> A[row,col] = Math.pow(A[row,col], B[row,col])`.
      Parameters:
        `A` - the matrix to modify.
        `B` - the matrix to stay unaffected.
      Returns:
        `A` (for convenience only).

Jump to the Colt Homepage