I want to implement Romberg’s method in Octave.
Sadly calculating first line of matrix (T_0k method) is working extremely slow comparing to my own Python implementation.
I am using array istead of dictionary but in method mentioned before im not using any data structure.

Why it is happening?

Python code:

import math

def h_k(a, b, k):
    return (b - a)/2**k

def x_i(a, i, h_k):
    return a + i * h_k

def T_0k(k, a, b, f):
    h = h_k(a, b, k)
    sum = 0
    for i in range(2**k + 1):
        if i == 0 or i == 2**k + 1:
            sum += f(x_i(a, i, h))/2
        else:
            sum += f(x_i(a, i, h))

    return h * sum

def T(m, k, d):
    d[(m, k)] = (4**m * d[(m-1, k+1)] - d[(m-1, k)])/(4**m - 1)

def Romberg_tab(a, b, f, m):
    d = {}
    for i in range(m+1):
        d[(0, i)] = T_0k(i, a, b, f)
    for i in range(1, m + 1):
        for j in range(m - i + 1):
            T(i, j, d)

    for m in range(21):
        print(f"T({m},{20 - m}): ", d[(m, 20 - m)])

a = -3
b = 2
def f(x):
    return 2024*x**8 - 1977*x**4 - 1981

Romberg_tab(a, b, f, 20)

Octave code:

disp("result is: ")

function hk = h_k(a, b, k)
    hk = (b - a) / 2^k;
end

function xi = x_i(a, i, hk)
    xi = a + i * hk;
end

function T_0k_result = T_0k(k, a, b, f)
    disp("T_0k_result")

    hk = h_k(a, b, k);
    sum = 0;
    for i = 0:2^k
        if i == 0 || i == 2^k
            sum = sum + f(x_i(a, i, hk)) / 2;
        else
            sum = sum + f(x_i(a, i, hk));
        end
    end
    T_0k_result = hk * sum;
end

function T_result = T(m, k, d)
    disp("T_result")

    T_result = (4^m * d{m - 1, k + 1} - d{m - 1, k}) / (4^m - 1);
end

function d = Romberg_table(a, b, f, m)
    disp("Romberg_table")
    d = cell(m+1, m+1);
    for i = 1:m+1
        d{1, i} = T_0k(i, a, b, f);
    end

    for i = 2:m+1
        for j = 1:m+1-i
            d{i, j} = T(i, j, d);
        end
    end
end

function result = f(x)
    result = 2024 * x^8 - 1977 * x^4 - 1981;
end

a = -3;
b = 2;
m = 20;

d = Romberg_table(a, b, @f, m);