Floating point comparisons with Viper

[rkompass]

I want to share that I found out that in Viper code I may compare / sort float values easily.
This is due to the IEEE-754 standard.
Three functions illustrate this:

# three functions that compare floats (in an array)
# equal
@micropython.viper
def _fpveq(x :int, y :int) -> bool:
    if (x | y) & int(0x7fffffff) == 0:  # comparison of 0.0 and -0.0
        return True
    return bool(x==y)

# greater than or equal: +0.0, -0.0 Inf, -Inf handled correctly, NaN is greater than all other values !!
@micropython.viper
def _fpvgte(arr :ptr32, i :int, j :int) -> bool:
    x :int = arr[i]
    y :int = arr[j]
    if (x | y) & int(0x7fffffff) == 0:  # comparison of 0.0 and -0.0
        return True
    if x & y & int(0x80000000):
        return bool(x >= y)
    else:
        return bool(x <= y)

# greater than: +0.0, -0.0 Inf, -Inf handled correctly, NaN is greater than all other values !!
@micropython.viper
def _fpvgt(arr :ptr32, i :int, j :int) -> bool:
    x :int = arr[i]
    y :int = arr[j]
    if (x | y) & int(0x7fffffff) == 0:  # comparison of 0.0 and -0.0
        return False
    if x & y & int(0x80000000):
        return bool(x > y)
    else:
        return bool(x < y)

This was used in a quicksort function which sorts an array.array('f',...) (which I may share too upon request).

The true speed gain but resulted from inlining

x >= y if x & y & int(0x80000000) else x <= y

for greater than or equal, and

x == y

for equal, with x and y delared as int, thus ignoring the equality of +0.0 and -0.0 (which sorts good anyway).
This makes a very fast sorting of float arrays possible, which we do not have as function in MP (not in ulab either).

The above inlining is necessary due to the fact that just a call to another viper function carries the costs of all python handling overhead (3-5 us). Including the above comparisons as function makes the >10 x speed gain vanish.

So dreaming about a way to call a viper function like a C-call without overhead . . . would allow for viper functions for add, subtract, multiply of floats?

[v923z]

@rkompass When you say that fast sorting of float arrays in not possible in ulab, what exactly do you mean? sort was one of the first numpy functions that we implemented. I would be happy to add functionality, if you think that something is missing.

[rkompass]

@v923z thanks for the correction. I recall to have done a search and apparently got an incomplete or out-of-date ulab doc.
In the process of creating a more elaborate statistics module I needed the float sort for the ranking of data for the Mann-Whitney U-test. In the end such a module is something that I think should be available as part of ulabs scipy.stats, but also standalone.
If you are interested I can send you my MP code for that, but it is not finished (all 3 versions of t test are there).

[v923z]

If scipy has the functions you need, we could definitely add those. If you need something very special, we could add those in the utils module. Just open a ticket with any relevant information at https://github.com/v923z/micropython-ulab/issues!

I would also point out that you can remove pretty much all functions from ulab with simple pre-processor switches, so in that way, you would basically get a stand-alone module with the statistical functions only.