Trapezoidal Rule for Approximate Value of Definite Integral

In the field of numerical analysis, Trapezoidal rule is used to find the approximation of a definite integral. The basic idea in Trapezoidal rule is to assume the region under the graph of the given function to be a trapezoid and calculate its area. 
It follows that:

For more accurate results the domain of the graph is divided into n segments of equal size as shown below: 

Grid spacing or segment size h = (b-a) / n. 
Therefore, approximate value of the integral can be given by: 

C++

// C++ program to implement Trapezoidal rule
#include<stdio.h>

// A sample function whose definite integral's
// approximate value is computed using Trapezoidal
// rule
float y(float x)
{
    // Declaring the function f(x) = 1/(1+x*x)
    return 1/(1+x*x);
}

// Function to evaluate the value of integral
float trapezoidal(float a, float b, float n)
{
    // Grid spacing
    float h = (b-a)/n;

    // Computing sum of first and last terms
    // in above formula
    float s = y(a)+y(b);

    // Adding middle terms in above formula
    for (int i = 1; i < n; i++)
        s += 2*y(a+i*h);

    // h/2 indicates (b-a)/2n. Multiplying h/2
    // with s.
    return (h/2)*s;
}

// Driver program to test above function
int main()
{
    // Range of definite integral
    float x0 = 0;
    float xn = 1;

    // Number of grids. Higher value means
    // more accuracy
    int n = 6;

    printf("Value of integral is %6.4f\n",
                  trapezoidal(x0, xn, n));
    return 0;
}

Java

// Java program to implement Trapezoidal rule

class GFG
{
    // A sample function whose definite
    // integral's approximate value
    // is computed using Trapezoidal
    // rule
    static float y(float x)
    {
        // Declaring the function
        // f(x) = 1/(1+x*x)
        return 1 / (1 + x * x);
    }

    // Function to evaluate the value of integral
    static float trapezoidal(float a, float b, float n)
    {
        // Grid spacing
        float h = (b - a) / n;

        // Computing sum of first and last terms
        // in above formula
        float s = y(a) + y(b);

        // Adding middle terms in above formula
        for (int i = 1; i < n; i++)
            s += 2 * y( a + i * h);

        // h/2 indicates (b-a)/2n. Multiplying h/2
        // with s.
        return (h / 2) * s;
    }

    // Driver code
    public static void main (String[] args)
    {
        // Range of definite integral
        float x0 = 0;
        float xn = 1;

        // Number of grids. Higher
        // value means more accuracy
        int n = 6;

        System.out.println("Value of integral is "+
                           Math.round(trapezoidal(x0, xn, n)
                           * 10000.0) / 10000.0);
    }
}

// This code is contributed by Anant Agarwal.

Python3

# Python3 code to implement Trapezoidal rule

# A sample function whose definite
# integral's approximate value is
# computed using Trapezoidal rule
def y( x ):

    # Declaring the function
    # f(x) = 1/(1+x*x)
    return (1 / (1 + x * x))

# Function to evaluate the value of integral
def trapezoidal (a, b, n):

    # Grid spacing
    h = (b - a) / n

    # Computing sum of first and last terms
    # in above formula
    s = (y(a) + y(b))

    # Adding middle terms in above formula
    i = 1
    while i < n:
        s += 2 * y(a + i * h)
        i += 1

    # h/2 indicates (b-a)/2n.
    # Multiplying h/2 with s.
    return ((h / 2) * s)

# Driver code to test above function
# Range of definite integral
x0 = 0
xn = 1

# Number of grids. Higher value means
# more accuracy
n = 6
print ("Value of integral is ",
     "%.4f"%trapezoidal(x0, xn, n))


# This code is contributed by "Sharad_Bhardwaj".

C#

// C# program to implement Trapezoidal
// rule.
using System;

class GFG {

    // A sample function whose definite
    // integral's approximate value
    // is computed using Trapezoidal
    // rule
    static float y(float x)
    {

        // Declaring the function
        // f(x) = 1/(1+x*x)
        return 1 / (1 + x * x);
    }

    // Function to evaluate the value
    // of integral
    static float trapezoidal(float a,
                       float b, float n)
    {

        // Grid spacing
        float h = (b - a) / n;

        // Computing sum of first and
        // last terms in above formula
        float s = y(a) + y(b);

        // Adding middle terms in above
        // formula
        for (int i = 1; i < n; i++)
            s += 2 * y( a + i * h);

        // h/2 indicates (b-a)/2n.
        // Multiplying h/2 with s.
        return (h / 2) * s;
    }

    // Driver code
    public static void Main ()
    {

        // Range of definite integral
        float x0 = 0;
        float xn = 1;

        // Number of grids. Higher
        // value means more accuracy
        int n = 6;

        Console.Write("Value of integral is "
          + Math.Round(trapezoidal(x0, xn, n)
                        * 10000.0) / 10000.0);
    }
}

// This code is contributed by nitin mittal.

PHP

<?php
// PHP program to implement Trapezoidal rule

// A sample function whose definite
// integral's approximate value is
// computed using Trapezoidal rule
function y($x)
{

    // Declaring the function
    // f(x) = 1/(1+x*x)
    return 1 / (1 + $x * $x);
}

// Function to evaluate the
// value of integral
function trapezoidal($a, $b, $n)
{

    // Grid spacing
    $h = ($b - $a) / $n;

    // Computing sum of first
    // and last terms
    // in above formula
    $s = y($a) + y($b);

    // Adding middle terms
    // in above formula
    for ($i = 1; $i < $n; $i++)
        $s += 2 * Y($a + $i * $h);

    // h/2 indicates (b-a)/2n.
    // Multiplying h/2 with s.
    return ($h / 2) * $s;
}

    // Driver Code
    // Range of definite integral
    $x0 = 0;
    $xn = 1;

    // Number of grids.
    // Higher value means
    // more accuracy
    $n = 6;

    echo("Value of integral is ");
    echo(trapezoidal($x0, $xn, $n));

// This code is contributed by nitin mittal
?>

Javascript

<script>

// Javascript program to implement Trapezoidal rule

// A sample function whose definite
// integral's approximate value
// is computed using Trapezoidal
// rule
function y(x)
{

    // Declaring the function
    // f(x) = 1/(1+x*x)
    return 1 / (1 + x * x);
}

// Function to evaluate the value of integral
function trapezoidal(a, b, n)
{

    // Grid spacing
    let h = (b - a) / n;

    // Computing sum of first and last terms
    // in above formula
    let s = y(a) + y(b);

    // Adding middle terms in above formula
    for(let i = 1; i < n; i++)
        s += 2 * y(a + i * h);

    // h/2 indicates (b-a)/2n. Multiplying h/2
    // with s.
    return (h / 2) * s;
}

// Driver code

// Range of definite integral
let x0 = 0;
let xn = 1;

// Number of grids. Higher
// value means more accuracy
let n = 6;

document.write("Value of integral is "+
               Math.round(trapezoidal(x0, xn, n) *
               10000.0) / 10000.0);

// This code is contributed by code_hunt

</script>

Output: 

Value of integral is 0.7842

References:
https://en.wikipedia.org/wiki/Trapezoidal_rule