Function implementation for monotony check

Is there a build-in MATLAB function (way) that calculates one function implementation monotony against a true (correct, golden, reference) implementation ?

One way I’m thinking, is to check if the actual function and the reference have the same behavior on two successive inputs.

(successive as stepping; -+eps, next float, or with different granularity)

Consider 2 function implementation one to be measured and one reference:

f(x), f(x+1) and ref(x), ref(x+1)

Monotony in an strict way may be

Count inconsistencies or errors as

• ref(x) > ref(x+1) not implies f(x) > f(x+1)
• ref(x) < ref(x+1) not implies f(x) < f(x+1)
• ref(x) == ref(x+1) not implies f(x) == f(x+1)

Monotony relaxed

• ref(x) >= ref(x+1) not implies f(x) >= f(x+1)
• ref(x) <= ref(x+1) not implies f(x) <= f(x+1)

over some interval.

Example

x=1;
stp=1;
 
err_strict = (ref(x)  > ref(x+stp)) == (f(x)  > f(x+stp)) | ...
             (ref(x)  < ref(x+stp)) == (f(x)  < f(x+stp)) | ...
             (ref(x) == ref(x+stp)) == (f(x) == f(x+stp)); 
 
err_relaxed = (ref(x) >= ref(x+stp)) == (f(x) >= f(x+stp)) | ...
              (ref(x) <= ref(x+stp)) == (f(x) <= f(x+stp));
 
disp(err_strict)
disp(err_relaxed)
 
function [y] = ref(x) 
    y = x+1;
end
 
function [y] = f(x) 
    y = single(x)+1;
end 

---

https://en.wikipedia.org/wiki/Monotonic_function

http://www.easy-math.net/monotonicity-of-functions/

https://www.math24.net/increasing-decreasing-functions/

[Firan Lucian]

code typo, upper one count conformities, below non-conformities

x=1;
stp=1;

err_strict = (ref(x)  > ref(x+stp)) ~= (f(x)  > f(x+stp)) | ...
             (ref(x)  < ref(x+stp)) ~= (f(x)  < f(x+stp)) | ...
             (ref(x) == ref(x+stp)) ~= (f(x) == f(x+stp)); 

err_relaxed = (ref(x) >= ref(x+stp)) ~= (f(x) >= f(x+stp)) | ...
              (ref(x) <= ref(x+stp)) ~= (f(x) <= f(x+stp));

disp(err_strict)
disp(err_relaxed)

function [y] = ref(x) 
    y = x+1;
end

function [y] = f(x) 
    y = single(x)+1;
end

Is this the fastest way to implement ? considering large number of tests (stepping size constraint).

[Firan Lucian]

Some issues may be with comparations (>=, <=) and equality == in floats.

https://floating-point-gui.de/errors/comparison/

There are also some special cases (corner cases) like inf, nan that should be handled in an meaningful way.

Monotony evaluation kernels examples

(where f is f(x) next_f is f(x+deltax) )

function [err] = monErr_single(f, next_f, ref, next_ref)
 
    err = (ref >= next_ref) ~= (f >= next_f) | ...
          (ref <= next_ref) ~= (f <= next_f);
          
end

or

    if (ref >= next_ref)
        if (f >= next_f)
            err = 0;
        else
            err = 1;
        end    
    else
        if (f <= next_f)
            err = 0;
        else
            err = 1;
        end         
    end

function [err] = monStrictErr_single(f, next_f, ref, next_ref)
         
    err = (ref  > next_ref) ~= (f  > next_f) | ...
          (ref  < next_ref) ~= (f  < next_f) | ...
          (ref == next_ref) ~= (f == next_f);      
 
end

or

    if (ref  > next_ref)
        if (f  > next_f)
            err = 0;
        else
            err = 1;
        end
    elseif (ref  < next_ref)
        if (f  < next_f)
            err = 0;
        else
            err = 1;
        end
    else
       if (f == next_f)
            err = 0;
        else
            err = 1;
        end
    end

one implemnatation may be faster than the other ?

Answer 1

[Andrey Kiselnikov]

Hi, the solution was provided here https://www.mathworks.com/matlabcentral/answers/373152-how-to-check-monotonity-of-a-vector

You can add the additional functionality to this code to perform your tasks.

a = 1:10;
 isIncreasing = all(diff(a)) %or all(diff(a)>=0) if you want to allow 0 difference

[Firan Lucian]

The idea here is not to check if one function has one monotony.

The idea is to compare 2 functions monotony and measure how close are monotony-wise.

Keeping all values may overflow system memory (let’s say for all single precision numbers), so I think is better to iterate and check.

(not to mention multivariable functions)

[Andrey Kiselnikov]

MATLAB is a good tool for working with big data arrays. Moreover, it designed to perform matrix operations. So I can't recommend using iteration, because it can be really slow in interpreted languages (can be speeded up by JIT compilation). Also, MATLAB has special tall arrays that do not fit system memory.

https://www.mathworks.com/help/matlab/tall-arrays.html