public static void Main(string[] args)
{
int row = 2;
int column = 3;
var matrix = new float[row, column];
for (int i = 0; i < row; i++)
{
for (int j = 0; j < column; j++)
{
matrix[i, j] = i + ((i + 1) * j);
}
}
var matrix_ = MatrixUtility.Transpose(matrix);
var matrix__ = MatrixUtility.Transpose(matrix_);
Console.WriteLine(matrix.ToPrintable());
Console.WriteLine(matrix_.ToPrintable());
Console.WriteLine(matrix__.ToPrintable());
var sum = MatrixUtility.Sum(matrix, matrix__);
Console.WriteLine(sum.ToPrintable());
var product = MatrixUtility.Multiply(matrix, matrix_);
Console.WriteLine(product.ToPrintable());
}
static void CalculateRegularization(Matrix <double> inputWeights, Matrix <double> hiddenLayerWeights, Matrix <double> inputs, double lambda, out Matrix <double> A3, out double regularization)
{
Matrix <double> temporaryInput = Matrix <double> .Build.DenseOfMatrix(inputs);
Matrix <double> A1 = temporaryInput.InsertColumn(0, Vector <double> .Build.Dense(inputs.RowCount, 1d));
Matrix <double> A2 = ActivationFunction(A1 * inputWeights.Transpose());
A3 = ActivationFunction(A2.InsertColumn(0, Vector <double> .Build.Dense(A2.RowCount, 1d)) * hiddenLayerWeights.Transpose());
regularization = lambda * MatrixUtility.SumOfSquaredMatrix(inputWeights, hiddenLayerWeights) / (2 * inputs.RowCount);
}
static Vector <double> CalculateGradientAndUnroll(Matrix <double> inputWeights, Matrix <double> hiddenLayerWeights, Matrix <double> desiredOutputs, double lambda, ref Matrix <double> thetaGrad1, ref Matrix <double> thetaGrad2)
{
Matrix <double> temporary = Matrix <double> .Build.DenseOfMatrix(inputWeights);
temporary.SetColumn(0, Vector <double> .Build.Dense(temporary.RowCount, 0d));
thetaGrad1 = thetaGrad1 / desiredOutputs.RowCount + lambda / desiredOutputs.RowCount * temporary;
temporary = Matrix <double> .Build.DenseOfMatrix(hiddenLayerWeights);
temporary.SetColumn(0, Vector <double> .Build.Dense(temporary.RowCount, 0d));
thetaGrad2 = thetaGrad2 / desiredOutputs.RowCount + lambda / desiredOutputs.RowCount * temporary;
Vector <double> unrolledGradient = MatrixUtility.UnrollMatrices(thetaGrad1, thetaGrad2);
return(unrolledGradient);
}
void HandleMatrices(ComputeRenderer[] renderers)
{
MatrixUtility.CalculateViewProjectionMatrices(camera, out V, out P, out VP);
Shader.SetGlobalMatrix("Ahoy_V", V);
Shader.SetGlobalMatrix("Ahoy_P", P);
Shader.SetGlobalMatrix("Ahoy_VP", VP);
renderers.ForEach(renderer =>
{
Matrix4x4 M, MV, MVP;
MatrixUtility.CalculateModelMatrices(
renderer.transform,
V,
VP,
out M,
out MV,
out MVP);
renderer.computeInstance.SetMatrix("Ahoy_M", M);
renderer.computeInstance.SetMatrix("Ahoy_MV", MV);
renderer.computeInstance.SetMatrix("Ahoy_MVP", MVP);
});
}
public static Matrix operator*(Matrix a, Matrix b)
{
return(new Matrix(MatrixUtility.MatrixProduct(a.Values, b.Values)));
}
public Matrix GetInverse()
{
return(new Matrix(MatrixUtility.MatrixInverse(Values)));
}
