Skip to content
Related Articles

Related Articles

Improve Article
Save Article
Like Article

Program to implement Simpson’s 3/8 rule

  • Difficulty Level : Hard
  • Last Updated : 13 Apr, 2021

Write a program to implement Simpson’s 3/8 rule.
The Simpsons’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 :
\int_{a}^{b} f(x) dx  \frac{3h}{8}  [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

 

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

 

C++




// CPP program to implement Simpson's rule
#include<iostream>
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




<?php
// PHP 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)
{
    $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.
?>

Javascript




<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

 




My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!