Some recommended big decimals library to use besides BabylonJs?


I’m working in a motion class for my babylonjs project and I have some issues interpolating arrays of numbers.
I believe this is caused for the javascript floating point precision issues: [Link]

Is there some recommended library to deal with this problem?
I’ve seen some of them (big.js, bignumber.js, decimal.js, bigdecimal.js…) but I’m not sure which one could be the best regarding performance.

E.g: A comparison of BigNumber libraries in JavaScript - DEV Community

Thanks in advance.

PS: I know this is not a BabylonJs topic, but I think it can be useful for the community.

It sounds like you’ve already made up your mind about your issues being related to “flops”. Just for curiosity’s sake then, could you describe the problem you’re seeing with vector interpolation? Is there some code or a PG you have that shows this?

It’s tough to recommend anything specific to your needs without having a better understanding of the problem you’re trying to solve :slightly_smiling_face::sunglasses:

1 Like

Agree with @jelster on this one, JS is actually fortunate enough (or way too expensive depending on how you look into it :slight_smile: ) to be all based on double so 64 bit precisions which is more than plenty in the majority of cases for interpolations.

Would be great to know a tiny bit more about your use case.


@jelster @sebavan sorry I didn’t explain well. I’m not using a BabylonJs vector, I’m using a custom vector (an array of numbers). I had Issues with some very small calculations, but I found a mistake in the algorithm and it is fixed now :slight_smile: Using custom vector allows me to use more than 3 or 4 values, then I can add scale, rotation, colors, AI params, or whatever.

This is the algorithm (there was a wrong reduce there):

const increaseVector = (from: number[], to: number[], speed: number, completed?: () => void): number[] => {
    const complete = () => {
        if (completed) {
        return to;
    const director = [];
    for (let i = 0; i < from.length; i++) {
        director.push(to[i] - from[i]);
    let lengthPow2 = 0;
    director.forEach((value) => (lengthPow2 += Math.pow(value, 2)));
    if (lengthPow2 < MIN_DISTANCE) {
        return complete();
    const length = Math.sqrt(lengthPow2);
    const directorNormalized = => value / length);
    let result = [];
    for (let i = 0; i < from.length; i++) {
        result.push(increaseValue(from[i], to[i], Math.abs(directorNormalized[i]) * speed));
    return result;

My question wasn’t about JS nor BabylonJs itself, my question is which one of the Big Decimals libraries should I use beside BabylonJs in case I need it.

E.g of some libraries: A comparison of BigNumber libraries in JavaScript - DEV Community

Sorry for the confussion on the topic.

No problem, about your topic I unfortunately have never used any of them so would be badly placed to answer :slight_smile: