private static Vector <float> PointFToVector(PointF p) { float[] xy = new float[2]; xy[0] = p.X; xy[1] = p.Y; return(CreateVector.DenseOfArray(xy)); }
public double[,] SortRank(double[,] orgRanks) { Matrix <double> matRanks = CreateMatrix.DenseOfArray(orgRanks); double[] projects = matRanks.Column(0).ToArray(); double[] ranks = matRanks.Column(1).ToArray(); Array.Sort(ranks, projects, Comparer <double> .Create((a, b) => { if (a == 0 && b != 0) { return(1); } if (a != 0 && b == 0) { return(-1); } if (a > b) { return(1); } if (a < b) { return(-1); } return(0); })); matRanks.SetColumn(0, CreateVector.DenseOfArray(projects)); matRanks.SetColumn(1, CreateVector.DenseOfArray(ranks)); return(matRanks.ToArray()); }
/// <summary> /// Runs through the network and makes a prediction. /// </summary> /// <param name="input">The input image to run the prediction on.</param> /// <returns>The values from the final layer. The largest value is the networks prediction.</returns> public double[] FeedForward(double[] input) { Matrix <double> _currentImages = CreateMatrix.DenseOfRowVectors(CreateVector.DenseOfArray <double>(input)); foreach (ILayerInformation _layerInformation in this.LayerInformation) { switch (_layerInformation.LayerType) { case (LayerType.Convolutional): ConvolutionalLayerInformation _convInfo = _layerInformation as ConvolutionalLayerInformation; _currentImages = this.Convolve(_convInfo, _currentImages); break; case (LayerType.Pooling): PoolingLayerInformation _poolInfo = _layerInformation as PoolingLayerInformation; _currentImages = this.Pool(_poolInfo, _currentImages); break; case (LayerType.NonLinear): NonLinearLayerInformation _nonLinearInfo = _layerInformation as NonLinearLayerInformation; _currentImages = this.NonLinear(_nonLinearInfo, _currentImages); break; } } double[] _fullyConnectedInput = CreateVector.DenseOfEnumerable <double>(_currentImages.EnumerateRows().SelectMany(a => a)).ToArray(); return(this.FullyConnectedNetwork.FeedForward(_currentImages.Enumerate().ToArray())); }
//Called after gathering training data public Vector <double>[] Solve(double[,] X, double[,] yArray) { //Solve matrix to generate weights for runtime calibration double[] y = new double[yArray.GetLength(0)]; Vector <double>[] theta = new Vector <double> [yArray.GetLength(1)]; //Process each collum one by one for (int i = 0; i < yArray.GetLength(1); i++) { //Clone raw data to manipulate double[,] Xclone = X.Clone() as double[, ]; //Disable channels not used for this solve Xclone = DisableChannels(Xclone, ActiveSensors, i); Matrix <double> XMatrix = CreateMatrix.DenseOfArray(Xclone); RemoveChannels temp = RemoveEmptyChannels(XMatrix); XMatrix = temp.ReducedMatrix; //Get a solution vector y = getCollumn(yArray, i); Matrix <double> tempMat = XMatrix; //Perform Regression fit Vector <double> yVector = CreateVector.DenseOfArray(y); theta[i] = MultipleRegression.Svd <double>(tempMat, yVector); //Add removed collumns theta[i] = PadArray(temp.usedCol, theta[i]); } return(theta); }
public void TrainingSet(double[,] x, int[] y) { if (x.GetUpperBound(0) + 1 < y.Length) { throw new Exception("You have more labels than training examples!"); } if (x.GetUpperBound(0) + 1 > y.Length) { throw new Exception("You have more training examples than labels!"); } int cv_size = (int)(0.2 * (x.GetUpperBound(0) + 1)); double[] _y = new double[y.Length - 2 * cv_size]; y = (int[])y.Clone(); X = CreateMatrix.DenseOfArray(x); Random r = new Random(); for (int i = 0; i < X.RowCount - 2; i++) { int j = r.Next(i, X.RowCount); var a = X.Row(i); var b = X.Row(j); X.SetRow(j, a); X.SetRow(i, b); int t = y[i]; y[i] = y[j]; y[j] = t; } CV = CreateMatrix.DenseOfRowVectors(X.Row(0)); X = X.RemoveRow(0); Test = CreateMatrix.DenseOfRowVectors(X.Row(0)); X = X.RemoveRow(0); for (int i = 0; i < cv_size - 1; i++) { CV = CV.InsertRow(i + 1, X.Row(0)); X = X.RemoveRow(0); Test = Test.InsertRow(i + 1, X.Row(0)); X = X.RemoveRow(0); } double[] _cvy = new double[cv_size]; double[] _testy = new double[cv_size]; for (int i = 0; i < 2 * cv_size; i++) { _cvy[i / 2] = y[i++]; _testy[i / 2] = y[i]; } for (int i = 2 * cv_size; i < y.Length; i++) { _y[i - 2 * cv_size] = y[i]; } Y = CreateVector.DenseOfArray(_y); CVY = CreateVector.DenseOfArray(_cvy); TestY = CreateVector.DenseOfArray(_testy); }
public int Predict(double[] x) { if (x.Length != Layers[0]) { throw new Exception("The input layer requires " + Layers[0] + " values. You gave " + x.Length + "."); } return(Predict(CreateVector.DenseOfArray(x))); }
Vector <double> CurrentStateVector() { float angularRotation = GetAngularRotationInRadians(); double[] newStateArray = { _rb.position.x, _rb.velocity.x, _rb.position.y, _rb.velocity.y, angularRotation, _rb.angularVelocity }; return(CreateVector.DenseOfArray <double>(newStateArray)); }
public static Vector <double> Normalize(byte[] data) { double[] ret = new double[data.Length]; for (int i = 0; i < ret.Length; i++) { ret[i] = data[i] / 255.0; } return(CreateVector.DenseOfArray <double>(ret)); }
public VectorBentimark() { vec1 = Enumerable.Range(0, size).Select(x => (float)x).ToArray(); vec2 = Enumerable.Range(0, size).Select(x => (float)x).ToArray(); this.v1 = CreateVector.DenseOfArray(vec1); this.v2 = CreateVector.DenseOfArray(vec2); this.mv1 = new Vector(vec1); this.mv2 = new Vector(vec2); }
public void feedForward(double[] pattern) { Neurons[0] = CreateVector.DenseOfArray(pattern); for (int l = 0, ln = Biases.Length; l < ln; l++) { Neurons[l + 1] = (Weights[l].LeftMultiply(Neurons[l])).Add(Biases[l]); Neurons[l + 1].MapInplace(Activations[l]); } }
public VerifyResult VerifyRank(double[,] initRanks, double[,] expAwards) { // init Matrix <double> matInitRanks = CreateMatrix.DenseOfArray(initRanks).Clone(); // make a copy so don't effect the original ranks Matrix <double> matExpAwards = CreateMatrix.DenseOfArray(expAwards); // clean up matRanks to filter out the rows have rank of 0 Tuple <int, double> zero = matInitRanks.Column(1).Find(r => r == 0.0d, Zeros.Include); if (zero != null && zero.Item1 > 0) { matInitRanks = matInitRanks.SubMatrix(0, zero.Item1, 0, matInitRanks.ColumnCount); } Vector <double> vecActRankNumber = matInitRanks.Column(1); Vector <double> vecExpAwards = CreateVector.DenseOfArray(To1DAwards(expAwards)); // init dimension int row = Math.Max(vecActRankNumber.Count, vecExpAwards.Count); int column = matExpAwards.RowCount; // matrix of Actual Matrix <double> matActRankNo = ToRankMatrix(row, column, vecActRankNumber.ToArray()); // matrix of Expected Matrix <double> matExpAwardsNo = ToRankMatrix(row, column, vecExpAwards.ToArray()); // diff between the matrix of Actual and the matrix of Expected Matrix <double> matDiff = matExpAwardsNo.Subtract(matActRankNo); if (matDiff.ForAll(d => d == 0.0d) /*.Equals(CreateMatrix.Dense(row, column, 0.0d)*/) { return(new VerifyResult() { Pass = true, OptRanks = matInitRanks.ToArray(), OrgRanks = initRanks }); } else { double[,] actAwards = To2DAwards(vecActRankNumber.ToArray()); return(new VerifyResult() { Pass = false, DiffMatrix = matDiff.ToArray(), ActRankNoMatrix = matActRankNo.ToArray(), ActAwards = actAwards, ExpAwards = expAwards, OptRanks = matInitRanks.ToArray(), OrgRanks = initRanks }); } }
public NonlinearMinimizationResult FindMinimum(IObjectiveModel objective, double[] initialGuess, double[] lowerBound = null, double[] upperBound = null, double[] scales = null, bool[] isFixed = null) { var lb = (lowerBound == null) ? null : CreateVector.Dense <double>(lowerBound); var ub = (upperBound == null) ? null : CreateVector.Dense <double>(upperBound); var sc = (scales == null) ? null : CreateVector.Dense <double>(scales); var fx = (isFixed == null) ? null : isFixed.ToList(); return(Minimum(Subproblem, objective, CreateVector.DenseOfArray <double>(initialGuess), lb, ub, sc, fx, GradientTolerance, StepTolerance, FunctionTolerance, RadiusTolerance, MaximumIterations)); }
public VectorBentimark(int size) { this.size = size; Random r = new Random(0); vec1 = Enumerable.Range(0, size).Select(x => (float)r.Next()).ToArray(); vec2 = Enumerable.Range(0, size).Select(x => (float)r.Next()).ToArray(); this.v1 = CreateVector.DenseOfArray(vec1); this.v2 = CreateVector.DenseOfArray(vec2); this.mv1 = new Vector(vec1); this.mv2 = new Vector(vec2); }
static void Main(string[] args) { var matrix = CreateMatrix.DenseOfArray <double>(new double[, ] { { 1.0, -1.0, 2.0 }, { 0.0, -3.0, 1.0 } }); var vector = CreateVector.Dense <double>(new double[] { 2, 1, 0 }); //Matrix-Vector product Console.WriteLine(MatrixDotVector(matrix, vector)); //Expected: [1 -3] //Hadamard Procut Console.WriteLine(HadamardProduct(vector, vector)); //Expected: [4,1,0] //Pointwise substraction Console.WriteLine(PointwiseSubstraction(vector, vector)); //Expected: [0,0,0] Console.WriteLine(PointwiseSubstraction(matrix, matrix)); //Expected: [0,0,0][0,0,0] //Mask a row/column (but not clear it) var uMatrix = CreateMatrix.Dense <double>(2, 3, 1.0); uMatrix.ClearColumns(0, 2); var cMatrix = CreateMatrix.Dense <double>(2, 3, 1.0); cMatrix.ClearColumn(1); //with 1st and 3rd columns masked var newMatrix = matrix.PointwiseMultiply(uMatrix); Console.WriteLine(newMatrix); //original matrix Console.WriteLine(matrix); //update the newMatrix newMatrix[0, 1] = 100; newMatrix[1, 1] = 200; Console.WriteLine(newMatrix); //push new values back to original matrix = matrix.PointwiseMultiply(cMatrix) + newMatrix.PointwiseMultiply(uMatrix); Console.WriteLine(matrix); //Vector equality Vector <double> a1 = CreateVector.DenseOfArray <double>(new double[] { 1.2, 3.4, 5.6 }); Vector <double> a2 = CreateVector.DenseOfArray <double>(new double[] { 1.2, 3.4, 5.6 }); Console.WriteLine(a1 == a2); Console.WriteLine(a1.Equals(a2)); //Find biggest element in vector Vector <double> c = CreateVector.DenseOfArray <double>(new double[] { 1.2, 3.4, 5.6 }); Console.WriteLine(c.MaximumIndex()); }
/// <summary> /// /// </summary> public void SetLocalPVectorCOG(Matrix <double> KeepMatrix) { int ElementIndex = GetElementIndex(); Vector <double> TestCOG = CreateVector.DenseOfArray <double>(new double[3] { 1, 2, 3 }); ///this.LocalPVectorCOG = this.KeepMatrixIdentity.Transpose() * GetLocalVectorMatrix(ElementIndex, Cog.Offset); /// Offset from parent origin to local origin missing this.LocalPVectorCOG = GetLocalVectorMatrix(ElementIndex, TestCOG); this.LocalPVectorCOG.InsertAtIndex(IdentityVectors.X, ElementIndex); this.LocalPVectorCOG.InsertAtIndex(IdentityVectors.Y, ElementIndex + 3); this.LocalPVectorCOG.InsertAtIndex(IdentityVectors.Z, ElementIndex + 6); this.LocalPVectorCOG = KeepMatrix * this.LocalPVectorCOG; }
public void IterateKalman() { if (pauseWhileNotMoving && prevMousePos == curMousePos) { return; } // add mesurement spread to the mouse pos var mesuredPos = curMousePos; mesuredPos.Offset(rnd.NextDouble(), rnd.NextDouble()); // prepare mesurement Vector var M = CreateVector.DenseOfArray(new[] { mesuredPos.X, mesuredPos.Y, }); // calc state vector prediction var Xkp = A * Xprev + B * a; // calc covariance matrix prediction var Pkp = A * (Pprev * A.Transpose()) + Q; // calc kalman gain var K = (Pkp * H.Transpose()) * (H * (Pkp * H.Transpose()) + R).Inverse(); // calc new state var Xk = Xkp + K * (M - H * Xkp); // calc new covariance matrix var Pk = (CreateMatrix.DiagonalIdentity <double>(4) - K * H) * Pkp; // save current state for next iteration Xprev = Xk; Pprev = Pk; // update UI OnPropertyChanged(nameof(XSpeed)); OnPropertyChanged(nameof(YSpeed)); // draw predicted line AddToLine(inkCanvasEstimated1, new Point(Xkp[0], Xkp[1]), Colors.Blue); // draw corrected line AddToLine(inkCanvasEstimated2, new Point(Xprev[0], Xprev[1]), Colors.Green); // draw mesurment points DrawPoint(mesuredPos, Colors.Red); prevMousePos = curMousePos; }
private void DLSIterate() { var jacobian = ComputeJacobian(); var deltaE = SafeDeltaE(goal, baseJoint.EndEffector); var jacobianMat = CreateMatrix.Dense(2, jacobian.Count, (row, col) => row == 0 ? jacobian[col].X : jacobian[col].Y); var lambda = .5f; var lambdaMatrix = lambda * lambda * CreateMatrix.DenseIdentity <float>(jacobianMat.RowCount); var deltaPhiVec = jacobianMat.Transpose() * (jacobianMat * jacobianMat.Transpose() + (lambdaMatrix)).Inverse() * CreateVector.DenseOfArray(new float[] { deltaE.X, deltaE.Y }); var deltaPhi = new LinkedList <float>(deltaPhiVec.ToArray()); baseJoint.ApplyDofDeltas(deltaPhi); }
public void IterateDLS(Hinge joint, Vector2 goal) { var jacobian = ComputeJacobian(joint); var deltaE = ClampDeltaE(goal, joint.EndEffector); var jacobianMat = CreateMatrix.Dense(2, jacobian.Count, (row, col) => row == 0 ? jacobian[col].X : jacobian[col].Y); var lambda = DLSLambda; var lambdaMatrix = lambda * lambda * CreateMatrix.DenseIdentity <float>(jacobianMat.RowCount); var deltaPhiVec = jacobianMat.Transpose() * (jacobianMat * jacobianMat.Transpose() + (lambdaMatrix)).Inverse() * CreateVector.DenseOfArray(new float[] { deltaE.X, deltaE.Y }); var deltaPhi = new LinkedList <float>(deltaPhiVec.ToArray()); joint.ApplyDofDeltas(deltaPhi); }
/// <summary> /// [offset] [type] [value] [description] ///0000 32 bit integer 0x00000801(2049) magic number(MSB first) ///0004 32 bit integer 60000 number of items ///0008 unsigned byte ?? label ///0009 unsigned byte ?? label ///........ ///xxxx unsigned byte ?? label ///The labels values are 0 to 9. /// </summary> /// <param name="labelFile"></param> /// <returns></returns> public static List <Vector <double> > LoadLabels(string labelFile) { if (!File.Exists(labelFile)) { throw new FileNotFoundException(); } List <byte> ret = new List <byte>(); using (FileStream stream = File.OpenRead(labelFile)) { using (GZipStream uncompressed = new GZipStream(stream, CompressionMode.Decompress)) { using (BinaryReader reader = new BinaryReader(uncompressed)) { int magicNumber = toLittleEndian(reader.ReadInt32()); if (magicNumber != 0x801) { throw new InvalidDataException("0x801 is expected at offset 000"); } int labelCount = toLittleEndian(reader.ReadInt32()); ret.AddRange(reader.ReadBytes(labelCount)); } } } List <Vector <double> > vectors = new List <Vector <double> >(); foreach (var label in ret) { vectors.Add(CreateVector.DenseOfArray <double>( new double[] { label == 0? 1.0:0.0, label == 1? 1.0:0.0, label == 2? 1.0:0.0, label == 3? 1.0:0.0, label == 4? 1.0:0.0, label == 5? 1.0:0.0, label == 6? 1.0:0.0, label == 7? 1.0:0.0, label == 8? 1.0:0.0, label == 9? 1.0:0.0 })); } return(vectors); }
public NonlinearMinimizationResult FindMinimum(IObjectiveModel objective, double[] initialGuess, double[] lowerBound = null, double[] upperBound = null, double[] scales = null, bool[] isFixed = null) { if (objective == null) { throw new ArgumentNullException("objective"); } if (initialGuess == null) { throw new ArgumentNullException("initialGuess"); } var lb = (lowerBound == null) ? null : CreateVector.Dense <double>(lowerBound); var ub = (upperBound == null) ? null : CreateVector.Dense <double>(upperBound); var sc = (scales == null) ? null : CreateVector.Dense <double>(scales); var fx = (isFixed == null) ? null : isFixed.ToList(); return(Minimum(objective, CreateVector.DenseOfArray <double>(initialGuess), lb, ub, sc, fx, InitialMu, GradientTolerance, StepTolerance, FunctionTolerance, MaximumIterations)); }
public static List <Vector <double> > GetOAT(Matrix <double> rot33) { var TOLERANCE = 1E-09; var st2 = Math.Sqrt(rot33[0, 2] * rot33[0, 2] + rot33[1, 2] * rot33[1, 2]); double a1, o1, t1; double a2, o2, t2; if (TOLERANCE < Math.Abs(st2)) { var st = st2; a1 = Math.Atan2(+st, rot33[2, 2]); a2 = Math.Atan2(-st, rot33[2, 2]); o1 = Math.Atan2(rot33[1, 2], +rot33[0, 2]); o2 = Math.Atan2(rot33[1, 2], -rot33[0, 2]); t1 = Math.Atan2(rot33[2, 1], -rot33[2, 0]); t2 = Math.Atan2(rot33[2, 1], +rot33[2, 0]); } else { //o1+t1=Math.Atan2(rot33[1, 0], rot33[1, 1]) を満たす (o1, t1)の組み合わせは無数にある。 //ここでは、t1=0 という解を得ることにする。 o1 = Math.Atan2(rot33[1, 0], rot33[1, 1]); a1 = (1d - rot33[2, 2]) * Math.PI / 2d; t1 = 0d; o2 = double.NaN; a2 = double.NaN; t2 = double.NaN; } var ans = new List <Vector <double> >(); ans.Add(CreateVector.DenseOfArray(new double[] { o1, a1, t1 })); if (!double.IsNaN(a2) || !double.IsNaN(a2) || !double.IsNaN(t2)) { ans.Add(CreateVector.DenseOfArray(new double[] { o2, a2, t2 })); } return(ans); }
//Add zeroed channels to align weights with their appropriate value private Vector <double> PadArray(bool [] usedCol, Vector <double> theta) { //Add removed collumns to array to make later calcs easier int index = 0; double[] tempArray = new double[usedCol.Length]; for (int j = 0; j < usedCol.Length; j++) { if (usedCol[j]) { tempArray[j] = theta.At(index); index++; } else { tempArray[j] = 0; } } return(CreateVector.DenseOfArray(tempArray)); }
void PlotOutputs() { if (!HasPerceptron) { return; } // precompute int ax = comboX.Active; int ay = comboY.Active; int volume = DISCRET_LEVEL * DISCRET_LEVEL; double step = 2.0 / (DISCRET_LEVEL + 1.0); // create points Vector3D[][] points = new Vector3D[conf.numOutputs][]; for (int o = 0; o < conf.numOutputs; o++) { points[o] = new Vector3D[volume]; } // fill points int c = 0; for (int ix = 1; ix <= DISCRET_LEVEL; ix++) { sector[ax] = step * ix; for (int iy = 1; iy <= DISCRET_LEVEL; iy++) { sector[ay] = step * iy; Vector <double> point = CreateVector.DenseOfArray(sector); double[] values = ann.Response(point).ToArray(); for (int o = 0; o < conf.numOutputs; o++) { points[o][c++] = new Vector3D(sector[ax], sector[ay], values[o]); } } } // render points rs3DP.Render(points, surf.Width, surf.Height); }
public void MoveCar() { if (_car.HasCollidedWithWall) { _car.Move(0f, -1f); return; } float speedNormalized = _car.CurrentSpeed / _car.MaxSpeed; float[] sensorDistancesNormalized = new float[_probe.SensorCount]; _probe.SensorDistances.CopyTo(sensorDistancesNormalized, 0); Array.ForEach(sensorDistancesNormalized, distance => distance = distance / _probe.MaxSensorDistance); float[] networkInputs = new float[_probe.SensorCount + 1]; networkInputs[0] = speedNormalized; sensorDistancesNormalized.CopyTo(networkInputs, 1); Vector <float> networkOutputs = _network.FeedForward(CreateVector.DenseOfArray(networkInputs)); _car.Move(networkOutputs[0], networkOutputs[1]); }
public static Layer Load(StreamReader reader) { var strContent = reader.ReadLine(); var values = strContent.Split(';'); int biascount = int.Parse(values[0]); int colCount = int.Parse(values[1]); int rowCount = int.Parse(values[2]); strContent = reader.ReadLine(); values = strContent.Split(';'); var biasArray = new double[biascount]; for (int i = 0; i < biascount; i++) { biasArray[i] = double.Parse(values[i]); } var bias = CreateVector.DenseOfArray <double>(biasArray); if (colCount != 0 && rowCount != 0) { double[,] mValues = new double[rowCount, colCount]; for (int y = 0; y < rowCount; y++) { strContent = reader.ReadLine(); values = strContent.Split(';'); for (int x = 0; x < colCount; x++) { mValues[y, x] = double.Parse(values[x]); } } var weights = CreateMatrix.DenseOfArray(mValues); return(new Layer(bias, weights)); } else { return(new Layer(bias, null)); } }
private OrgRank SplitRank(Matrix <double> matRanks, int rank_length, double[] awardNos, double[,] awards) { Vector <double> vecAwardNos = CreateVector.DenseOfArray(awardNos); //fill the rest of ranks as the last award double next_award = vecAwardNos[rank_length]; for (int i = rank_length; i < matRanks.RowCount; i++) { if (i < matRanks.RowCount) { matRanks[i, 1] = next_award; } } OrgRank orgRank = new OrgRank(matRanks.ToArray(), awards); // split ranks into two groups Matrix <double> matRanks1 = matRanks.SubMatrix(0, rank_length, 0, matRanks.ColumnCount); // split award_numbers into two sub_awards double[,] awards1 = To2DAwards(vecAwardNos.SubVector(0, rank_length).ToArray()); Rank rank1 = new Rank(matRanks1.ToArray(), awards1); orgRank.AddSubRank(rank1); // split ranks into two groups int length = matRanks.RowCount - rank_length; Matrix <double> matRanks2 = matRanks.SubMatrix(rank_length, length, 0, matRanks.ColumnCount); // split award_numbers into two sub_awards length = awardNos.Length - rank_length; double[,] awards2 = To2DAwards(vecAwardNos.SubVector(rank_length, length).ToArray()); Rank rank2 = new Rank(matRanks2.ToArray(), awards2); orgRank.AddSubRank(rank2); return(orgRank); }
public vnnCm(double[][,] W, double[][] B, Func <double, double>[] activations) { Activations = activations; Weights = new Matrix <double> [W.Length]; for (int i = 0; i < W.Length; i++) { Weights[i] = CreateMatrix.DenseOfArray(W[i]); } Biases = new Vector <double> [B.Length]; for (int i = 0; i < B.Length; i++) { Biases[i] = CreateVector.DenseOfArray(B[i]); } Neurons = new Vector <double> [B.Length + 1]; //Neurons[0] = CreateVector.DenseOfArray(new double[Weights[0].RowCount]); for (int i = 1; i < Neurons.Length; i++) { Neurons[i] = CreateVector.DenseOfArray(new double[Biases[i - 1].Count]); } }
static void Main(string[] args) { NeuralNetwork nn = new NeuralNetwork(0.001f, 1f, 2, 2, 2); //Console.WriteLine(nn.ToString()); double[] arr1 = { 0, 0 }; double[] arr2 = { 0, 1 }; double[] arr3 = { 1, 1 }; double[] arr4 = { 1, 0 }; double[] t1 = { 0 }; double[] t2 = { 1 }; double[] t3 = { 0 }; double[] t4 = { 1 }; Vector <double> v1 = CreateVector.DenseOfArray(arr1); Vector <double> v2 = CreateVector.DenseOfArray(arr2); Vector <double> v3 = CreateVector.DenseOfArray(arr3); Vector <double> v4 = CreateVector.DenseOfArray(arr4); Vector <double> w1 = CreateVector.DenseOfArray(t1); Vector <double> w2 = CreateVector.DenseOfArray(t2); Vector <double> w3 = CreateVector.DenseOfArray(t3); Vector <double> w4 = CreateVector.DenseOfArray(t4); Vector <double>[] input = { v1, v2, v3, v4 }; Vector <double>[] result = { w1, w2, w3, w4 }; //Console.WriteLine(v1); //Console.WriteLine(nn.AddBias(v1)); //Console.WriteLine(nn.FeedForward(v2)); nn.Train(input, result); //Console.WriteLine(); Console.Write("Input vector\n" + v1.ToString() + "Prediction\n" + nn.FeedForward(v1) + "\nCorrect result\n" + w1.ToString()); Console.Write("Input vector\n" + v2.ToString() + "Prediction\n" + nn.FeedForward(v2) + "\nCorrect result\n" + w2.ToString()); Console.Write("Input vector\n" + v3.ToString() + "Prediction\n" + nn.FeedForward(v3) + "\nCorrect result\n" + w3.ToString()); Console.Write("Input vector\n" + v4.ToString() + "Prediction\n" + nn.FeedForward(v4) + "\nCorrect result\n" + w4.ToString()); }
public Point SolveRayScreenVector(Point3D vec, ScreenProperties properties) { var unitPermm = UnitPerMM; var tempVec = CreateVector.Dense(vec.ToArray()); var tempScale = Math.Abs(LandmarkTransformVector[2] / tempVec[2]); tempVec = tempVec * tempScale; tempVec = tempVec + CreateVector.DenseOfArray(LandmarkTransformVector); if (tempVec[2] > 0.001) { Logger.Error("Wrong Vector try to solve"); } var tempScr = properties.ToScreenCoordinate(unitPermm, new Point3D(tempVec.ToArray())); //tempScr.X = properties.PixelSize.Width - Util.FixZero(tempScr.X); //tempScr.Y = -Util.FixZero(tempScr.Y); tempScr.X = Util.FixZero(tempScr.X); tempScr.Y = Util.FixZero(tempScr.Y); return(tempScr); }
static Vector <double> makeSpock() { return(CreateVector.DenseOfArray <double>(new double[] { 0, 0, 0, 0, 1 })); }