public EventModuleView() { InitializeComponent(); this.currentBrentPriceLabel = new Label(); this.crudeOilBrentPriceLabel = new Label(); this.crudeOilBrentPriceTextBox = new TextBox(); this.updatePriceButtton = new Button(); this.brent = new Brent(); brent.CrudeOilBrentPrice = 86; brent.BrentPriceChanged += brent_PriceChanged; currentBrentPriceLabel.Location = new Point(80, 24); currentBrentPriceLabel.Size = new Size(120, 24); currentBrentPriceLabel.Text = "Current Price: " + brent.CrudeOilBrentPrice.ToString(); crudeOilBrentPriceLabel.Location = new Point(24, 50); crudeOilBrentPriceLabel.Size = new Size(80, 24); crudeOilBrentPriceLabel.Text = "Brent Price"; crudeOilBrentPriceTextBox.Location = new Point(120, 50); crudeOilBrentPriceTextBox.Size = new Size(80, 24); updatePriceButtton.Location = new Point(50, 80); updatePriceButtton.Size = new Size(120, 40); updatePriceButtton.Text = "Update Crude Oil Price"; updatePriceButtton.Click += new EventHandler(updatePriceButtton_Click); this.Controls.Add(currentBrentPriceLabel); this.Controls.Add(crudeOilBrentPriceLabel); this.Controls.Add(crudeOilBrentPriceTextBox); this.Controls.Add(updatePriceButtton); }
private VoltageLimitCurve buildVoltageLimitCurve(int count = 50, double Imax = 55, double Umax = 140, double max_speed = 6000) { var mtpa = buildTableMaxtorquePerAmple(); VoltageLimitCurve vlc = new VoltageLimitCurve() { Imax = Imax, Umax = Umax, MaxSpeed = max_speed, }; for (int i = 0; i < count + 1; i++) { double t = mtpa.GetMaxTorqueWithCurrentMagnitude(i * Imax / count); var idq = mtpa.GetCurrentForTorque(t); // look for speed, that is suitable for given current (in max torque condition) and u=Umax double ss = 0; bool success = Brent.TryFindRoot(s => { var data_ = calculatePointdata(idq.d, idq.q, s); var u_ = Math.Sqrt(data_.ud * data_.ud + data_.uq * data_.uq); return(u_ - Umax); }, 100, max_speed, 1e-3, 100, out ss); if (success) { vlc.speeds.Add(ss); vlc.torques.Add(t); vlc.currents.Add(idq); } } return(vlc); }
public void Oneeq3() { // Test case from http://www.polymath-software.com/library/nle/Oneeq3.htm Func <double, double> f1 = T => Math.Exp(21000 / T) / (T * T) - 1.11e11; Assert.AreEqual(551.773822885233, Brent.FindRoot(f1, 550, 560, 1e-2), 1e-2); }
/// <summary> /// Computes the inverse of the cumulative distribution function (InvCDF) for the distribution /// at the given probability. This is also known as the quantile or percent point function. /// </summary> /// <param name="p">The location at which to compute the inverse cumulative density.</param> /// <param name="location">The location (μ) of the distribution.</param> /// <param name="scale">The scale (σ) of the distribution. Range: σ > 0.</param> /// <param name="freedom">The degrees of freedom (ν) for the distribution. Range: ν > 0.</param> /// <returns>the inverse cumulative density at <paramref name="p"/>.</returns> /// <seealso cref="InverseCumulativeDistribution"/> /// <remarks>WARNING: currently not an explicit implementation, hence slow and unreliable.</remarks> public static double InvCDF(double location, double scale, double freedom, double p) { if (scale <= 0.0 || freedom <= 0.0) { throw new ArgumentException(Resources.InvalidDistributionParameters); } // TODO JVG we can probably do a better job for Cauchy special case if (double.IsPositiveInfinity(freedom)) { return(Normal.InvCDF(location, scale, p)); } if (p == 0.5d) { return(location); } // TODO PERF: We must implement this explicitly instead of solving for CDF^-1 return(Brent.FindRoot(x => { var k = (x - location) / scale; var h = freedom / (freedom + (k * k)); var ib = 0.5 * SpecialFunctions.BetaRegularized(freedom / 2.0, 0.5, h); return x <= location ? ib - p : 1.0 - ib - p; }, -800, 800, accuracy: 1e-12)); }
public static double inv_m1_beta_black_cxv(double beta, double f, double sigma) { var s2 = sigma * sigma; var igb = inv_g(beta, f); var fac = -0.5 * s2; var rf = FS.fun((double cxv) => { var mu = igb + fac * cxv; var f0 = m1_beta_black(beta, mu, sigma); return(f - f0); }); var alpha = 0.5 * beta * s2; var guess = alpha == 0.0 ? 1.0 : Math.Min(1.0, Math.Max(0.0, (f + alpha) / alpha)); var lo = guess - 1e-3; var hi = guess + 1e-3; var tGuess = rf(alpha); if (DoubleUtils.ApproximatelyEqual(tGuess, 0.0, 100.0 * DoubleUtils.DoubleEpsilon)) { return(igb + fac * alpha); } NumericalRecipes.zbrac(rf, ref lo, ref hi); var cxvRoot = Brent.FindRoot(rf, lo, hi); return(igb + fac * cxvRoot); }
/// <summary> /// Calculates the throughput at which the expected time to FC the given movements = /// timeThresholdBase + time span of the movements /// </summary> private static double calculateFCTimeTP(IEnumerable <OsuMovement> movements) { if (movements.Count() == 0) { return(0); } double mapLength = movements.Last().Time - movements.First().Time; double timeThreshold = timeThresholdBase + mapLength; double maxFCTime = calculateFCTime(movements, tpMin); if (maxFCTime <= timeThreshold) { return(tpMin); } double minFCTime = calculateFCTime(movements, tpMax); if (minFCTime >= timeThreshold) { return(tpMax); } double fcTimeMinusThreshold(double tp) => calculateFCTime(movements, tp) - timeThreshold; return(Brent.FindRoot(fcTimeMinusThreshold, tpMin, tpMax, tpPrecision)); }
/// <summary> /// Creates a new <see cref="NonLinearRankFitnessFunction{TProgram}" /> with the given parameters. /// </summary> /// <param name="programComparer">The object used to compare programs and determine their ranking.</param> /// <param name="population">The list of programs whose fitness can be computed by this function.</param> /// <param name="selectivePressure"> /// The probability of the best individual being selected compared to the average probability of selection of all /// individuals. /// </param> public NonLinearRankFitnessFunction( IComparer <TProgram> programComparer, IPopulation <TProgram> population, double selectivePressure) : base(programComparer, population) { var n = population.Count; this.SelectivePressure = Math.Max(1d, Math.Min(n - 2d, selectivePressure)); // finds the root of the polynomial try { this._root = Brent.FindRootExpand(this.Polynomial, -n, n, 1E-08, 1000); this._rootFound = true; } catch (NonConvergenceException) { } // stores the exponential sum this._rootFactor = 0d; var pow = 1d; for (var i = 0; i < n; i++) { this._rootFactor += pow; pow *= this._root; } this._rootFactor = n / this._rootFactor; }
public void Oneeq19b() { // Test case from http://www.polymath-software.com/library/nle/Oneeq19b.htm Func <double, double> f1 = z => { const double P = 200; const double Pc = 33.5; const double T = 631; const double Tc = 126.2; const double Pr = P / Pc; const double Tr = T / Tc; double Asqr = 0.4278 * Pr / Math.Pow(Tr, 2.5); const double B = 0.0867 * Pr / Tr; double Q = B * B + B - Asqr; double r = Asqr * B; double p = (-3 * Q - 1) / 3; double q = (-27 * r - 9 * Q - 2) / 27; double R = Math.Pow(p / 3, 3) + Math.Pow(q / 2, 2); double V = (R > 0) ? Math.Pow(-q / 2 + Math.Sqrt(R), 1 / 3) : 0; double WW = (R > 0) ? (-q / 2 - Math.Sqrt(R)) : (0); double psi1 = (R < 0) ? (Math.Acos(Math.Sqrt((q * q / 4) / (-p * p * p / 27)))) : (0); double W = (R > 0) ? (Math.Sign(WW) * Math.Pow(Math.Abs(WW), 1 / 3)) : (0); double z1 = (R < 0) ? (2 * Math.Sqrt(-p / 3) * Math.Cos((psi1 / 3) + 2 * 3.1416 * 0 / 3) + 1 / 3) : (0); double z2 = (R < 0) ? (2 * Math.Sqrt(-p / 3) * Math.Cos((psi1 / 3) + 2 * 3.1416 * 1 / 3) + 1 / 3) : (0); double z3 = (R < 0) ? (2 * Math.Sqrt(-p / 3) * Math.Cos((psi1 / 3) + 2 * 3.1416 * 2 / 3) + 1 / 3) : (0); double z0 = (R > 0) ? (V + W + 1 / 3) : (0); return(z * z * z - z * z - Q * z - r); }; double x = Brent.FindRoot(f1, -0.5, 1.2, 1e-14); Assert.AreEqual(1.06831213384200, x, 1e-7); Assert.AreEqual(0, f1(x), 1e-14); }
public void Oneeq2a() { // Test case from http://www.polymath-software.com/library/nle/Oneeq2a.htm Func <double, double> f1 = T => { const double x1 = 0.332112; const double x2 = 1 - x1; const double G12 = 0.07858889; const double G21 = 0.30175355; double P2 = Math.Pow(10, 6.87776 - 1171.53 / (224.366 + T)); double P1 = Math.Pow(10, 8.04494 - 1554.3 / (222.65 + T)); double t1 = x1 + x2 * G12; double t2 = x2 + x1 * G21; double gamma2 = Math.Exp(-Math.Log(t2) - (x1 * (G12 * t2 - G21 * t1)) / (t1 * t2)); double gamma1 = Math.Exp(-Math.Log(t1) + (x2 * (G12 * t2 - G21 * t1)) / (t1 * t2)); double k1 = gamma1 * P1 / 760; double k2 = gamma2 * P2 / 760; return(1 - k1 * x1 - k2 * x2); }; double x = Brent.FindRoot(f1, 0, 100, 1e-14, 100); Assert.AreEqual(58.7000023925600, x, 1e-5); Assert.AreEqual(0, f1(x), 1e-14); }
public void Oneeq7() { // Test case from http://www.polymath-software.com/library/nle/Oneeq7.htm Func <double, double> f1 = x => x / (1 - x) - 5 * Math.Log(0.4 * (1 - x) / (0.4 - 0.5 * x)) + 4.45977; Assert.AreEqual(0.757396293891, Brent.FindRoot(f1, 0, 0.79, 1e-2), 1e-2); }
public void LocalMinima() { Func <double, double> f1 = x => x * x * x - 2 * x + 2; Assert.AreEqual(0, f1(Brent.FindRoot(f1, -5, 5, 1e-14, 100)), 1e-14); Assert.AreEqual(0, f1(Brent.FindRoot(f1, -2, 4, 1e-14, 100)), 1e-14); }
public void Oneeq16() { // Test case from http://www.polymath-software.com/library/nle/Oneeq16.htm Func <double, double> f1 = T => { const double y = 0.7; const double x = 1.7; const double z = 1 - y - 0.02; const double CH4 = 0; const double C2H6 = 0; const double COtwo = y + 2 * z; const double H2O = 2 * y + 3 * z; const double N2 = 0.02 + 3.76 * (2 * y + 7 * z / 2) * x; const double O2 = (2 * y + 7 * z / 2) * (x - 1); const double alp = 3.381 * CH4 + 2.247 * C2H6 + 6.214 * COtwo + 7.256 * H2O + 6.524 * N2 + 6.148 * O2; const double bet = 18.044 * CH4 + 38.201 * C2H6 + 10.396 * COtwo + 2.298 * H2O + 1.25 * N2 + 3.102 * O2; const double gam = -4.3 * CH4 - 11.049 * C2H6 - 3.545 * COtwo + 0.283 * H2O - 0.001 * N2 - 0.923 * O2; const double H0 = alp * 298 + bet * 0.001 * 298 * 298 / 2 + gam * 1e-6 * 298 * 298 * 298 / 3; double Hf = alp * T + bet * 0.001 * T * T / 2 + gam * 1e-6 * T * T * T / 3; double xx = 1; return(212798 * y * xx + 372820 * z * xx + H0 - Hf); }; double r = Brent.FindRoot(f1, 1000, 3000); Assert.AreEqual(1779.48406483697, r, 1e-5); Assert.AreEqual(0, f1(r), 1e-9); }
public static bool TryFindRoot(Func <double, double> function, double lowerBound, double upperBound, out double root, double accuracy = 1e-6, int maxIterations = 100) { try { double lowerBoundValue = function(lowerBound); if (lowerBoundValue == 0.0 && lowerBoundValue == function(upperBound)) { // For our usage, we don't want to consider a constant function at zero to have any roots. root = lowerBound; return(false); } if (Brent.TryFindRoot(function, lowerBound, upperBound, accuracy: accuracy, maxIterations: maxIterations, root: out root)) { return(true); } return(Bisection.TryFindRoot(function, lowerBound, upperBound, accuracy: accuracy, maxIterations: maxIterations, root: out root)); } catch (ArithmeticException) { root = double.NaN; return(false); } }
public void Oneeq6b() { // Test case from http://www.polymath-software.com/library/nle/Oneeq6b.htm Func <double, double> f1 = V => { const double R = 0.08205; const double T = 273.0; const double B0 = 0.05587; const double A0 = 2.2769; const double C = 128300.0; const double A = 0.01855; const double B = -0.01587; const double P = 100.0; const double Beta = R * T * B0 - A0 - R * C / (T * T); const double Gama = -R * T * B0 * B + A0 * A - R * C * B0 / (T * T); const double Delta = R * B0 * B * C / (T * T); return(R * T * V * V * V + Beta * V * V + Gama * V + Delta - P * V * V * V * V); }; double x = Brent.FindRoot(f1, 0.1, 1, 1e-14); Assert.AreEqual(0.174749600398905, x, 1e-5); Assert.AreEqual(0, f1(x), 1e-13); }
/// <summary> /// Bootstraps the specified priceable assets. /// </summary> /// <param name="priceableAssets">The priceable assets.</param> /// <param name="baseDate">The base date.</param> /// <param name="extrapolationPermitted">The extrapolationPermitted flag.</param> /// <param name="interpolationMethod">The interpolationMethod.</param> /// <param name="tolerance">Solver tolerance to use.</param> /// <returns></returns> public static TermPoint[] Bootstrap(IEnumerable <IPriceableRateAssetController> priceableAssets, DateTime baseDate, Boolean extrapolationPermitted, InterpolationMethod interpolationMethod, Double tolerance) { const double defaultGuess = 0.9; const double min = 0.000000001; const double max = 2; //only works for linear on zero. InterpolationMethod interp = InterpolationMethodHelper.Parse("LogLinearInterpolation"); // Add the first element (date : discount factor) to the list var points = new Dictionary <DateTime, double> { { baseDate, 1d } }; var items = new Dictionary <DateTime, Pair <string, decimal> > { { baseDate, new Pair <string, decimal>("", 1m) } }; var solver = new Brent(); bool first = true; // Add the rest foreach (IPriceableRateAssetController priceableAsset in priceableAssets) { DateTime assetMaturityDate = priceableAsset.GetRiskMaturityDate(); if (points.Keys.Contains(assetMaturityDate)) { continue; } if (assetMaturityDate < points.Keys.Last()) { throw new InvalidOperationException("The maturity dates of the assets must be consecutive order"); } if (first) { first = false; // Add the first point points.Add(assetMaturityDate, defaultGuess); var curve = new SimpleDiscountFactorCurve(baseDate, interp, extrapolationPermitted, points); points[assetMaturityDate] = (double)priceableAsset.CalculateDiscountFactorAtMaturity(curve); } else { //This now should automatically extrapolate the required discount factor on a flat rate basis. var curve = new SimpleDiscountFactorCurve(baseDate, interp, extrapolationPermitted, points); //The first guess, which should be correct for all priceable assets with analytical solutions that have been implemented. points.Add(assetMaturityDate, (double)priceableAsset.CalculateDiscountFactorAtMaturity(curve)); } var objectiveFunction = new RateAssetQuote(priceableAsset, baseDate, interpolationMethod, extrapolationPermitted, points, tolerance); // Check whether the guess was close enough if (!objectiveFunction.InitialValue()) { double guess = Math.Max(min, points[assetMaturityDate]); points[assetMaturityDate] = solver.Solve(objectiveFunction, tolerance, guess, min, max); } items.Add(assetMaturityDate, new Pair <string, decimal>(priceableAsset.Id, (decimal)points[assetMaturityDate])); } return(TermPointsFactory.Create(items)); }
public static double BlackScholesImpliedVol(this EuropeanOption option, Date valueDate, double spot, double rate, double div, double price) { Func <double, double> option_price = x => BlackScholesPrice(option, valueDate, spot, x, rate, div) - price; double impliedvol = Brent.FindRoot(option_price, 1e-4, 1000, 1e-8, 1000); return(impliedvol); }
///<summary> ///</summary> ///<param name="maturityDate">redemption date</param> ///<param name="lastCouponDate">last coupon date</param> ///<param name="couponRate">coupon rate</param> ///<param name="couponFrequency">coupons per year,1 for annual, 2 for semi, 4 for quarterly</param> ///<param name="faceValue">The face value of the bond.</param> ///<param name="dirtyPrice">dirty price</param> ///<returns></returns> public static double CalculateBondYTM(DateTime maturityDate, DateTime lastCouponDate, double couponRate, int couponFrequency, double faceValue, double dirtyPrice) { var c = new CalculateBondYTMObjectiveFunctionClass(maturityDate, lastCouponDate, couponRate, couponFrequency, faceValue, dirtyPrice); // Instantiate and initialise the equation solver. var solver = new Brent(); return(solver.Solve(c, .0000001, couponRate, 0.01)); }
public static double InvCDF(double a, double b, double p) { //if (a < 0.0 || b < 0.0 || p < 0.0 || p > 1.0) { // throw new ArgumentException(Resources.InvalidDistributionParameters); //} return(Brent.FindRoot(x => SpecialFunctions.BetaRegularized(a, b, x) - p, 0.0, 1.0, accuracy: 1e-12)); }
/// <summary> /// Find first miss count achievable with at least probability p /// </summary> private static double getMissCount(double p, double[] missProbabilities) { var distribution = new PoissonBinomial(missProbabilities); Func <double, double> cdfMinusProb = missCount => distribution.Cdf(missCount) - p; return(Brent.FindRootExpand(cdfMinusProb, -100, 1000)); }
public void Oneeq7() { // Test case from http://www.polymath-software.com/library/nle/Oneeq7.htm // not solvable with this method Func <double, double> f1 = x => x / (1 - x) - 5 * Math.Log(0.4 * (1 - x) / (0.4 - 0.5 * x)) + 4.45977; Assert.Throws <NonConvergenceException>(() => Brent.FindRoot(f1, 0, 0.79, 1e-2)); }
public void Oneeq3() { // Test case from http://www.polymath-software.com/library/nle/Oneeq3.htm // not solvable with this method Func <double, double> f1 = T => Math.Exp(21000 / T) / (T * T) - 1.11e11; Assert.Throws <NonConvergenceException>(() => Brent.FindRoot(f1, 550, 560, 1e-2)); }
/// <summary> /// Bootstraps the specified priceable assets. /// </summary> /// <param name="priceableAssets">The priceable assets.</param> /// <param name="baseDate">The base date.</param> /// <param name="extrapolationPermitted">The extrapolationPermitted flag.</param> /// <param name="interpolationMethod">The interpolationMethod.</param> /// <param name="tolerance">Solver tolerance to use.</param> /// <returns></returns> public static TermPoint[] Bootstrap(List <IPriceableFxAssetController> priceableAssets, DateTime baseDate, Boolean extrapolationPermitted, InterpolationMethod interpolationMethod, Double tolerance) { const Double solveRateGap = 0.015d;//should we need more precising perhaps??? const Decimal dfamMinThreshold = 0.0m; const Decimal defaultGuess = 0.9m; const Double accuracy = 0.000001d; InterpolationMethod interp = InterpolationMethodHelper.Parse("LinearInterpolation"); //only works for linear on zero. priceableAssets = priceableAssets.OrderBy(a => a.GetRiskMaturityDate()).ToList(); var dates = new List <DateTime>(); var discountFactors = new List <double>(); var items = new Dictionary <DateTime, Pair <string, decimal> >(); bool firstTime = true; foreach (var asset in priceableAssets) { DateTime assetMaturityDate = asset.GetRiskMaturityDate(); //check if the maturity date is already in the list. If not contimue. if (items.ContainsKey(assetMaturityDate)) { continue; } decimal guess = asset.ForwardAtMaturity > dfamMinThreshold ? asset.ForwardAtMaturity : defaultGuess; decimal dfam; if (firstTime) { firstTime = false; dates.Add(assetMaturityDate); discountFactors.Add(Convert.ToDouble(guess)); dfam = asset.CalculateImpliedQuote(new SimpleFxCurve(baseDate, interp, extrapolationPermitted, dates, discountFactors)); discountFactors[0] = (double)dfam; } else { //The first guess, which should be correct for all priceable assets with analytical solutions that have been implemented. //So far this is only wrt Depos and Futures...This now should automatically extrapolate the required discount factor on a flat rate basis. dfam = asset.CalculateImpliedQuote(new SimpleFxCurve(baseDate, interp, extrapolationPermitted, dates, discountFactors)); discountFactors.Add((double)dfam); dates.Add(assetMaturityDate); } //Add a check on the dfam so that the solver is only called if outside the tolerance. var objectiveFunction = new FxAssetQuote(asset, baseDate, interpolationMethod, extrapolationPermitted, dates, discountFactors, tolerance); if (!objectiveFunction.InitialValue()) { var timeInterval = Actual365.Instance.YearFraction(baseDate, assetMaturityDate); var solveInterval = Math.Exp(-solveRateGap * timeInterval); var min = Math.Max(0, (double)dfam * solveInterval); var max = (double)dfam / solveInterval; var solver = new Brent(); dfam = (decimal)solver.Solve(objectiveFunction, accuracy, (double)dfam, min, max); } items.Add(assetMaturityDate, new Pair <string, decimal>(asset.Id, dfam)); } return(TermPointsFactory.Create(items)); }
public void Oneeq1() { // Test case from http://www.polymath-software.com/library/nle/Oneeq1.htm Func <double, double> f1 = z => 8 * Math.Pow((4 - z) * z, 2) / (Math.Pow(6 - 3 * z, 2) * (2 - z)) - 0.186; double x = Brent.FindRoot(f1, 0.1, 0.9, 1e-14, 100); Assert.AreEqual(0.277759543089215, x, 1e-9); Assert.AreEqual(0, f1(x), 1e-16); }
public static double beta_black_break_even_to_sigma(double beta, double f, double t, double breakEven, double dt = 1.0 / 365.0) { var rf = FS.fun((double sigma) => beta_black_break_even(beta, f, t, sigma, dt) - breakEven); var x1 = 1.0; var x2 = 5.0; NumericalRecipes.zbrac(rf, ref x1, ref x2); return(Brent.FindRoot(rf, x1, x2)); }
public static double yieldBrent(Brent solver, Bond bond, double cleanPrice, DayCounter dayCounter, Compounding compounding, Frequency frequency) { double ret = NQuantLibcPINVOKE.BondFunctions_yieldBrent__SWIG_3(Brent.getCPtr(solver), Bond.getCPtr(bond), cleanPrice, DayCounter.getCPtr(dayCounter), (int)compounding, (int)frequency); if (NQuantLibcPINVOKE.SWIGPendingException.Pending) { throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve(); } return(ret); }
public void Oneeq17() { // Test case from http://www.polymath-software.com/library/nle/Oneeq17.htm Func <double, double> f1 = rp => rp - 0.327 * Math.Pow(0.06 - 161 * rp, 0.804) * Math.Exp(-5230 / (1.987 * (373 + 1.84e6 * rp))); double x = Brent.FindRoot(f1, 0, 0.00035, 1e-13); Assert.AreEqual(0.000340568862275, x, 1e-5); Assert.AreEqual(0, f1(x), 2e-14); }
public static double InvCDF(double d1, double d2, double p) { //if (d1 <= 0.0 || d2 <= 0.0) { // throw new ArgumentException(Resources.InvalidDistributionParameters); //} return(Brent.FindRoot( x => SpecialFunctions.BetaRegularized(d1 / 2.0, d2 / 2.0, d1 * x / (d1 * x + d2)) - p, 0, 1000, accuracy: 1e-12)); }
public static double ibeta_black(double beta, OptionType optType, double F, double K, double T, double premium) { var rf = FS.fun((double sigma) => beta_black(beta, optType, F, K, T, sigma) - premium); var lo = 1.0; var hi = 5.0; // If very deep in-out of the money, will fail. f(lo) = f(hi), zbrac only moves low NumericalRecipes.zbrac(rf, ref lo, ref hi); return(Brent.FindRoot(rf, lo, hi)); }
private static void test05() //****************************************************************************80 // // Purpose: // // TEST05 tests CYCLE_BRENT for F5. // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 17 June 2012 // // Author: // // John Burkardt // { int lam = 0; int mu = 0; Console.WriteLine(""); Console.WriteLine("TEST05"); Console.WriteLine(" Test CYCLE_BRENT for F5()."); Console.WriteLine(" f5(i) = mod ( 16383 * i + 1, 65536 )."); int x0 = 1; Console.WriteLine(""); Console.WriteLine(" Starting argument X0 = " + x0 + ""); Brent.cycle_brent(f5, x0, ref lam, ref mu); Console.WriteLine(""); Console.WriteLine(" Reported cycle length is " + lam + ""); Console.WriteLine(" Expected value is 8"); Console.WriteLine(""); Console.WriteLine(" Reported distance to first cycle element is " + mu + ""); Console.WriteLine(" Expected value is 0"); int i = 0; x0 = 1; Console.WriteLine(" " + i + " " + x0 + ""); for (i = 1; i <= 10; i++) { x0 = f5(x0); Console.WriteLine(" " + i + " " + x0 + ""); } }
public void Oneeq10() { // Test case from http://www.polymath-software.com/library/nle/Oneeq10.htm Func <double, double> f1 = x => (1.0 / 63.0) * Math.Log(x) + (64.0 / 63.0) * Math.Log(1 / (1 - x)) + Math.Log(0.95 - x) - Math.Log(0.9); double r = Brent.FindRoot(f1, .01, 0.35, 1e-14); Assert.AreEqual(0.036210083704, r, 1e-5); Assert.AreEqual(0, f1(r), 1e-14); r = Brent.FindRoot(f1, 0.35, 0.7); Assert.AreEqual(0.5, r, 1e-5); Assert.AreEqual(0, f1(r), 1e-14); }
internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Brent obj) { return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr; }