// TODO: Add ITorqueProvider and thrust effect on torque public override float GetPitchInput(Conditions conditions, float AoA, bool dryTorque = false, float guess = float.NaN) { BrentSearch solver = new BrentSearch((input) => this.GetAeroTorque(conditions, AoA, (float)input, dryTorque).x, -0.3, 0.3, 0.0001); if (solver.FindRoot()) return (float)solver.Solution; solver.LowerBound = -1; solver.UpperBound = 1; if (solver.FindRoot()) return (float)solver.Solution; if (this.GetAeroTorque(conditions, AoA, 0, dryTorque).x > 0) return -1; else return 1; }
/// <summary> /// Computes recommended sample size for the test to attain /// the power indicated in <see cref="Power"/> considering /// values of <see cref="Effect"/> and <see cref="Size"/>. /// </summary> /// /// <returns>Recommended sample size for attaining the given /// <see cref="Power"/> for size effect <see cref="Effect"/> /// under the given <see cref="Size"/>.</returns> /// public virtual void ComputeSamples() { double requiredPower = Power; // Attempt to locate the optimal sample size // to attain the required power by locating // a zero in the difference function: double sol = BrentSearch.FindRoot(n => { Samples = n; ComputePower(); return(requiredPower - Power); }, lowerBound: 2, upperBound: 1e+4); // Check it Samples = sol; ComputePower(); double newPower = Power; Power = requiredPower; if (Math.Abs(requiredPower - newPower) > 1e-5) { Samples = Double.NaN; } }
public void ConstructorTest() { #region doc_example // Suppose we were given the function x³ + 2x² - 10x and // we have to find its root, maximum and minimum inside // the interval [-4,3]. First, we express this function // as a lambda expression: Func <double, double> function = x => x * x * x + 2 * x * x - 10 * x; // And now we can create the search algorithm: BrentSearch search = new BrentSearch(function, -4, 3); // Finally, we can query the information we need bool success1 = search.Maximize(); // should be true double max = search.Solution; // occurs at -2.61 bool success2 = search.Minimize(); // should be true double min = search.Solution; // occurs at 1.27 bool success3 = search.FindRoot(); // should be true double root = search.Solution; // occurs at 0.50 #endregion Assert.IsTrue(success1); Assert.IsTrue(success2); Assert.IsTrue(success3); Assert.AreEqual(-2.6103173042172645, max); Assert.AreEqual(1.2769840667540548, min); Assert.AreEqual(-0.5, root); }
public void ConstructorTest() { #region doc_example // Suppose we were given the function x³ + 2x² - 10x + 1 and // we have to find its root, maximum and minimum inside // the interval [-4, 2]. First, we express this function // as a lambda expression: Func <double, double> function = x => x * x * x + 2 * x * x - 10 * x + 1; // And now we can create the search algorithm: BrentSearch search = new BrentSearch(function, -4, 2); // Finally, we can query the information we need bool success1 = search.Maximize(); // should be true double max = search.Solution; // occurs at -2.61 bool success2 = search.Minimize(); // should be true double min = search.Solution; // occurs at 1.28 bool success3 = search.FindRoot(); // should be true double root = search.Solution; // occurs at 0.10 double value = search.Value; // should be zero #endregion Assert.IsTrue(success1); Assert.IsTrue(success2); Assert.IsTrue(success3); Assert.AreEqual(-2.6103173073566239, max); Assert.AreEqual(1.2769839857480398, min); Assert.AreEqual(0.10219566016872624, root); Assert.AreEqual(0, value, 1e-5); }
public void OnData(Futures data1) { if (Time.Year == 2006) { System.Diagnostics.Debugger.Break(); } if (data1.Symbol == symbols[0]) { prices.Push1(data1.Open); } if (data1.Symbol == symbols[1]) { prices.Push2(data1.Open); } if (prices.QLength1 == numBars && prices.QLength2 == numBars) { mult = BrentSearch.FindRoot(prices.multFunc, -2, 2, 1e-8); resid = prices.Open1 - (mult * prices.Open2); if (Portfolio[symbols[0]].IsLong && resid > 0) { Order(symbols[0], -1); Order(symbols[1], 1); //Debug(data1.Time.ToString()+" Resid: "+resid.ToString()+" Close BuySell-Open1: "+prices.Open1.ToString()+" Open2: "+prices.Open2.ToString()); } if (Portfolio[symbols[0]].IsShort && resid < 0) { Order(symbols[0], 1); Order(symbols[1], -1); //Debug(data1.Time.ToString()+" Resid: "+resid.ToString()+" Close SellBuy-Open1: "+prices.Open1.ToString()+" Open2: "+prices.Open2.ToString()); } if (!Portfolio[symbols[0]].HoldStock && !Portfolio[symbols[1]].HoldStock) { if (resid > cLevel) { //int tradeSize = (int)(Portfolio.Cash / balRisk); Order(symbols[0], -1); Order(symbols[1], 1); //Debug(data1.Time.ToString()+" Resid: "+resid.ToString()+" SellBuy-Open1: "+prices.Open1.ToString()+" Open2: "+prices.Open2.ToString()); } if (resid < -cLevel) { //int tradeSize = (int)(Portfolio.Cash / balRisk); Order(symbols[0], 1); Order(symbols[1], -1); //Debug(data1.Time.ToString()+" Resid: "+resid.ToString()+" BuySell-Open1: "+prices.Open1.ToString()+" Open2: "+prices.Open2.ToString()); } } } }
public void FindRootWithLowMaxIterationsThrowsConvergenceException() { Func <double, double> f = x => (x + 2) * (x - 2); double a = -1; double b = +3000; Assert.ThrowsException <ConvergenceException>(() => { double actual = BrentSearch.FindRoot(f, a, b, maxIterations: 5); }); }
public void FindRootBoundedTwiceThrowsConvergenceException() { Func <double, double> f = x => (x + 2) * (x - 2); double a = -3; double b = +3; Assert.ThrowsException <ConvergenceException>(() => { double actual = BrentSearch.FindRoot(f, a, b); }); }
public void FindRootBoundedTwiceFailsToSolve() { Func <double, double> f = x => (x + 2) * (x - 2); double a = -3; double b = +3; var search = new BrentSearch(f, a, b); var isSuccess = search.FindRoot(); Assert.AreEqual(false, isSuccess); Assert.AreEqual(BrentSearchStatus.RootNotBracketed, search.Status); }
/// <summary> /// Get the minimum value that we can add to hit the target /// </summary> /// <param name="targetValue"> /// The target we would like to hit /// </param> /// <returns> /// The difference between the initial value and what we need to add/remove to hit the target /// </returns> public decimal GetGoalSeekValue(decimal targetValue) { this.iterations = 0; var startTime = DateTime.Now; this.target = targetValue; var startValue = this.GetStartValue(); var result = (decimal)BrentSearch.FindRoot(this.TestTree, (double)startValue, (double)targetValue, 1); this.timeSpan = DateTime.Now - startTime; return(result); }
public void FindRootTest() { // Example from http://en.wikipedia.org/wiki/Brent%27s_method Func <double, double> f = x => (x + 3) * Math.Pow((x - 1), 2); double a = -4; double b = 4 / 3.0; double expected = -3; double actual = BrentSearch.FindRoot(f, a, b); Assert.AreEqual(expected, actual, 1e-6); Assert.IsFalse(Double.IsNaN(actual)); }
public void FindRootWithLowMaxIterationsFailsToSolveButGivesLastKnownSolution() { Func <double, double> f = x => (x + 2) * (x - 2); double a = -1; double b = +3000; var search = new BrentSearch(f, a, b, maxIterations: 5); var isSuccess = search.FindRoot(); Assert.AreEqual(false, isSuccess); Assert.AreEqual(BrentSearchStatus.MaxIterationsReached, search.Status); Assert.IsTrue(search.Solution > a && search.Solution < b); }
/// <summary> /// Should solve /// </summary> /// <param name="c"></param> /// <param name="t0"></param> /// <param name="distance"></param> /// <returns></returns> public static double PointAtDistanceFrom(this ICurve c, double t0, double distance) { Func <double, double> objFunc = t1 => { var length3 = t0 < t1?c.GetLength3(t0, t1) : c.GetLength3(t1, t0); return(length3 - Math.Abs(distance)); }; var domain = c.Domain(); var min = distance < 0.0 ? 0.8 * domain[0] : t0; var max = distance < 0.0 ? t0 : 1.2 * domain[1]; var solver = new BrentSearch(objFunc, min, max); solver.FindRoot(); var sol = solver.Solution; return(sol); }
public void FindRootTest() { // Example from http://en.wikipedia.org/wiki/Brent%27s_method Func <double, double> f = x => (x + 3) * Math.Pow((x - 1), 2); double a = -4; double b = 4 / 3.0; double expected = -3; double actual = BrentSearch.FindRoot(f, a, b); Assert.AreEqual(expected, actual, 1e-6); Assert.IsFalse(Double.IsNaN(actual)); var search = new BrentSearch(f, a, b); bool isSuccess = search.FindRoot(); Assert.IsTrue(isSuccess); Assert.AreEqual(BrentSearchStatus.Success, search.Status); Assert.AreEqual(expected, search.Solution, 1e-6); Assert.IsTrue(Math.Abs(search.Value) < 1e-5); }
public FuncionLogLogistica(double[] eventos) : base(eventos) { try { double[] eventosOrdenados = eventos.OrderBy(x => x).ToArray(); double alfa = eventos.Count() % 2 == 0 ? (eventosOrdenados.ElementAt(eventos.Count() / 2) + eventosOrdenados.ElementAt((eventos.Count() / 2) + 1)) / 2 : eventos.OrderBy(x => x).ElementAt((eventos.Count() / 2) + 1); this.A = alfa.ToString("0.0000"); double media = eventos.Average(); int n = eventos.Count(); double sigma = eventos.Sum(x => Math.Pow(x - media, 2)) / n; double k = Math.Sqrt(Math.Pow(sigma, 2) / (Math.Pow(sigma, 2) + Math.Pow(media, 2))); Func <double, double> function = x => Math.Sqrt(1 - (x / Math.Tan(x))) - k; BrentSearch search = new BrentSearch(function, (Math.PI / 2) * k, Math.Sqrt(3) * k); search.FindRoot(); double beta = Math.PI / search.Solution; this.B = beta.ToString("0.0000"); DistribucionContinua = new LogLogisticDistribution(alfa, beta); Resultado = new ResultadoAjuste(StringFDP, StringInversa, DistribucionContinua.StandardDeviation, DistribucionContinua.Mean, DistribucionContinua.Variance, this); } catch (Exception) { Resultado = null; } }
public LogLogistics(double[] events) { try { double[] eventosOrdenados = events.OrderBy(x => x).ToArray(); double alfa = events.Count() % 2 == 0 ? (eventosOrdenados.ElementAt(events.Count() / 2) + eventosOrdenados.ElementAt((events.Count() / 2) + 1)) / 2 : events.OrderBy(x => x).ElementAt((events.Count() / 2) + 1); this.A = alfa.ToString("0.0000"); double media = events.Average(); int n = events.Count(); double sigma = events.Sum(x => Math.Pow(x - media, 2)) / n; double k = Math.Sqrt(Math.Pow(sigma, 2) / (Math.Pow(sigma, 2) + Math.Pow(media, 2))); Func <double, double> function = x => Math.Sqrt(1 - (x / Math.Tan(x))) - k; BrentSearch search = new BrentSearch(function, (Math.PI / 2) * k, Math.Sqrt(3) * k); search.FindRoot(); double beta = Math.PI / search.Solution; this.B = beta.ToString("0.0000"); this.continuousDistribution = new LogLogisticDistribution(alfa, beta); this.result = this.result = new DistributionResult(this.FDP, this.Inverse, this.continuousDistribution.StandardDeviation, this.continuousDistribution.Mean, this.continuousDistribution.Variance, this); } catch (Exception e) { Console.WriteLine("Excepcion en clase " + this.GetType().ToString() + e.Message); } }