Why Simpson's rule of integration rewritten in Python giving a different result?

Question

The following source codes are the implementation of Simpson's rule of Integration.

C# source code.

using System;

public class Simpson
{
    private double Function(double x)
    {
        return 1.0 / (1.0 + Math.Pow(x, 5)); //Define the function f(x)
    }

    public double Compute(double a, double b, int n)
    {
        double[] x = new double[n + 1];

        double delta_x = (b - a) / n;

        x[0] = a;

        for (int j = 1; j <= n; j++)//calculate the values of x1, x2, ...xn
        {
            x[j] = a + delta_x * j;
        }

        double sum = Function(x[0]);

        for (int j = 1; j < n; j++)
        {
            if (j % 2 != 0)
            {
                sum += 4 * Function(x[j]);
            }
            else
            {
                sum += 2 * Function(x[j]);
            }
        }

        sum += Function(x[n]);

        double integration = sum * delta_x / 3;

        return integration;
    }
}

public class MainClass
{
    public static void Main()
    {
        Simpson simpson = new Simpson();
        double a = 0d;//lower limit a
        double b = 3d;//upper limit b
        int n = 6;//Enter step-length n

        if (n % 2 == 0)//n must be even
        {
            Console.WriteLine(simpson.Compute(a, b, n));
        }
        else
        {
            Console.WriteLine("n should be an even number");
        }

        Console.ReadLine();
    }
}

Output:

1.07491527775614

.

Python Source Code.

import math

# function to be integrated
def Function(x):
    return 1.0 / (1.0 + math.pow(x, 5)); #Define the function f(x)

def Simpson(a, b, n):
    x = [0] * (n + 1);
    delta_x = (b - a) / n;
    x[0] = a;

    for j in range(1,n):#calculate the values of x1, x2, ...xn
        x[j] = a + delta_x * j;

    sum = Function(x[0]);

    for j in range( 1, n):
        if (j % 2 != 0):
            sum = sum + 4 * Function(x[j]);
        else:
            sum = sum + 2 * Function(x[j]);

    sum += Function(x[n]);

    integration = sum * delta_x / 3;

    return integration;


# Main Program
a = 0.0; # lower limit a
b = 3.0; # upper limit b
n = 6; # Enter step-length n

if (n % 2 == 0): # n must be even
    print(Simpson(a, b, n));
else:
    print("n should be an even number");

Output:

1.2408988843135185

C# program's output is different than Python's output.

Why is that?

Answer 1

range(1,n) is representing [1, n). While (int j = 1; j <= n; j++) is representing [1, n].

There could be more different but here is the most obvious one.