Program to implement Simpson’s 3/8 rule

16 May, 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 limitExamples :  
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++
Java
Python3
C#
PHP
Javascript
// CPP program to implement Simpson's rule#include<iostream>using 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 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 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# 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// PHP program to implement// Simpson's rule // Given function to be integratedfunction func( $x){    return (1 / ( 1 + $x * $x ));} // Function to perform calculationsfunction calculate($lower_limit, $upper_limit,                   $interval_limit){    $interval_size = ($upper_limit -                      $lower_limit) /                      $interval_limit;    $sum = func($lower_limit) +           func($upper_limit);     // Calculates value till    // integral limit    for ($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 Code$interval_limit = 10;$lower_limit = 1;$upper_limit = 10;$integral_res = calculate($lower_limit, $upper_limit,                          $interval_limit); echo $integral_res;     // This code is contributed by mits.?>
<script> // javascript program to implement Simpson's rule // Given function to be integrated    function func(x)    {        return (1 / ( 1 + x * x ));    }            // Function to perform calculations    function calculate(lower_limit,                           upper_limit, interval_limit )    {        let value;        let interval_size = (upper_limit - lower_limit)                               / interval_limit;           let sum = func(lower_limit) + func(upper_limit);                // Calculates value till integral limit        for (let 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 Function         let interval_limit = 10;        let lower_limit = 1;        let upper_limit = 10;        let integral_res = calculate(lower_limit, upper_limit,                                       interval_limit);                document.write(integral_res);         // This code is contributed by susmitakundugoaldanga.</script>
Output :  
0.687927
 
Mithun Kumar
susmitakundugoaldanga
simmytarika5
Algebra
Mathematical
Mathematical
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Algorithm to solve Rubik's Cube
Merge two sorted arrays with O(1) extra space
Program to print prime numbers from 1 to N.
Segment Tree | Set 1 (Sum of given range)
Check if a number is Palindrome
Count ways to reach the n'th stair
Fizz Buzz Implementation
Median of two sorted arrays of same size
Product of Array except itself
Find Union and Intersection of two unsorted arrays