Finding Integrand using Weedle’s Rule

Given a function and two integers a and b. The task is to find the integrand of the given function from lower limit(a) to the upper limit(b) using Weedle’s Rule. 
The given function is: 

Examples:

Input: a = 0, b = 6 
Output: 1.373448

Input: a = 10, b = 13 
Output: f(x) = 0.022897 

Approach:
The integration of any function using Weedle’s Formula is given by: 

= 
where, 
h = 
and i = [0, 6] 

Below are the steps:  

1. Find the value of h from the above formula i.e., h = .
2. Find the value from to and calculate the value from to 
3. Substitute the above values in Weedle’s Formula to find the integral value.

Below is the implementation of the above approach:  

C++

// C++ program to Implement Weedle's Rule
#include <bits/stdc++.h>
using namespace std;

// A sample function f(x) = 1/(1+x^2)
float y(float x)
{
    float num = 1;
    float denom = 1.0 + x * x;

    return num / denom;
}

// Function to find the integral value
// of f(x) with step size h, with
// initial lower limit and upper limit
// a and b
float WeedleRule(float a, float b)
{
    // Find step size h
    double h = (b - a) / 6;

    // To store the final sum
    float sum = 0;

    // Find sum using Weedle's Formula
    sum = sum + (((3 * h) / 10) * (y(a)
                                + y(a + 2 * h)
                                + 5 * y(a + h)
                                + 6 * y(a + 3 * h)
                                + y(a + 4 * h)
                                + 5 * y(a + 5 * h)
                                + y(a + 6 * h)));

    // Return the final sum
    return sum;
}

// Driver Code
int main()
{
    // lower limit and upper limit
    float a = 0, b = 6;

    // Function Call
    cout<< "f(x) = "<< fixed <<  WeedleRule(a, b);
    return 0;
}
// This code is contributed by shivanisinghss2110

C

// C program to Implement Weedle's Rule
#include <math.h>
#include <stdio.h>

// A sample function f(x) =  1/(1+x^2)
float y(float x)
{
    float num = 1;
    float denom = 1.0 + x * x;

    return num / denom;
}

// Function to find the integral value
// of f(x) with step size h, with
// initial lower limit and upper limit
// a and b
float WeedleRule(float a, float b)
{
    // Find step size h
    double h = (b - a) / 6;

    // To store the final sum
    float sum = 0;

    // Find sum using Weedle's Formula
    sum = sum + (((3 * h) / 10) * (y(a)
                                   + y(a + 2 * h)
                                   + 5 * y(a + h)
                                   + 6 * y(a + 3 * h)
                                   + y(a + 4 * h)
                                   + 5 * y(a + 5 * h)
                                   + y(a + 6 * h)));

    // Return the final sum
    return sum;
}

// Driver Code
int main()
{
    // lower limit and upper limit
    float a = 0, b = 6;

    // Function Call
    printf("f(x) = %f", WeedleRule(a, b));
    return 0;
}

Java

// Java program to Implement Weedle's Rule
import java.util.*;
class GFG{

    // A sample function f(x) = 1/(1+x^2)
    static float y(float x)
    {
        float num = 1;
        float denom = (float)1.0 + x * x;

        return num / denom;
    }

    // Function to find the integral value
    // of f(x) with step size h, with
    // initial lower limit and upper limit
    // a and b
    static float WeedleRule(float a, float b)
    {
        // Find step size h
        float h = (b - a) / 6;

        // To store the final sum
        float sum = 0;

        // Find sum using Weedle's Formula
        sum = sum + (((3 * h) / 10) * (y(a)
                                    + y(a + 2 * h)
                                    + 5 * y(a + h)
                                    + 6 * y(a + 3 * h)
                                    + y(a + 4 * h)
                                    + 5 * y(a + 5 * h)
                                    + y(a + 6 * h)));

        // Return the final sum
        return sum;
    }

    // Driver Code
    public static void main(String args[])
    {
        // lower limit and upper limit
        float a = 0, b = 6;

        // Function Call
        float num=WeedleRule(a, b);
        System.out.format("f(x) = "+"%.6f", num);

    }
}

// This code is contributed by AbhiThakur

Python3

# Python3 program to Implement Weedle's Rule

# A sample function f(x) = 1/(1+x^2)
def y(x):
    num = 1;
    denom = float(1.0 + x * x);

    return num / denom;

# Function to find the integral value
# of f(x) with step size h, with
# initial lower limit and upper limit
# a and b
def WeedleRule(a, b):

    # Find step size h
    h = (b - a) / 6;

    # To store the final sum
    sum = 0;

    # Find sum using Weedle's Formula
    sum = sum + (((3 * h) / 10) * (y(a)
            + y(a + 2 * h)
            + 5 * y(a + h)
            + 6 * y(a + 3 * h)
            + y(a + 4 * h)
            + 5 * y(a + 5 * h)
            + y(a + 6 * h)));

    # Return the final sum
    return sum;

# Driver Code
if __name__ == '__main__':

    # lower limit and upper limit
    a = 0;
    b = 6;

    # Function Call
    num = WeedleRule(a, b);
    print("f(x) = {0:.6f}".format(num));

# This code is contributed by sapnasingh4991

C#

// C# program to Implement Weedle's Rule
using System;
class GFG{

    // A sample function f(x) = 1/(1+x^2)
    static float y(float x)
    {
        float num = 1;
        float denom = (float)1.0 + x * x;

        return num / denom;
    }

    // Function to find the integral value
    // of f(x) with step size h, with
    // initial lower limit and upper limit
    // a and b
    static float WeedleRule(float a, float b)
    {
        // Find step size h
        float h = (b - a) / 6;

        // To store the final sum
        float sum = 0;

        // Find sum using Weedle's Formula
        sum = sum + (((3 * h) / 10) * (y(a)
                                    + y(a + 2 * h)
                                    + 5 * y(a + h)
                                    + 6 * y(a + 3 * h)
                                    + y(a + 4 * h)
                                    + 5 * y(a + 5 * h)
                                    + y(a + 6 * h)));

        // Return the final sum
        return sum;
    }

    // Driver Code
    public static void Main()
    {
        // lower limit and upper limit
        float a = 0, b = 6;

        // Function Call
        float num=WeedleRule(a, b);
        Console.Write("f(x) = "+num);

    }
}

// This code is contributed by AbhiThakur

Javascript

<script>

// Javascript program to Implement Weedle's Rule

// A sample function f(x) = 1/(1+x^2)
function y(x)
{
    let num = 1;
    let denom = 1.0 + x * x;

    return num / denom;
}

// Function to find the integral value
// of f(x) with step size h, with
// initial lower limit and upper limit
// a and b
function WeedleRule(a, b)
{

    // Find step size h
    let h = (b - a) / 6;

    // To store the final sum
    let sum = 0;

    // Find sum using Weedle's Formula
    sum = sum + (((3 * h) / 10) *
        (y(a) + y(a + 2 * h) + 5 * y(a + h) +
            6 * y(a + 3 * h) + y(a + 4 * h) +
            5 * y(a + 5 * h) + y(a + 6 * h)));

    // Return the final sum
    return sum.toFixed(6);
}

// Driver code

// lower limit and upper limit
let a = 0, b = 6;

// Function Call
let num = WeedleRule(a, b);
document.write("f(x) = " + num);

// This code is contributed by divyeshrabadiya07

</script>

Output:

f(x) = 1.373448