# Function implementation for monotony check

5 views (last 30 days)
Firan Lucian on 26 Aug 2019
Commented: Firan Lucian on 27 Aug 2019
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
---

Firan Lucian on 26 Aug 2019
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 on 27 Aug 2019
Some issues may be with comparations (>=, <=) and equality == in floats.
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 ?

Andrey Kiselnikov on 26 Aug 2019
Edited: Andrey Kiselnikov on 26 Aug 2019
a = 1:10;
isIncreasing = all(diff(a)) %or all(diff(a)>=0) if you want to allow 0 difference

Firan Lucian on 26 Aug 2019
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 on 26 Aug 2019
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.