Class Matrix

Static class Matrix. Defines a set of extension methods that operates mainly on multidimensional arrays and vectors.
Inheritance
System.Object
Matrix
Inherited Members
System.Object.Equals(System.Object, System.Object)
System.Object.GetHashCode()
System.Object.GetType()
System.Object.MemberwiseClone()
System.Object.ReferenceEquals(System.Object, System.Object)
System.Object.ToString()
Namespace: Mars.Numerics
Assembly: Mars.Numerics.dll
Syntax
public static class Matrix
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
Examples

Introduction

Declaring and using matrices does not requires much. In fact, it does not require anything else that is not already present at the .NET Standard. If you have already existing and working code using other libraries, you don't have to convert your matrices to any special format.

To begin, please add the following using directive on top of your .cs (or equivalent) source code file: 

using Mars.Numerics;

This is all you need to start using the matrix library.

Creating matrices

Let's start by declaring a matrix, or otherwise specifying matrices from other sources. The most straightforward way to declare a matrix is simply using: 

double[,] matrix = 
{
   { 1, 2 },
   { 3, 4 },
   { 5, 6 },
};

You don't need to create any fancy custom Matrix classes or vectors, which is a plus if you have already existent code using other libraries. You are also free to use both the multidimensional matrix syntax above or the jagged matrix syntax below: 

double[][] matrix = 
{
   new double[] { 1, 2 },
   new double[] { 3, 4 },
   new double[] { 5, 6 },
};

Special purpose matrices can also be created through specialized methods. Those include 

// Creates a vector of indices
int[] idx = Matrix.Indices(0, 10);  // { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }

// Creates a step vector within a given interval
double[] interval = Matrix.Interval(from: -2, to: 4); // { -2, -1, 0, 1, 2, 3, 4 };

// Special matrices
double[,] I = Matrix.Identity(3);     // creates a 3x3 identity matrix
double[,] magic = Matrix.Magic(5);    // creates a magic square matrix of size 5

double[] v = Matrix.Vector(5, 1.0);      // generates { 1, 1, 1, 1, 1 }
double[,] diagonal = Matrix.Diagonal(v); // matrix with v on its diagonal

Another way to declare matrices is by parsing the contents of a string: 

string str = @"1 2
             3 4";

double[,] matrix = Matrix.Parse(str);

You can even read directly from matrices formatted in C# syntax: 

string str = @"double[,] matrix = 
             {
                { 1, 2 },
                { 3, 4 },
                { 5, 6 },
             }";

double[,] multid = Matrix.Parse(str, CSharpMatrixFormatProvider.InvariantCulture);
double[,] jagged = Matrix.ParseJagged(str, CSharpMatrixFormatProvider.InvariantCulture);

And even from Octave-compatible syntax! 

string str = "[1 2; 3 4]";

double[,] matrix = Matrix.Parse(str, OctaveMatrixFormatProvider.InvariantCulture);

Matrix operations

Albeit being simple double[] matrices, the framework leverages .NET extension methods to support all basic matrix operations. For instance, consider the elementwise operations (also known as dot operations in Octave): 

double[] vector = { 0, 2, 4 };
double[] a = vector.ElementwiseMultiply(2); // vector .* 2, generates { 0,  4,  8 }
double[] b = vector.ElementwiseDivide(2);   // vector ./ 2, generates { 0,  1,  2 }
double[] c = vector.ElementwisePower(2);    // vector .^ 2, generates { 0,  4, 16 }

Operations between vectors, matrices, and both are also completely supported: 

// Declare two vectors
double[] u = { 1, 6, 3 };
double[] v = { 9, 4, 2 };

// Products between vectors
double inner = u.InnerProduct(v);    // 39.0
double[,] outer = u.OuterProduct(v); // see below
double[] kronecker = u.KroneckerProduct(v); // { 9, 4, 2, 54, 24, 12, 27, 12, 6 }
double[][] cartesian = u.CartesianProduct(v); // all possible pair-wise combinations

/* outer =
{ 
  {  9,  4,  2 },
  { 54, 24, 12 },
  { 27, 12,  6 },
};                  */

// Addition
double[] addv = u.Add(v); // { 10, 10, 5 }
double[] add5 = u.Add(5); // {  6, 11, 8 }

// Elementwise operations
double[] abs = u.Abs();   // { 1, 6, 3 }
double[] log = u.Log();   // { 0, 1.79, 1.09 }

// Apply *any* function to all elements in a vector
double[] cos = u.Apply(Math.Cos); // { 0.54, 0.96, -0.989 }
u.ApplyInPlace(Math.Cos); // can also do optionally in-place


// Declare a matrix
double[,] M = 
{
 { 0, 5, 2 },
 { 2, 1, 5 }
};

// Extract a sub-vector from v:
double[] vcut = v.Submatrix(0, 1); // { 9, 4 }

// Some operations between vectors and matrices
double[] Mv = m.Multiply(v);    //  { 24, 32 }
double[] vM = vcut.Multiply(m); // { 8, 49, 38 }

// Some operations between matrices
double[,] Md = m.MultiplyByDiagonal(v);   // { { 0, 20, 4 }, { 18, 4, 10 } }
double[,] MMt = m.MultiplyByTranspose(m); //   { { 29, 15 }, { 15, 30 } }

Please note this is by no means an extensive list; please take a look on all members available on this class or (preferably) use IntelliSense to navigate through all possible options when trying to perform an operation.

Methods

| Improve this Doc View Source

Apply<TInput, TResult>(TInput[], Func<TInput, TResult>, TResult[])

Applies a function to every element of the array.
Declaration
public static TResult[] Apply<TInput, TResult>(this TInput[] vector, Func<TInput, TResult> func, TResult[] result)
Parameters
Type Name Description
TInput[] vector
System.Func<TInput, TResult> func
TResult[] result
Returns
Type Description
TResult[]
Type Parameters
Name Description
TInput
TResult
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Apply<TInput, TResult>(TInput[], Func<TInput, TResult>)

Applies a function to every element of the array.
Declaration
public static TResult[] Apply<TInput, TResult>(this TInput[] vector, Func<TInput, TResult> func)
Parameters
Type Name Description
TInput[] vector
System.Func<TInput, TResult> func
Returns
Type Description
TResult[]
Type Parameters
Name Description
TInput
TResult
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Apply<TInput, TResult>(TInput[], Func<TInput, Int32, TResult>, TResult[])

Applies a function to every element of the array.
Declaration
public static TResult[] Apply<TInput, TResult>(this TInput[] vector, Func<TInput, int, TResult> func, TResult[] result)
Parameters
Type Name Description
TInput[] vector
System.Func<TInput, System.Int32, TResult> func
TResult[] result
Returns
Type Description
TResult[]
Type Parameters
Name Description
TInput
TResult
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Apply<TInput, TResult>(TInput[], Func<TInput, Int32, TResult>)

Applies a function to every element of the array.
Declaration
public static TResult[] Apply<TInput, TResult>(this TInput[] vector, Func<TInput, int, TResult> func)
Parameters
Type Name Description
TInput[] vector
System.Func<TInput, System.Int32, TResult> func
Returns
Type Description
TResult[]
Type Parameters
Name Description
TInput
TResult
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Apply<TInput, TResult>(TInput[][], Func<TInput, TResult>, TResult[][])

Applies a function to every element of the array.
Declaration
public static TResult[][] Apply<TInput, TResult>(this TInput[][] matrix, Func<TInput, TResult> func, TResult[][] result)
Parameters
Type Name Description
TInput[][] matrix
System.Func<TInput, TResult> func
TResult[][] result
Returns
Type Description
TResult[][]
Type Parameters
Name Description
TInput
TResult
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Apply<TInput, TResult>(TInput[][], Func<TInput, TResult>)

Applies a function to every element of the array.
Declaration
public static TResult[][] Apply<TInput, TResult>(TInput[][] matrix, Func<TInput, TResult> func)
Parameters
Type Name Description
TInput[][] matrix
System.Func<TInput, TResult> func
Returns
Type Description
TResult[][]
Type Parameters
Name Description
TInput
TResult
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Apply<TInput, TResult>(TInput[][], Func<TInput, Int32, Int32, TResult>, TResult[][])

Applies a function to every element of the array.
Declaration
public static TResult[][] Apply<TInput, TResult>(this TInput[][] matrix, Func<TInput, int, int, TResult> func, TResult[][] result)
Parameters
Type Name Description
TInput[][] matrix
System.Func<TInput, System.Int32, System.Int32, TResult> func
TResult[][] result
Returns
Type Description
TResult[][]
Type Parameters
Name Description
TInput
TResult
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Apply<TInput, TResult>(TInput[][], Func<TInput, Int32, Int32, TResult>)

Applies a function to every element of the array.
Declaration
public static TResult[][] Apply<TInput, TResult>(this TInput[][] matrix, Func<TInput, int, int, TResult> func)
Parameters
Type Name Description
TInput[][] matrix
System.Func<TInput, System.Int32, System.Int32, TResult> func
Returns
Type Description
TResult[][]
Type Parameters
Name Description
TInput
TResult
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Apply<TInput, TResult>(TInput[,], Func<TInput, TResult>, TResult[,])

Applies a function to every element of the array.
Declaration
public static TResult[, ] Apply<TInput, TResult>(this TInput[, ] matrix, Func<TInput, TResult> func, TResult[, ] result)
Parameters
Type Name Description
TInput[,] matrix
System.Func<TInput, TResult> func
TResult[,] result
Returns
Type Description
TResult[,]
Type Parameters
Name Description
TInput
TResult
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Apply<TInput, TResult>(TInput[,], Func<TInput, TResult>)

Applies a function to every element of the array.
Declaration
public static TResult[, ] Apply<TInput, TResult>(this TInput[, ] matrix, Func<TInput, TResult> func)
Parameters
Type Name Description
TInput[,] matrix
System.Func<TInput, TResult> func
Returns
Type Description
TResult[,]
Type Parameters
Name Description
TInput
TResult
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Apply<TInput, TResult>(TInput[,], Func<TInput, Int32, Int32, TResult>, TResult[,])

Applies a function to every element of the array.
Declaration
public static TResult[, ] Apply<TInput, TResult>(this TInput[, ] matrix, Func<TInput, int, int, TResult> func, TResult[, ] result)
Parameters
Type Name Description
TInput[,] matrix
System.Func<TInput, System.Int32, System.Int32, TResult> func
TResult[,] result
Returns
Type Description
TResult[,]
Type Parameters
Name Description
TInput
TResult
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Apply<TInput, TResult>(TInput[,], Func<TInput, Int32, Int32, TResult>)

Applies a function to every element of the array.
Declaration
public static TResult[, ] Apply<TInput, TResult>(this TInput[, ] matrix, Func<TInput, int, int, TResult> func)
Parameters
Type Name Description
TInput[,] matrix
System.Func<TInput, System.Int32, System.Int32, TResult> func
Returns
Type Description
TResult[,]
Type Parameters
Name Description
TInput
TResult
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Apply<TData, TResult>(IList<TData>, Func<TData, TResult>, TResult[])

Applies a function to every element of the array.
Declaration
public static TResult[] Apply<TData, TResult>(this IList<TData> vector, Func<TData, TResult> func, TResult[] result)
Parameters
Type Name Description
System.Collections.Generic.IList<TData> vector
System.Func<TData, TResult> func
TResult[] result
Returns
Type Description
TResult[]
Type Parameters
Name Description
TData
TResult
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Apply<TData, TResult>(IList<TData>, Func<TData, TResult>)

Applies a function to every element of the array.
Declaration
public static TResult[] Apply<TData, TResult>(this IList<TData> vector, Func<TData, TResult> func)
Parameters
Type Name Description
System.Collections.Generic.IList<TData> vector
System.Func<TData, TResult> func
Returns
Type Description
TResult[]
Type Parameters
Name Description
TData
TResult
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

ArgMax<T>(T[], out T)

Gets the maximum element in a vector.
Declaration
public static int ArgMax<T>(this T[] values, out T max)
    where T : IComparable<T>
Parameters
Type Name Description
T[] values
T max
Returns
Type Description
System.Int32
Type Parameters
Name Description
T
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

ArgMax<T>(T[])

Gets the maximum element in a vector.
Declaration
public static int ArgMax<T>(this T[] values)
    where T : IComparable<T>
Parameters
Type Name Description
T[] values
Returns
Type Description
System.Int32
Type Parameters
Name Description
T
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

ArgMax<T>(T[][])

Gets the index of the maximum element in a matrix.
Declaration
public static Tuple<int, int> ArgMax<T>(this T[][] matrix)
    where T : IComparable<T>
Parameters
Type Name Description
T[][] matrix
Returns
Type Description
System.Tuple<System.Int32, System.Int32>
Type Parameters
Name Description
T
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

ArgMax<T>(T[,], Int32, Int32[])

Gets the index of the maximum element in a matrix across a given dimension.
Declaration
public static int[] ArgMax<T>(this T[, ] matrix, int dimension, int[] result)
    where T : IComparable<T>
Parameters
Type Name Description
T[,] matrix
System.Int32 dimension
System.Int32[] result
Returns
Type Description
System.Int32[]
Type Parameters
Name Description
T
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

ArgMax<T>(T[,], Int32)

Gets the index of the maximum element in a matrix across a given dimension.
Declaration
public static int[] ArgMax<T>(this T[, ] matrix, int dimension)
    where T : IComparable<T>
Parameters
Type Name Description
T[,] matrix
System.Int32 dimension
Returns
Type Description
System.Int32[]
Type Parameters
Name Description
T
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

ArgMax<T>(T[,])

Gets the index of the maximum element in a matrix.
Declaration
public static Tuple<int, int> ArgMax<T>(this T[, ] matrix)
    where T : IComparable<T>
Parameters
Type Name Description
T[,] matrix
Returns
Type Description
System.Tuple<System.Int32, System.Int32>
Type Parameters
Name Description
T
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

ArgMin<T>(T[], out T)

Gets the minimum element in a vector.
Declaration
public static int ArgMin<T>(this T[] values, out T min)
    where T : IComparable<T>
Parameters
Type Name Description
T[] values
T min
Returns
Type Description
System.Int32
Type Parameters
Name Description
T
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

ArgMin<T>(T[])

Gets the minimum element in a vector.
Declaration
public static int ArgMin<T>(this T[] values)
    where T : IComparable<T>
Parameters
Type Name Description
T[] values
Returns
Type Description
System.Int32
Type Parameters
Name Description
T
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

ArgMin<T>(T[][])

Gets the index of the minimum element in a matrix.
Declaration
public static Tuple<int, int> ArgMin<T>(this T[][] matrix)
    where T : IComparable<T>
Parameters
Type Name Description
T[][] matrix
Returns
Type Description
System.Tuple<System.Int32, System.Int32>
Type Parameters
Name Description
T
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

ArgMin<T>(T[,], Int32, Int32[])

Gets the index of the minimum element in a matrix across a given dimension.
Declaration
public static int[] ArgMin<T>(this T[, ] matrix, int dimension, int[] result)
    where T : IComparable<T>
Parameters
Type Name Description
T[,] matrix
System.Int32 dimension
System.Int32[] result
Returns
Type Description
System.Int32[]
Type Parameters
Name Description
T
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

ArgMin<T>(T[,], Int32)

Gets the index of the minimum element in a matrix across a given dimension.
Declaration
public static int[] ArgMin<T>(this T[, ] matrix, int dimension)
    where T : IComparable<T>
Parameters
Type Name Description
T[,] matrix
System.Int32 dimension
Returns
Type Description
System.Int32[]
Type Parameters
Name Description
T
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

ArgMin<T>(T[,])

Gets the index of the minimum element in a matrix.
Declaration
public static Tuple<int, int> ArgMin<T>(this T[, ] matrix)
    where T : IComparable<T>
Parameters
Type Name Description
T[,] matrix
Returns
Type Description
System.Tuple<System.Int32, System.Int32>
Type Parameters
Name Description
T
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

ArgSort<T>(T[])

Gets the indices that sort a vector.
Declaration
public static int[] ArgSort<T>(this T[] values)
    where T : IComparable<T>
Parameters
Type Name Description
T[] values
Returns
Type Description
System.Int32[]
Type Parameters
Name Description
T
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Bottom<T>(T[], Int32, Boolean)

Retrieves the bottom count values of an array.
Declaration
public static int[] Bottom<T>(this T[] values, int count, bool inPlace = false)
    where T : IComparable<T>
Parameters
Type Name Description
T[] values
System.Int32 count
System.Boolean inPlace
Returns
Type Description
System.Int32[]
Type Parameters
Name Description
T
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Cartesian<T>(T[], T[])

Computes the Cartesian product of two sets.
Declaration
public static T[][] Cartesian<T>(this T[] sequence1, T[] sequence2)
Parameters
Type Name Description
T[] sequence1
T[] sequence2
Returns
Type Description
T[][]
Type Parameters
Name Description
T
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Cartesian<T>(T[][])

Computes the Cartesian product of many sets.
Declaration
public static T[][] Cartesian<T>(params T[][] sequences)
Parameters
Type Name Description
T[][] sequences
Returns
Type Description
T[][]
Type Parameters
Name Description
T
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Cartesian<T>(IEnumerable<IEnumerable<T>>)

Computes the Cartesian product of many sets.
Declaration
public static IEnumerable<IEnumerable<T>> Cartesian<T>(this IEnumerable<IEnumerable<T>> sequences)
Parameters
Type Name Description
System.Collections.Generic.IEnumerable<System.Collections.Generic.IEnumerable<T>> sequences
Returns
Type Description
System.Collections.Generic.IEnumerable<System.Collections.Generic.IEnumerable<T>>
Type Parameters
Name Description
T
Remarks
References: - http://blogs.msdn.com/b/ericlippert/archive/2010/06/28/computing-a-Cartesian-product-with-linq.aspx
See Also
| Improve this Doc View Source

Ceiling(Double[])

Returns the largest integer greater than or equal than to the specified double-precision floating-point number for each element of the array.
Declaration
public static double[] Ceiling(double[] vector)
Parameters
Type Name Description
System.Double[] vector
Returns
Type Description
System.Double[]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Ceiling(Double[,])

Returns the largest integer greater than or equal than to the specified double-precision floating-point number for each element of the matrix.
Declaration
public static double[, ] Ceiling(this double[, ] matrix)
Parameters
Type Name Description
System.Double[,] matrix
Returns
Type Description
System.Double[,]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Centering(Int32)

Creates a centering matrix of size N x N in the form (I - 1N) where 1N is a matrix with all elements equal to 1 / N.
Declaration
public static double[, ] Centering(int size)
Parameters
Type Name Description
System.Int32 size
Returns
Type Description
System.Double[,]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Clear(Array)

Sets all elements in an array to zero.
Declaration
public static void Clear(this Array array)
Parameters
Type Name Description
System.Array array
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Clear<T>(T[][])

Sets all elements in an array to zero.
Declaration
public static void Clear<T>(this T[][] array)
Parameters
Type Name Description
T[][] array
Type Parameters
Name Description
T
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Columns<T>(T[][], Boolean)

Gets the number of columns in a jagged matrix.
Declaration
public static int Columns<T>(this T[][] matrix, bool max = false)
Parameters
Type Name Description
T[][] matrix The matrix whose number of columns must be computed.
System.Boolean max Whether to compute the maximum length across all rows (because rows can have different lengths in jagged matrices). Default is false.
Returns
Type Description
System.Int32 The number of columns in the matrix.
Type Parameters
Name Description
T The type of the elements in the matrix.
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Columns<T>(T[,,])

Gets the number of columns in a multidimensional matrix.
Declaration
public static int Columns<T>(this T[,, ] matrix)
Parameters
Type Name Description
T[,,] matrix The matrix whose number of columns must be computed.
Returns
Type Description
System.Int32 The number of columns in the matrix.
Type Parameters
Name Description
T The type of the elements in the matrix.
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Columns<T>(T[,])

Gets the number of columns in a multidimensional matrix.
Declaration
public static int Columns<T>(this T[, ] matrix)
Parameters
Type Name Description
T[,] matrix The matrix whose number of columns must be computed.
Returns
Type Description
System.Int32 The number of columns in the matrix.
Type Parameters
Name Description
T The type of the elements in the matrix.
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Columns<T>(IEnumerable<T[]>)

Gets the number of columns in a jagged matrix.
Declaration
public static int Columns<T>(this IEnumerable<T[]> matrix)
Parameters
Type Name Description
System.Collections.Generic.IEnumerable<T[]> matrix The matrix whose number of columns must be computed.
Returns
Type Description
System.Int32 The number of columns in the matrix.
Type Parameters
Name Description
T The type of the elements in the matrix.
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Columns<T>(IList<IList<T>>)

Gets the number of columns in a jagged matrix.
Declaration
public static int Columns<T>(this IList<IList<T>> values)
Parameters
Type Name Description
System.Collections.Generic.IList<System.Collections.Generic.IList<T>> values The matrix whose number of rows must be computed.
Returns
Type Description
System.Int32 The number of columns in the matrix.
Type Parameters
Name Description
T The type of the elements in the matrix.
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

ColumnVector<T>(T[])

Creates a Nx1 matrix with a single column vector of size N.
Declaration
public static T[, ] ColumnVector<T>(params T[] values)
Parameters
Type Name Description
T[] values
Returns
Type Description
T[,]
Type Parameters
Name Description
T
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Concatenate<T>(T, T[])

Combines a vector and a element horizontally.
Declaration
public static T[] Concatenate<T>(this T element, T[] vector)
Parameters
Type Name Description
T element
T[] vector
Returns
Type Description
T[]
Type Parameters
Name Description
T
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Concatenate<T>(T[], T)

Combines a vector and a element horizontally.
Declaration
public static T[] Concatenate<T>(this T[] vector, T element)
Parameters
Type Name Description
T[] vector
T element
Returns
Type Description
T[]
Type Parameters
Name Description
T
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Concatenate<T>(T[], T[])

Combines two vectors horizontally.
Declaration
public static T[] Concatenate<T>(this T[] a, params T[] b)
Parameters
Type Name Description
T[] a
T[] b
Returns
Type Description
T[]
Type Parameters
Name Description
T
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Concatenate<T>(T[][], T[][])

Combines two matrices horizontally.
Declaration
public static T[][] Concatenate<T>(this T[][] a, T[][] b)
Parameters
Type Name Description
T[][] a
T[][] b
Returns
Type Description
T[][]
Type Parameters
Name Description
T
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Concatenate<T>(T[][])

Combine vectors horizontally.
Declaration
public static T[] Concatenate<T>(this T[][] vectors)
Parameters
Type Name Description
T[][] vectors
Returns
Type Description
T[]
Type Parameters
Name Description
T
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Concatenate<T>(T[][][])

Combines a matrix and a vector horizontally.
Declaration
public static T[][] Concatenate<T>(params T[][][] matrices)
Parameters
Type Name Description
T[][][] matrices
Returns
Type Description
T[][]
Type Parameters
Name Description
T
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Concatenate<T>(T[,], T[])

Combines a matrix and a vector horizontally.
Declaration
public static T[, ] Concatenate<T>(this T[, ] matrix, T[] vector)
Parameters
Type Name Description
T[,] matrix
T[] vector
Returns
Type Description
T[,]
Type Parameters
Name Description
T
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Concatenate<T>(T[,], T[,])

Combines two matrices horizontally.
Declaration
public static T[, ] Concatenate<T>(this T[, ] a, T[, ] b)
Parameters
Type Name Description
T[,] a
T[,] b
Returns
Type Description
T[,]
Type Parameters
Name Description
T
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Concatenate<T>(T[,][])

Combines a matrix and a vector horizontally.
Declaration
public static T[, ] Concatenate<T>(params T[, ][] matrices)
Parameters
Type Name Description
T[,][] matrices
Returns
Type Description
T[,]
Type Parameters
Name Description
T
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Convert(Array, Type)

Converts the values of a tensor.
Declaration
public static Array Convert(this Array array, Type type)
Parameters
Type Name Description
System.Array array The tensor to be converted.
System.Type type The type of the output.
Returns
Type Description
System.Array
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Convert<TOutput>(Array)

Converts the values of a tensor.
Declaration
public static Array Convert<TOutput>(this Array array)
Parameters
Type Name Description
System.Array array The tensor to be converted.
Returns
Type Description
System.Array
Type Parameters
Name Description
TOutput The type of the output.
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Convert<TInput, TOutput>(TInput[], Converter<TInput, TOutput>)

Converts the values of a vector using the given converter expression.
Declaration
public static TOutput[] Convert<TInput, TOutput>(this TInput[] vector, Converter<TInput, TOutput> converter)
Parameters
Type Name Description
TInput[] vector The vector to be converted.
System.Converter<TInput, TOutput> converter The converter function.
Returns
Type Description
TOutput[]
Type Parameters
Name Description
TInput The type of the input.
TOutput The type of the output.
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Convert<TInput, TOutput>(TInput[])

Converts the values of a vector using the given converter expression.
Declaration
public static TOutput[] Convert<TInput, TOutput>(this TInput[] vector)
Parameters
Type Name Description
TInput[] vector The vector to be converted.
Returns
Type Description
TOutput[]
Type Parameters
Name Description
TInput The type of the input.
TOutput The type of the output.
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Convert<TInput, TOutput>(TInput[][], Converter<TInput, TOutput>)

Converts the values of a matrix using the given converter expression.
Declaration
public static TOutput[, ] Convert<TInput, TOutput>(this TInput[][] matrix, Converter<TInput, TOutput> converter)
Parameters
Type Name Description
TInput[][] matrix The matrix to be converted.
System.Converter<TInput, TOutput> converter The converter function.
Returns
Type Description
TOutput[,]
Type Parameters
Name Description
TInput The type of the input.
TOutput The type of the output.
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Convert<TInput, TOutput>(TInput[][])

Converts the values of a matrix using the default converter.
Declaration
public static TOutput[, ] Convert<TInput, TOutput>(TInput[][] matrix)
Parameters
Type Name Description
TInput[][] matrix The matrix to be converted.
Returns
Type Description
TOutput[,]
Type Parameters
Name Description
TInput The type of the input.
TOutput The type of the output.
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Convert<TInput, TOutput>(TInput[,], Converter<TInput, TOutput>)

Converts the values of a matrix using the given converter expression.
Declaration
public static TOutput[, ] Convert<TInput, TOutput>(this TInput[, ] matrix, Converter<TInput, TOutput> converter)
Parameters
Type Name Description
TInput[,] matrix The vector to be converted.
System.Converter<TInput, TOutput> converter The converter function.
Returns
Type Description
TOutput[,]
Type Parameters
Name Description
TInput The type of the input.
TOutput The type of the output.
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Convert<TInput, TOutput>(TInput[,])

Converts the values of a matrix using the default converter.
Declaration
public static TOutput[, ] Convert<TInput, TOutput>(this TInput[, ] matrix)
Parameters
Type Name Description
TInput[,] matrix The matrix to be converted.
Returns
Type Description
TOutput[,]
Type Parameters
Name Description
TInput The type of the input.
TOutput The type of the output.
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Convolve(Double[], Double[], Boolean)

Convolves an array with the given kernel.
Declaration
public static double[] Convolve(this double[] a, double[] kernel, bool trim)
Parameters
Type Name Description
System.Double[] a A floating number array.
System.Double[] kernel A convolution kernel.
System.Boolean trim If true the resulting array will be trimmed to have the same length as the input array. Default is false.
Returns
Type Description
System.Double[]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Convolve(Double[], Double[])

Convolves an array with the given kernel.
Declaration
public static double[] Convolve(this double[] a, double[] kernel)
Parameters
Type Name Description
System.Double[] a A floating number array.
System.Double[] kernel A convolution kernel.
Returns
Type Description
System.Double[]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Copy(Array, Array)

Copies elements from an array to another array even if one is a jagged array and the other a multidimensional array.
Declaration
public static void Copy(this Array source, Array destination)
Parameters
Type Name Description
System.Array source The array whose elements should be copied from.
System.Array destination The array where elements will be written to.
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Copy<T>(T[][])

Creates a member-wise copy of a jagged matrix. Matrix elements themselves are copied only in a shallowed manner (i.e. not cloned).
Declaration
public static T[][] Copy<T>(this T[][] a)
Parameters
Type Name Description
T[][] a
Returns
Type Description
T[][]
Type Parameters
Name Description
T
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Copy<T>(T[,])

Creates a memberwise copy of a matrix. Matrix elements themselves are copied only in a shallow manner (i.e. not cloned).
Declaration
public static T[, ] Copy<T>(this T[, ] a)
Parameters
Type Name Description
T[,] a
Returns
Type Description
T[,]
Type Parameters
Name Description
T
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

CopyTo<T>(T[], T[])

Copies the content of an array to another array.
Declaration
public static void CopyTo<T>(this T[] vector, T[] destination)
Parameters
Type Name Description
T[] vector The source vector to be copied.
T[] destination The matrix where the elements should be copied to.
Type Parameters
Name Description
T The type of the elements to be copied.
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

CopyTo<T>(T[][], T[][], Boolean)

Copies the content of an array to another array.
Declaration
public static void CopyTo<T>(this T[][] matrix, T[][] destination, bool transpose = false)
Parameters
Type Name Description
T[][] matrix The source matrix to be copied.
T[][] destination The matrix where the elements should be copied to.
System.Boolean transpose Whether to transpose the matrix when copying or not. Default is false.
Type Parameters
Name Description
T The type of the elements to be copied.
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

CopyTo<T>(T[][], T[,])

Copies the content of an array to another array.
Declaration
public static void CopyTo<T>(this T[][] matrix, T[, ] destination)
Parameters
Type Name Description
T[][] matrix The source matrix to be copied.
T[,] destination The matrix where the elements should be copied to.
Type Parameters
Name Description
T The type of the elements to be copied.
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

CopyTo<T>(T[,], T[][], Boolean)

Copies the content of an array to another array.
Declaration
public static void CopyTo<T>(this T[, ] matrix, T[][] destination, bool transpose = false)
Parameters
Type Name Description
T[,] matrix The source matrix to be copied.
T[][] destination The matrix where the elements should be copied to.
System.Boolean transpose Whether to transpose the matrix when copying or not. Default is false.
Type Parameters
Name Description
T The type of the elements to be copied.
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

CopyTo<T>(T[,], T[,], Boolean)

Copies the content of an array to another array.
Declaration
public static void CopyTo<T>(this T[, ] matrix, T[, ] destination, bool transpose = false)
Parameters
Type Name Description
T[,] matrix The source matrix to be copied.
T[,] destination The matrix where the elements should be copied to.
System.Boolean transpose Whether to transpose the matrix when copying or not. Default is false.
Type Parameters
Name Description
T The type of the elements to be copied.
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Count<T>(T[], Func<T, Boolean>)

Gets the number of elements matching a certain criteria.
Declaration
public static int Count<T>(this T[] data, Func<T, bool> func)
Parameters
Type Name Description
T[] data The array to search inside.
System.Func<T, System.Boolean> func The search criteria.
Returns
Type Description
System.Int32
Type Parameters
Name Description
T The type of the array.
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Create(Type, Int32[], Object)

Creates a tensor with all values set to a given value.
Declaration
public static Array Create(Type elementType, int[] shape, object value)
Parameters
Type Name Description
System.Type elementType The type of the elements to be contained in the matrix.
System.Int32[] shape The number of dimensions that the matrix should have.
System.Object value The initial values for the vector.
Returns
Type Description
System.Array A matrix of the specified size.
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Create<T>(T[][])

Creates a matrix with the given rows.
Declaration
public static T[, ] Create<T>(params T[][] rows)
Parameters
Type Name Description
T[][] rows The row vectors in the matrix.
Returns
Type Description
T[,]
Type Parameters
Name Description
T
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Create<T>(T[,])

Creates a matrix with the given values.
Declaration
public static T[, ] Create<T>(T[, ] values)
Parameters
Type Name Description
T[,] values The values in the matrix.
Returns
Type Description
T[,]
Type Parameters
Name Description
T
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Create<T>(Int32, Int32, T)

Creates a matrix with all values set to a given value.
Declaration
public static T[, ] Create<T>(int rows, int columns, T value)
Parameters
Type Name Description
System.Int32 rows The number of rows in the matrix.
System.Int32 columns The number of columns in the matrix.
T value The initial values for the vector.
Returns
Type Description
T[,] A matrix of the specified size.
Type Parameters
Name Description
T
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Create<T>(Int32, Int32, T[])

Creates a matrix with all values set to a given value.
Declaration
public static T[, ] Create<T>(int rows, int columns, params T[] values)
Parameters
Type Name Description
System.Int32 rows The number of rows in the matrix.
System.Int32 columns The number of columns in the matrix.
T[] values The initial values for the matrix.
Returns
Type Description
T[,] A matrix of the specified size.
Type Parameters
Name Description
T
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Create<T>(Int32, Int32, T[,], Boolean)

Creates a matrix with all values set to a given value.
Declaration
public static T[, ] Create<T>(int rows, int columns, T[, ] values, bool transpose = false)
Parameters
Type Name Description
System.Int32 rows The number of rows in the matrix.
System.Int32 columns The number of columns in the matrix.
T[,] values The initial values for the matrix.
System.Boolean transpose Whether to transpose the matrix when copying or not. Default is false.
Returns
Type Description
T[,] A matrix of the specified size.
Type Parameters
Name Description
T
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Create<T>(Int32[], T)

Creates a tensor with all values set to a given value.
Declaration
public static Array Create<T>(int[] shape, T value)
Parameters
Type Name Description
System.Int32[] shape The number of dimensions that the matrix should have.
T value The initial values for the vector.
Returns
Type Description
System.Array A matrix of the specified size.
Type Parameters
Name Description
T
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

CreateAs(Array, Type)

Creates a new multidimensional matrix with the same shape as another matrix.
Declaration
public static Array CreateAs(Array matrix, Type type)
Parameters
Type Name Description
System.Array matrix
System.Type type
Returns
Type Description
System.Array
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

CreateAs<T>(T[][])

Creates a new multidimensional matrix with the same shape as another matrix.
Declaration
public static T[, ] CreateAs<T>(T[][] matrix)
Parameters
Type Name Description
T[][] matrix
Returns
Type Description
T[,]
Type Parameters
Name Description
T
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

CreateAs<T>(T[,])

Creates a new multidimensional matrix with the same shape as another matrix.
Declaration
public static T[, ] CreateAs<T>(T[, ] matrix)
Parameters
Type Name Description
T[,] matrix
Returns
Type Description
T[,]
Type Parameters
Name Description
T
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

CreateAs<TInput, TOutput>(TInput[][])

Creates a new multidimensional matrix with the same shape as another matrix.
Declaration
public static TOutput[, ] CreateAs<TInput, TOutput>(TInput[][] matrix)
Parameters
Type Name Description
TInput[][] matrix
Returns
Type Description
TOutput[,]
Type Parameters
Name Description
TInput
TOutput
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

CreateAs<TInput, TOutput>(TInput[,,])

Creates a new multidimensional matrix with the same shape as another matrix.
Declaration
public static TOutput[,, ] CreateAs<TInput, TOutput>(TInput[,, ] matrix)
Parameters
Type Name Description
TInput[,,] matrix
Returns
Type Description
TOutput[,,]
Type Parameters
Name Description
TInput
TOutput
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

CreateAs<TInput, TOutput>(TInput[,])

Creates a new multidimensional matrix with the same shape as another matrix.
Declaration
public static TOutput[, ] CreateAs<TInput, TOutput>(TInput[, ] matrix)
Parameters
Type Name Description
TInput[,] matrix
Returns
Type Description
TOutput[,]
Type Parameters
Name Description
TInput
TOutput
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Cross(Double[], Double[], Double[])

Vector product.
Declaration
public static double[] Cross(this double[] a, double[] b, double[] result)
Parameters
Type Name Description
System.Double[] a
System.Double[] b
System.Double[] result
Returns
Type Description
System.Double[]
Remarks
The cross product, vector product or Gibbs vector product is a binary operation on two vectors in three-dimensional space. It has a vector result, a vector which is always perpendicular to both of the vectors being multiplied and the plane containing them. It has many applications in mathematics, engineering and physics.
See Also
| Improve this Doc View Source

Cross(Double[], Double[], Int32[])

Vector product.
Declaration
public static int[] Cross(this double[] a, double[] b, int[] result)
Parameters
Type Name Description
System.Double[] a
System.Double[] b
System.Int32[] result
Returns
Type Description
System.Int32[]
Remarks
The cross product, vector product or Gibbs vector product is a binary operation on two vectors in three-dimensional space. It has a vector result, a vector which is always perpendicular to both of the vectors being multiplied and the plane containing them. It has many applications in mathematics, engineering and physics.
See Also
| Improve this Doc View Source

Cross(Double[], Double[])

Vector product.
Declaration
public static double[] Cross(this double[] a, double[] b)
Parameters
Type Name Description
System.Double[] a
System.Double[] b
Returns
Type Description
System.Double[]
Remarks
The cross product, vector product or Gibbs vector product is a binary operation on two vectors in three-dimensional space. It has a vector result, a vector which is always perpendicular to both of the vectors being multiplied and the plane containing them. It has many applications in mathematics, engineering and physics.
See Also
| Improve this Doc View Source

Cross(Double[], Int32[], Double[])

Vector product.
Declaration
public static double[] Cross(this double[] a, int[] b, double[] result)
Parameters
Type Name Description
System.Double[] a
System.Int32[] b
System.Double[] result
Returns
Type Description
System.Double[]
Remarks
The cross product, vector product or Gibbs vector product is a binary operation on two vectors in three-dimensional space. It has a vector result, a vector which is always perpendicular to both of the vectors being multiplied and the plane containing them. It has many applications in mathematics, engineering and physics.
See Also
| Improve this Doc View Source

Cross(Double[], Int32[], Int32[])

Vector product.
Declaration
public static int[] Cross(this double[] a, int[] b, int[] result)
Parameters
Type Name Description
System.Double[] a
System.Int32[] b
System.Int32[] result
Returns
Type Description
System.Int32[]
Remarks
The cross product, vector product or Gibbs vector product is a binary operation on two vectors in three-dimensional space. It has a vector result, a vector which is always perpendicular to both of the vectors being multiplied and the plane containing them. It has many applications in mathematics, engineering and physics.
See Also
| Improve this Doc View Source

Cross(Double[], Int32[])

Vector product.
Declaration
public static double[] Cross(this double[] a, int[] b)
Parameters
Type Name Description
System.Double[] a
System.Int32[] b
Returns
Type Description
System.Double[]
Remarks
The cross product, vector product or Gibbs vector product is a binary operation on two vectors in three-dimensional space. It has a vector result, a vector which is always perpendicular to both of the vectors being multiplied and the plane containing them. It has many applications in mathematics, engineering and physics.
See Also
| Improve this Doc View Source

Cross(Int32[], Double[], Double[])

Vector product.
Declaration
public static double[] Cross(this int[] a, double[] b, double[] result)
Parameters
Type Name Description
System.Int32[] a
System.Double[] b
System.Double[] result
Returns
Type Description
System.Double[]
Remarks
The cross product, vector product or Gibbs vector product is a binary operation on two vectors in three-dimensional space. It has a vector result, a vector which is always perpendicular to both of the vectors being multiplied and the plane containing them. It has many applications in mathematics, engineering and physics.
See Also
| Improve this Doc View Source

Cross(Int32[], Double[], Int32[])

Vector product.
Declaration
public static int[] Cross(this int[] a, double[] b, int[] result)
Parameters
Type Name Description
System.Int32[] a
System.Double[] b
System.Int32[] result
Returns
Type Description
System.Int32[]
Remarks
The cross product, vector product or Gibbs vector product is a binary operation on two vectors in three-dimensional space. It has a vector result, a vector which is always perpendicular to both of the vectors being multiplied and the plane containing them. It has many applications in mathematics, engineering and physics.
See Also
| Improve this Doc View Source

Cross(Int32[], Double[])

Vector product.
Declaration
public static double[] Cross(this int[] a, double[] b)
Parameters
Type Name Description
System.Int32[] a
System.Double[] b
Returns
Type Description
System.Double[]
Remarks
The cross product, vector product or Gibbs vector product is a binary operation on two vectors in three-dimensional space. It has a vector result, a vector which is always perpendicular to both of the vectors being multiplied and the plane containing them. It has many applications in mathematics, engineering and physics.
See Also
| Improve this Doc View Source

Cross(Int32[], Int32[], Double[])

Vector product.
Declaration
public static double[] Cross(this int[] a, int[] b, double[] result)
Parameters
Type Name Description
System.Int32[] a
System.Int32[] b
System.Double[] result
Returns
Type Description
System.Double[]
Remarks
The cross product, vector product or Gibbs vector product is a binary operation on two vectors in three-dimensional space. It has a vector result, a vector which is always perpendicular to both of the vectors being multiplied and the plane containing them. It has many applications in mathematics, engineering and physics.
See Also
| Improve this Doc View Source

Cross(Int32[], Int32[], Int32[])

Vector product.
Declaration
public static int[] Cross(this int[] a, int[] b, int[] result)
Parameters
Type Name Description
System.Int32[] a
System.Int32[] b
System.Int32[] result
Returns
Type Description
System.Int32[]
Remarks
The cross product, vector product or Gibbs vector product is a binary operation on two vectors in three-dimensional space. It has a vector result, a vector which is always perpendicular to both of the vectors being multiplied and the plane containing them. It has many applications in mathematics, engineering and physics.
See Also
| Improve this Doc View Source

Cross(Int32[], Int32[])

Vector product.
Declaration
public static int[] Cross(this int[] a, int[] b)
Parameters
Type Name Description
System.Int32[] a
System.Int32[] b
Returns
Type Description
System.Int32[]
Remarks
The cross product, vector product or Gibbs vector product is a binary operation on two vectors in three-dimensional space. It has a vector result, a vector which is always perpendicular to both of the vectors being multiplied and the plane containing them. It has many applications in mathematics, engineering and physics.
See Also
| Improve this Doc View Source

CumulativeSum(Double[], Double[])

Matrix cumulative sum.
Declaration
public static double[] CumulativeSum(this double[] vector, double[] result)
Parameters
Type Name Description
System.Double[] vector A vector whose cumulative sum will be calculated.
System.Double[] result A location where the result of this operation will be stored, avoiding unnecessary memory allocations.
Returns
Type Description
System.Double[]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

CumulativeSum(Double[])

Matrix cumulative sum.
Declaration
public static double[] CumulativeSum(this double[] vector)
Parameters
Type Name Description
System.Double[] vector A vector whose cumulative sum will be calculated.
Returns
Type Description
System.Double[]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

CumulativeSum(Double[][], Int32, Double[][])

Matrix cumulative sum.
Declaration
public static double[][] CumulativeSum(this double[][] matrix, int dimension, double[][] result)
Parameters
Type Name Description
System.Double[][] matrix A matrix whose cumulative sum will be calculated.
System.Int32 dimension The dimension in which the cumulative will be calculated.
System.Double[][] result A location where the result of this operation will be stored, avoiding unnecessary memory allocations.
Returns
Type Description
System.Double[][]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

CumulativeSum(Double[][], Int32)

Matrix cumulative sum.
Declaration
public static double[][] CumulativeSum(this double[][] matrix, int dimension)
Parameters
Type Name Description
System.Double[][] matrix A matrix whose cumulative sum will be calculated.
System.Int32 dimension The dimension in which the cumulative will be calculated.
Returns
Type Description
System.Double[][]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

CumulativeSum(Double[,], Int32, Double[,])

Matrix cumulative sum.
Declaration
public static double[, ] CumulativeSum(this double[, ] matrix, int dimension, double[, ] result)
Parameters
Type Name Description
System.Double[,] matrix A matrix whose cumulative sum will be calculated.
System.Int32 dimension The dimension in which the cumulative will be calculated.
System.Double[,] result A location where the result of this operation will be stored, avoiding unnecessary memory allocations.
Returns
Type Description
System.Double[,]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

CumulativeSum(Double[,], Int32)

Matrix cumulative sum.
Declaration
public static double[, ] CumulativeSum(this double[, ] matrix, int dimension)
Parameters
Type Name Description
System.Double[,] matrix A matrix whose cumulative sum will be calculated.
System.Int32 dimension The dimension in which the cumulative will be calculated.
Returns
Type Description
System.Double[,]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

CumulativeSum(Int32[], Int32[])

Matrix cumulative sum.
Declaration
public static int[] CumulativeSum(this int[] vector, int[] result)
Parameters
Type Name Description
System.Int32[] vector A vector whose cumulative sum will be calculated.
System.Int32[] result A location where the result of this operation will be stored, avoiding unnecessary memory allocations.
Returns
Type Description
System.Int32[]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

CumulativeSum(Int32[])

Matrix cumulative sum.
Declaration
public static int[] CumulativeSum(this int[] vector)
Parameters
Type Name Description
System.Int32[] vector A vector whose cumulative sum will be calculated.
Returns
Type Description
System.Int32[]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

CumulativeSum(Int32[][], Int32, Int32[][])

Matrix cumulative sum.
Declaration
public static int[][] CumulativeSum(this int[][] matrix, int dimension, int[][] result)
Parameters
Type Name Description
System.Int32[][] matrix A matrix whose cumulative sum will be calculated.
System.Int32 dimension The dimension in which the cumulative will be calculated.
System.Int32[][] result A location where the result of this operation will be stored, avoiding unnecessary memory allocations.
Returns
Type Description
System.Int32[][]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

CumulativeSum(Int32[][], Int32)

Matrix cumulative sum.
Declaration
public static int[][] CumulativeSum(this int[][] matrix, int dimension)
Parameters
Type Name Description
System.Int32[][] matrix A matrix whose cumulative sum will be calculated.
System.Int32 dimension The dimension in which the cumulative will be calculated.
Returns
Type Description
System.Int32[][]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

CumulativeSum(Int32[,], Int32, Int32[,])

Matrix cumulative sum.
Declaration
public static int[, ] CumulativeSum(this int[, ] matrix, int dimension, int[, ] result)
Parameters
Type Name Description
System.Int32[,] matrix A matrix whose cumulative sum will be calculated.
System.Int32 dimension The dimension in which the cumulative will be calculated.
System.Int32[,] result A location where the result of this operation will be stored, avoiding unnecessary memory allocations.
Returns
Type Description
System.Int32[,]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

CumulativeSum(Int32[,], Int32)

Matrix cumulative sum.
Declaration
public static int[, ] CumulativeSum(this int[, ] matrix, int dimension)
Parameters
Type Name Description
System.Int32[,] matrix A matrix whose cumulative sum will be calculated.
System.Int32 dimension The dimension in which the cumulative will be calculated.
Returns
Type Description
System.Int32[,]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

DeepFlatten(Array)

Transforms a jagged array matrix into a single vector.
Declaration
public static Array DeepFlatten(this Array array)
Parameters
Type Name Description
System.Array array A jagged array.
Returns
Type Description
System.Array
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

DeepToMatrix(Array)

Converts a jagged-array into a multidimensional array.
Declaration
public static Array DeepToMatrix(this Array array)
Parameters
Type Name Description
System.Array array
Returns
Type Description
System.Array
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Depth<T>(T[,,])

Gets the number of columns in a multidimensional matrix.
Declaration
public static int Depth<T>(this T[,, ] matrix)
Parameters
Type Name Description
T[,,] matrix The matrix whose number of columns must be computed.
Returns
Type Description
System.Int32 The number of columns in the matrix.
Type Parameters
Name Description
T The type of the elements in the matrix.
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Diagonal<T>(T[], T[,])

Return a square matrix with a vector of values on its diagonal.
Declaration
public static T[, ] Diagonal<T>(T[] values, T[, ] result)
Parameters
Type Name Description
T[] values
T[,] result
Returns
Type Description
T[,]
Type Parameters
Name Description
T
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Diagonal<T>(T[])

Return a square matrix with a vector of values on its diagonal.
Declaration
public static T[, ] Diagonal<T>(T[] values)
Parameters
Type Name Description
T[] values
Returns
Type Description
T[,]
Type Parameters
Name Description
T
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Diagonal<T>(T[][])

Gets the diagonal vector from a matrix.
Declaration
public static T[] Diagonal<T>(this T[][] matrix)
Parameters
Type Name Description
T[][] matrix A matrix.
Returns
Type Description
T[] The diagonal vector from the given matrix.
Type Parameters
Name Description
T
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Diagonal<T>(T[,])

Gets the diagonal vector from a matrix.
Declaration
public static T[] Diagonal<T>(this T[, ] matrix)
Parameters
Type Name Description
T[,] matrix A matrix.
Returns
Type Description
T[] The diagonal vector from the given matrix.
Type Parameters
Name Description
T
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Diagonal<T>(T[,][])

Returns a block-diagonal matrix with the given matrices on its diagonal.
Declaration
public static T[, ] Diagonal<T>(T[, ][] blocks)
Parameters
Type Name Description
T[,][] blocks
Returns
Type Description
T[,]
Type Parameters
Name Description
T
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Diagonal<T>(Int32, T, T[,])

Returns a square diagonal matrix of the given size.
Declaration
public static T[, ] Diagonal<T>(int size, T value, T[, ] result)
Parameters
Type Name Description
System.Int32 size
T value
T[,] result
Returns
Type Description
T[,]
Type Parameters
Name Description
T
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Diagonal<T>(Int32, T)

Returns a square diagonal matrix of the given size.
Declaration
public static T[, ] Diagonal<T>(int size, T value)
Parameters
Type Name Description
System.Int32 size
T value
Returns
Type Description
T[,]
Type Parameters
Name Description
T
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Diagonal<T>(Int32, T[], T[,])

Return a square matrix with a vector of values on its diagonal.
Declaration
public static T[, ] Diagonal<T>(int size, T[] values, T[, ] result)
Parameters
Type Name Description
System.Int32 size
T[] values
T[,] result
Returns
Type Description
T[,]
Type Parameters
Name Description
T
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Diagonal<T>(Int32, T[])

Return a square matrix with a vector of values on its diagonal.
Declaration
public static T[, ] Diagonal<T>(int size, T[] values)
Parameters
Type Name Description
System.Int32 size
T[] values
Returns
Type Description
T[,]
Type Parameters
Name Description
T
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Diagonal<T>(Int32, Int32, T, T[,])

Returns a matrix of the given size with value on its diagonal.
Declaration
public static T[, ] Diagonal<T>(int rows, int cols, T value, T[, ] result)
Parameters
Type Name Description
System.Int32 rows
System.Int32 cols
T value
T[,] result
Returns
Type Description
T[,]
Type Parameters
Name Description
T
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Diagonal<T>(Int32, Int32, T)

Returns a matrix of the given size with value on its diagonal.
Declaration
public static T[, ] Diagonal<T>(int rows, int cols, T value)
Parameters
Type Name Description
System.Int32 rows
System.Int32 cols
T value
Returns
Type Description
T[,]
Type Parameters
Name Description
T
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Diagonal<T>(Int32, Int32, T[], T[,])

Returns a matrix with a vector of values on its diagonal.
Declaration
public static T[, ] Diagonal<T>(int rows, int cols, T[] values, T[, ] result)
Parameters
Type Name Description
System.Int32 rows
System.Int32 cols
T[] values
T[,] result
Returns
Type Description
T[,]
Type Parameters
Name Description
T
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Diagonal<T>(Int32, Int32, T[])

Returns a matrix with a vector of values on its diagonal.
Declaration
public static T[, ] Diagonal<T>(int rows, int cols, T[] values)
Parameters
Type Name Description
System.Int32 rows
System.Int32 cols
T[] values
Returns
Type Description
T[,]
Type Parameters
Name Description
T
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

DimensionEquals(Array, Array)

Checks whether two arrays have the same dimensions.
Declaration
public static bool DimensionEquals(this Array a, Array b)
Parameters
Type Name Description
System.Array a
System.Array b
Returns
Type Description
System.Boolean
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Distinct<T>(T[], Boolean)

Retrieves only distinct values contained in an array.
Declaration
public static T[] Distinct<T>(this T[] values, bool allowNulls)
    where T : class
Parameters
Type Name Description
T[] values The array.
System.Boolean allowNulls Whether to allow null values in the method's output. Default is true.
Returns
Type Description
T[] An array containing only the distinct values in values.
Type Parameters
Name Description
T
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Distinct<T>(T[])

Retrieves only distinct values contained in an array.
Declaration
public static T[] Distinct<T>(this T[] values)
Parameters
Type Name Description
T[] values The array.
Returns
Type Description
T[] An array containing only the distinct values in values.
Type Parameters
Name Description
T
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Distinct<T>(T[][])

Retrieves a list of the distinct values for each matrix column.
Declaration
public static T[][] Distinct<T>(this T[][] values)
Parameters
Type Name Description
T[][] values The matrix.
Returns
Type Description
T[][] An array containing arrays of distinct values for each column in the values.
Type Parameters
Name Description
T
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Distinct<T>(T[,])

Retrieves a list of the distinct values for each matrix column.
Declaration
public static T[][] Distinct<T>(this T[, ] values)
Parameters
Type Name Description
T[,] values The matrix.
Returns
Type Description
T[][] An array containing arrays of distinct values for each column in the values.
Type Parameters
Name Description
T
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Distinct<T, TProperty>(T[], Func<T, TProperty>)

Retrieves only distinct values contained in an array.
Declaration
public static T[] Distinct<T, TProperty>(this T[] values, Func<T, TProperty> property)
    where TProperty : IComparable<TProperty>
Parameters
Type Name Description
T[] values The array.
System.Func<T, TProperty> property The property of the object used to determine distinct instances.
Returns
Type Description
T[] An array containing only the distinct values in values.
Type Parameters
Name Description
T
TProperty
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

DistinctCount<T>(T[])

Gets the number of distinct values present in each column of a matrix.
Declaration
public static int DistinctCount<T>(this T[] values)
Parameters
Type Name Description
T[] values
Returns
Type Description
System.Int32
Type Parameters
Name Description
T
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

DistinctCount<T>(T[][])

Gets the number of distinct values present in each column of a matrix.
Declaration
public static int[] DistinctCount<T>(this T[][] matrix)
Parameters
Type Name Description
T[][] matrix
Returns
Type Description
System.Int32[]
Type Parameters
Name Description
T
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

DistinctCount<T>(T[,])

Gets the number of distinct values present in each column of a matrix.
Declaration
public static int[] DistinctCount<T>(this T[, ] matrix)
Parameters
Type Name Description
T[,] matrix
Returns
Type Description
System.Int32[]
Type Parameters
Name Description
T
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

DivideByDiagonal(Double[][], Double[], Double[][])

Computes the product A*inv(B) of matrix A and diagonal matrix B.
Declaration
public static double[][] DivideByDiagonal(this double[][] a, double[] diagonal, double[][] result)
Parameters
Type Name Description
System.Double[][] a The left matrix A.
System.Double[] diagonal The diagonal vector of inverse right matrix B.
System.Double[][] result The matrix R to store the product R = A*B of the given matrices A and B.
Returns
Type Description
System.Double[][]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

DivideByDiagonal(Double[][], Double[], Int32[][])

Computes the product A*inv(B) of matrix A and diagonal matrix B.
Declaration
public static int[][] DivideByDiagonal(this double[][] a, double[] diagonal, int[][] result)
Parameters
Type Name Description
System.Double[][] a The left matrix A.
System.Double[] diagonal The diagonal vector of inverse right matrix B.
System.Int32[][] result The matrix R to store the product R = A*B of the given matrices A and B.
Returns
Type Description
System.Int32[][]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

DivideByDiagonal(Double[][], Double[])

Computes the product A*inv(B) of matrix A and diagonal matrix B.
Declaration
public static double[][] DivideByDiagonal(this double[][] a, double[] b)
Parameters
Type Name Description
System.Double[][] a The left matrix A.
System.Double[] b The diagonal vector of inverse right matrix B.
Returns
Type Description
System.Double[][] The product A*B of the given matrices A and B.
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

DivideByDiagonal(Double[][], Int32[], Double[][])

Computes the product A*inv(B) of matrix A and diagonal matrix B.
Declaration
public static double[][] DivideByDiagonal(this double[][] a, int[] diagonal, double[][] result)
Parameters
Type Name Description
System.Double[][] a The left matrix A.
System.Int32[] diagonal The diagonal vector of inverse right matrix B.
System.Double[][] result The matrix R to store the product R = A*B of the given matrices A and B.
Returns
Type Description
System.Double[][]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

DivideByDiagonal(Double[][], Int32[], Int32[][])

Computes the product A*inv(B) of matrix A and diagonal matrix B.
Declaration
public static int[][] DivideByDiagonal(this double[][] a, int[] diagonal, int[][] result)
Parameters
Type Name Description
System.Double[][] a The left matrix A.
System.Int32[] diagonal The diagonal vector of inverse right matrix B.
System.Int32[][] result The matrix R to store the product R = A*B of the given matrices A and B.
Returns
Type Description
System.Int32[][]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

DivideByDiagonal(Double[][], Int32[])

Computes the product A*inv(B) of matrix A and diagonal matrix B.
Declaration
public static double[][] DivideByDiagonal(this double[][] a, int[] b)
Parameters
Type Name Description
System.Double[][] a The left matrix A.
System.Int32[] b The diagonal vector of inverse right matrix B.
Returns
Type Description
System.Double[][] The product A*B of the given matrices A and B.
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

DivideByDiagonal(Double[,], Double[], Double[,])

Computes the product A*inv(B) of matrix A and diagonal matrix B.
Declaration
public static double[, ] DivideByDiagonal(this double[, ] a, double[] diagonal, double[, ] result)
Parameters
Type Name Description
System.Double[,] a The left matrix A.
System.Double[] diagonal The diagonal vector of inverse right matrix B.
System.Double[,] result The matrix R to store the product R = A*B of the given matrices A and B.
Returns
Type Description
System.Double[,]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

DivideByDiagonal(Double[,], Double[], Int32[,])

Computes the product A*inv(B) of matrix A and diagonal matrix B.
Declaration
public static int[, ] DivideByDiagonal(this double[, ] a, double[] diagonal, int[, ] result)
Parameters
Type Name Description
System.Double[,] a The left matrix A.
System.Double[] diagonal The diagonal vector of inverse right matrix B.
System.Int32[,] result The matrix R to store the product R = A*B of the given matrices A and B.
Returns
Type Description
System.Int32[,]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

DivideByDiagonal(Double[,], Double[])

Computes the product A*inv(B) of matrix A and diagonal matrix B.
Declaration
public static double[, ] DivideByDiagonal(this double[, ] a, double[] b)
Parameters
Type Name Description
System.Double[,] a The left matrix A.
System.Double[] b The diagonal vector of inverse right matrix B.
Returns
Type Description
System.Double[,] The product A*B of the given matrices A and B.
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

DivideByDiagonal(Double[,], Int32[], Double[,])

Computes the product A*inv(B) of matrix A and diagonal matrix B.
Declaration
public static double[, ] DivideByDiagonal(this double[, ] a, int[] diagonal, double[, ] result)
Parameters
Type Name Description
System.Double[,] a The left matrix A.
System.Int32[] diagonal The diagonal vector of inverse right matrix B.
System.Double[,] result The matrix R to store the product R = A*B of the given matrices A and B.
Returns
Type Description
System.Double[,]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

DivideByDiagonal(Double[,], Int32[], Int32[,])

Computes the product A*inv(B) of matrix A and diagonal matrix B.
Declaration
public static int[, ] DivideByDiagonal(this double[, ] a, int[] diagonal, int[, ] result)
Parameters
Type Name Description
System.Double[,] a The left matrix A.
System.Int32[] diagonal The diagonal vector of inverse right matrix B.
System.Int32[,] result The matrix R to store the product R = A*B of the given matrices A and B.
Returns
Type Description
System.Int32[,]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

DivideByDiagonal(Double[,], Int32[])

Computes the product A*inv(B) of matrix A and diagonal matrix B.
Declaration
public static double[, ] DivideByDiagonal(this double[, ] a, int[] b)
Parameters
Type Name Description
System.Double[,] a The left matrix A.
System.Int32[] b The diagonal vector of inverse right matrix B.
Returns
Type Description
System.Double[,] The product A*B of the given matrices A and B.
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

DivideByDiagonal(Int32[][], Double[], Double[][])

Computes the product A*inv(B) of matrix A and diagonal matrix B.
Declaration
public static double[][] DivideByDiagonal(this int[][] a, double[] diagonal, double[][] result)
Parameters
Type Name Description
System.Int32[][] a The left matrix A.
System.Double[] diagonal The diagonal vector of inverse right matrix B.
System.Double[][] result The matrix R to store the product R = A*B of the given matrices A and B.
Returns
Type Description
System.Double[][]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

DivideByDiagonal(Int32[][], Double[], Int32[][])

Computes the product A*inv(B) of matrix A and diagonal matrix B.
Declaration
public static int[][] DivideByDiagonal(this int[][] a, double[] diagonal, int[][] result)
Parameters
Type Name Description
System.Int32[][] a The left matrix A.
System.Double[] diagonal The diagonal vector of inverse right matrix B.
System.Int32[][] result The matrix R to store the product R = A*B of the given matrices A and B.
Returns
Type Description
System.Int32[][]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

DivideByDiagonal(Int32[][], Double[])

Computes the product A*inv(B) of matrix A and diagonal matrix B.
Declaration
public static double[][] DivideByDiagonal(this int[][] a, double[] b)
Parameters
Type Name Description
System.Int32[][] a The left matrix A.
System.Double[] b The diagonal vector of inverse right matrix B.
Returns
Type Description
System.Double[][] The product A*B of the given matrices A and B.
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

DivideByDiagonal(Int32[][], Int32[], Double[][])

Computes the product A*inv(B) of matrix A and diagonal matrix B.
Declaration
public static double[][] DivideByDiagonal(this int[][] a, int[] diagonal, double[][] result)
Parameters
Type Name Description
System.Int32[][] a The left matrix A.
System.Int32[] diagonal The diagonal vector of inverse right matrix B.
System.Double[][] result The matrix R to store the product R = A*B of the given matrices A and B.
Returns
Type Description
System.Double[][]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

DivideByDiagonal(Int32[][], Int32[], Int32[][])

Computes the product A*inv(B) of matrix A and diagonal matrix B.
Declaration
public static int[][] DivideByDiagonal(this int[][] a, int[] diagonal, int[][] result)
Parameters
Type Name Description
System.Int32[][] a The left matrix A.
System.Int32[] diagonal The diagonal vector of inverse right matrix B.
System.Int32[][] result The matrix R to store the product R = A*B of the given matrices A and B.
Returns
Type Description
System.Int32[][]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

DivideByDiagonal(Int32[][], Int32[])

Computes the product A*inv(B) of matrix A and diagonal matrix B.
Declaration
public static int[][] DivideByDiagonal(this int[][] a, int[] b)
Parameters
Type Name Description
System.Int32[][] a The left matrix A.
System.Int32[] b The diagonal vector of inverse right matrix B.
Returns
Type Description
System.Int32[][] The product A*B of the given matrices A and B.
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

DivideByDiagonal(Int32[,], Double[], Double[,])

Computes the product A*inv(B) of matrix A and diagonal matrix B.
Declaration
public static double[, ] DivideByDiagonal(this int[, ] a, double[] diagonal, double[, ] result)
Parameters
Type Name Description
System.Int32[,] a The left matrix A.
System.Double[] diagonal The diagonal vector of inverse right matrix B.
System.Double[,] result The matrix R to store the product R = A*B of the given matrices A and B.
Returns
Type Description
System.Double[,]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

DivideByDiagonal(Int32[,], Double[], Int32[,])

Computes the product A*inv(B) of matrix A and diagonal matrix B.
Declaration
public static int[, ] DivideByDiagonal(this int[, ] a, double[] diagonal, int[, ] result)
Parameters
Type Name Description
System.Int32[,] a The left matrix A.
System.Double[] diagonal The diagonal vector of inverse right matrix B.
System.Int32[,] result The matrix R to store the product R = A*B of the given matrices A and B.
Returns
Type Description
System.Int32[,]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

DivideByDiagonal(Int32[,], Double[])

Computes the product A*inv(B) of matrix A and diagonal matrix B.
Declaration
public static double[, ] DivideByDiagonal(this int[, ] a, double[] b)
Parameters
Type Name Description
System.Int32[,] a The left matrix A.
System.Double[] b The diagonal vector of inverse right matrix B.
Returns
Type Description
System.Double[,] The product A*B of the given matrices A and B.
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

DivideByDiagonal(Int32[,], Int32[], Double[,])

Computes the product A*inv(B) of matrix A and diagonal matrix B.
Declaration
public static double[, ] DivideByDiagonal(this int[, ] a, int[] diagonal, double[, ] result)
Parameters
Type Name Description
System.Int32[,] a The left matrix A.
System.Int32[] diagonal The diagonal vector of inverse right matrix B.
System.Double[,] result The matrix R to store the product R = A*B of the given matrices A and B.
Returns
Type Description
System.Double[,]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

DivideByDiagonal(Int32[,], Int32[], Int32[,])

Computes the product A*inv(B) of matrix A and diagonal matrix B.
Declaration
public static int[, ] DivideByDiagonal(this int[, ] a, int[] diagonal, int[, ] result)
Parameters
Type Name Description
System.Int32[,] a The left matrix A.
System.Int32[] diagonal The diagonal vector of inverse right matrix B.
System.Int32[,] result The matrix R to store the product R = A*B of the given matrices A and B.
Returns
Type Description
System.Int32[,]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

DivideByDiagonal(Int32[,], Int32[])

Computes the product A*inv(B) of matrix A and diagonal matrix B.
Declaration
public static int[, ] DivideByDiagonal(this int[, ] a, int[] b)
Parameters
Type Name Description
System.Int32[,] a The left matrix A.
System.Int32[] b The diagonal vector of inverse right matrix B.
Returns
Type Description
System.Int32[,] The product A*B of the given matrices A and B.
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Double[], Double[])

Gets the inner product (scalar product) between two vectors (a'*b).
Declaration
public static double Dot(this double[] a, double[] b)
Parameters
Type Name Description
System.Double[] a A vector.
System.Double[] b A vector.
Returns
Type Description
System.Double The inner product of the multiplication of the vectors.
Remarks

In mathematics, the dot product is an algebraic operation that takes two equal-length sequences of numbers (usually coordinate vectors) and returns a single number obtained by multiplying corresponding entries and adding up those products. The name is derived from the dot that is often used to designate this operation; the alternative name scalar product emphasizes the scalar (rather than vector) nature of the result.

The principal use of this product is the inner product in a Euclidean vector space: when two vectors are expressed on an orthonormal basis, the dot product of their coordinate vectors gives their inner product.

See Also
| Improve this Doc View Source

Dot(Double[], Double[][], Double[])

Computes the product R = A*B of two matrices A and B, storing the result in matrix R.
Declaration
public static double[] Dot(this double[] rowVector, double[][] matrix, double[] result)
Parameters
Type Name Description
System.Double[] rowVector The left matrix A.
System.Double[][] matrix The right matrix B.
System.Double[] result The matrix R to store the product.
Returns
Type Description
System.Double[]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Double[], Double[][], Int32[])

Computes the product R = A*B of two matrices A and B, storing the result in matrix R.
Declaration
public static int[] Dot(this double[] rowVector, double[][] matrix, int[] result)
Parameters
Type Name Description
System.Double[] rowVector The left matrix A.
System.Double[][] matrix The right matrix B.
System.Int32[] result The matrix R to store the product.
Returns
Type Description
System.Int32[]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Double[], Double[][])

Computes the product a*B of a row vector a and a matrix B.
Declaration
public static double[] Dot(this double[] rowVector, double[][] b)
Parameters
Type Name Description
System.Double[] rowVector The left vector a.
System.Double[][] b The right matrix B.
Returns
Type Description
System.Double[] The product a*B of the given vector a and B.
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Double[], Double[,], Double[])

Multiplies a row vector v and a matrix A, giving the product v'*A.
Declaration
public static double[] Dot(this double[] rowVector, double[, ] matrix, double[] result)
Parameters
Type Name Description
System.Double[] rowVector The row vector v.
System.Double[,] matrix The matrix A.
System.Double[] result The matrix R to store the product.
Returns
Type Description
System.Double[]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Double[], Double[,], Int32[])

Multiplies a row vector v and a matrix A, giving the product v'*A.
Declaration
public static int[] Dot(this double[] rowVector, double[, ] matrix, int[] result)
Parameters
Type Name Description
System.Double[] rowVector The row vector v.
System.Double[,] matrix The matrix A.
System.Int32[] result The matrix R to store the product.
Returns
Type Description
System.Int32[]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Double[], Double[,])

Computes the product a*B of a row vector a and a matrix B.
Declaration
public static double[] Dot(this double[] rowVector, double[, ] b)
Parameters
Type Name Description
System.Double[] rowVector The left vector a.
System.Double[,] b The right matrix B.
Returns
Type Description
System.Double[] The product a*B of the given vector a and B.
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Double[], Int32[])

Gets the inner product (scalar product) between two vectors (a'*b).
Declaration
public static double Dot(this double[] a, int[] b)
Parameters
Type Name Description
System.Double[] a A vector.
System.Int32[] b A vector.
Returns
Type Description
System.Double The inner product of the multiplication of the vectors.
Remarks

In mathematics, the dot product is an algebraic operation that takes two equal-length sequences of numbers (usually coordinate vectors) and returns a single number obtained by multiplying corresponding entries and adding up those products. The name is derived from the dot that is often used to designate this operation; the alternative name scalar product emphasizes the scalar (rather than vector) nature of the result.

The principal use of this product is the inner product in a Euclidean vector space: when two vectors are expressed on an orthonormal basis, the dot product of their coordinate vectors gives their inner product.

See Also
| Improve this Doc View Source

Dot(Double[], Int32[][], Double[])

Computes the product R = A*B of two matrices A and B, storing the result in matrix R.
Declaration
public static double[] Dot(this double[] rowVector, int[][] matrix, double[] result)
Parameters
Type Name Description
System.Double[] rowVector The left matrix A.
System.Int32[][] matrix The right matrix B.
System.Double[] result The matrix R to store the product.
Returns
Type Description
System.Double[]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Double[], Int32[][], Int32[])

Computes the product R = A*B of two matrices A and B, storing the result in matrix R.
Declaration
public static int[] Dot(this double[] rowVector, int[][] matrix, int[] result)
Parameters
Type Name Description
System.Double[] rowVector The left matrix A.
System.Int32[][] matrix The right matrix B.
System.Int32[] result The matrix R to store the product.
Returns
Type Description
System.Int32[]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Double[], Int32[][])

Computes the product a*B of a row vector a and a matrix B.
Declaration
public static double[] Dot(this double[] rowVector, int[][] b)
Parameters
Type Name Description
System.Double[] rowVector The left vector a.
System.Int32[][] b The right matrix B.
Returns
Type Description
System.Double[] The product a*B of the given vector a and B.
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Double[], Int32[,], Double[])

Multiplies a row vector v and a matrix A, giving the product v'*A.
Declaration
public static double[] Dot(this double[] rowVector, int[, ] matrix, double[] result)
Parameters
Type Name Description
System.Double[] rowVector The row vector v.
System.Int32[,] matrix The matrix A.
System.Double[] result The matrix R to store the product.
Returns
Type Description
System.Double[]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Double[], Int32[,], Int32[])

Multiplies a row vector v and a matrix A, giving the product v'*A.
Declaration
public static int[] Dot(this double[] rowVector, int[, ] matrix, int[] result)
Parameters
Type Name Description
System.Double[] rowVector The row vector v.
System.Int32[,] matrix The matrix A.
System.Int32[] result The matrix R to store the product.
Returns
Type Description
System.Int32[]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Double[], Int32[,])

Computes the product a*B of a row vector a and a matrix B.
Declaration
public static double[] Dot(this double[] rowVector, int[, ] b)
Parameters
Type Name Description
System.Double[] rowVector The left vector a.
System.Int32[,] b The right matrix B.
Returns
Type Description
System.Double[] The product a*B of the given vector a and B.
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Double[][], Double[], Double[])

Multiplies a matrix A and a column vector v, giving the product A*v
Declaration
public static double[] Dot(this double[][] matrix, double[] columnVector, double[] result)
Parameters
Type Name Description
System.Double[][] matrix The matrix A.
System.Double[] columnVector The column vector v.
System.Double[] result The matrix R to store the product.
Returns
Type Description
System.Double[]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Double[][], Double[], Int32[])

Multiplies a matrix A and a column vector v, giving the product A*v
Declaration
public static int[] Dot(this double[][] matrix, double[] columnVector, int[] result)
Parameters
Type Name Description
System.Double[][] matrix The matrix A.
System.Double[] columnVector The column vector v.
System.Int32[] result The matrix R to store the product.
Returns
Type Description
System.Int32[]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Double[][], Double[])

Computes the product A*b of a matrix A and a column vector b.
Declaration
public static double[] Dot(this double[][] a, double[] columnVector)
Parameters
Type Name Description
System.Double[][] a The left matrix A.
System.Double[] columnVector The right vector b.
Returns
Type Description
System.Double[] The product A*b of the given matrix A and vector b.
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Double[][], Double[][], Double[][])

Computes the product R = A*B of two matrices A and B, storing the result in matrix R.
Declaration
public static double[][] Dot(this double[][] a, double[][] b, double[][] result)
Parameters
Type Name Description
System.Double[][] a The left matrix A.
System.Double[][] b The right matrix B.
System.Double[][] result The matrix R to store the product.
Returns
Type Description
System.Double[][]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Double[][], Double[][], Int32[][])

Computes the product R = A*B of two matrices A and B, storing the result in matrix R.
Declaration
public static int[][] Dot(this double[][] a, double[][] b, int[][] result)
Parameters
Type Name Description
System.Double[][] a The left matrix A.
System.Double[][] b The right matrix B.
System.Int32[][] result The matrix R to store the product.
Returns
Type Description
System.Int32[][]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Double[][], Double[][])

Computes the product A*B of two matrices A and B.
Declaration
public static double[][] Dot(this double[][] a, double[][] b)
Parameters
Type Name Description
System.Double[][] a The left matrix A.
System.Double[][] b The right matrix B.
Returns
Type Description
System.Double[][] The product A*B of the given matrices A and B.
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Double[][], Double[,], Double[][])

Computes the product R = A*B of two matrices A and B, storing the result in matrix R.
Declaration
public static double[][] Dot(this double[][] a, double[, ] b, double[][] result)
Parameters
Type Name Description
System.Double[][] a The left matrix A.
System.Double[,] b The right matrix B.
System.Double[][] result The matrix R to store the product.
Returns
Type Description
System.Double[][]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Double[][], Double[,], Int32[][])

Computes the product R = A*B of two matrices A and B, storing the result in matrix R.
Declaration
public static int[][] Dot(this double[][] a, double[, ] b, int[][] result)
Parameters
Type Name Description
System.Double[][] a The left matrix A.
System.Double[,] b The right matrix B.
System.Int32[][] result The matrix R to store the product.
Returns
Type Description
System.Int32[][]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Double[][], Double[,])

Computes the product A*B of two matrices A and B.
Declaration
public static double[][] Dot(this double[][] a, double[, ] b)
Parameters
Type Name Description
System.Double[][] a The left matrix A.
System.Double[,] b The right matrix B.
Returns
Type Description
System.Double[][] The product A*B of the given matrices A and B.
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Double[][], Int32[], Double[])

Multiplies a matrix A and a column vector v, giving the product A*v
Declaration
public static double[] Dot(this double[][] matrix, int[] columnVector, double[] result)
Parameters
Type Name Description
System.Double[][] matrix The matrix A.
System.Int32[] columnVector The column vector v.
System.Double[] result The matrix R to store the product.
Returns
Type Description
System.Double[]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Double[][], Int32[], Int32[])

Multiplies a matrix A and a column vector v, giving the product A*v
Declaration
public static int[] Dot(this double[][] matrix, int[] columnVector, int[] result)
Parameters
Type Name Description
System.Double[][] matrix The matrix A.
System.Int32[] columnVector The column vector v.
System.Int32[] result The matrix R to store the product.
Returns
Type Description
System.Int32[]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Double[][], Int32[])

Computes the product A*b of a matrix A and a column vector b.
Declaration
public static double[] Dot(this double[][] a, int[] columnVector)
Parameters
Type Name Description
System.Double[][] a The left matrix A.
System.Int32[] columnVector The right vector b.
Returns
Type Description
System.Double[] The product A*b of the given matrix A and vector b.
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Double[][], Int32[][], Double[][])

Computes the product R = A*B of two matrices A and B, storing the result in matrix R.
Declaration
public static double[][] Dot(this double[][] a, int[][] b, double[][] result)
Parameters
Type Name Description
System.Double[][] a The left matrix A.
System.Int32[][] b The right matrix B.
System.Double[][] result The matrix R to store the product.
Returns
Type Description
System.Double[][]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Double[][], Int32[][], Int32[][])

Computes the product R = A*B of two matrices A and B, storing the result in matrix R.
Declaration
public static int[][] Dot(this double[][] a, int[][] b, int[][] result)
Parameters
Type Name Description
System.Double[][] a The left matrix A.
System.Int32[][] b The right matrix B.
System.Int32[][] result The matrix R to store the product.
Returns
Type Description
System.Int32[][]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Double[][], Int32[][])

Computes the product A*B of two matrices A and B.
Declaration
public static double[][] Dot(this double[][] a, int[][] b)
Parameters
Type Name Description
System.Double[][] a The left matrix A.
System.Int32[][] b The right matrix B.
Returns
Type Description
System.Double[][] The product A*B of the given matrices A and B.
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Double[][], Int32[,], Double[][])

Computes the product R = A*B of two matrices A and B, storing the result in matrix R.
Declaration
public static double[][] Dot(this double[][] a, int[, ] b, double[][] result)
Parameters
Type Name Description
System.Double[][] a The left matrix A.
System.Int32[,] b The right matrix B.
System.Double[][] result The matrix R to store the product.
Returns
Type Description
System.Double[][]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Double[][], Int32[,], Int32[][])

Computes the product R = A*B of two matrices A and B, storing the result in matrix R.
Declaration
public static int[][] Dot(this double[][] a, int[, ] b, int[][] result)
Parameters
Type Name Description
System.Double[][] a The left matrix A.
System.Int32[,] b The right matrix B.
System.Int32[][] result The matrix R to store the product.
Returns
Type Description
System.Int32[][]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Double[][], Int32[,])

Computes the product A*B of two matrices A and B.
Declaration
public static double[][] Dot(this double[][] a, int[, ] b)
Parameters
Type Name Description
System.Double[][] a The left matrix A.
System.Int32[,] b The right matrix B.
Returns
Type Description
System.Double[][] The product A*B of the given matrices A and B.
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Double[,], Double[], Double[])

Multiplies a matrix A and a column vector v, giving the product A*v
Declaration
public static double[] Dot(this double[, ] matrix, double[] columnVector, double[] result)
Parameters
Type Name Description
System.Double[,] matrix The matrix A.
System.Double[] columnVector The column vector v.
System.Double[] result The matrix R to store the product.
Returns
Type Description
System.Double[]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Double[,], Double[], Int32[])

Multiplies a matrix A and a column vector v, giving the product A*v
Declaration
public static int[] Dot(this double[, ] matrix, double[] columnVector, int[] result)
Parameters
Type Name Description
System.Double[,] matrix The matrix A.
System.Double[] columnVector The column vector v.
System.Int32[] result The matrix R to store the product.
Returns
Type Description
System.Int32[]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Double[,], Double[])

Computes the product A*b of a matrix A and a column vector b.
Declaration
public static double[] Dot(this double[, ] a, double[] columnVector)
Parameters
Type Name Description
System.Double[,] a The left matrix A.
System.Double[] columnVector The right vector b.
Returns
Type Description
System.Double[] The product A*b of the given matrix A and vector b.
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Double[,], Double[][], Double[][])

Computes the product R = A*B of two matrices A and B, storing the result in matrix R.
Declaration
public static double[][] Dot(this double[, ] a, double[][] b, double[][] result)
Parameters
Type Name Description
System.Double[,] a The left matrix A.
System.Double[][] b The right matrix B.
System.Double[][] result The matrix R to store the product.
Returns
Type Description
System.Double[][]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Double[,], Double[][], Int32[][])

Computes the product R = A*B of two matrices A and B, storing the result in matrix R.
Declaration
public static int[][] Dot(this double[, ] a, double[][] b, int[][] result)
Parameters
Type Name Description
System.Double[,] a The left matrix A.
System.Double[][] b The right matrix B.
System.Int32[][] result The matrix R to store the product.
Returns
Type Description
System.Int32[][]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Double[,], Double[][])

Computes the product A*B of two matrices A and B.
Declaration
public static double[][] Dot(this double[, ] a, double[][] b)
Parameters
Type Name Description
System.Double[,] a The left matrix A.
System.Double[][] b The right matrix B.
Returns
Type Description
System.Double[][] The product A*B of the given matrices A and B.
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Double[,], Double[,], Double[,])

Computes the product R = A*B of two matrices A and B, storing the result in matrix R.
Declaration
public static double[, ] Dot(this double[, ] a, double[, ] b, double[, ] result)
Parameters
Type Name Description
System.Double[,] a The left matrix A.
System.Double[,] b The right matrix B.
System.Double[,] result The matrix R to store the product R = A*B of the given matrices A and B.
Returns
Type Description
System.Double[,]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Double[,], Double[,], Int32[,])

Computes the product R = A*B of two matrices A and B, storing the result in matrix R.
Declaration
public static int[, ] Dot(this double[, ] a, double[, ] b, int[, ] result)
Parameters
Type Name Description
System.Double[,] a The left matrix A.
System.Double[,] b The right matrix B.
System.Int32[,] result The matrix R to store the product R = A*B of the given matrices A and B.
Returns
Type Description
System.Int32[,]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Double[,], Double[,])

Computes the product A*B of two matrices A and B.
Declaration
public static double[, ] Dot(this double[, ] a, double[, ] b)
Parameters
Type Name Description
System.Double[,] a The left matrix A.
System.Double[,] b The right matrix B.
Returns
Type Description
System.Double[,] The product A*B of the given matrices A and B.
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Double[,], Int32[], Double[])

Multiplies a matrix A and a column vector v, giving the product A*v
Declaration
public static double[] Dot(this double[, ] matrix, int[] columnVector, double[] result)
Parameters
Type Name Description
System.Double[,] matrix The matrix A.
System.Int32[] columnVector The column vector v.
System.Double[] result The matrix R to store the product.
Returns
Type Description
System.Double[]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Double[,], Int32[], Int32[])

Multiplies a matrix A and a column vector v, giving the product A*v
Declaration
public static int[] Dot(this double[, ] matrix, int[] columnVector, int[] result)
Parameters
Type Name Description
System.Double[,] matrix The matrix A.
System.Int32[] columnVector The column vector v.
System.Int32[] result The matrix R to store the product.
Returns
Type Description
System.Int32[]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Double[,], Int32[])

Computes the product A*b of a matrix A and a column vector b.
Declaration
public static double[] Dot(this double[, ] a, int[] columnVector)
Parameters
Type Name Description
System.Double[,] a The left matrix A.
System.Int32[] columnVector The right vector b.
Returns
Type Description
System.Double[] The product A*b of the given matrix A and vector b.
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Double[,], Int32[][], Double[][])

Computes the product R = A*B of two matrices A and B, storing the result in matrix R.
Declaration
public static double[][] Dot(this double[, ] a, int[][] b, double[][] result)
Parameters
Type Name Description
System.Double[,] a The left matrix A.
System.Int32[][] b The right matrix B.
System.Double[][] result The matrix R to store the product.
Returns
Type Description
System.Double[][]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Double[,], Int32[][], Int32[][])

Computes the product R = A*B of two matrices A and B, storing the result in matrix R.
Declaration
public static int[][] Dot(this double[, ] a, int[][] b, int[][] result)
Parameters
Type Name Description
System.Double[,] a The left matrix A.
System.Int32[][] b The right matrix B.
System.Int32[][] result The matrix R to store the product.
Returns
Type Description
System.Int32[][]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Double[,], Int32[][])

Computes the product A*B of two matrices A and B.
Declaration
public static double[][] Dot(this double[, ] a, int[][] b)
Parameters
Type Name Description
System.Double[,] a The left matrix A.
System.Int32[][] b The right matrix B.
Returns
Type Description
System.Double[][] The product A*B of the given matrices A and B.
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Double[,], Int32[,], Double[,])

Computes the product R = A*B of two matrices A and B, storing the result in matrix R.
Declaration
public static double[, ] Dot(this double[, ] a, int[, ] b, double[, ] result)
Parameters
Type Name Description
System.Double[,] a The left matrix A.
System.Int32[,] b The right matrix B.
System.Double[,] result The matrix R to store the product R = A*B of the given matrices A and B.
Returns
Type Description
System.Double[,]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Double[,], Int32[,], Int32[,])

Computes the product R = A*B of two matrices A and B, storing the result in matrix R.
Declaration
public static int[, ] Dot(this double[, ] a, int[, ] b, int[, ] result)
Parameters
Type Name Description
System.Double[,] a The left matrix A.
System.Int32[,] b The right matrix B.
System.Int32[,] result The matrix R to store the product R = A*B of the given matrices A and B.
Returns
Type Description
System.Int32[,]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Double[,], Int32[,])

Computes the product A*B of two matrices A and B.
Declaration
public static double[, ] Dot(this double[, ] a, int[, ] b)
Parameters
Type Name Description
System.Double[,] a The left matrix A.
System.Int32[,] b The right matrix B.
Returns
Type Description
System.Double[,] The product A*B of the given matrices A and B.
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Int32[], Double[])

Gets the inner product (scalar product) between two vectors (a'*b).
Declaration
public static double Dot(this int[] a, double[] b)
Parameters
Type Name Description
System.Int32[] a A vector.
System.Double[] b A vector.
Returns
Type Description
System.Double The inner product of the multiplication of the vectors.
Remarks

In mathematics, the dot product is an algebraic operation that takes two equal-length sequences of numbers (usually coordinate vectors) and returns a single number obtained by multiplying corresponding entries and adding up those products. The name is derived from the dot that is often used to designate this operation; the alternative name scalar product emphasizes the scalar (rather than vector) nature of the result.

The principal use of this product is the inner product in a Euclidean vector space: when two vectors are expressed on an orthonormal basis, the dot product of their coordinate vectors gives their inner product.

See Also
| Improve this Doc View Source

Dot(Int32[], Double[][], Double[])

Computes the product R = A*B of two matrices A and B, storing the result in matrix R.
Declaration
public static double[] Dot(this int[] rowVector, double[][] matrix, double[] result)
Parameters
Type Name Description
System.Int32[] rowVector The left matrix A.
System.Double[][] matrix The right matrix B.
System.Double[] result The matrix R to store the product.
Returns
Type Description
System.Double[]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Int32[], Double[][], Int32[])

Computes the product R = A*B of two matrices A and B, storing the result in matrix R.
Declaration
public static int[] Dot(this int[] rowVector, double[][] matrix, int[] result)
Parameters
Type Name Description
System.Int32[] rowVector The left matrix A.
System.Double[][] matrix The right matrix B.
System.Int32[] result The matrix R to store the product.
Returns
Type Description
System.Int32[]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Int32[], Double[][])

Computes the product a*B of a row vector a and a matrix B.
Declaration
public static double[] Dot(this int[] rowVector, double[][] b)
Parameters
Type Name Description
System.Int32[] rowVector The left vector a.
System.Double[][] b The right matrix B.
Returns
Type Description
System.Double[] The product a*B of the given vector a and B.
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Int32[], Double[,], Double[])

Multiplies a row vector v and a matrix A, giving the product v'*A.
Declaration
public static double[] Dot(this int[] rowVector, double[, ] matrix, double[] result)
Parameters
Type Name Description
System.Int32[] rowVector The row vector v.
System.Double[,] matrix The matrix A.
System.Double[] result The matrix R to store the product.
Returns
Type Description
System.Double[]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Int32[], Double[,], Int32[])

Multiplies a row vector v and a matrix A, giving the product v'*A.
Declaration
public static int[] Dot(this int[] rowVector, double[, ] matrix, int[] result)
Parameters
Type Name Description
System.Int32[] rowVector The row vector v.
System.Double[,] matrix The matrix A.
System.Int32[] result The matrix R to store the product.
Returns
Type Description
System.Int32[]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Int32[], Double[,])

Computes the product a*B of a row vector a and a matrix B.
Declaration
public static double[] Dot(this int[] rowVector, double[, ] b)
Parameters
Type Name Description
System.Int32[] rowVector The left vector a.
System.Double[,] b The right matrix B.
Returns
Type Description
System.Double[] The product a*B of the given vector a and B.
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Int32[], Int32[])

Gets the inner product (scalar product) between two vectors (a'*b).
Declaration
public static int Dot(this int[] a, int[] b)
Parameters
Type Name Description
System.Int32[] a A vector.
System.Int32[] b A vector.
Returns
Type Description
System.Int32 The inner product of the multiplication of the vectors.
Remarks

In mathematics, the dot product is an algebraic operation that takes two equal-length sequences of numbers (usually coordinate vectors) and returns a single number obtained by multiplying corresponding entries and adding up those products. The name is derived from the dot that is often used to designate this operation; the alternative name scalar product emphasizes the scalar (rather than vector) nature of the result.

The principal use of this product is the inner product in a Euclidean vector space: when two vectors are expressed on an orthonormal basis, the dot product of their coordinate vectors gives their inner product.

See Also
| Improve this Doc View Source

Dot(Int32[], Int32[][], Double[])

Computes the product R = A*B of two matrices A and B, storing the result in matrix R.
Declaration
public static double[] Dot(this int[] rowVector, int[][] matrix, double[] result)
Parameters
Type Name Description
System.Int32[] rowVector The left matrix A.
System.Int32[][] matrix The right matrix B.
System.Double[] result The matrix R to store the product.
Returns
Type Description
System.Double[]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Int32[], Int32[][], Int32[])

Computes the product R = A*B of two matrices A and B, storing the result in matrix R.
Declaration
public static int[] Dot(this int[] rowVector, int[][] matrix, int[] result)
Parameters
Type Name Description
System.Int32[] rowVector The left matrix A.
System.Int32[][] matrix The right matrix B.
System.Int32[] result The matrix R to store the product.
Returns
Type Description
System.Int32[]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Int32[], Int32[][])

Computes the product a*B of a row vector a and a matrix B.
Declaration
public static int[] Dot(this int[] rowVector, int[][] b)
Parameters
Type Name Description
System.Int32[] rowVector The left vector a.
System.Int32[][] b The right matrix B.
Returns
Type Description
System.Int32[] The product a*B of the given vector a and B.
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Int32[], Int32[,], Double[])

Multiplies a row vector v and a matrix A, giving the product v'*A.
Declaration
public static double[] Dot(this int[] rowVector, int[, ] matrix, double[] result)
Parameters
Type Name Description
System.Int32[] rowVector The row vector v.
System.Int32[,] matrix The matrix A.
System.Double[] result The matrix R to store the product.
Returns
Type Description
System.Double[]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Int32[], Int32[,], Int32[])

Multiplies a row vector v and a matrix A, giving the product v'*A.
Declaration
public static int[] Dot(this int[] rowVector, int[, ] matrix, int[] result)
Parameters
Type Name Description
System.Int32[] rowVector The row vector v.
System.Int32[,] matrix The matrix A.
System.Int32[] result The matrix R to store the product.
Returns
Type Description
System.Int32[]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Int32[], Int32[,])

Computes the product a*B of a row vector a and a matrix B.
Declaration
public static int[] Dot(this int[] rowVector, int[, ] b)
Parameters
Type Name Description
System.Int32[] rowVector The left vector a.
System.Int32[,] b The right matrix B.
Returns
Type Description
System.Int32[] The product a*B of the given vector a and B.
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Int32[][], Double[], Double[])

Multiplies a matrix A and a column vector v, giving the product A*v
Declaration
public static double[] Dot(this int[][] matrix, double[] columnVector, double[] result)
Parameters
Type Name Description
System.Int32[][] matrix The matrix A.
System.Double[] columnVector The column vector v.
System.Double[] result The matrix R to store the product.
Returns
Type Description
System.Double[]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Int32[][], Double[], Int32[])

Multiplies a matrix A and a column vector v, giving the product A*v
Declaration
public static int[] Dot(this int[][] matrix, double[] columnVector, int[] result)
Parameters
Type Name Description
System.Int32[][] matrix The matrix A.
System.Double[] columnVector The column vector v.
System.Int32[] result The matrix R to store the product.
Returns
Type Description
System.Int32[]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Int32[][], Double[])

Computes the product A*b of a matrix A and a column vector b.
Declaration
public static double[] Dot(this int[][] a, double[] columnVector)
Parameters
Type Name Description
System.Int32[][] a The left matrix A.
System.Double[] columnVector The right vector b.
Returns
Type Description
System.Double[] The product A*b of the given matrix A and vector b.
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Int32[][], Double[][], Double[][])

Computes the product R = A*B of two matrices A and B, storing the result in matrix R.
Declaration
public static double[][] Dot(this int[][] a, double[][] b, double[][] result)
Parameters
Type Name Description
System.Int32[][] a The left matrix A.
System.Double[][] b The right matrix B.
System.Double[][] result The matrix R to store the product.
Returns
Type Description
System.Double[][]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Int32[][], Double[][], Int32[][])

Computes the product R = A*B of two matrices A and B, storing the result in matrix R.
Declaration
public static int[][] Dot(this int[][] a, double[][] b, int[][] result)
Parameters
Type Name Description
System.Int32[][] a The left matrix A.
System.Double[][] b The right matrix B.
System.Int32[][] result The matrix R to store the product.
Returns
Type Description
System.Int32[][]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Int32[][], Double[][])

Computes the product A*B of two matrices A and B.
Declaration
public static double[][] Dot(this int[][] a, double[][] b)
Parameters
Type Name Description
System.Int32[][] a The left matrix A.
System.Double[][] b The right matrix B.
Returns
Type Description
System.Double[][] The product A*B of the given matrices A and B.
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Int32[][], Double[,], Double[][])

Computes the product R = A*B of two matrices A and B, storing the result in matrix R.
Declaration
public static double[][] Dot(this int[][] a, double[, ] b, double[][] result)
Parameters
Type Name Description
System.Int32[][] a The left matrix A.
System.Double[,] b The right matrix B.
System.Double[][] result The matrix R to store the product.
Returns
Type Description
System.Double[][]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Int32[][], Double[,], Int32[][])

Computes the product R = A*B of two matrices A and B, storing the result in matrix R.
Declaration
public static int[][] Dot(this int[][] a, double[, ] b, int[][] result)
Parameters
Type Name Description
System.Int32[][] a The left matrix A.
System.Double[,] b The right matrix B.
System.Int32[][] result The matrix R to store the product.
Returns
Type Description
System.Int32[][]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Int32[][], Double[,])

Computes the product A*B of two matrices A and B.
Declaration
public static double[][] Dot(this int[][] a, double[, ] b)
Parameters
Type Name Description
System.Int32[][] a The left matrix A.
System.Double[,] b The right matrix B.
Returns
Type Description
System.Double[][] The product A*B of the given matrices A and B.
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Int32[][], Int32[], Double[])

Multiplies a matrix A and a column vector v, giving the product A*v
Declaration
public static double[] Dot(this int[][] matrix, int[] columnVector, double[] result)
Parameters
Type Name Description
System.Int32[][] matrix The matrix A.
System.Int32[] columnVector The column vector v.
System.Double[] result The matrix R to store the product.
Returns
Type Description
System.Double[]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Int32[][], Int32[], Int32[])

Multiplies a matrix A and a column vector v, giving the product A*v
Declaration
public static int[] Dot(this int[][] matrix, int[] columnVector, int[] result)
Parameters
Type Name Description
System.Int32[][] matrix The matrix A.
System.Int32[] columnVector The column vector v.
System.Int32[] result The matrix R to store the product.
Returns
Type Description
System.Int32[]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Int32[][], Int32[])

Computes the product A*b of a matrix A and a column vector b.
Declaration
public static int[] Dot(this int[][] a, int[] columnVector)
Parameters
Type Name Description
System.Int32[][] a The left matrix A.
System.Int32[] columnVector The right vector b.
Returns
Type Description
System.Int32[] The product A*b of the given matrix A and vector b.
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Int32[][], Int32[][], Double[][])

Computes the product R = A*B of two matrices A and B, storing the result in matrix R.
Declaration
public static double[][] Dot(this int[][] a, int[][] b, double[][] result)
Parameters
Type Name Description
System.Int32[][] a The left matrix A.
System.Int32[][] b The right matrix B.
System.Double[][] result The matrix R to store the product.
Returns
Type Description
System.Double[][]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Int32[][], Int32[][], Int32[][])

Computes the product R = A*B of two matrices A and B, storing the result in matrix R.
Declaration
public static int[][] Dot(this int[][] a, int[][] b, int[][] result)
Parameters
Type Name Description
System.Int32[][] a The left matrix A.
System.Int32[][] b The right matrix B.
System.Int32[][] result The matrix R to store the product.
Returns
Type Description
System.Int32[][]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Int32[][], Int32[][])

Computes the product A*B of two matrices A and B.
Declaration
public static int[][] Dot(this int[][] a, int[][] b)
Parameters
Type Name Description
System.Int32[][] a The left matrix A.
System.Int32[][] b The right matrix B.
Returns
Type Description
System.Int32[][] The product A*B of the given matrices A and B.
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Int32[][], Int32[,], Double[][])

Computes the product R = A*B of two matrices A and B, storing the result in matrix R.
Declaration
public static double[][] Dot(this int[][] a, int[, ] b, double[][] result)
Parameters
Type Name Description
System.Int32[][] a The left matrix A.
System.Int32[,] b The right matrix B.
System.Double[][] result The matrix R to store the product.
Returns
Type Description
System.Double[][]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Int32[][], Int32[,], Int32[][])

Computes the product R = A*B of two matrices A and B, storing the result in matrix R.
Declaration
public static int[][] Dot(this int[][] a, int[, ] b, int[][] result)
Parameters
Type Name Description
System.Int32[][] a The left matrix A.
System.Int32[,] b The right matrix B.
System.Int32[][] result The matrix R to store the product.
Returns
Type Description
System.Int32[][]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Int32[][], Int32[,])

Computes the product A*B of two matrices A and B.
Declaration
public static int[][] Dot(this int[][] a, int[, ] b)
Parameters
Type Name Description
System.Int32[][] a The left matrix A.
System.Int32[,] b The right matrix B.
Returns
Type Description
System.Int32[][] The product A*B of the given matrices A and B.
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Int32[,], Double[], Double[])

Multiplies a matrix A and a column vector v, giving the product A*v
Declaration
public static double[] Dot(this int[, ] matrix, double[] columnVector, double[] result)
Parameters
Type Name Description
System.Int32[,] matrix The matrix A.
System.Double[] columnVector The column vector v.
System.Double[] result The matrix R to store the product.
Returns
Type Description
System.Double[]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Int32[,], Double[], Int32[])

Multiplies a matrix A and a column vector v, giving the product A*v
Declaration
public static int[] Dot(this int[, ] matrix, double[] columnVector, int[] result)
Parameters
Type Name Description
System.Int32[,] matrix The matrix A.
System.Double[] columnVector The column vector v.
System.Int32[] result The matrix R to store the product.
Returns
Type Description
System.Int32[]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Int32[,], Double[])

Computes the product A*b of a matrix A and a column vector b.
Declaration
public static double[] Dot(this int[, ] a, double[] columnVector)
Parameters
Type Name Description
System.Int32[,] a The left matrix A.
System.Double[] columnVector The right vector b.
Returns
Type Description
System.Double[] The product A*b of the given matrix A and vector b.
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Int32[,], Double[][], Double[][])

Computes the product R = A*B of two matrices A and B, storing the result in matrix R.
Declaration
public static double[][] Dot(this int[, ] a, double[][] b, double[][] result)
Parameters
Type Name Description
System.Int32[,] a The left matrix A.
System.Double[][] b The right matrix B.
System.Double[][] result The matrix R to store the product.
Returns
Type Description
System.Double[][]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Int32[,], Double[][], Int32[][])

Computes the product R = A*B of two matrices A and B, storing the result in matrix R.
Declaration
public static int[][] Dot(this int[, ] a, double[][] b, int[][] result)
Parameters
Type Name Description
System.Int32[,] a The left matrix A.
System.Double[][] b The right matrix B.
System.Int32[][] result The matrix R to store the product.
Returns
Type Description
System.Int32[][]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Int32[,], Double[][])

Computes the product A*B of two matrices A and B.
Declaration
public static double[][] Dot(this int[, ] a, double[][] b)
Parameters
Type Name Description
System.Int32[,] a The left matrix A.
System.Double[][] b The right matrix B.
Returns
Type Description
System.Double[][] The product A*B of the given matrices A and B.
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Int32[,], Double[,], Double[,])

Computes the product R = A*B of two matrices A and B, storing the result in matrix R.
Declaration
public static double[, ] Dot(this int[, ] a, double[, ] b, double[, ] result)
Parameters
Type Name Description
System.Int32[,] a The left matrix A.
System.Double[,] b The right matrix B.
System.Double[,] result The matrix R to store the product R = A*B of the given matrices A and B.
Returns
Type Description
System.Double[,]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Int32[,], Double[,], Int32[,])

Computes the product R = A*B of two matrices A and B, storing the result in matrix R.
Declaration
public static int[, ] Dot(this int[, ] a, double[, ] b, int[, ] result)
Parameters
Type Name Description
System.Int32[,] a The left matrix A.
System.Double[,] b The right matrix B.
System.Int32[,] result The matrix R to store the product R = A*B of the given matrices A and B.
Returns
Type Description
System.Int32[,]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Int32[,], Double[,])

Computes the product A*B of two matrices A and B.
Declaration
public static double[, ] Dot(this int[, ] a, double[, ] b)
Parameters
Type Name Description
System.Int32[,] a The left matrix A.
System.Double[,] b The right matrix B.
Returns
Type Description
System.Double[,] The product A*B of the given matrices A and B.
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Int32[,], Int32[], Double[])

Multiplies a matrix A and a column vector v, giving the product A*v
Declaration
public static double[] Dot(this int[, ] matrix, int[] columnVector, double[] result)
Parameters
Type Name Description
System.Int32[,] matrix The matrix A.
System.Int32[] columnVector The column vector v.
System.Double[] result The matrix R to store the product.
Returns
Type Description
System.Double[]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Int32[,], Int32[], Int32[])

Multiplies a matrix A and a column vector v, giving the product A*v
Declaration
public static int[] Dot(this int[, ] matrix, int[] columnVector, int[] result)
Parameters
Type Name Description
System.Int32[,] matrix The matrix A.
System.Int32[] columnVector The column vector v.
System.Int32[] result The matrix R to store the product.
Returns
Type Description
System.Int32[]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Int32[,], Int32[])

Computes the product A*b of a matrix A and a column vector b.
Declaration
public static int[] Dot(this int[, ] a, int[] columnVector)
Parameters
Type Name Description
System.Int32[,] a The left matrix A.
System.Int32[] columnVector The right vector b.
Returns
Type Description
System.Int32[] The product A*b of the given matrix A and vector b.
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Int32[,], Int32[][], Double[][])

Computes the product R = A*B of two matrices A and B, storing the result in matrix R.
Declaration
public static double[][] Dot(this int[, ] a, int[][] b, double[][] result)
Parameters
Type Name Description
System.Int32[,] a The left matrix A.
System.Int32[][] b The right matrix B.
System.Double[][] result The matrix R to store the product.
Returns
Type Description
System.Double[][]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Int32[,], Int32[][], Int32[][])

Computes the product R = A*B of two matrices A and B, storing the result in matrix R.
Declaration
public static int[][] Dot(this int[, ] a, int[][] b, int[][] result)
Parameters
Type Name Description
System.Int32[,] a The left matrix A.
System.Int32[][] b The right matrix B.
System.Int32[][] result The matrix R to store the product.
Returns
Type Description
System.Int32[][]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Int32[,], Int32[][])

Computes the product A*B of two matrices A and B.
Declaration
public static int[][] Dot(this int[, ] a, int[][] b)
Parameters
Type Name Description
System.Int32[,] a The left matrix A.
System.Int32[][] b The right matrix B.
Returns
Type Description
System.Int32[][] The product A*B of the given matrices A and B.
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Int32[,], Int32[,], Double[,])

Computes the product R = A*B of two matrices A and B, storing the result in matrix R.
Declaration
public static double[, ] Dot(this int[, ] a, int[, ] b, double[, ] result)
Parameters
Type Name Description
System.Int32[,] a The left matrix A.
System.Int32[,] b The right matrix B.
System.Double[,] result The matrix R to store the product R = A*B of the given matrices A and B.
Returns
Type Description
System.Double[,]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Int32[,], Int32[,], Int32[,])

Computes the product R = A*B of two matrices A and B, storing the result in matrix R.
Declaration
public static int[, ] Dot(this int[, ] a, int[, ] b, int[, ] result)
Parameters
Type Name Description
System.Int32[,] a The left matrix A.
System.Int32[,] b The right matrix B.
System.Int32[,] result The matrix R to store the product R = A*B of the given matrices A and B.
Returns
Type Description
System.Int32[,]
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

Dot(Int32[,], Int32[,])

Computes the product A*B of two matrices A and B.
Declaration
public static int[, ] Dot(this int[, ] a, int[, ] b)
Parameters
Type Name Description
System.Int32[,] a The left matrix A.
System.Int32[,] b The right matrix B.
Returns
Type Description
System.Int32[,] The product A*B of the given matrices A and B.
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

DotAndDot(Double[], Double[][], Double[])

Computes the product a*B*c of a row vector a, a square matrix B and a column vector c.
Declaration
public static double DotAndDot(this double[] rowVector, double[][] matrix, double[] columnVector)
Parameters
Type Name Description
System.Double[] rowVector The left vector a.
System.Double[][] matrix The square matrix B.
System.Double[] columnVector The column vector c.
Returns
Type Description
System.Double The product a*B*c of the given vector a, matrix B and vector c.
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

DotAndDot(Double[], Double[][], Int32[])

Computes the product a*B*c of a row vector a, a square matrix B and a column vector c.
Declaration
public static int DotAndDot(this double[] rowVector, double[][] matrix, int[] columnVector)
Parameters
Type Name Description
System.Double[] rowVector The left vector a.
System.Double[][] matrix The square matrix B.
System.Int32[] columnVector The column vector c.
Returns
Type Description
System.Int32 The product a*B*c of the given vector a, matrix B and vector c.
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

DotAndDot(Double[], Double[,], Double[])

Computes the product a*B*c of a row vector a, a square matrix B and a column vector c.
Declaration
public static double DotAndDot(this double[] rowVector, double[, ] matrix, double[] columnVector)
Parameters
Type Name Description
System.Double[] rowVector The left vector a.
System.Double[,] matrix The square matrix B.
System.Double[] columnVector The column vector c.
Returns
Type Description
System.Double The product a*B*c of the given vector a, matrix B and vector c.
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

DotAndDot(Double[], Double[,], Int32[])

Computes the product a*B*c of a row vector a, a square matrix B and a column vector c.
Declaration
public static int DotAndDot(this double[] rowVector, double[, ] matrix, int[] columnVector)
Parameters
Type Name Description
System.Double[] rowVector The left vector a.
System.Double[,] matrix The square matrix B.
System.Int32[] columnVector The column vector c.
Returns
Type Description
System.Int32 The product a*B*c of the given vector a, matrix B and vector c.
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

DotAndDot(Double[], Int32[][], Double[])

Computes the product a*B*c of a row vector a, a square matrix B and a column vector c.
Declaration
public static double DotAndDot(this double[] rowVector, int[][] matrix, double[] columnVector)
Parameters
Type Name Description
System.Double[] rowVector The left vector a.
System.Int32[][] matrix The square matrix B.
System.Double[] columnVector The column vector c.
Returns
Type Description
System.Double The product a*B*c of the given vector a, matrix B and vector c.
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

DotAndDot(Double[], Int32[][], Int32[])

Computes the product a*B*c of a row vector a, a square matrix B and a column vector c.
Declaration
public static int DotAndDot(this double[] rowVector, int[][] matrix, int[] columnVector)
Parameters
Type Name Description
System.Double[] rowVector The left vector a.
System.Int32[][] matrix The square matrix B.
System.Int32[] columnVector The column vector c.
Returns
Type Description
System.Int32 The product a*B*c of the given vector a, matrix B and vector c.
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

DotAndDot(Double[], Int32[,], Double[])

Computes the product a*B*c of a row vector a, a square matrix B and a column vector c.
Declaration
public static double DotAndDot(this double[] rowVector, int[, ] matrix, double[] columnVector)
Parameters
Type Name Description
System.Double[] rowVector The left vector a.
System.Int32[,] matrix The square matrix B.
System.Double[] columnVector The column vector c.
Returns
Type Description
System.Double The product a*B*c of the given vector a, matrix B and vector c.
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

DotAndDot(Double[], Int32[,], Int32[])

Computes the product a*B*c of a row vector a, a square matrix B and a column vector c.
Declaration
public static int DotAndDot(this double[] rowVector, int[, ] matrix, int[] columnVector)
Parameters
Type Name Description
System.Double[] rowVector The left vector a.
System.Int32[,] matrix The square matrix B.
System.Int32[] columnVector The column vector c.
Returns
Type Description
System.Int32 The product a*B*c of the given vector a, matrix B and vector c.
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

DotAndDot(Int32[], Double[][], Double[])

Computes the product a*B*c of a row vector a, a square matrix B and a column vector c.
Declaration
public static double DotAndDot(this int[] rowVector, double[][] matrix, double[] columnVector)
Parameters
Type Name Description
System.Int32[] rowVector The left vector a.
System.Double[][] matrix The square matrix B.
System.Double[] columnVector The column vector c.
Returns
Type Description
System.Double The product a*B*c of the given vector a, matrix B and vector c.
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

DotAndDot(Int32[], Double[][], Int32[])

Computes the product a*B*c of a row vector a, a square matrix B and a column vector c.
Declaration
public static int DotAndDot(this int[] rowVector, double[][] matrix, int[] columnVector)
Parameters
Type Name Description
System.Int32[] rowVector The left vector a.
System.Double[][] matrix The square matrix B.
System.Int32[] columnVector The column vector c.
Returns
Type Description
System.Int32 The product a*B*c of the given vector a, matrix B and vector c.
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

DotAndDot(Int32[], Double[,], Double[])

Computes the product a*B*c of a row vector a, a square matrix B and a column vector c.
Declaration
public static double DotAndDot(this int[] rowVector, double[, ] matrix, double[] columnVector)
Parameters
Type Name Description
System.Int32[] rowVector The left vector a.
System.Double[,] matrix The square matrix B.
System.Double[] columnVector The column vector c.
Returns
Type Description
System.Double The product a*B*c of the given vector a, matrix B and vector c.
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

DotAndDot(Int32[], Double[,], Int32[])

Computes the product a*B*c of a row vector a, a square matrix B and a column vector c.
Declaration
public static int DotAndDot(this int[] rowVector, double[, ] matrix, int[] columnVector)
Parameters
Type Name Description
System.Int32[] rowVector The left vector a.
System.Double[,] matrix The square matrix B.
System.Int32[] columnVector The column vector c.
Returns
Type Description
System.Int32 The product a*B*c of the given vector a, matrix B and vector c.
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

DotAndDot(Int32[], Int32[][], Double[])

Computes the product a*B*c of a row vector a, a square matrix B and a column vector c.
Declaration
public static double DotAndDot(this int[] rowVector, int[][] matrix, double[] columnVector)
Parameters
Type Name Description
System.Int32[] rowVector The left vector a.
System.Int32[][] matrix The square matrix B.
System.Double[] columnVector The column vector c.
Returns
Type Description
System.Double The product a*B*c of the given vector a, matrix B and vector c.
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source

DotAndDot(Int32[], Int32[][], Int32[])

Computes the product a*B*c of a row vector a, a square matrix B and a column vector c.
Declaration
public static int DotAndDot(this int[] rowVector, int[][] matrix, int[] columnVector)
Parameters
Type Name Description
System.Int32[] rowVector The left vector a.
System.Int32[][] matrix The square matrix B.
System.Int32[] columnVector The column vector c.
Returns
Type Description
System.Int32 The product a*B*c of the given vector a, matrix B and vector c.
Remarks
The matrix class is a static class containing several extension methods. To use this class, import the Mars.Numerics and use the standard .NET's matrices and jagged arrays. When you call the dot (.) operator on those classes, the extension methods offered by this class should become available through IntelliSense auto-complete.
See Also
| Improve this Doc View Source