Aller au contenu principal

Numeric

Index

Interfaces

Interfaces

Add

Add<Left, Right, Output>:

Type parameters

  • Left
  • Right = Left
  • Output = Left

+

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

  • Addition operator

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

CheckedAdd

CheckedAdd<Left, Right, Output>:

Type parameters

  • Left
  • Right = Left
  • Output = Left

+?

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

  • 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, Output>:

Type parameters

  • Base
  • Divider = Base
  • Output = Base

/?

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

  • Division operator

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

CheckedMultiply

CheckedMultiply<Base, Multiplier, Output>:

Type parameters

  • Base
  • Multiplier = Base
  • Output = Base

*?

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

  • 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)

CheckedPower

CheckedPower<Left, Right, Output>:

Type parameters

  • Left
  • Right = Left
  • Output = Left

**?

  • **?(left: Left, right: Right): Option<Output>

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

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

CheckedRemainder

CheckedRemainder<Base, Divider, Output>:

Type parameters

  • Base
  • Divider = Base
  • Output = Base

%?

  • %?(left: Base, right: Divider): Option<Output>

  • Remainder operator

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

CheckedSubtract

CheckedSubtract<Left, Right, Output>:

Type parameters

  • Left
  • Right = Left
  • Output = Left

-?

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

  • 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, Output>:

Type parameters

  • Base
  • Divider = Base
  • Output = Base

/

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

  • Division operator

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

Multiply

Multiply<Left, Right, Output>:

Type parameters

  • Left
  • Right = Left
  • Output = Left

*

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

  • Multiplication operator

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

Negate

Negate<Self, Output>:

Type parameters

  • Self
  • Output = Self

negate

  • negate(self: Self): Output

  • Negates the given value.

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

Power

Power<Left, Right, Output>:

Type parameters

  • Left
  • Right = Left
  • Output = Left

**

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

  • Power operator

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

Remainder

Remainder<Base, Divider, Output>:

Type parameters

  • Base
  • Divider = Base
  • Output = Base

%

  • %(left: Base, right: Divider): Output

  • Remainder operator

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

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, Output>:

Type parameters

  • Left
  • Right = Left
  • Output = Left

-

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

  • 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