[Feature Request] Rounding

[homomorphist]

I think it might be a good idea to have a built-in one instead of having to implement it manually.

I believe there should probably be three types, one for each of Math.round, Math.floor, and Math.ceil.

[arielhs]

I agree and will eventually add these. I think floor and ceil should be super easy. I think round might be a bit more tricky, but there's always a way.

[homomorphist]

I made a simple implementation of all of them earlier, though they could probably be improved or perhaps make use of the internal typings which I'm not familiar with, since it might be doing a bit of unnecessary work here.

type TakeIntegerComponent<N extends number> = (
    `${N}` extends `${infer I extends number}.${string}` ? I : N
)

// A lot of the bit outputs of checks here are used as numbers for operations instead of booleans, which is why some stuff might look a bit weird.

export type Floor<N extends number> = (
    IsInt<N> extends 1 ? N : Negate<Subtract<IsNegative<N>, TakeIntegerComponent<N>>>
)

export type Ceil<N extends number> = (
    IsInt<N> extends 1 ? N : Add<Floor<N>, 1>
)

export type Round<N extends number> = (
    IsInt<N> extends 1 ? N : 
        IsNegative<N> extends 1
            ? Negate<Subtract<Gt<Multiply<Mod<Abs<N>, 1>, 10>, 5>, TakeIntegerComponent<N>>>
            : Add<GtOrEq        <Multiply<Mod<    N , 1>, 10>, 5>, TakeIntegerComponent<N>>
)

// Weirder alternative? I dunno.
type Round<N extends number> = (
    IsInt<N> extends 1 ? N : Add<Multiply<Or<Gt<Abs<Multiply<Mod<N, 1>, 10>>, 5>, Eq<Mod<N, 1>, 0.5>>, IsPositive<N> extends 1 ? 1 : -1>, TakeIntegerComponent<N>>
)

I think it works, as this checks out.

console.log([-150.48, -130.5, -1.6].map(v => Math.round(v))) // [-150, -130, -2] 
console.log([ 150.48,  130.5,  1.6].map(v => Math.round(v))) // [ 150,  131,  2] 
type A = [Round<-150.48>, Round<-130.5>, Round<-1.6>] // [-150, -130, -2]
type B = [Round< 150.48>, Round< 130.5>, Round< 1.6>] // [ 150,  131,  2]

[arielhs]

I love it! Floor and Ceil are perfect, I will add these (or you could make a PR for them?)

For Round, you're absolutely right, we would definitely want to try and use the internal types as the numbers can stay in their internal form across the calculation (an array of Digits), rather than us repeatedly converting back and forth from internal -> number -> innternal etc..

That being said, I actually tried something like that for Pow, but it ended up being easier to just use all the "top level" types as you have done with Round.

Great stuff!

[homomorphist]

@arielhs Should it be a draft for now given that it's only partially implemented? I assume I shouldn't touch the version number; not too familiar with actually contributing to projects, haha.

[arielhs]

@Agapurnis
Lets just include Round as it as is and we can optimise it later.

Yep it's ok to leave the version number, i'll deal with that when i merge it. I'll also handle the build, you just focus on:

• Forking the code and making a separate branch off main
• Adding your new functions in the right places (i think maybe they belong in the Number folder? Not 100% sure how to categorise them).
• Include a tsdoc comment on the 3 functions you are going to be exporting
• Adding documentation for these to the README.md
• Make the PR!