std.math.scalar

The value without its sign: 0 for -0, and NaN for NaN. An integer's lowest value, which has none in its type, overflows.

1 for a value above 0, -1 for one below, and the value itself for 0 or NaN.

The largest whole number that isn't above the value.

The smallest whole number that isn't below the value.

The nearest whole number, with a value halfway between two going away from 0: 2.5 is 3, and -2.5 is -3.

The whole part, toward 0: Trunc(-2.7) is -2.

What Floor takes away, from 0 to 1: Fract(-0.25) is 0.75. A negative value too close to a whole number for the type to hold the difference gives 1.

The remainder of a divided by b with the sign of b, as dividing and rounding down leaves it: Mod(-1, 3) is 2, and Mod(1, -3) is -2. A b of 0 panics.

Examples

Expect(Mod(-1, 3) == 2)
Expect(Rem(-1, 3) == -1)

The remainder of a divided by b with the sign of b, as dividing and rounding down leaves it: Mod(-1.5, 4.0) is 2.5, and a 0 has b's sign. A b of 0 gives NaN. A remainder too small beside b for their sum to be below it gives 0, which is as near, a whole b away.

The remainder of a divided by b with the sign of a, as % gives it: Rem(-1, 3) is -1. A b of 0 panics.

The remainder of a divided by b with the sign of a, exactly, as C's fmod gives it: Rem(-1.5, 4.0) is -1.5. A b of 0 gives NaN.

The greatest common divisor of the two, which isn't negative: Gcd(12, -18) is 6, and Gcd(0, 0) is 0. One too large for T overflows.

Examples

Expect(Gcd(12, 18) == 6 && Lcm(4, 6) == 12)

The least common multiple of the two, which isn't negative: Lcm(4, 6) is 12, and 0 when either is 0. One too large for T overflows.

The largest integer whose square isn't above the value: IntSqrt(10) is 3. A negative value panics.

The value t of the way from a to b: a at 0, b itself at 1, though b - a rounds, and past them outside 0 to 1.

Examples

Expect(Lerp(0.0, 10.0, 0.25) == 2.5)
Expect(InverseLerp(0.0, 10.0, 2.5) == 0.25)
Expect(Remap(5.0, 0.0, 10.0, 100.0, 200.0) == 150.0)

How far of the way from a to b the value is, as Lerp's t: 0 at a, 1 at b. With a equal to b, it's 0.

The value moved from one range to another, as far through toLow to toHigh as it is through fromLow to fromHigh: Remap(5, 0, 10, 100, 200) is 150.

0 below low and 1 above high, and a smooth curve between, as GLSL's smoothstep: with low equal to high, 0 below it and 1 from it up.

The value wrapped into the range from low to high, high left out, as an angle wraps into a turn: Wrap(370, 0, 360) is 10. With low equal to high, it's low. The distances are worked out in a UInt64, so a range of any width, in any of the eight types, can't overflow.

Examples

Expect(Wrap(370, 0, 360) == 10)
Expect(Wrap(-30, 0, 360) == 330)

The value wrapped into the range from low to high, high left out, as an angle wraps into a turn: Wrap(370.0, 0.0, 360.0) is 10. With low equal to high, it's low. One that rounds to high gives low, which is as near, a turn away.

The value going from 0 up to length and back down, over and over: PingPong(3, 2) is 1. A negative length panics. It's worked out in a UInt64, by whole lengths, so no length of any of the eight types overflows.

The value going from 0 up to length and back down, over and over: PingPong(3.0, 2.0) is 1. A negative or NaN length panics.

Current moved toward target by maxDelta, or to target when it's no further: a negative maxDelta moves it away.

Whether a and b are no further apart than tolerance.

Whether a and b are equal but for rounding: no further apart than 0.00001 of the larger one's size, or of 1 near 0. An infinity is close only to itself, and NaN to nothing.

Examples

Expect(IsClose(0.1 + 0.2, 0.3))
Expect(!IsClose(1.0, 1.1))

The square root. A negative value's is NaN.

Examples

Expect(Sqrt(16.0) == 4.0)
Expect(IsClose(Sin(Deg(30)), 0.5))
Expect(IsClose(Atan2(1.0, 1.0), Deg(45)))

The cube root, negative for a negative value.

E to the power of the value.

2 to the power of the value.

The natural logarithm, of base E. 0's is -Inf, and a negative value's NaN.

The logarithm of the base: Log(8.0, 2.0) is 3.

The logarithm of base 2.

The logarithm of base 10.

The sine of an angle in radians.

The cosine of an angle in radians.

The tangent of an angle in radians.

The angle whose sine is the value, from -Pi / 2 to Pi / 2. Outside -1 to 1, it's NaN.

The angle whose cosine is the value, from 0 to Pi. Outside -1 to 1, it's NaN.

The angle whose tangent is the value, from -Pi / 2 to Pi / 2.

The angle from the X axis to the point (x, y), from -Pi to Pi.

The hyperbolic sine.

The hyperbolic cosine.

The hyperbolic tangent.

The value whose hyperbolic sine this is.

The value, not negative, whose hyperbolic cosine this is. Below 1, it's NaN.

The value whose hyperbolic tangent this is. Outside -1 to 1, it's NaN.

Whether the value is NaN, the one value that isn't equal to itself.

Whether the value is a number, neither infinite nor NaN.

The magnitude with the sign of sign, -0 and NaN's included: CopySign(2.0, -0.0) is -2.

a * b + c, rounded once, at the end.

The angle of so many degrees, in radians, the unit of every angle in std.math: Deg(90) is Pi / 2.

The angle of so many degrees, in radians, the unit of every angle in std.math: Deg(22.5) is Pi / 8.

The angle of so many radians, which is the number itself, for code that says its units, as Deg does.

The angle of so many radians, which is the number itself, for code that says its units, as Deg does.

The angle of so many degrees, in radians, as Deg gives it.

The angle of so many degrees, in radians, as Deg gives it.

The angle of so many radians, in degrees: ToDegrees(1) is about 57.3.

The angle in radians, in degrees: ToDegrees(Pi) is 180.