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)

Signed

Signed<T>:

Type parameters

  • T

abs

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

sign

  • sign(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)
Page Options