/// <summary> /// Find vector x that minimizes the function f(x) using the Nelder-Mead Simplex algorithm. /// For more options and diagnostics consider to use <see cref="NelderMeadSimplex"/> directly. /// </summary> public static (double P0, double P1, double P2, double P3) OfFunction(Func <double, double, double, double, double> function, double initialGuess0, double initialGuess1, double initialGuess2, double initialGuess3, double tolerance = 1e-8, int maxIterations = 1000) { var objective = ObjectiveFunction.Value(v => function(v[0], v[1], v[2], v[3])); var result = NelderMeadSimplex.Minimum(objective, CreateVector.Dense(new[] { initialGuess0, initialGuess1, initialGuess2, initialGuess3 }), tolerance, maxIterations); return(result.MinimizingPoint[0], result.MinimizingPoint[1], result.MinimizingPoint[2], result.MinimizingPoint[3]); }
public Neural() { nodes = new Vector <float> [nodeSetup.Length]; weights = new Matrix <float> [nodeSetup.Length - 1]; biases = new Vector <float> [nodeSetup.Length - 1]; gammaValues = new Vector <float> [nodeSetup.Length - 1]; deltaWeights = new Matrix <float> [nodeSetup.Length - 1]; deltaBiases = new Vector <float> [nodeSetup.Length - 1]; for (int i = 0; i < nodeSetup.Length; i++) { nodes[i] = CreateVector.Dense <float>(nodeSetup[i]); } for (int i = 0; i < nodeSetup.Length - 1; i++) { weights[i] = CreateMatrix.Dense <float>(nodeSetup[i + 1], nodeSetup[i]); deltaWeights[i] = CreateMatrix.Dense <float>(nodeSetup[i + 1], nodeSetup[i]); biases[i] = CreateVector.Dense <float>(nodeSetup[i + 1]); deltaBiases[i] = CreateVector.Dense <float>(nodeSetup[i + 1]); gammaValues[i] = CreateVector.Dense <float>(nodeSetup[i + 1]); } InitialiseWeights(); InitialiseBiases(); }
/// <summary> /// Find vector x that minimizes the function f(x) using the Nelder-Mead Simplex algorithm. /// For more options and diagnostics consider to use <see cref="NelderMeadSimplex"/> directly. /// </summary> public static double OfScalarFunction(Func <double, double> function, double initialGuess, double tolerance = 1e-8, int maxIterations = 1000) { var objective = ObjectiveFunction.Value(v => function(v[0])); var result = NelderMeadSimplex.Minimum(objective, CreateVector.Dense(new[] { initialGuess }), tolerance, maxIterations); return(result.MinimizingPoint[0]); }
/// <summary> /// Objective model with a user supplied jacobian for non-linear least squares regression. /// </summary> public static IObjectiveModel NonlinearModel(Func <Vector <double>, double, double> function, Func <Vector <double>, double, Vector <double> > derivatives, Vector <double> observedX, Vector <double> observedY, Vector <double> weight = null) { Vector <double> func(Vector <double> point, Vector <double> x) { var functionValues = CreateVector.Dense <double>(x.Count); for (int i = 0; i < x.Count; i++) { functionValues[i] = function(point, x[i]); } return(functionValues); } Matrix <double> prime(Vector <double> point, Vector <double> x) { var derivativeValues = CreateMatrix.Dense <double>(x.Count, point.Count); for (int i = 0; i < x.Count; i++) { derivativeValues.SetRow(i, derivatives(point, x[i])); } return(derivativeValues); } var objective = new NonlinearObjectiveFunction(func, prime); objective.SetObserved(observedX, observedY, weight); return(objective); }
public static Vector <double> GetDirection(Vector <double> a, Vector <double> b) { var ab = (b - a); var ab_hat = ab / ab.L2Norm(); return(CreateVector.Dense(new double[] { Math.Round(ab_hat[0], 2), Math.Round(ab_hat[1], 2) })); }
Vector <double> ToRandomBytes() { Vector <double> vector = CreateVector.Dense <double>(dimension * multiplier); int rand = random.Next(0, 1073741824); string bytes = Convert.ToString(rand, 2); int starter = dimension * multiplier - bytes.Length; for (int i = 0; i < starter; i++) { vector[i] = -1; } for (int i = starter; i < dimension * multiplier; i++) { if (Convert.ToInt32(bytes[i - starter]) == 49) { vector[i] = 1; } else if (Convert.ToInt32(bytes[i - starter]) == 48) { vector[i] = -1; } else { throw new Exception("Some error in converting to bytes occured"); } } return(vector); }
public PhysicBall() { Location = CreateVector.Dense <float>(2); Speed = CreateVector.Dense <float>(2); Acceleration = DenseVector.OfArray(new float[] { 1, 1 }); DeltaLocation = CreateVector.Dense <float>(2); }
public override MathNet.Numerics.LinearAlgebra.Vector <double> Predict(MathNet.Numerics.LinearAlgebra.Vector <double> input) { //Ax where A is the input and x are the weights if (Degree > 1) { double[] row = new double[input.Count * Degree]; for (int j = 0; j < input.Count; j++) { row[j] = input[j]; for (int k = 1; k < Degree; k++) { row[k * input.Count + j] = Math.Pow(row[j], k + 1); } } input = CreateVector.Dense <double>(row); } if (bias) { List <double> data = input.ToList(); data.Insert(0, 1.0); input = CreateVector.Dense <double>(data.ToArray <double>()); } Vector <double> output = CreateVector.Dense <double>(new double[] { input.DotProduct(Weights.Column(0)) }); return(output); }
/// <summary> /// Initilizes the multibody system. After calling this method, no changes to elements should occure. /// </summary> internal void InitilizeSystem() { this.TotalDegreesOfFreedom = 0; // Setting up all element ids and system reference as well as the state existance vector. var data = new List <double>(); elementStateExistancesVectors = new Vector <double> [Elements.Count]; foreach ((int id, Element element) in Elements.Select((x, i) => (i, x))) { element.ElementId = id; element.System = this; TotalDegreesOfFreedom += element.BaseJoint.DegreesOfFreedom.Count; elementStateExistancesVectors[id] = CreateVector.Dense <double>(12, 0); foreach (var index in element.BaseJoint.DegreesOfFreedom.SelectMany(x => new int[] { (int)x, (int)x + 6 })) { elementStateExistancesVectors[id][index] = 1; } } int offset = Elements.Count * 6; StateExistanceVector = CreateVector.Dense <double>(Elements.Count * 12, 0); Elements.SelectMany((element, index) => element.BaseJoint.DegreesOfFreedom.SelectMany(y => new int[] { (index + 1) * (int)y, (index + 1) * (int)y + offset })) .ToList().ForEach(x => StateExistanceVector[x] = 1); }
public Neural(List <float> flatValues) { nodes = new Vector <float> [nodeSetup.Length]; weights = new Matrix <float> [nodeSetup.Length - 1]; biases = new Vector <float> [nodeSetup.Length - 1]; gammaValues = new Vector <float> [nodeSetup.Length - 1]; deltaWeights = new Matrix <float> [nodeSetup.Length - 1]; deltaBiases = new Vector <float> [nodeSetup.Length - 1]; for (int i = 0; i < nodeSetup.Length; i++) { nodes[i] = CreateVector.Dense <float>(nodeSetup[i]); } for (int i = 0; i < nodeSetup.Length - 1; i++) { weights[i] = CreateMatrix.Dense <float>(nodeSetup[i + 1], nodeSetup[i]); deltaWeights[i] = CreateMatrix.Dense <float>(nodeSetup[i + 1], nodeSetup[i]); biases[i] = CreateVector.Dense <float>(nodeSetup[i + 1]); deltaBiases[i] = CreateVector.Dense <float>(nodeSetup[i + 1]); gammaValues[i] = CreateVector.Dense <float>(nodeSetup[i + 1]); } LoadFromAllValues(flatValues); }
public static Vector <double> GenerateComplementaryVector(int size, int[] mask) { var ret = CreateVector.Dense <double>(size, 1.0); var matrix = ret.ToRowMatrix(); matrix = (matrix - 1).PointwiseAbs(); return(matrix.Row(0)); }
public static Vector <double> GenerateMaskVector(int size, int[] masks) { var ret = CreateVector.Dense <double>(size, 1.0); var matrix = ret.ToRowMatrix(); matrix.ClearColumns(masks); return(matrix.Row(0)); }
public override AA1_MLP.Entities.DataSet LoadData(string datasetLocation, int featureVectorLength, int outputLength = 1, int skip = 0, bool Normalize = false, bool standardize = false, int?numberOfExamples = null, bool reportOsutput = true, bool permute = false, int?seed = null) { string l; System.IO.StreamReader file = new System.IO.StreamReader(datasetLocation); Matrix <double> input = CreateMatrix.Dense <double>(1, featureVectorLength, 0); Matrix <double> output = CreateMatrix.Dense <double>(1, outputLength, 0); int i = 0; while ((l = file.ReadLine()) != null) { if (!string.IsNullOrWhiteSpace(l) && !l.StartsWith("#")) { var line = l.Split(','); if (i == 0) { input.SetRow(i, line.Skip(skip).Take(featureVectorLength).Select(s => double.Parse(s, CultureInfo.InvariantCulture)).ToArray()); if (reportOsutput) { output.SetRow(i, line.Skip(featureVectorLength + skip).Select(s => double.Parse(s, CultureInfo.InvariantCulture)).ToArray()); } } else { input = input.InsertRow(i, CreateVector.Dense(line.Skip(skip).Take(featureVectorLength).Select(s => double.Parse(s)).ToArray())); if (reportOsutput) { output = output.InsertRow(i, CreateVector.Dense(line.Skip(featureVectorLength + skip).Select(s => double.Parse(s)).ToArray())); } } i++; if (numberOfExamples != null) { numberOfExamples--; if (numberOfExamples == 0) { break; } } } } file.Close(); // string[] lines = File.ReadAllLines(datasetLocation); // lines = lines.Select(s => !string.IsNullOrWhiteSpace(s)); // DataSet trainingSet = new DataSet(input.NormalizeColumns(2.0), output); DataSet trainingSet = new DataSet(Normalize ? input.NormalizeColumns(2.0) : input, output); if (standardize) { StandardizeData(trainingSet); } return(trainingSet); }
public HopfieldNetwork(List <Vector <double> > patterns) { this.patterns = patterns; var N = patterns[0].Count; var K = CreateMatrix.DenseOfColumnVectors(patterns); this.W = (1.0 / N) * K.TransposeAndMultiply(K); this.W.SetDiagonal(CreateVector.Dense(N, 0.0)); }
/// <summary> /// Updates all vectors and matrices of each element. Has to be run at every time step /// </summary> /// <param name="GlobalStateVector"></param> public void UpdateElements(StateVector GlobalStateVector) { foreach (Element i in this.Elements) { ///Vector<double> ls = GlobalStateVector.GetStateVectorForId(i.ElementId); Vector <double> ls = CreateVector.Dense <double>(6 * 2); i.Update(ls, this.KeepMatrix); } }
public TargetODE(double x01, double x02, double Tmax, double[] TimeValues) { _x0 = CreateVector.Dense <double>(2); _x0[0] = x01; _x0[1] = x02; _tMax = Tmax; _nSwitch = TimeValues.Length - 1; _timeValues = TimeValues; }
static Vector <double> CalculateFuncValue(Vector <double> x) { Vector <double> value = CreateVector.Dense <double>(x.Count); for (int i = 0; i < functions.Length; ++i) { value[i] = functions[i](x); } return(value); }
public Point SolveRayScreenRodrigues(double[] rod, ScreenProperties properties) { double[,] rotMat; Core.Cv.Rodrigues(rod, out rotMat); var rotMatMat = CreateMatrix.DenseOfArray(rotMat); var tempVec = CreateVector.Dense(new double[] { 0, 0, -1 }) * rotMatMat; return(SolveRayScreenVector(new Point3D(tempVec.ToArray()), properties)); }
// Data from https://www.mathworks.com/help/stats/examples/weighted-nonlinear-regression.html private Vector <double> PollutionModel(Vector <double> p, Vector <double> x) { var y = CreateVector.Dense <double>(x.Count); for (int i = 0; i < x.Count; i++) { y[i] = p[0] * (1.0 - Math.Exp(-p[1] * x[i])); } return(y); }
// model: Rat43 (https://www.itl.nist.gov/div898/strd/nls/data/ratkowsky3.shtml) // f(x; a, b, c, d) = a / ((1 + exp(b - c * x))^(1 / d)) // best fitted parameters: // a = 6.9964151270E+02 +/- 1.6302297817E+01 // b = 5.2771253025E+00 +/- 2.0828735829E+00 // c = 7.5962938329E-01 +/- 1.9566123451E-01 // d = 1.2792483859E+00 +/- 6.8761936385E-01 private Vector <double> Rat43Model(Vector <double> p, Vector <double> x) { var y = CreateVector.Dense <double>(x.Count); for (int i = 0; i < x.Count; i++) { y[i] = p[0] / Math.Pow(1.0 + Math.Exp(p[1] - p[2] * x[i]), 1.0 / p[3]); } return(y); }
// model: Rosenbrock // f(x; a, b) = (1 - a)^2 + 100*(b - a^2)^2 // derivatives: // df/da = 400*a^3 - 400*a*b + 2*a - 2 // df/db = 200*(b - a^2) // best fitted parameters: // a = 1 // b = 1 private Vector <double> RosenbrockModel(Vector <double> p, Vector <double> x) { var y = CreateVector.Dense <double>(x.Count); for (int i = 0; i < x.Count; i++) { y[i] = Math.Pow(1.0 - p[0], 2) + 100.0 * Math.Pow(p[1] - p[0] * p[0], 2); } return(y); }
private static Vector <double> CalculateRatios( DatabaseFin individual, List <FeaturePointType> benchmarkFeatures, List <FeaturePointType> landmarkFeatures, List <IEnumerable <FeaturePointType> > ratioPermutations, bool useRemappedOutline = false) { var coordinates = new Dictionary <FeaturePointType, PointF>(); foreach (var featurePoint in landmarkFeatures) { if (useRemappedOutline) { coordinates[featurePoint] = individual.FinOutline.GetRemappedFeaturePointCoords(featurePoint); } else { coordinates[featurePoint] = individual.FinOutline.GetFeaturePointCoords(featurePoint); } } var benchmarkDistance = MathHelper.GetDistance( coordinates[benchmarkFeatures[0]].X, coordinates[benchmarkFeatures[0]].Y, coordinates[benchmarkFeatures[1]].X, coordinates[benchmarkFeatures[1]].Y); Vector <double> ratios = CreateVector.Dense <double>(ratioPermutations.Count - 1); int i = 0; foreach (var permutation in ratioPermutations) { var permutationList = permutation.ToList(); if ((permutationList[0] == benchmarkFeatures[0] && permutationList[1] == benchmarkFeatures[1]) || (permutationList[0] == benchmarkFeatures[1] && permutationList[1] == benchmarkFeatures[0])) { // This is our benchmark continue; } var currentDistance = MathHelper.GetDistance( coordinates[permutationList[0]].X, coordinates[permutationList[0]].Y, coordinates[permutationList[1]].X, coordinates[permutationList[1]].Y); ratios[i] = currentDistance / benchmarkDistance; i += 1; } return(ratios); }
public Vector <double> T_round(Vector <double> vec, int v_init, double alpha, List <List <int> > active_edges) { var res = CreateVector.Dense <double>(n); const double eps = 1e-8; foreach (var edge in active_edges) { var argmaxs = new List <int>(); var argmins = new List <int>(); double maxval = double.MinValue, minval = double.MaxValue; foreach (var v in edge) { var val = vec[v] / w_Degree(v); if (val > maxval + eps) { maxval = val; argmaxs.Clear(); argmaxs.Add(v); } else if (val > maxval - eps) { argmaxs.Add(v); } if (val < minval - eps) { minval = val; argmins.Clear(); argmins.Add(v); } else if (val < minval + eps) { argmins.Add(v); } } foreach (var v in argmaxs) { res[v] += weights[ID[edge]] * (maxval - minval) / argmaxs.Count; } foreach (var v in argmins) { res[v] -= weights[ID[edge]] * (maxval - minval) / argmins.Count; } } var res_init = CreateVector.Dense <double>(n); vec.CopyTo(res_init); res_init[v_init] -= 1; var mix = (1 - alpha) * res + alpha * res_init; return(mix); }
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 InputLayer(int size, double[] input) { if (size != input.Length) { Debug.LogError("Layer: Input size and size parameter do not match"); } this.size = size; this.rawInput = input; this.input = CreateVector.Dense <double>(input); }
/// <summary> /// Calculates the local force vector of the element /// </summary> /// <returns>The local force vector</returns> private Vector <double> GetLocalForceMomentVector() { Vector <double> LocalForceMomentVector = CreateVector.Dense <double>(6); Vector <double> LocalForceVector = CreateVector.Dense <double>(3); Vector <double> LocalMomentVector = CreateVector.Dense <double>(3); LocalForceVector += System.GravitationVector * this.Mass; LocalForceMomentVector.InsertAtIndex(LocalForceVector, 0); LocalForceMomentVector.InsertAtIndex(LocalMomentVector, 3); return(LocalForceMomentVector); }
/// this callback calculates Gaussian function f(c,x) = c0 + c1*EXP[-(x-c2)^2/2*c3^2] /// c0, c1, c2 and c3 are the background, amplitude, centre and width of the Gaussians. /// where x is a position on X-axis and c is adjustable parameter //public static void GaussianFunc(double[] c, double[] x, ref double func, object obj) //{ // double arg = (x[0] - c[2]) / c[3]; // double ex = System.Math.Exp(-arg * arg / 2); // func = c[1] * ex + c[0]; //} private static Vector <double> GaussianFunc(Vector <double> c, Vector <double> x) { var y = CreateVector.Dense <double>(x.Count); for (int i = 0; i < x.Count; i++) { double arg = (x[i] - c[2]) / c[3]; double ex = System.Math.Exp(-arg * arg / 2); y[i] = c[1] * ex + c[0]; } return(y); }
[InlineData(new[] { 1.0D, 2 }, new[] { 4.0D, 6 }, new[] { -4.0D, 3, -2 })] //any public void CreateTest(double[] a, double[] b, double[] expected_raw) { var A = CreateVector.Dense(a); var B = CreateVector.Dense(b); var expect = Line.Create(CreateVector.Dense(expected_raw)); var result1 = Line.Create(A, B); var result2 = Line.Create(B, A); Assert.Equal(result1, result2, new Line.LineEqualityComparer()); Assert.Equal(expect, result1, new Line.LineEqualityComparer()); }
public Vector <double> BlochVector() { double z = 2 * StateOperator[0, 0].Real - 1; double x = StateOperator[0, 1].Real + StateOperator[1, 0].Real; double y = StateOperator[0, 1].Imaginary - StateOperator[1, 0].Imaginary; Vector <double> bloch = CreateVector.Dense <double>(3); bloch[0] = x; bloch[1] = y; bloch[2] = z; return(bloch); }
public static Tuple <Vector <double>, int> Newton(Vector <double> x, double eps) { Vector <double> y = CreateVector.Dense <double>(x.Count); int count = 0; do { y = x; x = x + LUDecomposition.SolveSLE(CalculateJacobiMatrixValue(x), -CalculateFuncValue(x)); ++count; } while ((x - y).L2Norm() >= eps); return(Tuple.Create(x, count)); }