Class Elementwise
Elementwise matrix and vector operations.
Inheritance
Namespace: ISynergy.Framework.Mathematics
Assembly: ISynergy.Framework.Mathematics.dll
Syntax
public static class Elementwise : objectMethods
View SourceAbs(Double[,])
Elementwise absolute value.
Declaration
public static double[, ] Abs(this double[, ] value)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | value |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Abs(Double[,], Double[,])
Elementwise absolute value.
Declaration
public static double[, ] Abs(this double[, ] value, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | value | A matrix. |
| System.Double[,] | result | The vector where the result should be stored. Pass the same
vector as |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Byte, Byte[])
Elementwise addition between a scalar a and a vector b.
Declaration
public static byte[] Add(this byte a, byte[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | The scalar |
| System.Byte[] | b | The vector |
Returns
| Type | Description |
|---|---|
| System.Byte[] |
Add(Byte, Byte[], Byte[])
Elementwise addition between a scalar a and a vectorb.
Declaration
public static byte[] Add(this byte a, byte[] b, byte[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | The scalar |
| System.Byte[] | b | The vector |
| System.Byte[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[] |
Add(Byte, Byte[], Double[])
Elementwise addition between a scalar a and a vectorb.
Declaration
public static double[] Add(this byte a, byte[] b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | The scalar |
| System.Byte[] | b | The vector |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Byte, Byte[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static byte[][] Add(this byte a, byte[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | The scalar |
| System.Byte[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
Add(Byte, Byte[][], Byte[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static byte[][] Add(this byte a, byte[][] b, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | The scalar |
| System.Byte[][] | b | The matrix |
| System.Byte[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
Add(Byte, Byte[][], Double[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static double[][] Add(this byte a, byte[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | The scalar |
| System.Byte[][] | b | The matrix |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Byte, Byte[,])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static byte[, ] Add(this byte a, byte[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | The scalar |
| System.Byte[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
Add(Byte, Byte[,], Byte[,])
Elementwise addition between a scalar a and a matrix b.
Declaration
public static byte[, ] Add(this byte a, byte[, ] b, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | The scalar |
| System.Byte[,] | b | The matrix |
| System.Byte[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
Add(Byte, Byte[,], Double[,])
Elementwise addition between a scalar a and a matrix b.
Declaration
public static double[, ] Add(this byte a, byte[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | The scalar |
| System.Byte[,] | b | The matrix |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Byte, Decimal[], Byte[])
Elementwise addition between a scalar a and a vectorb.
Declaration
public static byte[] Add(this byte a, decimal[] b, byte[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | The scalar |
| System.Decimal[] | b | The vector |
| System.Byte[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[] |
Add(Byte, Decimal[], Decimal[])
Elementwise addition between a scalar a and a vectorb.
Declaration
public static decimal[] Add(this byte a, decimal[] b, decimal[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | The scalar |
| System.Decimal[] | b | The vector |
| System.Decimal[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[] |
Add(Byte, Decimal[], Double[])
Elementwise addition between a scalar a and a vectorb.
Declaration
public static double[] Add(this byte a, decimal[] b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | The scalar |
| System.Decimal[] | b | The vector |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Byte, Decimal[][], Byte[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static byte[][] Add(this byte a, decimal[][] b, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | The scalar |
| System.Decimal[][] | b | The matrix |
| System.Byte[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
Add(Byte, Decimal[][], Decimal[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static decimal[][] Add(this byte a, decimal[][] b, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | The scalar |
| System.Decimal[][] | b | The matrix |
| System.Decimal[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
Add(Byte, Decimal[][], Double[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static double[][] Add(this byte a, decimal[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | The scalar |
| System.Decimal[][] | b | The matrix |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Byte, Decimal[,], Byte[,])
Elementwise addition between a scalar a and a matrix b.
Declaration
public static byte[, ] Add(this byte a, decimal[, ] b, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | The scalar |
| System.Decimal[,] | b | The matrix |
| System.Byte[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
Add(Byte, Decimal[,], Decimal[,])
Elementwise addition between a scalar a and a matrix b.
Declaration
public static decimal[, ] Add(this byte a, decimal[, ] b, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | The scalar |
| System.Decimal[,] | b | The matrix |
| System.Decimal[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
Add(Byte, Decimal[,], Double[,])
Elementwise addition between a scalar a and a matrix b.
Declaration
public static double[, ] Add(this byte a, decimal[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | The scalar |
| System.Decimal[,] | b | The matrix |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Byte, Double[])
Elementwise addition between a scalar a and a vector b.
Declaration
public static double[] Add(this byte a, double[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | The scalar |
| System.Double[] | b | The vector |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Byte, Double[], Byte[])
Elementwise addition between a scalar a and a vectorb.
Declaration
public static byte[] Add(this byte a, double[] b, byte[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | The scalar |
| System.Double[] | b | The vector |
| System.Byte[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[] |
Add(Byte, Double[], Double[])
Elementwise addition between a scalar a and a vectorb.
Declaration
public static double[] Add(this byte a, double[] b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | The scalar |
| System.Double[] | b | The vector |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Byte, Double[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static double[][] Add(this byte a, double[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | The scalar |
| System.Double[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Byte, Double[][], Byte[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static byte[][] Add(this byte a, double[][] b, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | The scalar |
| System.Double[][] | b | The matrix |
| System.Byte[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
Add(Byte, Double[][], Double[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static double[][] Add(this byte a, double[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | The scalar |
| System.Double[][] | b | The matrix |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Byte, Double[,])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static double[, ] Add(this byte a, double[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | The scalar |
| System.Double[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Byte, Double[,], Byte[,])
Elementwise addition between a scalar a and a matrix b.
Declaration
public static byte[, ] Add(this byte a, double[, ] b, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | The scalar |
| System.Double[,] | b | The matrix |
| System.Byte[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
Add(Byte, Double[,], Double[,])
Elementwise addition between a scalar a and a matrix b.
Declaration
public static double[, ] Add(this byte a, double[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | The scalar |
| System.Double[,] | b | The matrix |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Byte, Int16[], Byte[])
Elementwise addition between a scalar a and a vectorb.
Declaration
public static byte[] Add(this byte a, short[] b, byte[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | The scalar |
| System.Int16[] | b | The vector |
| System.Byte[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[] |
Add(Byte, Int16[], Double[])
Elementwise addition between a scalar a and a vectorb.
Declaration
public static double[] Add(this byte a, short[] b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | The scalar |
| System.Int16[] | b | The vector |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Byte, Int16[], Int16[])
Elementwise addition between a scalar a and a vectorb.
Declaration
public static short[] Add(this byte a, short[] b, short[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | The scalar |
| System.Int16[] | b | The vector |
| System.Int16[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[] |
Add(Byte, Int16[][], Byte[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static byte[][] Add(this byte a, short[][] b, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | The scalar |
| System.Int16[][] | b | The matrix |
| System.Byte[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
Add(Byte, Int16[][], Double[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static double[][] Add(this byte a, short[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | The scalar |
| System.Int16[][] | b | The matrix |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Byte, Int16[][], Int16[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static short[][] Add(this byte a, short[][] b, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | The scalar |
| System.Int16[][] | b | The matrix |
| System.Int16[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
Add(Byte, Int16[,], Byte[,])
Elementwise addition between a scalar a and a matrix b.
Declaration
public static byte[, ] Add(this byte a, short[, ] b, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | The scalar |
| System.Int16[,] | b | The matrix |
| System.Byte[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
Add(Byte, Int16[,], Double[,])
Elementwise addition between a scalar a and a matrix b.
Declaration
public static double[, ] Add(this byte a, short[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | The scalar |
| System.Int16[,] | b | The matrix |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Byte, Int16[,], Int16[,])
Elementwise addition between a scalar a and a matrix b.
Declaration
public static short[, ] Add(this byte a, short[, ] b, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | The scalar |
| System.Int16[,] | b | The matrix |
| System.Int16[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
Add(Byte, Int32[])
Elementwise addition between a scalar a and a vector b.
Declaration
public static int[] Add(this byte a, int[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | The scalar |
| System.Int32[] | b | The vector |
Returns
| Type | Description |
|---|---|
| System.Int32[] |
Add(Byte, Int32[], Byte[])
Elementwise addition between a scalar a and a vectorb.
Declaration
public static byte[] Add(this byte a, int[] b, byte[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | The scalar |
| System.Int32[] | b | The vector |
| System.Byte[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[] |
Add(Byte, Int32[], Double[])
Elementwise addition between a scalar a and a vectorb.
Declaration
public static double[] Add(this byte a, int[] b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | The scalar |
| System.Int32[] | b | The vector |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Byte, Int32[], Int32[])
Elementwise addition between a scalar a and a vectorb.
Declaration
public static int[] Add(this byte a, int[] b, int[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | The scalar |
| System.Int32[] | b | The vector |
| System.Int32[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[] |
Add(Byte, Int32[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static int[][] Add(this byte a, int[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | The scalar |
| System.Int32[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
Add(Byte, Int32[][], Byte[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static byte[][] Add(this byte a, int[][] b, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | The scalar |
| System.Int32[][] | b | The matrix |
| System.Byte[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
Add(Byte, Int32[][], Double[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static double[][] Add(this byte a, int[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | The scalar |
| System.Int32[][] | b | The matrix |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Byte, Int32[][], Int32[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static int[][] Add(this byte a, int[][] b, int[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | The scalar |
| System.Int32[][] | b | The matrix |
| System.Int32[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
Add(Byte, Int32[,])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static int[, ] Add(this byte a, int[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | The scalar |
| System.Int32[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
Add(Byte, Int32[,], Byte[,])
Elementwise addition between a scalar a and a matrix b.
Declaration
public static byte[, ] Add(this byte a, int[, ] b, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | The scalar |
| System.Int32[,] | b | The matrix |
| System.Byte[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
Add(Byte, Int32[,], Double[,])
Elementwise addition between a scalar a and a matrix b.
Declaration
public static double[, ] Add(this byte a, int[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | The scalar |
| System.Int32[,] | b | The matrix |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Byte, Int32[,], Int32[,])
Elementwise addition between a scalar a and a matrix b.
Declaration
public static int[, ] Add(this byte a, int[, ] b, int[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | The scalar |
| System.Int32[,] | b | The matrix |
| System.Int32[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
Add(Byte, Single[])
Elementwise addition between a scalar a and a vector b.
Declaration
public static float[] Add(this byte a, float[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | The scalar |
| System.Single[] | b | The vector |
Returns
| Type | Description |
|---|---|
| System.Single[] |
Add(Byte, Single[], Byte[])
Elementwise addition between a scalar a and a vectorb.
Declaration
public static byte[] Add(this byte a, float[] b, byte[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | The scalar |
| System.Single[] | b | The vector |
| System.Byte[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[] |
Add(Byte, Single[], Double[])
Elementwise addition between a scalar a and a vectorb.
Declaration
public static double[] Add(this byte a, float[] b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | The scalar |
| System.Single[] | b | The vector |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Byte, Single[], Single[])
Elementwise addition between a scalar a and a vectorb.
Declaration
public static float[] Add(this byte a, float[] b, float[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | The scalar |
| System.Single[] | b | The vector |
| System.Single[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[] |
Add(Byte, Single[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static float[][] Add(this byte a, float[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | The scalar |
| System.Single[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Byte, Single[][], Byte[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static byte[][] Add(this byte a, float[][] b, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | The scalar |
| System.Single[][] | b | The matrix |
| System.Byte[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
Add(Byte, Single[][], Double[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static double[][] Add(this byte a, float[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | The scalar |
| System.Single[][] | b | The matrix |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Byte, Single[][], Single[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static float[][] Add(this byte a, float[][] b, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | The scalar |
| System.Single[][] | b | The matrix |
| System.Single[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Byte, Single[,])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static float[, ] Add(this byte a, float[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | The scalar |
| System.Single[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Byte, Single[,], Byte[,])
Elementwise addition between a scalar a and a matrix b.
Declaration
public static byte[, ] Add(this byte a, float[, ] b, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | The scalar |
| System.Single[,] | b | The matrix |
| System.Byte[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
Add(Byte, Single[,], Double[,])
Elementwise addition between a scalar a and a matrix b.
Declaration
public static double[, ] Add(this byte a, float[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | The scalar |
| System.Single[,] | b | The matrix |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Byte, Single[,], Single[,])
Elementwise addition between a scalar a and a matrix b.
Declaration
public static float[, ] Add(this byte a, float[, ] b, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | The scalar |
| System.Single[,] | b | The matrix |
| System.Single[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Byte[], Byte)
Elementwise addition between a vector a and a scalar b.
Declaration
public static byte[] Add(this byte[] a, byte b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | The vector |
| System.Byte | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Byte[] |
Add(Byte[], Byte, Byte[])
Elementwise addition between a vector a and a scalar b.
Declaration
public static byte[] Add(this byte[] a, byte b, byte[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | The vector |
| System.Byte | b | The scalar |
| System.Byte[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[] |
Add(Byte[], Byte, Double[])
Elementwise addition between a vector a and a scalar b.
Declaration
public static double[] Add(this byte[] a, byte b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | The vector |
| System.Byte | b | The scalar |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Byte[], Byte[])
Elementwise addition between a vector a and a vector b.
Declaration
public static byte[] Add(this byte[] a, byte[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | The vector |
| System.Byte[] | b | The vector |
Returns
| Type | Description |
|---|---|
| System.Byte[] |
Add(Byte[], Byte[], Byte[])
Elementwise addition between a vector a and a vectorb.
Declaration
public static byte[] Add(this byte[] a, byte[] b, byte[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | The vector |
| System.Byte[] | b | The vector |
| System.Byte[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[] |
Add(Byte[], Byte[], Double[])
Elementwise addition between a vector a and a vectorb.
Declaration
public static double[] Add(this byte[] a, byte[] b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | The vector |
| System.Byte[] | b | The vector |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Byte[], Byte[][], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static byte[][] Add(this byte[] a, byte[][] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | The vector |
| System.Byte[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
Add(Byte[], Byte[][], VectorType, Byte[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static byte[][] Add(this byte[] a, byte[][] b, VectorType dimension, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | The vector |
| System.Byte[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Byte[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
Add(Byte[], Byte[][], VectorType, Double[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this byte[] a, byte[][] b, VectorType dimension, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | The vector |
| System.Byte[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Byte[], Byte[,], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static byte[, ] Add(this byte[] a, byte[, ] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | The vector |
| System.Byte[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
Add(Byte[], Byte[,], VectorType, Byte[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static byte[, ] Add(this byte[] a, byte[, ] b, VectorType dimension, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | The vector |
| System.Byte[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Byte[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
Add(Byte[], Byte[,], VectorType, Double[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this byte[] a, byte[, ] b, VectorType dimension, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | The vector |
| System.Byte[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Byte[], Decimal, Byte[])
Elementwise addition between a vector a and a scalar b.
Declaration
public static byte[] Add(this byte[] a, decimal b, byte[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | The vector |
| System.Decimal | b | The scalar |
| System.Byte[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[] |
Add(Byte[], Decimal, Decimal[])
Elementwise addition between a vector a and a scalar b.
Declaration
public static decimal[] Add(this byte[] a, decimal b, decimal[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | The vector |
| System.Decimal | b | The scalar |
| System.Decimal[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[] |
Add(Byte[], Decimal, Double[])
Elementwise addition between a vector a and a scalar b.
Declaration
public static double[] Add(this byte[] a, decimal b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | The vector |
| System.Decimal | b | The scalar |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Byte[], Decimal[], Byte[])
Elementwise addition between a vector a and a vectorb.
Declaration
public static byte[] Add(this byte[] a, decimal[] b, byte[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | The vector |
| System.Decimal[] | b | The vector |
| System.Byte[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[] |
Add(Byte[], Decimal[], Decimal[])
Elementwise addition between a vector a and a vectorb.
Declaration
public static decimal[] Add(this byte[] a, decimal[] b, decimal[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | The vector |
| System.Decimal[] | b | The vector |
| System.Decimal[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[] |
Add(Byte[], Decimal[], Double[])
Elementwise addition between a vector a and a vectorb.
Declaration
public static double[] Add(this byte[] a, decimal[] b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | The vector |
| System.Decimal[] | b | The vector |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Byte[], Decimal[][], VectorType, Byte[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static byte[][] Add(this byte[] a, decimal[][] b, VectorType dimension, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | The vector |
| System.Decimal[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Byte[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
Add(Byte[], Decimal[][], VectorType, Decimal[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static decimal[][] Add(this byte[] a, decimal[][] b, VectorType dimension, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | The vector |
| System.Decimal[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Decimal[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
Add(Byte[], Decimal[][], VectorType, Double[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this byte[] a, decimal[][] b, VectorType dimension, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | The vector |
| System.Decimal[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Byte[], Decimal[,], VectorType, Byte[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static byte[, ] Add(this byte[] a, decimal[, ] b, VectorType dimension, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | The vector |
| System.Decimal[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Byte[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
Add(Byte[], Decimal[,], VectorType, Decimal[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static decimal[, ] Add(this byte[] a, decimal[, ] b, VectorType dimension, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | The vector |
| System.Decimal[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Decimal[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
Add(Byte[], Decimal[,], VectorType, Double[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this byte[] a, decimal[, ] b, VectorType dimension, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | The vector |
| System.Decimal[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Byte[], Double)
Elementwise addition between a vector a and a scalar b.
Declaration
public static double[] Add(this byte[] a, double b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | The vector |
| System.Double | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Byte[], Double, Byte[])
Elementwise addition between a vector a and a scalar b.
Declaration
public static byte[] Add(this byte[] a, double b, byte[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | The vector |
| System.Double | b | The scalar |
| System.Byte[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[] |
Add(Byte[], Double, Double[])
Elementwise addition between a vector a and a scalar b.
Declaration
public static double[] Add(this byte[] a, double b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | The vector |
| System.Double | b | The scalar |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Byte[], Double[])
Elementwise addition between a vector a and a vector b.
Declaration
public static double[] Add(this byte[] a, double[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | The vector |
| System.Double[] | b | The vector |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Byte[], Double[], Byte[])
Elementwise addition between a vector a and a vectorb.
Declaration
public static byte[] Add(this byte[] a, double[] b, byte[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | The vector |
| System.Double[] | b | The vector |
| System.Byte[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[] |
Add(Byte[], Double[], Double[])
Elementwise addition between a vector a and a vectorb.
Declaration
public static double[] Add(this byte[] a, double[] b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | The vector |
| System.Double[] | b | The vector |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Byte[], Double[][], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this byte[] a, double[][] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | The vector |
| System.Double[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Byte[], Double[][], VectorType, Byte[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static byte[][] Add(this byte[] a, double[][] b, VectorType dimension, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | The vector |
| System.Double[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Byte[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
Add(Byte[], Double[][], VectorType, Double[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this byte[] a, double[][] b, VectorType dimension, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | The vector |
| System.Double[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Byte[], Double[,], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this byte[] a, double[, ] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | The vector |
| System.Double[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Byte[], Double[,], VectorType, Byte[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static byte[, ] Add(this byte[] a, double[, ] b, VectorType dimension, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | The vector |
| System.Double[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Byte[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
Add(Byte[], Double[,], VectorType, Double[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this byte[] a, double[, ] b, VectorType dimension, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | The vector |
| System.Double[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Byte[], Int16, Byte[])
Elementwise addition between a vector a and a scalar b.
Declaration
public static byte[] Add(this byte[] a, short b, byte[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | The vector |
| System.Int16 | b | The scalar |
| System.Byte[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[] |
Add(Byte[], Int16, Double[])
Elementwise addition between a vector a and a scalar b.
Declaration
public static double[] Add(this byte[] a, short b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | The vector |
| System.Int16 | b | The scalar |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Byte[], Int16, Int16[])
Elementwise addition between a vector a and a scalar b.
Declaration
public static short[] Add(this byte[] a, short b, short[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | The vector |
| System.Int16 | b | The scalar |
| System.Int16[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[] |
Add(Byte[], Int16[], Byte[])
Elementwise addition between a vector a and a vectorb.
Declaration
public static byte[] Add(this byte[] a, short[] b, byte[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | The vector |
| System.Int16[] | b | The vector |
| System.Byte[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[] |
Add(Byte[], Int16[], Double[])
Elementwise addition between a vector a and a vectorb.
Declaration
public static double[] Add(this byte[] a, short[] b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | The vector |
| System.Int16[] | b | The vector |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Byte[], Int16[], Int16[])
Elementwise addition between a vector a and a vectorb.
Declaration
public static short[] Add(this byte[] a, short[] b, short[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | The vector |
| System.Int16[] | b | The vector |
| System.Int16[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[] |
Add(Byte[], Int16[][], VectorType, Byte[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static byte[][] Add(this byte[] a, short[][] b, VectorType dimension, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | The vector |
| System.Int16[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Byte[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
Add(Byte[], Int16[][], VectorType, Double[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this byte[] a, short[][] b, VectorType dimension, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | The vector |
| System.Int16[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Byte[], Int16[][], VectorType, Int16[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static short[][] Add(this byte[] a, short[][] b, VectorType dimension, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | The vector |
| System.Int16[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Int16[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
Add(Byte[], Int16[,], VectorType, Byte[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static byte[, ] Add(this byte[] a, short[, ] b, VectorType dimension, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | The vector |
| System.Int16[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Byte[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
Add(Byte[], Int16[,], VectorType, Double[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this byte[] a, short[, ] b, VectorType dimension, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | The vector |
| System.Int16[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Byte[], Int16[,], VectorType, Int16[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static short[, ] Add(this byte[] a, short[, ] b, VectorType dimension, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | The vector |
| System.Int16[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Int16[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
Add(Byte[], Int32)
Elementwise addition between a vector a and a scalar b.
Declaration
public static int[] Add(this byte[] a, int b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | The vector |
| System.Int32 | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Int32[] |
Add(Byte[], Int32, Byte[])
Elementwise addition between a vector a and a scalar b.
Declaration
public static byte[] Add(this byte[] a, int b, byte[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | The vector |
| System.Int32 | b | The scalar |
| System.Byte[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[] |
Add(Byte[], Int32, Double[])
Elementwise addition between a vector a and a scalar b.
Declaration
public static double[] Add(this byte[] a, int b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | The vector |
| System.Int32 | b | The scalar |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Byte[], Int32, Int32[])
Elementwise addition between a vector a and a scalar b.
Declaration
public static int[] Add(this byte[] a, int b, int[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | The vector |
| System.Int32 | b | The scalar |
| System.Int32[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[] |
Add(Byte[], Int32[])
Elementwise addition between a vector a and a vector b.
Declaration
public static int[] Add(this byte[] a, int[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | The vector |
| System.Int32[] | b | The vector |
Returns
| Type | Description |
|---|---|
| System.Int32[] |
Add(Byte[], Int32[], Byte[])
Elementwise addition between a vector a and a vectorb.
Declaration
public static byte[] Add(this byte[] a, int[] b, byte[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | The vector |
| System.Int32[] | b | The vector |
| System.Byte[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[] |
Add(Byte[], Int32[], Double[])
Elementwise addition between a vector a and a vectorb.
Declaration
public static double[] Add(this byte[] a, int[] b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | The vector |
| System.Int32[] | b | The vector |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Byte[], Int32[], Int32[])
Elementwise addition between a vector a and a vectorb.
Declaration
public static int[] Add(this byte[] a, int[] b, int[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | The vector |
| System.Int32[] | b | The vector |
| System.Int32[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[] |
Add(Byte[], Int32[][], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static int[][] Add(this byte[] a, int[][] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | The vector |
| System.Int32[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
Add(Byte[], Int32[][], VectorType, Byte[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static byte[][] Add(this byte[] a, int[][] b, VectorType dimension, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | The vector |
| System.Int32[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Byte[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
Add(Byte[], Int32[][], VectorType, Double[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this byte[] a, int[][] b, VectorType dimension, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | The vector |
| System.Int32[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Byte[], Int32[][], VectorType, Int32[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static int[][] Add(this byte[] a, int[][] b, VectorType dimension, int[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | The vector |
| System.Int32[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Int32[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
Add(Byte[], Int32[,], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static int[, ] Add(this byte[] a, int[, ] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | The vector |
| System.Int32[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
Add(Byte[], Int32[,], VectorType, Byte[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static byte[, ] Add(this byte[] a, int[, ] b, VectorType dimension, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | The vector |
| System.Int32[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Byte[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
Add(Byte[], Int32[,], VectorType, Double[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this byte[] a, int[, ] b, VectorType dimension, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | The vector |
| System.Int32[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Byte[], Int32[,], VectorType, Int32[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static int[, ] Add(this byte[] a, int[, ] b, VectorType dimension, int[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | The vector |
| System.Int32[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Int32[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
Add(Byte[], Single)
Elementwise addition between a vector a and a scalar b.
Declaration
public static float[] Add(this byte[] a, float b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | The vector |
| System.Single | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Single[] |
Add(Byte[], Single, Byte[])
Elementwise addition between a vector a and a scalar b.
Declaration
public static byte[] Add(this byte[] a, float b, byte[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | The vector |
| System.Single | b | The scalar |
| System.Byte[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[] |
Add(Byte[], Single, Double[])
Elementwise addition between a vector a and a scalar b.
Declaration
public static double[] Add(this byte[] a, float b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | The vector |
| System.Single | b | The scalar |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Byte[], Single, Single[])
Elementwise addition between a vector a and a scalar b.
Declaration
public static float[] Add(this byte[] a, float b, float[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | The vector |
| System.Single | b | The scalar |
| System.Single[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[] |
Add(Byte[], Single[])
Elementwise addition between a vector a and a vector b.
Declaration
public static float[] Add(this byte[] a, float[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | The vector |
| System.Single[] | b | The vector |
Returns
| Type | Description |
|---|---|
| System.Single[] |
Add(Byte[], Single[], Byte[])
Elementwise addition between a vector a and a vectorb.
Declaration
public static byte[] Add(this byte[] a, float[] b, byte[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | The vector |
| System.Single[] | b | The vector |
| System.Byte[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[] |
Add(Byte[], Single[], Double[])
Elementwise addition between a vector a and a vectorb.
Declaration
public static double[] Add(this byte[] a, float[] b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | The vector |
| System.Single[] | b | The vector |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Byte[], Single[], Single[])
Elementwise addition between a vector a and a vectorb.
Declaration
public static float[] Add(this byte[] a, float[] b, float[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | The vector |
| System.Single[] | b | The vector |
| System.Single[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[] |
Add(Byte[], Single[][], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static float[][] Add(this byte[] a, float[][] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | The vector |
| System.Single[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Byte[], Single[][], VectorType, Byte[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static byte[][] Add(this byte[] a, float[][] b, VectorType dimension, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | The vector |
| System.Single[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Byte[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
Add(Byte[], Single[][], VectorType, Double[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this byte[] a, float[][] b, VectorType dimension, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | The vector |
| System.Single[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Byte[], Single[][], VectorType, Single[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static float[][] Add(this byte[] a, float[][] b, VectorType dimension, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | The vector |
| System.Single[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Single[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Byte[], Single[,], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static float[, ] Add(this byte[] a, float[, ] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | The vector |
| System.Single[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Byte[], Single[,], VectorType, Byte[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static byte[, ] Add(this byte[] a, float[, ] b, VectorType dimension, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | The vector |
| System.Single[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Byte[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
Add(Byte[], Single[,], VectorType, Double[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this byte[] a, float[, ] b, VectorType dimension, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | The vector |
| System.Single[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Byte[], Single[,], VectorType, Single[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static float[, ] Add(this byte[] a, float[, ] b, VectorType dimension, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | The vector |
| System.Single[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Single[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Byte[][], Byte)
Elementwise addition between a matrix A and a scalar b.
Declaration
public static byte[][] Add(this byte[][] a, byte b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | The matrix |
| System.Byte | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
Add(Byte[][], Byte, Byte[][])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static byte[][] Add(this byte[][] a, byte b, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | The matrix |
| System.Byte | b | The scalar |
| System.Byte[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
Add(Byte[][], Byte, Double[][])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[][] Add(this byte[][] a, byte b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | The matrix |
| System.Byte | b | The scalar |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Byte[][], Byte[], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static byte[][] Add(this byte[][] a, byte[] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | The matrix |
| System.Byte[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
Add(Byte[][], Byte[], VectorType, Byte[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static byte[][] Add(this byte[][] a, byte[] b, VectorType dimension, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | The matrix |
| System.Byte[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Byte[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
Add(Byte[][], Byte[], VectorType, Double[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this byte[][] a, byte[] b, VectorType dimension, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | The matrix |
| System.Byte[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Byte[][], Byte[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static byte[][] Add(this byte[][] a, byte[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | The matrix |
| System.Byte[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
Add(Byte[][], Byte[][], Byte[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static byte[][] Add(this byte[][] a, byte[][] b, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | The matrix |
| System.Byte[][] | b | The matrix |
| System.Byte[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
Add(Byte[][], Byte[][], Double[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[][] Add(this byte[][] a, byte[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | The matrix |
| System.Byte[][] | b | The matrix |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Byte[][], Decimal, Byte[][])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static byte[][] Add(this byte[][] a, decimal b, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | The matrix |
| System.Decimal | b | The scalar |
| System.Byte[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
Add(Byte[][], Decimal, Decimal[][])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static decimal[][] Add(this byte[][] a, decimal b, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | The matrix |
| System.Decimal | b | The scalar |
| System.Decimal[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
Add(Byte[][], Decimal, Double[][])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[][] Add(this byte[][] a, decimal b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | The matrix |
| System.Decimal | b | The scalar |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Byte[][], Decimal[], VectorType, Byte[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static byte[][] Add(this byte[][] a, decimal[] b, VectorType dimension, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | The matrix |
| System.Decimal[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Byte[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
Add(Byte[][], Decimal[], VectorType, Decimal[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static decimal[][] Add(this byte[][] a, decimal[] b, VectorType dimension, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | The matrix |
| System.Decimal[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Decimal[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
Add(Byte[][], Decimal[], VectorType, Double[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this byte[][] a, decimal[] b, VectorType dimension, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | The matrix |
| System.Decimal[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Byte[][], Decimal[][], Byte[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static byte[][] Add(this byte[][] a, decimal[][] b, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | The matrix |
| System.Decimal[][] | b | The matrix |
| System.Byte[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
Add(Byte[][], Decimal[][], Decimal[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static decimal[][] Add(this byte[][] a, decimal[][] b, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | The matrix |
| System.Decimal[][] | b | The matrix |
| System.Decimal[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
Add(Byte[][], Decimal[][], Double[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[][] Add(this byte[][] a, decimal[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | The matrix |
| System.Decimal[][] | b | The matrix |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Byte[][], Double)
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[][] Add(this byte[][] a, double b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | The matrix |
| System.Double | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Byte[][], Double, Byte[][])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static byte[][] Add(this byte[][] a, double b, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | The matrix |
| System.Double | b | The scalar |
| System.Byte[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
Add(Byte[][], Double, Double[][])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[][] Add(this byte[][] a, double b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | The matrix |
| System.Double | b | The scalar |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Byte[][], Double[], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this byte[][] a, double[] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | The matrix |
| System.Double[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Byte[][], Double[], VectorType, Byte[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static byte[][] Add(this byte[][] a, double[] b, VectorType dimension, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | The matrix |
| System.Double[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Byte[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
Add(Byte[][], Double[], VectorType, Double[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this byte[][] a, double[] b, VectorType dimension, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | The matrix |
| System.Double[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Byte[][], Double[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[][] Add(this byte[][] a, double[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | The matrix |
| System.Double[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Byte[][], Double[][], Byte[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static byte[][] Add(this byte[][] a, double[][] b, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | The matrix |
| System.Double[][] | b | The matrix |
| System.Byte[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
Add(Byte[][], Double[][], Double[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[][] Add(this byte[][] a, double[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | The matrix |
| System.Double[][] | b | The matrix |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Byte[][], Int16, Byte[][])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static byte[][] Add(this byte[][] a, short b, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | The matrix |
| System.Int16 | b | The scalar |
| System.Byte[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
Add(Byte[][], Int16, Double[][])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[][] Add(this byte[][] a, short b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | The matrix |
| System.Int16 | b | The scalar |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Byte[][], Int16, Int16[][])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static short[][] Add(this byte[][] a, short b, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | The matrix |
| System.Int16 | b | The scalar |
| System.Int16[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
Add(Byte[][], Int16[], VectorType, Byte[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static byte[][] Add(this byte[][] a, short[] b, VectorType dimension, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | The matrix |
| System.Int16[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Byte[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
Add(Byte[][], Int16[], VectorType, Double[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this byte[][] a, short[] b, VectorType dimension, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | The matrix |
| System.Int16[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Byte[][], Int16[], VectorType, Int16[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static short[][] Add(this byte[][] a, short[] b, VectorType dimension, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | The matrix |
| System.Int16[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Int16[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
Add(Byte[][], Int16[][], Byte[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static byte[][] Add(this byte[][] a, short[][] b, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | The matrix |
| System.Int16[][] | b | The matrix |
| System.Byte[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
Add(Byte[][], Int16[][], Double[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[][] Add(this byte[][] a, short[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | The matrix |
| System.Int16[][] | b | The matrix |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Byte[][], Int16[][], Int16[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static short[][] Add(this byte[][] a, short[][] b, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | The matrix |
| System.Int16[][] | b | The matrix |
| System.Int16[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
Add(Byte[][], Int32)
Elementwise addition between a matrix A and a scalar b.
Declaration
public static int[][] Add(this byte[][] a, int b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | The matrix |
| System.Int32 | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
Add(Byte[][], Int32, Byte[][])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static byte[][] Add(this byte[][] a, int b, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | The matrix |
| System.Int32 | b | The scalar |
| System.Byte[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
Add(Byte[][], Int32, Double[][])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[][] Add(this byte[][] a, int b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | The matrix |
| System.Int32 | b | The scalar |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Byte[][], Int32, Int32[][])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static int[][] Add(this byte[][] a, int b, int[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | The matrix |
| System.Int32 | b | The scalar |
| System.Int32[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
Add(Byte[][], Int32[], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static int[][] Add(this byte[][] a, int[] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | The matrix |
| System.Int32[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
Add(Byte[][], Int32[], VectorType, Byte[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static byte[][] Add(this byte[][] a, int[] b, VectorType dimension, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | The matrix |
| System.Int32[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Byte[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
Add(Byte[][], Int32[], VectorType, Double[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this byte[][] a, int[] b, VectorType dimension, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | The matrix |
| System.Int32[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Byte[][], Int32[], VectorType, Int32[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static int[][] Add(this byte[][] a, int[] b, VectorType dimension, int[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | The matrix |
| System.Int32[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Int32[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
Add(Byte[][], Int32[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static int[][] Add(this byte[][] a, int[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | The matrix |
| System.Int32[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
Add(Byte[][], Int32[][], Byte[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static byte[][] Add(this byte[][] a, int[][] b, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | The matrix |
| System.Int32[][] | b | The matrix |
| System.Byte[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
Add(Byte[][], Int32[][], Double[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[][] Add(this byte[][] a, int[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | The matrix |
| System.Int32[][] | b | The matrix |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Byte[][], Int32[][], Int32[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static int[][] Add(this byte[][] a, int[][] b, int[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | The matrix |
| System.Int32[][] | b | The matrix |
| System.Int32[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
Add(Byte[][], Single)
Elementwise addition between a matrix A and a scalar b.
Declaration
public static float[][] Add(this byte[][] a, float b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | The matrix |
| System.Single | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Byte[][], Single, Byte[][])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static byte[][] Add(this byte[][] a, float b, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | The matrix |
| System.Single | b | The scalar |
| System.Byte[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
Add(Byte[][], Single, Double[][])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[][] Add(this byte[][] a, float b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | The matrix |
| System.Single | b | The scalar |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Byte[][], Single, Single[][])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static float[][] Add(this byte[][] a, float b, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | The matrix |
| System.Single | b | The scalar |
| System.Single[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Byte[][], Single[], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static float[][] Add(this byte[][] a, float[] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | The matrix |
| System.Single[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Byte[][], Single[], VectorType, Byte[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static byte[][] Add(this byte[][] a, float[] b, VectorType dimension, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | The matrix |
| System.Single[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Byte[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
Add(Byte[][], Single[], VectorType, Double[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this byte[][] a, float[] b, VectorType dimension, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | The matrix |
| System.Single[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Byte[][], Single[], VectorType, Single[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static float[][] Add(this byte[][] a, float[] b, VectorType dimension, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | The matrix |
| System.Single[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Single[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Byte[][], Single[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static float[][] Add(this byte[][] a, float[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | The matrix |
| System.Single[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Byte[][], Single[][], Byte[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static byte[][] Add(this byte[][] a, float[][] b, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | The matrix |
| System.Single[][] | b | The matrix |
| System.Byte[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
Add(Byte[][], Single[][], Double[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[][] Add(this byte[][] a, float[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | The matrix |
| System.Single[][] | b | The matrix |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Byte[][], Single[][], Single[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static float[][] Add(this byte[][] a, float[][] b, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | The matrix |
| System.Single[][] | b | The matrix |
| System.Single[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Byte[,], Byte)
Elementwise addition between a matrix A and a scalar b.
Declaration
public static byte[, ] Add(this byte[, ] a, byte b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | The matrix |
| System.Byte | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
Add(Byte[,], Byte, Byte[,])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static byte[, ] Add(this byte[, ] a, byte b, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | The matrix |
| System.Byte | b | The scalar |
| System.Byte[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
Add(Byte[,], Byte, Double[,])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[, ] Add(this byte[, ] a, byte b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | The matrix |
| System.Byte | b | The scalar |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Byte[,], Byte[], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static byte[, ] Add(this byte[, ] a, byte[] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | The matrix |
| System.Byte[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
Add(Byte[,], Byte[], VectorType, Byte[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static byte[, ] Add(this byte[, ] a, byte[] b, VectorType dimension, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | The matrix |
| System.Byte[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Byte[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
Add(Byte[,], Byte[], VectorType, Double[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this byte[, ] a, byte[] b, VectorType dimension, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | The matrix |
| System.Byte[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Byte[,], Byte[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static byte[, ] Add(this byte[, ] a, byte[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | The matrix |
| System.Byte[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
Add(Byte[,], Byte[,], Byte[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static byte[, ] Add(this byte[, ] a, byte[, ] b, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | The matrix |
| System.Byte[,] | b | The matrix |
| System.Byte[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
Add(Byte[,], Byte[,], Double[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[, ] Add(this byte[, ] a, byte[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | The matrix |
| System.Byte[,] | b | The matrix |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Byte[,], Decimal, Byte[,])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static byte[, ] Add(this byte[, ] a, decimal b, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | The matrix |
| System.Decimal | b | The scalar |
| System.Byte[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
Add(Byte[,], Decimal, Decimal[,])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static decimal[, ] Add(this byte[, ] a, decimal b, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | The matrix |
| System.Decimal | b | The scalar |
| System.Decimal[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
Add(Byte[,], Decimal, Double[,])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[, ] Add(this byte[, ] a, decimal b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | The matrix |
| System.Decimal | b | The scalar |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Byte[,], Decimal[], VectorType, Byte[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static byte[, ] Add(this byte[, ] a, decimal[] b, VectorType dimension, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | The matrix |
| System.Decimal[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Byte[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
Add(Byte[,], Decimal[], VectorType, Decimal[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static decimal[, ] Add(this byte[, ] a, decimal[] b, VectorType dimension, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | The matrix |
| System.Decimal[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Decimal[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
Add(Byte[,], Decimal[], VectorType, Double[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this byte[, ] a, decimal[] b, VectorType dimension, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | The matrix |
| System.Decimal[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Byte[,], Decimal[,], Byte[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static byte[, ] Add(this byte[, ] a, decimal[, ] b, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | The matrix |
| System.Decimal[,] | b | The matrix |
| System.Byte[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
Add(Byte[,], Decimal[,], Decimal[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static decimal[, ] Add(this byte[, ] a, decimal[, ] b, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | The matrix |
| System.Decimal[,] | b | The matrix |
| System.Decimal[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
Add(Byte[,], Decimal[,], Double[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[, ] Add(this byte[, ] a, decimal[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | The matrix |
| System.Decimal[,] | b | The matrix |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Byte[,], Double)
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[, ] Add(this byte[, ] a, double b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | The matrix |
| System.Double | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Byte[,], Double, Byte[,])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static byte[, ] Add(this byte[, ] a, double b, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | The matrix |
| System.Double | b | The scalar |
| System.Byte[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
Add(Byte[,], Double, Double[,])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[, ] Add(this byte[, ] a, double b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | The matrix |
| System.Double | b | The scalar |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Byte[,], Double[], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this byte[, ] a, double[] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | The matrix |
| System.Double[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Byte[,], Double[], VectorType, Byte[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static byte[, ] Add(this byte[, ] a, double[] b, VectorType dimension, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | The matrix |
| System.Double[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Byte[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
Add(Byte[,], Double[], VectorType, Double[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this byte[, ] a, double[] b, VectorType dimension, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | The matrix |
| System.Double[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Byte[,], Double[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[, ] Add(this byte[, ] a, double[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | The matrix |
| System.Double[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Byte[,], Double[,], Byte[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static byte[, ] Add(this byte[, ] a, double[, ] b, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | The matrix |
| System.Double[,] | b | The matrix |
| System.Byte[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
Add(Byte[,], Double[,], Double[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[, ] Add(this byte[, ] a, double[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | The matrix |
| System.Double[,] | b | The matrix |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Byte[,], Int16, Byte[,])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static byte[, ] Add(this byte[, ] a, short b, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | The matrix |
| System.Int16 | b | The scalar |
| System.Byte[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
Add(Byte[,], Int16, Double[,])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[, ] Add(this byte[, ] a, short b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | The matrix |
| System.Int16 | b | The scalar |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Byte[,], Int16, Int16[,])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static short[, ] Add(this byte[, ] a, short b, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | The matrix |
| System.Int16 | b | The scalar |
| System.Int16[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
Add(Byte[,], Int16[], VectorType, Byte[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static byte[, ] Add(this byte[, ] a, short[] b, VectorType dimension, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | The matrix |
| System.Int16[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Byte[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
Add(Byte[,], Int16[], VectorType, Double[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this byte[, ] a, short[] b, VectorType dimension, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | The matrix |
| System.Int16[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Byte[,], Int16[], VectorType, Int16[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static short[, ] Add(this byte[, ] a, short[] b, VectorType dimension, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | The matrix |
| System.Int16[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Int16[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
Add(Byte[,], Int16[,], Byte[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static byte[, ] Add(this byte[, ] a, short[, ] b, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | The matrix |
| System.Int16[,] | b | The matrix |
| System.Byte[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
Add(Byte[,], Int16[,], Double[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[, ] Add(this byte[, ] a, short[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | The matrix |
| System.Int16[,] | b | The matrix |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Byte[,], Int16[,], Int16[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static short[, ] Add(this byte[, ] a, short[, ] b, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | The matrix |
| System.Int16[,] | b | The matrix |
| System.Int16[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
Add(Byte[,], Int32)
Elementwise addition between a matrix A and a scalar b.
Declaration
public static int[, ] Add(this byte[, ] a, int b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | The matrix |
| System.Int32 | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
Add(Byte[,], Int32, Byte[,])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static byte[, ] Add(this byte[, ] a, int b, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | The matrix |
| System.Int32 | b | The scalar |
| System.Byte[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
Add(Byte[,], Int32, Double[,])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[, ] Add(this byte[, ] a, int b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | The matrix |
| System.Int32 | b | The scalar |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Byte[,], Int32, Int32[,])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static int[, ] Add(this byte[, ] a, int b, int[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | The matrix |
| System.Int32 | b | The scalar |
| System.Int32[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
Add(Byte[,], Int32[], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static int[, ] Add(this byte[, ] a, int[] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | The matrix |
| System.Int32[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
Add(Byte[,], Int32[], VectorType, Byte[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static byte[, ] Add(this byte[, ] a, int[] b, VectorType dimension, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | The matrix |
| System.Int32[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Byte[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
Add(Byte[,], Int32[], VectorType, Double[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this byte[, ] a, int[] b, VectorType dimension, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | The matrix |
| System.Int32[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Byte[,], Int32[], VectorType, Int32[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static int[, ] Add(this byte[, ] a, int[] b, VectorType dimension, int[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | The matrix |
| System.Int32[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Int32[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
Add(Byte[,], Int32[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static int[, ] Add(this byte[, ] a, int[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | The matrix |
| System.Int32[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
Add(Byte[,], Int32[,], Byte[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static byte[, ] Add(this byte[, ] a, int[, ] b, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | The matrix |
| System.Int32[,] | b | The matrix |
| System.Byte[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
Add(Byte[,], Int32[,], Double[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[, ] Add(this byte[, ] a, int[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | The matrix |
| System.Int32[,] | b | The matrix |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Byte[,], Int32[,], Int32[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static int[, ] Add(this byte[, ] a, int[, ] b, int[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | The matrix |
| System.Int32[,] | b | The matrix |
| System.Int32[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
Add(Byte[,], Single)
Elementwise addition between a matrix A and a scalar b.
Declaration
public static float[, ] Add(this byte[, ] a, float b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | The matrix |
| System.Single | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Byte[,], Single, Byte[,])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static byte[, ] Add(this byte[, ] a, float b, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | The matrix |
| System.Single | b | The scalar |
| System.Byte[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
Add(Byte[,], Single, Double[,])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[, ] Add(this byte[, ] a, float b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | The matrix |
| System.Single | b | The scalar |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Byte[,], Single, Single[,])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static float[, ] Add(this byte[, ] a, float b, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | The matrix |
| System.Single | b | The scalar |
| System.Single[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Byte[,], Single[], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static float[, ] Add(this byte[, ] a, float[] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | The matrix |
| System.Single[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Byte[,], Single[], VectorType, Byte[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static byte[, ] Add(this byte[, ] a, float[] b, VectorType dimension, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | The matrix |
| System.Single[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Byte[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
Add(Byte[,], Single[], VectorType, Double[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this byte[, ] a, float[] b, VectorType dimension, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | The matrix |
| System.Single[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Byte[,], Single[], VectorType, Single[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static float[, ] Add(this byte[, ] a, float[] b, VectorType dimension, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | The matrix |
| System.Single[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Single[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Byte[,], Single[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static float[, ] Add(this byte[, ] a, float[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | The matrix |
| System.Single[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Byte[,], Single[,], Byte[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static byte[, ] Add(this byte[, ] a, float[, ] b, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | The matrix |
| System.Single[,] | b | The matrix |
| System.Byte[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
Add(Byte[,], Single[,], Double[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[, ] Add(this byte[, ] a, float[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | The matrix |
| System.Single[,] | b | The matrix |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Byte[,], Single[,], Single[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static float[, ] Add(this byte[, ] a, float[, ] b, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | The matrix |
| System.Single[,] | b | The matrix |
| System.Single[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Decimal, Byte[], Byte[])
Elementwise addition between a scalar a and a vectorb.
Declaration
public static byte[] Add(this decimal a, byte[] b, byte[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | The scalar |
| System.Byte[] | b | The vector |
| System.Byte[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[] |
Add(Decimal, Byte[], Decimal[])
Elementwise addition between a scalar a and a vectorb.
Declaration
public static decimal[] Add(this decimal a, byte[] b, decimal[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | The scalar |
| System.Byte[] | b | The vector |
| System.Decimal[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[] |
Add(Decimal, Byte[], Double[])
Elementwise addition between a scalar a and a vectorb.
Declaration
public static double[] Add(this decimal a, byte[] b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | The scalar |
| System.Byte[] | b | The vector |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Decimal, Byte[][], Byte[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static byte[][] Add(this decimal a, byte[][] b, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | The scalar |
| System.Byte[][] | b | The matrix |
| System.Byte[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
Add(Decimal, Byte[][], Decimal[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static decimal[][] Add(this decimal a, byte[][] b, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | The scalar |
| System.Byte[][] | b | The matrix |
| System.Decimal[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
Add(Decimal, Byte[][], Double[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static double[][] Add(this decimal a, byte[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | The scalar |
| System.Byte[][] | b | The matrix |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Decimal, Byte[,], Byte[,])
Elementwise addition between a scalar a and a matrix b.
Declaration
public static byte[, ] Add(this decimal a, byte[, ] b, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | The scalar |
| System.Byte[,] | b | The matrix |
| System.Byte[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
Add(Decimal, Byte[,], Decimal[,])
Elementwise addition between a scalar a and a matrix b.
Declaration
public static decimal[, ] Add(this decimal a, byte[, ] b, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | The scalar |
| System.Byte[,] | b | The matrix |
| System.Decimal[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
Add(Decimal, Byte[,], Double[,])
Elementwise addition between a scalar a and a matrix b.
Declaration
public static double[, ] Add(this decimal a, byte[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | The scalar |
| System.Byte[,] | b | The matrix |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Decimal, Decimal[])
Elementwise addition between a scalar a and a vector b.
Declaration
public static decimal[] Add(this decimal a, decimal[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | The scalar |
| System.Decimal[] | b | The vector |
Returns
| Type | Description |
|---|---|
| System.Decimal[] |
Add(Decimal, Decimal[], Decimal[])
Elementwise addition between a scalar a and a vectorb.
Declaration
public static decimal[] Add(this decimal a, decimal[] b, decimal[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | The scalar |
| System.Decimal[] | b | The vector |
| System.Decimal[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[] |
Add(Decimal, Decimal[], Double[])
Elementwise addition between a scalar a and a vectorb.
Declaration
public static double[] Add(this decimal a, decimal[] b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | The scalar |
| System.Decimal[] | b | The vector |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Decimal, Decimal[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static decimal[][] Add(this decimal a, decimal[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | The scalar |
| System.Decimal[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
Add(Decimal, Decimal[][], Decimal[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static decimal[][] Add(this decimal a, decimal[][] b, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | The scalar |
| System.Decimal[][] | b | The matrix |
| System.Decimal[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
Add(Decimal, Decimal[][], Double[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static double[][] Add(this decimal a, decimal[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | The scalar |
| System.Decimal[][] | b | The matrix |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Decimal, Decimal[,])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static decimal[, ] Add(this decimal a, decimal[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | The scalar |
| System.Decimal[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
Add(Decimal, Decimal[,], Decimal[,])
Elementwise addition between a scalar a and a matrix b.
Declaration
public static decimal[, ] Add(this decimal a, decimal[, ] b, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | The scalar |
| System.Decimal[,] | b | The matrix |
| System.Decimal[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
Add(Decimal, Decimal[,], Double[,])
Elementwise addition between a scalar a and a matrix b.
Declaration
public static double[, ] Add(this decimal a, decimal[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | The scalar |
| System.Decimal[,] | b | The matrix |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Decimal, Double[])
Elementwise addition between a scalar a and a vector b.
Declaration
public static double[] Add(this decimal a, double[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | The scalar |
| System.Double[] | b | The vector |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Decimal, Double[], Decimal[])
Elementwise addition between a scalar a and a vectorb.
Declaration
public static decimal[] Add(this decimal a, double[] b, decimal[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | The scalar |
| System.Double[] | b | The vector |
| System.Decimal[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[] |
Add(Decimal, Double[], Double[])
Elementwise addition between a scalar a and a vectorb.
Declaration
public static double[] Add(this decimal a, double[] b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | The scalar |
| System.Double[] | b | The vector |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Decimal, Double[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static double[][] Add(this decimal a, double[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | The scalar |
| System.Double[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Decimal, Double[][], Decimal[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static decimal[][] Add(this decimal a, double[][] b, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | The scalar |
| System.Double[][] | b | The matrix |
| System.Decimal[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
Add(Decimal, Double[][], Double[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static double[][] Add(this decimal a, double[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | The scalar |
| System.Double[][] | b | The matrix |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Decimal, Double[,])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static double[, ] Add(this decimal a, double[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | The scalar |
| System.Double[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Decimal, Double[,], Decimal[,])
Elementwise addition between a scalar a and a matrix b.
Declaration
public static decimal[, ] Add(this decimal a, double[, ] b, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | The scalar |
| System.Double[,] | b | The matrix |
| System.Decimal[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
Add(Decimal, Double[,], Double[,])
Elementwise addition between a scalar a and a matrix b.
Declaration
public static double[, ] Add(this decimal a, double[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | The scalar |
| System.Double[,] | b | The matrix |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Decimal, Int16[], Decimal[])
Elementwise addition between a scalar a and a vectorb.
Declaration
public static decimal[] Add(this decimal a, short[] b, decimal[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | The scalar |
| System.Int16[] | b | The vector |
| System.Decimal[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[] |
Add(Decimal, Int16[], Double[])
Elementwise addition between a scalar a and a vectorb.
Declaration
public static double[] Add(this decimal a, short[] b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | The scalar |
| System.Int16[] | b | The vector |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Decimal, Int16[], Int16[])
Elementwise addition between a scalar a and a vectorb.
Declaration
public static short[] Add(this decimal a, short[] b, short[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | The scalar |
| System.Int16[] | b | The vector |
| System.Int16[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[] |
Add(Decimal, Int16[][], Decimal[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static decimal[][] Add(this decimal a, short[][] b, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | The scalar |
| System.Int16[][] | b | The matrix |
| System.Decimal[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
Add(Decimal, Int16[][], Double[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static double[][] Add(this decimal a, short[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | The scalar |
| System.Int16[][] | b | The matrix |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Decimal, Int16[][], Int16[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static short[][] Add(this decimal a, short[][] b, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | The scalar |
| System.Int16[][] | b | The matrix |
| System.Int16[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
Add(Decimal, Int16[,], Decimal[,])
Elementwise addition between a scalar a and a matrix b.
Declaration
public static decimal[, ] Add(this decimal a, short[, ] b, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | The scalar |
| System.Int16[,] | b | The matrix |
| System.Decimal[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
Add(Decimal, Int16[,], Double[,])
Elementwise addition between a scalar a and a matrix b.
Declaration
public static double[, ] Add(this decimal a, short[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | The scalar |
| System.Int16[,] | b | The matrix |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Decimal, Int16[,], Int16[,])
Elementwise addition between a scalar a and a matrix b.
Declaration
public static short[, ] Add(this decimal a, short[, ] b, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | The scalar |
| System.Int16[,] | b | The matrix |
| System.Int16[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
Add(Decimal, Int32[])
Elementwise addition between a scalar a and a vector b.
Declaration
public static int[] Add(this decimal a, int[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | The scalar |
| System.Int32[] | b | The vector |
Returns
| Type | Description |
|---|---|
| System.Int32[] |
Add(Decimal, Int32[], Decimal[])
Elementwise addition between a scalar a and a vectorb.
Declaration
public static decimal[] Add(this decimal a, int[] b, decimal[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | The scalar |
| System.Int32[] | b | The vector |
| System.Decimal[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[] |
Add(Decimal, Int32[], Double[])
Elementwise addition between a scalar a and a vectorb.
Declaration
public static double[] Add(this decimal a, int[] b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | The scalar |
| System.Int32[] | b | The vector |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Decimal, Int32[], Int32[])
Elementwise addition between a scalar a and a vectorb.
Declaration
public static int[] Add(this decimal a, int[] b, int[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | The scalar |
| System.Int32[] | b | The vector |
| System.Int32[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[] |
Add(Decimal, Int32[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static int[][] Add(this decimal a, int[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | The scalar |
| System.Int32[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
Add(Decimal, Int32[][], Decimal[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static decimal[][] Add(this decimal a, int[][] b, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | The scalar |
| System.Int32[][] | b | The matrix |
| System.Decimal[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
Add(Decimal, Int32[][], Double[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static double[][] Add(this decimal a, int[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | The scalar |
| System.Int32[][] | b | The matrix |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Decimal, Int32[][], Int32[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static int[][] Add(this decimal a, int[][] b, int[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | The scalar |
| System.Int32[][] | b | The matrix |
| System.Int32[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
Add(Decimal, Int32[,])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static int[, ] Add(this decimal a, int[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | The scalar |
| System.Int32[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
Add(Decimal, Int32[,], Decimal[,])
Elementwise addition between a scalar a and a matrix b.
Declaration
public static decimal[, ] Add(this decimal a, int[, ] b, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | The scalar |
| System.Int32[,] | b | The matrix |
| System.Decimal[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
Add(Decimal, Int32[,], Double[,])
Elementwise addition between a scalar a and a matrix b.
Declaration
public static double[, ] Add(this decimal a, int[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | The scalar |
| System.Int32[,] | b | The matrix |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Decimal, Int32[,], Int32[,])
Elementwise addition between a scalar a and a matrix b.
Declaration
public static int[, ] Add(this decimal a, int[, ] b, int[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | The scalar |
| System.Int32[,] | b | The matrix |
| System.Int32[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
Add(Decimal, Single[])
Elementwise addition between a scalar a and a vector b.
Declaration
public static float[] Add(this decimal a, float[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | The scalar |
| System.Single[] | b | The vector |
Returns
| Type | Description |
|---|---|
| System.Single[] |
Add(Decimal, Single[], Decimal[])
Elementwise addition between a scalar a and a vectorb.
Declaration
public static decimal[] Add(this decimal a, float[] b, decimal[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | The scalar |
| System.Single[] | b | The vector |
| System.Decimal[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[] |
Add(Decimal, Single[], Double[])
Elementwise addition between a scalar a and a vectorb.
Declaration
public static double[] Add(this decimal a, float[] b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | The scalar |
| System.Single[] | b | The vector |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Decimal, Single[], Single[])
Elementwise addition between a scalar a and a vectorb.
Declaration
public static float[] Add(this decimal a, float[] b, float[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | The scalar |
| System.Single[] | b | The vector |
| System.Single[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[] |
Add(Decimal, Single[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static float[][] Add(this decimal a, float[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | The scalar |
| System.Single[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Decimal, Single[][], Decimal[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static decimal[][] Add(this decimal a, float[][] b, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | The scalar |
| System.Single[][] | b | The matrix |
| System.Decimal[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
Add(Decimal, Single[][], Double[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static double[][] Add(this decimal a, float[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | The scalar |
| System.Single[][] | b | The matrix |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Decimal, Single[][], Single[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static float[][] Add(this decimal a, float[][] b, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | The scalar |
| System.Single[][] | b | The matrix |
| System.Single[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Decimal, Single[,])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static float[, ] Add(this decimal a, float[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | The scalar |
| System.Single[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Decimal, Single[,], Decimal[,])
Elementwise addition between a scalar a and a matrix b.
Declaration
public static decimal[, ] Add(this decimal a, float[, ] b, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | The scalar |
| System.Single[,] | b | The matrix |
| System.Decimal[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
Add(Decimal, Single[,], Double[,])
Elementwise addition between a scalar a and a matrix b.
Declaration
public static double[, ] Add(this decimal a, float[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | The scalar |
| System.Single[,] | b | The matrix |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Decimal, Single[,], Single[,])
Elementwise addition between a scalar a and a matrix b.
Declaration
public static float[, ] Add(this decimal a, float[, ] b, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | The scalar |
| System.Single[,] | b | The matrix |
| System.Single[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Decimal[], Byte, Byte[])
Elementwise addition between a vector a and a scalar b.
Declaration
public static byte[] Add(this decimal[] a, byte b, byte[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | The vector |
| System.Byte | b | The scalar |
| System.Byte[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[] |
Add(Decimal[], Byte, Decimal[])
Elementwise addition between a vector a and a scalar b.
Declaration
public static decimal[] Add(this decimal[] a, byte b, decimal[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | The vector |
| System.Byte | b | The scalar |
| System.Decimal[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[] |
Add(Decimal[], Byte, Double[])
Elementwise addition between a vector a and a scalar b.
Declaration
public static double[] Add(this decimal[] a, byte b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | The vector |
| System.Byte | b | The scalar |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Decimal[], Byte[], Byte[])
Elementwise addition between a vector a and a vectorb.
Declaration
public static byte[] Add(this decimal[] a, byte[] b, byte[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | The vector |
| System.Byte[] | b | The vector |
| System.Byte[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[] |
Add(Decimal[], Byte[], Decimal[])
Elementwise addition between a vector a and a vectorb.
Declaration
public static decimal[] Add(this decimal[] a, byte[] b, decimal[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | The vector |
| System.Byte[] | b | The vector |
| System.Decimal[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[] |
Add(Decimal[], Byte[], Double[])
Elementwise addition between a vector a and a vectorb.
Declaration
public static double[] Add(this decimal[] a, byte[] b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | The vector |
| System.Byte[] | b | The vector |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Decimal[], Byte[][], VectorType, Byte[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static byte[][] Add(this decimal[] a, byte[][] b, VectorType dimension, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | The vector |
| System.Byte[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Byte[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
Add(Decimal[], Byte[][], VectorType, Decimal[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static decimal[][] Add(this decimal[] a, byte[][] b, VectorType dimension, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | The vector |
| System.Byte[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Decimal[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
Add(Decimal[], Byte[][], VectorType, Double[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this decimal[] a, byte[][] b, VectorType dimension, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | The vector |
| System.Byte[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Decimal[], Byte[,], VectorType, Byte[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static byte[, ] Add(this decimal[] a, byte[, ] b, VectorType dimension, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | The vector |
| System.Byte[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Byte[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
Add(Decimal[], Byte[,], VectorType, Decimal[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static decimal[, ] Add(this decimal[] a, byte[, ] b, VectorType dimension, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | The vector |
| System.Byte[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Decimal[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
Add(Decimal[], Byte[,], VectorType, Double[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this decimal[] a, byte[, ] b, VectorType dimension, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | The vector |
| System.Byte[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Decimal[], Decimal)
Elementwise addition between a vector a and a scalar b.
Declaration
public static decimal[] Add(this decimal[] a, decimal b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | The vector |
| System.Decimal | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Decimal[] |
Add(Decimal[], Decimal, Decimal[])
Elementwise addition between a vector a and a scalar b.
Declaration
public static decimal[] Add(this decimal[] a, decimal b, decimal[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | The vector |
| System.Decimal | b | The scalar |
| System.Decimal[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[] |
Add(Decimal[], Decimal, Double[])
Elementwise addition between a vector a and a scalar b.
Declaration
public static double[] Add(this decimal[] a, decimal b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | The vector |
| System.Decimal | b | The scalar |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Decimal[], Decimal[])
Elementwise addition between a vector a and a vector b.
Declaration
public static decimal[] Add(this decimal[] a, decimal[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | The vector |
| System.Decimal[] | b | The vector |
Returns
| Type | Description |
|---|---|
| System.Decimal[] |
Add(Decimal[], Decimal[], Decimal[])
Elementwise addition between a vector a and a vectorb.
Declaration
public static decimal[] Add(this decimal[] a, decimal[] b, decimal[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | The vector |
| System.Decimal[] | b | The vector |
| System.Decimal[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[] |
Add(Decimal[], Decimal[], Double[])
Elementwise addition between a vector a and a vectorb.
Declaration
public static double[] Add(this decimal[] a, decimal[] b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | The vector |
| System.Decimal[] | b | The vector |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Decimal[], Decimal[][], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static decimal[][] Add(this decimal[] a, decimal[][] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | The vector |
| System.Decimal[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
Add(Decimal[], Decimal[][], VectorType, Decimal[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static decimal[][] Add(this decimal[] a, decimal[][] b, VectorType dimension, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | The vector |
| System.Decimal[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Decimal[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
Add(Decimal[], Decimal[][], VectorType, Double[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this decimal[] a, decimal[][] b, VectorType dimension, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | The vector |
| System.Decimal[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Decimal[], Decimal[,], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static decimal[, ] Add(this decimal[] a, decimal[, ] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | The vector |
| System.Decimal[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
Add(Decimal[], Decimal[,], VectorType, Decimal[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static decimal[, ] Add(this decimal[] a, decimal[, ] b, VectorType dimension, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | The vector |
| System.Decimal[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Decimal[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
Add(Decimal[], Decimal[,], VectorType, Double[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this decimal[] a, decimal[, ] b, VectorType dimension, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | The vector |
| System.Decimal[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Decimal[], Double)
Elementwise addition between a vector a and a scalar b.
Declaration
public static double[] Add(this decimal[] a, double b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | The vector |
| System.Double | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Decimal[], Double, Decimal[])
Elementwise addition between a vector a and a scalar b.
Declaration
public static decimal[] Add(this decimal[] a, double b, decimal[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | The vector |
| System.Double | b | The scalar |
| System.Decimal[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[] |
Add(Decimal[], Double, Double[])
Elementwise addition between a vector a and a scalar b.
Declaration
public static double[] Add(this decimal[] a, double b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | The vector |
| System.Double | b | The scalar |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Decimal[], Double[])
Elementwise addition between a vector a and a vector b.
Declaration
public static double[] Add(this decimal[] a, double[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | The vector |
| System.Double[] | b | The vector |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Decimal[], Double[], Decimal[])
Elementwise addition between a vector a and a vectorb.
Declaration
public static decimal[] Add(this decimal[] a, double[] b, decimal[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | The vector |
| System.Double[] | b | The vector |
| System.Decimal[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[] |
Add(Decimal[], Double[], Double[])
Elementwise addition between a vector a and a vectorb.
Declaration
public static double[] Add(this decimal[] a, double[] b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | The vector |
| System.Double[] | b | The vector |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Decimal[], Double[][], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this decimal[] a, double[][] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | The vector |
| System.Double[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Decimal[], Double[][], VectorType, Decimal[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static decimal[][] Add(this decimal[] a, double[][] b, VectorType dimension, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | The vector |
| System.Double[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Decimal[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
Add(Decimal[], Double[][], VectorType, Double[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this decimal[] a, double[][] b, VectorType dimension, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | The vector |
| System.Double[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Decimal[], Double[,], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this decimal[] a, double[, ] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | The vector |
| System.Double[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Decimal[], Double[,], VectorType, Decimal[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static decimal[, ] Add(this decimal[] a, double[, ] b, VectorType dimension, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | The vector |
| System.Double[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Decimal[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
Add(Decimal[], Double[,], VectorType, Double[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this decimal[] a, double[, ] b, VectorType dimension, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | The vector |
| System.Double[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Decimal[], Int16, Decimal[])
Elementwise addition between a vector a and a scalar b.
Declaration
public static decimal[] Add(this decimal[] a, short b, decimal[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | The vector |
| System.Int16 | b | The scalar |
| System.Decimal[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[] |
Add(Decimal[], Int16, Double[])
Elementwise addition between a vector a and a scalar b.
Declaration
public static double[] Add(this decimal[] a, short b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | The vector |
| System.Int16 | b | The scalar |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Decimal[], Int16, Int16[])
Elementwise addition between a vector a and a scalar b.
Declaration
public static short[] Add(this decimal[] a, short b, short[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | The vector |
| System.Int16 | b | The scalar |
| System.Int16[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[] |
Add(Decimal[], Int16[], Decimal[])
Elementwise addition between a vector a and a vectorb.
Declaration
public static decimal[] Add(this decimal[] a, short[] b, decimal[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | The vector |
| System.Int16[] | b | The vector |
| System.Decimal[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[] |
Add(Decimal[], Int16[], Double[])
Elementwise addition between a vector a and a vectorb.
Declaration
public static double[] Add(this decimal[] a, short[] b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | The vector |
| System.Int16[] | b | The vector |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Decimal[], Int16[], Int16[])
Elementwise addition between a vector a and a vectorb.
Declaration
public static short[] Add(this decimal[] a, short[] b, short[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | The vector |
| System.Int16[] | b | The vector |
| System.Int16[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[] |
Add(Decimal[], Int16[][], VectorType, Decimal[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static decimal[][] Add(this decimal[] a, short[][] b, VectorType dimension, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | The vector |
| System.Int16[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Decimal[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
Add(Decimal[], Int16[][], VectorType, Double[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this decimal[] a, short[][] b, VectorType dimension, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | The vector |
| System.Int16[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Decimal[], Int16[][], VectorType, Int16[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static short[][] Add(this decimal[] a, short[][] b, VectorType dimension, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | The vector |
| System.Int16[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Int16[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
Add(Decimal[], Int16[,], VectorType, Decimal[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static decimal[, ] Add(this decimal[] a, short[, ] b, VectorType dimension, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | The vector |
| System.Int16[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Decimal[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
Add(Decimal[], Int16[,], VectorType, Double[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this decimal[] a, short[, ] b, VectorType dimension, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | The vector |
| System.Int16[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Decimal[], Int16[,], VectorType, Int16[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static short[, ] Add(this decimal[] a, short[, ] b, VectorType dimension, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | The vector |
| System.Int16[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Int16[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
Add(Decimal[], Int32)
Elementwise addition between a vector a and a scalar b.
Declaration
public static int[] Add(this decimal[] a, int b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | The vector |
| System.Int32 | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Int32[] |
Add(Decimal[], Int32, Decimal[])
Elementwise addition between a vector a and a scalar b.
Declaration
public static decimal[] Add(this decimal[] a, int b, decimal[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | The vector |
| System.Int32 | b | The scalar |
| System.Decimal[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[] |
Add(Decimal[], Int32, Double[])
Elementwise addition between a vector a and a scalar b.
Declaration
public static double[] Add(this decimal[] a, int b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | The vector |
| System.Int32 | b | The scalar |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Decimal[], Int32, Int32[])
Elementwise addition between a vector a and a scalar b.
Declaration
public static int[] Add(this decimal[] a, int b, int[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | The vector |
| System.Int32 | b | The scalar |
| System.Int32[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[] |
Add(Decimal[], Int32[])
Elementwise addition between a vector a and a vector b.
Declaration
public static int[] Add(this decimal[] a, int[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | The vector |
| System.Int32[] | b | The vector |
Returns
| Type | Description |
|---|---|
| System.Int32[] |
Add(Decimal[], Int32[], Decimal[])
Elementwise addition between a vector a and a vectorb.
Declaration
public static decimal[] Add(this decimal[] a, int[] b, decimal[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | The vector |
| System.Int32[] | b | The vector |
| System.Decimal[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[] |
Add(Decimal[], Int32[], Double[])
Elementwise addition between a vector a and a vectorb.
Declaration
public static double[] Add(this decimal[] a, int[] b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | The vector |
| System.Int32[] | b | The vector |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Decimal[], Int32[], Int32[])
Elementwise addition between a vector a and a vectorb.
Declaration
public static int[] Add(this decimal[] a, int[] b, int[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | The vector |
| System.Int32[] | b | The vector |
| System.Int32[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[] |
Add(Decimal[], Int32[][], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static int[][] Add(this decimal[] a, int[][] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | The vector |
| System.Int32[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
Add(Decimal[], Int32[][], VectorType, Decimal[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static decimal[][] Add(this decimal[] a, int[][] b, VectorType dimension, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | The vector |
| System.Int32[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Decimal[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
Add(Decimal[], Int32[][], VectorType, Double[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this decimal[] a, int[][] b, VectorType dimension, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | The vector |
| System.Int32[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Decimal[], Int32[][], VectorType, Int32[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static int[][] Add(this decimal[] a, int[][] b, VectorType dimension, int[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | The vector |
| System.Int32[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Int32[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
Add(Decimal[], Int32[,], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static int[, ] Add(this decimal[] a, int[, ] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | The vector |
| System.Int32[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
Add(Decimal[], Int32[,], VectorType, Decimal[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static decimal[, ] Add(this decimal[] a, int[, ] b, VectorType dimension, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | The vector |
| System.Int32[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Decimal[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
Add(Decimal[], Int32[,], VectorType, Double[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this decimal[] a, int[, ] b, VectorType dimension, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | The vector |
| System.Int32[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Decimal[], Int32[,], VectorType, Int32[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static int[, ] Add(this decimal[] a, int[, ] b, VectorType dimension, int[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | The vector |
| System.Int32[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Int32[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
Add(Decimal[], Single)
Elementwise addition between a vector a and a scalar b.
Declaration
public static float[] Add(this decimal[] a, float b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | The vector |
| System.Single | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Single[] |
Add(Decimal[], Single, Decimal[])
Elementwise addition between a vector a and a scalar b.
Declaration
public static decimal[] Add(this decimal[] a, float b, decimal[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | The vector |
| System.Single | b | The scalar |
| System.Decimal[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[] |
Add(Decimal[], Single, Double[])
Elementwise addition between a vector a and a scalar b.
Declaration
public static double[] Add(this decimal[] a, float b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | The vector |
| System.Single | b | The scalar |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Decimal[], Single, Single[])
Elementwise addition between a vector a and a scalar b.
Declaration
public static float[] Add(this decimal[] a, float b, float[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | The vector |
| System.Single | b | The scalar |
| System.Single[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[] |
Add(Decimal[], Single[])
Elementwise addition between a vector a and a vector b.
Declaration
public static float[] Add(this decimal[] a, float[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | The vector |
| System.Single[] | b | The vector |
Returns
| Type | Description |
|---|---|
| System.Single[] |
Add(Decimal[], Single[], Decimal[])
Elementwise addition between a vector a and a vectorb.
Declaration
public static decimal[] Add(this decimal[] a, float[] b, decimal[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | The vector |
| System.Single[] | b | The vector |
| System.Decimal[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[] |
Add(Decimal[], Single[], Double[])
Elementwise addition between a vector a and a vectorb.
Declaration
public static double[] Add(this decimal[] a, float[] b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | The vector |
| System.Single[] | b | The vector |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Decimal[], Single[], Single[])
Elementwise addition between a vector a and a vectorb.
Declaration
public static float[] Add(this decimal[] a, float[] b, float[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | The vector |
| System.Single[] | b | The vector |
| System.Single[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[] |
Add(Decimal[], Single[][], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static float[][] Add(this decimal[] a, float[][] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | The vector |
| System.Single[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Decimal[], Single[][], VectorType, Decimal[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static decimal[][] Add(this decimal[] a, float[][] b, VectorType dimension, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | The vector |
| System.Single[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Decimal[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
Add(Decimal[], Single[][], VectorType, Double[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this decimal[] a, float[][] b, VectorType dimension, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | The vector |
| System.Single[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Decimal[], Single[][], VectorType, Single[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static float[][] Add(this decimal[] a, float[][] b, VectorType dimension, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | The vector |
| System.Single[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Single[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Decimal[], Single[,], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static float[, ] Add(this decimal[] a, float[, ] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | The vector |
| System.Single[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Decimal[], Single[,], VectorType, Decimal[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static decimal[, ] Add(this decimal[] a, float[, ] b, VectorType dimension, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | The vector |
| System.Single[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Decimal[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
Add(Decimal[], Single[,], VectorType, Double[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this decimal[] a, float[, ] b, VectorType dimension, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | The vector |
| System.Single[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Decimal[], Single[,], VectorType, Single[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static float[, ] Add(this decimal[] a, float[, ] b, VectorType dimension, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | The vector |
| System.Single[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Single[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Decimal[][], Byte, Byte[][])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static byte[][] Add(this decimal[][] a, byte b, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | The matrix |
| System.Byte | b | The scalar |
| System.Byte[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
Add(Decimal[][], Byte, Decimal[][])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static decimal[][] Add(this decimal[][] a, byte b, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | The matrix |
| System.Byte | b | The scalar |
| System.Decimal[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
Add(Decimal[][], Byte, Double[][])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[][] Add(this decimal[][] a, byte b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | The matrix |
| System.Byte | b | The scalar |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Decimal[][], Byte[], VectorType, Byte[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static byte[][] Add(this decimal[][] a, byte[] b, VectorType dimension, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | The matrix |
| System.Byte[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Byte[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
Add(Decimal[][], Byte[], VectorType, Decimal[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static decimal[][] Add(this decimal[][] a, byte[] b, VectorType dimension, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | The matrix |
| System.Byte[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Decimal[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
Add(Decimal[][], Byte[], VectorType, Double[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this decimal[][] a, byte[] b, VectorType dimension, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | The matrix |
| System.Byte[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Decimal[][], Byte[][], Byte[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static byte[][] Add(this decimal[][] a, byte[][] b, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | The matrix |
| System.Byte[][] | b | The matrix |
| System.Byte[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
Add(Decimal[][], Byte[][], Decimal[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static decimal[][] Add(this decimal[][] a, byte[][] b, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | The matrix |
| System.Byte[][] | b | The matrix |
| System.Decimal[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
Add(Decimal[][], Byte[][], Double[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[][] Add(this decimal[][] a, byte[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | The matrix |
| System.Byte[][] | b | The matrix |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Decimal[][], Decimal)
Elementwise addition between a matrix A and a scalar b.
Declaration
public static decimal[][] Add(this decimal[][] a, decimal b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | The matrix |
| System.Decimal | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
Add(Decimal[][], Decimal, Decimal[][])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static decimal[][] Add(this decimal[][] a, decimal b, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | The matrix |
| System.Decimal | b | The scalar |
| System.Decimal[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
Add(Decimal[][], Decimal, Double[][])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[][] Add(this decimal[][] a, decimal b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | The matrix |
| System.Decimal | b | The scalar |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Decimal[][], Decimal[], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static decimal[][] Add(this decimal[][] a, decimal[] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | The matrix |
| System.Decimal[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
Add(Decimal[][], Decimal[], VectorType, Decimal[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static decimal[][] Add(this decimal[][] a, decimal[] b, VectorType dimension, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | The matrix |
| System.Decimal[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Decimal[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
Add(Decimal[][], Decimal[], VectorType, Double[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this decimal[][] a, decimal[] b, VectorType dimension, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | The matrix |
| System.Decimal[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Decimal[][], Decimal[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static decimal[][] Add(this decimal[][] a, decimal[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | The matrix |
| System.Decimal[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
Add(Decimal[][], Decimal[][], Decimal[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static decimal[][] Add(this decimal[][] a, decimal[][] b, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | The matrix |
| System.Decimal[][] | b | The matrix |
| System.Decimal[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
Add(Decimal[][], Decimal[][], Double[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[][] Add(this decimal[][] a, decimal[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | The matrix |
| System.Decimal[][] | b | The matrix |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Decimal[][], Double)
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[][] Add(this decimal[][] a, double b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | The matrix |
| System.Double | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Decimal[][], Double, Decimal[][])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static decimal[][] Add(this decimal[][] a, double b, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | The matrix |
| System.Double | b | The scalar |
| System.Decimal[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
Add(Decimal[][], Double, Double[][])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[][] Add(this decimal[][] a, double b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | The matrix |
| System.Double | b | The scalar |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Decimal[][], Double[], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this decimal[][] a, double[] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | The matrix |
| System.Double[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Decimal[][], Double[], VectorType, Decimal[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static decimal[][] Add(this decimal[][] a, double[] b, VectorType dimension, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | The matrix |
| System.Double[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Decimal[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
Add(Decimal[][], Double[], VectorType, Double[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this decimal[][] a, double[] b, VectorType dimension, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | The matrix |
| System.Double[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Decimal[][], Double[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[][] Add(this decimal[][] a, double[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | The matrix |
| System.Double[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Decimal[][], Double[][], Decimal[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static decimal[][] Add(this decimal[][] a, double[][] b, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | The matrix |
| System.Double[][] | b | The matrix |
| System.Decimal[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
Add(Decimal[][], Double[][], Double[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[][] Add(this decimal[][] a, double[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | The matrix |
| System.Double[][] | b | The matrix |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Decimal[][], Int16, Decimal[][])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static decimal[][] Add(this decimal[][] a, short b, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | The matrix |
| System.Int16 | b | The scalar |
| System.Decimal[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
Add(Decimal[][], Int16, Double[][])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[][] Add(this decimal[][] a, short b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | The matrix |
| System.Int16 | b | The scalar |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Decimal[][], Int16, Int16[][])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static short[][] Add(this decimal[][] a, short b, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | The matrix |
| System.Int16 | b | The scalar |
| System.Int16[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
Add(Decimal[][], Int16[], VectorType, Decimal[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static decimal[][] Add(this decimal[][] a, short[] b, VectorType dimension, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | The matrix |
| System.Int16[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Decimal[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
Add(Decimal[][], Int16[], VectorType, Double[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this decimal[][] a, short[] b, VectorType dimension, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | The matrix |
| System.Int16[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Decimal[][], Int16[], VectorType, Int16[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static short[][] Add(this decimal[][] a, short[] b, VectorType dimension, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | The matrix |
| System.Int16[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Int16[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
Add(Decimal[][], Int16[][], Decimal[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static decimal[][] Add(this decimal[][] a, short[][] b, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | The matrix |
| System.Int16[][] | b | The matrix |
| System.Decimal[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
Add(Decimal[][], Int16[][], Double[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[][] Add(this decimal[][] a, short[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | The matrix |
| System.Int16[][] | b | The matrix |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Decimal[][], Int16[][], Int16[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static short[][] Add(this decimal[][] a, short[][] b, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | The matrix |
| System.Int16[][] | b | The matrix |
| System.Int16[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
Add(Decimal[][], Int32)
Elementwise addition between a matrix A and a scalar b.
Declaration
public static int[][] Add(this decimal[][] a, int b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | The matrix |
| System.Int32 | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
Add(Decimal[][], Int32, Decimal[][])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static decimal[][] Add(this decimal[][] a, int b, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | The matrix |
| System.Int32 | b | The scalar |
| System.Decimal[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
Add(Decimal[][], Int32, Double[][])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[][] Add(this decimal[][] a, int b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | The matrix |
| System.Int32 | b | The scalar |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Decimal[][], Int32, Int32[][])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static int[][] Add(this decimal[][] a, int b, int[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | The matrix |
| System.Int32 | b | The scalar |
| System.Int32[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
Add(Decimal[][], Int32[], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static int[][] Add(this decimal[][] a, int[] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | The matrix |
| System.Int32[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
Add(Decimal[][], Int32[], VectorType, Decimal[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static decimal[][] Add(this decimal[][] a, int[] b, VectorType dimension, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | The matrix |
| System.Int32[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Decimal[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
Add(Decimal[][], Int32[], VectorType, Double[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this decimal[][] a, int[] b, VectorType dimension, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | The matrix |
| System.Int32[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Decimal[][], Int32[], VectorType, Int32[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static int[][] Add(this decimal[][] a, int[] b, VectorType dimension, int[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | The matrix |
| System.Int32[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Int32[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
Add(Decimal[][], Int32[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static int[][] Add(this decimal[][] a, int[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | The matrix |
| System.Int32[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
Add(Decimal[][], Int32[][], Decimal[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static decimal[][] Add(this decimal[][] a, int[][] b, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | The matrix |
| System.Int32[][] | b | The matrix |
| System.Decimal[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
Add(Decimal[][], Int32[][], Double[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[][] Add(this decimal[][] a, int[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | The matrix |
| System.Int32[][] | b | The matrix |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Decimal[][], Int32[][], Int32[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static int[][] Add(this decimal[][] a, int[][] b, int[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | The matrix |
| System.Int32[][] | b | The matrix |
| System.Int32[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
Add(Decimal[][], Single)
Elementwise addition between a matrix A and a scalar b.
Declaration
public static float[][] Add(this decimal[][] a, float b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | The matrix |
| System.Single | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Decimal[][], Single, Decimal[][])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static decimal[][] Add(this decimal[][] a, float b, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | The matrix |
| System.Single | b | The scalar |
| System.Decimal[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
Add(Decimal[][], Single, Double[][])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[][] Add(this decimal[][] a, float b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | The matrix |
| System.Single | b | The scalar |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Decimal[][], Single, Single[][])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static float[][] Add(this decimal[][] a, float b, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | The matrix |
| System.Single | b | The scalar |
| System.Single[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Decimal[][], Single[], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static float[][] Add(this decimal[][] a, float[] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | The matrix |
| System.Single[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Decimal[][], Single[], VectorType, Decimal[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static decimal[][] Add(this decimal[][] a, float[] b, VectorType dimension, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | The matrix |
| System.Single[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Decimal[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
Add(Decimal[][], Single[], VectorType, Double[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this decimal[][] a, float[] b, VectorType dimension, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | The matrix |
| System.Single[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Decimal[][], Single[], VectorType, Single[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static float[][] Add(this decimal[][] a, float[] b, VectorType dimension, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | The matrix |
| System.Single[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Single[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Decimal[][], Single[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static float[][] Add(this decimal[][] a, float[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | The matrix |
| System.Single[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Decimal[][], Single[][], Decimal[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static decimal[][] Add(this decimal[][] a, float[][] b, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | The matrix |
| System.Single[][] | b | The matrix |
| System.Decimal[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
Add(Decimal[][], Single[][], Double[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[][] Add(this decimal[][] a, float[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | The matrix |
| System.Single[][] | b | The matrix |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Decimal[][], Single[][], Single[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static float[][] Add(this decimal[][] a, float[][] b, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | The matrix |
| System.Single[][] | b | The matrix |
| System.Single[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Decimal[,], Byte, Byte[,])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static byte[, ] Add(this decimal[, ] a, byte b, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | The matrix |
| System.Byte | b | The scalar |
| System.Byte[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
Add(Decimal[,], Byte, Decimal[,])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static decimal[, ] Add(this decimal[, ] a, byte b, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | The matrix |
| System.Byte | b | The scalar |
| System.Decimal[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
Add(Decimal[,], Byte, Double[,])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[, ] Add(this decimal[, ] a, byte b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | The matrix |
| System.Byte | b | The scalar |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Decimal[,], Byte[], VectorType, Byte[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static byte[, ] Add(this decimal[, ] a, byte[] b, VectorType dimension, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | The matrix |
| System.Byte[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Byte[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
Add(Decimal[,], Byte[], VectorType, Decimal[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static decimal[, ] Add(this decimal[, ] a, byte[] b, VectorType dimension, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | The matrix |
| System.Byte[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Decimal[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
Add(Decimal[,], Byte[], VectorType, Double[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this decimal[, ] a, byte[] b, VectorType dimension, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | The matrix |
| System.Byte[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Decimal[,], Byte[,], Byte[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static byte[, ] Add(this decimal[, ] a, byte[, ] b, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | The matrix |
| System.Byte[,] | b | The matrix |
| System.Byte[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
Add(Decimal[,], Byte[,], Decimal[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static decimal[, ] Add(this decimal[, ] a, byte[, ] b, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | The matrix |
| System.Byte[,] | b | The matrix |
| System.Decimal[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
Add(Decimal[,], Byte[,], Double[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[, ] Add(this decimal[, ] a, byte[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | The matrix |
| System.Byte[,] | b | The matrix |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Decimal[,], Decimal)
Elementwise addition between a matrix A and a scalar b.
Declaration
public static decimal[, ] Add(this decimal[, ] a, decimal b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | The matrix |
| System.Decimal | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
Add(Decimal[,], Decimal, Decimal[,])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static decimal[, ] Add(this decimal[, ] a, decimal b, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | The matrix |
| System.Decimal | b | The scalar |
| System.Decimal[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
Add(Decimal[,], Decimal, Double[,])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[, ] Add(this decimal[, ] a, decimal b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | The matrix |
| System.Decimal | b | The scalar |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Decimal[,], Decimal[], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static decimal[, ] Add(this decimal[, ] a, decimal[] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | The matrix |
| System.Decimal[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
Add(Decimal[,], Decimal[], VectorType, Decimal[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static decimal[, ] Add(this decimal[, ] a, decimal[] b, VectorType dimension, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | The matrix |
| System.Decimal[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Decimal[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
Add(Decimal[,], Decimal[], VectorType, Double[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this decimal[, ] a, decimal[] b, VectorType dimension, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | The matrix |
| System.Decimal[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Decimal[,], Decimal[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static decimal[, ] Add(this decimal[, ] a, decimal[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | The matrix |
| System.Decimal[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
Add(Decimal[,], Decimal[,], Decimal[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static decimal[, ] Add(this decimal[, ] a, decimal[, ] b, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | The matrix |
| System.Decimal[,] | b | The matrix |
| System.Decimal[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
Add(Decimal[,], Decimal[,], Double[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[, ] Add(this decimal[, ] a, decimal[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | The matrix |
| System.Decimal[,] | b | The matrix |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Decimal[,], Double)
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[, ] Add(this decimal[, ] a, double b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | The matrix |
| System.Double | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Decimal[,], Double, Decimal[,])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static decimal[, ] Add(this decimal[, ] a, double b, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | The matrix |
| System.Double | b | The scalar |
| System.Decimal[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
Add(Decimal[,], Double, Double[,])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[, ] Add(this decimal[, ] a, double b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | The matrix |
| System.Double | b | The scalar |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Decimal[,], Double[], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this decimal[, ] a, double[] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | The matrix |
| System.Double[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Decimal[,], Double[], VectorType, Decimal[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static decimal[, ] Add(this decimal[, ] a, double[] b, VectorType dimension, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | The matrix |
| System.Double[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Decimal[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
Add(Decimal[,], Double[], VectorType, Double[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this decimal[, ] a, double[] b, VectorType dimension, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | The matrix |
| System.Double[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Decimal[,], Double[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[, ] Add(this decimal[, ] a, double[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | The matrix |
| System.Double[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Decimal[,], Double[,], Decimal[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static decimal[, ] Add(this decimal[, ] a, double[, ] b, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | The matrix |
| System.Double[,] | b | The matrix |
| System.Decimal[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
Add(Decimal[,], Double[,], Double[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[, ] Add(this decimal[, ] a, double[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | The matrix |
| System.Double[,] | b | The matrix |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Decimal[,], Int16, Decimal[,])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static decimal[, ] Add(this decimal[, ] a, short b, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | The matrix |
| System.Int16 | b | The scalar |
| System.Decimal[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
Add(Decimal[,], Int16, Double[,])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[, ] Add(this decimal[, ] a, short b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | The matrix |
| System.Int16 | b | The scalar |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Decimal[,], Int16, Int16[,])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static short[, ] Add(this decimal[, ] a, short b, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | The matrix |
| System.Int16 | b | The scalar |
| System.Int16[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
Add(Decimal[,], Int16[], VectorType, Decimal[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static decimal[, ] Add(this decimal[, ] a, short[] b, VectorType dimension, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | The matrix |
| System.Int16[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Decimal[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
Add(Decimal[,], Int16[], VectorType, Double[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this decimal[, ] a, short[] b, VectorType dimension, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | The matrix |
| System.Int16[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Decimal[,], Int16[], VectorType, Int16[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static short[, ] Add(this decimal[, ] a, short[] b, VectorType dimension, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | The matrix |
| System.Int16[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Int16[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
Add(Decimal[,], Int16[,], Decimal[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static decimal[, ] Add(this decimal[, ] a, short[, ] b, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | The matrix |
| System.Int16[,] | b | The matrix |
| System.Decimal[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
Add(Decimal[,], Int16[,], Double[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[, ] Add(this decimal[, ] a, short[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | The matrix |
| System.Int16[,] | b | The matrix |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Decimal[,], Int16[,], Int16[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static short[, ] Add(this decimal[, ] a, short[, ] b, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | The matrix |
| System.Int16[,] | b | The matrix |
| System.Int16[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
Add(Decimal[,], Int32)
Elementwise addition between a matrix A and a scalar b.
Declaration
public static int[, ] Add(this decimal[, ] a, int b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | The matrix |
| System.Int32 | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
Add(Decimal[,], Int32, Decimal[,])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static decimal[, ] Add(this decimal[, ] a, int b, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | The matrix |
| System.Int32 | b | The scalar |
| System.Decimal[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
Add(Decimal[,], Int32, Double[,])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[, ] Add(this decimal[, ] a, int b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | The matrix |
| System.Int32 | b | The scalar |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Decimal[,], Int32, Int32[,])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static int[, ] Add(this decimal[, ] a, int b, int[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | The matrix |
| System.Int32 | b | The scalar |
| System.Int32[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
Add(Decimal[,], Int32[], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static int[, ] Add(this decimal[, ] a, int[] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | The matrix |
| System.Int32[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
Add(Decimal[,], Int32[], VectorType, Decimal[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static decimal[, ] Add(this decimal[, ] a, int[] b, VectorType dimension, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | The matrix |
| System.Int32[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Decimal[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
Add(Decimal[,], Int32[], VectorType, Double[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this decimal[, ] a, int[] b, VectorType dimension, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | The matrix |
| System.Int32[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Decimal[,], Int32[], VectorType, Int32[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static int[, ] Add(this decimal[, ] a, int[] b, VectorType dimension, int[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | The matrix |
| System.Int32[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Int32[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
Add(Decimal[,], Int32[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static int[, ] Add(this decimal[, ] a, int[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | The matrix |
| System.Int32[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
Add(Decimal[,], Int32[,], Decimal[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static decimal[, ] Add(this decimal[, ] a, int[, ] b, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | The matrix |
| System.Int32[,] | b | The matrix |
| System.Decimal[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
Add(Decimal[,], Int32[,], Double[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[, ] Add(this decimal[, ] a, int[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | The matrix |
| System.Int32[,] | b | The matrix |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Decimal[,], Int32[,], Int32[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static int[, ] Add(this decimal[, ] a, int[, ] b, int[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | The matrix |
| System.Int32[,] | b | The matrix |
| System.Int32[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
Add(Decimal[,], Single)
Elementwise addition between a matrix A and a scalar b.
Declaration
public static float[, ] Add(this decimal[, ] a, float b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | The matrix |
| System.Single | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Decimal[,], Single, Decimal[,])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static decimal[, ] Add(this decimal[, ] a, float b, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | The matrix |
| System.Single | b | The scalar |
| System.Decimal[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
Add(Decimal[,], Single, Double[,])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[, ] Add(this decimal[, ] a, float b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | The matrix |
| System.Single | b | The scalar |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Decimal[,], Single, Single[,])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static float[, ] Add(this decimal[, ] a, float b, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | The matrix |
| System.Single | b | The scalar |
| System.Single[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Decimal[,], Single[], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static float[, ] Add(this decimal[, ] a, float[] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | The matrix |
| System.Single[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Decimal[,], Single[], VectorType, Decimal[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static decimal[, ] Add(this decimal[, ] a, float[] b, VectorType dimension, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | The matrix |
| System.Single[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Decimal[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
Add(Decimal[,], Single[], VectorType, Double[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this decimal[, ] a, float[] b, VectorType dimension, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | The matrix |
| System.Single[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Decimal[,], Single[], VectorType, Single[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static float[, ] Add(this decimal[, ] a, float[] b, VectorType dimension, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | The matrix |
| System.Single[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Single[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Decimal[,], Single[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static float[, ] Add(this decimal[, ] a, float[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | The matrix |
| System.Single[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Decimal[,], Single[,], Decimal[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static decimal[, ] Add(this decimal[, ] a, float[, ] b, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | The matrix |
| System.Single[,] | b | The matrix |
| System.Decimal[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
Add(Decimal[,], Single[,], Double[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[, ] Add(this decimal[, ] a, float[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | The matrix |
| System.Single[,] | b | The matrix |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Decimal[,], Single[,], Single[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static float[, ] Add(this decimal[, ] a, float[, ] b, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | The matrix |
| System.Single[,] | b | The matrix |
| System.Single[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Double, Byte[])
Elementwise addition between a scalar a and a vector b.
Declaration
public static double[] Add(this double a, byte[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | The scalar |
| System.Byte[] | b | The vector |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Double, Byte[], Byte[])
Elementwise addition between a scalar a and a vectorb.
Declaration
public static byte[] Add(this double a, byte[] b, byte[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | The scalar |
| System.Byte[] | b | The vector |
| System.Byte[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[] |
Add(Double, Byte[], Double[])
Elementwise addition between a scalar a and a vectorb.
Declaration
public static double[] Add(this double a, byte[] b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | The scalar |
| System.Byte[] | b | The vector |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Double, Byte[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static double[][] Add(this double a, byte[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | The scalar |
| System.Byte[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Double, Byte[][], Byte[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static byte[][] Add(this double a, byte[][] b, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | The scalar |
| System.Byte[][] | b | The matrix |
| System.Byte[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
Add(Double, Byte[][], Double[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static double[][] Add(this double a, byte[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | The scalar |
| System.Byte[][] | b | The matrix |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Double, Byte[,])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static double[, ] Add(this double a, byte[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | The scalar |
| System.Byte[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Double, Byte[,], Byte[,])
Elementwise addition between a scalar a and a matrix b.
Declaration
public static byte[, ] Add(this double a, byte[, ] b, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | The scalar |
| System.Byte[,] | b | The matrix |
| System.Byte[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
Add(Double, Byte[,], Double[,])
Elementwise addition between a scalar a and a matrix b.
Declaration
public static double[, ] Add(this double a, byte[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | The scalar |
| System.Byte[,] | b | The matrix |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Double, Decimal[])
Elementwise addition between a scalar a and a vector b.
Declaration
public static double[] Add(this double a, decimal[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | The scalar |
| System.Decimal[] | b | The vector |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Double, Decimal[], Decimal[])
Elementwise addition between a scalar a and a vectorb.
Declaration
public static decimal[] Add(this double a, decimal[] b, decimal[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | The scalar |
| System.Decimal[] | b | The vector |
| System.Decimal[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[] |
Add(Double, Decimal[], Double[])
Elementwise addition between a scalar a and a vectorb.
Declaration
public static double[] Add(this double a, decimal[] b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | The scalar |
| System.Decimal[] | b | The vector |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Double, Decimal[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static double[][] Add(this double a, decimal[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | The scalar |
| System.Decimal[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Double, Decimal[][], Decimal[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static decimal[][] Add(this double a, decimal[][] b, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | The scalar |
| System.Decimal[][] | b | The matrix |
| System.Decimal[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
Add(Double, Decimal[][], Double[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static double[][] Add(this double a, decimal[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | The scalar |
| System.Decimal[][] | b | The matrix |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Double, Decimal[,])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static double[, ] Add(this double a, decimal[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | The scalar |
| System.Decimal[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Double, Decimal[,], Decimal[,])
Elementwise addition between a scalar a and a matrix b.
Declaration
public static decimal[, ] Add(this double a, decimal[, ] b, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | The scalar |
| System.Decimal[,] | b | The matrix |
| System.Decimal[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
Add(Double, Decimal[,], Double[,])
Elementwise addition between a scalar a and a matrix b.
Declaration
public static double[, ] Add(this double a, decimal[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | The scalar |
| System.Decimal[,] | b | The matrix |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Double, Double[])
Elementwise addition between a scalar a and a vector b.
Declaration
public static double[] Add(this double a, double[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | The scalar |
| System.Double[] | b | The vector |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Double, Double[], Double[])
Elementwise addition between a scalar a and a vectorb.
Declaration
public static double[] Add(this double a, double[] b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | The scalar |
| System.Double[] | b | The vector |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Double, Double[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static double[][] Add(this double a, double[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | The scalar |
| System.Double[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Double, Double[][], Double[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static double[][] Add(this double a, double[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | The scalar |
| System.Double[][] | b | The matrix |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Double, Double[,])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static double[, ] Add(this double a, double[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | The scalar |
| System.Double[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Double, Double[,], Double[,])
Elementwise addition between a scalar a and a matrix b.
Declaration
public static double[, ] Add(this double a, double[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | The scalar |
| System.Double[,] | b | The matrix |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Double, Int16[])
Elementwise addition between a scalar a and a vector b.
Declaration
public static double[] Add(this double a, short[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | The scalar |
| System.Int16[] | b | The vector |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Double, Int16[], Double[])
Elementwise addition between a scalar a and a vectorb.
Declaration
public static double[] Add(this double a, short[] b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | The scalar |
| System.Int16[] | b | The vector |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Double, Int16[], Int16[])
Elementwise addition between a scalar a and a vectorb.
Declaration
public static short[] Add(this double a, short[] b, short[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | The scalar |
| System.Int16[] | b | The vector |
| System.Int16[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[] |
Add(Double, Int16[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static double[][] Add(this double a, short[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | The scalar |
| System.Int16[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Double, Int16[][], Double[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static double[][] Add(this double a, short[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | The scalar |
| System.Int16[][] | b | The matrix |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Double, Int16[][], Int16[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static short[][] Add(this double a, short[][] b, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | The scalar |
| System.Int16[][] | b | The matrix |
| System.Int16[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
Add(Double, Int16[,])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static double[, ] Add(this double a, short[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | The scalar |
| System.Int16[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Double, Int16[,], Double[,])
Elementwise addition between a scalar a and a matrix b.
Declaration
public static double[, ] Add(this double a, short[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | The scalar |
| System.Int16[,] | b | The matrix |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Double, Int16[,], Int16[,])
Elementwise addition between a scalar a and a matrix b.
Declaration
public static short[, ] Add(this double a, short[, ] b, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | The scalar |
| System.Int16[,] | b | The matrix |
| System.Int16[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
Add(Double, Int32[])
Elementwise addition between a scalar a and a vector b.
Declaration
public static double[] Add(this double a, int[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | The scalar |
| System.Int32[] | b | The vector |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Double, Int32[], Double[])
Elementwise addition between a scalar a and a vectorb.
Declaration
public static double[] Add(this double a, int[] b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | The scalar |
| System.Int32[] | b | The vector |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Double, Int32[], Int32[])
Elementwise addition between a scalar a and a vectorb.
Declaration
public static int[] Add(this double a, int[] b, int[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | The scalar |
| System.Int32[] | b | The vector |
| System.Int32[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[] |
Add(Double, Int32[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static double[][] Add(this double a, int[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | The scalar |
| System.Int32[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Double, Int32[][], Double[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static double[][] Add(this double a, int[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | The scalar |
| System.Int32[][] | b | The matrix |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Double, Int32[][], Int32[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static int[][] Add(this double a, int[][] b, int[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | The scalar |
| System.Int32[][] | b | The matrix |
| System.Int32[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
Add(Double, Int32[,])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static double[, ] Add(this double a, int[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | The scalar |
| System.Int32[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Double, Int32[,], Double[,])
Elementwise addition between a scalar a and a matrix b.
Declaration
public static double[, ] Add(this double a, int[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | The scalar |
| System.Int32[,] | b | The matrix |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Double, Int32[,], Int32[,])
Elementwise addition between a scalar a and a matrix b.
Declaration
public static int[, ] Add(this double a, int[, ] b, int[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | The scalar |
| System.Int32[,] | b | The matrix |
| System.Int32[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
Add(Double, Single[])
Elementwise addition between a scalar a and a vector b.
Declaration
public static double[] Add(this double a, float[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | The scalar |
| System.Single[] | b | The vector |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Double, Single[], Double[])
Elementwise addition between a scalar a and a vectorb.
Declaration
public static double[] Add(this double a, float[] b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | The scalar |
| System.Single[] | b | The vector |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Double, Single[], Single[])
Elementwise addition between a scalar a and a vectorb.
Declaration
public static float[] Add(this double a, float[] b, float[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | The scalar |
| System.Single[] | b | The vector |
| System.Single[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[] |
Add(Double, Single[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static double[][] Add(this double a, float[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | The scalar |
| System.Single[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Double, Single[][], Double[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static double[][] Add(this double a, float[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | The scalar |
| System.Single[][] | b | The matrix |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Double, Single[][], Single[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static float[][] Add(this double a, float[][] b, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | The scalar |
| System.Single[][] | b | The matrix |
| System.Single[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Double, Single[,])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static double[, ] Add(this double a, float[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | The scalar |
| System.Single[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Double, Single[,], Double[,])
Elementwise addition between a scalar a and a matrix b.
Declaration
public static double[, ] Add(this double a, float[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | The scalar |
| System.Single[,] | b | The matrix |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Double, Single[,], Single[,])
Elementwise addition between a scalar a and a matrix b.
Declaration
public static float[, ] Add(this double a, float[, ] b, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | The scalar |
| System.Single[,] | b | The matrix |
| System.Single[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Double[], Byte)
Elementwise addition between a vector a and a scalar b.
Declaration
public static double[] Add(this double[] a, byte b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The vector |
| System.Byte | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Double[], Byte, Byte[])
Elementwise addition between a vector a and a scalar b.
Declaration
public static byte[] Add(this double[] a, byte b, byte[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The vector |
| System.Byte | b | The scalar |
| System.Byte[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[] |
Add(Double[], Byte, Double[])
Elementwise addition between a vector a and a scalar b.
Declaration
public static double[] Add(this double[] a, byte b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The vector |
| System.Byte | b | The scalar |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Double[], Byte[])
Elementwise addition between a vector a and a vector b.
Declaration
public static double[] Add(this double[] a, byte[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The vector |
| System.Byte[] | b | The vector |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Double[], Byte[], Byte[])
Elementwise addition between a vector a and a vectorb.
Declaration
public static byte[] Add(this double[] a, byte[] b, byte[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The vector |
| System.Byte[] | b | The vector |
| System.Byte[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[] |
Add(Double[], Byte[], Double[])
Elementwise addition between a vector a and a vectorb.
Declaration
public static double[] Add(this double[] a, byte[] b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The vector |
| System.Byte[] | b | The vector |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Double[], Byte[][], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this double[] a, byte[][] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The vector |
| System.Byte[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Double[], Byte[][], VectorType, Byte[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static byte[][] Add(this double[] a, byte[][] b, VectorType dimension, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The vector |
| System.Byte[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Byte[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
Add(Double[], Byte[][], VectorType, Double[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this double[] a, byte[][] b, VectorType dimension, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The vector |
| System.Byte[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Double[], Byte[,], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this double[] a, byte[, ] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The vector |
| System.Byte[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Double[], Byte[,], VectorType, Byte[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static byte[, ] Add(this double[] a, byte[, ] b, VectorType dimension, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The vector |
| System.Byte[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Byte[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
Add(Double[], Byte[,], VectorType, Double[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this double[] a, byte[, ] b, VectorType dimension, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The vector |
| System.Byte[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Double[], Decimal)
Elementwise addition between a vector a and a scalar b.
Declaration
public static double[] Add(this double[] a, decimal b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The vector |
| System.Decimal | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Double[], Decimal, Decimal[])
Elementwise addition between a vector a and a scalar b.
Declaration
public static decimal[] Add(this double[] a, decimal b, decimal[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The vector |
| System.Decimal | b | The scalar |
| System.Decimal[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[] |
Add(Double[], Decimal, Double[])
Elementwise addition between a vector a and a scalar b.
Declaration
public static double[] Add(this double[] a, decimal b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The vector |
| System.Decimal | b | The scalar |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Double[], Decimal[])
Elementwise addition between a vector a and a vector b.
Declaration
public static double[] Add(this double[] a, decimal[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The vector |
| System.Decimal[] | b | The vector |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Double[], Decimal[], Decimal[])
Elementwise addition between a vector a and a vectorb.
Declaration
public static decimal[] Add(this double[] a, decimal[] b, decimal[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The vector |
| System.Decimal[] | b | The vector |
| System.Decimal[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[] |
Add(Double[], Decimal[], Double[])
Elementwise addition between a vector a and a vectorb.
Declaration
public static double[] Add(this double[] a, decimal[] b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The vector |
| System.Decimal[] | b | The vector |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Double[], Decimal[][], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this double[] a, decimal[][] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The vector |
| System.Decimal[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Double[], Decimal[][], VectorType, Decimal[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static decimal[][] Add(this double[] a, decimal[][] b, VectorType dimension, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The vector |
| System.Decimal[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Decimal[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
Add(Double[], Decimal[][], VectorType, Double[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this double[] a, decimal[][] b, VectorType dimension, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The vector |
| System.Decimal[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Double[], Decimal[,], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this double[] a, decimal[, ] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The vector |
| System.Decimal[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Double[], Decimal[,], VectorType, Decimal[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static decimal[, ] Add(this double[] a, decimal[, ] b, VectorType dimension, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The vector |
| System.Decimal[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Decimal[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
Add(Double[], Decimal[,], VectorType, Double[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this double[] a, decimal[, ] b, VectorType dimension, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The vector |
| System.Decimal[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Double[], Double)
Elementwise addition between a vector a and a scalar b.
Declaration
public static double[] Add(this double[] a, double b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The vector |
| System.Double | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Double[], Double, Double[])
Elementwise addition between a vector a and a scalar b.
Declaration
public static double[] Add(this double[] a, double b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The vector |
| System.Double | b | The scalar |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Double[], Double[])
Elementwise addition between a vector a and a vector b.
Declaration
public static double[] Add(this double[] a, double[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The vector |
| System.Double[] | b | The vector |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Double[], Double[], Double[])
Elementwise addition between a vector a and a vectorb.
Declaration
public static double[] Add(this double[] a, double[] b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The vector |
| System.Double[] | b | The vector |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Double[], Double[][], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this double[] a, double[][] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The vector |
| System.Double[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Double[], Double[][], VectorType, Double[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this double[] a, double[][] b, VectorType dimension, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The vector |
| System.Double[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Double[], Double[,], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this double[] a, double[, ] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The vector |
| System.Double[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Double[], Double[,], VectorType, Double[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this double[] a, double[, ] b, VectorType dimension, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The vector |
| System.Double[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Double[], Int16)
Elementwise addition between a vector a and a scalar b.
Declaration
public static double[] Add(this double[] a, short b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The vector |
| System.Int16 | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Double[], Int16, Double[])
Elementwise addition between a vector a and a scalar b.
Declaration
public static double[] Add(this double[] a, short b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The vector |
| System.Int16 | b | The scalar |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Double[], Int16, Int16[])
Elementwise addition between a vector a and a scalar b.
Declaration
public static short[] Add(this double[] a, short b, short[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The vector |
| System.Int16 | b | The scalar |
| System.Int16[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[] |
Add(Double[], Int16[])
Elementwise addition between a vector a and a vector b.
Declaration
public static double[] Add(this double[] a, short[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The vector |
| System.Int16[] | b | The vector |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Double[], Int16[], Double[])
Elementwise addition between a vector a and a vectorb.
Declaration
public static double[] Add(this double[] a, short[] b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The vector |
| System.Int16[] | b | The vector |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Double[], Int16[], Int16[])
Elementwise addition between a vector a and a vectorb.
Declaration
public static short[] Add(this double[] a, short[] b, short[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The vector |
| System.Int16[] | b | The vector |
| System.Int16[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[] |
Add(Double[], Int16[][], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this double[] a, short[][] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The vector |
| System.Int16[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Double[], Int16[][], VectorType, Double[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this double[] a, short[][] b, VectorType dimension, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The vector |
| System.Int16[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Double[], Int16[][], VectorType, Int16[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static short[][] Add(this double[] a, short[][] b, VectorType dimension, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The vector |
| System.Int16[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Int16[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
Add(Double[], Int16[,], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this double[] a, short[, ] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The vector |
| System.Int16[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Double[], Int16[,], VectorType, Double[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this double[] a, short[, ] b, VectorType dimension, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The vector |
| System.Int16[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Double[], Int16[,], VectorType, Int16[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static short[, ] Add(this double[] a, short[, ] b, VectorType dimension, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The vector |
| System.Int16[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Int16[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
Add(Double[], Int32)
Elementwise addition between a vector a and a scalar b.
Declaration
public static double[] Add(this double[] a, int b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The vector |
| System.Int32 | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Double[], Int32, Double[])
Elementwise addition between a vector a and a scalar b.
Declaration
public static double[] Add(this double[] a, int b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The vector |
| System.Int32 | b | The scalar |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Double[], Int32, Int32[])
Elementwise addition between a vector a and a scalar b.
Declaration
public static int[] Add(this double[] a, int b, int[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The vector |
| System.Int32 | b | The scalar |
| System.Int32[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[] |
Add(Double[], Int32[])
Elementwise addition between a vector a and a vector b.
Declaration
public static double[] Add(this double[] a, int[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The vector |
| System.Int32[] | b | The vector |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Double[], Int32[], Double[])
Elementwise addition between a vector a and a vectorb.
Declaration
public static double[] Add(this double[] a, int[] b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The vector |
| System.Int32[] | b | The vector |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Double[], Int32[], Int32[])
Elementwise addition between a vector a and a vectorb.
Declaration
public static int[] Add(this double[] a, int[] b, int[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The vector |
| System.Int32[] | b | The vector |
| System.Int32[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[] |
Add(Double[], Int32[][], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this double[] a, int[][] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The vector |
| System.Int32[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Double[], Int32[][], VectorType, Double[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this double[] a, int[][] b, VectorType dimension, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The vector |
| System.Int32[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Double[], Int32[][], VectorType, Int32[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static int[][] Add(this double[] a, int[][] b, VectorType dimension, int[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The vector |
| System.Int32[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Int32[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
Add(Double[], Int32[,], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this double[] a, int[, ] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The vector |
| System.Int32[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Double[], Int32[,], VectorType, Double[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this double[] a, int[, ] b, VectorType dimension, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The vector |
| System.Int32[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Double[], Int32[,], VectorType, Int32[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static int[, ] Add(this double[] a, int[, ] b, VectorType dimension, int[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The vector |
| System.Int32[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Int32[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
Add(Double[], Single)
Elementwise addition between a vector a and a scalar b.
Declaration
public static double[] Add(this double[] a, float b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The vector |
| System.Single | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Double[], Single, Double[])
Elementwise addition between a vector a and a scalar b.
Declaration
public static double[] Add(this double[] a, float b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The vector |
| System.Single | b | The scalar |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Double[], Single, Single[])
Elementwise addition between a vector a and a scalar b.
Declaration
public static float[] Add(this double[] a, float b, float[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The vector |
| System.Single | b | The scalar |
| System.Single[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[] |
Add(Double[], Single[])
Elementwise addition between a vector a and a vector b.
Declaration
public static double[] Add(this double[] a, float[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The vector |
| System.Single[] | b | The vector |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Double[], Single[], Double[])
Elementwise addition between a vector a and a vectorb.
Declaration
public static double[] Add(this double[] a, float[] b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The vector |
| System.Single[] | b | The vector |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Double[], Single[], Single[])
Elementwise addition between a vector a and a vectorb.
Declaration
public static float[] Add(this double[] a, float[] b, float[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The vector |
| System.Single[] | b | The vector |
| System.Single[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[] |
Add(Double[], Single[][], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this double[] a, float[][] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The vector |
| System.Single[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Double[], Single[][], VectorType, Double[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this double[] a, float[][] b, VectorType dimension, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The vector |
| System.Single[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Double[], Single[][], VectorType, Single[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static float[][] Add(this double[] a, float[][] b, VectorType dimension, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The vector |
| System.Single[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Single[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Double[], Single[,], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this double[] a, float[, ] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The vector |
| System.Single[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Double[], Single[,], VectorType, Double[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this double[] a, float[, ] b, VectorType dimension, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The vector |
| System.Single[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Double[], Single[,], VectorType, Single[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static float[, ] Add(this double[] a, float[, ] b, VectorType dimension, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The vector |
| System.Single[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Single[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Double[][], Byte)
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[][] Add(this double[][] a, byte b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | The matrix |
| System.Byte | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Double[][], Byte, Byte[][])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static byte[][] Add(this double[][] a, byte b, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | The matrix |
| System.Byte | b | The scalar |
| System.Byte[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
Add(Double[][], Byte, Double[][])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[][] Add(this double[][] a, byte b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | The matrix |
| System.Byte | b | The scalar |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Double[][], Byte[], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this double[][] a, byte[] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | The matrix |
| System.Byte[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Double[][], Byte[], VectorType, Byte[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static byte[][] Add(this double[][] a, byte[] b, VectorType dimension, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | The matrix |
| System.Byte[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Byte[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
Add(Double[][], Byte[], VectorType, Double[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this double[][] a, byte[] b, VectorType dimension, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | The matrix |
| System.Byte[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Double[][], Byte[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[][] Add(this double[][] a, byte[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | The matrix |
| System.Byte[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Double[][], Byte[][], Byte[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static byte[][] Add(this double[][] a, byte[][] b, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | The matrix |
| System.Byte[][] | b | The matrix |
| System.Byte[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
Add(Double[][], Byte[][], Double[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[][] Add(this double[][] a, byte[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | The matrix |
| System.Byte[][] | b | The matrix |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Double[][], Decimal)
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[][] Add(this double[][] a, decimal b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | The matrix |
| System.Decimal | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Double[][], Decimal, Decimal[][])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static decimal[][] Add(this double[][] a, decimal b, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | The matrix |
| System.Decimal | b | The scalar |
| System.Decimal[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
Add(Double[][], Decimal, Double[][])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[][] Add(this double[][] a, decimal b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | The matrix |
| System.Decimal | b | The scalar |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Double[][], Decimal[], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this double[][] a, decimal[] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | The matrix |
| System.Decimal[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Double[][], Decimal[], VectorType, Decimal[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static decimal[][] Add(this double[][] a, decimal[] b, VectorType dimension, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | The matrix |
| System.Decimal[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Decimal[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
Add(Double[][], Decimal[], VectorType, Double[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this double[][] a, decimal[] b, VectorType dimension, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | The matrix |
| System.Decimal[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Double[][], Decimal[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[][] Add(this double[][] a, decimal[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | The matrix |
| System.Decimal[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Double[][], Decimal[][], Decimal[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static decimal[][] Add(this double[][] a, decimal[][] b, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | The matrix |
| System.Decimal[][] | b | The matrix |
| System.Decimal[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
Add(Double[][], Decimal[][], Double[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[][] Add(this double[][] a, decimal[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | The matrix |
| System.Decimal[][] | b | The matrix |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Double[][], Double)
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[][] Add(this double[][] a, double b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | The matrix |
| System.Double | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Double[][], Double, Double[][])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[][] Add(this double[][] a, double b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | The matrix |
| System.Double | b | The scalar |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Double[][], Double[], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this double[][] a, double[] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | The matrix |
| System.Double[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Double[][], Double[], VectorType, Double[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this double[][] a, double[] b, VectorType dimension, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | The matrix |
| System.Double[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Double[][], Double[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[][] Add(this double[][] a, double[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | The matrix |
| System.Double[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Double[][], Double[][], Double[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[][] Add(this double[][] a, double[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | The matrix |
| System.Double[][] | b | The matrix |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Double[][], Int16)
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[][] Add(this double[][] a, short b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | The matrix |
| System.Int16 | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Double[][], Int16, Double[][])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[][] Add(this double[][] a, short b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | The matrix |
| System.Int16 | b | The scalar |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Double[][], Int16, Int16[][])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static short[][] Add(this double[][] a, short b, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | The matrix |
| System.Int16 | b | The scalar |
| System.Int16[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
Add(Double[][], Int16[], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this double[][] a, short[] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | The matrix |
| System.Int16[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Double[][], Int16[], VectorType, Double[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this double[][] a, short[] b, VectorType dimension, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | The matrix |
| System.Int16[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Double[][], Int16[], VectorType, Int16[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static short[][] Add(this double[][] a, short[] b, VectorType dimension, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | The matrix |
| System.Int16[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Int16[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
Add(Double[][], Int16[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[][] Add(this double[][] a, short[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | The matrix |
| System.Int16[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Double[][], Int16[][], Double[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[][] Add(this double[][] a, short[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | The matrix |
| System.Int16[][] | b | The matrix |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Double[][], Int16[][], Int16[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static short[][] Add(this double[][] a, short[][] b, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | The matrix |
| System.Int16[][] | b | The matrix |
| System.Int16[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
Add(Double[][], Int32)
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[][] Add(this double[][] a, int b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | The matrix |
| System.Int32 | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Double[][], Int32, Double[][])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[][] Add(this double[][] a, int b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | The matrix |
| System.Int32 | b | The scalar |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Double[][], Int32, Int32[][])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static int[][] Add(this double[][] a, int b, int[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | The matrix |
| System.Int32 | b | The scalar |
| System.Int32[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
Add(Double[][], Int32[], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this double[][] a, int[] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | The matrix |
| System.Int32[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Double[][], Int32[], VectorType, Double[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this double[][] a, int[] b, VectorType dimension, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | The matrix |
| System.Int32[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Double[][], Int32[], VectorType, Int32[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static int[][] Add(this double[][] a, int[] b, VectorType dimension, int[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | The matrix |
| System.Int32[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Int32[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
Add(Double[][], Int32[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[][] Add(this double[][] a, int[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | The matrix |
| System.Int32[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Double[][], Int32[][], Double[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[][] Add(this double[][] a, int[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | The matrix |
| System.Int32[][] | b | The matrix |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Double[][], Int32[][], Int32[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static int[][] Add(this double[][] a, int[][] b, int[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | The matrix |
| System.Int32[][] | b | The matrix |
| System.Int32[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
Add(Double[][], Single)
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[][] Add(this double[][] a, float b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | The matrix |
| System.Single | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Double[][], Single, Double[][])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[][] Add(this double[][] a, float b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | The matrix |
| System.Single | b | The scalar |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Double[][], Single, Single[][])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static float[][] Add(this double[][] a, float b, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | The matrix |
| System.Single | b | The scalar |
| System.Single[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Double[][], Single[], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this double[][] a, float[] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | The matrix |
| System.Single[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Double[][], Single[], VectorType, Double[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this double[][] a, float[] b, VectorType dimension, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | The matrix |
| System.Single[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Double[][], Single[], VectorType, Single[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static float[][] Add(this double[][] a, float[] b, VectorType dimension, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | The matrix |
| System.Single[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Single[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Double[][], Single[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[][] Add(this double[][] a, float[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | The matrix |
| System.Single[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Double[][], Single[][], Double[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[][] Add(this double[][] a, float[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | The matrix |
| System.Single[][] | b | The matrix |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Double[][], Single[][], Single[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static float[][] Add(this double[][] a, float[][] b, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | The matrix |
| System.Single[][] | b | The matrix |
| System.Single[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Double[,], Byte)
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[, ] Add(this double[, ] a, byte b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | The matrix |
| System.Byte | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Double[,], Byte, Byte[,])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static byte[, ] Add(this double[, ] a, byte b, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | The matrix |
| System.Byte | b | The scalar |
| System.Byte[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
Add(Double[,], Byte, Double[,])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[, ] Add(this double[, ] a, byte b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | The matrix |
| System.Byte | b | The scalar |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Double[,], Byte[], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this double[, ] a, byte[] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | The matrix |
| System.Byte[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Double[,], Byte[], VectorType, Byte[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static byte[, ] Add(this double[, ] a, byte[] b, VectorType dimension, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | The matrix |
| System.Byte[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Byte[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
Add(Double[,], Byte[], VectorType, Double[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this double[, ] a, byte[] b, VectorType dimension, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | The matrix |
| System.Byte[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Double[,], Byte[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[, ] Add(this double[, ] a, byte[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | The matrix |
| System.Byte[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Double[,], Byte[,], Byte[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static byte[, ] Add(this double[, ] a, byte[, ] b, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | The matrix |
| System.Byte[,] | b | The matrix |
| System.Byte[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
Add(Double[,], Byte[,], Double[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[, ] Add(this double[, ] a, byte[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | The matrix |
| System.Byte[,] | b | The matrix |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Double[,], Decimal)
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[, ] Add(this double[, ] a, decimal b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | The matrix |
| System.Decimal | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Double[,], Decimal, Decimal[,])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static decimal[, ] Add(this double[, ] a, decimal b, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | The matrix |
| System.Decimal | b | The scalar |
| System.Decimal[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
Add(Double[,], Decimal, Double[,])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[, ] Add(this double[, ] a, decimal b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | The matrix |
| System.Decimal | b | The scalar |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Double[,], Decimal[], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this double[, ] a, decimal[] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | The matrix |
| System.Decimal[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Double[,], Decimal[], VectorType, Decimal[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static decimal[, ] Add(this double[, ] a, decimal[] b, VectorType dimension, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | The matrix |
| System.Decimal[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Decimal[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
Add(Double[,], Decimal[], VectorType, Double[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this double[, ] a, decimal[] b, VectorType dimension, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | The matrix |
| System.Decimal[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Double[,], Decimal[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[, ] Add(this double[, ] a, decimal[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | The matrix |
| System.Decimal[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Double[,], Decimal[,], Decimal[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static decimal[, ] Add(this double[, ] a, decimal[, ] b, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | The matrix |
| System.Decimal[,] | b | The matrix |
| System.Decimal[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
Add(Double[,], Decimal[,], Double[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[, ] Add(this double[, ] a, decimal[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | The matrix |
| System.Decimal[,] | b | The matrix |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Double[,], Double)
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[, ] Add(this double[, ] a, double b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | The matrix |
| System.Double | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Double[,], Double, Double[,])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[, ] Add(this double[, ] a, double b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | The matrix |
| System.Double | b | The scalar |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Double[,], Double[], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this double[, ] a, double[] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | The matrix |
| System.Double[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Double[,], Double[], VectorType, Double[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this double[, ] a, double[] b, VectorType dimension, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | The matrix |
| System.Double[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Double[,], Double[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[, ] Add(this double[, ] a, double[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | The matrix |
| System.Double[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Double[,], Double[,], Double[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[, ] Add(this double[, ] a, double[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | The matrix |
| System.Double[,] | b | The matrix |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Double[,], Int16)
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[, ] Add(this double[, ] a, short b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | The matrix |
| System.Int16 | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Double[,], Int16, Double[,])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[, ] Add(this double[, ] a, short b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | The matrix |
| System.Int16 | b | The scalar |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Double[,], Int16, Int16[,])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static short[, ] Add(this double[, ] a, short b, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | The matrix |
| System.Int16 | b | The scalar |
| System.Int16[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
Add(Double[,], Int16[], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this double[, ] a, short[] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | The matrix |
| System.Int16[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Double[,], Int16[], VectorType, Double[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this double[, ] a, short[] b, VectorType dimension, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | The matrix |
| System.Int16[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Double[,], Int16[], VectorType, Int16[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static short[, ] Add(this double[, ] a, short[] b, VectorType dimension, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | The matrix |
| System.Int16[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Int16[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
Add(Double[,], Int16[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[, ] Add(this double[, ] a, short[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | The matrix |
| System.Int16[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Double[,], Int16[,], Double[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[, ] Add(this double[, ] a, short[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | The matrix |
| System.Int16[,] | b | The matrix |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Double[,], Int16[,], Int16[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static short[, ] Add(this double[, ] a, short[, ] b, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | The matrix |
| System.Int16[,] | b | The matrix |
| System.Int16[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
Add(Double[,], Int32)
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[, ] Add(this double[, ] a, int b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | The matrix |
| System.Int32 | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Double[,], Int32, Double[,])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[, ] Add(this double[, ] a, int b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | The matrix |
| System.Int32 | b | The scalar |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Double[,], Int32, Int32[,])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static int[, ] Add(this double[, ] a, int b, int[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | The matrix |
| System.Int32 | b | The scalar |
| System.Int32[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
Add(Double[,], Int32[], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this double[, ] a, int[] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | The matrix |
| System.Int32[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Double[,], Int32[], VectorType, Double[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this double[, ] a, int[] b, VectorType dimension, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | The matrix |
| System.Int32[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Double[,], Int32[], VectorType, Int32[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static int[, ] Add(this double[, ] a, int[] b, VectorType dimension, int[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | The matrix |
| System.Int32[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Int32[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
Add(Double[,], Int32[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[, ] Add(this double[, ] a, int[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | The matrix |
| System.Int32[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Double[,], Int32[,], Double[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[, ] Add(this double[, ] a, int[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | The matrix |
| System.Int32[,] | b | The matrix |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Double[,], Int32[,], Int32[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static int[, ] Add(this double[, ] a, int[, ] b, int[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | The matrix |
| System.Int32[,] | b | The matrix |
| System.Int32[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
Add(Double[,], Single)
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[, ] Add(this double[, ] a, float b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | The matrix |
| System.Single | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Double[,], Single, Double[,])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[, ] Add(this double[, ] a, float b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | The matrix |
| System.Single | b | The scalar |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Double[,], Single, Single[,])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static float[, ] Add(this double[, ] a, float b, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | The matrix |
| System.Single | b | The scalar |
| System.Single[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Double[,], Single[], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this double[, ] a, float[] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | The matrix |
| System.Single[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Double[,], Single[], VectorType, Double[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this double[, ] a, float[] b, VectorType dimension, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | The matrix |
| System.Single[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Double[,], Single[], VectorType, Single[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static float[, ] Add(this double[, ] a, float[] b, VectorType dimension, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | The matrix |
| System.Single[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Single[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Double[,], Single[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[, ] Add(this double[, ] a, float[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | The matrix |
| System.Single[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Double[,], Single[,], Double[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[, ] Add(this double[, ] a, float[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | The matrix |
| System.Single[,] | b | The matrix |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Double[,], Single[,], Single[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static float[, ] Add(this double[, ] a, float[, ] b, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | The matrix |
| System.Single[,] | b | The matrix |
| System.Single[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Int16, Byte[], Byte[])
Elementwise addition between a scalar a and a vectorb.
Declaration
public static byte[] Add(this short a, byte[] b, byte[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | The scalar |
| System.Byte[] | b | The vector |
| System.Byte[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[] |
Add(Int16, Byte[], Double[])
Elementwise addition between a scalar a and a vectorb.
Declaration
public static double[] Add(this short a, byte[] b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | The scalar |
| System.Byte[] | b | The vector |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Int16, Byte[], Int16[])
Elementwise addition between a scalar a and a vectorb.
Declaration
public static short[] Add(this short a, byte[] b, short[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | The scalar |
| System.Byte[] | b | The vector |
| System.Int16[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[] |
Add(Int16, Byte[][], Byte[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static byte[][] Add(this short a, byte[][] b, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | The scalar |
| System.Byte[][] | b | The matrix |
| System.Byte[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
Add(Int16, Byte[][], Double[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static double[][] Add(this short a, byte[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | The scalar |
| System.Byte[][] | b | The matrix |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Int16, Byte[][], Int16[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static short[][] Add(this short a, byte[][] b, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | The scalar |
| System.Byte[][] | b | The matrix |
| System.Int16[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
Add(Int16, Byte[,], Byte[,])
Elementwise addition between a scalar a and a matrix b.
Declaration
public static byte[, ] Add(this short a, byte[, ] b, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | The scalar |
| System.Byte[,] | b | The matrix |
| System.Byte[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
Add(Int16, Byte[,], Double[,])
Elementwise addition between a scalar a and a matrix b.
Declaration
public static double[, ] Add(this short a, byte[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | The scalar |
| System.Byte[,] | b | The matrix |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Int16, Byte[,], Int16[,])
Elementwise addition between a scalar a and a matrix b.
Declaration
public static short[, ] Add(this short a, byte[, ] b, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | The scalar |
| System.Byte[,] | b | The matrix |
| System.Int16[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
Add(Int16, Decimal[], Decimal[])
Elementwise addition between a scalar a and a vectorb.
Declaration
public static decimal[] Add(this short a, decimal[] b, decimal[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | The scalar |
| System.Decimal[] | b | The vector |
| System.Decimal[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[] |
Add(Int16, Decimal[], Double[])
Elementwise addition between a scalar a and a vectorb.
Declaration
public static double[] Add(this short a, decimal[] b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | The scalar |
| System.Decimal[] | b | The vector |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Int16, Decimal[], Int16[])
Elementwise addition between a scalar a and a vectorb.
Declaration
public static short[] Add(this short a, decimal[] b, short[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | The scalar |
| System.Decimal[] | b | The vector |
| System.Int16[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[] |
Add(Int16, Decimal[][], Decimal[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static decimal[][] Add(this short a, decimal[][] b, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | The scalar |
| System.Decimal[][] | b | The matrix |
| System.Decimal[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
Add(Int16, Decimal[][], Double[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static double[][] Add(this short a, decimal[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | The scalar |
| System.Decimal[][] | b | The matrix |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Int16, Decimal[][], Int16[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static short[][] Add(this short a, decimal[][] b, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | The scalar |
| System.Decimal[][] | b | The matrix |
| System.Int16[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
Add(Int16, Decimal[,], Decimal[,])
Elementwise addition between a scalar a and a matrix b.
Declaration
public static decimal[, ] Add(this short a, decimal[, ] b, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | The scalar |
| System.Decimal[,] | b | The matrix |
| System.Decimal[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
Add(Int16, Decimal[,], Double[,])
Elementwise addition between a scalar a and a matrix b.
Declaration
public static double[, ] Add(this short a, decimal[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | The scalar |
| System.Decimal[,] | b | The matrix |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Int16, Decimal[,], Int16[,])
Elementwise addition between a scalar a and a matrix b.
Declaration
public static short[, ] Add(this short a, decimal[, ] b, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | The scalar |
| System.Decimal[,] | b | The matrix |
| System.Int16[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
Add(Int16, Double[])
Elementwise addition between a scalar a and a vector b.
Declaration
public static double[] Add(this short a, double[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | The scalar |
| System.Double[] | b | The vector |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Int16, Double[], Double[])
Elementwise addition between a scalar a and a vectorb.
Declaration
public static double[] Add(this short a, double[] b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | The scalar |
| System.Double[] | b | The vector |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Int16, Double[], Int16[])
Elementwise addition between a scalar a and a vectorb.
Declaration
public static short[] Add(this short a, double[] b, short[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | The scalar |
| System.Double[] | b | The vector |
| System.Int16[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[] |
Add(Int16, Double[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static double[][] Add(this short a, double[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | The scalar |
| System.Double[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Int16, Double[][], Double[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static double[][] Add(this short a, double[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | The scalar |
| System.Double[][] | b | The matrix |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Int16, Double[][], Int16[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static short[][] Add(this short a, double[][] b, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | The scalar |
| System.Double[][] | b | The matrix |
| System.Int16[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
Add(Int16, Double[,])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static double[, ] Add(this short a, double[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | The scalar |
| System.Double[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Int16, Double[,], Double[,])
Elementwise addition between a scalar a and a matrix b.
Declaration
public static double[, ] Add(this short a, double[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | The scalar |
| System.Double[,] | b | The matrix |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Int16, Double[,], Int16[,])
Elementwise addition between a scalar a and a matrix b.
Declaration
public static short[, ] Add(this short a, double[, ] b, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | The scalar |
| System.Double[,] | b | The matrix |
| System.Int16[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
Add(Int16, Int16[])
Elementwise addition between a scalar a and a vector b.
Declaration
public static short[] Add(this short a, short[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | The scalar |
| System.Int16[] | b | The vector |
Returns
| Type | Description |
|---|---|
| System.Int16[] |
Add(Int16, Int16[], Double[])
Elementwise addition between a scalar a and a vectorb.
Declaration
public static double[] Add(this short a, short[] b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | The scalar |
| System.Int16[] | b | The vector |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Int16, Int16[], Int16[])
Elementwise addition between a scalar a and a vectorb.
Declaration
public static short[] Add(this short a, short[] b, short[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | The scalar |
| System.Int16[] | b | The vector |
| System.Int16[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[] |
Add(Int16, Int16[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static short[][] Add(this short a, short[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | The scalar |
| System.Int16[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
Add(Int16, Int16[][], Double[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static double[][] Add(this short a, short[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | The scalar |
| System.Int16[][] | b | The matrix |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Int16, Int16[][], Int16[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static short[][] Add(this short a, short[][] b, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | The scalar |
| System.Int16[][] | b | The matrix |
| System.Int16[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
Add(Int16, Int16[,])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static short[, ] Add(this short a, short[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | The scalar |
| System.Int16[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
Add(Int16, Int16[,], Double[,])
Elementwise addition between a scalar a and a matrix b.
Declaration
public static double[, ] Add(this short a, short[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | The scalar |
| System.Int16[,] | b | The matrix |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Int16, Int16[,], Int16[,])
Elementwise addition between a scalar a and a matrix b.
Declaration
public static short[, ] Add(this short a, short[, ] b, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | The scalar |
| System.Int16[,] | b | The matrix |
| System.Int16[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
Add(Int16, Int32[])
Elementwise addition between a scalar a and a vector b.
Declaration
public static int[] Add(this short a, int[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | The scalar |
| System.Int32[] | b | The vector |
Returns
| Type | Description |
|---|---|
| System.Int32[] |
Add(Int16, Int32[], Double[])
Elementwise addition between a scalar a and a vectorb.
Declaration
public static double[] Add(this short a, int[] b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | The scalar |
| System.Int32[] | b | The vector |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Int16, Int32[], Int16[])
Elementwise addition between a scalar a and a vectorb.
Declaration
public static short[] Add(this short a, int[] b, short[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | The scalar |
| System.Int32[] | b | The vector |
| System.Int16[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[] |
Add(Int16, Int32[], Int32[])
Elementwise addition between a scalar a and a vectorb.
Declaration
public static int[] Add(this short a, int[] b, int[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | The scalar |
| System.Int32[] | b | The vector |
| System.Int32[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[] |
Add(Int16, Int32[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static int[][] Add(this short a, int[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | The scalar |
| System.Int32[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
Add(Int16, Int32[][], Double[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static double[][] Add(this short a, int[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | The scalar |
| System.Int32[][] | b | The matrix |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Int16, Int32[][], Int16[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static short[][] Add(this short a, int[][] b, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | The scalar |
| System.Int32[][] | b | The matrix |
| System.Int16[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
Add(Int16, Int32[][], Int32[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static int[][] Add(this short a, int[][] b, int[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | The scalar |
| System.Int32[][] | b | The matrix |
| System.Int32[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
Add(Int16, Int32[,])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static int[, ] Add(this short a, int[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | The scalar |
| System.Int32[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
Add(Int16, Int32[,], Double[,])
Elementwise addition between a scalar a and a matrix b.
Declaration
public static double[, ] Add(this short a, int[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | The scalar |
| System.Int32[,] | b | The matrix |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Int16, Int32[,], Int16[,])
Elementwise addition between a scalar a and a matrix b.
Declaration
public static short[, ] Add(this short a, int[, ] b, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | The scalar |
| System.Int32[,] | b | The matrix |
| System.Int16[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
Add(Int16, Int32[,], Int32[,])
Elementwise addition between a scalar a and a matrix b.
Declaration
public static int[, ] Add(this short a, int[, ] b, int[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | The scalar |
| System.Int32[,] | b | The matrix |
| System.Int32[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
Add(Int16, Single[])
Elementwise addition between a scalar a and a vector b.
Declaration
public static float[] Add(this short a, float[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | The scalar |
| System.Single[] | b | The vector |
Returns
| Type | Description |
|---|---|
| System.Single[] |
Add(Int16, Single[], Double[])
Elementwise addition between a scalar a and a vectorb.
Declaration
public static double[] Add(this short a, float[] b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | The scalar |
| System.Single[] | b | The vector |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Int16, Single[], Int16[])
Elementwise addition between a scalar a and a vectorb.
Declaration
public static short[] Add(this short a, float[] b, short[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | The scalar |
| System.Single[] | b | The vector |
| System.Int16[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[] |
Add(Int16, Single[], Single[])
Elementwise addition between a scalar a and a vectorb.
Declaration
public static float[] Add(this short a, float[] b, float[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | The scalar |
| System.Single[] | b | The vector |
| System.Single[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[] |
Add(Int16, Single[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static float[][] Add(this short a, float[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | The scalar |
| System.Single[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Int16, Single[][], Double[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static double[][] Add(this short a, float[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | The scalar |
| System.Single[][] | b | The matrix |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Int16, Single[][], Int16[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static short[][] Add(this short a, float[][] b, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | The scalar |
| System.Single[][] | b | The matrix |
| System.Int16[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
Add(Int16, Single[][], Single[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static float[][] Add(this short a, float[][] b, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | The scalar |
| System.Single[][] | b | The matrix |
| System.Single[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Int16, Single[,])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static float[, ] Add(this short a, float[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | The scalar |
| System.Single[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Int16, Single[,], Double[,])
Elementwise addition between a scalar a and a matrix b.
Declaration
public static double[, ] Add(this short a, float[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | The scalar |
| System.Single[,] | b | The matrix |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Int16, Single[,], Int16[,])
Elementwise addition between a scalar a and a matrix b.
Declaration
public static short[, ] Add(this short a, float[, ] b, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | The scalar |
| System.Single[,] | b | The matrix |
| System.Int16[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
Add(Int16, Single[,], Single[,])
Elementwise addition between a scalar a and a matrix b.
Declaration
public static float[, ] Add(this short a, float[, ] b, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | The scalar |
| System.Single[,] | b | The matrix |
| System.Single[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Int16[], Byte, Byte[])
Elementwise addition between a vector a and a scalar b.
Declaration
public static byte[] Add(this short[] a, byte b, byte[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | The vector |
| System.Byte | b | The scalar |
| System.Byte[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[] |
Add(Int16[], Byte, Double[])
Elementwise addition between a vector a and a scalar b.
Declaration
public static double[] Add(this short[] a, byte b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | The vector |
| System.Byte | b | The scalar |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Int16[], Byte, Int16[])
Elementwise addition between a vector a and a scalar b.
Declaration
public static short[] Add(this short[] a, byte b, short[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | The vector |
| System.Byte | b | The scalar |
| System.Int16[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[] |
Add(Int16[], Byte[], Byte[])
Elementwise addition between a vector a and a vectorb.
Declaration
public static byte[] Add(this short[] a, byte[] b, byte[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | The vector |
| System.Byte[] | b | The vector |
| System.Byte[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[] |
Add(Int16[], Byte[], Double[])
Elementwise addition between a vector a and a vectorb.
Declaration
public static double[] Add(this short[] a, byte[] b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | The vector |
| System.Byte[] | b | The vector |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Int16[], Byte[], Int16[])
Elementwise addition between a vector a and a vectorb.
Declaration
public static short[] Add(this short[] a, byte[] b, short[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | The vector |
| System.Byte[] | b | The vector |
| System.Int16[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[] |
Add(Int16[], Byte[][], VectorType, Byte[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static byte[][] Add(this short[] a, byte[][] b, VectorType dimension, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | The vector |
| System.Byte[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Byte[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
Add(Int16[], Byte[][], VectorType, Double[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this short[] a, byte[][] b, VectorType dimension, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | The vector |
| System.Byte[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Int16[], Byte[][], VectorType, Int16[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static short[][] Add(this short[] a, byte[][] b, VectorType dimension, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | The vector |
| System.Byte[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Int16[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
Add(Int16[], Byte[,], VectorType, Byte[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static byte[, ] Add(this short[] a, byte[, ] b, VectorType dimension, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | The vector |
| System.Byte[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Byte[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
Add(Int16[], Byte[,], VectorType, Double[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this short[] a, byte[, ] b, VectorType dimension, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | The vector |
| System.Byte[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Int16[], Byte[,], VectorType, Int16[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static short[, ] Add(this short[] a, byte[, ] b, VectorType dimension, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | The vector |
| System.Byte[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Int16[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
Add(Int16[], Decimal, Decimal[])
Elementwise addition between a vector a and a scalar b.
Declaration
public static decimal[] Add(this short[] a, decimal b, decimal[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | The vector |
| System.Decimal | b | The scalar |
| System.Decimal[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[] |
Add(Int16[], Decimal, Double[])
Elementwise addition between a vector a and a scalar b.
Declaration
public static double[] Add(this short[] a, decimal b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | The vector |
| System.Decimal | b | The scalar |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Int16[], Decimal, Int16[])
Elementwise addition between a vector a and a scalar b.
Declaration
public static short[] Add(this short[] a, decimal b, short[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | The vector |
| System.Decimal | b | The scalar |
| System.Int16[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[] |
Add(Int16[], Decimal[], Decimal[])
Elementwise addition between a vector a and a vectorb.
Declaration
public static decimal[] Add(this short[] a, decimal[] b, decimal[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | The vector |
| System.Decimal[] | b | The vector |
| System.Decimal[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[] |
Add(Int16[], Decimal[], Double[])
Elementwise addition between a vector a and a vectorb.
Declaration
public static double[] Add(this short[] a, decimal[] b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | The vector |
| System.Decimal[] | b | The vector |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Int16[], Decimal[], Int16[])
Elementwise addition between a vector a and a vectorb.
Declaration
public static short[] Add(this short[] a, decimal[] b, short[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | The vector |
| System.Decimal[] | b | The vector |
| System.Int16[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[] |
Add(Int16[], Decimal[][], VectorType, Decimal[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static decimal[][] Add(this short[] a, decimal[][] b, VectorType dimension, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | The vector |
| System.Decimal[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Decimal[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
Add(Int16[], Decimal[][], VectorType, Double[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this short[] a, decimal[][] b, VectorType dimension, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | The vector |
| System.Decimal[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Int16[], Decimal[][], VectorType, Int16[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static short[][] Add(this short[] a, decimal[][] b, VectorType dimension, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | The vector |
| System.Decimal[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Int16[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
Add(Int16[], Decimal[,], VectorType, Decimal[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static decimal[, ] Add(this short[] a, decimal[, ] b, VectorType dimension, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | The vector |
| System.Decimal[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Decimal[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
Add(Int16[], Decimal[,], VectorType, Double[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this short[] a, decimal[, ] b, VectorType dimension, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | The vector |
| System.Decimal[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Int16[], Decimal[,], VectorType, Int16[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static short[, ] Add(this short[] a, decimal[, ] b, VectorType dimension, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | The vector |
| System.Decimal[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Int16[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
Add(Int16[], Double)
Elementwise addition between a vector a and a scalar b.
Declaration
public static double[] Add(this short[] a, double b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | The vector |
| System.Double | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Int16[], Double, Double[])
Elementwise addition between a vector a and a scalar b.
Declaration
public static double[] Add(this short[] a, double b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | The vector |
| System.Double | b | The scalar |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Int16[], Double, Int16[])
Elementwise addition between a vector a and a scalar b.
Declaration
public static short[] Add(this short[] a, double b, short[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | The vector |
| System.Double | b | The scalar |
| System.Int16[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[] |
Add(Int16[], Double[])
Elementwise addition between a vector a and a vector b.
Declaration
public static double[] Add(this short[] a, double[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | The vector |
| System.Double[] | b | The vector |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Int16[], Double[], Double[])
Elementwise addition between a vector a and a vectorb.
Declaration
public static double[] Add(this short[] a, double[] b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | The vector |
| System.Double[] | b | The vector |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Int16[], Double[], Int16[])
Elementwise addition between a vector a and a vectorb.
Declaration
public static short[] Add(this short[] a, double[] b, short[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | The vector |
| System.Double[] | b | The vector |
| System.Int16[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[] |
Add(Int16[], Double[][], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this short[] a, double[][] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | The vector |
| System.Double[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Int16[], Double[][], VectorType, Double[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this short[] a, double[][] b, VectorType dimension, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | The vector |
| System.Double[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Int16[], Double[][], VectorType, Int16[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static short[][] Add(this short[] a, double[][] b, VectorType dimension, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | The vector |
| System.Double[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Int16[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
Add(Int16[], Double[,], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this short[] a, double[, ] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | The vector |
| System.Double[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Int16[], Double[,], VectorType, Double[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this short[] a, double[, ] b, VectorType dimension, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | The vector |
| System.Double[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Int16[], Double[,], VectorType, Int16[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static short[, ] Add(this short[] a, double[, ] b, VectorType dimension, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | The vector |
| System.Double[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Int16[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
Add(Int16[], Int16)
Elementwise addition between a vector a and a scalar b.
Declaration
public static short[] Add(this short[] a, short b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | The vector |
| System.Int16 | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Int16[] |
Add(Int16[], Int16, Double[])
Elementwise addition between a vector a and a scalar b.
Declaration
public static double[] Add(this short[] a, short b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | The vector |
| System.Int16 | b | The scalar |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Int16[], Int16, Int16[])
Elementwise addition between a vector a and a scalar b.
Declaration
public static short[] Add(this short[] a, short b, short[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | The vector |
| System.Int16 | b | The scalar |
| System.Int16[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[] |
Add(Int16[], Int16[])
Elementwise addition between a vector a and a vector b.
Declaration
public static short[] Add(this short[] a, short[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | The vector |
| System.Int16[] | b | The vector |
Returns
| Type | Description |
|---|---|
| System.Int16[] |
Add(Int16[], Int16[], Double[])
Elementwise addition between a vector a and a vectorb.
Declaration
public static double[] Add(this short[] a, short[] b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | The vector |
| System.Int16[] | b | The vector |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Int16[], Int16[], Int16[])
Elementwise addition between a vector a and a vectorb.
Declaration
public static short[] Add(this short[] a, short[] b, short[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | The vector |
| System.Int16[] | b | The vector |
| System.Int16[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[] |
Add(Int16[], Int16[][], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static short[][] Add(this short[] a, short[][] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | The vector |
| System.Int16[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
Add(Int16[], Int16[][], VectorType, Double[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this short[] a, short[][] b, VectorType dimension, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | The vector |
| System.Int16[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Int16[], Int16[][], VectorType, Int16[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static short[][] Add(this short[] a, short[][] b, VectorType dimension, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | The vector |
| System.Int16[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Int16[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
Add(Int16[], Int16[,], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static short[, ] Add(this short[] a, short[, ] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | The vector |
| System.Int16[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
Add(Int16[], Int16[,], VectorType, Double[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this short[] a, short[, ] b, VectorType dimension, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | The vector |
| System.Int16[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Int16[], Int16[,], VectorType, Int16[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static short[, ] Add(this short[] a, short[, ] b, VectorType dimension, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | The vector |
| System.Int16[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Int16[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
Add(Int16[], Int32)
Elementwise addition between a vector a and a scalar b.
Declaration
public static int[] Add(this short[] a, int b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | The vector |
| System.Int32 | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Int32[] |
Add(Int16[], Int32, Double[])
Elementwise addition between a vector a and a scalar b.
Declaration
public static double[] Add(this short[] a, int b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | The vector |
| System.Int32 | b | The scalar |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Int16[], Int32, Int16[])
Elementwise addition between a vector a and a scalar b.
Declaration
public static short[] Add(this short[] a, int b, short[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | The vector |
| System.Int32 | b | The scalar |
| System.Int16[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[] |
Add(Int16[], Int32, Int32[])
Elementwise addition between a vector a and a scalar b.
Declaration
public static int[] Add(this short[] a, int b, int[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | The vector |
| System.Int32 | b | The scalar |
| System.Int32[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[] |
Add(Int16[], Int32[])
Elementwise addition between a vector a and a vector b.
Declaration
public static int[] Add(this short[] a, int[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | The vector |
| System.Int32[] | b | The vector |
Returns
| Type | Description |
|---|---|
| System.Int32[] |
Add(Int16[], Int32[], Double[])
Elementwise addition between a vector a and a vectorb.
Declaration
public static double[] Add(this short[] a, int[] b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | The vector |
| System.Int32[] | b | The vector |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Int16[], Int32[], Int16[])
Elementwise addition between a vector a and a vectorb.
Declaration
public static short[] Add(this short[] a, int[] b, short[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | The vector |
| System.Int32[] | b | The vector |
| System.Int16[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[] |
Add(Int16[], Int32[], Int32[])
Elementwise addition between a vector a and a vectorb.
Declaration
public static int[] Add(this short[] a, int[] b, int[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | The vector |
| System.Int32[] | b | The vector |
| System.Int32[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[] |
Add(Int16[], Int32[][], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static int[][] Add(this short[] a, int[][] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | The vector |
| System.Int32[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
Add(Int16[], Int32[][], VectorType, Double[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this short[] a, int[][] b, VectorType dimension, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | The vector |
| System.Int32[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Int16[], Int32[][], VectorType, Int16[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static short[][] Add(this short[] a, int[][] b, VectorType dimension, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | The vector |
| System.Int32[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Int16[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
Add(Int16[], Int32[][], VectorType, Int32[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static int[][] Add(this short[] a, int[][] b, VectorType dimension, int[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | The vector |
| System.Int32[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Int32[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
Add(Int16[], Int32[,], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static int[, ] Add(this short[] a, int[, ] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | The vector |
| System.Int32[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
Add(Int16[], Int32[,], VectorType, Double[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this short[] a, int[, ] b, VectorType dimension, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | The vector |
| System.Int32[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Int16[], Int32[,], VectorType, Int16[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static short[, ] Add(this short[] a, int[, ] b, VectorType dimension, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | The vector |
| System.Int32[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Int16[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
Add(Int16[], Int32[,], VectorType, Int32[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static int[, ] Add(this short[] a, int[, ] b, VectorType dimension, int[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | The vector |
| System.Int32[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Int32[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
Add(Int16[], Single)
Elementwise addition between a vector a and a scalar b.
Declaration
public static float[] Add(this short[] a, float b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | The vector |
| System.Single | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Single[] |
Add(Int16[], Single, Double[])
Elementwise addition between a vector a and a scalar b.
Declaration
public static double[] Add(this short[] a, float b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | The vector |
| System.Single | b | The scalar |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Int16[], Single, Int16[])
Elementwise addition between a vector a and a scalar b.
Declaration
public static short[] Add(this short[] a, float b, short[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | The vector |
| System.Single | b | The scalar |
| System.Int16[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[] |
Add(Int16[], Single, Single[])
Elementwise addition between a vector a and a scalar b.
Declaration
public static float[] Add(this short[] a, float b, float[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | The vector |
| System.Single | b | The scalar |
| System.Single[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[] |
Add(Int16[], Single[])
Elementwise addition between a vector a and a vector b.
Declaration
public static float[] Add(this short[] a, float[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | The vector |
| System.Single[] | b | The vector |
Returns
| Type | Description |
|---|---|
| System.Single[] |
Add(Int16[], Single[], Double[])
Elementwise addition between a vector a and a vectorb.
Declaration
public static double[] Add(this short[] a, float[] b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | The vector |
| System.Single[] | b | The vector |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Int16[], Single[], Int16[])
Elementwise addition between a vector a and a vectorb.
Declaration
public static short[] Add(this short[] a, float[] b, short[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | The vector |
| System.Single[] | b | The vector |
| System.Int16[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[] |
Add(Int16[], Single[], Single[])
Elementwise addition between a vector a and a vectorb.
Declaration
public static float[] Add(this short[] a, float[] b, float[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | The vector |
| System.Single[] | b | The vector |
| System.Single[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[] |
Add(Int16[], Single[][], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static float[][] Add(this short[] a, float[][] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | The vector |
| System.Single[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Int16[], Single[][], VectorType, Double[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this short[] a, float[][] b, VectorType dimension, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | The vector |
| System.Single[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Int16[], Single[][], VectorType, Int16[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static short[][] Add(this short[] a, float[][] b, VectorType dimension, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | The vector |
| System.Single[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Int16[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
Add(Int16[], Single[][], VectorType, Single[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static float[][] Add(this short[] a, float[][] b, VectorType dimension, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | The vector |
| System.Single[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Single[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Int16[], Single[,], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static float[, ] Add(this short[] a, float[, ] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | The vector |
| System.Single[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Int16[], Single[,], VectorType, Double[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this short[] a, float[, ] b, VectorType dimension, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | The vector |
| System.Single[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Int16[], Single[,], VectorType, Int16[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static short[, ] Add(this short[] a, float[, ] b, VectorType dimension, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | The vector |
| System.Single[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Int16[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
Add(Int16[], Single[,], VectorType, Single[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static float[, ] Add(this short[] a, float[, ] b, VectorType dimension, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | The vector |
| System.Single[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Single[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Int16[][], Byte, Byte[][])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static byte[][] Add(this short[][] a, byte b, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | The matrix |
| System.Byte | b | The scalar |
| System.Byte[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
Add(Int16[][], Byte, Double[][])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[][] Add(this short[][] a, byte b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | The matrix |
| System.Byte | b | The scalar |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Int16[][], Byte, Int16[][])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static short[][] Add(this short[][] a, byte b, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | The matrix |
| System.Byte | b | The scalar |
| System.Int16[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
Add(Int16[][], Byte[], VectorType, Byte[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static byte[][] Add(this short[][] a, byte[] b, VectorType dimension, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | The matrix |
| System.Byte[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Byte[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
Add(Int16[][], Byte[], VectorType, Double[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this short[][] a, byte[] b, VectorType dimension, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | The matrix |
| System.Byte[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Int16[][], Byte[], VectorType, Int16[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static short[][] Add(this short[][] a, byte[] b, VectorType dimension, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | The matrix |
| System.Byte[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Int16[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
Add(Int16[][], Byte[][], Byte[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static byte[][] Add(this short[][] a, byte[][] b, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | The matrix |
| System.Byte[][] | b | The matrix |
| System.Byte[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
Add(Int16[][], Byte[][], Double[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[][] Add(this short[][] a, byte[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | The matrix |
| System.Byte[][] | b | The matrix |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Int16[][], Byte[][], Int16[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static short[][] Add(this short[][] a, byte[][] b, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | The matrix |
| System.Byte[][] | b | The matrix |
| System.Int16[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
Add(Int16[][], Decimal, Decimal[][])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static decimal[][] Add(this short[][] a, decimal b, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | The matrix |
| System.Decimal | b | The scalar |
| System.Decimal[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
Add(Int16[][], Decimal, Double[][])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[][] Add(this short[][] a, decimal b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | The matrix |
| System.Decimal | b | The scalar |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Int16[][], Decimal, Int16[][])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static short[][] Add(this short[][] a, decimal b, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | The matrix |
| System.Decimal | b | The scalar |
| System.Int16[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
Add(Int16[][], Decimal[], VectorType, Decimal[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static decimal[][] Add(this short[][] a, decimal[] b, VectorType dimension, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | The matrix |
| System.Decimal[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Decimal[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
Add(Int16[][], Decimal[], VectorType, Double[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this short[][] a, decimal[] b, VectorType dimension, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | The matrix |
| System.Decimal[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Int16[][], Decimal[], VectorType, Int16[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static short[][] Add(this short[][] a, decimal[] b, VectorType dimension, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | The matrix |
| System.Decimal[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Int16[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
Add(Int16[][], Decimal[][], Decimal[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static decimal[][] Add(this short[][] a, decimal[][] b, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | The matrix |
| System.Decimal[][] | b | The matrix |
| System.Decimal[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
Add(Int16[][], Decimal[][], Double[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[][] Add(this short[][] a, decimal[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | The matrix |
| System.Decimal[][] | b | The matrix |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Int16[][], Decimal[][], Int16[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static short[][] Add(this short[][] a, decimal[][] b, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | The matrix |
| System.Decimal[][] | b | The matrix |
| System.Int16[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
Add(Int16[][], Double)
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[][] Add(this short[][] a, double b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | The matrix |
| System.Double | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Int16[][], Double, Double[][])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[][] Add(this short[][] a, double b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | The matrix |
| System.Double | b | The scalar |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Int16[][], Double, Int16[][])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static short[][] Add(this short[][] a, double b, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | The matrix |
| System.Double | b | The scalar |
| System.Int16[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
Add(Int16[][], Double[], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this short[][] a, double[] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | The matrix |
| System.Double[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Int16[][], Double[], VectorType, Double[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this short[][] a, double[] b, VectorType dimension, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | The matrix |
| System.Double[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Int16[][], Double[], VectorType, Int16[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static short[][] Add(this short[][] a, double[] b, VectorType dimension, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | The matrix |
| System.Double[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Int16[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
Add(Int16[][], Double[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[][] Add(this short[][] a, double[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | The matrix |
| System.Double[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Int16[][], Double[][], Double[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[][] Add(this short[][] a, double[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | The matrix |
| System.Double[][] | b | The matrix |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Int16[][], Double[][], Int16[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static short[][] Add(this short[][] a, double[][] b, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | The matrix |
| System.Double[][] | b | The matrix |
| System.Int16[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
Add(Int16[][], Int16)
Elementwise addition between a matrix A and a scalar b.
Declaration
public static short[][] Add(this short[][] a, short b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | The matrix |
| System.Int16 | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
Add(Int16[][], Int16, Double[][])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[][] Add(this short[][] a, short b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | The matrix |
| System.Int16 | b | The scalar |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Int16[][], Int16, Int16[][])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static short[][] Add(this short[][] a, short b, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | The matrix |
| System.Int16 | b | The scalar |
| System.Int16[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
Add(Int16[][], Int16[], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static short[][] Add(this short[][] a, short[] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | The matrix |
| System.Int16[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
Add(Int16[][], Int16[], VectorType, Double[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this short[][] a, short[] b, VectorType dimension, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | The matrix |
| System.Int16[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Int16[][], Int16[], VectorType, Int16[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static short[][] Add(this short[][] a, short[] b, VectorType dimension, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | The matrix |
| System.Int16[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Int16[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
Add(Int16[][], Int16[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static short[][] Add(this short[][] a, short[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | The matrix |
| System.Int16[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
Add(Int16[][], Int16[][], Double[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[][] Add(this short[][] a, short[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | The matrix |
| System.Int16[][] | b | The matrix |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Int16[][], Int16[][], Int16[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static short[][] Add(this short[][] a, short[][] b, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | The matrix |
| System.Int16[][] | b | The matrix |
| System.Int16[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
Add(Int16[][], Int32)
Elementwise addition between a matrix A and a scalar b.
Declaration
public static int[][] Add(this short[][] a, int b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | The matrix |
| System.Int32 | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
Add(Int16[][], Int32, Double[][])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[][] Add(this short[][] a, int b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | The matrix |
| System.Int32 | b | The scalar |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Int16[][], Int32, Int16[][])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static short[][] Add(this short[][] a, int b, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | The matrix |
| System.Int32 | b | The scalar |
| System.Int16[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
Add(Int16[][], Int32, Int32[][])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static int[][] Add(this short[][] a, int b, int[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | The matrix |
| System.Int32 | b | The scalar |
| System.Int32[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
Add(Int16[][], Int32[], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static int[][] Add(this short[][] a, int[] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | The matrix |
| System.Int32[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
Add(Int16[][], Int32[], VectorType, Double[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this short[][] a, int[] b, VectorType dimension, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | The matrix |
| System.Int32[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Int16[][], Int32[], VectorType, Int16[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static short[][] Add(this short[][] a, int[] b, VectorType dimension, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | The matrix |
| System.Int32[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Int16[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
Add(Int16[][], Int32[], VectorType, Int32[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static int[][] Add(this short[][] a, int[] b, VectorType dimension, int[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | The matrix |
| System.Int32[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Int32[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
Add(Int16[][], Int32[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static int[][] Add(this short[][] a, int[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | The matrix |
| System.Int32[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
Add(Int16[][], Int32[][], Double[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[][] Add(this short[][] a, int[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | The matrix |
| System.Int32[][] | b | The matrix |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Int16[][], Int32[][], Int16[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static short[][] Add(this short[][] a, int[][] b, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | The matrix |
| System.Int32[][] | b | The matrix |
| System.Int16[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
Add(Int16[][], Int32[][], Int32[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static int[][] Add(this short[][] a, int[][] b, int[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | The matrix |
| System.Int32[][] | b | The matrix |
| System.Int32[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
Add(Int16[][], Single)
Elementwise addition between a matrix A and a scalar b.
Declaration
public static float[][] Add(this short[][] a, float b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | The matrix |
| System.Single | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Int16[][], Single, Double[][])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[][] Add(this short[][] a, float b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | The matrix |
| System.Single | b | The scalar |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Int16[][], Single, Int16[][])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static short[][] Add(this short[][] a, float b, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | The matrix |
| System.Single | b | The scalar |
| System.Int16[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
Add(Int16[][], Single, Single[][])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static float[][] Add(this short[][] a, float b, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | The matrix |
| System.Single | b | The scalar |
| System.Single[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Int16[][], Single[], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static float[][] Add(this short[][] a, float[] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | The matrix |
| System.Single[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Int16[][], Single[], VectorType, Double[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this short[][] a, float[] b, VectorType dimension, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | The matrix |
| System.Single[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Int16[][], Single[], VectorType, Int16[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static short[][] Add(this short[][] a, float[] b, VectorType dimension, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | The matrix |
| System.Single[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Int16[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
Add(Int16[][], Single[], VectorType, Single[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static float[][] Add(this short[][] a, float[] b, VectorType dimension, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | The matrix |
| System.Single[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Single[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Int16[][], Single[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static float[][] Add(this short[][] a, float[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | The matrix |
| System.Single[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Int16[][], Single[][], Double[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[][] Add(this short[][] a, float[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | The matrix |
| System.Single[][] | b | The matrix |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Int16[][], Single[][], Int16[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static short[][] Add(this short[][] a, float[][] b, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | The matrix |
| System.Single[][] | b | The matrix |
| System.Int16[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
Add(Int16[][], Single[][], Single[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static float[][] Add(this short[][] a, float[][] b, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | The matrix |
| System.Single[][] | b | The matrix |
| System.Single[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Int16[,], Byte, Byte[,])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static byte[, ] Add(this short[, ] a, byte b, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | The matrix |
| System.Byte | b | The scalar |
| System.Byte[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
Add(Int16[,], Byte, Double[,])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[, ] Add(this short[, ] a, byte b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | The matrix |
| System.Byte | b | The scalar |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Int16[,], Byte, Int16[,])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static short[, ] Add(this short[, ] a, byte b, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | The matrix |
| System.Byte | b | The scalar |
| System.Int16[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
Add(Int16[,], Byte[], VectorType, Byte[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static byte[, ] Add(this short[, ] a, byte[] b, VectorType dimension, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | The matrix |
| System.Byte[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Byte[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
Add(Int16[,], Byte[], VectorType, Double[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this short[, ] a, byte[] b, VectorType dimension, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | The matrix |
| System.Byte[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Int16[,], Byte[], VectorType, Int16[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static short[, ] Add(this short[, ] a, byte[] b, VectorType dimension, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | The matrix |
| System.Byte[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Int16[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
Add(Int16[,], Byte[,], Byte[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static byte[, ] Add(this short[, ] a, byte[, ] b, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | The matrix |
| System.Byte[,] | b | The matrix |
| System.Byte[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
Add(Int16[,], Byte[,], Double[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[, ] Add(this short[, ] a, byte[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | The matrix |
| System.Byte[,] | b | The matrix |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Int16[,], Byte[,], Int16[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static short[, ] Add(this short[, ] a, byte[, ] b, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | The matrix |
| System.Byte[,] | b | The matrix |
| System.Int16[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
Add(Int16[,], Decimal, Decimal[,])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static decimal[, ] Add(this short[, ] a, decimal b, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | The matrix |
| System.Decimal | b | The scalar |
| System.Decimal[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
Add(Int16[,], Decimal, Double[,])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[, ] Add(this short[, ] a, decimal b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | The matrix |
| System.Decimal | b | The scalar |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Int16[,], Decimal, Int16[,])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static short[, ] Add(this short[, ] a, decimal b, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | The matrix |
| System.Decimal | b | The scalar |
| System.Int16[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
Add(Int16[,], Decimal[], VectorType, Decimal[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static decimal[, ] Add(this short[, ] a, decimal[] b, VectorType dimension, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | The matrix |
| System.Decimal[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Decimal[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
Add(Int16[,], Decimal[], VectorType, Double[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this short[, ] a, decimal[] b, VectorType dimension, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | The matrix |
| System.Decimal[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Int16[,], Decimal[], VectorType, Int16[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static short[, ] Add(this short[, ] a, decimal[] b, VectorType dimension, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | The matrix |
| System.Decimal[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Int16[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
Add(Int16[,], Decimal[,], Decimal[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static decimal[, ] Add(this short[, ] a, decimal[, ] b, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | The matrix |
| System.Decimal[,] | b | The matrix |
| System.Decimal[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
Add(Int16[,], Decimal[,], Double[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[, ] Add(this short[, ] a, decimal[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | The matrix |
| System.Decimal[,] | b | The matrix |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Int16[,], Decimal[,], Int16[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static short[, ] Add(this short[, ] a, decimal[, ] b, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | The matrix |
| System.Decimal[,] | b | The matrix |
| System.Int16[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
Add(Int16[,], Double)
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[, ] Add(this short[, ] a, double b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | The matrix |
| System.Double | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Int16[,], Double, Double[,])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[, ] Add(this short[, ] a, double b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | The matrix |
| System.Double | b | The scalar |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Int16[,], Double, Int16[,])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static short[, ] Add(this short[, ] a, double b, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | The matrix |
| System.Double | b | The scalar |
| System.Int16[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
Add(Int16[,], Double[], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this short[, ] a, double[] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | The matrix |
| System.Double[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Int16[,], Double[], VectorType, Double[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this short[, ] a, double[] b, VectorType dimension, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | The matrix |
| System.Double[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Int16[,], Double[], VectorType, Int16[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static short[, ] Add(this short[, ] a, double[] b, VectorType dimension, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | The matrix |
| System.Double[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Int16[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
Add(Int16[,], Double[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[, ] Add(this short[, ] a, double[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | The matrix |
| System.Double[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Int16[,], Double[,], Double[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[, ] Add(this short[, ] a, double[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | The matrix |
| System.Double[,] | b | The matrix |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Int16[,], Double[,], Int16[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static short[, ] Add(this short[, ] a, double[, ] b, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | The matrix |
| System.Double[,] | b | The matrix |
| System.Int16[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
Add(Int16[,], Int16)
Elementwise addition between a matrix A and a scalar b.
Declaration
public static short[, ] Add(this short[, ] a, short b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | The matrix |
| System.Int16 | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
Add(Int16[,], Int16, Double[,])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[, ] Add(this short[, ] a, short b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | The matrix |
| System.Int16 | b | The scalar |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Int16[,], Int16, Int16[,])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static short[, ] Add(this short[, ] a, short b, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | The matrix |
| System.Int16 | b | The scalar |
| System.Int16[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
Add(Int16[,], Int16[], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static short[, ] Add(this short[, ] a, short[] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | The matrix |
| System.Int16[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
Add(Int16[,], Int16[], VectorType, Double[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this short[, ] a, short[] b, VectorType dimension, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | The matrix |
| System.Int16[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Int16[,], Int16[], VectorType, Int16[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static short[, ] Add(this short[, ] a, short[] b, VectorType dimension, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | The matrix |
| System.Int16[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Int16[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
Add(Int16[,], Int16[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static short[, ] Add(this short[, ] a, short[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | The matrix |
| System.Int16[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
Add(Int16[,], Int16[,], Double[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[, ] Add(this short[, ] a, short[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | The matrix |
| System.Int16[,] | b | The matrix |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Int16[,], Int16[,], Int16[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static short[, ] Add(this short[, ] a, short[, ] b, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | The matrix |
| System.Int16[,] | b | The matrix |
| System.Int16[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
Add(Int16[,], Int32)
Elementwise addition between a matrix A and a scalar b.
Declaration
public static int[, ] Add(this short[, ] a, int b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | The matrix |
| System.Int32 | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
Add(Int16[,], Int32, Double[,])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[, ] Add(this short[, ] a, int b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | The matrix |
| System.Int32 | b | The scalar |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Int16[,], Int32, Int16[,])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static short[, ] Add(this short[, ] a, int b, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | The matrix |
| System.Int32 | b | The scalar |
| System.Int16[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
Add(Int16[,], Int32, Int32[,])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static int[, ] Add(this short[, ] a, int b, int[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | The matrix |
| System.Int32 | b | The scalar |
| System.Int32[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
Add(Int16[,], Int32[], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static int[, ] Add(this short[, ] a, int[] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | The matrix |
| System.Int32[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
Add(Int16[,], Int32[], VectorType, Double[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this short[, ] a, int[] b, VectorType dimension, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | The matrix |
| System.Int32[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Int16[,], Int32[], VectorType, Int16[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static short[, ] Add(this short[, ] a, int[] b, VectorType dimension, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | The matrix |
| System.Int32[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Int16[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
Add(Int16[,], Int32[], VectorType, Int32[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static int[, ] Add(this short[, ] a, int[] b, VectorType dimension, int[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | The matrix |
| System.Int32[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Int32[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
Add(Int16[,], Int32[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static int[, ] Add(this short[, ] a, int[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | The matrix |
| System.Int32[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
Add(Int16[,], Int32[,], Double[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[, ] Add(this short[, ] a, int[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | The matrix |
| System.Int32[,] | b | The matrix |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Int16[,], Int32[,], Int16[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static short[, ] Add(this short[, ] a, int[, ] b, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | The matrix |
| System.Int32[,] | b | The matrix |
| System.Int16[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
Add(Int16[,], Int32[,], Int32[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static int[, ] Add(this short[, ] a, int[, ] b, int[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | The matrix |
| System.Int32[,] | b | The matrix |
| System.Int32[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
Add(Int16[,], Single)
Elementwise addition between a matrix A and a scalar b.
Declaration
public static float[, ] Add(this short[, ] a, float b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | The matrix |
| System.Single | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Int16[,], Single, Double[,])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[, ] Add(this short[, ] a, float b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | The matrix |
| System.Single | b | The scalar |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Int16[,], Single, Int16[,])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static short[, ] Add(this short[, ] a, float b, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | The matrix |
| System.Single | b | The scalar |
| System.Int16[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
Add(Int16[,], Single, Single[,])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static float[, ] Add(this short[, ] a, float b, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | The matrix |
| System.Single | b | The scalar |
| System.Single[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Int16[,], Single[], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static float[, ] Add(this short[, ] a, float[] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | The matrix |
| System.Single[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Int16[,], Single[], VectorType, Double[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this short[, ] a, float[] b, VectorType dimension, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | The matrix |
| System.Single[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Int16[,], Single[], VectorType, Int16[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static short[, ] Add(this short[, ] a, float[] b, VectorType dimension, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | The matrix |
| System.Single[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Int16[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
Add(Int16[,], Single[], VectorType, Single[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static float[, ] Add(this short[, ] a, float[] b, VectorType dimension, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | The matrix |
| System.Single[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Single[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Int16[,], Single[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static float[, ] Add(this short[, ] a, float[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | The matrix |
| System.Single[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Int16[,], Single[,], Double[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[, ] Add(this short[, ] a, float[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | The matrix |
| System.Single[,] | b | The matrix |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Int16[,], Single[,], Int16[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static short[, ] Add(this short[, ] a, float[, ] b, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | The matrix |
| System.Single[,] | b | The matrix |
| System.Int16[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
Add(Int16[,], Single[,], Single[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static float[, ] Add(this short[, ] a, float[, ] b, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | The matrix |
| System.Single[,] | b | The matrix |
| System.Single[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Int32, Byte[])
Elementwise addition between a scalar a and a vector b.
Declaration
public static int[] Add(this int a, byte[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | The scalar |
| System.Byte[] | b | The vector |
Returns
| Type | Description |
|---|---|
| System.Int32[] |
Add(Int32, Byte[], Byte[])
Elementwise addition between a scalar a and a vectorb.
Declaration
public static byte[] Add(this int a, byte[] b, byte[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | The scalar |
| System.Byte[] | b | The vector |
| System.Byte[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[] |
Add(Int32, Byte[], Double[])
Elementwise addition between a scalar a and a vectorb.
Declaration
public static double[] Add(this int a, byte[] b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | The scalar |
| System.Byte[] | b | The vector |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Int32, Byte[], Int32[])
Elementwise addition between a scalar a and a vectorb.
Declaration
public static int[] Add(this int a, byte[] b, int[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | The scalar |
| System.Byte[] | b | The vector |
| System.Int32[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[] |
Add(Int32, Byte[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static int[][] Add(this int a, byte[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | The scalar |
| System.Byte[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
Add(Int32, Byte[][], Byte[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static byte[][] Add(this int a, byte[][] b, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | The scalar |
| System.Byte[][] | b | The matrix |
| System.Byte[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
Add(Int32, Byte[][], Double[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static double[][] Add(this int a, byte[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | The scalar |
| System.Byte[][] | b | The matrix |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Int32, Byte[][], Int32[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static int[][] Add(this int a, byte[][] b, int[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | The scalar |
| System.Byte[][] | b | The matrix |
| System.Int32[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
Add(Int32, Byte[,])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static int[, ] Add(this int a, byte[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | The scalar |
| System.Byte[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
Add(Int32, Byte[,], Byte[,])
Elementwise addition between a scalar a and a matrix b.
Declaration
public static byte[, ] Add(this int a, byte[, ] b, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | The scalar |
| System.Byte[,] | b | The matrix |
| System.Byte[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
Add(Int32, Byte[,], Double[,])
Elementwise addition between a scalar a and a matrix b.
Declaration
public static double[, ] Add(this int a, byte[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | The scalar |
| System.Byte[,] | b | The matrix |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Int32, Byte[,], Int32[,])
Elementwise addition between a scalar a and a matrix b.
Declaration
public static int[, ] Add(this int a, byte[, ] b, int[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | The scalar |
| System.Byte[,] | b | The matrix |
| System.Int32[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
Add(Int32, Decimal[])
Elementwise addition between a scalar a and a vector b.
Declaration
public static int[] Add(this int a, decimal[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | The scalar |
| System.Decimal[] | b | The vector |
Returns
| Type | Description |
|---|---|
| System.Int32[] |
Add(Int32, Decimal[], Decimal[])
Elementwise addition between a scalar a and a vectorb.
Declaration
public static decimal[] Add(this int a, decimal[] b, decimal[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | The scalar |
| System.Decimal[] | b | The vector |
| System.Decimal[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[] |
Add(Int32, Decimal[], Double[])
Elementwise addition between a scalar a and a vectorb.
Declaration
public static double[] Add(this int a, decimal[] b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | The scalar |
| System.Decimal[] | b | The vector |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Int32, Decimal[], Int32[])
Elementwise addition between a scalar a and a vectorb.
Declaration
public static int[] Add(this int a, decimal[] b, int[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | The scalar |
| System.Decimal[] | b | The vector |
| System.Int32[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[] |
Add(Int32, Decimal[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static int[][] Add(this int a, decimal[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | The scalar |
| System.Decimal[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
Add(Int32, Decimal[][], Decimal[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static decimal[][] Add(this int a, decimal[][] b, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | The scalar |
| System.Decimal[][] | b | The matrix |
| System.Decimal[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
Add(Int32, Decimal[][], Double[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static double[][] Add(this int a, decimal[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | The scalar |
| System.Decimal[][] | b | The matrix |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Int32, Decimal[][], Int32[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static int[][] Add(this int a, decimal[][] b, int[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | The scalar |
| System.Decimal[][] | b | The matrix |
| System.Int32[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
Add(Int32, Decimal[,])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static int[, ] Add(this int a, decimal[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | The scalar |
| System.Decimal[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
Add(Int32, Decimal[,], Decimal[,])
Elementwise addition between a scalar a and a matrix b.
Declaration
public static decimal[, ] Add(this int a, decimal[, ] b, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | The scalar |
| System.Decimal[,] | b | The matrix |
| System.Decimal[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
Add(Int32, Decimal[,], Double[,])
Elementwise addition between a scalar a and a matrix b.
Declaration
public static double[, ] Add(this int a, decimal[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | The scalar |
| System.Decimal[,] | b | The matrix |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Int32, Decimal[,], Int32[,])
Elementwise addition between a scalar a and a matrix b.
Declaration
public static int[, ] Add(this int a, decimal[, ] b, int[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | The scalar |
| System.Decimal[,] | b | The matrix |
| System.Int32[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
Add(Int32, Double[])
Elementwise addition between a scalar a and a vector b.
Declaration
public static double[] Add(this int a, double[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | The scalar |
| System.Double[] | b | The vector |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Int32, Double[], Double[])
Elementwise addition between a scalar a and a vectorb.
Declaration
public static double[] Add(this int a, double[] b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | The scalar |
| System.Double[] | b | The vector |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Int32, Double[], Int32[])
Elementwise addition between a scalar a and a vectorb.
Declaration
public static int[] Add(this int a, double[] b, int[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | The scalar |
| System.Double[] | b | The vector |
| System.Int32[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[] |
Add(Int32, Double[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static double[][] Add(this int a, double[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | The scalar |
| System.Double[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Int32, Double[][], Double[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static double[][] Add(this int a, double[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | The scalar |
| System.Double[][] | b | The matrix |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Int32, Double[][], Int32[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static int[][] Add(this int a, double[][] b, int[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | The scalar |
| System.Double[][] | b | The matrix |
| System.Int32[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
Add(Int32, Double[,])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static double[, ] Add(this int a, double[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | The scalar |
| System.Double[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Int32, Double[,], Double[,])
Elementwise addition between a scalar a and a matrix b.
Declaration
public static double[, ] Add(this int a, double[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | The scalar |
| System.Double[,] | b | The matrix |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Int32, Double[,], Int32[,])
Elementwise addition between a scalar a and a matrix b.
Declaration
public static int[, ] Add(this int a, double[, ] b, int[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | The scalar |
| System.Double[,] | b | The matrix |
| System.Int32[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
Add(Int32, Int16[])
Elementwise addition between a scalar a and a vector b.
Declaration
public static int[] Add(this int a, short[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | The scalar |
| System.Int16[] | b | The vector |
Returns
| Type | Description |
|---|---|
| System.Int32[] |
Add(Int32, Int16[], Double[])
Elementwise addition between a scalar a and a vectorb.
Declaration
public static double[] Add(this int a, short[] b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | The scalar |
| System.Int16[] | b | The vector |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Int32, Int16[], Int16[])
Elementwise addition between a scalar a and a vectorb.
Declaration
public static short[] Add(this int a, short[] b, short[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | The scalar |
| System.Int16[] | b | The vector |
| System.Int16[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[] |
Add(Int32, Int16[], Int32[])
Elementwise addition between a scalar a and a vectorb.
Declaration
public static int[] Add(this int a, short[] b, int[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | The scalar |
| System.Int16[] | b | The vector |
| System.Int32[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[] |
Add(Int32, Int16[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static int[][] Add(this int a, short[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | The scalar |
| System.Int16[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
Add(Int32, Int16[][], Double[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static double[][] Add(this int a, short[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | The scalar |
| System.Int16[][] | b | The matrix |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Int32, Int16[][], Int16[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static short[][] Add(this int a, short[][] b, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | The scalar |
| System.Int16[][] | b | The matrix |
| System.Int16[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
Add(Int32, Int16[][], Int32[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static int[][] Add(this int a, short[][] b, int[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | The scalar |
| System.Int16[][] | b | The matrix |
| System.Int32[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
Add(Int32, Int16[,])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static int[, ] Add(this int a, short[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | The scalar |
| System.Int16[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
Add(Int32, Int16[,], Double[,])
Elementwise addition between a scalar a and a matrix b.
Declaration
public static double[, ] Add(this int a, short[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | The scalar |
| System.Int16[,] | b | The matrix |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Int32, Int16[,], Int16[,])
Elementwise addition between a scalar a and a matrix b.
Declaration
public static short[, ] Add(this int a, short[, ] b, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | The scalar |
| System.Int16[,] | b | The matrix |
| System.Int16[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
Add(Int32, Int16[,], Int32[,])
Elementwise addition between a scalar a and a matrix b.
Declaration
public static int[, ] Add(this int a, short[, ] b, int[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | The scalar |
| System.Int16[,] | b | The matrix |
| System.Int32[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
Add(Int32, Int32[])
Elementwise addition between a scalar a and a vector b.
Declaration
public static int[] Add(this int a, int[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | The scalar |
| System.Int32[] | b | The vector |
Returns
| Type | Description |
|---|---|
| System.Int32[] |
Add(Int32, Int32[], Double[])
Elementwise addition between a scalar a and a vectorb.
Declaration
public static double[] Add(this int a, int[] b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | The scalar |
| System.Int32[] | b | The vector |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Int32, Int32[], Int32[])
Elementwise addition between a scalar a and a vectorb.
Declaration
public static int[] Add(this int a, int[] b, int[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | The scalar |
| System.Int32[] | b | The vector |
| System.Int32[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[] |
Add(Int32, Int32[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static int[][] Add(this int a, int[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | The scalar |
| System.Int32[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
Add(Int32, Int32[][], Double[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static double[][] Add(this int a, int[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | The scalar |
| System.Int32[][] | b | The matrix |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Int32, Int32[][], Int32[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static int[][] Add(this int a, int[][] b, int[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | The scalar |
| System.Int32[][] | b | The matrix |
| System.Int32[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
Add(Int32, Int32[,])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static int[, ] Add(this int a, int[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | The scalar |
| System.Int32[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
Add(Int32, Int32[,], Double[,])
Elementwise addition between a scalar a and a matrix b.
Declaration
public static double[, ] Add(this int a, int[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | The scalar |
| System.Int32[,] | b | The matrix |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Int32, Int32[,], Int32[,])
Elementwise addition between a scalar a and a matrix b.
Declaration
public static int[, ] Add(this int a, int[, ] b, int[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | The scalar |
| System.Int32[,] | b | The matrix |
| System.Int32[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
Add(Int32, Single[])
Elementwise addition between a scalar a and a vector b.
Declaration
public static float[] Add(this int a, float[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | The scalar |
| System.Single[] | b | The vector |
Returns
| Type | Description |
|---|---|
| System.Single[] |
Add(Int32, Single[], Double[])
Elementwise addition between a scalar a and a vectorb.
Declaration
public static double[] Add(this int a, float[] b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | The scalar |
| System.Single[] | b | The vector |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Int32, Single[], Int32[])
Elementwise addition between a scalar a and a vectorb.
Declaration
public static int[] Add(this int a, float[] b, int[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | The scalar |
| System.Single[] | b | The vector |
| System.Int32[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[] |
Add(Int32, Single[], Single[])
Elementwise addition between a scalar a and a vectorb.
Declaration
public static float[] Add(this int a, float[] b, float[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | The scalar |
| System.Single[] | b | The vector |
| System.Single[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[] |
Add(Int32, Single[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static float[][] Add(this int a, float[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | The scalar |
| System.Single[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Int32, Single[][], Double[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static double[][] Add(this int a, float[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | The scalar |
| System.Single[][] | b | The matrix |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Int32, Single[][], Int32[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static int[][] Add(this int a, float[][] b, int[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | The scalar |
| System.Single[][] | b | The matrix |
| System.Int32[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
Add(Int32, Single[][], Single[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static float[][] Add(this int a, float[][] b, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | The scalar |
| System.Single[][] | b | The matrix |
| System.Single[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Int32, Single[,])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static float[, ] Add(this int a, float[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | The scalar |
| System.Single[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Int32, Single[,], Double[,])
Elementwise addition between a scalar a and a matrix b.
Declaration
public static double[, ] Add(this int a, float[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | The scalar |
| System.Single[,] | b | The matrix |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Int32, Single[,], Int32[,])
Elementwise addition between a scalar a and a matrix b.
Declaration
public static int[, ] Add(this int a, float[, ] b, int[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | The scalar |
| System.Single[,] | b | The matrix |
| System.Int32[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
Add(Int32, Single[,], Single[,])
Elementwise addition between a scalar a and a matrix b.
Declaration
public static float[, ] Add(this int a, float[, ] b, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | The scalar |
| System.Single[,] | b | The matrix |
| System.Single[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Int32[], Byte)
Elementwise addition between a vector a and a scalar b.
Declaration
public static int[] Add(this int[] a, byte b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The vector |
| System.Byte | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Int32[] |
Add(Int32[], Byte, Byte[])
Elementwise addition between a vector a and a scalar b.
Declaration
public static byte[] Add(this int[] a, byte b, byte[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The vector |
| System.Byte | b | The scalar |
| System.Byte[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[] |
Add(Int32[], Byte, Double[])
Elementwise addition between a vector a and a scalar b.
Declaration
public static double[] Add(this int[] a, byte b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The vector |
| System.Byte | b | The scalar |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Int32[], Byte, Int32[])
Elementwise addition between a vector a and a scalar b.
Declaration
public static int[] Add(this int[] a, byte b, int[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The vector |
| System.Byte | b | The scalar |
| System.Int32[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[] |
Add(Int32[], Byte[])
Elementwise addition between a vector a and a vector b.
Declaration
public static int[] Add(this int[] a, byte[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The vector |
| System.Byte[] | b | The vector |
Returns
| Type | Description |
|---|---|
| System.Int32[] |
Add(Int32[], Byte[], Byte[])
Elementwise addition between a vector a and a vectorb.
Declaration
public static byte[] Add(this int[] a, byte[] b, byte[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The vector |
| System.Byte[] | b | The vector |
| System.Byte[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[] |
Add(Int32[], Byte[], Double[])
Elementwise addition between a vector a and a vectorb.
Declaration
public static double[] Add(this int[] a, byte[] b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The vector |
| System.Byte[] | b | The vector |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Int32[], Byte[], Int32[])
Elementwise addition between a vector a and a vectorb.
Declaration
public static int[] Add(this int[] a, byte[] b, int[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The vector |
| System.Byte[] | b | The vector |
| System.Int32[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[] |
Add(Int32[], Byte[][], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static int[][] Add(this int[] a, byte[][] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The vector |
| System.Byte[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
Add(Int32[], Byte[][], VectorType, Byte[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static byte[][] Add(this int[] a, byte[][] b, VectorType dimension, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The vector |
| System.Byte[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Byte[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
Add(Int32[], Byte[][], VectorType, Double[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this int[] a, byte[][] b, VectorType dimension, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The vector |
| System.Byte[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Int32[], Byte[][], VectorType, Int32[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static int[][] Add(this int[] a, byte[][] b, VectorType dimension, int[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The vector |
| System.Byte[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Int32[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
Add(Int32[], Byte[,], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static int[, ] Add(this int[] a, byte[, ] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The vector |
| System.Byte[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
Add(Int32[], Byte[,], VectorType, Byte[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static byte[, ] Add(this int[] a, byte[, ] b, VectorType dimension, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The vector |
| System.Byte[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Byte[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
Add(Int32[], Byte[,], VectorType, Double[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this int[] a, byte[, ] b, VectorType dimension, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The vector |
| System.Byte[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Int32[], Byte[,], VectorType, Int32[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static int[, ] Add(this int[] a, byte[, ] b, VectorType dimension, int[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The vector |
| System.Byte[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Int32[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
Add(Int32[], Decimal)
Elementwise addition between a vector a and a scalar b.
Declaration
public static int[] Add(this int[] a, decimal b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The vector |
| System.Decimal | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Int32[] |
Add(Int32[], Decimal, Decimal[])
Elementwise addition between a vector a and a scalar b.
Declaration
public static decimal[] Add(this int[] a, decimal b, decimal[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The vector |
| System.Decimal | b | The scalar |
| System.Decimal[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[] |
Add(Int32[], Decimal, Double[])
Elementwise addition between a vector a and a scalar b.
Declaration
public static double[] Add(this int[] a, decimal b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The vector |
| System.Decimal | b | The scalar |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Int32[], Decimal, Int32[])
Elementwise addition between a vector a and a scalar b.
Declaration
public static int[] Add(this int[] a, decimal b, int[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The vector |
| System.Decimal | b | The scalar |
| System.Int32[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[] |
Add(Int32[], Decimal[])
Elementwise addition between a vector a and a vector b.
Declaration
public static int[] Add(this int[] a, decimal[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The vector |
| System.Decimal[] | b | The vector |
Returns
| Type | Description |
|---|---|
| System.Int32[] |
Add(Int32[], Decimal[], Decimal[])
Elementwise addition between a vector a and a vectorb.
Declaration
public static decimal[] Add(this int[] a, decimal[] b, decimal[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The vector |
| System.Decimal[] | b | The vector |
| System.Decimal[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[] |
Add(Int32[], Decimal[], Double[])
Elementwise addition between a vector a and a vectorb.
Declaration
public static double[] Add(this int[] a, decimal[] b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The vector |
| System.Decimal[] | b | The vector |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Int32[], Decimal[], Int32[])
Elementwise addition between a vector a and a vectorb.
Declaration
public static int[] Add(this int[] a, decimal[] b, int[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The vector |
| System.Decimal[] | b | The vector |
| System.Int32[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[] |
Add(Int32[], Decimal[][], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static int[][] Add(this int[] a, decimal[][] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The vector |
| System.Decimal[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
Add(Int32[], Decimal[][], VectorType, Decimal[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static decimal[][] Add(this int[] a, decimal[][] b, VectorType dimension, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The vector |
| System.Decimal[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Decimal[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
Add(Int32[], Decimal[][], VectorType, Double[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this int[] a, decimal[][] b, VectorType dimension, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The vector |
| System.Decimal[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Int32[], Decimal[][], VectorType, Int32[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static int[][] Add(this int[] a, decimal[][] b, VectorType dimension, int[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The vector |
| System.Decimal[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Int32[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
Add(Int32[], Decimal[,], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static int[, ] Add(this int[] a, decimal[, ] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The vector |
| System.Decimal[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
Add(Int32[], Decimal[,], VectorType, Decimal[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static decimal[, ] Add(this int[] a, decimal[, ] b, VectorType dimension, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The vector |
| System.Decimal[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Decimal[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
Add(Int32[], Decimal[,], VectorType, Double[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this int[] a, decimal[, ] b, VectorType dimension, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The vector |
| System.Decimal[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Int32[], Decimal[,], VectorType, Int32[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static int[, ] Add(this int[] a, decimal[, ] b, VectorType dimension, int[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The vector |
| System.Decimal[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Int32[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
Add(Int32[], Double)
Elementwise addition between a vector a and a scalar b.
Declaration
public static double[] Add(this int[] a, double b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The vector |
| System.Double | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Int32[], Double, Double[])
Elementwise addition between a vector a and a scalar b.
Declaration
public static double[] Add(this int[] a, double b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The vector |
| System.Double | b | The scalar |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Int32[], Double, Int32[])
Elementwise addition between a vector a and a scalar b.
Declaration
public static int[] Add(this int[] a, double b, int[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The vector |
| System.Double | b | The scalar |
| System.Int32[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[] |
Add(Int32[], Double[])
Elementwise addition between a vector a and a vector b.
Declaration
public static double[] Add(this int[] a, double[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The vector |
| System.Double[] | b | The vector |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Int32[], Double[], Double[])
Elementwise addition between a vector a and a vectorb.
Declaration
public static double[] Add(this int[] a, double[] b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The vector |
| System.Double[] | b | The vector |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Int32[], Double[], Int32[])
Elementwise addition between a vector a and a vectorb.
Declaration
public static int[] Add(this int[] a, double[] b, int[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The vector |
| System.Double[] | b | The vector |
| System.Int32[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[] |
Add(Int32[], Double[][], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this int[] a, double[][] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The vector |
| System.Double[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Int32[], Double[][], VectorType, Double[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this int[] a, double[][] b, VectorType dimension, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The vector |
| System.Double[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Int32[], Double[][], VectorType, Int32[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static int[][] Add(this int[] a, double[][] b, VectorType dimension, int[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The vector |
| System.Double[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Int32[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
Add(Int32[], Double[,], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this int[] a, double[, ] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The vector |
| System.Double[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Int32[], Double[,], VectorType, Double[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this int[] a, double[, ] b, VectorType dimension, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The vector |
| System.Double[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Int32[], Double[,], VectorType, Int32[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static int[, ] Add(this int[] a, double[, ] b, VectorType dimension, int[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The vector |
| System.Double[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Int32[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
Add(Int32[], Int16)
Elementwise addition between a vector a and a scalar b.
Declaration
public static int[] Add(this int[] a, short b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The vector |
| System.Int16 | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Int32[] |
Add(Int32[], Int16, Double[])
Elementwise addition between a vector a and a scalar b.
Declaration
public static double[] Add(this int[] a, short b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The vector |
| System.Int16 | b | The scalar |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Int32[], Int16, Int16[])
Elementwise addition between a vector a and a scalar b.
Declaration
public static short[] Add(this int[] a, short b, short[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The vector |
| System.Int16 | b | The scalar |
| System.Int16[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[] |
Add(Int32[], Int16, Int32[])
Elementwise addition between a vector a and a scalar b.
Declaration
public static int[] Add(this int[] a, short b, int[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The vector |
| System.Int16 | b | The scalar |
| System.Int32[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[] |
Add(Int32[], Int16[])
Elementwise addition between a vector a and a vector b.
Declaration
public static int[] Add(this int[] a, short[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The vector |
| System.Int16[] | b | The vector |
Returns
| Type | Description |
|---|---|
| System.Int32[] |
Add(Int32[], Int16[], Double[])
Elementwise addition between a vector a and a vectorb.
Declaration
public static double[] Add(this int[] a, short[] b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The vector |
| System.Int16[] | b | The vector |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Int32[], Int16[], Int16[])
Elementwise addition between a vector a and a vectorb.
Declaration
public static short[] Add(this int[] a, short[] b, short[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The vector |
| System.Int16[] | b | The vector |
| System.Int16[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[] |
Add(Int32[], Int16[], Int32[])
Elementwise addition between a vector a and a vectorb.
Declaration
public static int[] Add(this int[] a, short[] b, int[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The vector |
| System.Int16[] | b | The vector |
| System.Int32[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[] |
Add(Int32[], Int16[][], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static int[][] Add(this int[] a, short[][] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The vector |
| System.Int16[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
Add(Int32[], Int16[][], VectorType, Double[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this int[] a, short[][] b, VectorType dimension, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The vector |
| System.Int16[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Int32[], Int16[][], VectorType, Int16[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static short[][] Add(this int[] a, short[][] b, VectorType dimension, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The vector |
| System.Int16[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Int16[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
Add(Int32[], Int16[][], VectorType, Int32[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static int[][] Add(this int[] a, short[][] b, VectorType dimension, int[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The vector |
| System.Int16[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Int32[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
Add(Int32[], Int16[,], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static int[, ] Add(this int[] a, short[, ] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The vector |
| System.Int16[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
Add(Int32[], Int16[,], VectorType, Double[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this int[] a, short[, ] b, VectorType dimension, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The vector |
| System.Int16[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Int32[], Int16[,], VectorType, Int16[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static short[, ] Add(this int[] a, short[, ] b, VectorType dimension, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The vector |
| System.Int16[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Int16[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
Add(Int32[], Int16[,], VectorType, Int32[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static int[, ] Add(this int[] a, short[, ] b, VectorType dimension, int[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The vector |
| System.Int16[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Int32[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
Add(Int32[], Int32)
Elementwise addition between a vector a and a scalar b.
Declaration
public static int[] Add(this int[] a, int b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The vector |
| System.Int32 | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Int32[] |
Add(Int32[], Int32, Double[])
Elementwise addition between a vector a and a scalar b.
Declaration
public static double[] Add(this int[] a, int b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The vector |
| System.Int32 | b | The scalar |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Int32[], Int32, Int32[])
Elementwise addition between a vector a and a scalar b.
Declaration
public static int[] Add(this int[] a, int b, int[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The vector |
| System.Int32 | b | The scalar |
| System.Int32[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[] |
Add(Int32[], Int32[])
Elementwise addition between a vector a and a vector b.
Declaration
public static int[] Add(this int[] a, int[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The vector |
| System.Int32[] | b | The vector |
Returns
| Type | Description |
|---|---|
| System.Int32[] |
Add(Int32[], Int32[], Double[])
Elementwise addition between a vector a and a vectorb.
Declaration
public static double[] Add(this int[] a, int[] b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The vector |
| System.Int32[] | b | The vector |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Int32[], Int32[], Int32[])
Elementwise addition between a vector a and a vectorb.
Declaration
public static int[] Add(this int[] a, int[] b, int[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The vector |
| System.Int32[] | b | The vector |
| System.Int32[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[] |
Add(Int32[], Int32[][], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static int[][] Add(this int[] a, int[][] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The vector |
| System.Int32[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
Add(Int32[], Int32[][], VectorType, Double[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this int[] a, int[][] b, VectorType dimension, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The vector |
| System.Int32[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Int32[], Int32[][], VectorType, Int32[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static int[][] Add(this int[] a, int[][] b, VectorType dimension, int[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The vector |
| System.Int32[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Int32[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
Add(Int32[], Int32[,], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static int[, ] Add(this int[] a, int[, ] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The vector |
| System.Int32[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
Add(Int32[], Int32[,], VectorType, Double[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this int[] a, int[, ] b, VectorType dimension, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The vector |
| System.Int32[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Int32[], Int32[,], VectorType, Int32[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static int[, ] Add(this int[] a, int[, ] b, VectorType dimension, int[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The vector |
| System.Int32[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Int32[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
Add(Int32[], Single)
Elementwise addition between a vector a and a scalar b.
Declaration
public static float[] Add(this int[] a, float b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The vector |
| System.Single | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Single[] |
Add(Int32[], Single, Double[])
Elementwise addition between a vector a and a scalar b.
Declaration
public static double[] Add(this int[] a, float b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The vector |
| System.Single | b | The scalar |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Int32[], Single, Int32[])
Elementwise addition between a vector a and a scalar b.
Declaration
public static int[] Add(this int[] a, float b, int[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The vector |
| System.Single | b | The scalar |
| System.Int32[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[] |
Add(Int32[], Single, Single[])
Elementwise addition between a vector a and a scalar b.
Declaration
public static float[] Add(this int[] a, float b, float[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The vector |
| System.Single | b | The scalar |
| System.Single[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[] |
Add(Int32[], Single[])
Elementwise addition between a vector a and a vector b.
Declaration
public static float[] Add(this int[] a, float[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The vector |
| System.Single[] | b | The vector |
Returns
| Type | Description |
|---|---|
| System.Single[] |
Add(Int32[], Single[], Double[])
Elementwise addition between a vector a and a vectorb.
Declaration
public static double[] Add(this int[] a, float[] b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The vector |
| System.Single[] | b | The vector |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Int32[], Single[], Int32[])
Elementwise addition between a vector a and a vectorb.
Declaration
public static int[] Add(this int[] a, float[] b, int[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The vector |
| System.Single[] | b | The vector |
| System.Int32[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[] |
Add(Int32[], Single[], Single[])
Elementwise addition between a vector a and a vectorb.
Declaration
public static float[] Add(this int[] a, float[] b, float[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The vector |
| System.Single[] | b | The vector |
| System.Single[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[] |
Add(Int32[], Single[][], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static float[][] Add(this int[] a, float[][] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The vector |
| System.Single[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Int32[], Single[][], VectorType, Double[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this int[] a, float[][] b, VectorType dimension, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The vector |
| System.Single[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Int32[], Single[][], VectorType, Int32[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static int[][] Add(this int[] a, float[][] b, VectorType dimension, int[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The vector |
| System.Single[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Int32[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
Add(Int32[], Single[][], VectorType, Single[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static float[][] Add(this int[] a, float[][] b, VectorType dimension, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The vector |
| System.Single[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Single[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Int32[], Single[,], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static float[, ] Add(this int[] a, float[, ] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The vector |
| System.Single[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Int32[], Single[,], VectorType, Double[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this int[] a, float[, ] b, VectorType dimension, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The vector |
| System.Single[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Int32[], Single[,], VectorType, Int32[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static int[, ] Add(this int[] a, float[, ] b, VectorType dimension, int[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The vector |
| System.Single[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Int32[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
Add(Int32[], Single[,], VectorType, Single[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static float[, ] Add(this int[] a, float[, ] b, VectorType dimension, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The vector |
| System.Single[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Single[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Int32[][], Byte)
Elementwise addition between a matrix A and a scalar b.
Declaration
public static int[][] Add(this int[][] a, byte b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | The matrix |
| System.Byte | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
Add(Int32[][], Byte, Byte[][])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static byte[][] Add(this int[][] a, byte b, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | The matrix |
| System.Byte | b | The scalar |
| System.Byte[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
Add(Int32[][], Byte, Double[][])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[][] Add(this int[][] a, byte b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | The matrix |
| System.Byte | b | The scalar |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Int32[][], Byte, Int32[][])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static int[][] Add(this int[][] a, byte b, int[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | The matrix |
| System.Byte | b | The scalar |
| System.Int32[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
Add(Int32[][], Byte[], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static int[][] Add(this int[][] a, byte[] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | The matrix |
| System.Byte[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
Add(Int32[][], Byte[], VectorType, Byte[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static byte[][] Add(this int[][] a, byte[] b, VectorType dimension, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | The matrix |
| System.Byte[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Byte[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
Add(Int32[][], Byte[], VectorType, Double[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this int[][] a, byte[] b, VectorType dimension, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | The matrix |
| System.Byte[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Int32[][], Byte[], VectorType, Int32[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static int[][] Add(this int[][] a, byte[] b, VectorType dimension, int[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | The matrix |
| System.Byte[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Int32[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
Add(Int32[][], Byte[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static int[][] Add(this int[][] a, byte[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | The matrix |
| System.Byte[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
Add(Int32[][], Byte[][], Byte[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static byte[][] Add(this int[][] a, byte[][] b, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | The matrix |
| System.Byte[][] | b | The matrix |
| System.Byte[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
Add(Int32[][], Byte[][], Double[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[][] Add(this int[][] a, byte[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | The matrix |
| System.Byte[][] | b | The matrix |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Int32[][], Byte[][], Int32[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static int[][] Add(this int[][] a, byte[][] b, int[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | The matrix |
| System.Byte[][] | b | The matrix |
| System.Int32[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
Add(Int32[][], Decimal)
Elementwise addition between a matrix A and a scalar b.
Declaration
public static int[][] Add(this int[][] a, decimal b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | The matrix |
| System.Decimal | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
Add(Int32[][], Decimal, Decimal[][])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static decimal[][] Add(this int[][] a, decimal b, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | The matrix |
| System.Decimal | b | The scalar |
| System.Decimal[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
Add(Int32[][], Decimal, Double[][])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[][] Add(this int[][] a, decimal b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | The matrix |
| System.Decimal | b | The scalar |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Int32[][], Decimal, Int32[][])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static int[][] Add(this int[][] a, decimal b, int[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | The matrix |
| System.Decimal | b | The scalar |
| System.Int32[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
Add(Int32[][], Decimal[], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static int[][] Add(this int[][] a, decimal[] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | The matrix |
| System.Decimal[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
Add(Int32[][], Decimal[], VectorType, Decimal[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static decimal[][] Add(this int[][] a, decimal[] b, VectorType dimension, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | The matrix |
| System.Decimal[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Decimal[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
Add(Int32[][], Decimal[], VectorType, Double[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this int[][] a, decimal[] b, VectorType dimension, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | The matrix |
| System.Decimal[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Int32[][], Decimal[], VectorType, Int32[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static int[][] Add(this int[][] a, decimal[] b, VectorType dimension, int[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | The matrix |
| System.Decimal[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Int32[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
Add(Int32[][], Decimal[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static int[][] Add(this int[][] a, decimal[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | The matrix |
| System.Decimal[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
Add(Int32[][], Decimal[][], Decimal[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static decimal[][] Add(this int[][] a, decimal[][] b, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | The matrix |
| System.Decimal[][] | b | The matrix |
| System.Decimal[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
Add(Int32[][], Decimal[][], Double[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[][] Add(this int[][] a, decimal[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | The matrix |
| System.Decimal[][] | b | The matrix |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Int32[][], Decimal[][], Int32[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static int[][] Add(this int[][] a, decimal[][] b, int[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | The matrix |
| System.Decimal[][] | b | The matrix |
| System.Int32[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
Add(Int32[][], Double)
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[][] Add(this int[][] a, double b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | The matrix |
| System.Double | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Int32[][], Double, Double[][])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[][] Add(this int[][] a, double b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | The matrix |
| System.Double | b | The scalar |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Int32[][], Double, Int32[][])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static int[][] Add(this int[][] a, double b, int[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | The matrix |
| System.Double | b | The scalar |
| System.Int32[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
Add(Int32[][], Double[], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this int[][] a, double[] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | The matrix |
| System.Double[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Int32[][], Double[], VectorType, Double[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this int[][] a, double[] b, VectorType dimension, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | The matrix |
| System.Double[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Int32[][], Double[], VectorType, Int32[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static int[][] Add(this int[][] a, double[] b, VectorType dimension, int[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | The matrix |
| System.Double[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Int32[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
Add(Int32[][], Double[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[][] Add(this int[][] a, double[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | The matrix |
| System.Double[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Int32[][], Double[][], Double[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[][] Add(this int[][] a, double[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | The matrix |
| System.Double[][] | b | The matrix |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Int32[][], Double[][], Int32[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static int[][] Add(this int[][] a, double[][] b, int[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | The matrix |
| System.Double[][] | b | The matrix |
| System.Int32[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
Add(Int32[][], Int16)
Elementwise addition between a matrix A and a scalar b.
Declaration
public static int[][] Add(this int[][] a, short b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | The matrix |
| System.Int16 | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
Add(Int32[][], Int16, Double[][])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[][] Add(this int[][] a, short b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | The matrix |
| System.Int16 | b | The scalar |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Int32[][], Int16, Int16[][])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static short[][] Add(this int[][] a, short b, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | The matrix |
| System.Int16 | b | The scalar |
| System.Int16[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
Add(Int32[][], Int16, Int32[][])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static int[][] Add(this int[][] a, short b, int[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | The matrix |
| System.Int16 | b | The scalar |
| System.Int32[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
Add(Int32[][], Int16[], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static int[][] Add(this int[][] a, short[] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | The matrix |
| System.Int16[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
Add(Int32[][], Int16[], VectorType, Double[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this int[][] a, short[] b, VectorType dimension, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | The matrix |
| System.Int16[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Int32[][], Int16[], VectorType, Int16[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static short[][] Add(this int[][] a, short[] b, VectorType dimension, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | The matrix |
| System.Int16[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Int16[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
Add(Int32[][], Int16[], VectorType, Int32[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static int[][] Add(this int[][] a, short[] b, VectorType dimension, int[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | The matrix |
| System.Int16[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Int32[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
Add(Int32[][], Int16[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static int[][] Add(this int[][] a, short[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | The matrix |
| System.Int16[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
Add(Int32[][], Int16[][], Double[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[][] Add(this int[][] a, short[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | The matrix |
| System.Int16[][] | b | The matrix |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Int32[][], Int16[][], Int16[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static short[][] Add(this int[][] a, short[][] b, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | The matrix |
| System.Int16[][] | b | The matrix |
| System.Int16[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
Add(Int32[][], Int16[][], Int32[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static int[][] Add(this int[][] a, short[][] b, int[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | The matrix |
| System.Int16[][] | b | The matrix |
| System.Int32[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
Add(Int32[][], Int32)
Elementwise addition between a matrix A and a scalar b.
Declaration
public static int[][] Add(this int[][] a, int b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | The matrix |
| System.Int32 | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
Add(Int32[][], Int32, Double[][])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[][] Add(this int[][] a, int b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | The matrix |
| System.Int32 | b | The scalar |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Int32[][], Int32, Int32[][])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static int[][] Add(this int[][] a, int b, int[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | The matrix |
| System.Int32 | b | The scalar |
| System.Int32[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
Add(Int32[][], Int32[], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static int[][] Add(this int[][] a, int[] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | The matrix |
| System.Int32[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
Add(Int32[][], Int32[], VectorType, Double[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this int[][] a, int[] b, VectorType dimension, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | The matrix |
| System.Int32[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Int32[][], Int32[], VectorType, Int32[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static int[][] Add(this int[][] a, int[] b, VectorType dimension, int[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | The matrix |
| System.Int32[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Int32[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
Add(Int32[][], Int32[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static int[][] Add(this int[][] a, int[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | The matrix |
| System.Int32[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
Add(Int32[][], Int32[][], Double[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[][] Add(this int[][] a, int[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | The matrix |
| System.Int32[][] | b | The matrix |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Int32[][], Int32[][], Int32[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static int[][] Add(this int[][] a, int[][] b, int[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | The matrix |
| System.Int32[][] | b | The matrix |
| System.Int32[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
Add(Int32[][], Single)
Elementwise addition between a matrix A and a scalar b.
Declaration
public static float[][] Add(this int[][] a, float b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | The matrix |
| System.Single | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Int32[][], Single, Double[][])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[][] Add(this int[][] a, float b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | The matrix |
| System.Single | b | The scalar |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Int32[][], Single, Int32[][])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static int[][] Add(this int[][] a, float b, int[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | The matrix |
| System.Single | b | The scalar |
| System.Int32[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
Add(Int32[][], Single, Single[][])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static float[][] Add(this int[][] a, float b, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | The matrix |
| System.Single | b | The scalar |
| System.Single[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Int32[][], Single[], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static float[][] Add(this int[][] a, float[] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | The matrix |
| System.Single[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Int32[][], Single[], VectorType, Double[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this int[][] a, float[] b, VectorType dimension, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | The matrix |
| System.Single[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Int32[][], Single[], VectorType, Int32[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static int[][] Add(this int[][] a, float[] b, VectorType dimension, int[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | The matrix |
| System.Single[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Int32[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
Add(Int32[][], Single[], VectorType, Single[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static float[][] Add(this int[][] a, float[] b, VectorType dimension, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | The matrix |
| System.Single[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Single[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Int32[][], Single[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static float[][] Add(this int[][] a, float[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | The matrix |
| System.Single[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Int32[][], Single[][], Double[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[][] Add(this int[][] a, float[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | The matrix |
| System.Single[][] | b | The matrix |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Int32[][], Single[][], Int32[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static int[][] Add(this int[][] a, float[][] b, int[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | The matrix |
| System.Single[][] | b | The matrix |
| System.Int32[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
Add(Int32[][], Single[][], Single[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static float[][] Add(this int[][] a, float[][] b, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | The matrix |
| System.Single[][] | b | The matrix |
| System.Single[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Int32[,], Byte)
Elementwise addition between a matrix A and a scalar b.
Declaration
public static int[, ] Add(this int[, ] a, byte b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | The matrix |
| System.Byte | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
Add(Int32[,], Byte, Byte[,])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static byte[, ] Add(this int[, ] a, byte b, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | The matrix |
| System.Byte | b | The scalar |
| System.Byte[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
Add(Int32[,], Byte, Double[,])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[, ] Add(this int[, ] a, byte b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | The matrix |
| System.Byte | b | The scalar |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Int32[,], Byte, Int32[,])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static int[, ] Add(this int[, ] a, byte b, int[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | The matrix |
| System.Byte | b | The scalar |
| System.Int32[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
Add(Int32[,], Byte[], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static int[, ] Add(this int[, ] a, byte[] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | The matrix |
| System.Byte[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
Add(Int32[,], Byte[], VectorType, Byte[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static byte[, ] Add(this int[, ] a, byte[] b, VectorType dimension, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | The matrix |
| System.Byte[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Byte[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
Add(Int32[,], Byte[], VectorType, Double[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this int[, ] a, byte[] b, VectorType dimension, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | The matrix |
| System.Byte[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Int32[,], Byte[], VectorType, Int32[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static int[, ] Add(this int[, ] a, byte[] b, VectorType dimension, int[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | The matrix |
| System.Byte[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Int32[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
Add(Int32[,], Byte[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static int[, ] Add(this int[, ] a, byte[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | The matrix |
| System.Byte[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
Add(Int32[,], Byte[,], Byte[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static byte[, ] Add(this int[, ] a, byte[, ] b, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | The matrix |
| System.Byte[,] | b | The matrix |
| System.Byte[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
Add(Int32[,], Byte[,], Double[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[, ] Add(this int[, ] a, byte[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | The matrix |
| System.Byte[,] | b | The matrix |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Int32[,], Byte[,], Int32[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static int[, ] Add(this int[, ] a, byte[, ] b, int[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | The matrix |
| System.Byte[,] | b | The matrix |
| System.Int32[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
Add(Int32[,], Decimal)
Elementwise addition between a matrix A and a scalar b.
Declaration
public static int[, ] Add(this int[, ] a, decimal b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | The matrix |
| System.Decimal | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
Add(Int32[,], Decimal, Decimal[,])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static decimal[, ] Add(this int[, ] a, decimal b, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | The matrix |
| System.Decimal | b | The scalar |
| System.Decimal[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
Add(Int32[,], Decimal, Double[,])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[, ] Add(this int[, ] a, decimal b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | The matrix |
| System.Decimal | b | The scalar |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Int32[,], Decimal, Int32[,])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static int[, ] Add(this int[, ] a, decimal b, int[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | The matrix |
| System.Decimal | b | The scalar |
| System.Int32[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
Add(Int32[,], Decimal[], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static int[, ] Add(this int[, ] a, decimal[] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | The matrix |
| System.Decimal[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
Add(Int32[,], Decimal[], VectorType, Decimal[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static decimal[, ] Add(this int[, ] a, decimal[] b, VectorType dimension, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | The matrix |
| System.Decimal[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Decimal[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
Add(Int32[,], Decimal[], VectorType, Double[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this int[, ] a, decimal[] b, VectorType dimension, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | The matrix |
| System.Decimal[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Int32[,], Decimal[], VectorType, Int32[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static int[, ] Add(this int[, ] a, decimal[] b, VectorType dimension, int[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | The matrix |
| System.Decimal[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Int32[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
Add(Int32[,], Decimal[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static int[, ] Add(this int[, ] a, decimal[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | The matrix |
| System.Decimal[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
Add(Int32[,], Decimal[,], Decimal[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static decimal[, ] Add(this int[, ] a, decimal[, ] b, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | The matrix |
| System.Decimal[,] | b | The matrix |
| System.Decimal[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
Add(Int32[,], Decimal[,], Double[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[, ] Add(this int[, ] a, decimal[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | The matrix |
| System.Decimal[,] | b | The matrix |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Int32[,], Decimal[,], Int32[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static int[, ] Add(this int[, ] a, decimal[, ] b, int[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | The matrix |
| System.Decimal[,] | b | The matrix |
| System.Int32[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
Add(Int32[,], Double)
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[, ] Add(this int[, ] a, double b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | The matrix |
| System.Double | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Int32[,], Double, Double[,])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[, ] Add(this int[, ] a, double b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | The matrix |
| System.Double | b | The scalar |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Int32[,], Double, Int32[,])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static int[, ] Add(this int[, ] a, double b, int[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | The matrix |
| System.Double | b | The scalar |
| System.Int32[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
Add(Int32[,], Double[], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this int[, ] a, double[] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | The matrix |
| System.Double[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Int32[,], Double[], VectorType, Double[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this int[, ] a, double[] b, VectorType dimension, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | The matrix |
| System.Double[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Int32[,], Double[], VectorType, Int32[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static int[, ] Add(this int[, ] a, double[] b, VectorType dimension, int[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | The matrix |
| System.Double[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Int32[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
Add(Int32[,], Double[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[, ] Add(this int[, ] a, double[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | The matrix |
| System.Double[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Int32[,], Double[,], Double[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[, ] Add(this int[, ] a, double[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | The matrix |
| System.Double[,] | b | The matrix |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Int32[,], Double[,], Int32[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static int[, ] Add(this int[, ] a, double[, ] b, int[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | The matrix |
| System.Double[,] | b | The matrix |
| System.Int32[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
Add(Int32[,], Int16)
Elementwise addition between a matrix A and a scalar b.
Declaration
public static int[, ] Add(this int[, ] a, short b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | The matrix |
| System.Int16 | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
Add(Int32[,], Int16, Double[,])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[, ] Add(this int[, ] a, short b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | The matrix |
| System.Int16 | b | The scalar |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Int32[,], Int16, Int16[,])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static short[, ] Add(this int[, ] a, short b, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | The matrix |
| System.Int16 | b | The scalar |
| System.Int16[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
Add(Int32[,], Int16, Int32[,])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static int[, ] Add(this int[, ] a, short b, int[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | The matrix |
| System.Int16 | b | The scalar |
| System.Int32[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
Add(Int32[,], Int16[], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static int[, ] Add(this int[, ] a, short[] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | The matrix |
| System.Int16[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
Add(Int32[,], Int16[], VectorType, Double[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this int[, ] a, short[] b, VectorType dimension, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | The matrix |
| System.Int16[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Int32[,], Int16[], VectorType, Int16[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static short[, ] Add(this int[, ] a, short[] b, VectorType dimension, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | The matrix |
| System.Int16[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Int16[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
Add(Int32[,], Int16[], VectorType, Int32[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static int[, ] Add(this int[, ] a, short[] b, VectorType dimension, int[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | The matrix |
| System.Int16[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Int32[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
Add(Int32[,], Int16[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static int[, ] Add(this int[, ] a, short[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | The matrix |
| System.Int16[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
Add(Int32[,], Int16[,], Double[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[, ] Add(this int[, ] a, short[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | The matrix |
| System.Int16[,] | b | The matrix |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Int32[,], Int16[,], Int16[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static short[, ] Add(this int[, ] a, short[, ] b, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | The matrix |
| System.Int16[,] | b | The matrix |
| System.Int16[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
Add(Int32[,], Int16[,], Int32[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static int[, ] Add(this int[, ] a, short[, ] b, int[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | The matrix |
| System.Int16[,] | b | The matrix |
| System.Int32[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
Add(Int32[,], Int32)
Elementwise addition between a matrix A and a scalar b.
Declaration
public static int[, ] Add(this int[, ] a, int b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | The matrix |
| System.Int32 | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
Add(Int32[,], Int32, Double[,])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[, ] Add(this int[, ] a, int b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | The matrix |
| System.Int32 | b | The scalar |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Int32[,], Int32, Int32[,])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static int[, ] Add(this int[, ] a, int b, int[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | The matrix |
| System.Int32 | b | The scalar |
| System.Int32[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
Add(Int32[,], Int32[], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static int[, ] Add(this int[, ] a, int[] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | The matrix |
| System.Int32[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
Add(Int32[,], Int32[], VectorType, Double[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this int[, ] a, int[] b, VectorType dimension, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | The matrix |
| System.Int32[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Int32[,], Int32[], VectorType, Int32[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static int[, ] Add(this int[, ] a, int[] b, VectorType dimension, int[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | The matrix |
| System.Int32[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Int32[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
Add(Int32[,], Int32[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static int[, ] Add(this int[, ] a, int[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | The matrix |
| System.Int32[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
Add(Int32[,], Int32[,], Double[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[, ] Add(this int[, ] a, int[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | The matrix |
| System.Int32[,] | b | The matrix |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Int32[,], Int32[,], Int32[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static int[, ] Add(this int[, ] a, int[, ] b, int[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | The matrix |
| System.Int32[,] | b | The matrix |
| System.Int32[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
Add(Int32[,], Single)
Elementwise addition between a matrix A and a scalar b.
Declaration
public static float[, ] Add(this int[, ] a, float b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | The matrix |
| System.Single | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Int32[,], Single, Double[,])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[, ] Add(this int[, ] a, float b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | The matrix |
| System.Single | b | The scalar |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Int32[,], Single, Int32[,])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static int[, ] Add(this int[, ] a, float b, int[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | The matrix |
| System.Single | b | The scalar |
| System.Int32[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
Add(Int32[,], Single, Single[,])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static float[, ] Add(this int[, ] a, float b, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | The matrix |
| System.Single | b | The scalar |
| System.Single[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Int32[,], Single[], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static float[, ] Add(this int[, ] a, float[] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | The matrix |
| System.Single[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Int32[,], Single[], VectorType, Double[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this int[, ] a, float[] b, VectorType dimension, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | The matrix |
| System.Single[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Int32[,], Single[], VectorType, Int32[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static int[, ] Add(this int[, ] a, float[] b, VectorType dimension, int[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | The matrix |
| System.Single[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Int32[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
Add(Int32[,], Single[], VectorType, Single[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static float[, ] Add(this int[, ] a, float[] b, VectorType dimension, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | The matrix |
| System.Single[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Single[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Int32[,], Single[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static float[, ] Add(this int[, ] a, float[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | The matrix |
| System.Single[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Int32[,], Single[,], Double[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[, ] Add(this int[, ] a, float[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | The matrix |
| System.Single[,] | b | The matrix |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Int32[,], Single[,], Int32[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static int[, ] Add(this int[, ] a, float[, ] b, int[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | The matrix |
| System.Single[,] | b | The matrix |
| System.Int32[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
Add(Int32[,], Single[,], Single[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static float[, ] Add(this int[, ] a, float[, ] b, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | The matrix |
| System.Single[,] | b | The matrix |
| System.Single[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Single, Byte[])
Elementwise addition between a scalar a and a vector b.
Declaration
public static float[] Add(this float a, byte[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | The scalar |
| System.Byte[] | b | The vector |
Returns
| Type | Description |
|---|---|
| System.Single[] |
Add(Single, Byte[], Byte[])
Elementwise addition between a scalar a and a vectorb.
Declaration
public static byte[] Add(this float a, byte[] b, byte[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | The scalar |
| System.Byte[] | b | The vector |
| System.Byte[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[] |
Add(Single, Byte[], Double[])
Elementwise addition between a scalar a and a vectorb.
Declaration
public static double[] Add(this float a, byte[] b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | The scalar |
| System.Byte[] | b | The vector |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Single, Byte[], Single[])
Elementwise addition between a scalar a and a vectorb.
Declaration
public static float[] Add(this float a, byte[] b, float[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | The scalar |
| System.Byte[] | b | The vector |
| System.Single[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[] |
Add(Single, Byte[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static float[][] Add(this float a, byte[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | The scalar |
| System.Byte[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Single, Byte[][], Byte[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static byte[][] Add(this float a, byte[][] b, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | The scalar |
| System.Byte[][] | b | The matrix |
| System.Byte[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
Add(Single, Byte[][], Double[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static double[][] Add(this float a, byte[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | The scalar |
| System.Byte[][] | b | The matrix |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Single, Byte[][], Single[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static float[][] Add(this float a, byte[][] b, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | The scalar |
| System.Byte[][] | b | The matrix |
| System.Single[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Single, Byte[,])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static float[, ] Add(this float a, byte[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | The scalar |
| System.Byte[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Single, Byte[,], Byte[,])
Elementwise addition between a scalar a and a matrix b.
Declaration
public static byte[, ] Add(this float a, byte[, ] b, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | The scalar |
| System.Byte[,] | b | The matrix |
| System.Byte[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
Add(Single, Byte[,], Double[,])
Elementwise addition between a scalar a and a matrix b.
Declaration
public static double[, ] Add(this float a, byte[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | The scalar |
| System.Byte[,] | b | The matrix |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Single, Byte[,], Single[,])
Elementwise addition between a scalar a and a matrix b.
Declaration
public static float[, ] Add(this float a, byte[, ] b, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | The scalar |
| System.Byte[,] | b | The matrix |
| System.Single[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Single, Decimal[])
Elementwise addition between a scalar a and a vector b.
Declaration
public static float[] Add(this float a, decimal[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | The scalar |
| System.Decimal[] | b | The vector |
Returns
| Type | Description |
|---|---|
| System.Single[] |
Add(Single, Decimal[], Decimal[])
Elementwise addition between a scalar a and a vectorb.
Declaration
public static decimal[] Add(this float a, decimal[] b, decimal[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | The scalar |
| System.Decimal[] | b | The vector |
| System.Decimal[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[] |
Add(Single, Decimal[], Double[])
Elementwise addition between a scalar a and a vectorb.
Declaration
public static double[] Add(this float a, decimal[] b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | The scalar |
| System.Decimal[] | b | The vector |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Single, Decimal[], Single[])
Elementwise addition between a scalar a and a vectorb.
Declaration
public static float[] Add(this float a, decimal[] b, float[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | The scalar |
| System.Decimal[] | b | The vector |
| System.Single[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[] |
Add(Single, Decimal[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static float[][] Add(this float a, decimal[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | The scalar |
| System.Decimal[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Single, Decimal[][], Decimal[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static decimal[][] Add(this float a, decimal[][] b, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | The scalar |
| System.Decimal[][] | b | The matrix |
| System.Decimal[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
Add(Single, Decimal[][], Double[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static double[][] Add(this float a, decimal[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | The scalar |
| System.Decimal[][] | b | The matrix |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Single, Decimal[][], Single[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static float[][] Add(this float a, decimal[][] b, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | The scalar |
| System.Decimal[][] | b | The matrix |
| System.Single[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Single, Decimal[,])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static float[, ] Add(this float a, decimal[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | The scalar |
| System.Decimal[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Single, Decimal[,], Decimal[,])
Elementwise addition between a scalar a and a matrix b.
Declaration
public static decimal[, ] Add(this float a, decimal[, ] b, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | The scalar |
| System.Decimal[,] | b | The matrix |
| System.Decimal[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
Add(Single, Decimal[,], Double[,])
Elementwise addition between a scalar a and a matrix b.
Declaration
public static double[, ] Add(this float a, decimal[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | The scalar |
| System.Decimal[,] | b | The matrix |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Single, Decimal[,], Single[,])
Elementwise addition between a scalar a and a matrix b.
Declaration
public static float[, ] Add(this float a, decimal[, ] b, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | The scalar |
| System.Decimal[,] | b | The matrix |
| System.Single[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Single, Double[])
Elementwise addition between a scalar a and a vector b.
Declaration
public static double[] Add(this float a, double[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | The scalar |
| System.Double[] | b | The vector |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Single, Double[], Double[])
Elementwise addition between a scalar a and a vectorb.
Declaration
public static double[] Add(this float a, double[] b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | The scalar |
| System.Double[] | b | The vector |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Single, Double[], Single[])
Elementwise addition between a scalar a and a vectorb.
Declaration
public static float[] Add(this float a, double[] b, float[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | The scalar |
| System.Double[] | b | The vector |
| System.Single[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[] |
Add(Single, Double[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static double[][] Add(this float a, double[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | The scalar |
| System.Double[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Single, Double[][], Double[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static double[][] Add(this float a, double[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | The scalar |
| System.Double[][] | b | The matrix |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Single, Double[][], Single[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static float[][] Add(this float a, double[][] b, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | The scalar |
| System.Double[][] | b | The matrix |
| System.Single[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Single, Double[,])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static double[, ] Add(this float a, double[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | The scalar |
| System.Double[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Single, Double[,], Double[,])
Elementwise addition between a scalar a and a matrix b.
Declaration
public static double[, ] Add(this float a, double[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | The scalar |
| System.Double[,] | b | The matrix |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Single, Double[,], Single[,])
Elementwise addition between a scalar a and a matrix b.
Declaration
public static float[, ] Add(this float a, double[, ] b, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | The scalar |
| System.Double[,] | b | The matrix |
| System.Single[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Single, Int16[])
Elementwise addition between a scalar a and a vector b.
Declaration
public static float[] Add(this float a, short[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | The scalar |
| System.Int16[] | b | The vector |
Returns
| Type | Description |
|---|---|
| System.Single[] |
Add(Single, Int16[], Double[])
Elementwise addition between a scalar a and a vectorb.
Declaration
public static double[] Add(this float a, short[] b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | The scalar |
| System.Int16[] | b | The vector |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Single, Int16[], Int16[])
Elementwise addition between a scalar a and a vectorb.
Declaration
public static short[] Add(this float a, short[] b, short[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | The scalar |
| System.Int16[] | b | The vector |
| System.Int16[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[] |
Add(Single, Int16[], Single[])
Elementwise addition between a scalar a and a vectorb.
Declaration
public static float[] Add(this float a, short[] b, float[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | The scalar |
| System.Int16[] | b | The vector |
| System.Single[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[] |
Add(Single, Int16[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static float[][] Add(this float a, short[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | The scalar |
| System.Int16[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Single, Int16[][], Double[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static double[][] Add(this float a, short[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | The scalar |
| System.Int16[][] | b | The matrix |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Single, Int16[][], Int16[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static short[][] Add(this float a, short[][] b, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | The scalar |
| System.Int16[][] | b | The matrix |
| System.Int16[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
Add(Single, Int16[][], Single[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static float[][] Add(this float a, short[][] b, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | The scalar |
| System.Int16[][] | b | The matrix |
| System.Single[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Single, Int16[,])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static float[, ] Add(this float a, short[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | The scalar |
| System.Int16[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Single, Int16[,], Double[,])
Elementwise addition between a scalar a and a matrix b.
Declaration
public static double[, ] Add(this float a, short[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | The scalar |
| System.Int16[,] | b | The matrix |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Single, Int16[,], Int16[,])
Elementwise addition between a scalar a and a matrix b.
Declaration
public static short[, ] Add(this float a, short[, ] b, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | The scalar |
| System.Int16[,] | b | The matrix |
| System.Int16[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
Add(Single, Int16[,], Single[,])
Elementwise addition between a scalar a and a matrix b.
Declaration
public static float[, ] Add(this float a, short[, ] b, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | The scalar |
| System.Int16[,] | b | The matrix |
| System.Single[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Single, Int32[])
Elementwise addition between a scalar a and a vector b.
Declaration
public static float[] Add(this float a, int[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | The scalar |
| System.Int32[] | b | The vector |
Returns
| Type | Description |
|---|---|
| System.Single[] |
Add(Single, Int32[], Double[])
Elementwise addition between a scalar a and a vectorb.
Declaration
public static double[] Add(this float a, int[] b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | The scalar |
| System.Int32[] | b | The vector |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Single, Int32[], Int32[])
Elementwise addition between a scalar a and a vectorb.
Declaration
public static int[] Add(this float a, int[] b, int[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | The scalar |
| System.Int32[] | b | The vector |
| System.Int32[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[] |
Add(Single, Int32[], Single[])
Elementwise addition between a scalar a and a vectorb.
Declaration
public static float[] Add(this float a, int[] b, float[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | The scalar |
| System.Int32[] | b | The vector |
| System.Single[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[] |
Add(Single, Int32[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static float[][] Add(this float a, int[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | The scalar |
| System.Int32[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Single, Int32[][], Double[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static double[][] Add(this float a, int[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | The scalar |
| System.Int32[][] | b | The matrix |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Single, Int32[][], Int32[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static int[][] Add(this float a, int[][] b, int[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | The scalar |
| System.Int32[][] | b | The matrix |
| System.Int32[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
Add(Single, Int32[][], Single[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static float[][] Add(this float a, int[][] b, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | The scalar |
| System.Int32[][] | b | The matrix |
| System.Single[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Single, Int32[,])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static float[, ] Add(this float a, int[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | The scalar |
| System.Int32[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Single, Int32[,], Double[,])
Elementwise addition between a scalar a and a matrix b.
Declaration
public static double[, ] Add(this float a, int[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | The scalar |
| System.Int32[,] | b | The matrix |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Single, Int32[,], Int32[,])
Elementwise addition between a scalar a and a matrix b.
Declaration
public static int[, ] Add(this float a, int[, ] b, int[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | The scalar |
| System.Int32[,] | b | The matrix |
| System.Int32[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
Add(Single, Int32[,], Single[,])
Elementwise addition between a scalar a and a matrix b.
Declaration
public static float[, ] Add(this float a, int[, ] b, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | The scalar |
| System.Int32[,] | b | The matrix |
| System.Single[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Single, Single[])
Elementwise addition between a scalar a and a vector b.
Declaration
public static float[] Add(this float a, float[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | The scalar |
| System.Single[] | b | The vector |
Returns
| Type | Description |
|---|---|
| System.Single[] |
Add(Single, Single[], Double[])
Elementwise addition between a scalar a and a vectorb.
Declaration
public static double[] Add(this float a, float[] b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | The scalar |
| System.Single[] | b | The vector |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Single, Single[], Single[])
Elementwise addition between a scalar a and a vectorb.
Declaration
public static float[] Add(this float a, float[] b, float[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | The scalar |
| System.Single[] | b | The vector |
| System.Single[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[] |
Add(Single, Single[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static float[][] Add(this float a, float[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | The scalar |
| System.Single[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Single, Single[][], Double[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static double[][] Add(this float a, float[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | The scalar |
| System.Single[][] | b | The matrix |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Single, Single[][], Single[][])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static float[][] Add(this float a, float[][] b, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | The scalar |
| System.Single[][] | b | The matrix |
| System.Single[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Single, Single[,])
Elementwise addition between a scalar a and a matrix B.
Declaration
public static float[, ] Add(this float a, float[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | The scalar |
| System.Single[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Single, Single[,], Double[,])
Elementwise addition between a scalar a and a matrix b.
Declaration
public static double[, ] Add(this float a, float[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | The scalar |
| System.Single[,] | b | The matrix |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Single, Single[,], Single[,])
Elementwise addition between a scalar a and a matrix b.
Declaration
public static float[, ] Add(this float a, float[, ] b, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | The scalar |
| System.Single[,] | b | The matrix |
| System.Single[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Single[], Byte)
Elementwise addition between a vector a and a scalar b.
Declaration
public static float[] Add(this float[] a, byte b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The vector |
| System.Byte | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Single[] |
Add(Single[], Byte, Byte[])
Elementwise addition between a vector a and a scalar b.
Declaration
public static byte[] Add(this float[] a, byte b, byte[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The vector |
| System.Byte | b | The scalar |
| System.Byte[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[] |
Add(Single[], Byte, Double[])
Elementwise addition between a vector a and a scalar b.
Declaration
public static double[] Add(this float[] a, byte b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The vector |
| System.Byte | b | The scalar |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Single[], Byte, Single[])
Elementwise addition between a vector a and a scalar b.
Declaration
public static float[] Add(this float[] a, byte b, float[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The vector |
| System.Byte | b | The scalar |
| System.Single[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[] |
Add(Single[], Byte[])
Elementwise addition between a vector a and a vector b.
Declaration
public static float[] Add(this float[] a, byte[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The vector |
| System.Byte[] | b | The vector |
Returns
| Type | Description |
|---|---|
| System.Single[] |
Add(Single[], Byte[], Byte[])
Elementwise addition between a vector a and a vectorb.
Declaration
public static byte[] Add(this float[] a, byte[] b, byte[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The vector |
| System.Byte[] | b | The vector |
| System.Byte[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[] |
Add(Single[], Byte[], Double[])
Elementwise addition between a vector a and a vectorb.
Declaration
public static double[] Add(this float[] a, byte[] b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The vector |
| System.Byte[] | b | The vector |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Single[], Byte[], Single[])
Elementwise addition between a vector a and a vectorb.
Declaration
public static float[] Add(this float[] a, byte[] b, float[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The vector |
| System.Byte[] | b | The vector |
| System.Single[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[] |
Add(Single[], Byte[][], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static float[][] Add(this float[] a, byte[][] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The vector |
| System.Byte[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Single[], Byte[][], VectorType, Byte[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static byte[][] Add(this float[] a, byte[][] b, VectorType dimension, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The vector |
| System.Byte[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Byte[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
Add(Single[], Byte[][], VectorType, Double[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this float[] a, byte[][] b, VectorType dimension, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The vector |
| System.Byte[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Single[], Byte[][], VectorType, Single[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static float[][] Add(this float[] a, byte[][] b, VectorType dimension, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The vector |
| System.Byte[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Single[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Single[], Byte[,], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static float[, ] Add(this float[] a, byte[, ] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The vector |
| System.Byte[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Single[], Byte[,], VectorType, Byte[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static byte[, ] Add(this float[] a, byte[, ] b, VectorType dimension, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The vector |
| System.Byte[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Byte[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
Add(Single[], Byte[,], VectorType, Double[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this float[] a, byte[, ] b, VectorType dimension, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The vector |
| System.Byte[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Single[], Byte[,], VectorType, Single[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static float[, ] Add(this float[] a, byte[, ] b, VectorType dimension, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The vector |
| System.Byte[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Single[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Single[], Decimal)
Elementwise addition between a vector a and a scalar b.
Declaration
public static float[] Add(this float[] a, decimal b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The vector |
| System.Decimal | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Single[] |
Add(Single[], Decimal, Decimal[])
Elementwise addition between a vector a and a scalar b.
Declaration
public static decimal[] Add(this float[] a, decimal b, decimal[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The vector |
| System.Decimal | b | The scalar |
| System.Decimal[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[] |
Add(Single[], Decimal, Double[])
Elementwise addition between a vector a and a scalar b.
Declaration
public static double[] Add(this float[] a, decimal b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The vector |
| System.Decimal | b | The scalar |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Single[], Decimal, Single[])
Elementwise addition between a vector a and a scalar b.
Declaration
public static float[] Add(this float[] a, decimal b, float[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The vector |
| System.Decimal | b | The scalar |
| System.Single[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[] |
Add(Single[], Decimal[])
Elementwise addition between a vector a and a vector b.
Declaration
public static float[] Add(this float[] a, decimal[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The vector |
| System.Decimal[] | b | The vector |
Returns
| Type | Description |
|---|---|
| System.Single[] |
Add(Single[], Decimal[], Decimal[])
Elementwise addition between a vector a and a vectorb.
Declaration
public static decimal[] Add(this float[] a, decimal[] b, decimal[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The vector |
| System.Decimal[] | b | The vector |
| System.Decimal[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[] |
Add(Single[], Decimal[], Double[])
Elementwise addition between a vector a and a vectorb.
Declaration
public static double[] Add(this float[] a, decimal[] b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The vector |
| System.Decimal[] | b | The vector |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Single[], Decimal[], Single[])
Elementwise addition between a vector a and a vectorb.
Declaration
public static float[] Add(this float[] a, decimal[] b, float[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The vector |
| System.Decimal[] | b | The vector |
| System.Single[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[] |
Add(Single[], Decimal[][], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static float[][] Add(this float[] a, decimal[][] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The vector |
| System.Decimal[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Single[], Decimal[][], VectorType, Decimal[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static decimal[][] Add(this float[] a, decimal[][] b, VectorType dimension, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The vector |
| System.Decimal[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Decimal[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
Add(Single[], Decimal[][], VectorType, Double[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this float[] a, decimal[][] b, VectorType dimension, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The vector |
| System.Decimal[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Single[], Decimal[][], VectorType, Single[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static float[][] Add(this float[] a, decimal[][] b, VectorType dimension, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The vector |
| System.Decimal[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Single[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Single[], Decimal[,], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static float[, ] Add(this float[] a, decimal[, ] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The vector |
| System.Decimal[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Single[], Decimal[,], VectorType, Decimal[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static decimal[, ] Add(this float[] a, decimal[, ] b, VectorType dimension, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The vector |
| System.Decimal[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Decimal[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
Add(Single[], Decimal[,], VectorType, Double[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this float[] a, decimal[, ] b, VectorType dimension, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The vector |
| System.Decimal[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Single[], Decimal[,], VectorType, Single[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static float[, ] Add(this float[] a, decimal[, ] b, VectorType dimension, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The vector |
| System.Decimal[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Single[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Single[], Double)
Elementwise addition between a vector a and a scalar b.
Declaration
public static double[] Add(this float[] a, double b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The vector |
| System.Double | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Single[], Double, Double[])
Elementwise addition between a vector a and a scalar b.
Declaration
public static double[] Add(this float[] a, double b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The vector |
| System.Double | b | The scalar |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Single[], Double, Single[])
Elementwise addition between a vector a and a scalar b.
Declaration
public static float[] Add(this float[] a, double b, float[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The vector |
| System.Double | b | The scalar |
| System.Single[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[] |
Add(Single[], Double[])
Elementwise addition between a vector a and a vector b.
Declaration
public static double[] Add(this float[] a, double[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The vector |
| System.Double[] | b | The vector |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Single[], Double[], Double[])
Elementwise addition between a vector a and a vectorb.
Declaration
public static double[] Add(this float[] a, double[] b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The vector |
| System.Double[] | b | The vector |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Single[], Double[], Single[])
Elementwise addition between a vector a and a vectorb.
Declaration
public static float[] Add(this float[] a, double[] b, float[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The vector |
| System.Double[] | b | The vector |
| System.Single[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[] |
Add(Single[], Double[][], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this float[] a, double[][] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The vector |
| System.Double[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Single[], Double[][], VectorType, Double[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this float[] a, double[][] b, VectorType dimension, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The vector |
| System.Double[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Single[], Double[][], VectorType, Single[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static float[][] Add(this float[] a, double[][] b, VectorType dimension, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The vector |
| System.Double[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Single[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Single[], Double[,], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this float[] a, double[, ] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The vector |
| System.Double[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Single[], Double[,], VectorType, Double[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this float[] a, double[, ] b, VectorType dimension, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The vector |
| System.Double[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Single[], Double[,], VectorType, Single[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static float[, ] Add(this float[] a, double[, ] b, VectorType dimension, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The vector |
| System.Double[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Single[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Single[], Int16)
Elementwise addition between a vector a and a scalar b.
Declaration
public static float[] Add(this float[] a, short b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The vector |
| System.Int16 | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Single[] |
Add(Single[], Int16, Double[])
Elementwise addition between a vector a and a scalar b.
Declaration
public static double[] Add(this float[] a, short b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The vector |
| System.Int16 | b | The scalar |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Single[], Int16, Int16[])
Elementwise addition between a vector a and a scalar b.
Declaration
public static short[] Add(this float[] a, short b, short[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The vector |
| System.Int16 | b | The scalar |
| System.Int16[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[] |
Add(Single[], Int16, Single[])
Elementwise addition between a vector a and a scalar b.
Declaration
public static float[] Add(this float[] a, short b, float[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The vector |
| System.Int16 | b | The scalar |
| System.Single[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[] |
Add(Single[], Int16[])
Elementwise addition between a vector a and a vector b.
Declaration
public static float[] Add(this float[] a, short[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The vector |
| System.Int16[] | b | The vector |
Returns
| Type | Description |
|---|---|
| System.Single[] |
Add(Single[], Int16[], Double[])
Elementwise addition between a vector a and a vectorb.
Declaration
public static double[] Add(this float[] a, short[] b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The vector |
| System.Int16[] | b | The vector |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Single[], Int16[], Int16[])
Elementwise addition between a vector a and a vectorb.
Declaration
public static short[] Add(this float[] a, short[] b, short[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The vector |
| System.Int16[] | b | The vector |
| System.Int16[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[] |
Add(Single[], Int16[], Single[])
Elementwise addition between a vector a and a vectorb.
Declaration
public static float[] Add(this float[] a, short[] b, float[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The vector |
| System.Int16[] | b | The vector |
| System.Single[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[] |
Add(Single[], Int16[][], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static float[][] Add(this float[] a, short[][] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The vector |
| System.Int16[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Single[], Int16[][], VectorType, Double[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this float[] a, short[][] b, VectorType dimension, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The vector |
| System.Int16[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Single[], Int16[][], VectorType, Int16[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static short[][] Add(this float[] a, short[][] b, VectorType dimension, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The vector |
| System.Int16[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Int16[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
Add(Single[], Int16[][], VectorType, Single[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static float[][] Add(this float[] a, short[][] b, VectorType dimension, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The vector |
| System.Int16[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Single[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Single[], Int16[,], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static float[, ] Add(this float[] a, short[, ] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The vector |
| System.Int16[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Single[], Int16[,], VectorType, Double[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this float[] a, short[, ] b, VectorType dimension, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The vector |
| System.Int16[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Single[], Int16[,], VectorType, Int16[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static short[, ] Add(this float[] a, short[, ] b, VectorType dimension, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The vector |
| System.Int16[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Int16[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
Add(Single[], Int16[,], VectorType, Single[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static float[, ] Add(this float[] a, short[, ] b, VectorType dimension, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The vector |
| System.Int16[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Single[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Single[], Int32)
Elementwise addition between a vector a and a scalar b.
Declaration
public static float[] Add(this float[] a, int b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The vector |
| System.Int32 | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Single[] |
Add(Single[], Int32, Double[])
Elementwise addition between a vector a and a scalar b.
Declaration
public static double[] Add(this float[] a, int b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The vector |
| System.Int32 | b | The scalar |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Single[], Int32, Int32[])
Elementwise addition between a vector a and a scalar b.
Declaration
public static int[] Add(this float[] a, int b, int[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The vector |
| System.Int32 | b | The scalar |
| System.Int32[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[] |
Add(Single[], Int32, Single[])
Elementwise addition between a vector a and a scalar b.
Declaration
public static float[] Add(this float[] a, int b, float[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The vector |
| System.Int32 | b | The scalar |
| System.Single[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[] |
Add(Single[], Int32[])
Elementwise addition between a vector a and a vector b.
Declaration
public static float[] Add(this float[] a, int[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The vector |
| System.Int32[] | b | The vector |
Returns
| Type | Description |
|---|---|
| System.Single[] |
Add(Single[], Int32[], Double[])
Elementwise addition between a vector a and a vectorb.
Declaration
public static double[] Add(this float[] a, int[] b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The vector |
| System.Int32[] | b | The vector |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Single[], Int32[], Int32[])
Elementwise addition between a vector a and a vectorb.
Declaration
public static int[] Add(this float[] a, int[] b, int[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The vector |
| System.Int32[] | b | The vector |
| System.Int32[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[] |
Add(Single[], Int32[], Single[])
Elementwise addition between a vector a and a vectorb.
Declaration
public static float[] Add(this float[] a, int[] b, float[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The vector |
| System.Int32[] | b | The vector |
| System.Single[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[] |
Add(Single[], Int32[][], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static float[][] Add(this float[] a, int[][] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The vector |
| System.Int32[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Single[], Int32[][], VectorType, Double[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this float[] a, int[][] b, VectorType dimension, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The vector |
| System.Int32[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Single[], Int32[][], VectorType, Int32[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static int[][] Add(this float[] a, int[][] b, VectorType dimension, int[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The vector |
| System.Int32[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Int32[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
Add(Single[], Int32[][], VectorType, Single[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static float[][] Add(this float[] a, int[][] b, VectorType dimension, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The vector |
| System.Int32[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Single[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Single[], Int32[,], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static float[, ] Add(this float[] a, int[, ] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The vector |
| System.Int32[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Single[], Int32[,], VectorType, Double[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this float[] a, int[, ] b, VectorType dimension, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The vector |
| System.Int32[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Single[], Int32[,], VectorType, Int32[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static int[, ] Add(this float[] a, int[, ] b, VectorType dimension, int[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The vector |
| System.Int32[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Int32[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
Add(Single[], Int32[,], VectorType, Single[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static float[, ] Add(this float[] a, int[, ] b, VectorType dimension, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The vector |
| System.Int32[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Single[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Single[], Single)
Elementwise addition between a vector a and a scalar b.
Declaration
public static float[] Add(this float[] a, float b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The vector |
| System.Single | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Single[] |
Add(Single[], Single, Double[])
Elementwise addition between a vector a and a scalar b.
Declaration
public static double[] Add(this float[] a, float b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The vector |
| System.Single | b | The scalar |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Single[], Single, Single[])
Elementwise addition between a vector a and a scalar b.
Declaration
public static float[] Add(this float[] a, float b, float[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The vector |
| System.Single | b | The scalar |
| System.Single[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[] |
Add(Single[], Single[])
Elementwise addition between a vector a and a vector b.
Declaration
public static float[] Add(this float[] a, float[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The vector |
| System.Single[] | b | The vector |
Returns
| Type | Description |
|---|---|
| System.Single[] |
Add(Single[], Single[], Double[])
Elementwise addition between a vector a and a vectorb.
Declaration
public static double[] Add(this float[] a, float[] b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The vector |
| System.Single[] | b | The vector |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Add(Single[], Single[], Single[])
Elementwise addition between a vector a and a vectorb.
Declaration
public static float[] Add(this float[] a, float[] b, float[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The vector |
| System.Single[] | b | The vector |
| System.Single[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[] |
Add(Single[], Single[][], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static float[][] Add(this float[] a, float[][] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The vector |
| System.Single[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Single[], Single[][], VectorType, Double[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this float[] a, float[][] b, VectorType dimension, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The vector |
| System.Single[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Single[], Single[][], VectorType, Single[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static float[][] Add(this float[] a, float[][] b, VectorType dimension, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The vector |
| System.Single[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Single[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Single[], Single[,], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static float[, ] Add(this float[] a, float[, ] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The vector |
| System.Single[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Single[], Single[,], VectorType, Double[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this float[] a, float[, ] b, VectorType dimension, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The vector |
| System.Single[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Single[], Single[,], VectorType, Single[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static float[, ] Add(this float[] a, float[, ] b, VectorType dimension, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The vector |
| System.Single[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Single[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Single[][], Byte)
Elementwise addition between a matrix A and a scalar b.
Declaration
public static float[][] Add(this float[][] a, byte b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | The matrix |
| System.Byte | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Single[][], Byte, Byte[][])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static byte[][] Add(this float[][] a, byte b, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | The matrix |
| System.Byte | b | The scalar |
| System.Byte[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
Add(Single[][], Byte, Double[][])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[][] Add(this float[][] a, byte b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | The matrix |
| System.Byte | b | The scalar |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Single[][], Byte, Single[][])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static float[][] Add(this float[][] a, byte b, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | The matrix |
| System.Byte | b | The scalar |
| System.Single[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Single[][], Byte[], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static float[][] Add(this float[][] a, byte[] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | The matrix |
| System.Byte[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Single[][], Byte[], VectorType, Byte[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static byte[][] Add(this float[][] a, byte[] b, VectorType dimension, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | The matrix |
| System.Byte[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Byte[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
Add(Single[][], Byte[], VectorType, Double[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this float[][] a, byte[] b, VectorType dimension, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | The matrix |
| System.Byte[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Single[][], Byte[], VectorType, Single[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static float[][] Add(this float[][] a, byte[] b, VectorType dimension, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | The matrix |
| System.Byte[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Single[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Single[][], Byte[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static float[][] Add(this float[][] a, byte[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | The matrix |
| System.Byte[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Single[][], Byte[][], Byte[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static byte[][] Add(this float[][] a, byte[][] b, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | The matrix |
| System.Byte[][] | b | The matrix |
| System.Byte[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
Add(Single[][], Byte[][], Double[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[][] Add(this float[][] a, byte[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | The matrix |
| System.Byte[][] | b | The matrix |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Single[][], Byte[][], Single[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static float[][] Add(this float[][] a, byte[][] b, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | The matrix |
| System.Byte[][] | b | The matrix |
| System.Single[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Single[][], Decimal)
Elementwise addition between a matrix A and a scalar b.
Declaration
public static float[][] Add(this float[][] a, decimal b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | The matrix |
| System.Decimal | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Single[][], Decimal, Decimal[][])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static decimal[][] Add(this float[][] a, decimal b, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | The matrix |
| System.Decimal | b | The scalar |
| System.Decimal[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
Add(Single[][], Decimal, Double[][])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[][] Add(this float[][] a, decimal b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | The matrix |
| System.Decimal | b | The scalar |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Single[][], Decimal, Single[][])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static float[][] Add(this float[][] a, decimal b, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | The matrix |
| System.Decimal | b | The scalar |
| System.Single[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Single[][], Decimal[], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static float[][] Add(this float[][] a, decimal[] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | The matrix |
| System.Decimal[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Single[][], Decimal[], VectorType, Decimal[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static decimal[][] Add(this float[][] a, decimal[] b, VectorType dimension, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | The matrix |
| System.Decimal[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Decimal[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
Add(Single[][], Decimal[], VectorType, Double[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this float[][] a, decimal[] b, VectorType dimension, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | The matrix |
| System.Decimal[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Single[][], Decimal[], VectorType, Single[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static float[][] Add(this float[][] a, decimal[] b, VectorType dimension, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | The matrix |
| System.Decimal[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Single[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Single[][], Decimal[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static float[][] Add(this float[][] a, decimal[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | The matrix |
| System.Decimal[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Single[][], Decimal[][], Decimal[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static decimal[][] Add(this float[][] a, decimal[][] b, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | The matrix |
| System.Decimal[][] | b | The matrix |
| System.Decimal[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
Add(Single[][], Decimal[][], Double[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[][] Add(this float[][] a, decimal[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | The matrix |
| System.Decimal[][] | b | The matrix |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Single[][], Decimal[][], Single[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static float[][] Add(this float[][] a, decimal[][] b, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | The matrix |
| System.Decimal[][] | b | The matrix |
| System.Single[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Single[][], Double)
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[][] Add(this float[][] a, double b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | The matrix |
| System.Double | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Single[][], Double, Double[][])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[][] Add(this float[][] a, double b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | The matrix |
| System.Double | b | The scalar |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Single[][], Double, Single[][])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static float[][] Add(this float[][] a, double b, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | The matrix |
| System.Double | b | The scalar |
| System.Single[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Single[][], Double[], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this float[][] a, double[] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | The matrix |
| System.Double[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Single[][], Double[], VectorType, Double[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this float[][] a, double[] b, VectorType dimension, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | The matrix |
| System.Double[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Single[][], Double[], VectorType, Single[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static float[][] Add(this float[][] a, double[] b, VectorType dimension, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | The matrix |
| System.Double[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Single[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Single[][], Double[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[][] Add(this float[][] a, double[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | The matrix |
| System.Double[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Single[][], Double[][], Double[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[][] Add(this float[][] a, double[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | The matrix |
| System.Double[][] | b | The matrix |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Single[][], Double[][], Single[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static float[][] Add(this float[][] a, double[][] b, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | The matrix |
| System.Double[][] | b | The matrix |
| System.Single[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Single[][], Int16)
Elementwise addition between a matrix A and a scalar b.
Declaration
public static float[][] Add(this float[][] a, short b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | The matrix |
| System.Int16 | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Single[][], Int16, Double[][])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[][] Add(this float[][] a, short b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | The matrix |
| System.Int16 | b | The scalar |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Single[][], Int16, Int16[][])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static short[][] Add(this float[][] a, short b, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | The matrix |
| System.Int16 | b | The scalar |
| System.Int16[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
Add(Single[][], Int16, Single[][])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static float[][] Add(this float[][] a, short b, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | The matrix |
| System.Int16 | b | The scalar |
| System.Single[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Single[][], Int16[], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static float[][] Add(this float[][] a, short[] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | The matrix |
| System.Int16[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Single[][], Int16[], VectorType, Double[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this float[][] a, short[] b, VectorType dimension, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | The matrix |
| System.Int16[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Single[][], Int16[], VectorType, Int16[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static short[][] Add(this float[][] a, short[] b, VectorType dimension, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | The matrix |
| System.Int16[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Int16[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
Add(Single[][], Int16[], VectorType, Single[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static float[][] Add(this float[][] a, short[] b, VectorType dimension, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | The matrix |
| System.Int16[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Single[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Single[][], Int16[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static float[][] Add(this float[][] a, short[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | The matrix |
| System.Int16[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Single[][], Int16[][], Double[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[][] Add(this float[][] a, short[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | The matrix |
| System.Int16[][] | b | The matrix |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Single[][], Int16[][], Int16[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static short[][] Add(this float[][] a, short[][] b, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | The matrix |
| System.Int16[][] | b | The matrix |
| System.Int16[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
Add(Single[][], Int16[][], Single[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static float[][] Add(this float[][] a, short[][] b, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | The matrix |
| System.Int16[][] | b | The matrix |
| System.Single[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Single[][], Int32)
Elementwise addition between a matrix A and a scalar b.
Declaration
public static float[][] Add(this float[][] a, int b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | The matrix |
| System.Int32 | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Single[][], Int32, Double[][])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[][] Add(this float[][] a, int b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | The matrix |
| System.Int32 | b | The scalar |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Single[][], Int32, Int32[][])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static int[][] Add(this float[][] a, int b, int[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | The matrix |
| System.Int32 | b | The scalar |
| System.Int32[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
Add(Single[][], Int32, Single[][])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static float[][] Add(this float[][] a, int b, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | The matrix |
| System.Int32 | b | The scalar |
| System.Single[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Single[][], Int32[], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static float[][] Add(this float[][] a, int[] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | The matrix |
| System.Int32[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Single[][], Int32[], VectorType, Double[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this float[][] a, int[] b, VectorType dimension, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | The matrix |
| System.Int32[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Single[][], Int32[], VectorType, Int32[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static int[][] Add(this float[][] a, int[] b, VectorType dimension, int[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | The matrix |
| System.Int32[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Int32[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
Add(Single[][], Int32[], VectorType, Single[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static float[][] Add(this float[][] a, int[] b, VectorType dimension, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | The matrix |
| System.Int32[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Single[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Single[][], Int32[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static float[][] Add(this float[][] a, int[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | The matrix |
| System.Int32[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Single[][], Int32[][], Double[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[][] Add(this float[][] a, int[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | The matrix |
| System.Int32[][] | b | The matrix |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Single[][], Int32[][], Int32[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static int[][] Add(this float[][] a, int[][] b, int[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | The matrix |
| System.Int32[][] | b | The matrix |
| System.Int32[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
Add(Single[][], Int32[][], Single[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static float[][] Add(this float[][] a, int[][] b, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | The matrix |
| System.Int32[][] | b | The matrix |
| System.Single[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Single[][], Single)
Elementwise addition between a matrix A and a scalar b.
Declaration
public static float[][] Add(this float[][] a, float b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | The matrix |
| System.Single | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Single[][], Single, Double[][])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[][] Add(this float[][] a, float b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | The matrix |
| System.Single | b | The scalar |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Single[][], Single, Single[][])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static float[][] Add(this float[][] a, float b, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | The matrix |
| System.Single | b | The scalar |
| System.Single[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Single[][], Single[], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static float[][] Add(this float[][] a, float[] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | The matrix |
| System.Single[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Single[][], Single[], VectorType, Double[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[][] Add(this float[][] a, float[] b, VectorType dimension, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | The matrix |
| System.Single[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Single[][], Single[], VectorType, Single[][])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static float[][] Add(this float[][] a, float[] b, VectorType dimension, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | The matrix |
| System.Single[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Single[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Single[][], Single[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static float[][] Add(this float[][] a, float[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | The matrix |
| System.Single[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Single[][], Single[][], Double[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[][] Add(this float[][] a, float[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | The matrix |
| System.Single[][] | b | The matrix |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Add(Single[][], Single[][], Single[][])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static float[][] Add(this float[][] a, float[][] b, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | The matrix |
| System.Single[][] | b | The matrix |
| System.Single[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
Add(Single[,], Byte)
Elementwise addition between a matrix A and a scalar b.
Declaration
public static float[, ] Add(this float[, ] a, byte b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | The matrix |
| System.Byte | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Single[,], Byte, Byte[,])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static byte[, ] Add(this float[, ] a, byte b, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | The matrix |
| System.Byte | b | The scalar |
| System.Byte[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
Add(Single[,], Byte, Double[,])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[, ] Add(this float[, ] a, byte b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | The matrix |
| System.Byte | b | The scalar |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Single[,], Byte, Single[,])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static float[, ] Add(this float[, ] a, byte b, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | The matrix |
| System.Byte | b | The scalar |
| System.Single[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Single[,], Byte[], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static float[, ] Add(this float[, ] a, byte[] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | The matrix |
| System.Byte[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Single[,], Byte[], VectorType, Byte[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static byte[, ] Add(this float[, ] a, byte[] b, VectorType dimension, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | The matrix |
| System.Byte[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Byte[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
Add(Single[,], Byte[], VectorType, Double[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this float[, ] a, byte[] b, VectorType dimension, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | The matrix |
| System.Byte[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Single[,], Byte[], VectorType, Single[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static float[, ] Add(this float[, ] a, byte[] b, VectorType dimension, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | The matrix |
| System.Byte[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Single[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Single[,], Byte[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static float[, ] Add(this float[, ] a, byte[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | The matrix |
| System.Byte[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Single[,], Byte[,], Byte[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static byte[, ] Add(this float[, ] a, byte[, ] b, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | The matrix |
| System.Byte[,] | b | The matrix |
| System.Byte[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
Add(Single[,], Byte[,], Double[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[, ] Add(this float[, ] a, byte[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | The matrix |
| System.Byte[,] | b | The matrix |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Single[,], Byte[,], Single[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static float[, ] Add(this float[, ] a, byte[, ] b, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | The matrix |
| System.Byte[,] | b | The matrix |
| System.Single[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Single[,], Decimal)
Elementwise addition between a matrix A and a scalar b.
Declaration
public static float[, ] Add(this float[, ] a, decimal b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | The matrix |
| System.Decimal | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Single[,], Decimal, Decimal[,])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static decimal[, ] Add(this float[, ] a, decimal b, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | The matrix |
| System.Decimal | b | The scalar |
| System.Decimal[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
Add(Single[,], Decimal, Double[,])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[, ] Add(this float[, ] a, decimal b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | The matrix |
| System.Decimal | b | The scalar |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Single[,], Decimal, Single[,])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static float[, ] Add(this float[, ] a, decimal b, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | The matrix |
| System.Decimal | b | The scalar |
| System.Single[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Single[,], Decimal[], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static float[, ] Add(this float[, ] a, decimal[] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | The matrix |
| System.Decimal[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Single[,], Decimal[], VectorType, Decimal[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static decimal[, ] Add(this float[, ] a, decimal[] b, VectorType dimension, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | The matrix |
| System.Decimal[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Decimal[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
Add(Single[,], Decimal[], VectorType, Double[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this float[, ] a, decimal[] b, VectorType dimension, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | The matrix |
| System.Decimal[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Single[,], Decimal[], VectorType, Single[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static float[, ] Add(this float[, ] a, decimal[] b, VectorType dimension, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | The matrix |
| System.Decimal[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Single[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Single[,], Decimal[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static float[, ] Add(this float[, ] a, decimal[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | The matrix |
| System.Decimal[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Single[,], Decimal[,], Decimal[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static decimal[, ] Add(this float[, ] a, decimal[, ] b, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | The matrix |
| System.Decimal[,] | b | The matrix |
| System.Decimal[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
Add(Single[,], Decimal[,], Double[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[, ] Add(this float[, ] a, decimal[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | The matrix |
| System.Decimal[,] | b | The matrix |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Single[,], Decimal[,], Single[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static float[, ] Add(this float[, ] a, decimal[, ] b, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | The matrix |
| System.Decimal[,] | b | The matrix |
| System.Single[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Single[,], Double)
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[, ] Add(this float[, ] a, double b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | The matrix |
| System.Double | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Single[,], Double, Double[,])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[, ] Add(this float[, ] a, double b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | The matrix |
| System.Double | b | The scalar |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Single[,], Double, Single[,])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static float[, ] Add(this float[, ] a, double b, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | The matrix |
| System.Double | b | The scalar |
| System.Single[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Single[,], Double[], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this float[, ] a, double[] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | The matrix |
| System.Double[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Single[,], Double[], VectorType, Double[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this float[, ] a, double[] b, VectorType dimension, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | The matrix |
| System.Double[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Single[,], Double[], VectorType, Single[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static float[, ] Add(this float[, ] a, double[] b, VectorType dimension, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | The matrix |
| System.Double[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Single[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Single[,], Double[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[, ] Add(this float[, ] a, double[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | The matrix |
| System.Double[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Single[,], Double[,], Double[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[, ] Add(this float[, ] a, double[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | The matrix |
| System.Double[,] | b | The matrix |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Single[,], Double[,], Single[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static float[, ] Add(this float[, ] a, double[, ] b, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | The matrix |
| System.Double[,] | b | The matrix |
| System.Single[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Single[,], Int16)
Elementwise addition between a matrix A and a scalar b.
Declaration
public static float[, ] Add(this float[, ] a, short b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | The matrix |
| System.Int16 | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Single[,], Int16, Double[,])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[, ] Add(this float[, ] a, short b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | The matrix |
| System.Int16 | b | The scalar |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Single[,], Int16, Int16[,])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static short[, ] Add(this float[, ] a, short b, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | The matrix |
| System.Int16 | b | The scalar |
| System.Int16[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
Add(Single[,], Int16, Single[,])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static float[, ] Add(this float[, ] a, short b, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | The matrix |
| System.Int16 | b | The scalar |
| System.Single[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Single[,], Int16[], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static float[, ] Add(this float[, ] a, short[] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | The matrix |
| System.Int16[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Single[,], Int16[], VectorType, Double[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this float[, ] a, short[] b, VectorType dimension, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | The matrix |
| System.Int16[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Single[,], Int16[], VectorType, Int16[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static short[, ] Add(this float[, ] a, short[] b, VectorType dimension, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | The matrix |
| System.Int16[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Int16[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
Add(Single[,], Int16[], VectorType, Single[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static float[, ] Add(this float[, ] a, short[] b, VectorType dimension, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | The matrix |
| System.Int16[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Single[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Single[,], Int16[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static float[, ] Add(this float[, ] a, short[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | The matrix |
| System.Int16[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Single[,], Int16[,], Double[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[, ] Add(this float[, ] a, short[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | The matrix |
| System.Int16[,] | b | The matrix |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Single[,], Int16[,], Int16[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static short[, ] Add(this float[, ] a, short[, ] b, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | The matrix |
| System.Int16[,] | b | The matrix |
| System.Int16[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
Add(Single[,], Int16[,], Single[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static float[, ] Add(this float[, ] a, short[, ] b, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | The matrix |
| System.Int16[,] | b | The matrix |
| System.Single[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Single[,], Int32)
Elementwise addition between a matrix A and a scalar b.
Declaration
public static float[, ] Add(this float[, ] a, int b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | The matrix |
| System.Int32 | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Single[,], Int32, Double[,])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[, ] Add(this float[, ] a, int b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | The matrix |
| System.Int32 | b | The scalar |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Single[,], Int32, Int32[,])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static int[, ] Add(this float[, ] a, int b, int[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | The matrix |
| System.Int32 | b | The scalar |
| System.Int32[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
Add(Single[,], Int32, Single[,])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static float[, ] Add(this float[, ] a, int b, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | The matrix |
| System.Int32 | b | The scalar |
| System.Single[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Single[,], Int32[], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static float[, ] Add(this float[, ] a, int[] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | The matrix |
| System.Int32[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Single[,], Int32[], VectorType, Double[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this float[, ] a, int[] b, VectorType dimension, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | The matrix |
| System.Int32[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Single[,], Int32[], VectorType, Int32[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static int[, ] Add(this float[, ] a, int[] b, VectorType dimension, int[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | The matrix |
| System.Int32[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Int32[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
Add(Single[,], Int32[], VectorType, Single[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static float[, ] Add(this float[, ] a, int[] b, VectorType dimension, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | The matrix |
| System.Int32[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Single[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Single[,], Int32[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static float[, ] Add(this float[, ] a, int[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | The matrix |
| System.Int32[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Single[,], Int32[,], Double[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[, ] Add(this float[, ] a, int[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | The matrix |
| System.Int32[,] | b | The matrix |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Single[,], Int32[,], Int32[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static int[, ] Add(this float[, ] a, int[, ] b, int[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | The matrix |
| System.Int32[,] | b | The matrix |
| System.Int32[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
Add(Single[,], Int32[,], Single[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static float[, ] Add(this float[, ] a, int[, ] b, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | The matrix |
| System.Int32[,] | b | The matrix |
| System.Single[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Single[,], Single)
Elementwise addition between a matrix A and a scalar b.
Declaration
public static float[, ] Add(this float[, ] a, float b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | The matrix |
| System.Single | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Single[,], Single, Double[,])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static double[, ] Add(this float[, ] a, float b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | The matrix |
| System.Single | b | The scalar |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Single[,], Single, Single[,])
Elementwise addition between a matrix A and a scalar b.
Declaration
public static float[, ] Add(this float[, ] a, float b, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | The matrix |
| System.Single | b | The scalar |
| System.Single[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Single[,], Single[], VectorType)
Elementwise addition between a matrix A and a vectorb.
Declaration
public static float[, ] Add(this float[, ] a, float[] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | The matrix |
| System.Single[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Single[,], Single[], VectorType, Double[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static double[, ] Add(this float[, ] a, float[] b, VectorType dimension, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | The matrix |
| System.Single[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Single[,], Single[], VectorType, Single[,])
Elementwise addition between a matrix A and a vectorb.
Declaration
public static float[, ] Add(this float[, ] a, float[] b, VectorType dimension, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | The matrix |
| System.Single[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Single[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Single[,], Single[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static float[, ] Add(this float[, ] a, float[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | The matrix |
| System.Single[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Add(Single[,], Single[,], Double[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static double[, ] Add(this float[, ] a, float[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | The matrix |
| System.Single[,] | b | The matrix |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Add(Single[,], Single[,], Single[,])
Elementwise addition between a matrix A and a matrix B.
Declaration
public static float[, ] Add(this float[, ] a, float[, ] b, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | The matrix |
| System.Single[,] | b | The matrix |
| System.Single[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
AddToDiagonal(Byte, Byte[][])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static byte[][] AddToDiagonal(this byte a, byte[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | The scalar |
| System.Byte[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
AddToDiagonal(Byte, Byte[][], Byte[][])
Declaration
public static byte[][] AddToDiagonal(this byte a, byte[][] b, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | |
| System.Byte[][] | b | |
| System.Byte[][] | result |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
AddToDiagonal(Byte, Byte[][], Double[][])
Declaration
public static double[][] AddToDiagonal(this byte a, byte[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | |
| System.Byte[][] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Byte, Byte[,])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static byte[, ] AddToDiagonal(this byte a, byte[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | The scalar |
| System.Byte[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
AddToDiagonal(Byte, Byte[,], Byte[,])
Declaration
public static byte[, ] AddToDiagonal(this byte a, byte[, ] b, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | |
| System.Byte[,] | b | |
| System.Byte[,] | result |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
AddToDiagonal(Byte, Byte[,], Double[,])
Declaration
public static double[, ] AddToDiagonal(this byte a, byte[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | |
| System.Byte[,] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Byte, Decimal[][], Byte[][])
Declaration
public static byte[][] AddToDiagonal(this byte a, decimal[][] b, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | |
| System.Decimal[][] | b | |
| System.Byte[][] | result |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
AddToDiagonal(Byte, Decimal[][], Decimal[][])
Declaration
public static decimal[][] AddToDiagonal(this byte a, decimal[][] b, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | |
| System.Decimal[][] | b | |
| System.Decimal[][] | result |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
AddToDiagonal(Byte, Decimal[][], Double[][])
Declaration
public static double[][] AddToDiagonal(this byte a, decimal[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | |
| System.Decimal[][] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Byte, Decimal[,], Byte[,])
Declaration
public static byte[, ] AddToDiagonal(this byte a, decimal[, ] b, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | |
| System.Decimal[,] | b | |
| System.Byte[,] | result |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
AddToDiagonal(Byte, Decimal[,], Decimal[,])
Declaration
public static decimal[, ] AddToDiagonal(this byte a, decimal[, ] b, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | |
| System.Decimal[,] | b | |
| System.Decimal[,] | result |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
AddToDiagonal(Byte, Decimal[,], Double[,])
Declaration
public static double[, ] AddToDiagonal(this byte a, decimal[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | |
| System.Decimal[,] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Byte, Double[][])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static double[][] AddToDiagonal(this byte a, double[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | The scalar |
| System.Double[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Byte, Double[][], Byte[][])
Declaration
public static byte[][] AddToDiagonal(this byte a, double[][] b, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | |
| System.Double[][] | b | |
| System.Byte[][] | result |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
AddToDiagonal(Byte, Double[][], Double[][])
Declaration
public static double[][] AddToDiagonal(this byte a, double[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | |
| System.Double[][] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Byte, Double[,])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static double[, ] AddToDiagonal(this byte a, double[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | The scalar |
| System.Double[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Byte, Double[,], Byte[,])
Declaration
public static byte[, ] AddToDiagonal(this byte a, double[, ] b, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | |
| System.Double[,] | b | |
| System.Byte[,] | result |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
AddToDiagonal(Byte, Double[,], Double[,])
Declaration
public static double[, ] AddToDiagonal(this byte a, double[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | |
| System.Double[,] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Byte, Int16[][], Byte[][])
Declaration
public static byte[][] AddToDiagonal(this byte a, short[][] b, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | |
| System.Int16[][] | b | |
| System.Byte[][] | result |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
AddToDiagonal(Byte, Int16[][], Double[][])
Declaration
public static double[][] AddToDiagonal(this byte a, short[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | |
| System.Int16[][] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Byte, Int16[][], Int16[][])
Declaration
public static short[][] AddToDiagonal(this byte a, short[][] b, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | |
| System.Int16[][] | b | |
| System.Int16[][] | result |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
AddToDiagonal(Byte, Int16[,], Byte[,])
Declaration
public static byte[, ] AddToDiagonal(this byte a, short[, ] b, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | |
| System.Int16[,] | b | |
| System.Byte[,] | result |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
AddToDiagonal(Byte, Int16[,], Double[,])
Declaration
public static double[, ] AddToDiagonal(this byte a, short[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | |
| System.Int16[,] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Byte, Int16[,], Int16[,])
Declaration
public static short[, ] AddToDiagonal(this byte a, short[, ] b, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | |
| System.Int16[,] | b | |
| System.Int16[,] | result |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
AddToDiagonal(Byte, Int32[][])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static int[][] AddToDiagonal(this byte a, int[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | The scalar |
| System.Int32[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
AddToDiagonal(Byte, Int32[][], Byte[][])
Declaration
public static byte[][] AddToDiagonal(this byte a, int[][] b, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | |
| System.Int32[][] | b | |
| System.Byte[][] | result |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
AddToDiagonal(Byte, Int32[][], Double[][])
Declaration
public static double[][] AddToDiagonal(this byte a, int[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | |
| System.Int32[][] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Byte, Int32[][], Int32[][])
Declaration
public static int[][] AddToDiagonal(this byte a, int[][] b, int[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | |
| System.Int32[][] | b | |
| System.Int32[][] | result |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
AddToDiagonal(Byte, Int32[,])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static int[, ] AddToDiagonal(this byte a, int[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | The scalar |
| System.Int32[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
AddToDiagonal(Byte, Int32[,], Byte[,])
Declaration
public static byte[, ] AddToDiagonal(this byte a, int[, ] b, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | |
| System.Int32[,] | b | |
| System.Byte[,] | result |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
AddToDiagonal(Byte, Int32[,], Double[,])
Declaration
public static double[, ] AddToDiagonal(this byte a, int[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | |
| System.Int32[,] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Byte, Int32[,], Int32[,])
Declaration
public static int[, ] AddToDiagonal(this byte a, int[, ] b, int[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | |
| System.Int32[,] | b | |
| System.Int32[,] | result |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
AddToDiagonal(Byte, Single[][])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static float[][] AddToDiagonal(this byte a, float[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | The scalar |
| System.Single[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
AddToDiagonal(Byte, Single[][], Byte[][])
Declaration
public static byte[][] AddToDiagonal(this byte a, float[][] b, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | |
| System.Single[][] | b | |
| System.Byte[][] | result |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
AddToDiagonal(Byte, Single[][], Double[][])
Declaration
public static double[][] AddToDiagonal(this byte a, float[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | |
| System.Single[][] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Byte, Single[][], Single[][])
Declaration
public static float[][] AddToDiagonal(this byte a, float[][] b, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | |
| System.Single[][] | b | |
| System.Single[][] | result |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
AddToDiagonal(Byte, Single[,])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static float[, ] AddToDiagonal(this byte a, float[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | The scalar |
| System.Single[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
AddToDiagonal(Byte, Single[,], Byte[,])
Declaration
public static byte[, ] AddToDiagonal(this byte a, float[, ] b, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | |
| System.Single[,] | b | |
| System.Byte[,] | result |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
AddToDiagonal(Byte, Single[,], Double[,])
Declaration
public static double[, ] AddToDiagonal(this byte a, float[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | |
| System.Single[,] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Byte, Single[,], Single[,])
Declaration
public static float[, ] AddToDiagonal(this byte a, float[, ] b, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte | a | |
| System.Single[,] | b | |
| System.Single[,] | result |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
AddToDiagonal(Byte[], Byte[][])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static byte[][] AddToDiagonal(this byte[] a, byte[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | The scalar |
| System.Byte[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
AddToDiagonal(Byte[], Byte[][], Byte[][])
Declaration
public static byte[][] AddToDiagonal(this byte[] a, byte[][] b, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | |
| System.Byte[][] | b | |
| System.Byte[][] | result |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
AddToDiagonal(Byte[], Byte[][], Double[][])
Declaration
public static double[][] AddToDiagonal(this byte[] a, byte[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | |
| System.Byte[][] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Byte[], Byte[,])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static byte[, ] AddToDiagonal(this byte[] a, byte[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | The scalar |
| System.Byte[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
AddToDiagonal(Byte[], Byte[,], Byte[,])
Declaration
public static byte[, ] AddToDiagonal(this byte[] a, byte[, ] b, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | |
| System.Byte[,] | b | |
| System.Byte[,] | result |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
AddToDiagonal(Byte[], Byte[,], Double[,])
Declaration
public static double[, ] AddToDiagonal(this byte[] a, byte[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | |
| System.Byte[,] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Byte[], Decimal[][], Byte[][])
Declaration
public static byte[][] AddToDiagonal(this byte[] a, decimal[][] b, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | |
| System.Decimal[][] | b | |
| System.Byte[][] | result |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
AddToDiagonal(Byte[], Decimal[][], Decimal[][])
Declaration
public static decimal[][] AddToDiagonal(this byte[] a, decimal[][] b, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | |
| System.Decimal[][] | b | |
| System.Decimal[][] | result |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
AddToDiagonal(Byte[], Decimal[][], Double[][])
Declaration
public static double[][] AddToDiagonal(this byte[] a, decimal[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | |
| System.Decimal[][] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Byte[], Decimal[,], Byte[,])
Declaration
public static byte[, ] AddToDiagonal(this byte[] a, decimal[, ] b, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | |
| System.Decimal[,] | b | |
| System.Byte[,] | result |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
AddToDiagonal(Byte[], Decimal[,], Decimal[,])
Declaration
public static decimal[, ] AddToDiagonal(this byte[] a, decimal[, ] b, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | |
| System.Decimal[,] | b | |
| System.Decimal[,] | result |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
AddToDiagonal(Byte[], Decimal[,], Double[,])
Declaration
public static double[, ] AddToDiagonal(this byte[] a, decimal[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | |
| System.Decimal[,] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Byte[], Double[][])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static double[][] AddToDiagonal(this byte[] a, double[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | The scalar |
| System.Double[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Byte[], Double[][], Byte[][])
Declaration
public static byte[][] AddToDiagonal(this byte[] a, double[][] b, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | |
| System.Double[][] | b | |
| System.Byte[][] | result |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
AddToDiagonal(Byte[], Double[][], Double[][])
Declaration
public static double[][] AddToDiagonal(this byte[] a, double[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | |
| System.Double[][] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Byte[], Double[,])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static double[, ] AddToDiagonal(this byte[] a, double[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | The scalar |
| System.Double[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Byte[], Double[,], Byte[,])
Declaration
public static byte[, ] AddToDiagonal(this byte[] a, double[, ] b, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | |
| System.Double[,] | b | |
| System.Byte[,] | result |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
AddToDiagonal(Byte[], Double[,], Double[,])
Declaration
public static double[, ] AddToDiagonal(this byte[] a, double[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | |
| System.Double[,] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Byte[], Int16[][], Byte[][])
Declaration
public static byte[][] AddToDiagonal(this byte[] a, short[][] b, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | |
| System.Int16[][] | b | |
| System.Byte[][] | result |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
AddToDiagonal(Byte[], Int16[][], Double[][])
Declaration
public static double[][] AddToDiagonal(this byte[] a, short[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | |
| System.Int16[][] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Byte[], Int16[][], Int16[][])
Declaration
public static short[][] AddToDiagonal(this byte[] a, short[][] b, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | |
| System.Int16[][] | b | |
| System.Int16[][] | result |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
AddToDiagonal(Byte[], Int16[,], Byte[,])
Declaration
public static byte[, ] AddToDiagonal(this byte[] a, short[, ] b, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | |
| System.Int16[,] | b | |
| System.Byte[,] | result |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
AddToDiagonal(Byte[], Int16[,], Double[,])
Declaration
public static double[, ] AddToDiagonal(this byte[] a, short[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | |
| System.Int16[,] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Byte[], Int16[,], Int16[,])
Declaration
public static short[, ] AddToDiagonal(this byte[] a, short[, ] b, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | |
| System.Int16[,] | b | |
| System.Int16[,] | result |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
AddToDiagonal(Byte[], Int32[][])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static int[][] AddToDiagonal(this byte[] a, int[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | The scalar |
| System.Int32[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
AddToDiagonal(Byte[], Int32[][], Byte[][])
Declaration
public static byte[][] AddToDiagonal(this byte[] a, int[][] b, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | |
| System.Int32[][] | b | |
| System.Byte[][] | result |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
AddToDiagonal(Byte[], Int32[][], Double[][])
Declaration
public static double[][] AddToDiagonal(this byte[] a, int[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | |
| System.Int32[][] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Byte[], Int32[][], Int32[][])
Declaration
public static int[][] AddToDiagonal(this byte[] a, int[][] b, int[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | |
| System.Int32[][] | b | |
| System.Int32[][] | result |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
AddToDiagonal(Byte[], Int32[,])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static int[, ] AddToDiagonal(this byte[] a, int[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | The scalar |
| System.Int32[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
AddToDiagonal(Byte[], Int32[,], Byte[,])
Declaration
public static byte[, ] AddToDiagonal(this byte[] a, int[, ] b, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | |
| System.Int32[,] | b | |
| System.Byte[,] | result |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
AddToDiagonal(Byte[], Int32[,], Double[,])
Declaration
public static double[, ] AddToDiagonal(this byte[] a, int[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | |
| System.Int32[,] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Byte[], Int32[,], Int32[,])
Declaration
public static int[, ] AddToDiagonal(this byte[] a, int[, ] b, int[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | |
| System.Int32[,] | b | |
| System.Int32[,] | result |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
AddToDiagonal(Byte[], Single[][])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static float[][] AddToDiagonal(this byte[] a, float[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | The scalar |
| System.Single[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
AddToDiagonal(Byte[], Single[][], Byte[][])
Declaration
public static byte[][] AddToDiagonal(this byte[] a, float[][] b, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | |
| System.Single[][] | b | |
| System.Byte[][] | result |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
AddToDiagonal(Byte[], Single[][], Double[][])
Declaration
public static double[][] AddToDiagonal(this byte[] a, float[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | |
| System.Single[][] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Byte[], Single[][], Single[][])
Declaration
public static float[][] AddToDiagonal(this byte[] a, float[][] b, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | |
| System.Single[][] | b | |
| System.Single[][] | result |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
AddToDiagonal(Byte[], Single[,])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static float[, ] AddToDiagonal(this byte[] a, float[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | The scalar |
| System.Single[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
AddToDiagonal(Byte[], Single[,], Byte[,])
Declaration
public static byte[, ] AddToDiagonal(this byte[] a, float[, ] b, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | |
| System.Single[,] | b | |
| System.Byte[,] | result |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
AddToDiagonal(Byte[], Single[,], Double[,])
Declaration
public static double[, ] AddToDiagonal(this byte[] a, float[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | |
| System.Single[,] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Byte[], Single[,], Single[,])
Declaration
public static float[, ] AddToDiagonal(this byte[] a, float[, ] b, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[] | a | |
| System.Single[,] | b | |
| System.Single[,] | result |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
AddToDiagonal(Byte[][], Byte)
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static byte[][] AddToDiagonal(this byte[][] a, byte b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | The scalar |
| System.Byte | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
AddToDiagonal(Byte[][], Byte, Byte[][])
Declaration
public static byte[][] AddToDiagonal(this byte[][] a, byte b, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | |
| System.Byte | b | |
| System.Byte[][] | result |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
AddToDiagonal(Byte[][], Byte, Double[][])
Declaration
public static double[][] AddToDiagonal(this byte[][] a, byte b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | |
| System.Byte | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Byte[][], Byte[])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static byte[][] AddToDiagonal(this byte[][] a, byte[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | The scalar |
| System.Byte[] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
AddToDiagonal(Byte[][], Byte[], Byte[][])
Declaration
public static byte[][] AddToDiagonal(this byte[][] a, byte[] b, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | |
| System.Byte[] | b | |
| System.Byte[][] | result |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
AddToDiagonal(Byte[][], Byte[], Double[][])
Declaration
public static double[][] AddToDiagonal(this byte[][] a, byte[] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | |
| System.Byte[] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Byte[][], Decimal, Byte[][])
Declaration
public static byte[][] AddToDiagonal(this byte[][] a, decimal b, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | |
| System.Decimal | b | |
| System.Byte[][] | result |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
AddToDiagonal(Byte[][], Decimal, Decimal[][])
Declaration
public static decimal[][] AddToDiagonal(this byte[][] a, decimal b, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | |
| System.Decimal | b | |
| System.Decimal[][] | result |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
AddToDiagonal(Byte[][], Decimal, Double[][])
Declaration
public static double[][] AddToDiagonal(this byte[][] a, decimal b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | |
| System.Decimal | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Byte[][], Decimal[], Byte[][])
Declaration
public static byte[][] AddToDiagonal(this byte[][] a, decimal[] b, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | |
| System.Decimal[] | b | |
| System.Byte[][] | result |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
AddToDiagonal(Byte[][], Decimal[], Decimal[][])
Declaration
public static decimal[][] AddToDiagonal(this byte[][] a, decimal[] b, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | |
| System.Decimal[] | b | |
| System.Decimal[][] | result |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
AddToDiagonal(Byte[][], Decimal[], Double[][])
Declaration
public static double[][] AddToDiagonal(this byte[][] a, decimal[] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | |
| System.Decimal[] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Byte[][], Double)
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static byte[][] AddToDiagonal(this byte[][] a, double b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | The scalar |
| System.Double | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
AddToDiagonal(Byte[][], Double, Byte[][])
Declaration
public static byte[][] AddToDiagonal(this byte[][] a, double b, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | |
| System.Double | b | |
| System.Byte[][] | result |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
AddToDiagonal(Byte[][], Double, Double[][])
Declaration
public static double[][] AddToDiagonal(this byte[][] a, double b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | |
| System.Double | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Byte[][], Double[])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static byte[][] AddToDiagonal(this byte[][] a, double[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | The scalar |
| System.Double[] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
AddToDiagonal(Byte[][], Double[], Byte[][])
Declaration
public static byte[][] AddToDiagonal(this byte[][] a, double[] b, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | |
| System.Double[] | b | |
| System.Byte[][] | result |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
AddToDiagonal(Byte[][], Double[], Double[][])
Declaration
public static double[][] AddToDiagonal(this byte[][] a, double[] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | |
| System.Double[] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Byte[][], Int16, Byte[][])
Declaration
public static byte[][] AddToDiagonal(this byte[][] a, short b, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | |
| System.Int16 | b | |
| System.Byte[][] | result |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
AddToDiagonal(Byte[][], Int16, Double[][])
Declaration
public static double[][] AddToDiagonal(this byte[][] a, short b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | |
| System.Int16 | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Byte[][], Int16, Int16[][])
Declaration
public static short[][] AddToDiagonal(this byte[][] a, short b, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | |
| System.Int16 | b | |
| System.Int16[][] | result |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
AddToDiagonal(Byte[][], Int16[], Byte[][])
Declaration
public static byte[][] AddToDiagonal(this byte[][] a, short[] b, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | |
| System.Int16[] | b | |
| System.Byte[][] | result |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
AddToDiagonal(Byte[][], Int16[], Double[][])
Declaration
public static double[][] AddToDiagonal(this byte[][] a, short[] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | |
| System.Int16[] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Byte[][], Int16[], Int16[][])
Declaration
public static short[][] AddToDiagonal(this byte[][] a, short[] b, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | |
| System.Int16[] | b | |
| System.Int16[][] | result |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
AddToDiagonal(Byte[][], Int32)
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static byte[][] AddToDiagonal(this byte[][] a, int b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | The scalar |
| System.Int32 | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
AddToDiagonal(Byte[][], Int32, Byte[][])
Declaration
public static byte[][] AddToDiagonal(this byte[][] a, int b, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | |
| System.Int32 | b | |
| System.Byte[][] | result |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
AddToDiagonal(Byte[][], Int32, Double[][])
Declaration
public static double[][] AddToDiagonal(this byte[][] a, int b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | |
| System.Int32 | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Byte[][], Int32, Int32[][])
Declaration
public static int[][] AddToDiagonal(this byte[][] a, int b, int[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | |
| System.Int32 | b | |
| System.Int32[][] | result |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
AddToDiagonal(Byte[][], Int32[])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static byte[][] AddToDiagonal(this byte[][] a, int[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | The scalar |
| System.Int32[] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
AddToDiagonal(Byte[][], Int32[], Byte[][])
Declaration
public static byte[][] AddToDiagonal(this byte[][] a, int[] b, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | |
| System.Int32[] | b | |
| System.Byte[][] | result |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
AddToDiagonal(Byte[][], Int32[], Double[][])
Declaration
public static double[][] AddToDiagonal(this byte[][] a, int[] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | |
| System.Int32[] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Byte[][], Int32[], Int32[][])
Declaration
public static int[][] AddToDiagonal(this byte[][] a, int[] b, int[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | |
| System.Int32[] | b | |
| System.Int32[][] | result |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
AddToDiagonal(Byte[][], Single)
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static byte[][] AddToDiagonal(this byte[][] a, float b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | The scalar |
| System.Single | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
AddToDiagonal(Byte[][], Single, Byte[][])
Declaration
public static byte[][] AddToDiagonal(this byte[][] a, float b, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | |
| System.Single | b | |
| System.Byte[][] | result |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
AddToDiagonal(Byte[][], Single, Double[][])
Declaration
public static double[][] AddToDiagonal(this byte[][] a, float b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | |
| System.Single | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Byte[][], Single, Single[][])
Declaration
public static float[][] AddToDiagonal(this byte[][] a, float b, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | |
| System.Single | b | |
| System.Single[][] | result |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
AddToDiagonal(Byte[][], Single[])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static byte[][] AddToDiagonal(this byte[][] a, float[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | The scalar |
| System.Single[] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
AddToDiagonal(Byte[][], Single[], Byte[][])
Declaration
public static byte[][] AddToDiagonal(this byte[][] a, float[] b, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | |
| System.Single[] | b | |
| System.Byte[][] | result |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
AddToDiagonal(Byte[][], Single[], Double[][])
Declaration
public static double[][] AddToDiagonal(this byte[][] a, float[] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | |
| System.Single[] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Byte[][], Single[], Single[][])
Declaration
public static float[][] AddToDiagonal(this byte[][] a, float[] b, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[][] | a | |
| System.Single[] | b | |
| System.Single[][] | result |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
AddToDiagonal(Byte[,], Byte)
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static byte[, ] AddToDiagonal(this byte[, ] a, byte b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | The scalar |
| System.Byte | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
AddToDiagonal(Byte[,], Byte, Byte[,])
Declaration
public static byte[, ] AddToDiagonal(this byte[, ] a, byte b, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | |
| System.Byte | b | |
| System.Byte[,] | result |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
AddToDiagonal(Byte[,], Byte, Double[,])
Declaration
public static double[, ] AddToDiagonal(this byte[, ] a, byte b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | |
| System.Byte | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Byte[,], Byte[])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static byte[, ] AddToDiagonal(this byte[, ] a, byte[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | The scalar |
| System.Byte[] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
AddToDiagonal(Byte[,], Byte[], Byte[,])
Declaration
public static byte[, ] AddToDiagonal(this byte[, ] a, byte[] b, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | |
| System.Byte[] | b | |
| System.Byte[,] | result |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
AddToDiagonal(Byte[,], Byte[], Double[,])
Declaration
public static double[, ] AddToDiagonal(this byte[, ] a, byte[] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | |
| System.Byte[] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Byte[,], Decimal, Byte[,])
Declaration
public static byte[, ] AddToDiagonal(this byte[, ] a, decimal b, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | |
| System.Decimal | b | |
| System.Byte[,] | result |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
AddToDiagonal(Byte[,], Decimal, Decimal[,])
Declaration
public static decimal[, ] AddToDiagonal(this byte[, ] a, decimal b, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | |
| System.Decimal | b | |
| System.Decimal[,] | result |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
AddToDiagonal(Byte[,], Decimal, Double[,])
Declaration
public static double[, ] AddToDiagonal(this byte[, ] a, decimal b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | |
| System.Decimal | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Byte[,], Decimal[], Byte[,])
Declaration
public static byte[, ] AddToDiagonal(this byte[, ] a, decimal[] b, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | |
| System.Decimal[] | b | |
| System.Byte[,] | result |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
AddToDiagonal(Byte[,], Decimal[], Decimal[,])
Declaration
public static decimal[, ] AddToDiagonal(this byte[, ] a, decimal[] b, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | |
| System.Decimal[] | b | |
| System.Decimal[,] | result |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
AddToDiagonal(Byte[,], Decimal[], Double[,])
Declaration
public static double[, ] AddToDiagonal(this byte[, ] a, decimal[] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | |
| System.Decimal[] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Byte[,], Double)
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static byte[, ] AddToDiagonal(this byte[, ] a, double b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | The scalar |
| System.Double | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
AddToDiagonal(Byte[,], Double, Byte[,])
Declaration
public static byte[, ] AddToDiagonal(this byte[, ] a, double b, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | |
| System.Double | b | |
| System.Byte[,] | result |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
AddToDiagonal(Byte[,], Double, Double[,])
Declaration
public static double[, ] AddToDiagonal(this byte[, ] a, double b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | |
| System.Double | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Byte[,], Double[])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static byte[, ] AddToDiagonal(this byte[, ] a, double[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | The scalar |
| System.Double[] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
AddToDiagonal(Byte[,], Double[], Byte[,])
Declaration
public static byte[, ] AddToDiagonal(this byte[, ] a, double[] b, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | |
| System.Double[] | b | |
| System.Byte[,] | result |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
AddToDiagonal(Byte[,], Double[], Double[,])
Declaration
public static double[, ] AddToDiagonal(this byte[, ] a, double[] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | |
| System.Double[] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Byte[,], Int16, Byte[,])
Declaration
public static byte[, ] AddToDiagonal(this byte[, ] a, short b, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | |
| System.Int16 | b | |
| System.Byte[,] | result |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
AddToDiagonal(Byte[,], Int16, Double[,])
Declaration
public static double[, ] AddToDiagonal(this byte[, ] a, short b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | |
| System.Int16 | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Byte[,], Int16, Int16[,])
Declaration
public static short[, ] AddToDiagonal(this byte[, ] a, short b, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | |
| System.Int16 | b | |
| System.Int16[,] | result |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
AddToDiagonal(Byte[,], Int16[], Byte[,])
Declaration
public static byte[, ] AddToDiagonal(this byte[, ] a, short[] b, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | |
| System.Int16[] | b | |
| System.Byte[,] | result |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
AddToDiagonal(Byte[,], Int16[], Double[,])
Declaration
public static double[, ] AddToDiagonal(this byte[, ] a, short[] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | |
| System.Int16[] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Byte[,], Int16[], Int16[,])
Declaration
public static short[, ] AddToDiagonal(this byte[, ] a, short[] b, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | |
| System.Int16[] | b | |
| System.Int16[,] | result |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
AddToDiagonal(Byte[,], Int32)
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static byte[, ] AddToDiagonal(this byte[, ] a, int b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | The scalar |
| System.Int32 | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
AddToDiagonal(Byte[,], Int32, Byte[,])
Declaration
public static byte[, ] AddToDiagonal(this byte[, ] a, int b, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | |
| System.Int32 | b | |
| System.Byte[,] | result |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
AddToDiagonal(Byte[,], Int32, Double[,])
Declaration
public static double[, ] AddToDiagonal(this byte[, ] a, int b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | |
| System.Int32 | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Byte[,], Int32, Int32[,])
Declaration
public static int[, ] AddToDiagonal(this byte[, ] a, int b, int[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | |
| System.Int32 | b | |
| System.Int32[,] | result |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
AddToDiagonal(Byte[,], Int32[])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static byte[, ] AddToDiagonal(this byte[, ] a, int[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | The scalar |
| System.Int32[] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
AddToDiagonal(Byte[,], Int32[], Byte[,])
Declaration
public static byte[, ] AddToDiagonal(this byte[, ] a, int[] b, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | |
| System.Int32[] | b | |
| System.Byte[,] | result |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
AddToDiagonal(Byte[,], Int32[], Double[,])
Declaration
public static double[, ] AddToDiagonal(this byte[, ] a, int[] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | |
| System.Int32[] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Byte[,], Int32[], Int32[,])
Declaration
public static int[, ] AddToDiagonal(this byte[, ] a, int[] b, int[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | |
| System.Int32[] | b | |
| System.Int32[,] | result |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
AddToDiagonal(Byte[,], Single)
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static byte[, ] AddToDiagonal(this byte[, ] a, float b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | The scalar |
| System.Single | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
AddToDiagonal(Byte[,], Single, Byte[,])
Declaration
public static byte[, ] AddToDiagonal(this byte[, ] a, float b, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | |
| System.Single | b | |
| System.Byte[,] | result |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
AddToDiagonal(Byte[,], Single, Double[,])
Declaration
public static double[, ] AddToDiagonal(this byte[, ] a, float b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | |
| System.Single | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Byte[,], Single, Single[,])
Declaration
public static float[, ] AddToDiagonal(this byte[, ] a, float b, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | |
| System.Single | b | |
| System.Single[,] | result |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
AddToDiagonal(Byte[,], Single[])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static byte[, ] AddToDiagonal(this byte[, ] a, float[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | The scalar |
| System.Single[] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
AddToDiagonal(Byte[,], Single[], Byte[,])
Declaration
public static byte[, ] AddToDiagonal(this byte[, ] a, float[] b, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | |
| System.Single[] | b | |
| System.Byte[,] | result |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
AddToDiagonal(Byte[,], Single[], Double[,])
Declaration
public static double[, ] AddToDiagonal(this byte[, ] a, float[] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | |
| System.Single[] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Byte[,], Single[], Single[,])
Declaration
public static float[, ] AddToDiagonal(this byte[, ] a, float[] b, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Byte[,] | a | |
| System.Single[] | b | |
| System.Single[,] | result |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
AddToDiagonal(Decimal, Byte[][], Byte[][])
Declaration
public static byte[][] AddToDiagonal(this decimal a, byte[][] b, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | |
| System.Byte[][] | b | |
| System.Byte[][] | result |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
AddToDiagonal(Decimal, Byte[][], Decimal[][])
Declaration
public static decimal[][] AddToDiagonal(this decimal a, byte[][] b, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | |
| System.Byte[][] | b | |
| System.Decimal[][] | result |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
AddToDiagonal(Decimal, Byte[][], Double[][])
Declaration
public static double[][] AddToDiagonal(this decimal a, byte[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | |
| System.Byte[][] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Decimal, Byte[,], Byte[,])
Declaration
public static byte[, ] AddToDiagonal(this decimal a, byte[, ] b, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | |
| System.Byte[,] | b | |
| System.Byte[,] | result |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
AddToDiagonal(Decimal, Byte[,], Decimal[,])
Declaration
public static decimal[, ] AddToDiagonal(this decimal a, byte[, ] b, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | |
| System.Byte[,] | b | |
| System.Decimal[,] | result |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
AddToDiagonal(Decimal, Byte[,], Double[,])
Declaration
public static double[, ] AddToDiagonal(this decimal a, byte[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | |
| System.Byte[,] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Decimal, Decimal[][])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static decimal[][] AddToDiagonal(this decimal a, decimal[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | The scalar |
| System.Decimal[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
AddToDiagonal(Decimal, Decimal[][], Decimal[][])
Declaration
public static decimal[][] AddToDiagonal(this decimal a, decimal[][] b, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | |
| System.Decimal[][] | b | |
| System.Decimal[][] | result |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
AddToDiagonal(Decimal, Decimal[][], Double[][])
Declaration
public static double[][] AddToDiagonal(this decimal a, decimal[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | |
| System.Decimal[][] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Decimal, Decimal[,])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static decimal[, ] AddToDiagonal(this decimal a, decimal[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | The scalar |
| System.Decimal[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
AddToDiagonal(Decimal, Decimal[,], Decimal[,])
Declaration
public static decimal[, ] AddToDiagonal(this decimal a, decimal[, ] b, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | |
| System.Decimal[,] | b | |
| System.Decimal[,] | result |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
AddToDiagonal(Decimal, Decimal[,], Double[,])
Declaration
public static double[, ] AddToDiagonal(this decimal a, decimal[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | |
| System.Decimal[,] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Decimal, Double[][])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static double[][] AddToDiagonal(this decimal a, double[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | The scalar |
| System.Double[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Decimal, Double[][], Decimal[][])
Declaration
public static decimal[][] AddToDiagonal(this decimal a, double[][] b, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | |
| System.Double[][] | b | |
| System.Decimal[][] | result |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
AddToDiagonal(Decimal, Double[][], Double[][])
Declaration
public static double[][] AddToDiagonal(this decimal a, double[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | |
| System.Double[][] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Decimal, Double[,])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static double[, ] AddToDiagonal(this decimal a, double[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | The scalar |
| System.Double[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Decimal, Double[,], Decimal[,])
Declaration
public static decimal[, ] AddToDiagonal(this decimal a, double[, ] b, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | |
| System.Double[,] | b | |
| System.Decimal[,] | result |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
AddToDiagonal(Decimal, Double[,], Double[,])
Declaration
public static double[, ] AddToDiagonal(this decimal a, double[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | |
| System.Double[,] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Decimal, Int16[][], Decimal[][])
Declaration
public static decimal[][] AddToDiagonal(this decimal a, short[][] b, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | |
| System.Int16[][] | b | |
| System.Decimal[][] | result |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
AddToDiagonal(Decimal, Int16[][], Double[][])
Declaration
public static double[][] AddToDiagonal(this decimal a, short[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | |
| System.Int16[][] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Decimal, Int16[][], Int16[][])
Declaration
public static short[][] AddToDiagonal(this decimal a, short[][] b, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | |
| System.Int16[][] | b | |
| System.Int16[][] | result |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
AddToDiagonal(Decimal, Int16[,], Decimal[,])
Declaration
public static decimal[, ] AddToDiagonal(this decimal a, short[, ] b, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | |
| System.Int16[,] | b | |
| System.Decimal[,] | result |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
AddToDiagonal(Decimal, Int16[,], Double[,])
Declaration
public static double[, ] AddToDiagonal(this decimal a, short[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | |
| System.Int16[,] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Decimal, Int16[,], Int16[,])
Declaration
public static short[, ] AddToDiagonal(this decimal a, short[, ] b, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | |
| System.Int16[,] | b | |
| System.Int16[,] | result |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
AddToDiagonal(Decimal, Int32[][])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static int[][] AddToDiagonal(this decimal a, int[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | The scalar |
| System.Int32[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
AddToDiagonal(Decimal, Int32[][], Decimal[][])
Declaration
public static decimal[][] AddToDiagonal(this decimal a, int[][] b, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | |
| System.Int32[][] | b | |
| System.Decimal[][] | result |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
AddToDiagonal(Decimal, Int32[][], Double[][])
Declaration
public static double[][] AddToDiagonal(this decimal a, int[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | |
| System.Int32[][] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Decimal, Int32[][], Int32[][])
Declaration
public static int[][] AddToDiagonal(this decimal a, int[][] b, int[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | |
| System.Int32[][] | b | |
| System.Int32[][] | result |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
AddToDiagonal(Decimal, Int32[,])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static int[, ] AddToDiagonal(this decimal a, int[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | The scalar |
| System.Int32[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
AddToDiagonal(Decimal, Int32[,], Decimal[,])
Declaration
public static decimal[, ] AddToDiagonal(this decimal a, int[, ] b, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | |
| System.Int32[,] | b | |
| System.Decimal[,] | result |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
AddToDiagonal(Decimal, Int32[,], Double[,])
Declaration
public static double[, ] AddToDiagonal(this decimal a, int[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | |
| System.Int32[,] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Decimal, Int32[,], Int32[,])
Declaration
public static int[, ] AddToDiagonal(this decimal a, int[, ] b, int[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | |
| System.Int32[,] | b | |
| System.Int32[,] | result |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
AddToDiagonal(Decimal, Single[][])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static float[][] AddToDiagonal(this decimal a, float[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | The scalar |
| System.Single[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
AddToDiagonal(Decimal, Single[][], Decimal[][])
Declaration
public static decimal[][] AddToDiagonal(this decimal a, float[][] b, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | |
| System.Single[][] | b | |
| System.Decimal[][] | result |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
AddToDiagonal(Decimal, Single[][], Double[][])
Declaration
public static double[][] AddToDiagonal(this decimal a, float[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | |
| System.Single[][] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Decimal, Single[][], Single[][])
Declaration
public static float[][] AddToDiagonal(this decimal a, float[][] b, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | |
| System.Single[][] | b | |
| System.Single[][] | result |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
AddToDiagonal(Decimal, Single[,])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static float[, ] AddToDiagonal(this decimal a, float[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | The scalar |
| System.Single[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
AddToDiagonal(Decimal, Single[,], Decimal[,])
Declaration
public static decimal[, ] AddToDiagonal(this decimal a, float[, ] b, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | |
| System.Single[,] | b | |
| System.Decimal[,] | result |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
AddToDiagonal(Decimal, Single[,], Double[,])
Declaration
public static double[, ] AddToDiagonal(this decimal a, float[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | |
| System.Single[,] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Decimal, Single[,], Single[,])
Declaration
public static float[, ] AddToDiagonal(this decimal a, float[, ] b, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal | a | |
| System.Single[,] | b | |
| System.Single[,] | result |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
AddToDiagonal(Decimal[], Byte[][], Byte[][])
Declaration
public static byte[][] AddToDiagonal(this decimal[] a, byte[][] b, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | |
| System.Byte[][] | b | |
| System.Byte[][] | result |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
AddToDiagonal(Decimal[], Byte[][], Decimal[][])
Declaration
public static decimal[][] AddToDiagonal(this decimal[] a, byte[][] b, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | |
| System.Byte[][] | b | |
| System.Decimal[][] | result |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
AddToDiagonal(Decimal[], Byte[][], Double[][])
Declaration
public static double[][] AddToDiagonal(this decimal[] a, byte[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | |
| System.Byte[][] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Decimal[], Byte[,], Byte[,])
Declaration
public static byte[, ] AddToDiagonal(this decimal[] a, byte[, ] b, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | |
| System.Byte[,] | b | |
| System.Byte[,] | result |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
AddToDiagonal(Decimal[], Byte[,], Decimal[,])
Declaration
public static decimal[, ] AddToDiagonal(this decimal[] a, byte[, ] b, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | |
| System.Byte[,] | b | |
| System.Decimal[,] | result |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
AddToDiagonal(Decimal[], Byte[,], Double[,])
Declaration
public static double[, ] AddToDiagonal(this decimal[] a, byte[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | |
| System.Byte[,] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Decimal[], Decimal[][])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static decimal[][] AddToDiagonal(this decimal[] a, decimal[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | The scalar |
| System.Decimal[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
AddToDiagonal(Decimal[], Decimal[][], Decimal[][])
Declaration
public static decimal[][] AddToDiagonal(this decimal[] a, decimal[][] b, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | |
| System.Decimal[][] | b | |
| System.Decimal[][] | result |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
AddToDiagonal(Decimal[], Decimal[][], Double[][])
Declaration
public static double[][] AddToDiagonal(this decimal[] a, decimal[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | |
| System.Decimal[][] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Decimal[], Decimal[,])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static decimal[, ] AddToDiagonal(this decimal[] a, decimal[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | The scalar |
| System.Decimal[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
AddToDiagonal(Decimal[], Decimal[,], Decimal[,])
Declaration
public static decimal[, ] AddToDiagonal(this decimal[] a, decimal[, ] b, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | |
| System.Decimal[,] | b | |
| System.Decimal[,] | result |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
AddToDiagonal(Decimal[], Decimal[,], Double[,])
Declaration
public static double[, ] AddToDiagonal(this decimal[] a, decimal[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | |
| System.Decimal[,] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Decimal[], Double[][])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static double[][] AddToDiagonal(this decimal[] a, double[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | The scalar |
| System.Double[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Decimal[], Double[][], Decimal[][])
Declaration
public static decimal[][] AddToDiagonal(this decimal[] a, double[][] b, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | |
| System.Double[][] | b | |
| System.Decimal[][] | result |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
AddToDiagonal(Decimal[], Double[][], Double[][])
Declaration
public static double[][] AddToDiagonal(this decimal[] a, double[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | |
| System.Double[][] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Decimal[], Double[,])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static double[, ] AddToDiagonal(this decimal[] a, double[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | The scalar |
| System.Double[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Decimal[], Double[,], Decimal[,])
Declaration
public static decimal[, ] AddToDiagonal(this decimal[] a, double[, ] b, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | |
| System.Double[,] | b | |
| System.Decimal[,] | result |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
AddToDiagonal(Decimal[], Double[,], Double[,])
Declaration
public static double[, ] AddToDiagonal(this decimal[] a, double[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | |
| System.Double[,] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Decimal[], Int16[][], Decimal[][])
Declaration
public static decimal[][] AddToDiagonal(this decimal[] a, short[][] b, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | |
| System.Int16[][] | b | |
| System.Decimal[][] | result |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
AddToDiagonal(Decimal[], Int16[][], Double[][])
Declaration
public static double[][] AddToDiagonal(this decimal[] a, short[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | |
| System.Int16[][] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Decimal[], Int16[][], Int16[][])
Declaration
public static short[][] AddToDiagonal(this decimal[] a, short[][] b, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | |
| System.Int16[][] | b | |
| System.Int16[][] | result |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
AddToDiagonal(Decimal[], Int16[,], Decimal[,])
Declaration
public static decimal[, ] AddToDiagonal(this decimal[] a, short[, ] b, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | |
| System.Int16[,] | b | |
| System.Decimal[,] | result |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
AddToDiagonal(Decimal[], Int16[,], Double[,])
Declaration
public static double[, ] AddToDiagonal(this decimal[] a, short[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | |
| System.Int16[,] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Decimal[], Int16[,], Int16[,])
Declaration
public static short[, ] AddToDiagonal(this decimal[] a, short[, ] b, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | |
| System.Int16[,] | b | |
| System.Int16[,] | result |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
AddToDiagonal(Decimal[], Int32[][])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static int[][] AddToDiagonal(this decimal[] a, int[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | The scalar |
| System.Int32[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
AddToDiagonal(Decimal[], Int32[][], Decimal[][])
Declaration
public static decimal[][] AddToDiagonal(this decimal[] a, int[][] b, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | |
| System.Int32[][] | b | |
| System.Decimal[][] | result |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
AddToDiagonal(Decimal[], Int32[][], Double[][])
Declaration
public static double[][] AddToDiagonal(this decimal[] a, int[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | |
| System.Int32[][] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Decimal[], Int32[][], Int32[][])
Declaration
public static int[][] AddToDiagonal(this decimal[] a, int[][] b, int[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | |
| System.Int32[][] | b | |
| System.Int32[][] | result |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
AddToDiagonal(Decimal[], Int32[,])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static int[, ] AddToDiagonal(this decimal[] a, int[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | The scalar |
| System.Int32[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
AddToDiagonal(Decimal[], Int32[,], Decimal[,])
Declaration
public static decimal[, ] AddToDiagonal(this decimal[] a, int[, ] b, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | |
| System.Int32[,] | b | |
| System.Decimal[,] | result |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
AddToDiagonal(Decimal[], Int32[,], Double[,])
Declaration
public static double[, ] AddToDiagonal(this decimal[] a, int[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | |
| System.Int32[,] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Decimal[], Int32[,], Int32[,])
Declaration
public static int[, ] AddToDiagonal(this decimal[] a, int[, ] b, int[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | |
| System.Int32[,] | b | |
| System.Int32[,] | result |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
AddToDiagonal(Decimal[], Single[][])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static float[][] AddToDiagonal(this decimal[] a, float[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | The scalar |
| System.Single[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
AddToDiagonal(Decimal[], Single[][], Decimal[][])
Declaration
public static decimal[][] AddToDiagonal(this decimal[] a, float[][] b, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | |
| System.Single[][] | b | |
| System.Decimal[][] | result |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
AddToDiagonal(Decimal[], Single[][], Double[][])
Declaration
public static double[][] AddToDiagonal(this decimal[] a, float[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | |
| System.Single[][] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Decimal[], Single[][], Single[][])
Declaration
public static float[][] AddToDiagonal(this decimal[] a, float[][] b, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | |
| System.Single[][] | b | |
| System.Single[][] | result |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
AddToDiagonal(Decimal[], Single[,])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static float[, ] AddToDiagonal(this decimal[] a, float[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | The scalar |
| System.Single[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
AddToDiagonal(Decimal[], Single[,], Decimal[,])
Declaration
public static decimal[, ] AddToDiagonal(this decimal[] a, float[, ] b, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | |
| System.Single[,] | b | |
| System.Decimal[,] | result |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
AddToDiagonal(Decimal[], Single[,], Double[,])
Declaration
public static double[, ] AddToDiagonal(this decimal[] a, float[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | |
| System.Single[,] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Decimal[], Single[,], Single[,])
Declaration
public static float[, ] AddToDiagonal(this decimal[] a, float[, ] b, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[] | a | |
| System.Single[,] | b | |
| System.Single[,] | result |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
AddToDiagonal(Decimal[][], Byte, Byte[][])
Declaration
public static byte[][] AddToDiagonal(this decimal[][] a, byte b, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | |
| System.Byte | b | |
| System.Byte[][] | result |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
AddToDiagonal(Decimal[][], Byte, Decimal[][])
Declaration
public static decimal[][] AddToDiagonal(this decimal[][] a, byte b, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | |
| System.Byte | b | |
| System.Decimal[][] | result |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
AddToDiagonal(Decimal[][], Byte, Double[][])
Declaration
public static double[][] AddToDiagonal(this decimal[][] a, byte b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | |
| System.Byte | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Decimal[][], Byte[], Byte[][])
Declaration
public static byte[][] AddToDiagonal(this decimal[][] a, byte[] b, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | |
| System.Byte[] | b | |
| System.Byte[][] | result |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
AddToDiagonal(Decimal[][], Byte[], Decimal[][])
Declaration
public static decimal[][] AddToDiagonal(this decimal[][] a, byte[] b, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | |
| System.Byte[] | b | |
| System.Decimal[][] | result |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
AddToDiagonal(Decimal[][], Byte[], Double[][])
Declaration
public static double[][] AddToDiagonal(this decimal[][] a, byte[] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | |
| System.Byte[] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Decimal[][], Decimal)
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static decimal[][] AddToDiagonal(this decimal[][] a, decimal b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | The scalar |
| System.Decimal | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
AddToDiagonal(Decimal[][], Decimal, Decimal[][])
Declaration
public static decimal[][] AddToDiagonal(this decimal[][] a, decimal b, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | |
| System.Decimal | b | |
| System.Decimal[][] | result |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
AddToDiagonal(Decimal[][], Decimal, Double[][])
Declaration
public static double[][] AddToDiagonal(this decimal[][] a, decimal b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | |
| System.Decimal | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Decimal[][], Decimal[])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static decimal[][] AddToDiagonal(this decimal[][] a, decimal[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | The scalar |
| System.Decimal[] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
AddToDiagonal(Decimal[][], Decimal[], Decimal[][])
Declaration
public static decimal[][] AddToDiagonal(this decimal[][] a, decimal[] b, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | |
| System.Decimal[] | b | |
| System.Decimal[][] | result |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
AddToDiagonal(Decimal[][], Decimal[], Double[][])
Declaration
public static double[][] AddToDiagonal(this decimal[][] a, decimal[] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | |
| System.Decimal[] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Decimal[][], Double)
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static decimal[][] AddToDiagonal(this decimal[][] a, double b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | The scalar |
| System.Double | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
AddToDiagonal(Decimal[][], Double, Decimal[][])
Declaration
public static decimal[][] AddToDiagonal(this decimal[][] a, double b, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | |
| System.Double | b | |
| System.Decimal[][] | result |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
AddToDiagonal(Decimal[][], Double, Double[][])
Declaration
public static double[][] AddToDiagonal(this decimal[][] a, double b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | |
| System.Double | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Decimal[][], Double[])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static decimal[][] AddToDiagonal(this decimal[][] a, double[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | The scalar |
| System.Double[] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
AddToDiagonal(Decimal[][], Double[], Decimal[][])
Declaration
public static decimal[][] AddToDiagonal(this decimal[][] a, double[] b, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | |
| System.Double[] | b | |
| System.Decimal[][] | result |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
AddToDiagonal(Decimal[][], Double[], Double[][])
Declaration
public static double[][] AddToDiagonal(this decimal[][] a, double[] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | |
| System.Double[] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Decimal[][], Int16, Decimal[][])
Declaration
public static decimal[][] AddToDiagonal(this decimal[][] a, short b, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | |
| System.Int16 | b | |
| System.Decimal[][] | result |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
AddToDiagonal(Decimal[][], Int16, Double[][])
Declaration
public static double[][] AddToDiagonal(this decimal[][] a, short b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | |
| System.Int16 | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Decimal[][], Int16, Int16[][])
Declaration
public static short[][] AddToDiagonal(this decimal[][] a, short b, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | |
| System.Int16 | b | |
| System.Int16[][] | result |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
AddToDiagonal(Decimal[][], Int16[], Decimal[][])
Declaration
public static decimal[][] AddToDiagonal(this decimal[][] a, short[] b, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | |
| System.Int16[] | b | |
| System.Decimal[][] | result |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
AddToDiagonal(Decimal[][], Int16[], Double[][])
Declaration
public static double[][] AddToDiagonal(this decimal[][] a, short[] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | |
| System.Int16[] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Decimal[][], Int16[], Int16[][])
Declaration
public static short[][] AddToDiagonal(this decimal[][] a, short[] b, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | |
| System.Int16[] | b | |
| System.Int16[][] | result |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
AddToDiagonal(Decimal[][], Int32)
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static decimal[][] AddToDiagonal(this decimal[][] a, int b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | The scalar |
| System.Int32 | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
AddToDiagonal(Decimal[][], Int32, Decimal[][])
Declaration
public static decimal[][] AddToDiagonal(this decimal[][] a, int b, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | |
| System.Int32 | b | |
| System.Decimal[][] | result |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
AddToDiagonal(Decimal[][], Int32, Double[][])
Declaration
public static double[][] AddToDiagonal(this decimal[][] a, int b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | |
| System.Int32 | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Decimal[][], Int32, Int32[][])
Declaration
public static int[][] AddToDiagonal(this decimal[][] a, int b, int[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | |
| System.Int32 | b | |
| System.Int32[][] | result |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
AddToDiagonal(Decimal[][], Int32[])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static decimal[][] AddToDiagonal(this decimal[][] a, int[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | The scalar |
| System.Int32[] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
AddToDiagonal(Decimal[][], Int32[], Decimal[][])
Declaration
public static decimal[][] AddToDiagonal(this decimal[][] a, int[] b, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | |
| System.Int32[] | b | |
| System.Decimal[][] | result |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
AddToDiagonal(Decimal[][], Int32[], Double[][])
Declaration
public static double[][] AddToDiagonal(this decimal[][] a, int[] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | |
| System.Int32[] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Decimal[][], Int32[], Int32[][])
Declaration
public static int[][] AddToDiagonal(this decimal[][] a, int[] b, int[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | |
| System.Int32[] | b | |
| System.Int32[][] | result |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
AddToDiagonal(Decimal[][], Single)
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static decimal[][] AddToDiagonal(this decimal[][] a, float b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | The scalar |
| System.Single | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
AddToDiagonal(Decimal[][], Single, Decimal[][])
Declaration
public static decimal[][] AddToDiagonal(this decimal[][] a, float b, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | |
| System.Single | b | |
| System.Decimal[][] | result |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
AddToDiagonal(Decimal[][], Single, Double[][])
Declaration
public static double[][] AddToDiagonal(this decimal[][] a, float b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | |
| System.Single | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Decimal[][], Single, Single[][])
Declaration
public static float[][] AddToDiagonal(this decimal[][] a, float b, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | |
| System.Single | b | |
| System.Single[][] | result |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
AddToDiagonal(Decimal[][], Single[])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static decimal[][] AddToDiagonal(this decimal[][] a, float[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | The scalar |
| System.Single[] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
AddToDiagonal(Decimal[][], Single[], Decimal[][])
Declaration
public static decimal[][] AddToDiagonal(this decimal[][] a, float[] b, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | |
| System.Single[] | b | |
| System.Decimal[][] | result |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
AddToDiagonal(Decimal[][], Single[], Double[][])
Declaration
public static double[][] AddToDiagonal(this decimal[][] a, float[] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | |
| System.Single[] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Decimal[][], Single[], Single[][])
Declaration
public static float[][] AddToDiagonal(this decimal[][] a, float[] b, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[][] | a | |
| System.Single[] | b | |
| System.Single[][] | result |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
AddToDiagonal(Decimal[,], Byte, Byte[,])
Declaration
public static byte[, ] AddToDiagonal(this decimal[, ] a, byte b, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | |
| System.Byte | b | |
| System.Byte[,] | result |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
AddToDiagonal(Decimal[,], Byte, Decimal[,])
Declaration
public static decimal[, ] AddToDiagonal(this decimal[, ] a, byte b, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | |
| System.Byte | b | |
| System.Decimal[,] | result |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
AddToDiagonal(Decimal[,], Byte, Double[,])
Declaration
public static double[, ] AddToDiagonal(this decimal[, ] a, byte b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | |
| System.Byte | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Decimal[,], Byte[], Byte[,])
Declaration
public static byte[, ] AddToDiagonal(this decimal[, ] a, byte[] b, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | |
| System.Byte[] | b | |
| System.Byte[,] | result |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
AddToDiagonal(Decimal[,], Byte[], Decimal[,])
Declaration
public static decimal[, ] AddToDiagonal(this decimal[, ] a, byte[] b, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | |
| System.Byte[] | b | |
| System.Decimal[,] | result |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
AddToDiagonal(Decimal[,], Byte[], Double[,])
Declaration
public static double[, ] AddToDiagonal(this decimal[, ] a, byte[] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | |
| System.Byte[] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Decimal[,], Decimal)
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static decimal[, ] AddToDiagonal(this decimal[, ] a, decimal b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | The scalar |
| System.Decimal | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
AddToDiagonal(Decimal[,], Decimal, Decimal[,])
Declaration
public static decimal[, ] AddToDiagonal(this decimal[, ] a, decimal b, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | |
| System.Decimal | b | |
| System.Decimal[,] | result |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
AddToDiagonal(Decimal[,], Decimal, Double[,])
Declaration
public static double[, ] AddToDiagonal(this decimal[, ] a, decimal b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | |
| System.Decimal | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Decimal[,], Decimal[])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static decimal[, ] AddToDiagonal(this decimal[, ] a, decimal[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | The scalar |
| System.Decimal[] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
AddToDiagonal(Decimal[,], Decimal[], Decimal[,])
Declaration
public static decimal[, ] AddToDiagonal(this decimal[, ] a, decimal[] b, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | |
| System.Decimal[] | b | |
| System.Decimal[,] | result |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
AddToDiagonal(Decimal[,], Decimal[], Double[,])
Declaration
public static double[, ] AddToDiagonal(this decimal[, ] a, decimal[] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | |
| System.Decimal[] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Decimal[,], Double)
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static decimal[, ] AddToDiagonal(this decimal[, ] a, double b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | The scalar |
| System.Double | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
AddToDiagonal(Decimal[,], Double, Decimal[,])
Declaration
public static decimal[, ] AddToDiagonal(this decimal[, ] a, double b, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | |
| System.Double | b | |
| System.Decimal[,] | result |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
AddToDiagonal(Decimal[,], Double, Double[,])
Declaration
public static double[, ] AddToDiagonal(this decimal[, ] a, double b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | |
| System.Double | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Decimal[,], Double[])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static decimal[, ] AddToDiagonal(this decimal[, ] a, double[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | The scalar |
| System.Double[] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
AddToDiagonal(Decimal[,], Double[], Decimal[,])
Declaration
public static decimal[, ] AddToDiagonal(this decimal[, ] a, double[] b, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | |
| System.Double[] | b | |
| System.Decimal[,] | result |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
AddToDiagonal(Decimal[,], Double[], Double[,])
Declaration
public static double[, ] AddToDiagonal(this decimal[, ] a, double[] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | |
| System.Double[] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Decimal[,], Int16, Decimal[,])
Declaration
public static decimal[, ] AddToDiagonal(this decimal[, ] a, short b, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | |
| System.Int16 | b | |
| System.Decimal[,] | result |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
AddToDiagonal(Decimal[,], Int16, Double[,])
Declaration
public static double[, ] AddToDiagonal(this decimal[, ] a, short b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | |
| System.Int16 | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Decimal[,], Int16, Int16[,])
Declaration
public static short[, ] AddToDiagonal(this decimal[, ] a, short b, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | |
| System.Int16 | b | |
| System.Int16[,] | result |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
AddToDiagonal(Decimal[,], Int16[], Decimal[,])
Declaration
public static decimal[, ] AddToDiagonal(this decimal[, ] a, short[] b, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | |
| System.Int16[] | b | |
| System.Decimal[,] | result |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
AddToDiagonal(Decimal[,], Int16[], Double[,])
Declaration
public static double[, ] AddToDiagonal(this decimal[, ] a, short[] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | |
| System.Int16[] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Decimal[,], Int16[], Int16[,])
Declaration
public static short[, ] AddToDiagonal(this decimal[, ] a, short[] b, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | |
| System.Int16[] | b | |
| System.Int16[,] | result |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
AddToDiagonal(Decimal[,], Int32)
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static decimal[, ] AddToDiagonal(this decimal[, ] a, int b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | The scalar |
| System.Int32 | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
AddToDiagonal(Decimal[,], Int32, Decimal[,])
Declaration
public static decimal[, ] AddToDiagonal(this decimal[, ] a, int b, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | |
| System.Int32 | b | |
| System.Decimal[,] | result |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
AddToDiagonal(Decimal[,], Int32, Double[,])
Declaration
public static double[, ] AddToDiagonal(this decimal[, ] a, int b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | |
| System.Int32 | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Decimal[,], Int32, Int32[,])
Declaration
public static int[, ] AddToDiagonal(this decimal[, ] a, int b, int[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | |
| System.Int32 | b | |
| System.Int32[,] | result |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
AddToDiagonal(Decimal[,], Int32[])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static decimal[, ] AddToDiagonal(this decimal[, ] a, int[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | The scalar |
| System.Int32[] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
AddToDiagonal(Decimal[,], Int32[], Decimal[,])
Declaration
public static decimal[, ] AddToDiagonal(this decimal[, ] a, int[] b, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | |
| System.Int32[] | b | |
| System.Decimal[,] | result |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
AddToDiagonal(Decimal[,], Int32[], Double[,])
Declaration
public static double[, ] AddToDiagonal(this decimal[, ] a, int[] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | |
| System.Int32[] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Decimal[,], Int32[], Int32[,])
Declaration
public static int[, ] AddToDiagonal(this decimal[, ] a, int[] b, int[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | |
| System.Int32[] | b | |
| System.Int32[,] | result |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
AddToDiagonal(Decimal[,], Single)
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static decimal[, ] AddToDiagonal(this decimal[, ] a, float b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | The scalar |
| System.Single | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
AddToDiagonal(Decimal[,], Single, Decimal[,])
Declaration
public static decimal[, ] AddToDiagonal(this decimal[, ] a, float b, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | |
| System.Single | b | |
| System.Decimal[,] | result |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
AddToDiagonal(Decimal[,], Single, Double[,])
Declaration
public static double[, ] AddToDiagonal(this decimal[, ] a, float b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | |
| System.Single | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Decimal[,], Single, Single[,])
Declaration
public static float[, ] AddToDiagonal(this decimal[, ] a, float b, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | |
| System.Single | b | |
| System.Single[,] | result |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
AddToDiagonal(Decimal[,], Single[])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static decimal[, ] AddToDiagonal(this decimal[, ] a, float[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | The scalar |
| System.Single[] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
AddToDiagonal(Decimal[,], Single[], Decimal[,])
Declaration
public static decimal[, ] AddToDiagonal(this decimal[, ] a, float[] b, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | |
| System.Single[] | b | |
| System.Decimal[,] | result |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
AddToDiagonal(Decimal[,], Single[], Double[,])
Declaration
public static double[, ] AddToDiagonal(this decimal[, ] a, float[] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | |
| System.Single[] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Decimal[,], Single[], Single[,])
Declaration
public static float[, ] AddToDiagonal(this decimal[, ] a, float[] b, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Decimal[,] | a | |
| System.Single[] | b | |
| System.Single[,] | result |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
AddToDiagonal(Double, Byte[][])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static byte[][] AddToDiagonal(this double a, byte[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | The scalar |
| System.Byte[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
AddToDiagonal(Double, Byte[][], Byte[][])
Declaration
public static byte[][] AddToDiagonal(this double a, byte[][] b, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | |
| System.Byte[][] | b | |
| System.Byte[][] | result |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
AddToDiagonal(Double, Byte[][], Double[][])
Declaration
public static double[][] AddToDiagonal(this double a, byte[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | |
| System.Byte[][] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Double, Byte[,])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static byte[, ] AddToDiagonal(this double a, byte[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | The scalar |
| System.Byte[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
AddToDiagonal(Double, Byte[,], Byte[,])
Declaration
public static byte[, ] AddToDiagonal(this double a, byte[, ] b, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | |
| System.Byte[,] | b | |
| System.Byte[,] | result |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
AddToDiagonal(Double, Byte[,], Double[,])
Declaration
public static double[, ] AddToDiagonal(this double a, byte[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | |
| System.Byte[,] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Double, Decimal[][])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static decimal[][] AddToDiagonal(this double a, decimal[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | The scalar |
| System.Decimal[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
AddToDiagonal(Double, Decimal[][], Decimal[][])
Declaration
public static decimal[][] AddToDiagonal(this double a, decimal[][] b, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | |
| System.Decimal[][] | b | |
| System.Decimal[][] | result |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
AddToDiagonal(Double, Decimal[][], Double[][])
Declaration
public static double[][] AddToDiagonal(this double a, decimal[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | |
| System.Decimal[][] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Double, Decimal[,])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static decimal[, ] AddToDiagonal(this double a, decimal[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | The scalar |
| System.Decimal[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
AddToDiagonal(Double, Decimal[,], Decimal[,])
Declaration
public static decimal[, ] AddToDiagonal(this double a, decimal[, ] b, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | |
| System.Decimal[,] | b | |
| System.Decimal[,] | result |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
AddToDiagonal(Double, Decimal[,], Double[,])
Declaration
public static double[, ] AddToDiagonal(this double a, decimal[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | |
| System.Decimal[,] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Double, Double[][])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static double[][] AddToDiagonal(this double a, double[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | The scalar |
| System.Double[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Double, Double[][], Double[][])
Declaration
public static double[][] AddToDiagonal(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[][] |
AddToDiagonal(Double, Double[,])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static double[, ] AddToDiagonal(this double a, double[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | The scalar |
| System.Double[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Double, Double[,], Double[,])
Declaration
public static double[, ] AddToDiagonal(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[,] |
AddToDiagonal(Double, Int16[][])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static short[][] AddToDiagonal(this double a, short[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | The scalar |
| System.Int16[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
AddToDiagonal(Double, Int16[][], Double[][])
Declaration
public static double[][] AddToDiagonal(this double a, short[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | |
| System.Int16[][] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Double, Int16[][], Int16[][])
Declaration
public static short[][] AddToDiagonal(this double a, short[][] b, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | |
| System.Int16[][] | b | |
| System.Int16[][] | result |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
AddToDiagonal(Double, Int16[,])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static short[, ] AddToDiagonal(this double a, short[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | The scalar |
| System.Int16[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
AddToDiagonal(Double, Int16[,], Double[,])
Declaration
public static double[, ] AddToDiagonal(this double a, short[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | |
| System.Int16[,] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Double, Int16[,], Int16[,])
Declaration
public static short[, ] AddToDiagonal(this double a, short[, ] b, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | |
| System.Int16[,] | b | |
| System.Int16[,] | result |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
AddToDiagonal(Double, Int32[][])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static int[][] AddToDiagonal(this double a, int[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | The scalar |
| System.Int32[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
AddToDiagonal(Double, Int32[][], Double[][])
Declaration
public static double[][] AddToDiagonal(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[][] |
AddToDiagonal(Double, Int32[][], Int32[][])
Declaration
public static int[][] AddToDiagonal(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[][] |
AddToDiagonal(Double, Int32[,])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static int[, ] AddToDiagonal(this double a, int[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | The scalar |
| System.Int32[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
AddToDiagonal(Double, Int32[,], Double[,])
Declaration
public static double[, ] AddToDiagonal(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[,] |
AddToDiagonal(Double, Int32[,], Int32[,])
Declaration
public static int[, ] AddToDiagonal(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[,] |
AddToDiagonal(Double, Single[][])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static float[][] AddToDiagonal(this double a, float[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | The scalar |
| System.Single[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
AddToDiagonal(Double, Single[][], Double[][])
Declaration
public static double[][] AddToDiagonal(this double a, float[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | |
| System.Single[][] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Double, Single[][], Single[][])
Declaration
public static float[][] AddToDiagonal(this double a, float[][] b, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | |
| System.Single[][] | b | |
| System.Single[][] | result |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
AddToDiagonal(Double, Single[,])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static float[, ] AddToDiagonal(this double a, float[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | The scalar |
| System.Single[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
AddToDiagonal(Double, Single[,], Double[,])
Declaration
public static double[, ] AddToDiagonal(this double a, float[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | |
| System.Single[,] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Double, Single[,], Single[,])
Declaration
public static float[, ] AddToDiagonal(this double a, float[, ] b, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | |
| System.Single[,] | b | |
| System.Single[,] | result |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
AddToDiagonal(Double[], Byte[][])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static byte[][] AddToDiagonal(this double[] a, byte[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The scalar |
| System.Byte[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
AddToDiagonal(Double[], Byte[][], Byte[][])
Declaration
public static byte[][] AddToDiagonal(this double[] a, byte[][] b, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | |
| System.Byte[][] | b | |
| System.Byte[][] | result |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
AddToDiagonal(Double[], Byte[][], Double[][])
Declaration
public static double[][] AddToDiagonal(this double[] a, byte[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | |
| System.Byte[][] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Double[], Byte[,])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static byte[, ] AddToDiagonal(this double[] a, byte[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The scalar |
| System.Byte[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
AddToDiagonal(Double[], Byte[,], Byte[,])
Declaration
public static byte[, ] AddToDiagonal(this double[] a, byte[, ] b, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | |
| System.Byte[,] | b | |
| System.Byte[,] | result |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
AddToDiagonal(Double[], Byte[,], Double[,])
Declaration
public static double[, ] AddToDiagonal(this double[] a, byte[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | |
| System.Byte[,] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Double[], Decimal[][])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static decimal[][] AddToDiagonal(this double[] a, decimal[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The scalar |
| System.Decimal[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
AddToDiagonal(Double[], Decimal[][], Decimal[][])
Declaration
public static decimal[][] AddToDiagonal(this double[] a, decimal[][] b, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | |
| System.Decimal[][] | b | |
| System.Decimal[][] | result |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
AddToDiagonal(Double[], Decimal[][], Double[][])
Declaration
public static double[][] AddToDiagonal(this double[] a, decimal[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | |
| System.Decimal[][] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Double[], Decimal[,])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static decimal[, ] AddToDiagonal(this double[] a, decimal[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The scalar |
| System.Decimal[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
AddToDiagonal(Double[], Decimal[,], Decimal[,])
Declaration
public static decimal[, ] AddToDiagonal(this double[] a, decimal[, ] b, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | |
| System.Decimal[,] | b | |
| System.Decimal[,] | result |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
AddToDiagonal(Double[], Decimal[,], Double[,])
Declaration
public static double[, ] AddToDiagonal(this double[] a, decimal[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | |
| System.Decimal[,] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Double[], Double[][])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static double[][] AddToDiagonal(this double[] a, double[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The scalar |
| System.Double[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Double[], Double[][], Double[][])
Declaration
public static double[][] AddToDiagonal(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[][] |
AddToDiagonal(Double[], Double[,])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static double[, ] AddToDiagonal(this double[] a, double[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The scalar |
| System.Double[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Double[], Double[,], Double[,])
Declaration
public static double[, ] AddToDiagonal(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[,] |
AddToDiagonal(Double[], Int16[][])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static short[][] AddToDiagonal(this double[] a, short[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The scalar |
| System.Int16[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
AddToDiagonal(Double[], Int16[][], Double[][])
Declaration
public static double[][] AddToDiagonal(this double[] a, short[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | |
| System.Int16[][] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Double[], Int16[][], Int16[][])
Declaration
public static short[][] AddToDiagonal(this double[] a, short[][] b, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | |
| System.Int16[][] | b | |
| System.Int16[][] | result |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
AddToDiagonal(Double[], Int16[,])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static short[, ] AddToDiagonal(this double[] a, short[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The scalar |
| System.Int16[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
AddToDiagonal(Double[], Int16[,], Double[,])
Declaration
public static double[, ] AddToDiagonal(this double[] a, short[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | |
| System.Int16[,] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Double[], Int16[,], Int16[,])
Declaration
public static short[, ] AddToDiagonal(this double[] a, short[, ] b, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | |
| System.Int16[,] | b | |
| System.Int16[,] | result |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
AddToDiagonal(Double[], Int32[][])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static int[][] AddToDiagonal(this double[] a, int[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The scalar |
| System.Int32[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
AddToDiagonal(Double[], Int32[][], Double[][])
Declaration
public static double[][] AddToDiagonal(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[][] |
AddToDiagonal(Double[], Int32[][], Int32[][])
Declaration
public static int[][] AddToDiagonal(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[][] |
AddToDiagonal(Double[], Int32[,])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static int[, ] AddToDiagonal(this double[] a, int[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The scalar |
| System.Int32[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
AddToDiagonal(Double[], Int32[,], Double[,])
Declaration
public static double[, ] AddToDiagonal(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[,] |
AddToDiagonal(Double[], Int32[,], Int32[,])
Declaration
public static int[, ] AddToDiagonal(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[,] |
AddToDiagonal(Double[], Single[][])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static float[][] AddToDiagonal(this double[] a, float[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The scalar |
| System.Single[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
AddToDiagonal(Double[], Single[][], Double[][])
Declaration
public static double[][] AddToDiagonal(this double[] a, float[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | |
| System.Single[][] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Double[], Single[][], Single[][])
Declaration
public static float[][] AddToDiagonal(this double[] a, float[][] b, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | |
| System.Single[][] | b | |
| System.Single[][] | result |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
AddToDiagonal(Double[], Single[,])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static float[, ] AddToDiagonal(this double[] a, float[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The scalar |
| System.Single[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
AddToDiagonal(Double[], Single[,], Double[,])
Declaration
public static double[, ] AddToDiagonal(this double[] a, float[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | |
| System.Single[,] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Double[], Single[,], Single[,])
Declaration
public static float[, ] AddToDiagonal(this double[] a, float[, ] b, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | |
| System.Single[,] | b | |
| System.Single[,] | result |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
AddToDiagonal(Double[][], Byte)
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static double[][] AddToDiagonal(this double[][] a, byte b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | The scalar |
| System.Byte | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Double[][], Byte, Byte[][])
Declaration
public static byte[][] AddToDiagonal(this double[][] a, byte b, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | |
| System.Byte | b | |
| System.Byte[][] | result |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
AddToDiagonal(Double[][], Byte, Double[][])
Declaration
public static double[][] AddToDiagonal(this double[][] a, byte b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | |
| System.Byte | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Double[][], Byte[])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static double[][] AddToDiagonal(this double[][] a, byte[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | The scalar |
| System.Byte[] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Double[][], Byte[], Byte[][])
Declaration
public static byte[][] AddToDiagonal(this double[][] a, byte[] b, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | |
| System.Byte[] | b | |
| System.Byte[][] | result |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
AddToDiagonal(Double[][], Byte[], Double[][])
Declaration
public static double[][] AddToDiagonal(this double[][] a, byte[] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | |
| System.Byte[] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Double[][], Decimal)
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static double[][] AddToDiagonal(this double[][] a, decimal b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | The scalar |
| System.Decimal | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Double[][], Decimal, Decimal[][])
Declaration
public static decimal[][] AddToDiagonal(this double[][] a, decimal b, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | |
| System.Decimal | b | |
| System.Decimal[][] | result |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
AddToDiagonal(Double[][], Decimal, Double[][])
Declaration
public static double[][] AddToDiagonal(this double[][] a, decimal b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | |
| System.Decimal | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Double[][], Decimal[])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static double[][] AddToDiagonal(this double[][] a, decimal[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | The scalar |
| System.Decimal[] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Double[][], Decimal[], Decimal[][])
Declaration
public static decimal[][] AddToDiagonal(this double[][] a, decimal[] b, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | |
| System.Decimal[] | b | |
| System.Decimal[][] | result |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
AddToDiagonal(Double[][], Decimal[], Double[][])
Declaration
public static double[][] AddToDiagonal(this double[][] a, decimal[] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | |
| System.Decimal[] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Double[][], Double)
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static double[][] AddToDiagonal(this double[][] a, double b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | The scalar |
| System.Double | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Double[][], Double, Double[][])
Declaration
public static double[][] AddToDiagonal(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[][] |
AddToDiagonal(Double[][], Double[])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static double[][] AddToDiagonal(this double[][] a, double[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | The scalar |
| System.Double[] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Double[][], Double[], Double[][])
Declaration
public static double[][] AddToDiagonal(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[][] |
AddToDiagonal(Double[][], Int16)
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static double[][] AddToDiagonal(this double[][] a, short b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | The scalar |
| System.Int16 | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Double[][], Int16, Double[][])
Declaration
public static double[][] AddToDiagonal(this double[][] a, short b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | |
| System.Int16 | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Double[][], Int16, Int16[][])
Declaration
public static short[][] AddToDiagonal(this double[][] a, short b, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | |
| System.Int16 | b | |
| System.Int16[][] | result |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
AddToDiagonal(Double[][], Int16[])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static double[][] AddToDiagonal(this double[][] a, short[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | The scalar |
| System.Int16[] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Double[][], Int16[], Double[][])
Declaration
public static double[][] AddToDiagonal(this double[][] a, short[] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | |
| System.Int16[] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Double[][], Int16[], Int16[][])
Declaration
public static short[][] AddToDiagonal(this double[][] a, short[] b, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | |
| System.Int16[] | b | |
| System.Int16[][] | result |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
AddToDiagonal(Double[][], Int32)
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static double[][] AddToDiagonal(this double[][] a, int b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | The scalar |
| System.Int32 | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Double[][], Int32, Double[][])
Declaration
public static double[][] AddToDiagonal(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[][] |
AddToDiagonal(Double[][], Int32, Int32[][])
Declaration
public static int[][] AddToDiagonal(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[][] |
AddToDiagonal(Double[][], Int32[])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static double[][] AddToDiagonal(this double[][] a, int[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | The scalar |
| System.Int32[] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Double[][], Int32[], Double[][])
Declaration
public static double[][] AddToDiagonal(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[][] |
AddToDiagonal(Double[][], Int32[], Int32[][])
Declaration
public static int[][] AddToDiagonal(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[][] |
AddToDiagonal(Double[][], Single)
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static double[][] AddToDiagonal(this double[][] a, float b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | The scalar |
| System.Single | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Double[][], Single, Double[][])
Declaration
public static double[][] AddToDiagonal(this double[][] a, float b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | |
| System.Single | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Double[][], Single, Single[][])
Declaration
public static float[][] AddToDiagonal(this double[][] a, float b, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | |
| System.Single | b | |
| System.Single[][] | result |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
AddToDiagonal(Double[][], Single[])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static double[][] AddToDiagonal(this double[][] a, float[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | The scalar |
| System.Single[] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Double[][], Single[], Double[][])
Declaration
public static double[][] AddToDiagonal(this double[][] a, float[] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | |
| System.Single[] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Double[][], Single[], Single[][])
Declaration
public static float[][] AddToDiagonal(this double[][] a, float[] b, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | |
| System.Single[] | b | |
| System.Single[][] | result |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
AddToDiagonal(Double[,], Byte)
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static double[, ] AddToDiagonal(this double[, ] a, byte b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | The scalar |
| System.Byte | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Double[,], Byte, Byte[,])
Declaration
public static byte[, ] AddToDiagonal(this double[, ] a, byte b, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | |
| System.Byte | b | |
| System.Byte[,] | result |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
AddToDiagonal(Double[,], Byte, Double[,])
Declaration
public static double[, ] AddToDiagonal(this double[, ] a, byte b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | |
| System.Byte | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Double[,], Byte[])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static double[, ] AddToDiagonal(this double[, ] a, byte[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | The scalar |
| System.Byte[] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Double[,], Byte[], Byte[,])
Declaration
public static byte[, ] AddToDiagonal(this double[, ] a, byte[] b, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | |
| System.Byte[] | b | |
| System.Byte[,] | result |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
AddToDiagonal(Double[,], Byte[], Double[,])
Declaration
public static double[, ] AddToDiagonal(this double[, ] a, byte[] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | |
| System.Byte[] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Double[,], Decimal)
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static double[, ] AddToDiagonal(this double[, ] a, decimal b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | The scalar |
| System.Decimal | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Double[,], Decimal, Decimal[,])
Declaration
public static decimal[, ] AddToDiagonal(this double[, ] a, decimal b, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | |
| System.Decimal | b | |
| System.Decimal[,] | result |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
AddToDiagonal(Double[,], Decimal, Double[,])
Declaration
public static double[, ] AddToDiagonal(this double[, ] a, decimal b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | |
| System.Decimal | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Double[,], Decimal[])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static double[, ] AddToDiagonal(this double[, ] a, decimal[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | The scalar |
| System.Decimal[] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Double[,], Decimal[], Decimal[,])
Declaration
public static decimal[, ] AddToDiagonal(this double[, ] a, decimal[] b, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | |
| System.Decimal[] | b | |
| System.Decimal[,] | result |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
AddToDiagonal(Double[,], Decimal[], Double[,])
Declaration
public static double[, ] AddToDiagonal(this double[, ] a, decimal[] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | |
| System.Decimal[] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Double[,], Double)
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static double[, ] AddToDiagonal(this double[, ] a, double b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | The scalar |
| System.Double | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Double[,], Double, Double[,])
Declaration
public static double[, ] AddToDiagonal(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[,] |
AddToDiagonal(Double[,], Double[])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static double[, ] AddToDiagonal(this double[, ] a, double[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | The scalar |
| System.Double[] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Double[,], Double[], Double[,])
Declaration
public static double[, ] AddToDiagonal(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[,] |
AddToDiagonal(Double[,], Int16)
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static double[, ] AddToDiagonal(this double[, ] a, short b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | The scalar |
| System.Int16 | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Double[,], Int16, Double[,])
Declaration
public static double[, ] AddToDiagonal(this double[, ] a, short b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | |
| System.Int16 | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Double[,], Int16, Int16[,])
Declaration
public static short[, ] AddToDiagonal(this double[, ] a, short b, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | |
| System.Int16 | b | |
| System.Int16[,] | result |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
AddToDiagonal(Double[,], Int16[])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static double[, ] AddToDiagonal(this double[, ] a, short[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | The scalar |
| System.Int16[] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Double[,], Int16[], Double[,])
Declaration
public static double[, ] AddToDiagonal(this double[, ] a, short[] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | |
| System.Int16[] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Double[,], Int16[], Int16[,])
Declaration
public static short[, ] AddToDiagonal(this double[, ] a, short[] b, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | |
| System.Int16[] | b | |
| System.Int16[,] | result |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
AddToDiagonal(Double[,], Int32)
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static double[, ] AddToDiagonal(this double[, ] a, int b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | The scalar |
| System.Int32 | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Double[,], Int32, Double[,])
Declaration
public static double[, ] AddToDiagonal(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[,] |
AddToDiagonal(Double[,], Int32, Int32[,])
Declaration
public static int[, ] AddToDiagonal(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[,] |
AddToDiagonal(Double[,], Int32[])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static double[, ] AddToDiagonal(this double[, ] a, int[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | The scalar |
| System.Int32[] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Double[,], Int32[], Double[,])
Declaration
public static double[, ] AddToDiagonal(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[,] |
AddToDiagonal(Double[,], Int32[], Int32[,])
Declaration
public static int[, ] AddToDiagonal(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[,] |
AddToDiagonal(Double[,], Single)
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static double[, ] AddToDiagonal(this double[, ] a, float b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | The scalar |
| System.Single | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Double[,], Single, Double[,])
Declaration
public static double[, ] AddToDiagonal(this double[, ] a, float b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | |
| System.Single | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Double[,], Single, Single[,])
Declaration
public static float[, ] AddToDiagonal(this double[, ] a, float b, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | |
| System.Single | b | |
| System.Single[,] | result |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
AddToDiagonal(Double[,], Single[])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static double[, ] AddToDiagonal(this double[, ] a, float[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | The scalar |
| System.Single[] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Double[,], Single[], Double[,])
Declaration
public static double[, ] AddToDiagonal(this double[, ] a, float[] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | |
| System.Single[] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Double[,], Single[], Single[,])
Declaration
public static float[, ] AddToDiagonal(this double[, ] a, float[] b, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | |
| System.Single[] | b | |
| System.Single[,] | result |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
AddToDiagonal(Int16, Byte[][], Byte[][])
Declaration
public static byte[][] AddToDiagonal(this short a, byte[][] b, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | |
| System.Byte[][] | b | |
| System.Byte[][] | result |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
AddToDiagonal(Int16, Byte[][], Double[][])
Declaration
public static double[][] AddToDiagonal(this short a, byte[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | |
| System.Byte[][] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Int16, Byte[][], Int16[][])
Declaration
public static short[][] AddToDiagonal(this short a, byte[][] b, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | |
| System.Byte[][] | b | |
| System.Int16[][] | result |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
AddToDiagonal(Int16, Byte[,], Byte[,])
Declaration
public static byte[, ] AddToDiagonal(this short a, byte[, ] b, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | |
| System.Byte[,] | b | |
| System.Byte[,] | result |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
AddToDiagonal(Int16, Byte[,], Double[,])
Declaration
public static double[, ] AddToDiagonal(this short a, byte[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | |
| System.Byte[,] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Int16, Byte[,], Int16[,])
Declaration
public static short[, ] AddToDiagonal(this short a, byte[, ] b, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | |
| System.Byte[,] | b | |
| System.Int16[,] | result |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
AddToDiagonal(Int16, Decimal[][], Decimal[][])
Declaration
public static decimal[][] AddToDiagonal(this short a, decimal[][] b, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | |
| System.Decimal[][] | b | |
| System.Decimal[][] | result |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
AddToDiagonal(Int16, Decimal[][], Double[][])
Declaration
public static double[][] AddToDiagonal(this short a, decimal[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | |
| System.Decimal[][] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Int16, Decimal[][], Int16[][])
Declaration
public static short[][] AddToDiagonal(this short a, decimal[][] b, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | |
| System.Decimal[][] | b | |
| System.Int16[][] | result |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
AddToDiagonal(Int16, Decimal[,], Decimal[,])
Declaration
public static decimal[, ] AddToDiagonal(this short a, decimal[, ] b, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | |
| System.Decimal[,] | b | |
| System.Decimal[,] | result |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
AddToDiagonal(Int16, Decimal[,], Double[,])
Declaration
public static double[, ] AddToDiagonal(this short a, decimal[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | |
| System.Decimal[,] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Int16, Decimal[,], Int16[,])
Declaration
public static short[, ] AddToDiagonal(this short a, decimal[, ] b, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | |
| System.Decimal[,] | b | |
| System.Int16[,] | result |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
AddToDiagonal(Int16, Double[][])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static double[][] AddToDiagonal(this short a, double[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | The scalar |
| System.Double[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Int16, Double[][], Double[][])
Declaration
public static double[][] AddToDiagonal(this short a, double[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | |
| System.Double[][] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Int16, Double[][], Int16[][])
Declaration
public static short[][] AddToDiagonal(this short a, double[][] b, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | |
| System.Double[][] | b | |
| System.Int16[][] | result |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
AddToDiagonal(Int16, Double[,])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static double[, ] AddToDiagonal(this short a, double[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | The scalar |
| System.Double[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Int16, Double[,], Double[,])
Declaration
public static double[, ] AddToDiagonal(this short a, double[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | |
| System.Double[,] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Int16, Double[,], Int16[,])
Declaration
public static short[, ] AddToDiagonal(this short a, double[, ] b, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | |
| System.Double[,] | b | |
| System.Int16[,] | result |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
AddToDiagonal(Int16, Int16[][])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static short[][] AddToDiagonal(this short a, short[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | The scalar |
| System.Int16[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
AddToDiagonal(Int16, Int16[][], Double[][])
Declaration
public static double[][] AddToDiagonal(this short a, short[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | |
| System.Int16[][] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Int16, Int16[][], Int16[][])
Declaration
public static short[][] AddToDiagonal(this short a, short[][] b, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | |
| System.Int16[][] | b | |
| System.Int16[][] | result |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
AddToDiagonal(Int16, Int16[,])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static short[, ] AddToDiagonal(this short a, short[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | The scalar |
| System.Int16[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
AddToDiagonal(Int16, Int16[,], Double[,])
Declaration
public static double[, ] AddToDiagonal(this short a, short[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | |
| System.Int16[,] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Int16, Int16[,], Int16[,])
Declaration
public static short[, ] AddToDiagonal(this short a, short[, ] b, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | |
| System.Int16[,] | b | |
| System.Int16[,] | result |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
AddToDiagonal(Int16, Int32[][])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static int[][] AddToDiagonal(this short a, int[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | The scalar |
| System.Int32[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
AddToDiagonal(Int16, Int32[][], Double[][])
Declaration
public static double[][] AddToDiagonal(this short a, int[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | |
| System.Int32[][] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Int16, Int32[][], Int16[][])
Declaration
public static short[][] AddToDiagonal(this short a, int[][] b, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | |
| System.Int32[][] | b | |
| System.Int16[][] | result |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
AddToDiagonal(Int16, Int32[][], Int32[][])
Declaration
public static int[][] AddToDiagonal(this short a, int[][] b, int[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | |
| System.Int32[][] | b | |
| System.Int32[][] | result |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
AddToDiagonal(Int16, Int32[,])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static int[, ] AddToDiagonal(this short a, int[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | The scalar |
| System.Int32[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
AddToDiagonal(Int16, Int32[,], Double[,])
Declaration
public static double[, ] AddToDiagonal(this short a, int[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | |
| System.Int32[,] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Int16, Int32[,], Int16[,])
Declaration
public static short[, ] AddToDiagonal(this short a, int[, ] b, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | |
| System.Int32[,] | b | |
| System.Int16[,] | result |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
AddToDiagonal(Int16, Int32[,], Int32[,])
Declaration
public static int[, ] AddToDiagonal(this short a, int[, ] b, int[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | |
| System.Int32[,] | b | |
| System.Int32[,] | result |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
AddToDiagonal(Int16, Single[][])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static float[][] AddToDiagonal(this short a, float[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | The scalar |
| System.Single[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
AddToDiagonal(Int16, Single[][], Double[][])
Declaration
public static double[][] AddToDiagonal(this short a, float[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | |
| System.Single[][] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Int16, Single[][], Int16[][])
Declaration
public static short[][] AddToDiagonal(this short a, float[][] b, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | |
| System.Single[][] | b | |
| System.Int16[][] | result |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
AddToDiagonal(Int16, Single[][], Single[][])
Declaration
public static float[][] AddToDiagonal(this short a, float[][] b, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | |
| System.Single[][] | b | |
| System.Single[][] | result |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
AddToDiagonal(Int16, Single[,])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static float[, ] AddToDiagonal(this short a, float[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | The scalar |
| System.Single[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
AddToDiagonal(Int16, Single[,], Double[,])
Declaration
public static double[, ] AddToDiagonal(this short a, float[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | |
| System.Single[,] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Int16, Single[,], Int16[,])
Declaration
public static short[, ] AddToDiagonal(this short a, float[, ] b, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | |
| System.Single[,] | b | |
| System.Int16[,] | result |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
AddToDiagonal(Int16, Single[,], Single[,])
Declaration
public static float[, ] AddToDiagonal(this short a, float[, ] b, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | a | |
| System.Single[,] | b | |
| System.Single[,] | result |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
AddToDiagonal(Int16[], Byte[][], Byte[][])
Declaration
public static byte[][] AddToDiagonal(this short[] a, byte[][] b, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | |
| System.Byte[][] | b | |
| System.Byte[][] | result |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
AddToDiagonal(Int16[], Byte[][], Double[][])
Declaration
public static double[][] AddToDiagonal(this short[] a, byte[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | |
| System.Byte[][] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Int16[], Byte[][], Int16[][])
Declaration
public static short[][] AddToDiagonal(this short[] a, byte[][] b, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | |
| System.Byte[][] | b | |
| System.Int16[][] | result |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
AddToDiagonal(Int16[], Byte[,], Byte[,])
Declaration
public static byte[, ] AddToDiagonal(this short[] a, byte[, ] b, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | |
| System.Byte[,] | b | |
| System.Byte[,] | result |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
AddToDiagonal(Int16[], Byte[,], Double[,])
Declaration
public static double[, ] AddToDiagonal(this short[] a, byte[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | |
| System.Byte[,] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Int16[], Byte[,], Int16[,])
Declaration
public static short[, ] AddToDiagonal(this short[] a, byte[, ] b, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | |
| System.Byte[,] | b | |
| System.Int16[,] | result |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
AddToDiagonal(Int16[], Decimal[][], Decimal[][])
Declaration
public static decimal[][] AddToDiagonal(this short[] a, decimal[][] b, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | |
| System.Decimal[][] | b | |
| System.Decimal[][] | result |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
AddToDiagonal(Int16[], Decimal[][], Double[][])
Declaration
public static double[][] AddToDiagonal(this short[] a, decimal[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | |
| System.Decimal[][] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Int16[], Decimal[][], Int16[][])
Declaration
public static short[][] AddToDiagonal(this short[] a, decimal[][] b, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | |
| System.Decimal[][] | b | |
| System.Int16[][] | result |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
AddToDiagonal(Int16[], Decimal[,], Decimal[,])
Declaration
public static decimal[, ] AddToDiagonal(this short[] a, decimal[, ] b, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | |
| System.Decimal[,] | b | |
| System.Decimal[,] | result |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
AddToDiagonal(Int16[], Decimal[,], Double[,])
Declaration
public static double[, ] AddToDiagonal(this short[] a, decimal[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | |
| System.Decimal[,] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Int16[], Decimal[,], Int16[,])
Declaration
public static short[, ] AddToDiagonal(this short[] a, decimal[, ] b, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | |
| System.Decimal[,] | b | |
| System.Int16[,] | result |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
AddToDiagonal(Int16[], Double[][])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static double[][] AddToDiagonal(this short[] a, double[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | The scalar |
| System.Double[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Int16[], Double[][], Double[][])
Declaration
public static double[][] AddToDiagonal(this short[] a, double[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | |
| System.Double[][] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Int16[], Double[][], Int16[][])
Declaration
public static short[][] AddToDiagonal(this short[] a, double[][] b, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | |
| System.Double[][] | b | |
| System.Int16[][] | result |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
AddToDiagonal(Int16[], Double[,])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static double[, ] AddToDiagonal(this short[] a, double[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | The scalar |
| System.Double[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Int16[], Double[,], Double[,])
Declaration
public static double[, ] AddToDiagonal(this short[] a, double[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | |
| System.Double[,] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Int16[], Double[,], Int16[,])
Declaration
public static short[, ] AddToDiagonal(this short[] a, double[, ] b, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | |
| System.Double[,] | b | |
| System.Int16[,] | result |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
AddToDiagonal(Int16[], Int16[][])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static short[][] AddToDiagonal(this short[] a, short[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | The scalar |
| System.Int16[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
AddToDiagonal(Int16[], Int16[][], Double[][])
Declaration
public static double[][] AddToDiagonal(this short[] a, short[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | |
| System.Int16[][] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Int16[], Int16[][], Int16[][])
Declaration
public static short[][] AddToDiagonal(this short[] a, short[][] b, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | |
| System.Int16[][] | b | |
| System.Int16[][] | result |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
AddToDiagonal(Int16[], Int16[,])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static short[, ] AddToDiagonal(this short[] a, short[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | The scalar |
| System.Int16[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
AddToDiagonal(Int16[], Int16[,], Double[,])
Declaration
public static double[, ] AddToDiagonal(this short[] a, short[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | |
| System.Int16[,] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Int16[], Int16[,], Int16[,])
Declaration
public static short[, ] AddToDiagonal(this short[] a, short[, ] b, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | |
| System.Int16[,] | b | |
| System.Int16[,] | result |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
AddToDiagonal(Int16[], Int32[][])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static int[][] AddToDiagonal(this short[] a, int[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | The scalar |
| System.Int32[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
AddToDiagonal(Int16[], Int32[][], Double[][])
Declaration
public static double[][] AddToDiagonal(this short[] a, int[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | |
| System.Int32[][] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Int16[], Int32[][], Int16[][])
Declaration
public static short[][] AddToDiagonal(this short[] a, int[][] b, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | |
| System.Int32[][] | b | |
| System.Int16[][] | result |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
AddToDiagonal(Int16[], Int32[][], Int32[][])
Declaration
public static int[][] AddToDiagonal(this short[] a, int[][] b, int[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | |
| System.Int32[][] | b | |
| System.Int32[][] | result |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
AddToDiagonal(Int16[], Int32[,])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static int[, ] AddToDiagonal(this short[] a, int[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | The scalar |
| System.Int32[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
AddToDiagonal(Int16[], Int32[,], Double[,])
Declaration
public static double[, ] AddToDiagonal(this short[] a, int[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | |
| System.Int32[,] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Int16[], Int32[,], Int16[,])
Declaration
public static short[, ] AddToDiagonal(this short[] a, int[, ] b, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | |
| System.Int32[,] | b | |
| System.Int16[,] | result |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
AddToDiagonal(Int16[], Int32[,], Int32[,])
Declaration
public static int[, ] AddToDiagonal(this short[] a, int[, ] b, int[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | |
| System.Int32[,] | b | |
| System.Int32[,] | result |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
AddToDiagonal(Int16[], Single[][])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static float[][] AddToDiagonal(this short[] a, float[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | The scalar |
| System.Single[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
AddToDiagonal(Int16[], Single[][], Double[][])
Declaration
public static double[][] AddToDiagonal(this short[] a, float[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | |
| System.Single[][] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Int16[], Single[][], Int16[][])
Declaration
public static short[][] AddToDiagonal(this short[] a, float[][] b, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | |
| System.Single[][] | b | |
| System.Int16[][] | result |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
AddToDiagonal(Int16[], Single[][], Single[][])
Declaration
public static float[][] AddToDiagonal(this short[] a, float[][] b, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | |
| System.Single[][] | b | |
| System.Single[][] | result |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
AddToDiagonal(Int16[], Single[,])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static float[, ] AddToDiagonal(this short[] a, float[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | The scalar |
| System.Single[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
AddToDiagonal(Int16[], Single[,], Double[,])
Declaration
public static double[, ] AddToDiagonal(this short[] a, float[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | |
| System.Single[,] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Int16[], Single[,], Int16[,])
Declaration
public static short[, ] AddToDiagonal(this short[] a, float[, ] b, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | |
| System.Single[,] | b | |
| System.Int16[,] | result |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
AddToDiagonal(Int16[], Single[,], Single[,])
Declaration
public static float[, ] AddToDiagonal(this short[] a, float[, ] b, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[] | a | |
| System.Single[,] | b | |
| System.Single[,] | result |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
AddToDiagonal(Int16[][], Byte, Byte[][])
Declaration
public static byte[][] AddToDiagonal(this short[][] a, byte b, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | |
| System.Byte | b | |
| System.Byte[][] | result |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
AddToDiagonal(Int16[][], Byte, Double[][])
Declaration
public static double[][] AddToDiagonal(this short[][] a, byte b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | |
| System.Byte | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Int16[][], Byte, Int16[][])
Declaration
public static short[][] AddToDiagonal(this short[][] a, byte b, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | |
| System.Byte | b | |
| System.Int16[][] | result |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
AddToDiagonal(Int16[][], Byte[], Byte[][])
Declaration
public static byte[][] AddToDiagonal(this short[][] a, byte[] b, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | |
| System.Byte[] | b | |
| System.Byte[][] | result |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
AddToDiagonal(Int16[][], Byte[], Double[][])
Declaration
public static double[][] AddToDiagonal(this short[][] a, byte[] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | |
| System.Byte[] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Int16[][], Byte[], Int16[][])
Declaration
public static short[][] AddToDiagonal(this short[][] a, byte[] b, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | |
| System.Byte[] | b | |
| System.Int16[][] | result |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
AddToDiagonal(Int16[][], Decimal, Decimal[][])
Declaration
public static decimal[][] AddToDiagonal(this short[][] a, decimal b, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | |
| System.Decimal | b | |
| System.Decimal[][] | result |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
AddToDiagonal(Int16[][], Decimal, Double[][])
Declaration
public static double[][] AddToDiagonal(this short[][] a, decimal b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | |
| System.Decimal | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Int16[][], Decimal, Int16[][])
Declaration
public static short[][] AddToDiagonal(this short[][] a, decimal b, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | |
| System.Decimal | b | |
| System.Int16[][] | result |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
AddToDiagonal(Int16[][], Decimal[], Decimal[][])
Declaration
public static decimal[][] AddToDiagonal(this short[][] a, decimal[] b, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | |
| System.Decimal[] | b | |
| System.Decimal[][] | result |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
AddToDiagonal(Int16[][], Decimal[], Double[][])
Declaration
public static double[][] AddToDiagonal(this short[][] a, decimal[] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | |
| System.Decimal[] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Int16[][], Decimal[], Int16[][])
Declaration
public static short[][] AddToDiagonal(this short[][] a, decimal[] b, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | |
| System.Decimal[] | b | |
| System.Int16[][] | result |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
AddToDiagonal(Int16[][], Double)
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static short[][] AddToDiagonal(this short[][] a, double b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | The scalar |
| System.Double | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
AddToDiagonal(Int16[][], Double, Double[][])
Declaration
public static double[][] AddToDiagonal(this short[][] a, double b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | |
| System.Double | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Int16[][], Double, Int16[][])
Declaration
public static short[][] AddToDiagonal(this short[][] a, double b, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | |
| System.Double | b | |
| System.Int16[][] | result |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
AddToDiagonal(Int16[][], Double[])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static short[][] AddToDiagonal(this short[][] a, double[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | The scalar |
| System.Double[] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
AddToDiagonal(Int16[][], Double[], Double[][])
Declaration
public static double[][] AddToDiagonal(this short[][] a, double[] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | |
| System.Double[] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Int16[][], Double[], Int16[][])
Declaration
public static short[][] AddToDiagonal(this short[][] a, double[] b, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | |
| System.Double[] | b | |
| System.Int16[][] | result |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
AddToDiagonal(Int16[][], Int16)
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static short[][] AddToDiagonal(this short[][] a, short b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | The scalar |
| System.Int16 | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
AddToDiagonal(Int16[][], Int16, Double[][])
Declaration
public static double[][] AddToDiagonal(this short[][] a, short b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | |
| System.Int16 | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Int16[][], Int16, Int16[][])
Declaration
public static short[][] AddToDiagonal(this short[][] a, short b, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | |
| System.Int16 | b | |
| System.Int16[][] | result |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
AddToDiagonal(Int16[][], Int16[])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static short[][] AddToDiagonal(this short[][] a, short[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | The scalar |
| System.Int16[] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
AddToDiagonal(Int16[][], Int16[], Double[][])
Declaration
public static double[][] AddToDiagonal(this short[][] a, short[] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | |
| System.Int16[] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Int16[][], Int16[], Int16[][])
Declaration
public static short[][] AddToDiagonal(this short[][] a, short[] b, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | |
| System.Int16[] | b | |
| System.Int16[][] | result |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
AddToDiagonal(Int16[][], Int32)
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static short[][] AddToDiagonal(this short[][] a, int b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | The scalar |
| System.Int32 | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
AddToDiagonal(Int16[][], Int32, Double[][])
Declaration
public static double[][] AddToDiagonal(this short[][] a, int b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | |
| System.Int32 | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Int16[][], Int32, Int16[][])
Declaration
public static short[][] AddToDiagonal(this short[][] a, int b, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | |
| System.Int32 | b | |
| System.Int16[][] | result |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
AddToDiagonal(Int16[][], Int32, Int32[][])
Declaration
public static int[][] AddToDiagonal(this short[][] a, int b, int[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | |
| System.Int32 | b | |
| System.Int32[][] | result |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
AddToDiagonal(Int16[][], Int32[])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static short[][] AddToDiagonal(this short[][] a, int[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | The scalar |
| System.Int32[] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
AddToDiagonal(Int16[][], Int32[], Double[][])
Declaration
public static double[][] AddToDiagonal(this short[][] a, int[] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | |
| System.Int32[] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Int16[][], Int32[], Int16[][])
Declaration
public static short[][] AddToDiagonal(this short[][] a, int[] b, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | |
| System.Int32[] | b | |
| System.Int16[][] | result |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
AddToDiagonal(Int16[][], Int32[], Int32[][])
Declaration
public static int[][] AddToDiagonal(this short[][] a, int[] b, int[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | |
| System.Int32[] | b | |
| System.Int32[][] | result |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
AddToDiagonal(Int16[][], Single)
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static short[][] AddToDiagonal(this short[][] a, float b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | The scalar |
| System.Single | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
AddToDiagonal(Int16[][], Single, Double[][])
Declaration
public static double[][] AddToDiagonal(this short[][] a, float b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | |
| System.Single | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Int16[][], Single, Int16[][])
Declaration
public static short[][] AddToDiagonal(this short[][] a, float b, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | |
| System.Single | b | |
| System.Int16[][] | result |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
AddToDiagonal(Int16[][], Single, Single[][])
Declaration
public static float[][] AddToDiagonal(this short[][] a, float b, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | |
| System.Single | b | |
| System.Single[][] | result |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
AddToDiagonal(Int16[][], Single[])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static short[][] AddToDiagonal(this short[][] a, float[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | The scalar |
| System.Single[] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
AddToDiagonal(Int16[][], Single[], Double[][])
Declaration
public static double[][] AddToDiagonal(this short[][] a, float[] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | |
| System.Single[] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Int16[][], Single[], Int16[][])
Declaration
public static short[][] AddToDiagonal(this short[][] a, float[] b, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | |
| System.Single[] | b | |
| System.Int16[][] | result |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
AddToDiagonal(Int16[][], Single[], Single[][])
Declaration
public static float[][] AddToDiagonal(this short[][] a, float[] b, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[][] | a | |
| System.Single[] | b | |
| System.Single[][] | result |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
AddToDiagonal(Int16[,], Byte, Byte[,])
Declaration
public static byte[, ] AddToDiagonal(this short[, ] a, byte b, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | |
| System.Byte | b | |
| System.Byte[,] | result |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
AddToDiagonal(Int16[,], Byte, Double[,])
Declaration
public static double[, ] AddToDiagonal(this short[, ] a, byte b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | |
| System.Byte | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Int16[,], Byte, Int16[,])
Declaration
public static short[, ] AddToDiagonal(this short[, ] a, byte b, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | |
| System.Byte | b | |
| System.Int16[,] | result |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
AddToDiagonal(Int16[,], Byte[], Byte[,])
Declaration
public static byte[, ] AddToDiagonal(this short[, ] a, byte[] b, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | |
| System.Byte[] | b | |
| System.Byte[,] | result |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
AddToDiagonal(Int16[,], Byte[], Double[,])
Declaration
public static double[, ] AddToDiagonal(this short[, ] a, byte[] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | |
| System.Byte[] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Int16[,], Byte[], Int16[,])
Declaration
public static short[, ] AddToDiagonal(this short[, ] a, byte[] b, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | |
| System.Byte[] | b | |
| System.Int16[,] | result |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
AddToDiagonal(Int16[,], Decimal, Decimal[,])
Declaration
public static decimal[, ] AddToDiagonal(this short[, ] a, decimal b, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | |
| System.Decimal | b | |
| System.Decimal[,] | result |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
AddToDiagonal(Int16[,], Decimal, Double[,])
Declaration
public static double[, ] AddToDiagonal(this short[, ] a, decimal b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | |
| System.Decimal | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Int16[,], Decimal, Int16[,])
Declaration
public static short[, ] AddToDiagonal(this short[, ] a, decimal b, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | |
| System.Decimal | b | |
| System.Int16[,] | result |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
AddToDiagonal(Int16[,], Decimal[], Decimal[,])
Declaration
public static decimal[, ] AddToDiagonal(this short[, ] a, decimal[] b, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | |
| System.Decimal[] | b | |
| System.Decimal[,] | result |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
AddToDiagonal(Int16[,], Decimal[], Double[,])
Declaration
public static double[, ] AddToDiagonal(this short[, ] a, decimal[] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | |
| System.Decimal[] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Int16[,], Decimal[], Int16[,])
Declaration
public static short[, ] AddToDiagonal(this short[, ] a, decimal[] b, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | |
| System.Decimal[] | b | |
| System.Int16[,] | result |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
AddToDiagonal(Int16[,], Double)
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static short[, ] AddToDiagonal(this short[, ] a, double b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | The scalar |
| System.Double | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
AddToDiagonal(Int16[,], Double, Double[,])
Declaration
public static double[, ] AddToDiagonal(this short[, ] a, double b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | |
| System.Double | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Int16[,], Double, Int16[,])
Declaration
public static short[, ] AddToDiagonal(this short[, ] a, double b, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | |
| System.Double | b | |
| System.Int16[,] | result |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
AddToDiagonal(Int16[,], Double[])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static short[, ] AddToDiagonal(this short[, ] a, double[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | The scalar |
| System.Double[] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
AddToDiagonal(Int16[,], Double[], Double[,])
Declaration
public static double[, ] AddToDiagonal(this short[, ] a, double[] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | |
| System.Double[] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Int16[,], Double[], Int16[,])
Declaration
public static short[, ] AddToDiagonal(this short[, ] a, double[] b, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | |
| System.Double[] | b | |
| System.Int16[,] | result |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
AddToDiagonal(Int16[,], Int16)
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static short[, ] AddToDiagonal(this short[, ] a, short b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | The scalar |
| System.Int16 | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
AddToDiagonal(Int16[,], Int16, Double[,])
Declaration
public static double[, ] AddToDiagonal(this short[, ] a, short b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | |
| System.Int16 | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Int16[,], Int16, Int16[,])
Declaration
public static short[, ] AddToDiagonal(this short[, ] a, short b, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | |
| System.Int16 | b | |
| System.Int16[,] | result |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
AddToDiagonal(Int16[,], Int16[])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static short[, ] AddToDiagonal(this short[, ] a, short[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | The scalar |
| System.Int16[] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
AddToDiagonal(Int16[,], Int16[], Double[,])
Declaration
public static double[, ] AddToDiagonal(this short[, ] a, short[] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | |
| System.Int16[] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Int16[,], Int16[], Int16[,])
Declaration
public static short[, ] AddToDiagonal(this short[, ] a, short[] b, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | |
| System.Int16[] | b | |
| System.Int16[,] | result |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
AddToDiagonal(Int16[,], Int32)
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static short[, ] AddToDiagonal(this short[, ] a, int b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | The scalar |
| System.Int32 | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
AddToDiagonal(Int16[,], Int32, Double[,])
Declaration
public static double[, ] AddToDiagonal(this short[, ] a, int b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | |
| System.Int32 | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Int16[,], Int32, Int16[,])
Declaration
public static short[, ] AddToDiagonal(this short[, ] a, int b, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | |
| System.Int32 | b | |
| System.Int16[,] | result |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
AddToDiagonal(Int16[,], Int32, Int32[,])
Declaration
public static int[, ] AddToDiagonal(this short[, ] a, int b, int[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | |
| System.Int32 | b | |
| System.Int32[,] | result |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
AddToDiagonal(Int16[,], Int32[])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static short[, ] AddToDiagonal(this short[, ] a, int[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | The scalar |
| System.Int32[] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
AddToDiagonal(Int16[,], Int32[], Double[,])
Declaration
public static double[, ] AddToDiagonal(this short[, ] a, int[] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | |
| System.Int32[] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Int16[,], Int32[], Int16[,])
Declaration
public static short[, ] AddToDiagonal(this short[, ] a, int[] b, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | |
| System.Int32[] | b | |
| System.Int16[,] | result |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
AddToDiagonal(Int16[,], Int32[], Int32[,])
Declaration
public static int[, ] AddToDiagonal(this short[, ] a, int[] b, int[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | |
| System.Int32[] | b | |
| System.Int32[,] | result |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
AddToDiagonal(Int16[,], Single)
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static short[, ] AddToDiagonal(this short[, ] a, float b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | The scalar |
| System.Single | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
AddToDiagonal(Int16[,], Single, Double[,])
Declaration
public static double[, ] AddToDiagonal(this short[, ] a, float b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | |
| System.Single | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Int16[,], Single, Int16[,])
Declaration
public static short[, ] AddToDiagonal(this short[, ] a, float b, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | |
| System.Single | b | |
| System.Int16[,] | result |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
AddToDiagonal(Int16[,], Single, Single[,])
Declaration
public static float[, ] AddToDiagonal(this short[, ] a, float b, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | |
| System.Single | b | |
| System.Single[,] | result |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
AddToDiagonal(Int16[,], Single[])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static short[, ] AddToDiagonal(this short[, ] a, float[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | The scalar |
| System.Single[] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
AddToDiagonal(Int16[,], Single[], Double[,])
Declaration
public static double[, ] AddToDiagonal(this short[, ] a, float[] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | |
| System.Single[] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Int16[,], Single[], Int16[,])
Declaration
public static short[, ] AddToDiagonal(this short[, ] a, float[] b, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | |
| System.Single[] | b | |
| System.Int16[,] | result |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
AddToDiagonal(Int16[,], Single[], Single[,])
Declaration
public static float[, ] AddToDiagonal(this short[, ] a, float[] b, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16[,] | a | |
| System.Single[] | b | |
| System.Single[,] | result |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
AddToDiagonal(Int32, Byte[][])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static byte[][] AddToDiagonal(this int a, byte[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | The scalar |
| System.Byte[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
AddToDiagonal(Int32, Byte[][], Byte[][])
Declaration
public static byte[][] AddToDiagonal(this int a, byte[][] b, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | |
| System.Byte[][] | b | |
| System.Byte[][] | result |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
AddToDiagonal(Int32, Byte[][], Double[][])
Declaration
public static double[][] AddToDiagonal(this int a, byte[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | |
| System.Byte[][] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Int32, Byte[][], Int32[][])
Declaration
public static int[][] AddToDiagonal(this int a, byte[][] b, int[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | |
| System.Byte[][] | b | |
| System.Int32[][] | result |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
AddToDiagonal(Int32, Byte[,])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static byte[, ] AddToDiagonal(this int a, byte[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | The scalar |
| System.Byte[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
AddToDiagonal(Int32, Byte[,], Byte[,])
Declaration
public static byte[, ] AddToDiagonal(this int a, byte[, ] b, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | |
| System.Byte[,] | b | |
| System.Byte[,] | result |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
AddToDiagonal(Int32, Byte[,], Double[,])
Declaration
public static double[, ] AddToDiagonal(this int a, byte[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | |
| System.Byte[,] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Int32, Byte[,], Int32[,])
Declaration
public static int[, ] AddToDiagonal(this int a, byte[, ] b, int[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | |
| System.Byte[,] | b | |
| System.Int32[,] | result |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
AddToDiagonal(Int32, Decimal[][])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static decimal[][] AddToDiagonal(this int a, decimal[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | The scalar |
| System.Decimal[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
AddToDiagonal(Int32, Decimal[][], Decimal[][])
Declaration
public static decimal[][] AddToDiagonal(this int a, decimal[][] b, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | |
| System.Decimal[][] | b | |
| System.Decimal[][] | result |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
AddToDiagonal(Int32, Decimal[][], Double[][])
Declaration
public static double[][] AddToDiagonal(this int a, decimal[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | |
| System.Decimal[][] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Int32, Decimal[][], Int32[][])
Declaration
public static int[][] AddToDiagonal(this int a, decimal[][] b, int[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | |
| System.Decimal[][] | b | |
| System.Int32[][] | result |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
AddToDiagonal(Int32, Decimal[,])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static decimal[, ] AddToDiagonal(this int a, decimal[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | The scalar |
| System.Decimal[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
AddToDiagonal(Int32, Decimal[,], Decimal[,])
Declaration
public static decimal[, ] AddToDiagonal(this int a, decimal[, ] b, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | |
| System.Decimal[,] | b | |
| System.Decimal[,] | result |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
AddToDiagonal(Int32, Decimal[,], Double[,])
Declaration
public static double[, ] AddToDiagonal(this int a, decimal[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | |
| System.Decimal[,] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Int32, Decimal[,], Int32[,])
Declaration
public static int[, ] AddToDiagonal(this int a, decimal[, ] b, int[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | |
| System.Decimal[,] | b | |
| System.Int32[,] | result |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
AddToDiagonal(Int32, Double[][])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static double[][] AddToDiagonal(this int a, double[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | The scalar |
| System.Double[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Int32, Double[][], Double[][])
Declaration
public static double[][] AddToDiagonal(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[][] |
AddToDiagonal(Int32, Double[][], Int32[][])
Declaration
public static int[][] AddToDiagonal(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[][] |
AddToDiagonal(Int32, Double[,])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static double[, ] AddToDiagonal(this int a, double[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | The scalar |
| System.Double[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Int32, Double[,], Double[,])
Declaration
public static double[, ] AddToDiagonal(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[,] |
AddToDiagonal(Int32, Double[,], Int32[,])
Declaration
public static int[, ] AddToDiagonal(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[,] |
AddToDiagonal(Int32, Int16[][])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static short[][] AddToDiagonal(this int a, short[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | The scalar |
| System.Int16[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
AddToDiagonal(Int32, Int16[][], Double[][])
Declaration
public static double[][] AddToDiagonal(this int a, short[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | |
| System.Int16[][] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Int32, Int16[][], Int16[][])
Declaration
public static short[][] AddToDiagonal(this int a, short[][] b, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | |
| System.Int16[][] | b | |
| System.Int16[][] | result |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
AddToDiagonal(Int32, Int16[][], Int32[][])
Declaration
public static int[][] AddToDiagonal(this int a, short[][] b, int[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | |
| System.Int16[][] | b | |
| System.Int32[][] | result |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
AddToDiagonal(Int32, Int16[,])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static short[, ] AddToDiagonal(this int a, short[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | The scalar |
| System.Int16[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
AddToDiagonal(Int32, Int16[,], Double[,])
Declaration
public static double[, ] AddToDiagonal(this int a, short[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | |
| System.Int16[,] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Int32, Int16[,], Int16[,])
Declaration
public static short[, ] AddToDiagonal(this int a, short[, ] b, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | |
| System.Int16[,] | b | |
| System.Int16[,] | result |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
AddToDiagonal(Int32, Int16[,], Int32[,])
Declaration
public static int[, ] AddToDiagonal(this int a, short[, ] b, int[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | |
| System.Int16[,] | b | |
| System.Int32[,] | result |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
AddToDiagonal(Int32, Int32[][])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static int[][] AddToDiagonal(this int a, int[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | The scalar |
| System.Int32[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
AddToDiagonal(Int32, Int32[][], Double[][])
Declaration
public static double[][] AddToDiagonal(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[][] |
AddToDiagonal(Int32, Int32[][], Int32[][])
Declaration
public static int[][] AddToDiagonal(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[][] |
AddToDiagonal(Int32, Int32[,])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static int[, ] AddToDiagonal(this int a, int[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | The scalar |
| System.Int32[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
AddToDiagonal(Int32, Int32[,], Double[,])
Declaration
public static double[, ] AddToDiagonal(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[,] |
AddToDiagonal(Int32, Int32[,], Int32[,])
Declaration
public static int[, ] AddToDiagonal(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[,] |
AddToDiagonal(Int32, Single[][])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static float[][] AddToDiagonal(this int a, float[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | The scalar |
| System.Single[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
AddToDiagonal(Int32, Single[][], Double[][])
Declaration
public static double[][] AddToDiagonal(this int a, float[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | |
| System.Single[][] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Int32, Single[][], Int32[][])
Declaration
public static int[][] AddToDiagonal(this int a, float[][] b, int[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | |
| System.Single[][] | b | |
| System.Int32[][] | result |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
AddToDiagonal(Int32, Single[][], Single[][])
Declaration
public static float[][] AddToDiagonal(this int a, float[][] b, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | |
| System.Single[][] | b | |
| System.Single[][] | result |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
AddToDiagonal(Int32, Single[,])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static float[, ] AddToDiagonal(this int a, float[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | The scalar |
| System.Single[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
AddToDiagonal(Int32, Single[,], Double[,])
Declaration
public static double[, ] AddToDiagonal(this int a, float[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | |
| System.Single[,] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Int32, Single[,], Int32[,])
Declaration
public static int[, ] AddToDiagonal(this int a, float[, ] b, int[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | |
| System.Single[,] | b | |
| System.Int32[,] | result |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
AddToDiagonal(Int32, Single[,], Single[,])
Declaration
public static float[, ] AddToDiagonal(this int a, float[, ] b, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | a | |
| System.Single[,] | b | |
| System.Single[,] | result |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
AddToDiagonal(Int32[], Byte[][])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static byte[][] AddToDiagonal(this int[] a, byte[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The scalar |
| System.Byte[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
AddToDiagonal(Int32[], Byte[][], Byte[][])
Declaration
public static byte[][] AddToDiagonal(this int[] a, byte[][] b, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | |
| System.Byte[][] | b | |
| System.Byte[][] | result |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
AddToDiagonal(Int32[], Byte[][], Double[][])
Declaration
public static double[][] AddToDiagonal(this int[] a, byte[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | |
| System.Byte[][] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Int32[], Byte[][], Int32[][])
Declaration
public static int[][] AddToDiagonal(this int[] a, byte[][] b, int[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | |
| System.Byte[][] | b | |
| System.Int32[][] | result |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
AddToDiagonal(Int32[], Byte[,])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static byte[, ] AddToDiagonal(this int[] a, byte[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The scalar |
| System.Byte[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
AddToDiagonal(Int32[], Byte[,], Byte[,])
Declaration
public static byte[, ] AddToDiagonal(this int[] a, byte[, ] b, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | |
| System.Byte[,] | b | |
| System.Byte[,] | result |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
AddToDiagonal(Int32[], Byte[,], Double[,])
Declaration
public static double[, ] AddToDiagonal(this int[] a, byte[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | |
| System.Byte[,] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Int32[], Byte[,], Int32[,])
Declaration
public static int[, ] AddToDiagonal(this int[] a, byte[, ] b, int[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | |
| System.Byte[,] | b | |
| System.Int32[,] | result |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
AddToDiagonal(Int32[], Decimal[][])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static decimal[][] AddToDiagonal(this int[] a, decimal[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The scalar |
| System.Decimal[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
AddToDiagonal(Int32[], Decimal[][], Decimal[][])
Declaration
public static decimal[][] AddToDiagonal(this int[] a, decimal[][] b, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | |
| System.Decimal[][] | b | |
| System.Decimal[][] | result |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
AddToDiagonal(Int32[], Decimal[][], Double[][])
Declaration
public static double[][] AddToDiagonal(this int[] a, decimal[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | |
| System.Decimal[][] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Int32[], Decimal[][], Int32[][])
Declaration
public static int[][] AddToDiagonal(this int[] a, decimal[][] b, int[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | |
| System.Decimal[][] | b | |
| System.Int32[][] | result |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
AddToDiagonal(Int32[], Decimal[,])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static decimal[, ] AddToDiagonal(this int[] a, decimal[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The scalar |
| System.Decimal[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
AddToDiagonal(Int32[], Decimal[,], Decimal[,])
Declaration
public static decimal[, ] AddToDiagonal(this int[] a, decimal[, ] b, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | |
| System.Decimal[,] | b | |
| System.Decimal[,] | result |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
AddToDiagonal(Int32[], Decimal[,], Double[,])
Declaration
public static double[, ] AddToDiagonal(this int[] a, decimal[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | |
| System.Decimal[,] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Int32[], Decimal[,], Int32[,])
Declaration
public static int[, ] AddToDiagonal(this int[] a, decimal[, ] b, int[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | |
| System.Decimal[,] | b | |
| System.Int32[,] | result |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
AddToDiagonal(Int32[], Double[][])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static double[][] AddToDiagonal(this int[] a, double[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The scalar |
| System.Double[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Int32[], Double[][], Double[][])
Declaration
public static double[][] AddToDiagonal(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[][] |
AddToDiagonal(Int32[], Double[][], Int32[][])
Declaration
public static int[][] AddToDiagonal(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[][] |
AddToDiagonal(Int32[], Double[,])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static double[, ] AddToDiagonal(this int[] a, double[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The scalar |
| System.Double[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Int32[], Double[,], Double[,])
Declaration
public static double[, ] AddToDiagonal(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[,] |
AddToDiagonal(Int32[], Double[,], Int32[,])
Declaration
public static int[, ] AddToDiagonal(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[,] |
AddToDiagonal(Int32[], Int16[][])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static short[][] AddToDiagonal(this int[] a, short[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The scalar |
| System.Int16[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
AddToDiagonal(Int32[], Int16[][], Double[][])
Declaration
public static double[][] AddToDiagonal(this int[] a, short[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | |
| System.Int16[][] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Int32[], Int16[][], Int16[][])
Declaration
public static short[][] AddToDiagonal(this int[] a, short[][] b, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | |
| System.Int16[][] | b | |
| System.Int16[][] | result |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
AddToDiagonal(Int32[], Int16[][], Int32[][])
Declaration
public static int[][] AddToDiagonal(this int[] a, short[][] b, int[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | |
| System.Int16[][] | b | |
| System.Int32[][] | result |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
AddToDiagonal(Int32[], Int16[,])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static short[, ] AddToDiagonal(this int[] a, short[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The scalar |
| System.Int16[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
AddToDiagonal(Int32[], Int16[,], Double[,])
Declaration
public static double[, ] AddToDiagonal(this int[] a, short[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | |
| System.Int16[,] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Int32[], Int16[,], Int16[,])
Declaration
public static short[, ] AddToDiagonal(this int[] a, short[, ] b, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | |
| System.Int16[,] | b | |
| System.Int16[,] | result |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
AddToDiagonal(Int32[], Int16[,], Int32[,])
Declaration
public static int[, ] AddToDiagonal(this int[] a, short[, ] b, int[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | |
| System.Int16[,] | b | |
| System.Int32[,] | result |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
AddToDiagonal(Int32[], Int32[][])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static int[][] AddToDiagonal(this int[] a, int[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The scalar |
| System.Int32[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
AddToDiagonal(Int32[], Int32[][], Double[][])
Declaration
public static double[][] AddToDiagonal(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[][] |
AddToDiagonal(Int32[], Int32[][], Int32[][])
Declaration
public static int[][] AddToDiagonal(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[][] |
AddToDiagonal(Int32[], Int32[,])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static int[, ] AddToDiagonal(this int[] a, int[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The scalar |
| System.Int32[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
AddToDiagonal(Int32[], Int32[,], Double[,])
Declaration
public static double[, ] AddToDiagonal(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[,] |
AddToDiagonal(Int32[], Int32[,], Int32[,])
Declaration
public static int[, ] AddToDiagonal(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[,] |
AddToDiagonal(Int32[], Single[][])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static float[][] AddToDiagonal(this int[] a, float[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The scalar |
| System.Single[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
AddToDiagonal(Int32[], Single[][], Double[][])
Declaration
public static double[][] AddToDiagonal(this int[] a, float[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | |
| System.Single[][] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Int32[], Single[][], Int32[][])
Declaration
public static int[][] AddToDiagonal(this int[] a, float[][] b, int[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | |
| System.Single[][] | b | |
| System.Int32[][] | result |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
AddToDiagonal(Int32[], Single[][], Single[][])
Declaration
public static float[][] AddToDiagonal(this int[] a, float[][] b, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | |
| System.Single[][] | b | |
| System.Single[][] | result |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
AddToDiagonal(Int32[], Single[,])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static float[, ] AddToDiagonal(this int[] a, float[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | The scalar |
| System.Single[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
AddToDiagonal(Int32[], Single[,], Double[,])
Declaration
public static double[, ] AddToDiagonal(this int[] a, float[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | |
| System.Single[,] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Int32[], Single[,], Int32[,])
Declaration
public static int[, ] AddToDiagonal(this int[] a, float[, ] b, int[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | |
| System.Single[,] | b | |
| System.Int32[,] | result |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
AddToDiagonal(Int32[], Single[,], Single[,])
Declaration
public static float[, ] AddToDiagonal(this int[] a, float[, ] b, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[] | a | |
| System.Single[,] | b | |
| System.Single[,] | result |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
AddToDiagonal(Int32[][], Byte)
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static int[][] AddToDiagonal(this int[][] a, byte b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | The scalar |
| System.Byte | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
AddToDiagonal(Int32[][], Byte, Byte[][])
Declaration
public static byte[][] AddToDiagonal(this int[][] a, byte b, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | |
| System.Byte | b | |
| System.Byte[][] | result |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
AddToDiagonal(Int32[][], Byte, Double[][])
Declaration
public static double[][] AddToDiagonal(this int[][] a, byte b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | |
| System.Byte | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Int32[][], Byte, Int32[][])
Declaration
public static int[][] AddToDiagonal(this int[][] a, byte b, int[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | |
| System.Byte | b | |
| System.Int32[][] | result |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
AddToDiagonal(Int32[][], Byte[])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static int[][] AddToDiagonal(this int[][] a, byte[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | The scalar |
| System.Byte[] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
AddToDiagonal(Int32[][], Byte[], Byte[][])
Declaration
public static byte[][] AddToDiagonal(this int[][] a, byte[] b, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | |
| System.Byte[] | b | |
| System.Byte[][] | result |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
AddToDiagonal(Int32[][], Byte[], Double[][])
Declaration
public static double[][] AddToDiagonal(this int[][] a, byte[] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | |
| System.Byte[] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Int32[][], Byte[], Int32[][])
Declaration
public static int[][] AddToDiagonal(this int[][] a, byte[] b, int[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | |
| System.Byte[] | b | |
| System.Int32[][] | result |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
AddToDiagonal(Int32[][], Decimal)
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static int[][] AddToDiagonal(this int[][] a, decimal b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | The scalar |
| System.Decimal | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
AddToDiagonal(Int32[][], Decimal, Decimal[][])
Declaration
public static decimal[][] AddToDiagonal(this int[][] a, decimal b, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | |
| System.Decimal | b | |
| System.Decimal[][] | result |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
AddToDiagonal(Int32[][], Decimal, Double[][])
Declaration
public static double[][] AddToDiagonal(this int[][] a, decimal b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | |
| System.Decimal | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Int32[][], Decimal, Int32[][])
Declaration
public static int[][] AddToDiagonal(this int[][] a, decimal b, int[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | |
| System.Decimal | b | |
| System.Int32[][] | result |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
AddToDiagonal(Int32[][], Decimal[])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static int[][] AddToDiagonal(this int[][] a, decimal[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | The scalar |
| System.Decimal[] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
AddToDiagonal(Int32[][], Decimal[], Decimal[][])
Declaration
public static decimal[][] AddToDiagonal(this int[][] a, decimal[] b, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | |
| System.Decimal[] | b | |
| System.Decimal[][] | result |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
AddToDiagonal(Int32[][], Decimal[], Double[][])
Declaration
public static double[][] AddToDiagonal(this int[][] a, decimal[] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | |
| System.Decimal[] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Int32[][], Decimal[], Int32[][])
Declaration
public static int[][] AddToDiagonal(this int[][] a, decimal[] b, int[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | |
| System.Decimal[] | b | |
| System.Int32[][] | result |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
AddToDiagonal(Int32[][], Double)
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static int[][] AddToDiagonal(this int[][] a, double b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | The scalar |
| System.Double | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
AddToDiagonal(Int32[][], Double, Double[][])
Declaration
public static double[][] AddToDiagonal(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[][] |
AddToDiagonal(Int32[][], Double, Int32[][])
Declaration
public static int[][] AddToDiagonal(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[][] |
AddToDiagonal(Int32[][], Double[])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static int[][] AddToDiagonal(this int[][] a, double[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | The scalar |
| System.Double[] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
AddToDiagonal(Int32[][], Double[], Double[][])
Declaration
public static double[][] AddToDiagonal(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[][] |
AddToDiagonal(Int32[][], Double[], Int32[][])
Declaration
public static int[][] AddToDiagonal(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[][] |
AddToDiagonal(Int32[][], Int16)
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static int[][] AddToDiagonal(this int[][] a, short b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | The scalar |
| System.Int16 | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
AddToDiagonal(Int32[][], Int16, Double[][])
Declaration
public static double[][] AddToDiagonal(this int[][] a, short b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | |
| System.Int16 | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Int32[][], Int16, Int16[][])
Declaration
public static short[][] AddToDiagonal(this int[][] a, short b, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | |
| System.Int16 | b | |
| System.Int16[][] | result |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
AddToDiagonal(Int32[][], Int16, Int32[][])
Declaration
public static int[][] AddToDiagonal(this int[][] a, short b, int[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | |
| System.Int16 | b | |
| System.Int32[][] | result |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
AddToDiagonal(Int32[][], Int16[])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static int[][] AddToDiagonal(this int[][] a, short[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | The scalar |
| System.Int16[] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
AddToDiagonal(Int32[][], Int16[], Double[][])
Declaration
public static double[][] AddToDiagonal(this int[][] a, short[] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | |
| System.Int16[] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Int32[][], Int16[], Int16[][])
Declaration
public static short[][] AddToDiagonal(this int[][] a, short[] b, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | |
| System.Int16[] | b | |
| System.Int16[][] | result |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
AddToDiagonal(Int32[][], Int16[], Int32[][])
Declaration
public static int[][] AddToDiagonal(this int[][] a, short[] b, int[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | |
| System.Int16[] | b | |
| System.Int32[][] | result |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
AddToDiagonal(Int32[][], Int32)
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static int[][] AddToDiagonal(this int[][] a, int b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | The scalar |
| System.Int32 | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
AddToDiagonal(Int32[][], Int32, Double[][])
Declaration
public static double[][] AddToDiagonal(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[][] |
AddToDiagonal(Int32[][], Int32, Int32[][])
Declaration
public static int[][] AddToDiagonal(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[][] |
AddToDiagonal(Int32[][], Int32[])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static int[][] AddToDiagonal(this int[][] a, int[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | The scalar |
| System.Int32[] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
AddToDiagonal(Int32[][], Int32[], Double[][])
Declaration
public static double[][] AddToDiagonal(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[][] |
AddToDiagonal(Int32[][], Int32[], Int32[][])
Declaration
public static int[][] AddToDiagonal(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[][] |
AddToDiagonal(Int32[][], Single)
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static int[][] AddToDiagonal(this int[][] a, float b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | The scalar |
| System.Single | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
AddToDiagonal(Int32[][], Single, Double[][])
Declaration
public static double[][] AddToDiagonal(this int[][] a, float b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | |
| System.Single | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Int32[][], Single, Int32[][])
Declaration
public static int[][] AddToDiagonal(this int[][] a, float b, int[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | |
| System.Single | b | |
| System.Int32[][] | result |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
AddToDiagonal(Int32[][], Single, Single[][])
Declaration
public static float[][] AddToDiagonal(this int[][] a, float b, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | |
| System.Single | b | |
| System.Single[][] | result |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
AddToDiagonal(Int32[][], Single[])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static int[][] AddToDiagonal(this int[][] a, float[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | The scalar |
| System.Single[] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
AddToDiagonal(Int32[][], Single[], Double[][])
Declaration
public static double[][] AddToDiagonal(this int[][] a, float[] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | |
| System.Single[] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Int32[][], Single[], Int32[][])
Declaration
public static int[][] AddToDiagonal(this int[][] a, float[] b, int[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | |
| System.Single[] | b | |
| System.Int32[][] | result |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
AddToDiagonal(Int32[][], Single[], Single[][])
Declaration
public static float[][] AddToDiagonal(this int[][] a, float[] b, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[][] | a | |
| System.Single[] | b | |
| System.Single[][] | result |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
AddToDiagonal(Int32[,], Byte)
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static int[, ] AddToDiagonal(this int[, ] a, byte b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | The scalar |
| System.Byte | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
AddToDiagonal(Int32[,], Byte, Byte[,])
Declaration
public static byte[, ] AddToDiagonal(this int[, ] a, byte b, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | |
| System.Byte | b | |
| System.Byte[,] | result |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
AddToDiagonal(Int32[,], Byte, Double[,])
Declaration
public static double[, ] AddToDiagonal(this int[, ] a, byte b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | |
| System.Byte | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Int32[,], Byte, Int32[,])
Declaration
public static int[, ] AddToDiagonal(this int[, ] a, byte b, int[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | |
| System.Byte | b | |
| System.Int32[,] | result |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
AddToDiagonal(Int32[,], Byte[])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static int[, ] AddToDiagonal(this int[, ] a, byte[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | The scalar |
| System.Byte[] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
AddToDiagonal(Int32[,], Byte[], Byte[,])
Declaration
public static byte[, ] AddToDiagonal(this int[, ] a, byte[] b, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | |
| System.Byte[] | b | |
| System.Byte[,] | result |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
AddToDiagonal(Int32[,], Byte[], Double[,])
Declaration
public static double[, ] AddToDiagonal(this int[, ] a, byte[] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | |
| System.Byte[] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Int32[,], Byte[], Int32[,])
Declaration
public static int[, ] AddToDiagonal(this int[, ] a, byte[] b, int[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | |
| System.Byte[] | b | |
| System.Int32[,] | result |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
AddToDiagonal(Int32[,], Decimal)
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static int[, ] AddToDiagonal(this int[, ] a, decimal b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | The scalar |
| System.Decimal | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
AddToDiagonal(Int32[,], Decimal, Decimal[,])
Declaration
public static decimal[, ] AddToDiagonal(this int[, ] a, decimal b, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | |
| System.Decimal | b | |
| System.Decimal[,] | result |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
AddToDiagonal(Int32[,], Decimal, Double[,])
Declaration
public static double[, ] AddToDiagonal(this int[, ] a, decimal b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | |
| System.Decimal | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Int32[,], Decimal, Int32[,])
Declaration
public static int[, ] AddToDiagonal(this int[, ] a, decimal b, int[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | |
| System.Decimal | b | |
| System.Int32[,] | result |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
AddToDiagonal(Int32[,], Decimal[])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static int[, ] AddToDiagonal(this int[, ] a, decimal[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | The scalar |
| System.Decimal[] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
AddToDiagonal(Int32[,], Decimal[], Decimal[,])
Declaration
public static decimal[, ] AddToDiagonal(this int[, ] a, decimal[] b, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | |
| System.Decimal[] | b | |
| System.Decimal[,] | result |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
AddToDiagonal(Int32[,], Decimal[], Double[,])
Declaration
public static double[, ] AddToDiagonal(this int[, ] a, decimal[] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | |
| System.Decimal[] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Int32[,], Decimal[], Int32[,])
Declaration
public static int[, ] AddToDiagonal(this int[, ] a, decimal[] b, int[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | |
| System.Decimal[] | b | |
| System.Int32[,] | result |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
AddToDiagonal(Int32[,], Double)
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static int[, ] AddToDiagonal(this int[, ] a, double b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | The scalar |
| System.Double | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
AddToDiagonal(Int32[,], Double, Double[,])
Declaration
public static double[, ] AddToDiagonal(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[,] |
AddToDiagonal(Int32[,], Double, Int32[,])
Declaration
public static int[, ] AddToDiagonal(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[,] |
AddToDiagonal(Int32[,], Double[])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static int[, ] AddToDiagonal(this int[, ] a, double[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | The scalar |
| System.Double[] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
AddToDiagonal(Int32[,], Double[], Double[,])
Declaration
public static double[, ] AddToDiagonal(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[,] |
AddToDiagonal(Int32[,], Double[], Int32[,])
Declaration
public static int[, ] AddToDiagonal(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[,] |
AddToDiagonal(Int32[,], Int16)
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static int[, ] AddToDiagonal(this int[, ] a, short b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | The scalar |
| System.Int16 | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
AddToDiagonal(Int32[,], Int16, Double[,])
Declaration
public static double[, ] AddToDiagonal(this int[, ] a, short b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | |
| System.Int16 | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Int32[,], Int16, Int16[,])
Declaration
public static short[, ] AddToDiagonal(this int[, ] a, short b, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | |
| System.Int16 | b | |
| System.Int16[,] | result |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
AddToDiagonal(Int32[,], Int16, Int32[,])
Declaration
public static int[, ] AddToDiagonal(this int[, ] a, short b, int[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | |
| System.Int16 | b | |
| System.Int32[,] | result |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
AddToDiagonal(Int32[,], Int16[])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static int[, ] AddToDiagonal(this int[, ] a, short[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | The scalar |
| System.Int16[] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
AddToDiagonal(Int32[,], Int16[], Double[,])
Declaration
public static double[, ] AddToDiagonal(this int[, ] a, short[] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | |
| System.Int16[] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Int32[,], Int16[], Int16[,])
Declaration
public static short[, ] AddToDiagonal(this int[, ] a, short[] b, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | |
| System.Int16[] | b | |
| System.Int16[,] | result |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
AddToDiagonal(Int32[,], Int16[], Int32[,])
Declaration
public static int[, ] AddToDiagonal(this int[, ] a, short[] b, int[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | |
| System.Int16[] | b | |
| System.Int32[,] | result |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
AddToDiagonal(Int32[,], Int32)
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static int[, ] AddToDiagonal(this int[, ] a, int b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | The scalar |
| System.Int32 | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
AddToDiagonal(Int32[,], Int32, Double[,])
Declaration
public static double[, ] AddToDiagonal(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[,] |
AddToDiagonal(Int32[,], Int32, Int32[,])
Declaration
public static int[, ] AddToDiagonal(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[,] |
AddToDiagonal(Int32[,], Int32[])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static int[, ] AddToDiagonal(this int[, ] a, int[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | The scalar |
| System.Int32[] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
AddToDiagonal(Int32[,], Int32[], Double[,])
Declaration
public static double[, ] AddToDiagonal(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[,] |
AddToDiagonal(Int32[,], Int32[], Int32[,])
Declaration
public static int[, ] AddToDiagonal(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[,] |
AddToDiagonal(Int32[,], Single)
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static int[, ] AddToDiagonal(this int[, ] a, float b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | The scalar |
| System.Single | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
AddToDiagonal(Int32[,], Single, Double[,])
Declaration
public static double[, ] AddToDiagonal(this int[, ] a, float b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | |
| System.Single | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Int32[,], Single, Int32[,])
Declaration
public static int[, ] AddToDiagonal(this int[, ] a, float b, int[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | |
| System.Single | b | |
| System.Int32[,] | result |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
AddToDiagonal(Int32[,], Single, Single[,])
Declaration
public static float[, ] AddToDiagonal(this int[, ] a, float b, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | |
| System.Single | b | |
| System.Single[,] | result |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
AddToDiagonal(Int32[,], Single[])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static int[, ] AddToDiagonal(this int[, ] a, float[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | The scalar |
| System.Single[] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
AddToDiagonal(Int32[,], Single[], Double[,])
Declaration
public static double[, ] AddToDiagonal(this int[, ] a, float[] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | |
| System.Single[] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Int32[,], Single[], Int32[,])
Declaration
public static int[, ] AddToDiagonal(this int[, ] a, float[] b, int[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | |
| System.Single[] | b | |
| System.Int32[,] | result |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
AddToDiagonal(Int32[,], Single[], Single[,])
Declaration
public static float[, ] AddToDiagonal(this int[, ] a, float[] b, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32[,] | a | |
| System.Single[] | b | |
| System.Single[,] | result |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
AddToDiagonal(Single, Byte[][])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static byte[][] AddToDiagonal(this float a, byte[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | The scalar |
| System.Byte[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
AddToDiagonal(Single, Byte[][], Byte[][])
Declaration
public static byte[][] AddToDiagonal(this float a, byte[][] b, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | |
| System.Byte[][] | b | |
| System.Byte[][] | result |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
AddToDiagonal(Single, Byte[][], Double[][])
Declaration
public static double[][] AddToDiagonal(this float a, byte[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | |
| System.Byte[][] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Single, Byte[][], Single[][])
Declaration
public static float[][] AddToDiagonal(this float a, byte[][] b, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | |
| System.Byte[][] | b | |
| System.Single[][] | result |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
AddToDiagonal(Single, Byte[,])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static byte[, ] AddToDiagonal(this float a, byte[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | The scalar |
| System.Byte[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
AddToDiagonal(Single, Byte[,], Byte[,])
Declaration
public static byte[, ] AddToDiagonal(this float a, byte[, ] b, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | |
| System.Byte[,] | b | |
| System.Byte[,] | result |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
AddToDiagonal(Single, Byte[,], Double[,])
Declaration
public static double[, ] AddToDiagonal(this float a, byte[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | |
| System.Byte[,] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Single, Byte[,], Single[,])
Declaration
public static float[, ] AddToDiagonal(this float a, byte[, ] b, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | |
| System.Byte[,] | b | |
| System.Single[,] | result |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
AddToDiagonal(Single, Decimal[][])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static decimal[][] AddToDiagonal(this float a, decimal[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | The scalar |
| System.Decimal[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
AddToDiagonal(Single, Decimal[][], Decimal[][])
Declaration
public static decimal[][] AddToDiagonal(this float a, decimal[][] b, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | |
| System.Decimal[][] | b | |
| System.Decimal[][] | result |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
AddToDiagonal(Single, Decimal[][], Double[][])
Declaration
public static double[][] AddToDiagonal(this float a, decimal[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | |
| System.Decimal[][] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Single, Decimal[][], Single[][])
Declaration
public static float[][] AddToDiagonal(this float a, decimal[][] b, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | |
| System.Decimal[][] | b | |
| System.Single[][] | result |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
AddToDiagonal(Single, Decimal[,])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static decimal[, ] AddToDiagonal(this float a, decimal[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | The scalar |
| System.Decimal[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
AddToDiagonal(Single, Decimal[,], Decimal[,])
Declaration
public static decimal[, ] AddToDiagonal(this float a, decimal[, ] b, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | |
| System.Decimal[,] | b | |
| System.Decimal[,] | result |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
AddToDiagonal(Single, Decimal[,], Double[,])
Declaration
public static double[, ] AddToDiagonal(this float a, decimal[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | |
| System.Decimal[,] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Single, Decimal[,], Single[,])
Declaration
public static float[, ] AddToDiagonal(this float a, decimal[, ] b, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | |
| System.Decimal[,] | b | |
| System.Single[,] | result |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
AddToDiagonal(Single, Double[][])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static double[][] AddToDiagonal(this float a, double[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | The scalar |
| System.Double[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Single, Double[][], Double[][])
Declaration
public static double[][] AddToDiagonal(this float a, double[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | |
| System.Double[][] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Single, Double[][], Single[][])
Declaration
public static float[][] AddToDiagonal(this float a, double[][] b, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | |
| System.Double[][] | b | |
| System.Single[][] | result |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
AddToDiagonal(Single, Double[,])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static double[, ] AddToDiagonal(this float a, double[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | The scalar |
| System.Double[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Single, Double[,], Double[,])
Declaration
public static double[, ] AddToDiagonal(this float a, double[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | |
| System.Double[,] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Single, Double[,], Single[,])
Declaration
public static float[, ] AddToDiagonal(this float a, double[, ] b, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | |
| System.Double[,] | b | |
| System.Single[,] | result |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
AddToDiagonal(Single, Int16[][])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static short[][] AddToDiagonal(this float a, short[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | The scalar |
| System.Int16[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
AddToDiagonal(Single, Int16[][], Double[][])
Declaration
public static double[][] AddToDiagonal(this float a, short[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | |
| System.Int16[][] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Single, Int16[][], Int16[][])
Declaration
public static short[][] AddToDiagonal(this float a, short[][] b, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | |
| System.Int16[][] | b | |
| System.Int16[][] | result |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
AddToDiagonal(Single, Int16[][], Single[][])
Declaration
public static float[][] AddToDiagonal(this float a, short[][] b, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | |
| System.Int16[][] | b | |
| System.Single[][] | result |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
AddToDiagonal(Single, Int16[,])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static short[, ] AddToDiagonal(this float a, short[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | The scalar |
| System.Int16[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
AddToDiagonal(Single, Int16[,], Double[,])
Declaration
public static double[, ] AddToDiagonal(this float a, short[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | |
| System.Int16[,] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Single, Int16[,], Int16[,])
Declaration
public static short[, ] AddToDiagonal(this float a, short[, ] b, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | |
| System.Int16[,] | b | |
| System.Int16[,] | result |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
AddToDiagonal(Single, Int16[,], Single[,])
Declaration
public static float[, ] AddToDiagonal(this float a, short[, ] b, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | |
| System.Int16[,] | b | |
| System.Single[,] | result |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
AddToDiagonal(Single, Int32[][])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static int[][] AddToDiagonal(this float a, int[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | The scalar |
| System.Int32[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
AddToDiagonal(Single, Int32[][], Double[][])
Declaration
public static double[][] AddToDiagonal(this float a, int[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | |
| System.Int32[][] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Single, Int32[][], Int32[][])
Declaration
public static int[][] AddToDiagonal(this float a, int[][] b, int[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | |
| System.Int32[][] | b | |
| System.Int32[][] | result |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
AddToDiagonal(Single, Int32[][], Single[][])
Declaration
public static float[][] AddToDiagonal(this float a, int[][] b, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | |
| System.Int32[][] | b | |
| System.Single[][] | result |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
AddToDiagonal(Single, Int32[,])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static int[, ] AddToDiagonal(this float a, int[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | The scalar |
| System.Int32[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
AddToDiagonal(Single, Int32[,], Double[,])
Declaration
public static double[, ] AddToDiagonal(this float a, int[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | |
| System.Int32[,] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Single, Int32[,], Int32[,])
Declaration
public static int[, ] AddToDiagonal(this float a, int[, ] b, int[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | |
| System.Int32[,] | b | |
| System.Int32[,] | result |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
AddToDiagonal(Single, Int32[,], Single[,])
Declaration
public static float[, ] AddToDiagonal(this float a, int[, ] b, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | |
| System.Int32[,] | b | |
| System.Single[,] | result |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
AddToDiagonal(Single, Single[][])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static float[][] AddToDiagonal(this float a, float[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | The scalar |
| System.Single[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
AddToDiagonal(Single, Single[][], Double[][])
Declaration
public static double[][] AddToDiagonal(this float a, float[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | |
| System.Single[][] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Single, Single[][], Single[][])
Declaration
public static float[][] AddToDiagonal(this float a, float[][] b, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | |
| System.Single[][] | b | |
| System.Single[][] | result |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
AddToDiagonal(Single, Single[,])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static float[, ] AddToDiagonal(this float a, float[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | The scalar |
| System.Single[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
AddToDiagonal(Single, Single[,], Double[,])
Declaration
public static double[, ] AddToDiagonal(this float a, float[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | |
| System.Single[,] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Single, Single[,], Single[,])
Declaration
public static float[, ] AddToDiagonal(this float a, float[, ] b, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | a | |
| System.Single[,] | b | |
| System.Single[,] | result |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
AddToDiagonal(Single[], Byte[][])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static byte[][] AddToDiagonal(this float[] a, byte[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The scalar |
| System.Byte[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
AddToDiagonal(Single[], Byte[][], Byte[][])
Declaration
public static byte[][] AddToDiagonal(this float[] a, byte[][] b, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | |
| System.Byte[][] | b | |
| System.Byte[][] | result |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
AddToDiagonal(Single[], Byte[][], Double[][])
Declaration
public static double[][] AddToDiagonal(this float[] a, byte[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | |
| System.Byte[][] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Single[], Byte[][], Single[][])
Declaration
public static float[][] AddToDiagonal(this float[] a, byte[][] b, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | |
| System.Byte[][] | b | |
| System.Single[][] | result |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
AddToDiagonal(Single[], Byte[,])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static byte[, ] AddToDiagonal(this float[] a, byte[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The scalar |
| System.Byte[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
AddToDiagonal(Single[], Byte[,], Byte[,])
Declaration
public static byte[, ] AddToDiagonal(this float[] a, byte[, ] b, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | |
| System.Byte[,] | b | |
| System.Byte[,] | result |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
AddToDiagonal(Single[], Byte[,], Double[,])
Declaration
public static double[, ] AddToDiagonal(this float[] a, byte[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | |
| System.Byte[,] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Single[], Byte[,], Single[,])
Declaration
public static float[, ] AddToDiagonal(this float[] a, byte[, ] b, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | |
| System.Byte[,] | b | |
| System.Single[,] | result |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
AddToDiagonal(Single[], Decimal[][])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static decimal[][] AddToDiagonal(this float[] a, decimal[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The scalar |
| System.Decimal[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
AddToDiagonal(Single[], Decimal[][], Decimal[][])
Declaration
public static decimal[][] AddToDiagonal(this float[] a, decimal[][] b, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | |
| System.Decimal[][] | b | |
| System.Decimal[][] | result |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
AddToDiagonal(Single[], Decimal[][], Double[][])
Declaration
public static double[][] AddToDiagonal(this float[] a, decimal[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | |
| System.Decimal[][] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Single[], Decimal[][], Single[][])
Declaration
public static float[][] AddToDiagonal(this float[] a, decimal[][] b, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | |
| System.Decimal[][] | b | |
| System.Single[][] | result |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
AddToDiagonal(Single[], Decimal[,])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static decimal[, ] AddToDiagonal(this float[] a, decimal[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The scalar |
| System.Decimal[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
AddToDiagonal(Single[], Decimal[,], Decimal[,])
Declaration
public static decimal[, ] AddToDiagonal(this float[] a, decimal[, ] b, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | |
| System.Decimal[,] | b | |
| System.Decimal[,] | result |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
AddToDiagonal(Single[], Decimal[,], Double[,])
Declaration
public static double[, ] AddToDiagonal(this float[] a, decimal[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | |
| System.Decimal[,] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Single[], Decimal[,], Single[,])
Declaration
public static float[, ] AddToDiagonal(this float[] a, decimal[, ] b, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | |
| System.Decimal[,] | b | |
| System.Single[,] | result |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
AddToDiagonal(Single[], Double[][])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static double[][] AddToDiagonal(this float[] a, double[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The scalar |
| System.Double[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Single[], Double[][], Double[][])
Declaration
public static double[][] AddToDiagonal(this float[] a, double[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | |
| System.Double[][] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Single[], Double[][], Single[][])
Declaration
public static float[][] AddToDiagonal(this float[] a, double[][] b, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | |
| System.Double[][] | b | |
| System.Single[][] | result |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
AddToDiagonal(Single[], Double[,])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static double[, ] AddToDiagonal(this float[] a, double[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The scalar |
| System.Double[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Single[], Double[,], Double[,])
Declaration
public static double[, ] AddToDiagonal(this float[] a, double[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | |
| System.Double[,] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Single[], Double[,], Single[,])
Declaration
public static float[, ] AddToDiagonal(this float[] a, double[, ] b, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | |
| System.Double[,] | b | |
| System.Single[,] | result |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
AddToDiagonal(Single[], Int16[][])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static short[][] AddToDiagonal(this float[] a, short[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The scalar |
| System.Int16[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
AddToDiagonal(Single[], Int16[][], Double[][])
Declaration
public static double[][] AddToDiagonal(this float[] a, short[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | |
| System.Int16[][] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Single[], Int16[][], Int16[][])
Declaration
public static short[][] AddToDiagonal(this float[] a, short[][] b, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | |
| System.Int16[][] | b | |
| System.Int16[][] | result |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
AddToDiagonal(Single[], Int16[][], Single[][])
Declaration
public static float[][] AddToDiagonal(this float[] a, short[][] b, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | |
| System.Int16[][] | b | |
| System.Single[][] | result |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
AddToDiagonal(Single[], Int16[,])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static short[, ] AddToDiagonal(this float[] a, short[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The scalar |
| System.Int16[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
AddToDiagonal(Single[], Int16[,], Double[,])
Declaration
public static double[, ] AddToDiagonal(this float[] a, short[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | |
| System.Int16[,] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Single[], Int16[,], Int16[,])
Declaration
public static short[, ] AddToDiagonal(this float[] a, short[, ] b, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | |
| System.Int16[,] | b | |
| System.Int16[,] | result |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
AddToDiagonal(Single[], Int16[,], Single[,])
Declaration
public static float[, ] AddToDiagonal(this float[] a, short[, ] b, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | |
| System.Int16[,] | b | |
| System.Single[,] | result |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
AddToDiagonal(Single[], Int32[][])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static int[][] AddToDiagonal(this float[] a, int[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The scalar |
| System.Int32[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
AddToDiagonal(Single[], Int32[][], Double[][])
Declaration
public static double[][] AddToDiagonal(this float[] a, int[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | |
| System.Int32[][] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Single[], Int32[][], Int32[][])
Declaration
public static int[][] AddToDiagonal(this float[] a, int[][] b, int[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | |
| System.Int32[][] | b | |
| System.Int32[][] | result |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
AddToDiagonal(Single[], Int32[][], Single[][])
Declaration
public static float[][] AddToDiagonal(this float[] a, int[][] b, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | |
| System.Int32[][] | b | |
| System.Single[][] | result |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
AddToDiagonal(Single[], Int32[,])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static int[, ] AddToDiagonal(this float[] a, int[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The scalar |
| System.Int32[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
AddToDiagonal(Single[], Int32[,], Double[,])
Declaration
public static double[, ] AddToDiagonal(this float[] a, int[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | |
| System.Int32[,] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Single[], Int32[,], Int32[,])
Declaration
public static int[, ] AddToDiagonal(this float[] a, int[, ] b, int[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | |
| System.Int32[,] | b | |
| System.Int32[,] | result |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
AddToDiagonal(Single[], Int32[,], Single[,])
Declaration
public static float[, ] AddToDiagonal(this float[] a, int[, ] b, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | |
| System.Int32[,] | b | |
| System.Single[,] | result |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
AddToDiagonal(Single[], Single[][])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static float[][] AddToDiagonal(this float[] a, float[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The scalar |
| System.Single[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
AddToDiagonal(Single[], Single[][], Double[][])
Declaration
public static double[][] AddToDiagonal(this float[] a, float[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | |
| System.Single[][] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Single[], Single[][], Single[][])
Declaration
public static float[][] AddToDiagonal(this float[] a, float[][] b, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | |
| System.Single[][] | b | |
| System.Single[][] | result |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
AddToDiagonal(Single[], Single[,])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static float[, ] AddToDiagonal(this float[] a, float[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | The scalar |
| System.Single[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
AddToDiagonal(Single[], Single[,], Double[,])
Declaration
public static double[, ] AddToDiagonal(this float[] a, float[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | |
| System.Single[,] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Single[], Single[,], Single[,])
Declaration
public static float[, ] AddToDiagonal(this float[] a, float[, ] b, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[] | a | |
| System.Single[,] | b | |
| System.Single[,] | result |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
AddToDiagonal(Single[][], Byte)
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static float[][] AddToDiagonal(this float[][] a, byte b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | The scalar |
| System.Byte | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
AddToDiagonal(Single[][], Byte, Byte[][])
Declaration
public static byte[][] AddToDiagonal(this float[][] a, byte b, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | |
| System.Byte | b | |
| System.Byte[][] | result |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
AddToDiagonal(Single[][], Byte, Double[][])
Declaration
public static double[][] AddToDiagonal(this float[][] a, byte b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | |
| System.Byte | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Single[][], Byte, Single[][])
Declaration
public static float[][] AddToDiagonal(this float[][] a, byte b, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | |
| System.Byte | b | |
| System.Single[][] | result |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
AddToDiagonal(Single[][], Byte[])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static float[][] AddToDiagonal(this float[][] a, byte[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | The scalar |
| System.Byte[] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
AddToDiagonal(Single[][], Byte[], Byte[][])
Declaration
public static byte[][] AddToDiagonal(this float[][] a, byte[] b, byte[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | |
| System.Byte[] | b | |
| System.Byte[][] | result |
Returns
| Type | Description |
|---|---|
| System.Byte[][] |
AddToDiagonal(Single[][], Byte[], Double[][])
Declaration
public static double[][] AddToDiagonal(this float[][] a, byte[] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | |
| System.Byte[] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Single[][], Byte[], Single[][])
Declaration
public static float[][] AddToDiagonal(this float[][] a, byte[] b, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | |
| System.Byte[] | b | |
| System.Single[][] | result |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
AddToDiagonal(Single[][], Decimal)
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static float[][] AddToDiagonal(this float[][] a, decimal b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | The scalar |
| System.Decimal | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
AddToDiagonal(Single[][], Decimal, Decimal[][])
Declaration
public static decimal[][] AddToDiagonal(this float[][] a, decimal b, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | |
| System.Decimal | b | |
| System.Decimal[][] | result |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
AddToDiagonal(Single[][], Decimal, Double[][])
Declaration
public static double[][] AddToDiagonal(this float[][] a, decimal b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | |
| System.Decimal | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Single[][], Decimal, Single[][])
Declaration
public static float[][] AddToDiagonal(this float[][] a, decimal b, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | |
| System.Decimal | b | |
| System.Single[][] | result |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
AddToDiagonal(Single[][], Decimal[])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static float[][] AddToDiagonal(this float[][] a, decimal[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | The scalar |
| System.Decimal[] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
AddToDiagonal(Single[][], Decimal[], Decimal[][])
Declaration
public static decimal[][] AddToDiagonal(this float[][] a, decimal[] b, decimal[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | |
| System.Decimal[] | b | |
| System.Decimal[][] | result |
Returns
| Type | Description |
|---|---|
| System.Decimal[][] |
AddToDiagonal(Single[][], Decimal[], Double[][])
Declaration
public static double[][] AddToDiagonal(this float[][] a, decimal[] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | |
| System.Decimal[] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Single[][], Decimal[], Single[][])
Declaration
public static float[][] AddToDiagonal(this float[][] a, decimal[] b, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | |
| System.Decimal[] | b | |
| System.Single[][] | result |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
AddToDiagonal(Single[][], Double)
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static float[][] AddToDiagonal(this float[][] a, double b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | The scalar |
| System.Double | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
AddToDiagonal(Single[][], Double, Double[][])
Declaration
public static double[][] AddToDiagonal(this float[][] a, double b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | |
| System.Double | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Single[][], Double, Single[][])
Declaration
public static float[][] AddToDiagonal(this float[][] a, double b, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | |
| System.Double | b | |
| System.Single[][] | result |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
AddToDiagonal(Single[][], Double[])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static float[][] AddToDiagonal(this float[][] a, double[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | The scalar |
| System.Double[] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
AddToDiagonal(Single[][], Double[], Double[][])
Declaration
public static double[][] AddToDiagonal(this float[][] a, double[] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | |
| System.Double[] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Single[][], Double[], Single[][])
Declaration
public static float[][] AddToDiagonal(this float[][] a, double[] b, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | |
| System.Double[] | b | |
| System.Single[][] | result |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
AddToDiagonal(Single[][], Int16)
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static float[][] AddToDiagonal(this float[][] a, short b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | The scalar |
| System.Int16 | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
AddToDiagonal(Single[][], Int16, Double[][])
Declaration
public static double[][] AddToDiagonal(this float[][] a, short b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | |
| System.Int16 | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Single[][], Int16, Int16[][])
Declaration
public static short[][] AddToDiagonal(this float[][] a, short b, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | |
| System.Int16 | b | |
| System.Int16[][] | result |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
AddToDiagonal(Single[][], Int16, Single[][])
Declaration
public static float[][] AddToDiagonal(this float[][] a, short b, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | |
| System.Int16 | b | |
| System.Single[][] | result |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
AddToDiagonal(Single[][], Int16[])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static float[][] AddToDiagonal(this float[][] a, short[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | The scalar |
| System.Int16[] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
AddToDiagonal(Single[][], Int16[], Double[][])
Declaration
public static double[][] AddToDiagonal(this float[][] a, short[] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | |
| System.Int16[] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Single[][], Int16[], Int16[][])
Declaration
public static short[][] AddToDiagonal(this float[][] a, short[] b, short[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | |
| System.Int16[] | b | |
| System.Int16[][] | result |
Returns
| Type | Description |
|---|---|
| System.Int16[][] |
AddToDiagonal(Single[][], Int16[], Single[][])
Declaration
public static float[][] AddToDiagonal(this float[][] a, short[] b, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | |
| System.Int16[] | b | |
| System.Single[][] | result |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
AddToDiagonal(Single[][], Int32)
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static float[][] AddToDiagonal(this float[][] a, int b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | The scalar |
| System.Int32 | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
AddToDiagonal(Single[][], Int32, Double[][])
Declaration
public static double[][] AddToDiagonal(this float[][] a, int b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | |
| System.Int32 | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Single[][], Int32, Int32[][])
Declaration
public static int[][] AddToDiagonal(this float[][] a, int b, int[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | |
| System.Int32 | b | |
| System.Int32[][] | result |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
AddToDiagonal(Single[][], Int32, Single[][])
Declaration
public static float[][] AddToDiagonal(this float[][] a, int b, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | |
| System.Int32 | b | |
| System.Single[][] | result |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
AddToDiagonal(Single[][], Int32[])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static float[][] AddToDiagonal(this float[][] a, int[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | The scalar |
| System.Int32[] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
AddToDiagonal(Single[][], Int32[], Double[][])
Declaration
public static double[][] AddToDiagonal(this float[][] a, int[] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | |
| System.Int32[] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Single[][], Int32[], Int32[][])
Declaration
public static int[][] AddToDiagonal(this float[][] a, int[] b, int[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | |
| System.Int32[] | b | |
| System.Int32[][] | result |
Returns
| Type | Description |
|---|---|
| System.Int32[][] |
AddToDiagonal(Single[][], Int32[], Single[][])
Declaration
public static float[][] AddToDiagonal(this float[][] a, int[] b, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | |
| System.Int32[] | b | |
| System.Single[][] | result |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
AddToDiagonal(Single[][], Single)
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static float[][] AddToDiagonal(this float[][] a, float b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | The scalar |
| System.Single | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
AddToDiagonal(Single[][], Single, Double[][])
Declaration
public static double[][] AddToDiagonal(this float[][] a, float b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | |
| System.Single | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Single[][], Single, Single[][])
Declaration
public static float[][] AddToDiagonal(this float[][] a, float b, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | |
| System.Single | b | |
| System.Single[][] | result |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
AddToDiagonal(Single[][], Single[])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static float[][] AddToDiagonal(this float[][] a, float[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | The scalar |
| System.Single[] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
AddToDiagonal(Single[][], Single[], Double[][])
Declaration
public static double[][] AddToDiagonal(this float[][] a, float[] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | |
| System.Single[] | b | |
| System.Double[][] | result |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
AddToDiagonal(Single[][], Single[], Single[][])
Declaration
public static float[][] AddToDiagonal(this float[][] a, float[] b, float[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[][] | a | |
| System.Single[] | b | |
| System.Single[][] | result |
Returns
| Type | Description |
|---|---|
| System.Single[][] |
AddToDiagonal(Single[,], Byte)
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static float[, ] AddToDiagonal(this float[, ] a, byte b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | The scalar |
| System.Byte | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
AddToDiagonal(Single[,], Byte, Byte[,])
Declaration
public static byte[, ] AddToDiagonal(this float[, ] a, byte b, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | |
| System.Byte | b | |
| System.Byte[,] | result |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
AddToDiagonal(Single[,], Byte, Double[,])
Declaration
public static double[, ] AddToDiagonal(this float[, ] a, byte b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | |
| System.Byte | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Single[,], Byte, Single[,])
Declaration
public static float[, ] AddToDiagonal(this float[, ] a, byte b, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | |
| System.Byte | b | |
| System.Single[,] | result |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
AddToDiagonal(Single[,], Byte[])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static float[, ] AddToDiagonal(this float[, ] a, byte[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | The scalar |
| System.Byte[] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
AddToDiagonal(Single[,], Byte[], Byte[,])
Declaration
public static byte[, ] AddToDiagonal(this float[, ] a, byte[] b, byte[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | |
| System.Byte[] | b | |
| System.Byte[,] | result |
Returns
| Type | Description |
|---|---|
| System.Byte[,] |
AddToDiagonal(Single[,], Byte[], Double[,])
Declaration
public static double[, ] AddToDiagonal(this float[, ] a, byte[] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | |
| System.Byte[] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Single[,], Byte[], Single[,])
Declaration
public static float[, ] AddToDiagonal(this float[, ] a, byte[] b, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | |
| System.Byte[] | b | |
| System.Single[,] | result |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
AddToDiagonal(Single[,], Decimal)
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static float[, ] AddToDiagonal(this float[, ] a, decimal b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | The scalar |
| System.Decimal | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
AddToDiagonal(Single[,], Decimal, Decimal[,])
Declaration
public static decimal[, ] AddToDiagonal(this float[, ] a, decimal b, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | |
| System.Decimal | b | |
| System.Decimal[,] | result |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
AddToDiagonal(Single[,], Decimal, Double[,])
Declaration
public static double[, ] AddToDiagonal(this float[, ] a, decimal b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | |
| System.Decimal | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Single[,], Decimal, Single[,])
Declaration
public static float[, ] AddToDiagonal(this float[, ] a, decimal b, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | |
| System.Decimal | b | |
| System.Single[,] | result |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
AddToDiagonal(Single[,], Decimal[])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static float[, ] AddToDiagonal(this float[, ] a, decimal[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | The scalar |
| System.Decimal[] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
AddToDiagonal(Single[,], Decimal[], Decimal[,])
Declaration
public static decimal[, ] AddToDiagonal(this float[, ] a, decimal[] b, decimal[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | |
| System.Decimal[] | b | |
| System.Decimal[,] | result |
Returns
| Type | Description |
|---|---|
| System.Decimal[,] |
AddToDiagonal(Single[,], Decimal[], Double[,])
Declaration
public static double[, ] AddToDiagonal(this float[, ] a, decimal[] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | |
| System.Decimal[] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Single[,], Decimal[], Single[,])
Declaration
public static float[, ] AddToDiagonal(this float[, ] a, decimal[] b, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | |
| System.Decimal[] | b | |
| System.Single[,] | result |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
AddToDiagonal(Single[,], Double)
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static float[, ] AddToDiagonal(this float[, ] a, double b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | The scalar |
| System.Double | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
AddToDiagonal(Single[,], Double, Double[,])
Declaration
public static double[, ] AddToDiagonal(this float[, ] a, double b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | |
| System.Double | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Single[,], Double, Single[,])
Declaration
public static float[, ] AddToDiagonal(this float[, ] a, double b, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | |
| System.Double | b | |
| System.Single[,] | result |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
AddToDiagonal(Single[,], Double[])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static float[, ] AddToDiagonal(this float[, ] a, double[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | The scalar |
| System.Double[] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
AddToDiagonal(Single[,], Double[], Double[,])
Declaration
public static double[, ] AddToDiagonal(this float[, ] a, double[] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | |
| System.Double[] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Single[,], Double[], Single[,])
Declaration
public static float[, ] AddToDiagonal(this float[, ] a, double[] b, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | |
| System.Double[] | b | |
| System.Single[,] | result |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
AddToDiagonal(Single[,], Int16)
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static float[, ] AddToDiagonal(this float[, ] a, short b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | The scalar |
| System.Int16 | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
AddToDiagonal(Single[,], Int16, Double[,])
Declaration
public static double[, ] AddToDiagonal(this float[, ] a, short b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | |
| System.Int16 | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Single[,], Int16, Int16[,])
Declaration
public static short[, ] AddToDiagonal(this float[, ] a, short b, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | |
| System.Int16 | b | |
| System.Int16[,] | result |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
AddToDiagonal(Single[,], Int16, Single[,])
Declaration
public static float[, ] AddToDiagonal(this float[, ] a, short b, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | |
| System.Int16 | b | |
| System.Single[,] | result |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
AddToDiagonal(Single[,], Int16[])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static float[, ] AddToDiagonal(this float[, ] a, short[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | The scalar |
| System.Int16[] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
AddToDiagonal(Single[,], Int16[], Double[,])
Declaration
public static double[, ] AddToDiagonal(this float[, ] a, short[] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | |
| System.Int16[] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Single[,], Int16[], Int16[,])
Declaration
public static short[, ] AddToDiagonal(this float[, ] a, short[] b, short[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | |
| System.Int16[] | b | |
| System.Int16[,] | result |
Returns
| Type | Description |
|---|---|
| System.Int16[,] |
AddToDiagonal(Single[,], Int16[], Single[,])
Declaration
public static float[, ] AddToDiagonal(this float[, ] a, short[] b, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | |
| System.Int16[] | b | |
| System.Single[,] | result |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
AddToDiagonal(Single[,], Int32)
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static float[, ] AddToDiagonal(this float[, ] a, int b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | The scalar |
| System.Int32 | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
AddToDiagonal(Single[,], Int32, Double[,])
Declaration
public static double[, ] AddToDiagonal(this float[, ] a, int b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | |
| System.Int32 | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Single[,], Int32, Int32[,])
Declaration
public static int[, ] AddToDiagonal(this float[, ] a, int b, int[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | |
| System.Int32 | b | |
| System.Int32[,] | result |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
AddToDiagonal(Single[,], Int32, Single[,])
Declaration
public static float[, ] AddToDiagonal(this float[, ] a, int b, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | |
| System.Int32 | b | |
| System.Single[,] | result |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
AddToDiagonal(Single[,], Int32[])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static float[, ] AddToDiagonal(this float[, ] a, int[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | The scalar |
| System.Int32[] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
AddToDiagonal(Single[,], Int32[], Double[,])
Declaration
public static double[, ] AddToDiagonal(this float[, ] a, int[] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | |
| System.Int32[] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Single[,], Int32[], Int32[,])
Declaration
public static int[, ] AddToDiagonal(this float[, ] a, int[] b, int[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | |
| System.Int32[] | b | |
| System.Int32[,] | result |
Returns
| Type | Description |
|---|---|
| System.Int32[,] |
AddToDiagonal(Single[,], Int32[], Single[,])
Declaration
public static float[, ] AddToDiagonal(this float[, ] a, int[] b, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | |
| System.Int32[] | b | |
| System.Single[,] | result |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
AddToDiagonal(Single[,], Single)
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static float[, ] AddToDiagonal(this float[, ] a, float b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | The scalar |
| System.Single | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
AddToDiagonal(Single[,], Single, Double[,])
Declaration
public static double[, ] AddToDiagonal(this float[, ] a, float b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | |
| System.Single | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Single[,], Single, Single[,])
Declaration
public static float[, ] AddToDiagonal(this float[, ] a, float b, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | |
| System.Single | b | |
| System.Single[,] | result |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
AddToDiagonal(Single[,], Single[])
Elementwise addition between a scalar a and to the main diagonal of matrix B.
Declaration
public static float[, ] AddToDiagonal(this float[, ] a, float[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | The scalar |
| System.Single[] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
AddToDiagonal(Single[,], Single[], Double[,])
Declaration
public static double[, ] AddToDiagonal(this float[, ] a, float[] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | |
| System.Single[] | b | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
AddToDiagonal(Single[,], Single[], Single[,])
Declaration
public static float[, ] AddToDiagonal(this float[, ] a, float[] b, float[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Single[,] | a | |
| System.Single[] | b | |
| System.Single[,] | result |
Returns
| Type | Description |
|---|---|
| System.Single[,] |
Divide(Double, Double[])
Elementwise division between a scalar a and a vector b.
Declaration
public static double[] Divide(this double a, double[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | The scalar |
| System.Double[] | b | The vector |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Divide(Double, Double[], Double[])
Elementwise division between a scalar a and a vectorb.
Declaration
public static double[] Divide(this double a, double[] b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | The scalar |
| System.Double[] | b | The vector |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Divide(Double, Double[][])
Elementwise division between a scalar a and a matrix B.
Declaration
public static double[][] Divide(this double a, double[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | The scalar |
| System.Double[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Divide(Double, Double[][], Double[][])
Elementwise division between a scalar a and a matrix B.
Declaration
public static double[][] Divide(this double a, double[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | The scalar |
| System.Double[][] | b | The matrix |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Divide(Double, Double[,])
Elementwise division between a scalar a and a matrix B.
Declaration
public static double[, ] Divide(this double a, double[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | The scalar |
| System.Double[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Divide(Double, Double[,], Double[,])
Elementwise division between a scalar a and a matrix b.
Declaration
public static double[, ] Divide(this double a, double[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | The scalar |
| System.Double[,] | b | The matrix |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Divide(Double[], Double)
Elementwise division between a vector a and a scalar b.
Declaration
public static double[] Divide(this double[] a, double b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The vector |
| System.Double | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Divide(Double[], Double, Double[])
Elementwise division between a vector a and a scalar b.
Declaration
public static double[] Divide(this double[] a, double b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The vector |
| System.Double | b | The scalar |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Divide(Double[], Double[])
Elementwise division between a vector a and a vector b.
Declaration
public static double[] Divide(this double[] a, double[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The vector |
| System.Double[] | b | The vector |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Divide(Double[], Double[], Double[])
Elementwise division between a vector a and a vectorb.
Declaration
public static double[] Divide(this double[] a, double[] b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The vector |
| System.Double[] | b | The vector |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Divide(Double[], Double[][], VectorType)
Elementwise division between a matrix A and a vectorb.
Declaration
public static double[][] Divide(this double[] a, double[][] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The vector |
| System.Double[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Divide(Double[], Double[][], VectorType, Double[][])
Elementwise division between a matrix A and a vectorb.
Declaration
public static double[][] Divide(this double[] a, double[][] b, VectorType dimension, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The vector |
| System.Double[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Divide(Double[], Double[,], VectorType)
Elementwise division between a matrix A and a vectorb.
Declaration
public static double[, ] Divide(this double[] a, double[, ] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The vector |
| System.Double[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Divide(Double[], Double[,], VectorType, Double[,])
Elementwise division between a matrix A and a vectorb.
Declaration
public static double[, ] Divide(this double[] a, double[, ] b, VectorType dimension, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The vector |
| System.Double[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Divide(Double[][], Double)
Elementwise division between a matrix A and a scalar b.
Declaration
public static double[][] Divide(this double[][] a, double b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | The matrix |
| System.Double | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Divide(Double[][], Double, Double[][])
Elementwise division between a matrix A and a scalar b.
Declaration
public static double[][] Divide(this double[][] a, double b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | The matrix |
| System.Double | b | The scalar |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Divide(Double[][], Double[], VectorType)
Elementwise division between a matrix A and a vectorb.
Declaration
public static double[][] Divide(this double[][] a, double[] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | The matrix |
| System.Double[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Divide(Double[][], Double[], VectorType, Double[][])
Elementwise division between a matrix A and a vectorb.
Declaration
public static double[][] Divide(this double[][] a, double[] b, VectorType dimension, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | The matrix |
| System.Double[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Divide(Double[][], Double[][])
Elementwise division between a matrix A and a matrix B.
Declaration
public static double[][] Divide(this double[][] a, double[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | The matrix |
| System.Double[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Divide(Double[][], Double[][], Double[][])
Elementwise division between a matrix A and a matrix B.
Declaration
public static double[][] Divide(this double[][] a, double[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | The matrix |
| System.Double[][] | b | The matrix |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Divide(Double[,], Double)
Elementwise division between a matrix A and a scalar b.
Declaration
public static double[, ] Divide(this double[, ] a, double b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | The matrix |
| System.Double | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Divide(Double[,], Double, Double[,])
Elementwise division between a matrix A and a scalar b.
Declaration
public static double[, ] Divide(this double[, ] a, double b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | The matrix |
| System.Double | b | The scalar |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Divide(Double[,], Double[], VectorType)
Elementwise division between a matrix A and a vectorb.
Declaration
public static double[, ] Divide(this double[, ] a, double[] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | The matrix |
| System.Double[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Divide(Double[,], Double[], VectorType, Double[,])
Elementwise division between a matrix A and a vectorb.
Declaration
public static double[, ] Divide(this double[, ] a, double[] b, VectorType dimension, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | The matrix |
| System.Double[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Divide(Double[,], Double[,])
Elementwise division between a matrix A and a matrix B.
Declaration
public static double[, ] Divide(this double[, ] a, double[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | The matrix |
| System.Double[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Divide(Double[,], Double[,], Double[,])
Elementwise division between a matrix A and a matrix B.
Declaration
public static double[, ] Divide(this double[, ] a, double[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | The matrix |
| System.Double[,] | b | The matrix |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
DivideByDiagonal(Double, Double[][])
Elementwise division between a scalar a and to the main diagonal of matrix B.
Declaration
public static double[][] DivideByDiagonal(this double a, double[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | The scalar |
| System.Double[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
DivideByDiagonal(Double, Double[][], Double[][])
Declaration
public static double[][] DivideByDiagonal(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[][] |
DivideByDiagonal(Double, Double[,])
Elementwise division between a scalar a and to the main diagonal of matrix B.
Declaration
public static double[, ] DivideByDiagonal(this double a, double[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | The scalar |
| System.Double[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
DivideByDiagonal(Double, Double[,], Double[,])
Declaration
public static double[, ] DivideByDiagonal(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[,] |
DivideByDiagonal(Double[], Double[][])
Elementwise division between a scalar a and to the main diagonal of matrix B.
Declaration
public static double[][] DivideByDiagonal(this double[] a, double[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The scalar |
| System.Double[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
DivideByDiagonal(Double[], Double[][], Double[][])
Declaration
public static double[][] DivideByDiagonal(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[][] |
DivideByDiagonal(Double[], Double[,])
Elementwise division between a scalar a and to the main diagonal of matrix B.
Declaration
public static double[, ] DivideByDiagonal(this double[] a, double[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The scalar |
| System.Double[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
DivideByDiagonal(Double[], Double[,], Double[,])
Declaration
public static double[, ] DivideByDiagonal(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[,] |
DivideByDiagonal(Double[][], Double)
Elementwise division between a scalar a and to the main diagonal of matrix B.
Declaration
public static double[][] DivideByDiagonal(this double[][] a, double b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | The scalar |
| System.Double | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
DivideByDiagonal(Double[][], Double, Double[][])
Declaration
public static double[][] DivideByDiagonal(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[][] |
DivideByDiagonal(Double[][], Double[])
Elementwise division between a scalar a and to the main diagonal of matrix B.
Declaration
public static double[][] DivideByDiagonal(this double[][] a, double[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | The scalar |
| System.Double[] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
DivideByDiagonal(Double[][], Double[], Double[][])
Declaration
public static double[][] DivideByDiagonal(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[][] |
DivideByDiagonal(Double[,], Double)
Elementwise division between a scalar a and to the main diagonal of matrix B.
Declaration
public static double[, ] DivideByDiagonal(this double[, ] a, double b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | The scalar |
| System.Double | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
DivideByDiagonal(Double[,], Double, Double[,])
Declaration
public static double[, ] DivideByDiagonal(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[,] |
DivideByDiagonal(Double[,], Double[])
Elementwise division between a scalar a and to the main diagonal of matrix B.
Declaration
public static double[, ] DivideByDiagonal(this double[, ] a, double[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | The scalar |
| System.Double[] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
DivideByDiagonal(Double[,], Double[], Double[,])
Declaration
public static double[, ] DivideByDiagonal(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[,] |
Equals(Double, Double[], Double, Double)
Determines whether two vectors contain the same values.
Declaration
public static bool[] Equals(Double a, Double[] b, Double atol = null, Double rtol = null)Parameters
| Type | Name | Description |
|---|---|---|
| Double | a | |
| Double[] | b | |
| Double | atol | |
| Double | rtol |
Returns
| Type | Description |
|---|---|
| System.Boolean[] |
Equals(Double, Double[][], Double, Double)
Determines whether two matrices contain the same values.
Declaration
public static bool[][] Equals(Double a, Double[][] b, Double atol = null, Double rtol = null)Parameters
| Type | Name | Description |
|---|---|---|
| Double | a | |
| Double[][] | b | |
| Double | atol | |
| Double | rtol |
Returns
| Type | Description |
|---|---|
| System.Boolean[][] |
Equals(Double, Double[,], Double, Double)
Determines whether two matrices contain the same values.
Declaration
public static bool[, ] Equals(Double a, Double[, ] b, Double atol = null, Double rtol = null)Parameters
| Type | Name | Description |
|---|---|---|
| Double | a | |
| Double[,] | b | |
| Double | atol | |
| Double | rtol |
Returns
| Type | Description |
|---|---|
| System.Boolean[,] |
Equals(Double[], Double, Double, Double)
Determines whether two vectors contain the same values.
Declaration
public static bool[] Equals(Double[] a, Double b, Double atol = null, Double rtol = null)Parameters
| Type | Name | Description |
|---|---|---|
| Double[] | a | |
| Double | b | |
| Double | atol | |
| Double | rtol |
Returns
| Type | Description |
|---|---|
| System.Boolean[] |
Equals(Double[], Double[], Double, Double)
Determines whether two vectors contain the same values.
Declaration
public static bool[] Equals(Double[] a, Double[] b, Double atol = null, Double rtol = null)Parameters
| Type | Name | Description |
|---|---|---|
| Double[] | a | |
| Double[] | b | |
| Double | atol | |
| Double | rtol |
Returns
| Type | Description |
|---|---|
| System.Boolean[] |
Equals(Double[][], Double, Double, Double)
Determines whether two matrices contain the same values.
Declaration
public static bool[][] Equals(Double[][] a, Double b, Double atol = null, Double rtol = null)Parameters
| Type | Name | Description |
|---|---|---|
| Double[][] | a | |
| Double | b | |
| Double | atol | |
| Double | rtol |
Returns
| Type | Description |
|---|---|
| System.Boolean[][] |
Equals(Double[][], Double[][], Double, Double)
Determines whether two matrices contain the same values.
Declaration
public static bool[][] Equals(Double[][] a, Double[][] b, Double atol = null, Double rtol = null)Parameters
| Type | Name | Description |
|---|---|---|
| Double[][] | a | |
| Double[][] | b | |
| Double | atol | |
| Double | rtol |
Returns
| Type | Description |
|---|---|
| System.Boolean[][] |
Equals(Double[][], Double[,], Double, Double)
Determines whether two matrices contain the same values.
Declaration
public static bool[][] Equals(Double[][] a, Double[, ] b, Double atol = null, Double rtol = null)Parameters
| Type | Name | Description |
|---|---|---|
| Double[][] | a | |
| Double[,] | b | |
| Double | atol | |
| Double | rtol |
Returns
| Type | Description |
|---|---|
| System.Boolean[][] |
Equals(Double[,], Double, Double, Double)
Determines whether two matrices contain the same values.
Declaration
public static bool[, ] Equals(Double[, ] a, Double b, Double atol = null, Double rtol = null)Parameters
| Type | Name | Description |
|---|---|---|
| Double[,] | a | |
| Double | b | |
| Double | atol | |
| Double | rtol |
Returns
| Type | Description |
|---|---|
| System.Boolean[,] |
Equals(Double[,], Double[][], Double, Double)
Determines whether two matrices contain the same values.
Declaration
public static bool[][] Equals(Double[, ] a, Double[][] b, Double atol = null, Double rtol = null)Parameters
| Type | Name | Description |
|---|---|---|
| Double[,] | a | |
| Double[][] | b | |
| Double | atol | |
| Double | rtol |
Returns
| Type | Description |
|---|---|
| System.Boolean[][] |
Equals(Double[,], Double[,], Double, Double)
Determines whether two matrices contain the same values.
Declaration
public static bool[, ] Equals(Double[, ] a, Double[, ] b, Double atol = null, Double rtol = null)Parameters
| Type | Name | Description |
|---|---|---|
| Double[,] | a | |
| Double[,] | b | |
| Double | atol | |
| Double | rtol |
Returns
| Type | Description |
|---|---|
| System.Boolean[,] |
Multiply(Double, Double[])
Elementwise multiplication (note: this is not a dot or matrix product) between a scalar a and a vector b.
Declaration
public static double[] Multiply(this double a, double[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | The scalar |
| System.Double[] | b | The vector |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Multiply(Double, Double[], Double[])
Elementwise multiplication (note: this is not a dot or matrix product) between a scalar a and a vectorb.
Declaration
public static double[] Multiply(this double a, double[] b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | The scalar |
| System.Double[] | b | The vector |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Multiply(Double, Double[][])
Elementwise multiplication (note: this is not a dot or matrix product) between a scalar a and a matrix B.
Declaration
public static double[][] Multiply(this double a, double[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | The scalar |
| System.Double[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Multiply(Double, Double[][], Double[][])
Elementwise multiplication (note: this is not a dot or matrix product) between a scalar a and a matrix B.
Declaration
public static double[][] Multiply(this double a, double[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | The scalar |
| System.Double[][] | b | The matrix |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Multiply(Double, Double[,])
Elementwise multiplication (note: this is not a dot or matrix product) between a scalar a and a matrix B.
Declaration
public static double[, ] Multiply(this double a, double[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | The scalar |
| System.Double[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Multiply(Double, Double[,], Double[,])
Elementwise multiplication (note: this is not a dot or matrix product) between a scalar a and a matrix b.
Declaration
public static double[, ] Multiply(this double a, double[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | The scalar |
| System.Double[,] | b | The matrix |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Multiply(Double[], Double)
Elementwise multiplication (note: this is not a dot or matrix product) between a vector a and a scalar b.
Declaration
public static double[] Multiply(this double[] a, double b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The vector |
| System.Double | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Multiply(Double[], Double, Double[])
Elementwise multiplication (note: this is not a dot or matrix product) between a vector a and a scalar b.
Declaration
public static double[] Multiply(this double[] a, double b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The vector |
| System.Double | b | The scalar |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Multiply(Double[], Double[])
Elementwise multiplication (note: this is not a dot or matrix product) between a vector a and a vector b.
Declaration
public static double[] Multiply(this double[] a, double[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The vector |
| System.Double[] | b | The vector |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Multiply(Double[], Double[], Double[])
Elementwise multiplication (note: this is not a dot or matrix product) between a vector a and a vectorb.
Declaration
public static double[] Multiply(this double[] a, double[] b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The vector |
| System.Double[] | b | The vector |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Multiply(Double[], Double[][], VectorType)
Elementwise multiplication (note: this is not a dot or matrix product) between a matrix A and a vectorb.
Declaration
public static double[][] Multiply(this double[] a, double[][] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The vector |
| System.Double[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Multiply(Double[], Double[][], VectorType, Double[][])
Elementwise multiplication (note: this is not a dot or matrix product) between a matrix A and a vectorb.
Declaration
public static double[][] Multiply(this double[] a, double[][] b, VectorType dimension, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The vector |
| System.Double[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Multiply(Double[], Double[,], VectorType)
Elementwise multiplication (note: this is not a dot or matrix product) between a matrix A and a vectorb.
Declaration
public static double[, ] Multiply(this double[] a, double[, ] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The vector |
| System.Double[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Multiply(Double[], Double[,], VectorType, Double[,])
Elementwise multiplication (note: this is not a dot or matrix product) between a matrix A and a vectorb.
Declaration
public static double[, ] Multiply(this double[] a, double[, ] b, VectorType dimension, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The vector |
| System.Double[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Multiply(Double[][], Double)
Elementwise multiplication (note: this is not a dot or matrix product) between a matrix A and a scalar b.
Declaration
public static double[][] Multiply(this double[][] a, double b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | The matrix |
| System.Double | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Multiply(Double[][], Double, Double[][])
Elementwise multiplication (note: this is not a dot or matrix product) between a matrix A and a scalar b.
Declaration
public static double[][] Multiply(this double[][] a, double b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | The matrix |
| System.Double | b | The scalar |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Multiply(Double[][], Double[], VectorType)
Elementwise multiplication (note: this is not a dot or matrix product) between a matrix A and a vectorb.
Declaration
public static double[][] Multiply(this double[][] a, double[] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | The matrix |
| System.Double[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Multiply(Double[][], Double[], VectorType, Double[][])
Elementwise multiplication (note: this is not a dot or matrix product) between a matrix A and a vectorb.
Declaration
public static double[][] Multiply(this double[][] a, double[] b, VectorType dimension, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | The matrix |
| System.Double[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Multiply(Double[][], Double[][])
Elementwise multiplication (note: this is not a dot or matrix product) between a matrix A and a matrix B.
Declaration
public static double[][] Multiply(this double[][] a, double[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | The matrix |
| System.Double[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Multiply(Double[][], Double[][], Double[][])
Elementwise multiplication (note: this is not a dot or matrix product) between a matrix A and a matrix B.
Declaration
public static double[][] Multiply(this double[][] a, double[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | The matrix |
| System.Double[][] | b | The matrix |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Multiply(Double[,], Double)
Elementwise multiplication (note: this is not a dot or matrix product) between a matrix A and a scalar b.
Declaration
public static double[, ] Multiply(this double[, ] a, double b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | The matrix |
| System.Double | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Multiply(Double[,], Double, Double[,])
Elementwise multiplication (note: this is not a dot or matrix product) between a matrix A and a scalar b.
Declaration
public static double[, ] Multiply(this double[, ] a, double b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | The matrix |
| System.Double | b | The scalar |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Multiply(Double[,], Double[], VectorType)
Elementwise multiplication (note: this is not a dot or matrix product) between a matrix A and a vectorb.
Declaration
public static double[, ] Multiply(this double[, ] a, double[] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | The matrix |
| System.Double[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Multiply(Double[,], Double[], VectorType, Double[,])
Elementwise multiplication (note: this is not a dot or matrix product) between a matrix A and a vectorb.
Declaration
public static double[, ] Multiply(this double[, ] a, double[] b, VectorType dimension, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | The matrix |
| System.Double[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Multiply(Double[,], Double[,])
Elementwise multiplication (note: this is not a dot or matrix product) between a matrix A and a matrix B.
Declaration
public static double[, ] Multiply(this double[, ] a, double[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | The matrix |
| System.Double[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Multiply(Double[,], Double[,], Double[,])
Elementwise multiplication (note: this is not a dot or matrix product) between a matrix A and a matrix B.
Declaration
public static double[, ] Multiply(this double[, ] a, double[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | The matrix |
| System.Double[,] | b | The matrix |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
MultiplyAndAdd(Double[][], Double, Double[][], Double[][])
Multiplies a matrix A with a scalar b and accumulates with c.
Declaration
public static double[][] MultiplyAndAdd(this double[][] a, double b, double[][] c, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | The matrix |
| System.Double | b | The scalar |
| System.Double[][] | c | The matrix |
| System.Double[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
MultiplyAndAdd(Double[,], Double, Double[,], Double[,])
Multiplies a matrix A with a scalar b and accumulates with c.
Declaration
public static double[, ] MultiplyAndAdd(this double[, ] a, double b, double[, ] c, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | The matrix |
| System.Double | b | The scalar |
| System.Double[,] | c | The matrix |
| System.Double[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
MultiplyWithDiagonal(Double, Double[][])
Elementwise multiplication (note: this is not a dot or matrix product) between a scalar a and to the main diagonal of matrix B.
Declaration
public static double[][] MultiplyWithDiagonal(this double a, double[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | The scalar |
| System.Double[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
MultiplyWithDiagonal(Double, Double[][], Double[][])
Declaration
public static double[][] MultiplyWithDiagonal(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[][] |
MultiplyWithDiagonal(Double, Double[,])
Elementwise multiplication (note: this is not a dot or matrix product) between a scalar a and to the main diagonal of matrix B.
Declaration
public static double[, ] MultiplyWithDiagonal(this double a, double[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | The scalar |
| System.Double[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
MultiplyWithDiagonal(Double, Double[,], Double[,])
Declaration
public static double[, ] MultiplyWithDiagonal(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[,] |
MultiplyWithDiagonal(Double[], Double[][])
Elementwise multiplication (note: this is not a dot or matrix product) between a scalar a and to the main diagonal of matrix B.
Declaration
public static double[][] MultiplyWithDiagonal(this double[] a, double[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The scalar |
| System.Double[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
MultiplyWithDiagonal(Double[], Double[][], Double[][])
Declaration
public static double[][] MultiplyWithDiagonal(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[][] |
MultiplyWithDiagonal(Double[], Double[,])
Elementwise multiplication (note: this is not a dot or matrix product) between a scalar a and to the main diagonal of matrix B.
Declaration
public static double[, ] MultiplyWithDiagonal(this double[] a, double[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The scalar |
| System.Double[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
MultiplyWithDiagonal(Double[], Double[,], Double[,])
Declaration
public static double[, ] MultiplyWithDiagonal(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[,] |
MultiplyWithDiagonal(Double[][], Double)
Elementwise multiplication (note: this is not a dot or matrix product) between a scalar a and to the main diagonal of matrix B.
Declaration
public static double[][] MultiplyWithDiagonal(this double[][] a, double b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | The scalar |
| System.Double | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
MultiplyWithDiagonal(Double[][], Double, Double[][])
Declaration
public static double[][] MultiplyWithDiagonal(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[][] |
MultiplyWithDiagonal(Double[][], Double[])
Elementwise multiplication (note: this is not a dot or matrix product) between a scalar a and to the main diagonal of matrix B.
Declaration
public static double[][] MultiplyWithDiagonal(this double[][] a, double[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | The scalar |
| System.Double[] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
MultiplyWithDiagonal(Double[][], Double[], Double[][])
Declaration
public static double[][] MultiplyWithDiagonal(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[][] |
MultiplyWithDiagonal(Double[,], Double)
Elementwise multiplication (note: this is not a dot or matrix product) between a scalar a and to the main diagonal of matrix B.
Declaration
public static double[, ] MultiplyWithDiagonal(this double[, ] a, double b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | The scalar |
| System.Double | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
MultiplyWithDiagonal(Double[,], Double, Double[,])
Declaration
public static double[, ] MultiplyWithDiagonal(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[,] |
MultiplyWithDiagonal(Double[,], Double[])
Elementwise multiplication (note: this is not a dot or matrix product) between a scalar a and to the main diagonal of matrix B.
Declaration
public static double[, ] MultiplyWithDiagonal(this double[, ] a, double[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | The scalar |
| System.Double[] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
MultiplyWithDiagonal(Double[,], Double[], Double[,])
Declaration
public static double[, ] MultiplyWithDiagonal(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[,] |
Pow(Double[], Double)
Elementwise power.
Declaration
public static double[] Pow(this double[] value, double y)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | value | A matrix. |
| System.Double | y | A power. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Pow(Double[], Double, Double[])
Elementwise power.
Declaration
public static double[] Pow(this double[] value, double y, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | value | A matrix. |
| System.Double | y | A power. |
| System.Double[] | result | The vector where the result should be stored. Pass the same
vector as |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Sqrt(Double[])
Elementwise square-root.
Declaration
public static double[] Sqrt(this double[] value)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | value |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Sqrt(Double[], Double[])
Elementwise square-root.
Declaration
public static double[] Sqrt(this double[] value, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | value | A matrix. |
| System.Double[] | result | The vector where the result should be stored. Pass the same
vector as |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Sqrt(Double[][])
Elementwise square-root.
Declaration
public static double[][] Sqrt(this double[][] value)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | value |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Sqrt(Double[][], Double[][])
Elementwise square-root.
Declaration
public static double[][] Sqrt(this double[][] value, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | value | A matrix. |
| System.Double[][] | result | The vector where the result should be stored. Pass the same
vector as |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Sqrt(Double[,])
Elementwise square-root.
Declaration
public static double[, ] Sqrt(this double[, ] value)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | value |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Sqrt(Double[,], Double[,])
Elementwise square-root.
Declaration
public static double[, ] Sqrt(this double[, ] value, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | value | A matrix. |
| System.Double[,] | result | The vector where the result should be stored. Pass the same
vector as |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Subtract(Double, Double[])
Elementwise subtraction between a scalar a and a vector b.
Declaration
public static double[] Subtract(this double a, double[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | The scalar |
| System.Double[] | b | The vector |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Subtract(Double, Double[], Double[])
Elementwise subtraction between a scalar a and a vectorb.
Declaration
public static double[] Subtract(this double a, double[] b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | The scalar |
| System.Double[] | b | The vector |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Subtract(Double, Double[][])
Elementwise subtraction between a scalar a and a matrix B.
Declaration
public static double[][] Subtract(this double a, double[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | The scalar |
| System.Double[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Subtract(Double, Double[][], Double[][])
Elementwise subtraction between a scalar a and a matrix B.
Declaration
public static double[][] Subtract(this double a, double[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | The scalar |
| System.Double[][] | b | The matrix |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Subtract(Double, Double[,])
Elementwise subtraction between a scalar a and a matrix B.
Declaration
public static double[, ] Subtract(this double a, double[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | The scalar |
| System.Double[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Subtract(Double, Double[,], Double[,])
Elementwise subtraction between a scalar a and a matrix b.
Declaration
public static double[, ] Subtract(this double a, double[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | The scalar |
| System.Double[,] | b | The matrix |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Subtract(Double[], Double)
Elementwise subtraction between a vector a and a scalar b.
Declaration
public static double[] Subtract(this double[] a, double b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The vector |
| System.Double | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Subtract(Double[], Double, Double[])
Elementwise subtraction between a vector a and a scalar b.
Declaration
public static double[] Subtract(this double[] a, double b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The vector |
| System.Double | b | The scalar |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Subtract(Double[], Double[])
Elementwise subtraction between a vector a and a vector b.
Declaration
public static double[] Subtract(this double[] a, double[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The vector |
| System.Double[] | b | The vector |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Subtract(Double[], Double[], Double[])
Elementwise subtraction between a vector a and a vectorb.
Declaration
public static double[] Subtract(this double[] a, double[] b, double[] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The vector |
| System.Double[] | b | The vector |
| System.Double[] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[] |
Subtract(Double[], Double[][], VectorType)
Elementwise subtraction between a matrix A and a vectorb.
Declaration
public static double[][] Subtract(this double[] a, double[][] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The vector |
| System.Double[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Subtract(Double[], Double[][], VectorType, Double[][])
Elementwise subtraction between a matrix A and a vectorb.
Declaration
public static double[][] Subtract(this double[] a, double[][] b, VectorType dimension, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The vector |
| System.Double[][] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Subtract(Double[], Double[,], VectorType)
Elementwise subtraction between a matrix A and a vectorb.
Declaration
public static double[, ] Subtract(this double[] a, double[, ] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The vector |
| System.Double[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Subtract(Double[], Double[,], VectorType, Double[,])
Elementwise subtraction between a matrix A and a vectorb.
Declaration
public static double[, ] Subtract(this double[] a, double[, ] b, VectorType dimension, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The vector |
| System.Double[,] | b | The matrix |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Subtract(Double[][], Double)
Elementwise subtraction between a matrix A and a scalar b.
Declaration
public static double[][] Subtract(this double[][] a, double b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | The matrix |
| System.Double | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Subtract(Double[][], Double, Double[][])
Elementwise subtraction between a matrix A and a scalar b.
Declaration
public static double[][] Subtract(this double[][] a, double b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | The matrix |
| System.Double | b | The scalar |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Subtract(Double[][], Double[], VectorType)
Elementwise subtraction between a matrix A and a vectorb.
Declaration
public static double[][] Subtract(this double[][] a, double[] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | The matrix |
| System.Double[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Subtract(Double[][], Double[], VectorType, Double[][])
Elementwise subtraction between a matrix A and a vectorb.
Declaration
public static double[][] Subtract(this double[][] a, double[] b, VectorType dimension, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | The matrix |
| System.Double[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[][] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Subtract(Double[][], Double[][])
Elementwise subtraction between a matrix A and a matrix B.
Declaration
public static double[][] Subtract(this double[][] a, double[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | The matrix |
| System.Double[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Subtract(Double[][], Double[][], Double[][])
Elementwise subtraction between a matrix A and a matrix B.
Declaration
public static double[][] Subtract(this double[][] a, double[][] b, double[][] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | The matrix |
| System.Double[][] | b | The matrix |
| System.Double[][] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
Subtract(Double[,], Double)
Elementwise subtraction between a matrix A and a scalar b.
Declaration
public static double[, ] Subtract(this double[, ] a, double b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | The matrix |
| System.Double | b | The scalar |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Subtract(Double[,], Double, Double[,])
Elementwise subtraction between a matrix A and a scalar b.
Declaration
public static double[, ] Subtract(this double[, ] a, double b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | The matrix |
| System.Double | b | The scalar |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Subtract(Double[,], Double[], VectorType)
Elementwise subtraction between a matrix A and a vectorb.
Declaration
public static double[, ] Subtract(this double[, ] a, double[] b, VectorType dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | The matrix |
| System.Double[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Subtract(Double[,], Double[], VectorType, Double[,])
Elementwise subtraction between a matrix A and a vectorb.
Declaration
public static double[, ] Subtract(this double[, ] a, double[] b, VectorType dimension, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | The matrix |
| System.Double[] | b | The vector |
| VectorType | dimension | The type of the vector being passed to the function. If the vector is a RowVector, then the operation will be applied between each row of the matrix and the given vector. If the vector is a ColumnVector, then the operation will be applied between each column of the matrix and the given vector. |
| System.Double[,] | result | The matrix where the result should be stored. Pass the same matrix as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Subtract(Double[,], Double[], Int32)
Obsolete. Please specify a VectorType in place of an integer in the dimension argument.
Declaration
public static double[, ] Subtract(this double[, ] a, double[] b, int dimension)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | |
| System.Double[] | b | |
| System.Int32 | dimension |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Subtract(Double[,], Double[], Int32, Double[,])
Obsolete. Please specify a VectorType in place of an integer in the dimension argument.
Declaration
public static double[, ] Subtract(this double[, ] a, double[] b, int dimension, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | |
| System.Double[] | b | |
| System.Int32 | dimension | |
| System.Double[,] | result |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Subtract(Double[,], Double[,])
Elementwise subtraction between a matrix A and a matrix B.
Declaration
public static double[, ] Subtract(this double[, ] a, double[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | The matrix |
| System.Double[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
Subtract(Double[,], Double[,], Double[,])
Elementwise subtraction between a matrix A and a matrix B.
Declaration
public static double[, ] Subtract(this double[, ] a, double[, ] b, double[, ] result)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | The matrix |
| System.Double[,] | b | The matrix |
| System.Double[,] | result | The vector where the result should be stored. Pass the same vector as one of the arguments to perform the operation in place. |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
SubtractFromDiagonal(Double, Double[][])
Elementwise subtraction between a scalar a and to the main diagonal of matrix B.
Declaration
public static double[][] SubtractFromDiagonal(this double a, double[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | The scalar |
| System.Double[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
SubtractFromDiagonal(Double, Double[][], Double[][])
Declaration
public static double[][] SubtractFromDiagonal(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[][] |
SubtractFromDiagonal(Double, Double[,])
Elementwise subtraction between a scalar a and to the main diagonal of matrix B.
Declaration
public static double[, ] SubtractFromDiagonal(this double a, double[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | a | The scalar |
| System.Double[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
SubtractFromDiagonal(Double, Double[,], Double[,])
Declaration
public static double[, ] SubtractFromDiagonal(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[,] |
SubtractFromDiagonal(Double[], Double[][])
Elementwise subtraction between a scalar a and to the main diagonal of matrix B.
Declaration
public static double[][] SubtractFromDiagonal(this double[] a, double[][] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The scalar |
| System.Double[][] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
SubtractFromDiagonal(Double[], Double[][], Double[][])
Declaration
public static double[][] SubtractFromDiagonal(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[][] |
SubtractFromDiagonal(Double[], Double[,])
Elementwise subtraction between a scalar a and to the main diagonal of matrix B.
Declaration
public static double[, ] SubtractFromDiagonal(this double[] a, double[, ] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[] | a | The scalar |
| System.Double[,] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
SubtractFromDiagonal(Double[], Double[,], Double[,])
Declaration
public static double[, ] SubtractFromDiagonal(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[,] |
SubtractFromDiagonal(Double[][], Double)
Elementwise subtraction between a scalar a and to the main diagonal of matrix B.
Declaration
public static double[][] SubtractFromDiagonal(this double[][] a, double b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | The scalar |
| System.Double | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
SubtractFromDiagonal(Double[][], Double, Double[][])
Declaration
public static double[][] SubtractFromDiagonal(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[][] |
SubtractFromDiagonal(Double[][], Double[])
Elementwise subtraction between a scalar a and to the main diagonal of matrix B.
Declaration
public static double[][] SubtractFromDiagonal(this double[][] a, double[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[][] | a | The scalar |
| System.Double[] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[][] |
SubtractFromDiagonal(Double[][], Double[], Double[][])
Declaration
public static double[][] SubtractFromDiagonal(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[][] |
SubtractFromDiagonal(Double[,], Double)
Elementwise subtraction between a scalar a and to the main diagonal of matrix B.
Declaration
public static double[, ] SubtractFromDiagonal(this double[, ] a, double b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | The scalar |
| System.Double | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
SubtractFromDiagonal(Double[,], Double, Double[,])
Declaration
public static double[, ] SubtractFromDiagonal(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[,] |
SubtractFromDiagonal(Double[,], Double[])
Elementwise subtraction between a scalar a and to the main diagonal of matrix B.
Declaration
public static double[, ] SubtractFromDiagonal(this double[, ] a, double[] b)Parameters
| Type | Name | Description |
|---|---|---|
| System.Double[,] | a | The scalar |
| System.Double[] | b | The matrix |
Returns
| Type | Description |
|---|---|
| System.Double[,] |
SubtractFromDiagonal(Double[,], Double[], Double[,])
Declaration
public static double[, ] SubtractFromDiagonal(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[,] |