Skip to main content

Numeric

Index

Interfaces

Interfaces

Add

Add<Left, Right, Return>:

Type parameters

  • Left
  • Right = Left
  • Return = Left

+

  • +(left: Left, right: Right): Return

  • Addition operator

    @example
    type T = ...;
    const TNumeric: Numeric.Add<T> = ...;
    const result = TNumeric['+'](left, right);// represents (left + right)

CheckedAdd

CheckedAdd<Left, Right, Return>:

Type parameters

  • Left
  • Right = Left
  • Return = Left

+?

  • +?(left: Left, right: Right): Option<Return>

  • Addition operator that returns None instead of wrapping around on overflow.

    @example
    type T = ...;
    const TNumeric: Numeric.CheckedAdd<T> = ...;
    const result = TNumeric['+?'](left, right);// represents (left + right)

CheckedDivide

CheckedDivide<Base, Divider, Return>:

Type parameters

  • Base
  • Divider = Base
  • Return = Base

/?

  • /?(left: Base, right: Divider): Option<Return>

  • Division operator

    @example
    type T = ...;
    const TNumeric: Numeric.CheckedDivide<T> = ...;
    const result = Numeric['/?'](left, right);// represents (left / right)

CheckedMultiply

CheckedMultiply<Base, Multiplier, Return>:

Type parameters

  • Base
  • Multiplier = Base
  • Return = Base

*?

  • *?(base: Base, multiplier: Multiplier): Option<Return>

  • Multiplication operator that returns None instead of wrapping around on overflow.

    @example
    type T = ...;
    const TNumeric: Numeric.CheckedMultiply<T> = ...;
    const result = Numeric['*?'](left, right);// represents (left * right)

CheckedSubtract

CheckedSubtract<Left, Right, Return>:

Type parameters

  • Left
  • Right = Left
  • Return = Left

-?

  • -?(left: Left, right: Right): Option<Return>

  • Subtraction operator that returns None instead of wrapping around on overflow.

    @example
    type T = ...;
    const TNumeric: Numeric.CheckedSubtract<T> = ...;
    const result = TNumeric['-?'](left, right);// represents (left + right)

Divide

Divide<Base, Divider, Return>:

Type parameters

  • Base
  • Divider = Base
  • Return = Base

/

  • /(base: Base, divider: Divider): Return

  • Division operator

    @example
    type T = ...;
    const TNumeric: Numeric.Divide<T> = ...;
    const result = Numeric['/'](left, right);// represents (left / right)

Multiply

Multiply<Left, Right, Return>:

Type parameters

  • Left
  • Right = Left
  • Return = Left

*

  • *(left: Left, right: Right): Return

  • Multiplication operator

    @example
    type T = ...;
    const TNumeric: Numeric.Multiply<T> = ...;
    const result = Numeric['*'](left, right);// represents (left * right)

Negate

Negate<T, Return>:

Type parameters

  • T
  • Return = T

negate

  • negate(self: T): Return

  • Negates the given value.

    @example
    Number.negate(5); // -5
    Number.negate(Number.negate(5)); // 5

Signed

Signed<T>:

Type parameters

  • T

abs

  • abs(this: void, value: T): T

  • Absolute value. It should satisfy Numeric['*'](Numeric.abs(x), Numeric.sign(x)) == x

    @example
    type T = ...;
    const TSigned: Numeric.Signed<T> = ...;
    const result = TSigned.abs(value);// absolute value of (value)

isNegative

  • isNegative(this: void, self: T): boolean

  • Returns true if the number is negative and false if the number is zero or positive.

isPositive

  • isPositive(this: void, self: T): boolean

  • Returns true if the number is positive and false if the number is zero or negative.

sign

  • sign(this: void, value: T): T

  • Sign of a number. It should satisfy TSigned['*'](TSigned.abs(x), TSigned.sign(x)) == x

Subtract

Subtract<Left, Right, Return>:

Type parameters

  • Left
  • Right = Left
  • Return = Left

-

  • -(left: Left, right: Right): Return

  • Subtraction operator

    @example
    type T = ...;
    const TNumeric: Numeric.Subtract<T> = ...;
    const result = Numeric['-'](left, right);// represents (left - right)

Zero

Zero<T>:

Type parameters

  • T

isZero

  • isZero(this: void, self: T): boolean

  • Returns true if self is equal to the additive identity.

    @example
    Number.isZero(0); // true
    Number.isZero(1); // false

zero

  • zero(this: void): T

  • Returns the additive identity element of T, 0.

    @example
    Number.zero(); // 0
Page Options