# 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 #include using namespace std;   // Given function to be integrated float func( float x) {     return (1 / ( 1 + x * x )); }   // Function to perform calculations 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 Code int 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 rule import 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 # integrated def func(x):           return (float(1) / ( 1 + x * x ))      # Function to perform calculations def 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 function interval_limit = 10 lower_limit = 1 upper_limit = 10   integral_res = calculate(lower_limit, upper_limit, interval_limit)   # rounding the final answer to 6 decimal places  print (round(integral_res, 6))   # This code is contributed by Saloni.

## C#

 // C# Code to implement Simpson's rule using 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
Related Articles