Order Calculator

Multi-Input Module

Data 1:
Data 2:

Single-Input Module

Data:

Results

...

Code Reference

Python:

import numpy as np

def order(errors, nlist=None):
    if nlist == None:
        n = len(errors)
        return [np.log(errors[k] / errors[k + 1]) / np.log(2) for k in range(n - 1)]
    else:
        n = len(errors)
        assert len(nlist) == n
        return [-(np.log(errors[k] / errors[k + 1])) / (np.log(nlist[k] / nlist[k + 1])) for k in range(n - 1)]

MATLAB:

function result = order(errors, nlist)
    if nargin < 2
        n = length(errors);
        result = zeros(1, n - 1);
        for k = 1:(n - 1)
            result(k) = log(errors(k) / errors(k + 1)) / log(2);
        end
    else
        n = length(errors);
        assert(length(nlist) == n, 'Length of nlist must be equal to length of errors');
        result = zeros(1, n - 1);
        for k = 1:(n - 1)
            result(k) = -(log(errors(k) / errors(k + 1)) / log(nlist(k) / nlist(k + 1)));
        end
    end
end

Mathematica:

order[errors_List, nlist_List: {}] := Module[{n, result},
    If[Length[nlist] == 0,
    n = Length[errors];
    result = Table[Log[errors[[k]]/errors[[k + 1]]]/Log[2], {k, 1, n - 1}],
    n = Length[errors];
    If[Length[nlist] == n,
        result = Table[-(Log[errors[[k]]/errors[[k + 1]]]/Log[nlist[[k]]/nlist[[k + 1]]]), {k, 1, n - 1}],
        Print["Length of nlist must be equal to length of errors"]]];result]

Cpp:

std::vector<double> order(const std::vector<double> &errors) {
    auto n = errors.size();
    std::vector<double> result(n - 1);
    for (auto k = 0; k < n - 1; ++k) {
        result[k] = log(errors[k] / errors[k + 1]) / log(2);
    }

    return result;
}

std::vector<double> order(const std::vector<double> &errors,
                            const std::vector<double> &nlist) {
    auto n = errors.size();
    assert(nlist.size() == n && "Length of nlist must be equal to length of errors");

    std::vector<double> result(n - 1);
    for (auto k = 0; k < n - 1; ++k) {
        result[k] = -(log(errors[k] / errors[k + 1]) / log(nlist[k] / nlist[k + 1]));
    }

    return result;
}