public Matrix(params Vector <F>[] columns)
{
N = columns.Length;
var height = columns.First().Size;
for (int i = 1; i < N; ++i)
{
if (columns[i].Size != height)
{
throw new ArgumentException($"All columns must have the same length. The first column has length {height}, but column {i} has length {columns[i].Size}.");
}
}
var result = new MatrixRow <F> [columns.First().Size];
for (int j = 0; j < height; ++j)
{
var row = new F[N];
for (int i = 0; i < N; ++i)
{
row[i] = columns[i][j];
}
result[j] = new MatrixRow <F>(row);
}
Rows = result;
}
public Vector(MatrixRow <F> mr)
{
vector = new F[mr.Length];
for (int i = 0; i < mr.Length; ++i)
{
vector[i] = mr[i];
}
}
public Matrix <F> RemoveRow(int m)
{
var result = new MatrixRow <F> [M - 1];
for (int j = 0; j < M - 1; ++j)
{
result[j] = j < m ? this[j] : this[j + 1];
}
return(new Matrix <F>(result));
}
public MatrixRow <F> Add(MatrixRow <F> mr)
{
if (Length != mr.Length)
{
throw new ArgumentException("In order to add two rows, they must have the same length.");
}
var result = new F[Length];
for (int i = 0; i < Length; ++i)
{
result[i] = Data[i].Add(mr[i]);
}
return(new MatrixRow <F>(result));
}
public static Matrix <F> UnitMatrix(int dim)
{
var result = new MatrixRow <F> [dim];
for (int j = 0; j < dim; ++j)
{
var row = new F[dim];
for (int i = 0; i < dim; ++i)
{
row[i] = i == j ? new F().ONE : new F();
}
result[j] = new MatrixRow <F>(row);
}
return(new Matrix <F>(result));
}
public Matrix <F> Transpose()
{
var result = new MatrixRow <F> [N];
for (int i = 0; i < N; ++i)
{
var row = new F[M];
for (int j = 0; j < M; ++j)
{
row[j] = this[j][i];
}
result[i] = new MatrixRow <F>(row);
}
return(new Matrix <F>(result));
}
public static Matrix <F> operator *(F d, Matrix <F> m)
{
var result = new MatrixRow <F> [m.M];
for (int j = 0; j < m.M; ++j)
{
var row = new F[m.N];
for (int i = 0; i < m.N; ++i)
{
row[i] = m[j][i].Multiply(d);
}
result[j] = new MatrixRow <F>(row);
}
return(new Matrix <F>(result));
}
public LEMatrix Transpose()
{
var result = new MatrixRow[N];
for (int i = 0; i < N; ++i)
{
var row = new double[M];
for (int j = 0; j < M; ++j)
{
row[j] = this[j][i];
}
result[i] = new MatrixRow(row);
}
return(new LEMatrix(result));
}
public static LEMatrix UnitMatrix(int dim)
{
var result = new MatrixRow[dim];
for (int j = 0; j < dim; ++j)
{
var row = new double[dim];
for (int i = 0; i < dim; ++i)
{
row[i] = i == j ? 1 : 0;
}
result[j] = new MatrixRow(row);
}
return(new LEMatrix(result));
}
public static LEMatrix operator *(double d, LEMatrix m)
{
var result = new MatrixRow[m.M];
for (int j = 0; j < m.M; ++j)
{
var row = new double[m.N];
for (int i = 0; i < m.N; ++i)
{
row[i] = m[j][i] * d;
}
result[j] = new MatrixRow(row);
}
return(new LEMatrix(result));
}
public static Matrix <F> operator*(Matrix <F> m1, Matrix <F> m2)
{
if (m1.N != m2.M)
{
throw new ArgumentException("m1.N must equal m2.N.");
}
var result = new MatrixRow <F> [m1.M];
for (int j = 0; j < m1.M; ++j)
{
var row = new F[m2.N];
for (int i = 0; i < m2.N; ++i)
{
row[i] = m1[j].ToVector().Zip(m2.Column(i), (a, b) => (a, b)).Aggregate(new F(), (a, f) => a.Add(f.a.Multiply(f.b)));
}
result[j] = new MatrixRow <F>(row);
}
return(new Matrix <F>(result));
}
public static Matrix <F> operator -(Matrix <F> m1, Matrix <F> m2)
{
if (m1.M != m2.M || m1.N != m2.N)
{
throw new ArgumentException("In order to add to matrixes, they must have the same dimensions.");
}
var result = new MatrixRow <F> [m1.M];
for (int j = 0; j < m1.M; ++j)
{
var row = new F[m1.N];
for (int i = 0; i < m1.N; ++i)
{
row[i] = m1[j][i].Subtract(m2[j][i]);
}
result[j] = new MatrixRow <F>(row);
}
return(new Matrix <F>(result));
}
public static LEMatrix operator*(LEMatrix m1, LEMatrix m2)
{
if (m1.N != m2.M)
{
throw new ArgumentException("m1.N must equal m2.N.");
}
var result = new MatrixRow[m1.M];
for (int j = 0; j < m1.M; ++j)
{
var row = new double[m2.N];
for (int i = 0; i < m2.N; ++i)
{
row[i] = m1[j].ToLEVector().DotSum(m2.Column(i));
}
result[j] = new MatrixRow(row);
}
return(new LEMatrix(result));
}
public static LEMatrix operator -(LEMatrix m1, LEMatrix m2)
{
if (m1.M != m2.M || m1.N != m2.N)
{
throw new ArgumentException("In order to add to matrixes, they must have the same dimensions.");
}
var result = new MatrixRow[m1.M];
for (int j = 0; j < m1.M; ++j)
{
var row = new double[m1.N];
for (int i = 0; i < m1.N; ++i)
{
row[i] = m1[j][i] - m2[j][i];
}
result[j] = new MatrixRow(row);
}
return(new LEMatrix(result));
}
public Matrix(IEnumerable <F> values, int rows)
{
if (values.Count() % rows != 0)
{
throw new ArgumentException($"The number of values({values.Count()}) must be divisible by the number of rows({rows}).");
}
N = values.Count() / rows;
var result = new MatrixRow <F> [rows];
int j = -1;
int i = 0;
var row = new F[N];
foreach (var value in values)
{
row[i] = value;
if (++i >= N)
{
i -= N;
result[++j] = new MatrixRow <F>(row);
}
}
Rows = result;
}
