void ITreeWalker.Visit(MatrixExpression expression)
{
var values = expression.Values;
var rows = values.Length;
var cols = rows > 0 ? values[0].Length : 0;
expression.Validate(this);
InsertMatrix(cols, rows, (i, j) => values[j][i].Accept(this));
}
/// <summary>
/// Visits a matrix expression - accepts all values.
/// </summary>
public virtual void Visit(MatrixExpression expression)
{
foreach (var row in expression.Values)
{
foreach (var value in row)
{
value.Accept(this);
}
}
}
public static double Nrm2(MatrixExpression a)
{
var i = a.Evaluate();
var r = Blas.nrm2(i.Length, i.Array, 0, 1);
if (a is not MatrixInput)
{
i.Dispose();
}
return(r);
}
void ITreeWalker.Visit(MatrixExpression expression)
{
expression.Validate(this);
foreach (var row in expression.Values)
{
foreach (var value in row)
{
value.Accept(this);
}
}
}
public static (int, int) Iamin(MatrixExpression a)
{
var i = a.Evaluate();
int r = Blas.iamin(i.Length, i.Array, 0, 1);
if (a is not MatrixInput)
{
i.Dispose();
}
int col = Math.DivRem(r, i.Rows, out int row);
return(row, col);
}
public static (matrix, matrix) SinCos(MatrixExpression a)
{
var sin = a.Evaluate();
if (a is MatrixInput)
{
sin = Copy(sin);
}
var cos = new matrix(sin.Rows, sin.Cols);
Vml.SinCos(sin.Length, sin.Array, sin.Array, cos.Array);
return(sin, cos);
}
public static (matrix, matrix) Modf(MatrixExpression a)
{
var tru = a.Evaluate();
if (a is MatrixInput)
{
tru = Copy(tru);
}
var rem = new matrix(tru.Rows, tru.Cols);
Vml.Modf(tru.Length, tru.Array, tru.Array, rem.Array);
return(tru, rem);
}
public static (matrix, vector) Eigens(MatrixExpression a)
{
var v = a.Evaluate();
if (v.Rows != v.Cols)
{
ThrowHelper.ThrowIncorrectDimensionsForOperation();
}
if (a is MatrixInput)
{
v = Copy(v);
}
var w = new vector(v.Rows);
ThrowHelper.Check(Lapack.syev(Layout.ColMajor, 'V', UpLoChar.Lower, v.Rows, v.Array, v.Rows, w.Array));
return(v, w);
}
void ITreeWalker.Visit(MatrixExpression expression)
{
var values = expression.Values;
var rows = values.Length;
var cols = rows > 0 ? values[0].Length : 0;
expression.Validate(this);
_operations.Add(new NewMatOperation(rows, cols));
for (var row = 0; row < rows; row++)
{
for (var col = 0; col < cols; col++)
{
var value = values[row][col];
value.Accept(this);
_operations.Add(new InitMatOperation(row, col));
}
}
}
void ITreeWalker.Visit(MatrixExpression expression)
{
Header("Expression/Matrix");
WriteLine("- Rows:");
_level++;
foreach (var row in expression.Values)
{
WriteLine("- Values:");
_level++;
foreach (var value in row)
{
WriteItem(value);
}
_level--;
}
_level--;
}
public static double Det(MatrixExpression a)
{
var m = a.Evaluate();
if (a is MatrixInput)
{
m = Copy(m);
}
var ipiv = Pool.Int.Rent(m.Rows);
ThrowHelper.Check(Lapack.getrf(Layout.ColMajor, m.Rows, m.Rows, m.Array, m.Rows, ipiv));
Pool.Int.Return(ipiv);
double r = m[0, 0];
for (int i = 1; i < m.Rows; i++)
{
r *= m[i, i];
}
m.Dispose();
return(-r);
}
public static MatrixExpression Mul(MatrixExpression a, MatrixExpression b) => new MatrixMul(a, b);
public static MatrixExpression Fmod(MatrixExpression a, MatrixExpression b) => new MatrixFmod(a, b);
public static MatrixExpression Atan2pi(MatrixExpression a, MatrixExpression b) => new MatrixAtan2pi(a, b);
public static MatrixExpression Remainder(MatrixExpression a, MatrixExpression b) => new MatrixRemainder(a, b);
public static MatrixExpression Lower(MatrixExpression a) => new MatrixLower(a);
public MatrixToVectorT(MatrixExpression a) => E = a;
public static MatrixExpression Pow(MatrixExpression a, MatrixExpression b) => new MatrixPow(a, b);
public static MatrixExpression NextAfter(MatrixExpression a, MatrixExpression b) => new MatrixNextAfter(a, b);
public static MatrixExpression Solve(MatrixExpression a, MatrixExpression b) => new MatrixSolve(a, b);
public static MatrixExpression Cholesky(MatrixExpression a) => new MatrixCholesky(a);
public static MatrixExpression Upper(MatrixExpression a) => new MatrixUpper(a);
public MatrixVectorMultiply(MatrixExpression m, VectorExpression v, double[]?reuse)
{
M = m;
V = v;
R = reuse;
}
public static MatrixExpression Div(MatrixExpression a, MatrixExpression b) => new MatrixDiv(a, b);
public VectorTMatrixMultiply(VectorTExpression vt, MatrixExpression m, double[]?reuse)
{
VT = vt;
M = m;
R = reuse;
}
public static MatrixExpression Hypot(MatrixExpression a, MatrixExpression b) => new MatrixHypot(a, b);
public static MatrixExpression Inverse(MatrixExpression a) => new MatrixInverse(a);
public static MatrixExpression LinearFrac(MatrixExpression a, MatrixExpression b, double scalea, double shifta, double scaleb, double shiftb) => new MatrixLinearFrac(a, b, scalea, shifta, scaleb, shiftb);
public static MatrixExpression LeastSquares(MatrixExpression a, MatrixExpression b) => new MatrixLeastSquares(a, b);
public static MatrixExpression MaxMag(MatrixExpression a, MatrixExpression b) => new MatrixMaxMag(a, b);
