C# Class Accord.Math.Matrix

Mostrar archivo Open project: accord-net/framework Class Usage Examples

Public Methods

Method Description
Decompose ( this matrix, bool leastSquares = false ) : ISolverArrayDecomposition

Creates a matrix decomposition that be used to compute the solution matrix if the matrix is square or the least squares solution otherwise.
Decompose ( this matrix, bool leastSquares = false ) : ISolverArrayDecomposition

Creates a matrix decomposition that be used to compute the solution matrix if the matrix is square or the least squares solution otherwise.
Decompose ( this matrix, bool leastSquares = false ) : ISolverArrayDecomposition

Creates a matrix decomposition that be used to compute the solution matrix if the matrix is square or the least squares solution otherwise.
Decompose ( this matrix, bool leastSquares = false ) : ISolverMatrixDecomposition

Creates a matrix decomposition that be used to compute the solution matrix if the matrix is square or the least squares solution otherwise.
Decompose ( this matrix, bool leastSquares = false ) : ISolverMatrixDecomposition

Creates a matrix decomposition that be used to compute the solution matrix if the matrix is square or the least squares solution otherwise.
Decompose ( this matrix, bool leastSquares = false ) : ISolverMatrixDecomposition

Creates a matrix decomposition that be used to compute the solution matrix if the matrix is square or the least squares solution otherwise.
Divide ( this a, decimal b, bool leastSquares = false ) : ].decimal[

Divides two matrices by multiplying A by the inverse of B.
Divide ( this a, decimal b, bool leastSquares = false ) : decimal[][]

Divides two matrices by multiplying A by the inverse of B.
Divide ( this a, double b, bool leastSquares = false ) : ].double[

Divides two matrices by multiplying A by the inverse of B.
Divide ( this a, double b, bool leastSquares = false ) : double[][]

Divides two matrices by multiplying A by the inverse of B.
Divide ( this a, float b, bool leastSquares = false ) : ].float[

Divides two matrices by multiplying A by the inverse of B.
Divide ( this a, float b, bool leastSquares = false ) : float[][]

Divides two matrices by multiplying A by the inverse of B.
ElementwiseMultiply ( double a, double b ) : ].double[

Elementwise multiply operation.
Inverse ( this matrix ) : ].decimal[

Computes the inverse of a matrix.
Inverse ( this matrix, bool inPlace ) : ].decimal[

Computes the inverse of a matrix.
Inverse ( this matrix ) : decimal[][]

Computes the inverse of a matrix.
Inverse ( this matrix, bool inPlace ) : decimal[][]

Computes the inverse of a matrix.
Inverse ( this matrix ) : ].double[

Computes the inverse of a matrix.
Inverse ( this matrix, bool inPlace ) : ].double[

Computes the inverse of a matrix.
Inverse ( this matrix ) : double[][]

Computes the inverse of a matrix.
Inverse ( this matrix, bool inPlace ) : double[][]

Computes the inverse of a matrix.
Inverse ( this matrix ) : ].float[

Computes the inverse of a matrix.
Inverse ( this matrix, bool inPlace ) : ].float[

Computes the inverse of a matrix.
Inverse ( this matrix ) : float[][]

Computes the inverse of a matrix.
Inverse ( this matrix, bool inPlace ) : float[][]

Computes the inverse of a matrix.
PseudoInverse ( this matrix ) : ].decimal[

Computes the pseudo-inverse of a matrix.
PseudoInverse ( this matrix ) : decimal[][]

Computes the pseudo-inverse of a matrix.
PseudoInverse ( this matrix ) : ].double[

Computes the pseudo-inverse of a matrix.
PseudoInverse ( this matrix ) : double[][]

Computes the pseudo-inverse of a matrix.
PseudoInverse ( this matrix ) : ].float[

Computes the pseudo-inverse of a matrix.
PseudoInverse ( this matrix ) : float[][]

Computes the pseudo-inverse of a matrix.
Random ( int size, byte min, byte max, bool symmetric = false, byte result = null ) : ].byte[

Creates a matrix with uniformly distributed random data.
Random ( int rows, int columns, byte min, byte max, byte result = null ) : ].byte[

Creates a matrix with uniformly distributed random data.
Random ( int size, decimal min, decimal max, bool symmetric = false, decimal result = null ) : ].decimal[

Creates a matrix with uniformly distributed random data.
Random ( int rows, int columns, decimal min, decimal max, decimal result = null ) : ].decimal[

Creates a matrix with uniformly distributed random data.
Random ( int size ) : ].double[

Creates a matrix with uniformly distributed random data.
Random ( int size, double min, double max, bool symmetric = false, double result = null ) : ].double[

Creates a matrix with uniformly distributed random data.
Random ( int rows, int columns ) : ].double[

Creates a matrix with uniformly distributed random data.
Random ( int rows, int columns, double min, double max, double result = null ) : ].double[

Creates a matrix with uniformly distributed random data.
Random ( int size, float min, float max, bool symmetric = false, float result = null ) : ].float[

Creates a matrix with uniformly distributed random data.
Random ( int rows, int columns, float min, float max, float result = null ) : ].float[

Creates a matrix with uniformly distributed random data.
Random ( int size, int min, int max, bool symmetric = false, int result = null ) : ].int[

Creates a matrix with uniformly distributed random data.
Random ( int rows, int columns, int min, int max, int result = null ) : ].int[

Creates a matrix with uniformly distributed random data.
Random ( int rows, int columns, long min, long max, long result = null ) : ].long[

Creates a matrix with uniformly distributed random data.
Random ( int size, long min, long max, bool symmetric = false, long result = null ) : ].long[

Creates a matrix with uniformly distributed random data.
Random ( int rows, int columns, sbyte min, sbyte max, sbyte result = null ) : ].sbyte[

Creates a matrix with uniformly distributed random data.
Random ( int size, sbyte min, sbyte max, bool symmetric = false, sbyte result = null ) : ].sbyte[

Creates a matrix with uniformly distributed random data.
Random ( int rows, int columns, short min, short max, short result = null ) : ].short[

Creates a matrix with uniformly distributed random data.
Random ( int size, short min, short max, bool symmetric = false, short result = null ) : ].short[

Creates a matrix with uniformly distributed random data.
Random ( int rows, int columns, ulong min, ulong max, ulong result = null ) : ].ulong[

Creates a matrix with uniformly distributed random data.
Random ( int size, ulong min, ulong max, bool symmetric = false, ulong result = null ) : ].ulong[

Creates a matrix with uniformly distributed random data.
Random ( int rows, int columns, ushort min, ushort max, ushort result = null ) : ].ushort[

Creates a matrix with uniformly distributed random data.
Random ( int size, ushort min, ushort max, bool symmetric = false, ushort result = null ) : ].ushort[

Creates a matrix with uniformly distributed random data.
Solve ( this matrix, decimal rightSide, bool leastSquares = false ) : ].decimal[

Returns the solution matrix if the matrix is square or the least squares solution otherwise.

Please note that this does not check if the matrix is non-singular before attempting to solve. If a least squares solution is desired in case the matrix is singular, pass true to the leastSquares parameter when calling this function.

Solve ( this matrix, decimal rightSide, bool leastSquares = false ) : decimal[]

Returns the solution matrix if the matrix is square or the least squares solution otherwise.

Please note that this does not check if the matrix is non-singular before attempting to solve. If a least squares solution is desired in case the matrix is singular, pass true to the leastSquares parameter when calling this function.

Solve ( this matrix, decimal rightSide, bool leastSquares = false ) : decimal[][]

Returns the solution matrix if the matrix is square or the least squares solution otherwise.

Please note that this does not check if the matrix is non-singular before attempting to solve. If a least squares solution is desired in case the matrix is singular, pass true to the leastSquares parameter when calling this function.

Solve ( this matrix, double rightSide, bool leastSquares = false ) : ].double[

Returns the solution matrix if the matrix is square or the least squares solution otherwise.

Please note that this does not check if the matrix is non-singular before attempting to solve. If a least squares solution is desired in case the matrix is singular, pass true to the leastSquares parameter when calling this function.

Solve ( this matrix, double rightSide, bool leastSquares = false ) : double[]

Returns the solution matrix if the matrix is square or the least squares solution otherwise.

Please note that this does not check if the matrix is non-singular before attempting to solve. If a least squares solution is desired in case the matrix is singular, pass true to the leastSquares parameter when calling this function.

Solve ( this matrix, double rightSide, bool leastSquares = false ) : double[][]

Returns the solution matrix if the matrix is square or the least squares solution otherwise.

Please note that this does not check if the matrix is non-singular before attempting to solve. If a least squares solution is desired in case the matrix is singular, pass true to the leastSquares parameter when calling this function.

Solve ( this matrix, float rightSide, bool leastSquares = false ) : ].float[

Returns the solution matrix if the matrix is square or the least squares solution otherwise.

Please note that this does not check if the matrix is non-singular before attempting to solve. If a least squares solution is desired in case the matrix is singular, pass true to the leastSquares parameter when calling this function.

Solve ( this matrix, float rightSide, bool leastSquares = false ) : float[]

Returns the solution matrix if the matrix is square or the least squares solution otherwise.

Please note that this does not check if the matrix is non-singular before attempting to solve. If a least squares solution is desired in case the matrix is singular, pass true to the leastSquares parameter when calling this function.

Solve ( this matrix, float rightSide, bool leastSquares = false ) : float[][]

Returns the solution matrix if the matrix is square or the least squares solution otherwise.

Please note that this does not check if the matrix is non-singular before attempting to solve. If a least squares solution is desired in case the matrix is singular, pass true to the leastSquares parameter when calling this function.

Private Methods

Method Description
Abs ( double value ) : ].double[
Abs ( double value ) : double[]
Abs ( int value ) : ].int[
Abs ( int value ) : int[]
CumulativeSum ( this matrix, int dimension ) : ].decimal[
CumulativeSum ( this matrix, int dimension, decimal result ) : ].decimal[
CumulativeSum ( this vector ) : decimal[]
CumulativeSum ( this vector, decimal result ) : decimal[]
CumulativeSum ( this matrix, int dimension ) : decimal[][]
CumulativeSum ( this matrix, int dimension, decimal result ) : decimal[][]
CumulativeSum ( this matrix, int dimension ) : ].double[
CumulativeSum ( this matrix, int dimension, double result ) : ].double[
CumulativeSum ( this vector ) : double[]
CumulativeSum ( this vector, double result ) : double[]
CumulativeSum ( this matrix, int dimension ) : double[][]
CumulativeSum ( this matrix, int dimension, double result ) : double[][]
CumulativeSum ( this matrix, int dimension ) : ].float[
CumulativeSum ( this matrix, int dimension, float result ) : ].float[
CumulativeSum ( this vector ) : float[]
CumulativeSum ( this vector, float result ) : float[]
CumulativeSum ( this matrix, int dimension ) : float[][]
CumulativeSum ( this matrix, int dimension, float result ) : float[][]
CumulativeSum ( this matrix, int dimension ) : ].int[
CumulativeSum ( this matrix, int dimension, int result ) : ].int[
CumulativeSum ( this vector ) : int[]
CumulativeSum ( this vector, int result ) : int[]
CumulativeSum ( this matrix, int dimension ) : int[][]
CumulativeSum ( this matrix, int dimension, int result ) : int[][]
CumulativeSum ( this matrix, int dimension ) : ].long[
CumulativeSum ( this matrix, int dimension, long result ) : ].long[
CumulativeSum ( this vector ) : long[]
CumulativeSum ( this vector, long result ) : long[]
CumulativeSum ( this matrix, int dimension ) : long[][]
CumulativeSum ( this matrix, int dimension, long result ) : long[][]
CumulativeSum ( this matrix, int dimension ) : ].short[
CumulativeSum ( this matrix, int dimension, short result ) : ].short[
CumulativeSum ( this vector ) : short[]
CumulativeSum ( this vector, short result ) : short[]
CumulativeSum ( this matrix, int dimension ) : short[][]
CumulativeSum ( this matrix, int dimension, short result ) : short[][]
ElementwiseDivide ( double a, double b, int dimension, bool inPlace = false ) : ].double[
ElementwiseDivide ( int a, int b, int dimension ) : ].double[
ElementwiseDivide ( this a, double b ) : ].double[
ElementwiseDivide ( double a, double b ) : double[]
ElementwiseDivide ( float a, float b ) : ].float[
ElementwiseMultiply ( double a, double b, double r, int dimension ) : ].double[
ElementwiseMultiply ( double a, double b, int dimension ) : ].double[
ElementwiseMultiply ( double a, double b ) : double[]
ElementwiseMultiply ( double a, int b ) : double[]
ElementwiseMultiply ( int a, int b ) : ].int[
ElementwiseMultiply ( int a, int b ) : int[]
ElementwisePower ( double x, double y ) : ].double[
ElementwisePower ( double x, double y ) : double[]
Exp ( double value ) : ].double[
Exp ( double value ) : double[]
IsEqual ( this a, Byte b, Byte atol, Double rtol ) : bool
IsEqual ( this a, Byte b, Decimal atol, Decimal rtol ) : bool
IsEqual ( this a, Byte b, Double atol, Double rtol ) : bool
IsEqual ( this a, Byte b, Int16 atol, Double rtol ) : bool
IsEqual ( this a, Byte b, Int32 atol, Double rtol ) : bool
IsEqual ( this a, Byte b, System.Int64 atol, Double rtol ) : bool
IsEqual ( this a, Byte b, System.Single atol, Double rtol ) : bool
IsEqual ( this a, Decimal b, Decimal atol, Decimal rtol ) : bool
IsEqual ( this a, Double b, Decimal atol, Decimal rtol ) : bool
IsEqual ( this a, Double b, Double atol, Double rtol ) : bool
IsEqual ( this a, Int16 b, Decimal atol, Decimal rtol ) : bool
IsEqual ( this a, Int16 b, Double atol, Double rtol ) : bool
IsEqual ( this a, Int16 b, Int16 atol, Double rtol ) : bool
IsEqual ( this a, Int16 b, Int32 atol, Double rtol ) : bool
IsEqual ( this a, Int16 b, System.Int64 atol, Double rtol ) : bool
IsEqual ( this a, Int16 b, System.Single atol, Double rtol ) : bool
IsEqual ( this a, Int32 b, Decimal atol, Decimal rtol ) : bool
IsEqual ( this a, Int32 b, Double atol, Double rtol ) : bool
IsEqual ( this a, Int32 b, Int32 atol, Double rtol ) : bool
IsEqual ( this a, Int32 b, System.Int64 atol, Double rtol ) : bool
IsEqual ( this a, Int32 b, System.Single atol, Double rtol ) : bool
IsEqual ( this a, System.Int64 b, Decimal atol, Decimal rtol ) : bool
IsEqual ( this a, System.Int64 b, Double atol, Double rtol ) : bool
IsEqual ( this a, System.Int64 b, System.Int64 atol, Double rtol ) : bool
IsEqual ( this a, System.Int64 b, System.Single atol, Double rtol ) : bool
IsEqual ( this a, System.Single b, Decimal atol, Decimal rtol ) : bool
IsEqual ( this a, System.Single b, Double atol, Double rtol ) : bool
IsEqual ( this a, System.Single b, System.Single atol, Double rtol ) : bool
IsEqual ( this a, sbyte b, Byte atol, Double rtol ) : bool
IsEqual ( this a, sbyte b, Decimal atol, Decimal rtol ) : bool
IsEqual ( this a, sbyte b, Double atol, Double rtol ) : bool
IsEqual ( this a, sbyte b, Int16 atol, Double rtol ) : bool
IsEqual ( this a, sbyte b, Int32 atol, Double rtol ) : bool
IsEqual ( this a, sbyte b, System.Int64 atol, Double rtol ) : bool
IsEqual ( this a, sbyte b, System.Single atol, Double rtol ) : bool
IsEqual ( this a, sbyte b, byte atol, Double rtol ) : bool
Log ( double value ) : ].double[
Log ( double value ) : double[]
Log ( int value ) : double[]
Product ( this vector ) : decimal
Product ( this matrix, int dimension ) : decimal[]
Product ( this matrix, int dimension, decimal result ) : decimal[]
Product ( this vector ) : double
Product ( this matrix, int dimension ) : double[]
Product ( this matrix, int dimension, double result ) : double[]
Product ( this vector ) : float
Product ( this matrix, int dimension ) : float[]
Product ( this matrix, int dimension, float result ) : float[]
Product ( this vector ) : int
Product ( this matrix, int dimension ) : int[]
Product ( this matrix, int dimension, int result ) : int[]
Product ( this vector ) : long
Product ( this matrix, int dimension ) : long[]
Product ( this matrix, int dimension, long result ) : long[]
Product ( this vector ) : short
Product ( this matrix, int dimension ) : short[]
Product ( this matrix, int dimension, short result ) : short[]
Sign ( double value ) : double[]
Sqrt ( double value ) : ].double[
Sqrt ( double value ) : double[]
Sum ( this vector ) : decimal
Sum ( this matrix, int dimension ) : decimal[]
Sum ( this matrix, int dimension, decimal result ) : decimal[]
Sum ( this vector ) : double
Sum ( this matrix, int dimension ) : double[]
Sum ( this matrix, int dimension, double result ) : double[]
Sum ( this vector ) : float
Sum ( this matrix, int dimension ) : float[]
Sum ( this matrix, int dimension, float result ) : float[]
Sum ( this vector ) : int
Sum ( this matrix, int dimension ) : int[]
Sum ( this matrix, int dimension, int result ) : int[]
Sum ( this vector ) : long
Sum ( this matrix, int dimension ) : long[]
Sum ( this matrix, int dimension, long result ) : long[]
Sum ( this vector ) : short
Sum ( this matrix, int dimension ) : short[]
Sum ( this matrix, int dimension, short result ) : short[]
ToBoolean ( this value ) : ].bool[
ToBoolean ( this value, bool result ) : ].bool[
ToBoolean ( this value ) : bool[]
ToBoolean ( this value, bool result ) : bool[]
ToBoolean ( this value ) : bool[][]
ToBoolean ( this value, bool result ) : bool[][]
ToBoolean ( this value ) : bool[][][]
ToBoolean ( this value, bool result ) : bool[][][]
ToByte ( this value ) : ].byte[
ToByte ( this value, byte result ) : ].byte[
ToByte ( this value ) : byte[]
ToByte ( this value, byte result ) : byte[]
ToByte ( this value ) : byte[][]
ToByte ( this value, byte result ) : byte[][]
ToByte ( this value ) : byte[][][]
ToByte ( this value, byte result ) : byte[][][]
ToDecimal ( this value ) : ].decimal[
ToDecimal ( this value, decimal result ) : ].decimal[
ToDecimal ( this value ) : decimal[]
ToDecimal ( this value, decimal result ) : decimal[]
ToDecimal ( this value ) : decimal[][]
ToDecimal ( this value, decimal result ) : decimal[][]
ToDecimal ( this value ) : decimal[][][]
ToDecimal ( this value, decimal result ) : decimal[][][]
ToDouble ( this value ) : ].double[
ToDouble ( this value, double result ) : ].double[
ToDouble ( this value ) : double[]
ToDouble ( this value, double result ) : double[]
ToDouble ( this value ) : double[][]
ToDouble ( this value, double result ) : double[][]
ToDouble ( this value ) : double[][][]
ToDouble ( this value, double result ) : double[][][]
ToInt16 ( this value ) : ].short[
ToInt16 ( this value, short result ) : ].short[
ToInt16 ( this value ) : short[]
ToInt16 ( this value, short result ) : short[]
ToInt16 ( this value ) : short[][]
ToInt16 ( this value, short result ) : short[][]
ToInt16 ( this value ) : short[][][]
ToInt16 ( this value, short result ) : short[][][]
ToInt32 ( this value ) : ].int[
ToInt32 ( this value, int result ) : ].int[
ToInt32 ( this value ) : int[]
ToInt32 ( this value, int result ) : int[]
ToInt32 ( this value ) : int[][]
ToInt32 ( this value, int result ) : int[][]
ToInt32 ( this value ) : int[][][]
ToInt32 ( this value, int result ) : int[][][]
ToInt64 ( this value ) : ].long[
ToInt64 ( this value, long result ) : ].long[
ToInt64 ( this value ) : long[]
ToInt64 ( this value, long result ) : long[]
ToInt64 ( this value ) : long[][]
ToInt64 ( this value, long result ) : long[][]
ToInt64 ( this value ) : long[][][]
ToInt64 ( this value, long result ) : long[][][]
ToSByte ( this value ) : ].sbyte[
ToSByte ( this value, sbyte result ) : ].sbyte[
ToSByte ( this value ) : sbyte[]
ToSByte ( this value, sbyte result ) : sbyte[]
ToSByte ( this value ) : sbyte[][]
ToSByte ( this value, sbyte result ) : sbyte[][]
ToSByte ( this value ) : sbyte[][][]
ToSByte ( this value, sbyte result ) : sbyte[][][]
ToSingle ( this value ) : ].float[
ToSingle ( this value, float result ) : ].float[
ToSingle ( this value ) : float[]
ToSingle ( this value, float result ) : float[]
ToSingle ( this value ) : float[][]
ToSingle ( this value, float result ) : float[][]
ToSingle ( this value ) : float[][][]
ToSingle ( this value, float result ) : float[][][]

Method Details

Decompose() public static method

Creates a matrix decomposition that be used to compute the solution matrix if the matrix is square or the least squares solution otherwise.
public static Decompose ( this matrix, bool leastSquares = false ) : ISolverArrayDecomposition
matrix this
leastSquares bool
return ISolverArrayDecomposition

Decompose() public static method

Creates a matrix decomposition that be used to compute the solution matrix if the matrix is square or the least squares solution otherwise.
public static Decompose ( this matrix, bool leastSquares = false ) : ISolverArrayDecomposition
matrix this
leastSquares bool
return ISolverArrayDecomposition

Decompose() public static method

Creates a matrix decomposition that be used to compute the solution matrix if the matrix is square or the least squares solution otherwise.
public static Decompose ( this matrix, bool leastSquares = false ) : ISolverArrayDecomposition
matrix this
leastSquares bool
return ISolverArrayDecomposition

Decompose() public static method

Creates a matrix decomposition that be used to compute the solution matrix if the matrix is square or the least squares solution otherwise.
public static Decompose ( this matrix, bool leastSquares = false ) : ISolverMatrixDecomposition
matrix this
leastSquares bool
return ISolverMatrixDecomposition

Decompose() public static method

Creates a matrix decomposition that be used to compute the solution matrix if the matrix is square or the least squares solution otherwise.
public static Decompose ( this matrix, bool leastSquares = false ) : ISolverMatrixDecomposition
matrix this
leastSquares bool
return ISolverMatrixDecomposition

Decompose() public static method

Creates a matrix decomposition that be used to compute the solution matrix if the matrix is square or the least squares solution otherwise.
public static Decompose ( this matrix, bool leastSquares = false ) : ISolverMatrixDecomposition
matrix this
leastSquares bool
return ISolverMatrixDecomposition

Divide() public static method

Divides two matrices by multiplying A by the inverse of B.
public static Divide ( this a, decimal b, bool leastSquares = false ) : ].decimal[
a this The first matrix.
b decimal The second matrix (which will be inverted).
leastSquares bool True to produce a solution even if the /// is singular; false otherwise. Default is false.
return ].decimal[

Divide() public static method

Divides two matrices by multiplying A by the inverse of B.
public static Divide ( this a, decimal b, bool leastSquares = false ) : decimal[][]
a this The first matrix.
b decimal The second matrix (which will be inverted).
leastSquares bool True to produce a solution even if the /// is singular; false otherwise. Default is false.
return decimal[][]

Divide() public static method

Divides two matrices by multiplying A by the inverse of B.
public static Divide ( this a, double b, bool leastSquares = false ) : ].double[
a this The first matrix.
b double The second matrix (which will be inverted).
leastSquares bool True to produce a solution even if the /// is singular; false otherwise. Default is false.
return ].double[

Divide() public static method

Divides two matrices by multiplying A by the inverse of B.
public static Divide ( this a, double b, bool leastSquares = false ) : double[][]
a this The first matrix.
b double The second matrix (which will be inverted).
leastSquares bool True to produce a solution even if the /// is singular; false otherwise. Default is false.
return double[][]

Divide() public static method

Divides two matrices by multiplying A by the inverse of B.
public static Divide ( this a, float b, bool leastSquares = false ) : ].float[
a this The first matrix.
b float The second matrix (which will be inverted).
leastSquares bool True to produce a solution even if the /// is singular; false otherwise. Default is false.
return ].float[

Divide() public static method

Divides two matrices by multiplying A by the inverse of B.
public static Divide ( this a, float b, bool leastSquares = false ) : float[][]
a this The first matrix.
b float The second matrix (which will be inverted).
leastSquares bool True to produce a solution even if the /// is singular; false otherwise. Default is false.
return float[][]

ElementwiseMultiply() public static method

Elementwise multiply operation.
public static ElementwiseMultiply ( double a, double b ) : ].double[
a double
b double
return ].double[

Inverse() public static method

Computes the inverse of a matrix.
public static Inverse ( this matrix ) : ].decimal[
matrix this
return ].decimal[

Inverse() public static method

Computes the inverse of a matrix.
public static Inverse ( this matrix, bool inPlace ) : ].decimal[
matrix this
inPlace bool
return ].decimal[

Inverse() public static method

Computes the inverse of a matrix.
public static Inverse ( this matrix ) : decimal[][]
matrix this
return decimal[][]

Inverse() public static method

Computes the inverse of a matrix.
public static Inverse ( this matrix, bool inPlace ) : decimal[][]
matrix this
inPlace bool
return decimal[][]

Inverse() public static method

Computes the inverse of a matrix.
public static Inverse ( this matrix ) : ].double[
matrix this
return ].double[

Inverse() public static method

Computes the inverse of a matrix.
public static Inverse ( this matrix, bool inPlace ) : ].double[
matrix this
inPlace bool
return ].double[

Inverse() public static method

Computes the inverse of a matrix.
public static Inverse ( this matrix ) : double[][]
matrix this
return double[][]

Inverse() public static method

Computes the inverse of a matrix.
public static Inverse ( this matrix, bool inPlace ) : double[][]
matrix this
inPlace bool
return double[][]

Inverse() public static method

Computes the inverse of a matrix.
public static Inverse ( this matrix ) : ].float[
matrix this
return ].float[

Inverse() public static method

Computes the inverse of a matrix.
public static Inverse ( this matrix, bool inPlace ) : ].float[
matrix this
inPlace bool
return ].float[

Inverse() public static method

Computes the inverse of a matrix.
public static Inverse ( this matrix ) : float[][]
matrix this
return float[][]

Inverse() public static method

Computes the inverse of a matrix.
public static Inverse ( this matrix, bool inPlace ) : float[][]
matrix this
inPlace bool
return float[][]

PseudoInverse() public static method

Computes the pseudo-inverse of a matrix.
public static PseudoInverse ( this matrix ) : ].decimal[
matrix this
return ].decimal[

PseudoInverse() public static method

Computes the pseudo-inverse of a matrix.
public static PseudoInverse ( this matrix ) : decimal[][]
matrix this
return decimal[][]

PseudoInverse() public static method

Computes the pseudo-inverse of a matrix.
public static PseudoInverse ( this matrix ) : ].double[
matrix this
return ].double[

PseudoInverse() public static method

Computes the pseudo-inverse of a matrix.
public static PseudoInverse ( this matrix ) : double[][]
matrix this
return double[][]

PseudoInverse() public static method

Computes the pseudo-inverse of a matrix.
public static PseudoInverse ( this matrix ) : ].float[
matrix this
return ].float[

PseudoInverse() public static method

Computes the pseudo-inverse of a matrix.
public static PseudoInverse ( this matrix ) : float[][]
matrix this
return float[][]

Random() public static method

Creates a matrix with uniformly distributed random data.
public static Random ( int size, byte min, byte max, bool symmetric = false, byte result = null ) : ].byte[
size int
min byte
max byte
symmetric bool
result byte
return ].byte[

Random() public static method

Creates a matrix with uniformly distributed random data.
public static Random ( int rows, int columns, byte min, byte max, byte result = null ) : ].byte[
rows int
columns int
min byte
max byte
result byte
return ].byte[

Random() public static method

Creates a matrix with uniformly distributed random data.
public static Random ( int size, decimal min, decimal max, bool symmetric = false, decimal result = null ) : ].decimal[
size int
min decimal
max decimal
symmetric bool
result decimal
return ].decimal[

Random() public static method

Creates a matrix with uniformly distributed random data.
public static Random ( int rows, int columns, decimal min, decimal max, decimal result = null ) : ].decimal[
rows int
columns int
min decimal
max decimal
result decimal
return ].decimal[

Random() public static method

Creates a matrix with uniformly distributed random data.
public static Random ( int size ) : ].double[
size int
return ].double[

Random() public static method

Creates a matrix with uniformly distributed random data.
public static Random ( int size, double min, double max, bool symmetric = false, double result = null ) : ].double[
size int
min double
max double
symmetric bool
result double
return ].double[

Random() public static method

Creates a matrix with uniformly distributed random data.
public static Random ( int rows, int columns ) : ].double[
rows int
columns int
return ].double[

Random() public static method

Creates a matrix with uniformly distributed random data.
public static Random ( int rows, int columns, double min, double max, double result = null ) : ].double[
rows int
columns int
min double
max double
result double
return ].double[

Random() public static method

Creates a matrix with uniformly distributed random data.
public static Random ( int size, float min, float max, bool symmetric = false, float result = null ) : ].float[
size int
min float
max float
symmetric bool
result float
return ].float[

Random() public static method

Creates a matrix with uniformly distributed random data.
public static Random ( int rows, int columns, float min, float max, float result = null ) : ].float[
rows int
columns int
min float
max float
result float
return ].float[

Random() public static method

Creates a matrix with uniformly distributed random data.
public static Random ( int size, int min, int max, bool symmetric = false, int result = null ) : ].int[
size int
min int
max int
symmetric bool
result int
return ].int[

Random() public static method

Creates a matrix with uniformly distributed random data.
public static Random ( int rows, int columns, int min, int max, int result = null ) : ].int[
rows int
columns int
min int
max int
result int
return ].int[

Random() public static method

Creates a matrix with uniformly distributed random data.
public static Random ( int rows, int columns, long min, long max, long result = null ) : ].long[
rows int
columns int
min long
max long
result long
return ].long[

Random() public static method

Creates a matrix with uniformly distributed random data.
public static Random ( int size, long min, long max, bool symmetric = false, long result = null ) : ].long[
size int
min long
max long
symmetric bool
result long
return ].long[

Random() public static method

Creates a matrix with uniformly distributed random data.
public static Random ( int rows, int columns, sbyte min, sbyte max, sbyte result = null ) : ].sbyte[
rows int
columns int
min sbyte
max sbyte
result sbyte
return ].sbyte[

Random() public static method

Creates a matrix with uniformly distributed random data.
public static Random ( int size, sbyte min, sbyte max, bool symmetric = false, sbyte result = null ) : ].sbyte[
size int
min sbyte
max sbyte
symmetric bool
result sbyte
return ].sbyte[

Random() public static method

Creates a matrix with uniformly distributed random data.
public static Random ( int rows, int columns, short min, short max, short result = null ) : ].short[
rows int
columns int
min short
max short
result short
return ].short[

Random() public static method

Creates a matrix with uniformly distributed random data.
public static Random ( int size, short min, short max, bool symmetric = false, short result = null ) : ].short[
size int
min short
max short
symmetric bool
result short
return ].short[

Random() public static method

Creates a matrix with uniformly distributed random data.
public static Random ( int rows, int columns, ulong min, ulong max, ulong result = null ) : ].ulong[
rows int
columns int
min ulong
max ulong
result ulong
return ].ulong[

Random() public static method

Creates a matrix with uniformly distributed random data.
public static Random ( int size, ulong min, ulong max, bool symmetric = false, ulong result = null ) : ].ulong[
size int
min ulong
max ulong
symmetric bool
result ulong
return ].ulong[

Random() public static method

Creates a matrix with uniformly distributed random data.
public static Random ( int rows, int columns, ushort min, ushort max, ushort result = null ) : ].ushort[
rows int
columns int
min ushort
max ushort
result ushort
return ].ushort[

Random() public static method

Creates a matrix with uniformly distributed random data.
public static Random ( int size, ushort min, ushort max, bool symmetric = false, ushort result = null ) : ].ushort[
size int
min ushort
max ushort
symmetric bool
result ushort
return ].ushort[

Solve() public static method

Returns the solution matrix if the matrix is square or the least squares solution otherwise.
Please note that this does not check if the matrix is non-singular before attempting to solve. If a least squares solution is desired in case the matrix is singular, pass true to the leastSquares parameter when calling this function.
public static Solve ( this matrix, decimal rightSide, bool leastSquares = false ) : ].decimal[
matrix this The matrix for the linear problem.
rightSide decimal The right side b.
leastSquares bool True to produce a solution even if the /// is singular; false otherwise. Default is false.
return ].decimal[

Solve() public static method

Returns the solution matrix if the matrix is square or the least squares solution otherwise.
Please note that this does not check if the matrix is non-singular before attempting to solve. If a least squares solution is desired in case the matrix is singular, pass true to the leastSquares parameter when calling this function.
public static Solve ( this matrix, decimal rightSide, bool leastSquares = false ) : decimal[]
matrix this The matrix for the linear problem.
rightSide decimal The right side b.
leastSquares bool True to produce a solution even if the /// is singular; false otherwise. Default is false.
return decimal[]

Solve() public static method

Returns the solution matrix if the matrix is square or the least squares solution otherwise.
Please note that this does not check if the matrix is non-singular before attempting to solve. If a least squares solution is desired in case the matrix is singular, pass true to the leastSquares parameter when calling this function.
public static Solve ( this matrix, decimal rightSide, bool leastSquares = false ) : decimal[][]
matrix this The matrix for the linear problem.
rightSide decimal The right side b.
leastSquares bool True to produce a solution even if the /// is singular; false otherwise. Default is false.
return decimal[][]

Solve() public static method

Returns the solution matrix if the matrix is square or the least squares solution otherwise.
Please note that this does not check if the matrix is non-singular before attempting to solve. If a least squares solution is desired in case the matrix is singular, pass true to the leastSquares parameter when calling this function.
public static Solve ( this matrix, double rightSide, bool leastSquares = false ) : ].double[
matrix this The matrix for the linear problem.
rightSide double The right side b.
leastSquares bool True to produce a solution even if the /// is singular; false otherwise. Default is false.
return ].double[

Solve() public static method

Returns the solution matrix if the matrix is square or the least squares solution otherwise.
Please note that this does not check if the matrix is non-singular before attempting to solve. If a least squares solution is desired in case the matrix is singular, pass true to the leastSquares parameter when calling this function.
public static Solve ( this matrix, double rightSide, bool leastSquares = false ) : double[]
matrix this The matrix for the linear problem.
rightSide double The right side b.
leastSquares bool True to produce a solution even if the /// is singular; false otherwise. Default is false.
return double[]

Solve() public static method

Returns the solution matrix if the matrix is square or the least squares solution otherwise.
Please note that this does not check if the matrix is non-singular before attempting to solve. If a least squares solution is desired in case the matrix is singular, pass true to the leastSquares parameter when calling this function.
public static Solve ( this matrix, double rightSide, bool leastSquares = false ) : double[][]
matrix this The matrix for the linear problem.
rightSide double The right side b.
leastSquares bool True to produce a solution even if the /// is singular; false otherwise. Default is false.
return double[][]

Solve() public static method

Returns the solution matrix if the matrix is square or the least squares solution otherwise.
Please note that this does not check if the matrix is non-singular before attempting to solve. If a least squares solution is desired in case the matrix is singular, pass true to the leastSquares parameter when calling this function.
public static Solve ( this matrix, float rightSide, bool leastSquares = false ) : ].float[
matrix this The matrix for the linear problem.
rightSide float The right side b.
leastSquares bool True to produce a solution even if the /// is singular; false otherwise. Default is false.
return ].float[

Solve() public static method

Returns the solution matrix if the matrix is square or the least squares solution otherwise.
Please note that this does not check if the matrix is non-singular before attempting to solve. If a least squares solution is desired in case the matrix is singular, pass true to the leastSquares parameter when calling this function.
public static Solve ( this matrix, float rightSide, bool leastSquares = false ) : float[]
matrix this The matrix for the linear problem.
rightSide float The right side b.
leastSquares bool True to produce a solution even if the /// is singular; false otherwise. Default is false.
return float[]

Solve() public static method

Returns the solution matrix if the matrix is square or the least squares solution otherwise.
Please note that this does not check if the matrix is non-singular before attempting to solve. If a least squares solution is desired in case the matrix is singular, pass true to the leastSquares parameter when calling this function.
public static Solve ( this matrix, float rightSide, bool leastSquares = false ) : float[][]
matrix this The matrix for the linear problem.
rightSide float The right side b.
leastSquares bool True to produce a solution even if the /// is singular; false otherwise. Default is false.
return float[][]