Program to implement Simpson’s 3/8 rule

• Difficulty Level : Hard
• Last Updated : 21 Sep, 2022

Write a program to implement Simpson’s 3/8 rule.
The Simpson’s 3/8 rule was developed by Thomas Simpson. This method is used for performing numerical integrations. This method is generally used for numerical approximation of definite integrals. Here, parabolas are used to approximate each part of curve.
Simpson’s 3/8 formula :
[Tex](     [/Tex]F(a) + 3F [Tex]\frac{2a + b}{3} )     [/Tex]+ 3F[Tex]\frac{a + 2b}{3} )     [/Tex]+ F(b)
Here,
h is the interval size given by h = ( b – a ) / n
n is number of intervals or interval limit
Examples :

Input : lower_limit = 1, upper_limit = 10,
interval_limit = 10
Output : integration_result = 0.687927

Input : lower_limit = 1, upper_limit = 5,
interval_limit = 3
Output : integration_result = 0.605835

C++

 // CPP program to implement Simpson's rule#includeusing namespace std; // Given function to be integratedfloat func( float x){    return (1 / ( 1 + x * x ));} // Function to perform calculationsfloat calculate(float lower_limit, float upper_limit,                int interval_limit ){    float value;    float interval_size = (upper_limit - lower_limit)                          / interval_limit;    float sum = func(lower_limit) + func(upper_limit);     // Calculates value till integral limit    for (int i = 1 ; i < interval_limit ; i++)    {        if (i % 3 == 0)            sum = sum + 2 * func(lower_limit + i * interval_size);        else            sum = sum + 3 * func(lower_limit + i * interval_size);    }    return ( 3 * interval_size / 8 ) * sum ;} // Driver Codeint main(){    int interval_limit = 10;    float lower_limit = 1;    float upper_limit = 10;    float integral_res = calculate(lower_limit, upper_limit,                                   interval_limit);     cout << integral_res;    return 0;}

Java

 // Java Code to implement Simpson's ruleimport java.util.*; class GFG {         // Given function to be integrated    static float func( float x)    {        return (1 / ( 1 + x * x ));    }          // Function to perform calculations    static float calculate(float lower_limit,                           float upper_limit, int interval_limit )    {        float value;        float interval_size = (upper_limit - lower_limit)                               / interval_limit;         float sum = func(lower_limit) + func(upper_limit);              // Calculates value till integral limit        for (int i = 1 ; i < interval_limit ; i++)        {            if (i % 3 == 0)                sum = sum + 2 * func(lower_limit                                     + i * interval_size);            else                sum = sum + 3 * func(lower_limit + i                                     * interval_size);        }        return ( 3 * interval_size / 8 ) * sum ;    }         // Driver program to test above function    public static void main(String[] args)    {        int interval_limit = 10;        float lower_limit = 1;        float upper_limit = 10;        float integral_res = calculate(lower_limit, upper_limit,                                       interval_limit);              System.out.println(integral_res);        }    } // This article is contributed by Arnav Kr. Mandal.

Python3

 # Python3 code to implement# Simpson's rule # Given function to be# integrateddef func(x):         return (float(1) / ( 1 + x * x ))   # Function to perform calculationsdef calculate(lower_limit, upper_limit, interval_limit ):         interval_size = (float(upper_limit - lower_limit) / interval_limit)    sum = func(lower_limit) + func(upper_limit);      # Calculates value till integral limit    for i in range(1, interval_limit ):        if (i % 3 == 0):            sum = sum + 2 * func(lower_limit + i * interval_size)        else:            sum = sum + 3 * func(lower_limit + i * interval_size)         return ((float( 3 * interval_size) / 8 ) * sum ) # driver functioninterval_limit = 10lower_limit = 1upper_limit = 10 integral_res = calculate(lower_limit, upper_limit, interval_limit) # rounding the final answer to 6 decimal placesprint (round(integral_res, 6)) # This code is contributed by Saloni.

C#

 // C# Code to implement Simpson's ruleusing System; class GFG {         // Given function to be integrated    static float func( float x)    {        return (1 / ( 1 + x * x ));    }         // Function to perform calculations    static float calculate(float lower_limit,                        float upper_limit, int interval_limit )    {        //float value;        float interval_size = (upper_limit - lower_limit)                            / interval_limit;         float sum = func(lower_limit) + func(upper_limit);             // Calculates value till integral limit        for (int i = 1 ; i < interval_limit ; i++)        {            if (i % 3 == 0)                sum = sum + 2 * func(lower_limit                                    + i * interval_size);            else                sum = sum + 3 * func(lower_limit + i                                    * interval_size);        }        return ( 3 * interval_size / 8 ) * sum ;    }         // Driver program to test above function    public static void Main()    {        int interval_limit = 10;        float lower_limit = 1;        float upper_limit = 10;        float integral_res = calculate(lower_limit, upper_limit,                                    interval_limit);             Console.WriteLine(integral_res);        }    } // This code is contributed by Vt_m.

PHP

 

Javascript

 

Output :

0.687927

Time Complexity: O(interval_limit)
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up