private void GenerateOrthogonality() { double a = 0.01; double b = 10e4; var lg = new Laguerre(FirstDegree); var lg2 = new Laguerre(SecondDegree); double dx = (b - a) / (steps - 1); double x; double integral = 0.0; alpha = 0; double fx1; if (alpha != 0) { integral = NewtonCotesTrapeziumRule.IntegrateTwoPoint(z => (lg.Polynomial.FunctionValueInPoint(z) * lg2.Polynomial.FunctionValueInPoint(z) * Math.Pow(z, -alpha) * Math.Exp(-z)), 0.0, 100); } else { for (int i = 0; i < steps; i++) { //x = Convert.ToDouble(i); x = Convert.ToDouble(i) * dx + a; fx1 = lg.Polynomial.FunctionValueInPoint(x) * lg2.Polynomial.FunctionValueInPoint(x) * (Math.Pow(x, alpha) * Math.Exp(-x)); //x += dx; //double fx2 = lg.Polynomial.FunctionValueInPoint(x) * lg2.Polynomial.FunctionValueInPoint(x) * (Math.Pow(x, alpha) * Math.Exp(-x)); //integral += 0.5 * dx * (fx1 + fx2); integral += fx1 * dx; } } Orthogonal = integral; }
public void TrapeziumRuleSupportsTwoPointIntegration() { Assert.AreEqual( TargetAreaA, NewtonCotesTrapeziumRule.IntegrateTwoPoint(TargetFunctionA, StartA, StopA), 0.4 * TargetAreaA, "Direct (1 Partition)"); }
public void TrapeziumRuleSupportsAdaptiveIntegration(double targetRelativeError) { Assert.AreEqual( TargetAreaA, NewtonCotesTrapeziumRule.IntegrateAdaptive(TargetFunctionA, StartA, StopA, targetRelativeError), targetRelativeError * TargetAreaA, "Adaptive {0}", targetRelativeError); }
public void TrapeziumRuleSupportsCompositeIntegration(int partitions, double maxRelativeError) { Assert.AreEqual( TargetAreaA, NewtonCotesTrapeziumRule.IntegrateComposite(TargetFunctionA, StartA, StopA, partitions), maxRelativeError * TargetAreaA, "Composite {0} Partitions", partitions); }
public void TrapeziumRuleSupportsCompositeIntegration([Values(1, 5, 10, 50, 1000)] int partitions, [Values(3.5e-1, 1e-1, 2e-2, 6e-4, 1.5e-6)] double maxRelativeError) { Assert.AreEqual( TargetAreaA, NewtonCotesTrapeziumRule.IntegrateComposite(TargetFunctionA, StartA, StopA, partitions), maxRelativeError * TargetAreaA, "Composite {0} Partitions", partitions); }
public static double trapezoidalRuleEt(Expr expr, string varName, double a, double b, int n) { var f = expr.Compile(varName); double trValue = NewtonCotesTrapeziumRule.IntegrateComposite(f, a, b, n); double trueValue = Integrate.OnClosedInterval(f, a, b); return(abs(trueValue - trValue)); }
// This evaluates the SQUARED intergral of (S*Etan) public static double TFInt( Vector <Double> ETan_Z, Vector <Complex> ETan_RMS, Vector <Double> TF_Z, Vector <Complex> TF_Sr ) { int num_points = 5000; double zmin = Math.Max(TF_Z.Minimum(), ETan_Z.Minimum()); double zmax = Math.Min(TF_Z.Maximum(), ETan_Z.Maximum()); LinearSpline etansinterpR = LinearSpline.Interpolate( ETan_Z, ETan_RMS.Real()); LinearSpline etansinterpI = LinearSpline.Interpolate( ETan_Z, ETan_RMS.Imaginary()); LinearSpline TF_SrInterpR = LinearSpline.Interpolate( TF_Z, TF_Sr.Real()); LinearSpline TF_SrInterpI = LinearSpline.Interpolate( TF_Z, TF_Sr.Imaginary()); /*var ETanGridded = CreateVector.DenseOfEnumerable( * zvals.Select(z => new Complex( * etansinterpR.Interpolate(z), etansinterpI.Interpolate(z))) * ); * var SrGridded = CreateVector.DenseOfEnumerable( * zvals.Select(z => new Complex( * TF_SrInterpR.Interpolate(z), TF_SrInterpI.Interpolate(z))) * );*/ //var Z = SrGridded.PointwiseMultiply(ETanGridded); // This is the integrand, SR*Etan Func <double, Complex> SrEtan = (z) => { var s = new Complex( TF_SrInterpR.Interpolate(z), TF_SrInterpI.Interpolate(z)); var e = new Complex( etansinterpR.Interpolate(z), etansinterpI.Interpolate(z)); return(s * e); }; // And to integrate it, the real and imaginary components must be // separately computed. Complex sum = new Complex( NewtonCotesTrapeziumRule.IntegrateComposite( (z => SrEtan(z).Real), zmin, zmax, num_points), NewtonCotesTrapeziumRule.IntegrateComposite( (z => SrEtan(z).Imaginary), zmin, zmax, num_points) ); // Usually we need the magnitude squared (for the temperature calculations) // But, the caller may find the square root, if needed, for example for voltages double dT = sum.MagnitudeSquared(); return(dT); }
private double CalculateAverageDopplerShift( QQDataFunction function, double qgpTemperature, double qgpVelocity ) { Func <double, double> integrand = cosine => function( GetDopplerShiftedTemperature(qgpTemperature, qgpVelocity, cosine)); return(0.5 * NewtonCotesTrapeziumRule.IntegrateComposite( integrand, -1, 1, NumberAveragingAngles)); }
/// <summary> /// Calculates the p. /// </summary> /// <returns>The p.</returns> private double P(int j) { double v = _VarianceParameters.V0; double x = Math.Log(_InitialStockPrice); // Integrand Func <double, double> integrad = phi => ((Complex.Exp(new Complex(0, -phi * Math.Log(_StrikePrice))) * (Complex.Exp(C(j, phi) + D(j, phi) * v + new Complex(0, phi * x)))) / new Complex(0, phi)).Real; double integral = NewtonCotesTrapeziumRule.IntegrateAdaptive(integrad, 1e-6, 1000, 1e-5); return(0.5 + (integral / Math.PI)); }
private void GenerateOrthogonality2() { double a = 0; double b = 10e10; double dx = (b - a) / steps; double x; double integral = 0.0; alpha = 0; for (int i = 0; i < steps; i++) { x = Convert.ToDouble(i); x = x * dx + a; double fx1 = alglib.laguerrecalculate(FirstDegree, x) * alglib.laguerrecalculate(SecondDegree, x) * (Math.Pow(x, alpha) * Math.Exp(-x)); x += dx; double fx2 = alglib.laguerrecalculate(FirstDegree, x) * alglib.laguerrecalculate(SecondDegree, x) * (Math.Pow(x, alpha) * Math.Exp(-x)); integral += 0.5 * dx * (fx1 + fx2); } double adaptive = NewtonCotesTrapeziumRule.IntegrateTwoPoint(z => (alglib.laguerrecalculate(degree, z) * alglib.laguerrecalculate(degree, z) * Math.Exp(-z)), 0.0, 10e10); //Orthogonal = integral.ToString(); }
/// <summary> /// the formula for calculating /// </summary> /// <param name="S">Initial Stock Price</param> /// <param name="r">Risk Free Rate</param> /// <param name="T">Maturity</param> /// <param name="K">Strike Price</param> /// <returns>the final price of Euorpean option</returns> public double CalculateCallOptionPrice(double S, double K, double r, double T) { double b1 = k - rho * sigma; double b2 = k; double a = k * theta; if (sigma <= 0 || T <= 0 || K <= 0 || S <= 0) { throw new System.ArgumentException("Need sigma > 0, T > 0, K > 0 and S > 0."); } Complex d1(double phi) { return(Complex.Sqrt(Complex.Pow(rho * sigma * phi * i - b1, 2.0) - sigma * sigma * (2.0 * u1 * phi * i - phi * phi))); } Complex d2(double phi) { return(Complex.Sqrt(Complex.Pow(rho * sigma * phi * i - b2, 2.0) - sigma * sigma * (2.0 * u2 * phi * i - phi * phi))); } Complex g1(double phi) { return((b1 - rho * sigma * phi * i - d1(phi)) / (b1 - rho * sigma * phi * i + d1(phi))); } Complex g2(double phi) { return((b2 - rho * sigma * phi * i - d2(phi)) / (b2 - rho * sigma * phi * i + d2(phi))); } Complex C1(double tau, double phi) { return(r * phi * i * tau + (a / Math.Pow(sigma, 2.0)) * ((b1 - rho * sigma * phi * i - d1(phi)) * tau - 2.0 * Complex.Log((1.0 - g1(phi) * Complex.Exp(-tau * d1(phi))) / (1.0 - g1(phi))))); } Complex C2(double tau, double phi) { return(r * phi * i * tau + (a / Math.Pow(sigma, 2.0)) * ((b2 - rho * sigma * phi * i - d2(phi)) * tau - 2.0 * Complex.Log((1.0 - g2(phi) * Complex.Exp(-tau * d2(phi))) / (1.0 - g2(phi))))); } Complex D1(double tau, double phi) { return(((b1 - rho * sigma * phi * i - d1(phi)) / Math.Pow(sigma, 2.0)) * ((1.0 - Complex.Exp(-tau * d1(phi))) / (1.0 - g1(phi) * Complex.Exp(-tau * d1(phi))))); } Complex D2(double tau, double phi) { return(((b2 - rho * sigma * phi * i - d2(phi)) / Math.Pow(sigma, 2.0)) * ((1.0 - Complex.Exp(-tau * d2(phi))) / (1.0 - g2(phi) * Complex.Exp(-tau * d2(phi))))); } Complex Phi1(double x, double phi) { return(Complex.Exp(C1(T, phi) + D1(T, phi) * nv + i * phi * x)); } Complex Phi2(double x, double phi) { return(Complex.Exp(C2(T, phi) + D2(T, phi) * nv + i * phi * x)); } Complex integrand1(double x, double phi) { return((Complex.Exp(-i * phi * Math.Log(K)) * Phi1(x, phi)) / (i * phi)); } Complex integrand2(double x, double phi) { return((Complex.Exp(-i * phi * Math.Log(K)) * Phi2(x, phi)) / (i * phi)); } double P1(double x) { Func <double, double> IntegrateFormula = (phi) => { Complex aj = integrand1(x, phi); return(aj.Real); }; CompositeIntegrator integrator = new CompositeIntegrator(4); /*double integral = integrator.Integrate(IntegrateFormula, 0.0001, 10000, 10000);*/ double integral = NewtonCotesTrapeziumRule.IntegrateComposite(IntegrateFormula, 0.0001, 10000, 10000); /*double integral = DoubleExponentialTransformation.Integrate(IntegrateFormula, 0.01, 1e3, 1e-5);*/ return(0.50 + (1 / Math.PI) * integral); } double P2(double x) { Func <double, double> IntegrateFormula = (phi) => { Complex al = integrand2(x, phi); return(al.Real); }; CompositeIntegrator integrator = new CompositeIntegrator(4); /*double integral = integrator.Integrate(IntegrateFormula, 0.0001, 10000, 10000);*/ double integral2 = NewtonCotesTrapeziumRule.IntegrateComposite(IntegrateFormula, 0.0001, 10000, 10000); /*double integral = DoubleExponentialTransformation.Integrate(IntegrateFormula, 0.01, 1e3, 1e-5);*/ return(0.50 + (1 / Math.PI) * integral2); } return(S * P1(Math.Log(S)) - Math.Exp(-r * T) * K * P2(Math.Log(S))); }
public double Integrate(ITestFunction testFunction, double tolerance) { return(NewtonCotesTrapeziumRule.IntegrateAdaptive(testFunction.Eval, testFunction.A, testFunction.B, tolerance)); }
public static double trapezoidalRuleError(Expr expr, string varName, double a, double b, double Et) { var f = expr.Compile(varName); return(NewtonCotesTrapeziumRule.IntegrateAdaptive(f, a, b, Et)); }
public static double trapezoidalRule(Expr expr, string varName, double a, double b, int n) { var f = expr.Compile(varName); return(NewtonCotesTrapeziumRule.IntegrateComposite(f, a, b, n)); }