cern.colt.matrix

## Class DoubleFactory1D

- java.lang.Object
- - cern.colt.PersistentObject
  - - cern.colt.matrix.DoubleFactory1D

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

      public class DoubleFactory1D
      extends PersistentObject

  Factory for convenient construction of 1-d matrices holding `double` cells. Use idioms like `DoubleFactory1D.dense.make(1000)` to construct dense matrices, `DoubleFactory1D.sparse.make(1000)` to construct sparse matrices. If the factory is used frequently it might be useful to streamline the notation. For example by aliasing:

      DoubleFactory1D F = DoubleFactory1D.dense;
      F.make(1000);
      F.descending(10);
      F.random(3);
      ...

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

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `static DoubleFactory1D` | `dense` A factory producing dense matrices.
    `static DoubleFactory1D` | `sparse` A factory producing sparse matrices.

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

      `serialVersionUID`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `DoubleMatrix1D` | `append(DoubleMatrix1D A, DoubleMatrix1D B)` C = A||B; Constructs a new matrix which is the concatenation of two other matrices.
    `DoubleMatrix1D` | `ascending(int size)` Constructs a matrix with cells having ascending values.
    `DoubleMatrix1D` | `descending(int size)` Constructs a matrix with cells having descending values.
    `DoubleMatrix1D` | `make(AbstractDoubleList values)` Constructs a matrix from the values of the given list.
    `DoubleMatrix1D` | `make(double[] values)` Constructs a matrix with the given cell values.
    `DoubleMatrix1D` | `make(DoubleMatrix1D[] parts)` Constructs a matrix which is the concatenation of all given parts.
    `DoubleMatrix1D` | `make(int size)` Constructs a matrix with the given shape, each cell initialized with zero.
    `DoubleMatrix1D` | `make(int size, double initialValue)` Constructs a matrix with the given shape, each cell initialized with the given value.
    `DoubleMatrix1D` | `random(int size)` Constructs a matrix with uniformly distributed values in `(0,1)` (exclusive).
    `DoubleMatrix1D` | `repeat(DoubleMatrix1D A, int repeat)` C = A||A||..||A; Constructs a new matrix which is concatenated `repeat` times.
    `DoubleMatrix1D` | `sample(int size, double value, double nonZeroFraction)` Constructs a randomly sampled matrix with the given shape.
    `DoubleArrayList` | `toList(DoubleMatrix1D values)` Constructs a list from the given matrix.

    - ### 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

    - #### dense

          public static final DoubleFactory1D dense

      A factory producing dense matrices.

    - #### sparse

          public static final DoubleFactory1D sparse

      A factory producing sparse matrices.

  - ### Method Detail

    - #### append

          public DoubleMatrix1D append(DoubleMatrix1D A,
                              DoubleMatrix1D B)

      C = A||B; Constructs a new matrix which is the concatenation of two other matrices. Example: `0 1` append `3 4` --> `0 1 3 4`.

    - #### ascending

          public DoubleMatrix1D ascending(int size)

      Constructs a matrix with cells having ascending values. For debugging purposes. Example: `0 1 2`

    - #### descending

          public DoubleMatrix1D descending(int size)

      Constructs a matrix with cells having descending values. For debugging purposes. Example: `2 1 0`

    - #### make

          public DoubleMatrix1D make(double[] values)

      Constructs a matrix with the given cell values. The values are copied. So subsequent changes in `values` are not reflected in the matrix, and vice-versa.
      Parameters:
        `values` - The values to be filled into the new matrix.

    - #### make

          public DoubleMatrix1D make(DoubleMatrix1D[] parts)

      Constructs a matrix which is the concatenation of all given parts. Cells are copied.

    - #### make

          public DoubleMatrix1D make(int size)

      Constructs a matrix with the given shape, each cell initialized with zero.

    - #### make

          public DoubleMatrix1D make(int size,
                            double initialValue)

      Constructs a matrix with the given shape, each cell initialized with the given value.

    - #### make

          public DoubleMatrix1D make(AbstractDoubleList values)

      Constructs a matrix from the values of the given list. The values are copied. So subsequent changes in `values` are not reflected in the matrix, and vice-versa.
      Parameters:
        `values` - The values to be filled into the new matrix.
      Returns:
        a new matrix.

    - #### random

          public DoubleMatrix1D random(int size)

      Constructs a matrix with uniformly distributed values in `(0,1)` (exclusive).

    - #### repeat

          public DoubleMatrix1D repeat(DoubleMatrix1D A,
                              int repeat)

      C = A||A||..||A; Constructs a new matrix which is concatenated `repeat` times. Example:

          0 1
          repeat(3) -->
          0 1 0 1 0 1

    - #### sample

          public DoubleMatrix1D sample(int size,
                              double value,
                              double nonZeroFraction)

      Constructs a randomly sampled matrix with the given shape. Randomly picks exactly `Math.round(size*nonZeroFraction)` cells and initializes them to `value`, all the rest will be initialized to zero. Note that this is not the same as setting each cell with probability `nonZeroFraction` to `value`.
      Throws:
        `java.lang.IllegalArgumentException` - if `nonZeroFraction < 0 || nonZeroFraction > 1`.
      See Also:
        `RandomSampler`

    - #### toList

          public DoubleArrayList toList(DoubleMatrix1D values)

      Constructs a list from the given matrix. The values are copied. So subsequent changes in `values` are not reflected in the list, and vice-versa.
      Parameters:
        `values` - The values to be filled into the new list.
      Returns:
        a new list.

Jump to the Colt Homepage