Programa para implementar la regla 3/8 de Simpson

Escriba un programa para implementar la regla 3/8 de Simpson.
La regla de los 3/8 de Simpson fue desarrollada por Thomas Simpson. Este método se utiliza para realizar integraciones numéricas. Este método se utiliza generalmente para la aproximación numérica de integrales definidas. Aquí, las parábolas se utilizan para aproximar cada parte de la curva.
Fórmula 3/8 de Simpson:
=  [Tex]( [/Tex]F(a) + 3F  [Tex]\frac{2a + b}{3} ) [/Tex]+ 3F [Tex]\frac{a + 2b }{3} ) [/Tex]+ F(b) 
Aquí, 
h es el tamaño del intervalo dado por h = ( b – a ) / n 
n es el número de intervalos o límite de intervalo
Ejemplos : 
 

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

// 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 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 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# 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 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.
?>

<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>

Producción : 
 

0.687927