GenericTensor

```cs public GenTensor GetSubtensor(params int[] indecies) ``` Allows to get a subtensor with SHARED data (so that any changes to intial tensor or the subtensor will be reflected in both). For example, Subtensor of a matrix is a vector (row). Works for O(1)

```cs public void SetSubtensor(GenTensor sub, params int[] indecies); ``` Allows to set a subtensor by forwarding all elements from sub to this. Override ConstantsAndFunctions.Forward to enable it. Works for O(V)

```cs public void Transpose(int axis1, int axis2); public void TransposeMatrix(); ``` Swaps axis1 and axis2 in this. TransposeMatrix swaps the last two axes. Works for O(1)

```cs public static GenTensor Concat(GenTensor a, GenTensor b); ``` Conatenates two tensors by their first axis. For example, concatenation of two tensors of shape [4 x 5 x 6] and [7 x 5 x 6] is a tensor of shape [11 x 5 x 6]. Works for O(N)

```cs public static GenTensor Stack(params GenTensor[] elements); ``` Unites all same-shape elements into one tensor with 1 dimension more. For example, if t1, t2, and t3 are of shape [2 x 5], Stack(t1, t2, t3) will return a tensor of shape [3 x 2 x 5] Works for O(V)

```cs public GenTensor Slice(int leftIncluding, int rightExcluding); ``` Slices this into another tensor with data-sharing. Syntax and use is similar to python's numpy: ```py v = myTensor[2:3] ``` is the same as ```cs var v = myTensor.Slice(2, 3); ``` Works for O(N)

```cs public byte[] Serialize(); public static GenTensor Deserialize(byte[] data); ``` Non-static Serialize() serializes given tensor into a byte array. It will call `TWrapper.Serialize(T a)`. Use this to store your tensor somewhere in file or database. Static Deserialize() provides the opposite to Serialize operation. It takes a byte array as an argument and returns the same tensor as it was before serialization. As it calls `TWrapper.Deserialize(byte[] data)`, it should be of the exact same type as it was before serialization.

```cs public static T VectorDotProduct(GenTensor a, GenTensor b); public static GenTensor TensorVectorDotProduct(GenTensor a, GenTensor b); ``` Counts dot product of two same-shaped vectors. For example, you have v1 = {2, 3, 4}, v2 = {5, 6, 7}, then VectorDotProduct(v1, v2) = 2 * 5 + 3 * 6 + 4 * 7 = 56. Works for O(V)

```cs public static GenTensor VectorCrossProduct(GenTensor a, GenTensor b); public static GenTensor TensorVectorCrossProduct(GenTensor a, GenTensor b); ``` Counts cross product of two same-shaped vectors. The resulting vector is such one that is perdendicular to all of the arguments. Works for O(V)

```cs public void RowMultiply(int rowId, T coef); public void RowAdd(int dstRowId, int srcRowId, T coef); public void RowSubtract(int dstRowId, int srcRowId, T coef); public void RowSwap(int row1Id, int row2Id) ``` Performs elementary row operations on a matrix. `this` must be a matrix (otherwise, an exception is thrown). The operations modify the matrix (without making copies). Works for O(N)

```cs public GenTensor RowEchelonFormSimple(); public GenTensor RowEchelonFormSafeDivision(); public GenTensor RowEchelonFormLeadingOnesSimple(); public GenTensor RowEchelonFormLeadingOnesSafeDivision(); public GenTensor ReducedRowEchelonFormSimple(); public GenTensor ReducedRowEchelonFormSafeDivision(); ``` Finds the requested form of a matrix. Due to different definitions of row echelon forms, we provide both forms: the one with leading ones and the one with arbitrary leading elements. There is also reduced row echelon form. They are implemented via Gaussian elimination. Every of these three methods has two variants: Simple and SafeDivision. In SafeDivision it will postpone the actual division of numbers up to the end of the algorithm, while Simple will perform division immediately. SafeDivision provides a higher precision, but it requires a high upper/lower bound of a number, because while computing even simple matrices, it might exceed billions. Works for O(N^3)

```cs public static GenTensor MatrixMultiply(GenTensor a, GenTensor b, Threading threading = Threading.Single); public static GenTensor TensorMatrixMultiply(GenTensor a, GenTensor b, Threading threading = Threading.Single); ``` Performs matrix multiplication operation of two matrices. One's height should be the same as Another's width. MatrixMultiply for `Threading.Multi` performs parallel computations over the first axis, TensorMatrixMultiplyParallel performs parallel computations over matrices. Works for O(N^3)

```cs public T DeterminantLaplace(); public T DeterminantGaussianSafeDivision(); public T DeterminantGaussianSimple(); ``` Finds determinant of a square matrix. DeterminantLaplace is the simplest and true way to find determinant, but it is as slow as O(N!). Guassian elimination works for O(N^3) but might cause precision loss when dividing. If your type does not lose precision when being divided, use DeterminantGaussianSimple. Otherwise, for example, for int, use DeterminantGaussianSafeDivision. Works for O(N!), O(N^3)

```cs public void InvertMatrix(); public void TensorMatrixInvert(); ``` Inverts A to B such that A * B = I where I is identity matrix. Works for O(N^4)

```cs public GenTensor Adjoint(); ``` Returns an adjugate matrix. Works for O(N^4)

```cs public static GenTensor MatrixDivide(GenTensor a, GenTensor b); public static GenTensor TensorMatrixDivide(GenTensor a, GenTensor b) ``` Of A, B returns such C that A == C * B. Works for O(N^4)

```cs public static GenTensor MatrixPower(GenTensor m, int power); public static GenTensor TensorMatrixPower(GenTensor m, int power); ``` Finds the power of a matrix. Works for O(log(N) * N^3)

```cs public (GenTensor p, GenTensor l, GenTensor u) PluDecomposition() ``` Find PLU decomposition: matrices P, L, U such that for original matrix A: PA = LU. Works for O(n^3)

```cs public (GenTensor, GenTensor) LuDecomposition() ``` Find LU decomposition: matrices L, U such that for original matrix A: A = LU. Works for O(n^3)

```cs public static GenTensor PiecewiseAdd(GenTensor a, GenTensor b, Threading threading = Threading.Single); public static GenTensor PiecewiseSubtract(GenTensor a, GenTensor b, Threading threading = Threading.Single); public static GenTensor PiecewiseMultiply(GenTensor a, GenTensor b, Threading threading = Threading.Single); public static GenTensor PiecewiseDivide(GenTensor a, GenTensor b, Threading threading = Threading.Single); ``` Returns a tensor of an operation being applied to every matching pair so that Add is. Those with Parallel in its name are ran on multiple cores (via Parallel.For). ``` result[i, j, k...] = a[i, j, k...] + b[i, j, k...] ``` Works for O(V)

```cs public static GenTensor PiecewiseAdd(GenTensor a, T b, Threading threading = Threading.Single); public static GenTensor PiecewiseSubtract(GenTensor a, T b, Threading threading = Threading.Single); public static GenTensor PiecewiseSubtract(T a, GenTensor b, Threading threading = Threading.Single); public static GenTensor PiecewiseMultiply(GenTensor a, T b, Threading threading = Threading.Single); public static GenTensor PiecewiseDivide(GenTensor a, T b, Threading threading = Threading.Single); public static GenTensor PiecewiseDivide(T a, GenTensor b, Threading threading = Threading.Single); ``` Performs an operation on each of tensor's element and forwards them to the result You can set `threading: Threading.Auto` to let GT to determine whether it is better to use multi-threading or keep working at one core, or `threading: Threading.Multi` if you need multi-threading. Works for O(V)