public void TestSimpsonRule() { SimpsonRule algorithm = new SimpsonRule(); Assert.That( algorithm.IntegrateThreePoint(TargetFunctionA, StartA, StopA), NumericIs.AlmostEqualTo(TargetAreaA, 1.7e-1), "Direct (2 Partitions)"); Assert.That( algorithm.IntegrateComposite(TargetFunctionA, StartA, StopA, 2), NumericIs.AlmostEqualTo(TargetAreaA, 1.7e-1), "Composite 2 Partitions"); Assert.That( algorithm.IntegrateComposite(TargetFunctionA, StartA, StopA, 6), NumericIs.AlmostEqualTo(TargetAreaA, 1.2e-1), "Composite 6 Partitions"); Assert.That( algorithm.IntegrateComposite(TargetFunctionA, StartA, StopA, 10), NumericIs.AlmostEqualTo(TargetAreaA, 8e-3), "Composite 10 Partitions"); Assert.That( algorithm.IntegrateComposite(TargetFunctionA, StartA, StopA, 50), NumericIs.AlmostEqualTo(TargetAreaA, 8e-6), "Composite 50 Partitions"); Assert.That( algorithm.IntegrateComposite(TargetFunctionA, StartA, StopA, 1000), NumericIs.AlmostEqualTo(TargetAreaA, 5e-11), "Composite 1000 Partitions"); }
public static float3 Integral(float4[] cp, float tOld, float tNew) { float intX = (float)SimpsonRule.IntegrateThreePoint(x => cp[0].x * m.pow(1 - x, 4) + 4f * cp[1].x * x * m.pow(1 - x, 3) + 6f * cp[2].x * m.pow(x, 2) * m.pow(1 - x, 2) + 4f * cp[3].x * m.pow(x, 4), tOld, tNew); float intY = (float)SimpsonRule.IntegrateThreePoint(x => cp[0].y * m.pow(1 - x, 4) + 4f * cp[1].y * x * m.pow(1 - x, 3) + 6f * cp[2].y * m.pow(x, 2) * m.pow(1 - x, 2) + 4f * cp[3].y * m.pow(x, 4), tOld, tNew); float intZ = (float)SimpsonRule.IntegrateThreePoint(x => cp[0].z * m.pow(1 - x, 4) + 4f * cp[1].z * x * m.pow(1 - x, 3) + 6f * cp[2].z * m.pow(x, 2) * m.pow(1 - x, 2) + 4f * cp[3].z * m.pow(x, 4), tOld, tNew); return(new float3(intX, intY, intZ)); }
public void SimpsonRuleSupportsThreePointIntegration() { Assert.AreEqual( TargetAreaA, SimpsonRule.IntegrateThreePoint(TargetFunctionA, StartA, StopA), 0.2 * TargetAreaA, "Direct (2 Partitions)"); }
//Calcula um valor especifico de distribuição normal multiplicando a constante pela integral da série private double CalculateNormalDistribuition(double z) { var firstPart = (1 / Math.Sqrt(2 * Math.PI)); var integrate = SimpsonRule.IntegrateComposite(x => CalcSomatorio(x, 27), 0, z, 10000); var result = firstPart * integrate; return(result); }
public void SimpsonRuleSupportsCompositeIntegration(int partitions, double maxRelativeError) { Assert.AreEqual( TargetAreaA, SimpsonRule.IntegrateComposite(TargetFunctionA, StartA, StopA, partitions), maxRelativeError * TargetAreaA, "Composite {0} Partitions", partitions); }
public void SimpsonRuleSupportsCompositeIntegration([Values(2, 6, 10, 50, 1000)] int partitions, [Values(1.7e-1, 1.2e-1, 8e-3, 8e-6, 5e-11)] double maxRelativeError) { Assert.AreEqual( TargetAreaA, SimpsonRule.IntegrateComposite(TargetFunctionA, StartA, StopA, partitions), maxRelativeError * TargetAreaA, "Composite {0} Partitions", partitions); }
public static double simpsonRuleEs(Expr expr, string varName, double a, double b, int n) { var f = expr.Compile(varName); double srValue = SimpsonRule.IntegrateComposite(f, a, b, n); double trueValue = Integrate.OnClosedInterval(f, a, b); return(abs(trueValue - srValue)); }
public static double CalculateStrictValue(FuzzyNumber fuzzyNumber) { var leftX = fuzzyNumber.M - fuzzyNumber.L; var leftValue = fuzzyNumber.L; var rightX = fuzzyNumber.U - fuzzyNumber.M; var rightValue = fuzzyNumber.U; var finalX = leftX - rightX; var finalValue = rightValue + leftValue; return(SimpsonRule.IntegrateThreePoint(x => 0.5 * (finalX * x + finalValue), 0.0, 1.0)); }
public double getObjectiveValue(double Qflow) { double f = 0.0; double c1 = 0, c0 = 0, c2 = 0, c5 = 0, c6 = 0, c3 = 0; int c4 = 0; double Qadd = 0; //oklart vad dena tillför Convert.ToDouble(kf); double X = (Qflow + Qadd) / kf; //flöde per körfält switch (vdValue) { case 3: c1 = 100; c0 = 0.1; break; case 10: c1 = 13; c0 = 10; break; case 11: c1 = 35; c0 = 2; break; case 12: c1 = 35; c0 = 4; break; case 13: c1 = 20; c0 = 6; break; case 14: c1 = 22.22; c0 = 6; break; } if (c1 == 0) { // fungerar double intervalBegin = 0; double intervalEnd = X; double partitionNumbers = 10.0; double deltaX = (intervalEnd - intervalBegin) / partitionNumbers; double SimpsonsIntegration = (deltaX / 3) * (getTime(intervalBegin, vdValue) + 4 * getTime(intervalBegin + deltaX * 1, vdValue) + 2 * getTime(intervalBegin + deltaX * 2, vdValue) + 4 * getTime(intervalBegin + deltaX * 3, vdValue) + 2 * getTime(intervalBegin + deltaX * 4, vdValue) + 2 * getTime(intervalBegin + deltaX * 5, vdValue) + 4 * getTime(intervalBegin + deltaX * 6, vdValue) + 2 * getTime(intervalBegin + deltaX * 7, vdValue) + 4 * getTime(intervalBegin + deltaX * 8, vdValue) + 2 * getTime(intervalBegin + deltaX * 9, vdValue) + getTime(intervalEnd, vdValue)); f = SimpsonsIntegration * kf; } else { f = SimpsonRule.IntegrateComposite(x => ((60 * length) / c1 + c0), 0, Qflow, 10); } return(f * (100.0 / 60.0)); }
/// <summary> /// Simpsonses the rule integral. /// </summary> /// <returns>The rule integral.</returns> /// <param name="values">Values.</param> public static List <decimal> SimpsonsRuleIntegral(List <decimal> values) { var integralVals = new List <decimal>(); if (values.Any()) { currentVals = values.Select(x => (double)x).ToList(); for (int i = 1; i < currentVals.Count(); i++) { var simpsonIntegral = SimpsonRule.IntegrateComposite(GetValue, 0, i, (i * 2)); integralVals.Add((decimal)simpsonIntegral); } } return(integralVals); }
private void btn_Integrate_Click(object sender, EventArgs e) { double a = Convert.ToDouble(txt_A.Text), b = Convert.ToDouble(txt_B.Text); string Function = txt_Func.Text; SymbolicExpression x = Variable("x"); Func <double, double> f = Parse(Function).Compile(nameof(x)); double IntegrationResult = SimpsonRule.IntegrateComposite(f, a, b, 4); txt_Result.Text = IntegrationResult.ToString(); // Draw area under function graph var model = new PlotModel { Title = "Area of f(x)" }; var series = new AreaSeries { Title = "∫ f(x)dx" }; for (double x_val = a; x_val <= b; x_val += 0.01d) { series.Points.Add(new DataPoint(x_val, f(x_val))); series.Points2.Add(new DataPoint(x_val, 0)); } series.Color2 = OxyColors.Transparent; model.Series.Add(series); FunctionSeries func = new FunctionSeries(f, a - (1.0d / 4.0d) * Math.Abs(a), b + (1.0d / 4.0d) * b, 0.01d, "f(x)"); model.Series.Add(func); plot1.Model = model; }
/// <summary> /// Funzione che calcola l'integrale tra a e b della funzione di densità di probabilità. /// </summary> /// <param name="a">L'estremo sinistro dell'intervallo. Può anche essere -∞.</param> /// <param name="b">L'estremo destro dell'intervallo. Può anche essere +∞.</param> /// <param name="sigma">Lo scarto quadratico medio. Se non passato, di default è 1.</param> /// <param name="mu">La media. Se non passata, di default è 0.</param> /// <returns>Il valore dell'area</returns> public static double CalcolaIntegrale(double a, double b, double sigma = 1, double mu = 0) { //check condizioni di operabilità if (a > b || a.Equals(double.PositiveInfinity) || b.Equals(double.NegativeInfinity) || sigma < 0 || mu < 0) { return(double.NaN); } // - e + inf if (a == double.NegativeInfinity && b == double.PositiveInfinity) { return(1); } // -inf e valore if (a == double.NegativeInfinity) { if (b >= mu) { return(0.5 + SimpsonRule.IntegrateComposite(funzioneDensita(mu, sigma), mu, b, 100000)); } else { return(0.5 - SimpsonRule.IntegrateComposite(funzioneDensita(mu, sigma), mu, -b, 100000)); } } // valore e +inf else if (b == double.PositiveInfinity) { if (a >= mu) { return(0.5 - SimpsonRule.IntegrateComposite(funzioneDensita(mu, sigma), mu, a, 100000)); } else { return(0.5 + SimpsonRule.IntegrateComposite(funzioneDensita(mu, sigma), mu, -a, 100000)); } } return(SimpsonRule.IntegrateComposite(funzioneDensita(mu, sigma), a, b, 100000)); }
//************************************************************************** // Function: WaterUsage // // Description: Calculate the water usage of a specific pivot. Based on // the Pacific University 2021 mathematics capstone 'RainCat' // // Parameters: fieldTable - FieldTable object to calculate water usage of // // Returns: Total water that the pivot uses. //************************************************************************** public static double WaterUsage(ref FieldTable fieldTable) { double constA = SoilModel.InfiltrationConstants[fieldTable.SoilType].Item1; double constB = SoilModel.InfiltrationConstants[fieldTable.SoilType].Item2; double totalWater = 0; double t_a = 0; double da_dt_max = 0; double da_dt = 0; double di_dt = 0; double intersect1 = 0; double intersect2 = 0; bool bInt1Found = false; bool bInt2Found = false; double circumference = 0; double totalSlice = 0; double integration = 0; // For each sprinkler in the pivot for (int i = CenterPivotModel.Spacing; i < fieldTable.PivotLength; i += CenterPivotModel.Spacing) { // Get sprinkler specific data t_a = (CenterPivotModel.RevolutionTime) * (CenterPivotModel.WettedDiameter / (2 * Math.PI * i)); da_dt_max = (4 / Math.PI) * (CenterPivotModel.WettedSoilDepth / t_a); // Find first intersection by incrementing through small time increments starting at zero for (double t = .001; t < t_a && bInt1Found == false; t += .001) { da_dt = (da_dt_max) * Math.Sqrt(1 - (Math.Pow((t - (t_a / 2)), 2) / Math.Pow(t_a / 2, 2))); di_dt = 600 * constA * constB * Math.Pow(t, constB - 1); if (di_dt - da_dt < 1 && di_dt - da_dt > -1) { intersect1 = t; bInt1Found = true; } } // If first intersection is found then we need to search for the second if (true == bInt1Found) { // Find second intersection by incrementing through small time increments starting at the end of the interval for (double t = t_a; t > intersect1 + .005 && bInt2Found == false; t -= .001) { da_dt = (da_dt_max) * Math.Sqrt(1 - (Math.Pow((t - (t_a / 2)), 2) / Math.Pow(t_a / 2, 2))); di_dt = 600 * constA * constB * Math.Pow(t, constB - 1); if (di_dt - da_dt < 1 && di_dt - da_dt > -1) { intersect2 = t; bInt2Found = true; } } } // If both intersections are found then we have enough information to get the water usage stats if (true == bInt1Found && true == bInt2Found) { // Get distance traveled then integrate to get amount of water used from t_0 to t_1 circumference = 2 * Math.PI * i; totalSlice = (circumference / CenterPivotModel.RevolutionTime) * (intersect2 - intersect1); integration = SimpsonRule.IntegrateComposite(x => (da_dt_max) * Math.Sqrt(1 - (Math.Pow((x - (t_a / 2)), 2) / Math.Pow(t_a / 2, 2))), 0, intersect1, 4); } // If first intersection was not found, OR if second intersection was not found then assume pivot will run entire time else if (false == bInt1Found || false == bInt2Found) { circumference = 2 * Math.PI * i; totalSlice = (circumference / CenterPivotModel.RevolutionTime) * (t_a - 0); integration = SimpsonRule.IntegrateComposite(x => (da_dt_max) * Math.Sqrt(1 - (Math.Pow((x - (t_a / 2)), 2) / Math.Pow(t_a / 2, 2))), 0, t_a, 4); } totalWater += integration * (circumference / totalSlice); // Reset Values intersect1 = 0; intersect2 = 0; bInt1Found = false; bInt2Found = false; circumference = 0; totalSlice = 0; } return(totalWater); }
/// <summary> /// Остаток на складе /// </summary> /// <param name="lb"></param> /// <param name="ub"></param> /// <param name="t"></param> /// <returns></returns> double I(double lb, double ub, double t) { double rez = SimpsonRule.IntegrateThreePoint(x => D(x), lb, ub) - SimpsonRule.IntegrateThreePoint(x => D(x), lb, t); return(rez); }
public void TestSimpsonRule() { SimpsonRule algorithm = new SimpsonRule(); Assert.That( algorithm.IntegrateThreePoint(TargetFunctionA, StartA, StopA), NumericIs.AlmostEqualTo(TargetAreaA, 1.7e-1), "Direct (2 Partitions)"); Assert.That( algorithm.IntegrateComposite(TargetFunctionA, StartA, StopA, 2), NumericIs.AlmostEqualTo(TargetAreaA, 1.7e-1), "Composite 2 Partitions"); Assert.That( algorithm.IntegrateComposite(TargetFunctionA, StartA, StopA, 6), NumericIs.AlmostEqualTo(TargetAreaA, 1.2e-1), "Composite 6 Partitions"); Assert.That( algorithm.IntegrateComposite(TargetFunctionA, StartA, StopA, 10), NumericIs.AlmostEqualTo(TargetAreaA, 8e-3), "Composite 10 Partitions"); Assert.That( algorithm.IntegrateComposite(TargetFunctionA, StartA, StopA, 50), NumericIs.AlmostEqualTo(TargetAreaA, 8e-6), "Composite 50 Partitions"); Assert.That( algorithm.IntegrateComposite(TargetFunctionA, StartA, StopA, 1000), NumericIs.AlmostEqualTo(TargetAreaA, 5e-11), "Composite 1000 Partitions"); }
public static double simpsonRule(Expr expr, string varName, double a, double b, int n) { var f = expr.Compile(varName); return(SimpsonRule.IntegrateComposite(f, a, b, n)); }
static void Main(string[] args) { /// Git test project Console.WriteLine("ASP joined the project"); /// Simpsons Rule //--------------------------------------------- Console.WriteLine("Simpson integration"); Console.WriteLine(""); // Composite approximation with 4 partitions double composite = SimpsonRule.IntegrateComposite(x => x * x, 0.0, 10.0, 4); // Approximate value using IntegrateComposite with 4 partitions is: 333.33333333333337 Console.WriteLine("Approximate value using IntegrateComposite with 4 partitions is: " + composite); // Three point approximation double threePoint = SimpsonRule.IntegrateThreePoint(x => x * x, 0.0, 10.0); // Approximate value using IntegrateThreePoint is: 333.333333333333 Console.WriteLine("Approximate value using IntegrateThreePoint is: " + threePoint); /// Gauss-Legendre integration //--------------------------------------------- Console.WriteLine(""); Console.WriteLine("Gauss-Legendre integration"); Console.WriteLine(""); // Create a 5-point Gauss-Legendre rule over the integration interval [0, 10] GaussLegendreRule rule = new GaussLegendreRule(0.0, 10.0, 5); double sum = 0; // Will hold the approximate value of the integral for (int i = 0; i < rule.Order; i++) // rule.Order = 5 { // Access the ith abscissa and weight sum += rule.GetWeight(i) * rule.GetAbscissa(i) * rule.GetAbscissa(i); } // Approximate value is: 333.333333333333 Console.WriteLine("Approximate value is: " + sum); // The order of the rule is: 5 Console.WriteLine("The order of the rule is: " + rule.Order); // 1D integration using a 5-point Gauss-Legendre rule over the integration interval [0, 10] double integrate1D = GaussLegendreRule.Integrate(x => x * x * x, 0.0, 10.0, 5); // Approximate value of the 1D integral is: 333.333333333333 Console.WriteLine("Approximate value of the 1D integral is: " + integrate1D); // 2D integration using a 5-point Gauss-Legendre rule over the integration interval [0, 10] X [1, 2] double integrate2D = GaussLegendreRule.Integrate((x, y) => (x * x) * (y * y), 0.0, 10.0, 1.0, 2.0, 5); // Approximate value of the 2D integral is: 777.777777777778 Console.WriteLine("Approximate value of the 2D integral is: " + integrate2D); Console.ReadLine(); }