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); }