public float RowStd(int row)
{
if (row >= GetRows())
{
Debug.Log("Accessing out of bounds.");
return(0f);
}
return(Eigen.RowStd(Ptr, row));
}
public float GetValue(int row, int col)
{
if (row >= GetRows() || col >= GetCols())
{
Debug.Log("Getting out of bounds at [" + row + ", " + col + "] in matrix " + ID + ".");
return(0f);
}
return(Eigen.GetValue(Ptr, row, col));
}
public void SetValue(int row, int col, float value)
{
if (row >= GetRows() || col >= GetCols())
{
Debug.Log("Setting out of bounds at [" + row + ", " + col + "] in matrix " + ID + ".");
return;
}
Eigen.SetValue(Ptr, row, col, value);
}
public float ColStd(int col)
{
if (col >= GetCols())
{
Debug.Log("Accessing out of bounds.");
return(0f);
}
return(Eigen.ColStd(Ptr, col));
}
//------------------------------------------------------------------------------
protected bool DoPCATest()
{
bool result = true;
// create a list of vectors for the suface;
List <Vectors> vcList = new List <Vectors>(leafCount);
for (int k = 0; k < leafCount; k++)
{
vcList.Add(_leafs[k].Sigma);
}
PCA calc = new PCA(vcList, vcList.Count);
Eigen e = calc.eigen;
_vnorm = calc.Norm;
_vnorm.normalize();
_tand = calc.dcent;
_eigenvec2 = e.GetEigenvector(1); _eigenvec2.normalize();
_eigenvec3 = e.GetEigenvector(2); _eigenvec3.normalize();
_rg._X = Math.Sqrt(Math.Abs(e.GetEigenvalue(0))); //TODO::Check if we need Abs here? or check for NaN
_rg._Y = Math.Sqrt(Math.Abs(e.GetEigenvalue(1)));
_rg._Z = Math.Sqrt(Math.Abs(e.GetEigenvalue(2)));
_rg._W = _rg._X / (_rg._X + _rg._Y + _rg._Z);
result = C.CONST.IS_NUM(_vnorm);
if (result)
{
result = C.CONST.IS_NUM(_tand);
}
if (result)
{
result = C.CONST.IS_NUM(_eigenvec2);
}
if (result)
{
result = C.CONST.IS_NUM(_eigenvec3);
}
if (result)
{
result = C.CONST.IS_NUM(_rg);
}
if (result != true)
{
// some thing gone wrong ?
// set values to default
_vnorm = new Vectors();
_eigenvec2 = new Vectors();
_eigenvec3 = new Vectors();
_rg = new Vectors();
_tand = 0.0d;
}
return(result);
}
public Matrix BlendAll(Matrix M, Matrix[] W, float[] w, int length)
{
System.IntPtr[] ptr = new System.IntPtr[length];
for (int i = 0; i < length; i++)
{
ptr[i] = W[i].Ptr;
}
Eigen.BlendAll(M.Ptr, ptr, w, length);
return(M);
}
public static Matrix Product(Matrix lhs, Matrix rhs, Matrix OUT)
{
if (lhs.GetCols() != rhs.GetRows())
{
Debug.Log("Incompatible Matrix dimensions.");
}
else
{
Eigen.Product(lhs.Ptr, rhs.Ptr, OUT.Ptr);
}
return(OUT);
}
public static Tensor Product(Tensor lhs, Tensor rhs, Tensor OUT)
{
if (lhs.GetCols() != rhs.GetRows())
{
Debug.Log("Incompatible tensor dimensions.");
}
else
{
Eigen.Product(lhs.Ptr, rhs.Ptr, OUT.Ptr);
}
return(OUT);
}
public void TestSortDescending()
{
Eigen evd = new Eigen(
new Vector(1, 3, 2),
new Vector(0, 0, 0),
new List<Vector>(new[] { new Vector(), new Vector(), new Vector() }),
new List<Vector>(new[] { new Vector(), new Vector(), new Vector() }));
evd.Sort(Eigen.SortOrder.Descending);
Assert.That(evd.RealEigenvalues[0], Is.EqualTo(3));
Assert.That(evd.RealEigenvalues[1], Is.EqualTo(2));
Assert.That(evd.RealEigenvalues[2], Is.EqualTo(1));
}
public void TestSortDescending()
{
Eigen evd = new Eigen(
new Vector(1, 3, 2),
new Vector(0, 0, 0),
new List <Vector>(new[] { new Vector(), new Vector(), new Vector() }),
new List <Vector>(new[] { new Vector(), new Vector(), new Vector() }));
evd.Sort(Eigen.SortOrder.Descending);
Assert.That(evd.RealEigenvalues[0], Is.EqualTo(3));
Assert.That(evd.RealEigenvalues[1], Is.EqualTo(2));
Assert.That(evd.RealEigenvalues[2], Is.EqualTo(1));
}
public Matrix Normalise(Matrix IN, Matrix mean, Matrix std, Matrix OUT)
{
if (IN.GetRows() != mean.GetRows() || IN.GetRows() != std.GetRows() || IN.GetCols() != mean.GetCols() || IN.GetCols() != std.GetCols())
{
Debug.Log("Incompatible dimensions for normalisation.");
return(IN);
}
else
{
Eigen.Normalise(IN.Ptr, mean.Ptr, std.Ptr, OUT.Ptr);
return(OUT);
}
}
public Matrix Blend(Matrix M, Matrix W, float w)
{
if (M.GetRows() != W.GetRows() || M.GetCols() != W.GetCols())
{
Debug.Log("Incompatible dimensions for blending.");
return(M);
}
else
{
Eigen.Blend(M.Ptr, W.Ptr, w);
return(M);
}
}
public Matrix Layer(Matrix IN, Matrix W, Matrix b, Matrix OUT)
{
if (IN.GetRows() != W.GetCols() || W.GetRows() != b.GetRows() || IN.GetCols() != b.GetCols())
{
Debug.Log("Incompatible dimensions for layer feed-forward.");
return(IN);
}
else
{
Eigen.Layer(IN.Ptr, W.Ptr, b.Ptr, OUT.Ptr);
return(OUT);
}
}
public Tensor Renormalise(Tensor IN, Tensor mean, Tensor std, Tensor OUT)
{
if (IN.GetRows() != mean.GetRows() || IN.GetRows() != std.GetRows() || IN.GetCols() != mean.GetCols() || IN.GetCols() != std.GetCols())
{
Debug.Log("Incompatible dimensions for renormalisation.");
return(IN);
}
else
{
Eigen.Renormalise(IN.Ptr, mean.Ptr, std.Ptr, OUT.Ptr);
return(OUT);
}
}
public Tensor Layer(Tensor IN, Tensor W, Tensor b, Tensor OUT)
{
if (IN.GetRows() != W.GetCols() || W.GetRows() != b.GetRows() || IN.GetCols() != b.GetCols())
{
Debug.Log("Incompatible dimensions for feed-forward.");
return(IN);
}
else
{
Eigen.Layer(IN.Ptr, W.Ptr, b.Ptr, OUT.Ptr);
return(OUT);
}
}
public Tensor Blend(Tensor T, Tensor W, float w)
{
if (T.GetRows() != W.GetRows() || T.GetCols() != W.GetCols())
{
Debug.Log("Incompatible dimensions for blending.");
return(T);
}
else
{
Eigen.Blend(T.Ptr, W.Ptr, w);
return(T);
}
}
//------------------------------------------------------------------------------
protected bool DoPCATest()
{
bool result = true;
PCA calc = new PCA(_pts, NumPts);
Eigen e = calc.eigen;
_vnorm = calc.Norm;
_vnorm.normalize();
_tand = calc.dcent;
_eigenvec2 = e.GetEigenvector(1); _eigenvec2.normalize();
_eigenvec3 = e.GetEigenvector(2); _eigenvec3.normalize();
_rg._X = Math.Sqrt(Math.Abs(e.GetEigenvalue(0))); //TODO::Check if we need Abs here? or check for NaN
_rg._Y = Math.Sqrt(Math.Abs(e.GetEigenvalue(1)));
_rg._Z = Math.Sqrt(Math.Abs(e.GetEigenvalue(2)));
_rg._W = _rg._X / (_rg._X + _rg._Y + _rg._Z);
result = C.CONST.IS_NUM(_vnorm);
if (result)
{
result = C.CONST.IS_NUM(_tand);
}
if (result)
{
result = C.CONST.IS_NUM(_eigenvec2);
}
if (result)
{
result = C.CONST.IS_NUM(_eigenvec3);
}
if (result)
{
result = C.CONST.IS_NUM(_rg);
}
if (result != true)
{
// some thing gone wrong ?
// set values to default
_vnorm = new Vectors();
_eigenvec2 = new Vectors();
_eigenvec3 = new Vectors();
_rg = new Vectors();
_tand = 0.0d;
}
return(result);
}
public void rotateTrajectory()
{
using (var cov = DoubleArray.From(new Double[, ] {
{ totalXX, totalXZ },
{ totalXZ, totalZZ }
}))
{
using (Eigen eigen = new Eigen(cov))
{
var V = eigen.V as DoubleArray;
var t = V * V.Transpose();
var u = V.Transpose() * V;
var newPoints = points.Select(p => new Point((p.x * V[0, 0] + p.z * V[0, 1]), (p.x * V[1, 0] + p.z * V[1, 1]), p.timeStamp)).ToList();
points = newPoints;
}
}
}
private void CalculateB()
{
if (!CanCalculateArbitrage())
{
return;
}
Eigen aE = new Eigen(m_a);
CMatrix aECVec = aE.Eigenvectors;
CVector aECVal = aE.Eigenvalues;
double aLambdaMax = aECVal[0].Real;
Vector aEVec = new Vector(aECVal.Length);
for (int i = 0; i < aECVal.Length; i++)
{
aEVec[i] = aECVec[i, 0].Real;
}
for (int i = 0; i < m_a.Rows; i++)
{
for (int j = 0; j < m_a.Cols; j++)
{
m_b[i, j] = aEVec[i] / aEVec[j];
//m_b[i, j] = (m_eigenValuesTest[i] / m_eigenValuesTest[j]);
}
}
Eigen bE = new Eigen(m_b);
CMatrix bECVec = bE.Eigenvectors;
CVector bECVal = bE.Eigenvalues;
double bLambdaMax = bECVal[0].Real;
Dispatcher.Invoke(() =>
{
ALambdaMax = Math.Round(aLambdaMax, 5);
BLambdaMax = Math.Round(bLambdaMax, 5);
});
}
public void Unit()
{
int rows = GetRows();
int cols = GetCols();
float magnitude = 0f;
for (int i = 0; i < rows; i++)
{
for (int j = 0; j < cols; j++)
{
float value = GetValue(i, j);
magnitude += value * value;
}
}
magnitude = Mathf.Sqrt(magnitude);
if (magnitude != 0f)
{
Eigen.Scale(Ptr, 1f / magnitude, Ptr);
}
}
public Ellipse(Trajectory trajectory)
{
Point center = trajectory.mean();
centerX = center.x;
centerY = center.z;
//Calculate area
DoubleArray covMatrix = trajectory.covariance();
Eigen eigen = new Eigen(covMatrix);
double chisquare_val = 2.4477;
DoubleArray eigenvalues = (DoubleArray)eigen.D;
a = chisquare_val * Math.Sqrt(eigenvalues.Max());
b = chisquare_val * Math.Sqrt(eigenvalues.Min());
//Calculate ellipse coordinate points
DoubleArray eigenvectors = (DoubleArray)eigen.V;
DoubleArray largestEigenvector = eigenvectors.Max(0);
DoubleArray smallestEigenvector = eigenvectors.Min(0);
angle = Math.Atan2(largestEigenvector[1], largestEigenvector[0]);
//This angle is between -pi and pi.
//Let's shift it such that the angle is between 0 and 2pi
if (angle < 0)
{
angle = angle + 2 * Math.PI;
}
area = Math.PI * a * b;
perimeter = Math.PI / 2 * Math.Sqrt(2 * a * a + 2 * b * b);
getEllipseSamplePoints(100);
covMatrix.Dispose();
eigenvalues.Dispose();
eigenvectors.Dispose();
largestEigenvector.Dispose();
smallestEigenvector.Dispose();
}
private void CalculateB()
{
if (!CanCalculateArbitrage()) return;
Eigen aE = new Eigen(m_a);
CMatrix aECVec = aE.Eigenvectors;
CVector aECVal = aE.Eigenvalues;
double aLambdaMax = aECVal[0].Real;
Vector aEVec = new Vector(aECVal.Length);
for (int i = 0; i < aECVal.Length; i++)
{
aEVec[i] = aECVec[i, 0].Real;
}
for (int i = 0; i < m_a.Rows; i++)
{
for (int j = 0; j < m_a.Cols; j++)
{
m_b[i, j] = aEVec[i] / aEVec[j];
//m_b[i, j] = (m_eigenValuesTest[i] / m_eigenValuesTest[j]);
}
}
Eigen bE = new Eigen(m_b);
CMatrix bECVec = bE.Eigenvectors;
CVector bECVal = bE.Eigenvalues;
double bLambdaMax = bECVal[0].Real;
Dispatcher.Invoke(() =>
{
ALambdaMax = Math.Round(aLambdaMax, 5);
BLambdaMax = Math.Round(bLambdaMax, 5);
});
}
/// <summary>
/// Compute a plane which best fits a series of input points.
/// </summary>
/// <param name="tPoints">The array of points to analyse.</param>
/// <param name="tWeights">The relative weightings to apply to each point.</param>
/// <returns>The plane of best fit.</returns>
public static Plane ComputeBestFit(Vector3[] tPoints, float[] tWeights)
{
Vector3 kOrigin = new Vector3();
float w = 1;
float wtotal = 0;
// Calculate the weighted center of all the points.
for (int i = 0, n = tPoints.Length; i < n; ++i)
{
w = 1;
if (tWeights != null)
w *= tWeights[i];
Vector3 p = tPoints[i];
kOrigin.X += p.X * w;
kOrigin.Y += p.Y * w;
kOrigin.Z += p.Z * w;
wtotal += w;
}
float recip = 1.0f / wtotal; // reciprocol of total weighting
kOrigin.X *= recip;
kOrigin.Y *= recip;
kOrigin.Z *= recip;
float fSumXX = 0;
float fSumXY = 0;
float fSumXZ = 0;
float fSumYY = 0;
float fSumYZ = 0;
float fSumZZ = 0;
//--
for (int i = 0, n = tPoints.Length; i < n; ++i)
{
w = 1;
if (tWeights != null)
w *= tWeights[i];
// Transform to center and apply vertex weighting.
Vector3 p = tPoints[i];
Vector3 kDiff = new Vector3(w * (p.X - kOrigin.X), w * (p.Y - kOrigin.Y), w * (p.Z - kOrigin.Z));
fSumXX += kDiff.X * kDiff.X; // sum of the squares of the differences.
fSumXY += kDiff.X * kDiff.Y; // sum of the squares of the differences.
fSumXZ += kDiff.X * kDiff.Z; // sum of the squares of the differences.
fSumYY += kDiff.Y * kDiff.Y;
fSumYZ += kDiff.Y * kDiff.Z;
fSumZZ += kDiff.Z * kDiff.Z;
}
//--
fSumXX *= recip;
fSumXY *= recip;
fSumXZ *= recip;
fSumYY *= recip;
fSumYZ *= recip;
fSumZZ *= recip;
// Setup an eigensolver.
Eigen kES = new Eigen();
kES.mElement[0, 0] = fSumXX;
kES.mElement[0, 1] = fSumXY;
kES.mElement[0, 2] = fSumXZ;
kES.mElement[1, 0] = fSumXY;
kES.mElement[1, 1] = fSumYY;
kES.mElement[1, 2] = fSumYZ;
kES.mElement[2, 0] = fSumXZ;
kES.mElement[2, 1] = fSumYZ;
kES.mElement[2, 2] = fSumZZ;
// compute eigenstuff, smallest eigenvalue is in last position
kES.DecrSortEigenStuff();
Vector3 kNormal = new Vector3();
kNormal.X = kES.mElement[0, 2];
kNormal.Y = kES.mElement[1, 2];
kNormal.Z = kES.mElement[2, 2];
// The minimum energy.
return new Plane(kNormal, 0 - Vector3.Dot(kNormal, kOrigin));
}
public Tensor SoftSign(Tensor T)
{
Eigen.SoftSign(T.Ptr);
return(T);
}
public void Convertor()
{
var eigen1 = new Eigen(matrix1);
var p1 = new Matrix();
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 3; j++)
{
p1[i, j] = eigen1.Eigenvectors[i, j].Real;
}
}
var y1 = Matrix.Multiply(Matrix.Multiply(p1.Inverse(), matrix1), p1);
var diagonalizing = new Matrix();
for (int i = 0; i < 3; i++)
{
diagonalizing[i, i] = 1 / Math.Sqrt(y1[i, i]);
}
var y2 = Matrix.Multiply(p1.Transpose(),Matrix.Multiply(matrix2,p1));
var z2 = Matrix.Multiply(Matrix.Multiply(diagonalizing.Transpose(), y2),diagonalizing);
var eigen2 = new Eigen(z2);
var eigen_vectors2 = new Matrix();
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 3; j++)
{
eigen_vectors2[i, j] = eigen2.Eigenvectors[i, j].Real;
}
}
var v2 = Matrix.Multiply(Matrix.Multiply(eigen_vectors2.Transpose(),z2), eigen_vectors2);
var new_means1 = Matrix.Multiply(eigen_vectors2,Matrix.Multiply(diagonalizing, Matrix.Multiply(p1.Transpose(), means1)));
var new_means2 = Matrix.Multiply(eigen_vectors2,Matrix.Multiply(Matrix.Multiply(diagonalizing, p1.Transpose()), means2));
PrintMatrix(y1, "y1");
PrintMatrix(y2, "y2");
PrintMatrix(z2, "z2");
PrintMatrix(v2, "v2");
eigen2 = new Eigen(matrix2);
var p2 = new Matrix();
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 3; j++)
{
p2[i, j] = eigen2.Eigenvectors[i, j].Real;
}
}
var y = Matrix.Multiply(Matrix.Multiply(p2.Inverse(), matrix2), p2);
var diagonalizing2 = new Matrix();
for (int i = 0; i < 3; i++)
{
diagonalizing2[i, i] = Math.Sqrt(y[i, i]);
}
var diagonalizing3 = new Matrix();
for (int i = 0; i < 3; i++)
{
diagonalizing3[i, i] = Math.Sqrt(y1[i, i]);
}
for (int i = 0; i < 200; i++)
{
var penBlue = new Pen(Color.Blue);
var penRed = new Pen(Color.Red);
var vector1 = GenerateGaussianVector(means1);
vector1 = Matrix.Multiply(p1, Matrix.Multiply(diagonalizing3, vector1));
var vector2 = GenerateGaussianVector(means2);
vector2 = Matrix.Multiply(p2, Matrix.Multiply(diagonalizing2, vector2));
// x1-x2 before
var g = pn_12before.CreateGraphics();
var point = new Point((int)(vector1[0] * 6 + 150), (int)(vector1[1] * 6 + 130));
var s = new System.Drawing.Size(2,2);
var circle = new Rectangle(point,s);
g.DrawRectangle(penBlue, circle);
point = new Point((int)(vector2[0] * 6 + 150), (int)(vector2[1] * 6 + 130));
circle = new Rectangle(point, s);
g.DrawRectangle(penRed, circle);
// x1-x3 before
g = pn_13before.CreateGraphics();
point = new Point((int)(vector1[0] * 6 + 150), (int)(vector1[2] * 6 + 130));
circle = new Rectangle(point, s);
g.DrawRectangle(penBlue, circle);
point = new Point((int)(vector2[0] * 6 + 150), (int)(vector2[2] * 6 + 130));
circle = new Rectangle(point, s);
g.DrawRectangle(penRed, circle);
// after
vector1 = GenerateGaussianVector(new_means1);
vector2 = GenerateGaussianVector(new_means2);
var eigen = new Eigen(v2);
var m = new Matrix();
for (int k = 0; k < 3; k++)
{
for (int j = 0; j < 3; j++)
{
m[k, j] = eigen.Eigenvectors[k, j].Real;
}
}
var result1 = Matrix.Multiply(Matrix.Multiply(m.Inverse(), v2), m);
var diagonal = new Matrix();
for (int k = 0; k < 3; k++)
diagonal[k, k] = 1 / Math.Sqrt(result1[k, k]);
vector2 = Matrix.Multiply(m, Matrix.Multiply(diagonal, vector2));
// x1-x2 after
g = pn_12after.CreateGraphics();
int scalar = 10;
point = new Point((int)(vector1[0] * scalar + 110), (int)(vector1[1] * scalar + 130));
circle = new Rectangle(point, s);
g.DrawRectangle(penBlue, circle);
point = new Point((int)(vector2[0] * scalar + 110), (int)(vector2[1] * scalar + 130));
circle = new Rectangle(point, s);
g.DrawRectangle(penRed, circle);
// x1-x3 after
g = pn_13after.CreateGraphics();
point = new Point((int)(vector1[0] * scalar + 110), (int)(vector1[2] * scalar + 130));
circle = new Rectangle(point, s);
g.DrawRectangle(penBlue, circle);
point = new Point((int)(vector2[0] * scalar + 110), (int)(vector2[2] * scalar + 130));
circle = new Rectangle(point, s);
g.DrawRectangle(penRed, circle);
}
}
public void Convertor()
{
#region Calculate v2 new means
var eigen1 = new Eigen(matrix1);
var p1 = new Matrix();
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 3; j++)
{
p1[i, j] = eigen1.Eigenvectors[i, j].Real;
}
}
var y1 = Matrix.Multiply(Matrix.Multiply(p1.Inverse(), matrix1), p1);
var diagonalizing = new Matrix();
for (int i = 0; i < 3; i++)
{
diagonalizing[i, i] = 1 / Math.Sqrt(y1[i, i]);
}
var y2 = Matrix.Multiply(p1.Transpose(), Matrix.Multiply(matrix2, p1));
var z2 = Matrix.Multiply(Matrix.Multiply(diagonalizing.Transpose(), y2), diagonalizing);
var eigen2 = new Eigen(z2);
var eigen_vectors2 = new Matrix();
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 3; j++)
{
eigen_vectors2[i, j] = eigen2.Eigenvectors[i, j].Real;
}
}
var v2 = Matrix.Multiply(Matrix.Multiply(eigen_vectors2.Transpose(), z2), eigen_vectors2);
new_means1 = Matrix.Multiply(eigen_vectors2, Matrix.Multiply(diagonalizing, Matrix.Multiply(p1.Transpose(), means1)));
new_means2 = Matrix.Multiply(eigen_vectors2, Matrix.Multiply(Matrix.Multiply(diagonalizing, p1.Transpose()), means2));
#endregion
#region generate 200 points
for (int i = 0; i < 200; i++)
{
var orig_vector1 = GenerateGaussianVector(means1);
var orig_vector2 = GenerateGaussianVector(means2);
var vector1 = AddCovariance(matrix1, orig_vector1);
var vector2 = AddCovariance(matrix2, orig_vector2);
//for (int j = 0; i < 3;j++ )
//{
// orig_vectors1[i, j] = orig_vector1[j];
// orig_vectors2[i, j] = orig_vector2[j];
//}
try
{
Draw(pn_12before, Color.Blue, vector1[0], vector1[1]);
Draw(pn_13before, Color.Blue, vector1[0], vector1[2]);
Draw(pn_12before, Color.Red, vector2[0], vector2[1]);
Draw(pn_13before, Color.Red, vector2[0], vector2[2]);
// after
//vector1 = ModifyVector(vector1, means1);
//vector2 = ModifyVector(vector2, means2);
vector1 = GenerateGaussianVector(new_means1);
vector2 = GenerateGaussianVector(new_means2);
vector2 = AddCovariance(z2, vector2);
Draw(pn_12after, Color.Blue, vector1[0], vector1[1]);
Draw(pn_13after, Color.Blue, vector1[0], vector1[2]);
Draw(pn_12after, Color.Red, vector2[0], vector2[1]);
Draw(pn_13after, Color.Red, vector2[0], vector2[2]);
}
catch(Exception)
{ }
}
#endregion
#region Calculate discreminant function
var E = new double[,]{{1,0,0},{0,1,0},{0,0,1}};
var identity = new Matrix(E);
DrawDiscreminant(pn_12before, matrix1, matrix2, means1, means2, 0, 1);
DrawDiscreminant(pn_13before, matrix1, matrix2, means1, means2, 0, 2);
DrawDiscreminant(pn_12after, identity, z2, new_means1, new_means2, 0, 1);
DrawDiscreminant(pn_13after, identity, z2, new_means1, new_means2, 0, 2);
#endregion
#region Test
var correct = 0;
var wrong = 0;
// Before
for(int i=0;i<200;i++)
{
var vector1 = GenerateGaussianVector(means1);
var vector2 = GenerateGaussianVector(means2);
vector1 = AddCovariance(matrix1, vector1);
vector2 = AddCovariance(matrix2, vector2);
if (1 == Test(matrix1, matrix2, means1, means2, vector1))
{
correct++;
}
else
{
wrong++;
}
if (2 == Test(matrix1, matrix2, means1, means2, vector2))
{
correct++;
}
else
{
wrong++;
}
}
txb_result.Text += "Before:\r\ncorrect: " + correct.ToString() + "\r\nwrong: " + wrong.ToString();
txb_result.Text += "\r\nAccuracy: " + (double)correct / (correct + wrong);
// After
correct = 0;
wrong = 0;
for(int i=0;i<200;i++)
{
var vector1 = GenerateGaussianVector(new_means1);
var vector2 = GenerateGaussianVector(new_means2);
vector2 = AddCovariance(v2, vector2);
if (1 == Test(identity, v2, new_means1, new_means2, vector1))
{
correct++;
}
else
{
wrong++;
}
if (2 == Test(identity, v2, new_means1, new_means2, vector2))
{
correct++;
}
else
{
wrong++;
}
}
txb_result.Text += "\r\nAfter:\r\ncorrect: " + correct.ToString() + "\r\nwrong: " + wrong.ToString();
txb_result.Text += "\r\nAccuracy: " + (double)correct / (correct + wrong);
#endregion
}
public Tensor(int rows, int cols)
{
Ptr = Eigen.Create(rows, cols);
Deleted = false;
}
public void SetZero()
{
Eigen.SetZero(Ptr);
}
public Tensor ELU(Tensor T)
{
Eigen.ELU(T.Ptr);
return(T);
}
public Tensor TanH(Tensor T)
{
Eigen.TanH(T.Ptr);
return(T);
}
public Tensor Sigmoid(Tensor T)
{
Eigen.Sigmoid(T.Ptr);
return(T);
}
public int GetRows()
{
return(Eigen.GetRows(Ptr));
}
public Tensor LogSoftMax(Tensor T)
{
Eigen.LogSoftMax(T.Ptr);
return(T);
}
public int GetCols()
{
return(Eigen.GetCols(Ptr));
}
public Tensor Exp(Tensor T)
{
Eigen.Exp(T.Ptr);
return(T);
}
public double[] AddCovariance(double[,] matrix, double[] vector)
{
var eigen = new Eigen(matrix);
var p = new Matrix();
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 3; j++)
{
p[i, j] = eigen.Eigenvectors[i, j].Real;
}
}
var y = Matrix.Multiply(Matrix.Multiply(p.Inverse(), matrix), p);
var diagonalizing = new Matrix();
for (int i = 0; i < 3; i++)
{
diagonalizing[i, i] = Math.Sqrt(y[i, i]);
}
return Matrix.Multiply(Matrix.Multiply(p, diagonalizing), vector);
}
