private double FunctionValueHalfTime(INonlinearModel model, int rowVid, ValuesByIndex values, bool newValues) { foreach (Variable c in data.Variables) { if (c.ConstName == "T1/2") { c.ConstValue = values[model.GetIndexFromKey(c.ConstName)]; break; } } double R = data.Variables[0].ConstValue; double w = data.Variables[1].ConstValue; double Kon = data.Variables[2].ConstValue; double Koff = data.Variables[3].ConstValue; double Df = data.Variables[4].ConstValue; double Ceq = data.Variables[5].ConstValue; double Feq = 1 - Ceq; double Tht = data.Variables[6].ConstValue; data.FitYVals = new double[data.XVals.Length]; Laplace lap = new Laplace(); lap.InitStehfest(14); return(Math.Abs((R)*lap.InverseTransform(R, w, Feq, Ceq, Kon, Koff, Df, Tht) - 0.5 * R)); }
private double FunctionEvaluator(INonlinearModel model, int rowVid, ValuesByIndex values, bool newValues) { if (newValues) { this.Compute(values); } return this.curVal; }
private double FunctionEvaluator(INonlinearModel model, int rowVid, ValuesByIndex values, bool newValues) { if (newValues) { this.Compute(values); } return(this.curVal); }
private double FunctionValueHalfTime(INonlinearModel model, int rowVid, ValuesByIndex values, bool newValues) { e.Parameters["t"] = values[model.GetIndexFromKey("t")]; double val = 0; double.TryParse(e.Evaluate().ToString(), out val); return(Math.Abs(half - val)); }
private double FunctionValue(INonlinearModel model, int rowVid, ValuesByIndex values, bool newValues) { foreach (Variable c in data.Variables) { c.ConstValue = values[model.GetIndexFromKey(c.ConstName)]; } double dev = FindDeviation(data); return(dev); }
private void GradientEvaluator(INonlinearModel model, int rowVid, ValuesByIndex values, bool newValues, ValuesByIndex gradient) { if (newValues) { this.Compute(values); } for (var index = 0; index < this.curGradient.Length; ++index) { gradient[this.variables[index]] = this.curGradient[index]; } }
/// <summary> /// Gradient value callback for the first variant of Rosenbrock's function. /// This is the multidimensional variant of Ronsenbrock when n must be pair /// f(x) = sum(i, from 1 to N){ [alpha(x(2i) - x(2i-1)^2)^2] + [(1 - x(2i-1))^2] } /// </summary> /// <param name="model">the model.</param> /// <param name="rowVid">the row index.</param> /// <param name="values">the variable values.</param> /// <param name="newValues">is first evaluator call with those variable values.</param> /// <param name="gradient">the gradient values (set by the user).</param> private static void FirstRosenbrockVariantGradient(INonlinearModel model, int rowVid, ValuesByIndex values, bool newValues, ValuesByIndex gradient) { const int firstVid = 1; const int alpha = 100; int dimentions = model.VariableCount; if (dimentions < 2) { throw new ArgumentException("Multidimensional variant require at least two dimensions"); } for (int i = firstVid; i <= dimentions / 2; i++) { gradient[2 * i - 1] = (4 * alpha * values[2 * i - 1] * (values[2 * i - 1] * values[2 * i - 1] - values[2 * i]) + 2 * values[2 * i - 1] - 2); gradient[2 * i] = (2 * alpha * -1 * (values[2 * i - 1] * values[2 * i - 1] - values[2 * i])); } }
/// <summary> /// Function value callback for first variant of Rosenbrock's function. /// This is the multidimensional variant of Ronsenbrock when n must be pair /// f(x) = sum(i, from 1 to N){ [alpha(x(2i) - x(2i-1)^2)^2] + [(1 - x(2i-1))^2] } /// <param name="model">the model.</param> /// <param name="rowVid">the row index.</param> /// <param name="values">the variable values.</param> /// <param name="newValues">is first evaluator call with those variable values.</param> /// <returns>the row value</returns> private static double FirstRosenbrockVariantFunction(INonlinearModel model, int rowVid, ValuesByIndex values, bool newValues) { const int firstVid = 1; const int alpha = 100; double value = 0; int dimentions = model.VariableCount; if (dimentions < 2) { throw new ArgumentException("Multidimensional variant require at least two dimensions"); } for (int i = firstVid; i <= dimentions / 2; i++) { value += alpha * (Math.Pow((values[2 * i] - values[2 * i - 1] * values[2 * i - 1]), 2)) + (Math.Pow(1 - values[2 * i - 1], 2)); } return(value); }
private double SinxValue(INonlinearModel model, int rowVid, ValuesByIndex values, bool newValues) { //_decay[0][0] = 1.000; // By CQN solver convention, first (and in this case only) variable always has the vid of 1 double sum = 0.0; for (int i = _begin; i < _end; i++) { sum += Math.Pow ( ((+1 * (_step * 2 / 1000.0) / values[1]) * Math.Exp(-1.0 * ((_time[i] - _begin0 + 0) / 1000.0) / (values[1] * values[2] / 1000.0)) * 1000.0 + (values[3]) - (_decay[i] * _factor)), 2 ); } return(sum); }
private double DiffMapping(INonlinearModel model, int rowVid, ValuesByIndex v, bool newValues) { int a = 1; var translate = new Vector3D(v[0 + a], v[1 + a], v[2 + a]); var rotate = new Vector3D(v[3 + a], v[4 + a], v[5 + a]); var fov = v[6 + a]; var shift = new Vector2D(v[7 + a], v[8 + a]); double sum = 0; int i = 0; foreach (var r in FReal) { var result = Project(r, translate, rotate, fov, shift) - FMapped[i]; sum += result.x * result.x + result.y * result.y; i++; } return(sum); // of least squares }
/// <summary> /// Function value callback for the second multidimensional variant of Rosenbrock's function /// f(x) = sum(i, from 1 to N-1){ [alpha(x(i+1) - x(i)^2)^2] + [(1 - x(i))^2] } /// <param name="model">the model.</param> /// <param name="rowVid">the row index.</param> /// <param name="values">the variable values.</param> /// <param name="newValues">is first evaluator call with those variable values.</param> /// <returns>the row value</returns> private static double SecondRosenbrockVariantFunction(INonlinearModel model, int rowVid, ValuesByIndex values, bool newValues) { const int firstVid = 1; const int alpha = 100; int dimentions = model.VariableCount; if (dimentions < 2) { throw new ArgumentException("Multidimensional variant require at least two dimensions"); } // first dimention special case double value = alpha * (Math.Pow((values[firstVid + 1] - values[firstVid] * values[firstVid]), 2)) + (Math.Pow(1 - values[firstVid], 2)); for (int i = firstVid + 1; i < dimentions; i++) { value += alpha * (Math.Pow((values[i + 1] - values[i] * values[i]), 2)) + (Math.Pow(1 - values[i], 2)); } return(value); }
/// <summary> /// Gradient value callback for second multidimensional variant of Rosenbrock's function /// f(x) = sum(i, from 1 to N-1){ [alpha(x(i+1) - x(i)^2)^2] + [(1 - x(i))^2] } /// </summary> /// <param name="model">the model.</param> /// <param name="rowVid">the row index.</param> /// <param name="values">the variable values.</param> /// <param name="newValues">is first evaluator call with those variable values.</param> /// <param name="gradient">the gradient values (set by the user).</param> private static void SecondRosenbrockVariantGradient(INonlinearModel model, int rowVid, ValuesByIndex values, bool newValues, ValuesByIndex gradient) { const int firstVid = 1; // common alpha is 100 int alpha = 100; int dimentions = model.VariableCount; if (dimentions < 2) { throw new ArgumentException("Multidimensional variant require at least two dimensions"); } // first dimention special case gradient[firstVid] = 4 * alpha * values[firstVid] * (values[firstVid] * values[firstVid] - values[firstVid + 1]) + 2 * (values[firstVid] - 1); for (int i = firstVid + 1; i < dimentions; i++) { gradient[i] = -2 * alpha * (values[i - 1] * values[i - 1] - values[i]) + 4 * alpha * values[i] * (values[i] * values[i] - values[i + 1]) + 2 * (values[i] - 1); } // last dimention special case gradient[dimentions] = -2 * alpha * (values[dimentions - 1] * values[dimentions - 1] - values[dimentions]); }
/// <summary> /// Gradient value callback for the original Rosenbrock's function /// f(x, y) = (1 - x)^2 + 100(y - x^2)^2 /// </summary> /// <param name="model">the model.</param> /// <param name="rowVid">the row index.</param> /// <param name="values">the variable values.</param> /// <param name="newValues">is first evaluator call with those variable values.</param> /// <param name="gradient">the gradient values (set by the user).</param> private static void OriginalRosenbrockGradient(INonlinearModel model, int rowVid, ValuesByIndex values, bool newValues, ValuesByIndex gradient) { gradient[1] = -2 * (1 - values[1]) - 400 * values[1] * (values[2] - (values[1] * values[1])); gradient[2] = 200 * (values[2] - (values[1] * values[1])); }
/// <summary> /// Function value callback for the original Rosenbrock's function /// f(x, y) = (1 - x)^2 + 100(y - x^2)^2 /// <param name="model">the model.</param> /// <param name="rowVid">the row index.</param> /// <param name="values">the variable values.</param> /// <param name="newValues">is first evaluator call with those variable values.</param> /// <returns>the row value</returns> private static double OriginalRosenbrockFunction(INonlinearModel model, int rowVid, ValuesByIndex values, bool newValues) { double value = Math.Pow(1 - values[1], 2) + 100 * (Math.Pow(values[2] - (values[1] * values[1]), 2)); return(value); }