RandomMatrices (Efficient Java Matrix Library 0.25 API)

java.lang.Object
- org.ejml.ops.RandomMatrices

```
public class RandomMatrices
extends Object
```
Contains a list of functions for creating random matrices and vectors with different structures.

Author:

Peter Abeles

Constructor Summary

Constructors
Constructor and Description

RandomMatrices()

Constructors
Constructor and Description
`RandomMatrices()`

Method Summary

Methods
Modifier and Type	Method and Description
`static void`	`addRandom(DenseMatrix64F A, double min, double max, Random rand)` Adds random values to each element in the matrix from an uniform distribution. a_ij = a_ij + U(min,max)
`static DenseMatrix64F`	`createDiagonal(int N, double min, double max, Random rand)` Creates a random diagonal matrix where the diagonal elements are selected from a uniform distribution that goes from min to max.
`static DenseMatrix64F`	`createDiagonal(int numRows, int numCols, double min, double max, Random rand)` Creates a random matrix where all elements are zero but diagonal elements.
`static DenseMatrix64F`	`createEigenvaluesSymm(int num, Random rand, double... eigenvalues)` Creates a new random symmetric matrix that will have the specified real eigenvalues.
`static DenseMatrix64F`	`createInSpan(DenseMatrix64F[] span, double min, double max, Random rand)` Creates a random vector that is inside the specified span.
`static DenseMatrix64F`	`createOrthogonal(int numRows, int numCols, Random rand)` Creates a random orthogonal or isometric matrix, depending on the number of rows and columns.
`static DenseMatrix64F`	`createRandom(int numRow, int numCol, double min, double max, Random rand)` Returns a matrix where all the elements are selected independently from a uniform distribution between 'min' and 'max' inclusive.
`static DenseMatrix64F`	`createRandom(int numRow, int numCol, Random rand)` Returns a matrix where all the elements are selected independently from a uniform distribution between 0 and 1 inclusive.
`static DenseMatrix64F`	`createSingularValues(int numRows, int numCols, Random rand, double... sv)` Creates a random matrix which will have the provided singular values.
`static DenseMatrix64F[]`	`createSpan(int dimen, int numVectors, Random rand)` Creates a randomly generated set of orthonormal vectors.
`static void`	`createSymmetric(DenseMatrix64F A, double min, double max, Random rand)` Sets the provided square matrix to be a random symmetric matrix whose values are selected from an uniform distribution from min to max, inclusive.
`static DenseMatrix64F`	`createSymmetric(int length, double min, double max, Random rand)` Creates a random symmetric matrix whose values are selected from an uniform distribution from min to max, inclusive.
`static DenseMatrix64F`	`createSymmPosDef(int width, Random rand)` Creates a random symmetric positive definite matrix.
`static DenseMatrix64F`	`createUpperTriangle(int dimen, int hessenberg, double min, double max, Random rand)` Creates an upper triangular matrix whose values are selected from a uniform distribution.
`static void`	`setRandom(D1Matrix64F mat, double min, double max, Random rand)` Sets each element in the matrix to a value drawn from an uniform distribution from 'min' to 'max' inclusive.
`static void`	`setRandom(DenseMatrix64F mat, Random rand)` Sets each element in the matrix to a value drawn from an uniform distribution from 0 to 1 inclusive.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - RandomMatrices
```
public RandomMatrices()
```
- Method Detail
  - createSpan
```
public static DenseMatrix64F[] createSpan(int dimen,
                          int numVectors,
                          Random rand)
```
    Creates a randomly generated set of orthonormal vectors. At most it can generate the same number of vectors as the dimension of the vectors.
    
    This is done by creating random vectors then ensuring that they are orthogonal to all the ones previously created with reflectors.
    
    NOTE: This employs a brute force O(N³) algorithm.
    
    Parameters:
    dimen - dimension of the space which the vectors will span.
    numVectors - How many vectors it should generate.
    rand - Used to create random vectors.
    
    Returns:
    Array of N random orthogonal vectors of unit length.
  - createInSpan
```
public static DenseMatrix64F createInSpan(DenseMatrix64F[] span,
                          double min,
                          double max,
                          Random rand)
```
    Creates a random vector that is inside the specified span.
    
    Parameters:
    span - The span the random vector belongs in.
    rand - RNG
    
    Returns:
    A random vector within the specified span.
  - createOrthogonal
```
public static DenseMatrix64F createOrthogonal(int numRows,
                              int numCols,
                              Random rand)
```
    Creates a random orthogonal or isometric matrix, depending on the number of rows and columns. The number of rows must be more than or equal to the number of columns.
    
    Parameters:
    numRows - Number of rows in the generated matrix.
    numCols - Number of columns in the generated matrix.
    rand - Random number generator used to create matrices.
    
    Returns:
    A new isometric matrix.
  - createDiagonal
```
public static DenseMatrix64F createDiagonal(int N,
                            double min,
                            double max,
                            Random rand)
```
    Creates a random diagonal matrix where the diagonal elements are selected from a uniform distribution that goes from min to max.
    
    Parameters:
    N - Dimension of the matrix.
    min - Minimum value of a diagonal element.
    max - Maximum value of a diagonal element.
    rand - Random number generator.
    
    Returns:
    A random diagonal matrix.
  - createDiagonal
```
public static DenseMatrix64F createDiagonal(int numRows,
                            int numCols,
                            double min,
                            double max,
                            Random rand)
```
    Creates a random matrix where all elements are zero but diagonal elements. Diagonal elements randomly drawn from a uniform distribution from min to max, inclusive.
    
    Parameters:
    numRows - Number of rows in the returned matrix..
    numCols - Number of columns in the returned matrix.
    min - Minimum value of a diagonal element.
    max - Maximum value of a diagonal element.
    rand - Random number generator.
    
    Returns:
    A random diagonal matrix.
  - createSingularValues
```
public static DenseMatrix64F createSingularValues(int numRows,
                                  int numCols,
                                  Random rand,
                                  double... sv)
```
    Creates a random matrix which will have the provided singular values. The length of sv is assumed to be the rank of the matrix. This can be useful for testing purposes when one needs to ensure that a matrix is not singular but randomly generated.
    
    Parameters:
    numRows - Number of rows in generated matrix.
    numCols - NUmber of columns in generated matrix.
    rand - Random number generator.
    sv - Singular values of the matrix.
    
    Returns:
    A new matrix with the specified singular values.
  - createEigenvaluesSymm
```
public static DenseMatrix64F createEigenvaluesSymm(int num,
                                   Random rand,
                                   double... eigenvalues)
```
    Creates a new random symmetric matrix that will have the specified real eigenvalues.
    
    Parameters:
    num - Dimension of the resulting matrix.
    rand - Random number generator.
    eigenvalues - Set of real eigenvalues that the matrix will have.
    
    Returns:
    A random matrix with the specified eigenvalues.
  - createRandom
```
public static DenseMatrix64F createRandom(int numRow,
                          int numCol,
                          Random rand)
```
    Returns a matrix where all the elements are selected independently from a uniform distribution between 0 and 1 inclusive.
    
    Parameters:
    numRow - Number of rows in the new matrix.
    numCol - Number of columns in the new matrix.
    rand - Random number generator used to fill the matrix.
    
    Returns:
    The randomly generated matrix.
  - addRandom
```
public static void addRandom(DenseMatrix64F A,
             double min,
             double max,
             Random rand)
```
    Adds random values to each element in the matrix from an uniform distribution.
    
    a_ij = a_ij + U(min,max)
    
    Parameters:
    A - The matrix who is to be randomized. Modified
    min - The minimum value each element can be.
    max - The maximum value each element can be..
    rand - Random number generator used to fill the matrix.
  - createRandom
```
public static DenseMatrix64F createRandom(int numRow,
                          int numCol,
                          double min,
                          double max,
                          Random rand)
```
    Returns a matrix where all the elements are selected independently from a uniform distribution between 'min' and 'max' inclusive.
    
    Parameters:
    numRow - Number of rows in the new matrix.
    numCol - Number of columns in the new matrix.
    min - The minimum value each element can be.
    max - The maximum value each element can be.
    rand - Random number generator used to fill the matrix.
    
    Returns:
    The randomly generated matrix.
  - setRandom
```
public static void setRandom(DenseMatrix64F mat,
             Random rand)
```
    Sets each element in the matrix to a value drawn from an uniform distribution from 0 to 1 inclusive.
    
    Parameters:
    mat - The matrix who is to be randomized. Modified.
    rand - Random number generator used to fill the matrix.
  - setRandom
```
public static void setRandom(D1Matrix64F mat,
             double min,
             double max,
             Random rand)
```
    Sets each element in the matrix to a value drawn from an uniform distribution from 'min' to 'max' inclusive.
    
    Parameters:
    min - The minimum value each element can be.
    max - The maximum value each element can be.
    mat - The matrix who is to be randomized. Modified.
    rand - Random number generator used to fill the matrix.
  - createSymmPosDef
```
public static DenseMatrix64F createSymmPosDef(int width,
                              Random rand)
```
    Creates a random symmetric positive definite matrix.
    
    Parameters:
    width - The width of the square matrix it returns.
    rand - Random number generator used to make the matrix.
    
    Returns:
    The random symmetric positive definite matrix.
  - createSymmetric
```
public static DenseMatrix64F createSymmetric(int length,
                             double min,
                             double max,
                             Random rand)
```
    Creates a random symmetric matrix whose values are selected from an uniform distribution from min to max, inclusive.
    
    Parameters:
    length - Width and height of the matrix.
    min - Minimum value an element can have.
    max - Maximum value an element can have.
    rand - Random number generator.
    
    Returns:
    A symmetric matrix.
  - createSymmetric
```
public static void createSymmetric(DenseMatrix64F A,
                   double min,
                   double max,
                   Random rand)
```
    Sets the provided square matrix to be a random symmetric matrix whose values are selected from an uniform distribution from min to max, inclusive.
    
    Parameters:
    A - The matrix that is to be modified. Must be square. Modified.
    min - Minimum value an element can have.
    max - Maximum value an element can have.
    rand - Random number generator.
  - createUpperTriangle
```
public static DenseMatrix64F createUpperTriangle(int dimen,
                                 int hessenberg,
                                 double min,
                                 double max,
                                 Random rand)
```
    Creates an upper triangular matrix whose values are selected from a uniform distribution. If hessenberg is greater than zero then a hessenberg matrix of the specified degree is created instead.
    
    Parameters:
    dimen - Number of rows and columns in the matrix..
    hessenberg - 0 for triangular matrix and > 0 for hessenberg matrix.
    min - minimum value an element can be.
    max - maximum value an element can be.
    rand - random number generator used.
    
    Returns:
    The randomly generated matrix.

Class RandomMatrices

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

RandomMatrices

Method Detail

createSpan

createInSpan

createOrthogonal

createDiagonal

createDiagonal

createSingularValues

createEigenvaluesSymm

createRandom

addRandom

createRandom

setRandom

setRandom

createSymmPosDef

createSymmetric

createSymmetric

createUpperTriangle