Aller au contenu principal

NumberConversion

Index

Interfaces

Functions

Interfaces

Module

Module<T>:

Type parameters

  • T

readonlyinheritedmaxValue

maxValue: T

Maximum value for this type

const anyNumber: number
anyNumber < Number.maxValue // true

readonlyinheritedminValue

minValue: T

Minimum value for this type

const anyNumber: number
anyNumber > Number.minValue // true

inherited-

  • -(left, right): T

  • Subtraction operator

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

inherited!=

  • !=(this, left, right): boolean

  • "Not equal to" operator

    const TEqual: Equal<T>;
    TEqual['!='](value, otherValue); // true
    TEqual['!='](value, value); // false

inherited*

  • *(left, right): T

  • Multiplication operator

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

inherited**

  • **(left, right): T

  • Power operator

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

inherited%

  • %(left, right): T

  • Remainder operator

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

inherited+

  • +(left, right): T

  • Addition operator

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

inherited＜

  • ＜(this, left, right): boolean

  • "Less than" operator

    type T;
    const TCompare: Comparable<T>;
    const smallerT: T;
    const greaterT: T;
    TCompare['<'](smallerT, smallerT); // false
    TCompare['<'](smallerT, greaterT); // true
    TCompare['<'](greaterT, smallerT); // false

inherited＜=

  • ＜=(this, left, right): boolean

  • "Less than or equal to" operator

    type T;
    const TCompare: Comparable<T>;
    const smallerT: T;
    const greaterT: T;
    TCompare['<='](smallerT, smallerT); // true
    TCompare['<='](smallerT, greaterT); // true
    TCompare['<='](greaterT, smallerT); // false

inherited==

  • ==(this, left, right): boolean

  • "Equal to" operator

    type T = // ...
    const TEqual: Equal<T>;
    TEqual['=='](value, value); // true
    TEqual['=='](value, otherValue); // false

inherited＞

  • ＞(this, left, right): boolean

  • "Greater than" operator

    type T;
    const TCompare: Comparable<T>;
    const smallerT: T;
    const greaterT: T;
    TCompare['>'](smallerT, smallerT); // false
    TCompare['>'](smallerT, greaterT); // false
    TCompare['>'](greaterT, smallerT); // true

inherited＞=

  • ＞=(this, left, right): boolean

  • "Greater than or equal to" operator

    type T;
    const TCompare: Comparable<T>;
    const smallerT: T;
    const greaterT: T;
    TCompare['>='](smallerT, smallerT); // true
    TCompare['>='](smallerT, greaterT); // false
    TCompare['>='](greaterT, smallerT); // true

inheritedabs

  • abs(this, value): T

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

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

inheritedclamp

  • clamp(this, value, minValue, maxValue): T

  • Clamp value between minValue and maxValue

    type T;
    const TCompare: Comparable<T>;
    TCompare.clamp(value, min, max); // min if value < min, max if value > max, otherwise value itself

inheritedcompare

  • compare(this, left, right): Ordering

  • Return an Ordering that represents comparison result

    type T;
    const TCompare: Comparable<T>;
    const sorted = [3, 1, 1].sort(TCompare.compare);

    See more at Order

inheritedequals

  • equals(this, left, right): boolean

  • Alias to '=='

    type T = // ...
    const TEqual: Equal<T>;
    TEqual.equals(value, value); // true
    TEqual.equals(value, otherValue); // false

inheritedisNegative

  • isNegative(this, self): boolean

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

    Number.isPositive(-1);// true
    Number.isPositive(0);// false
    Number.isPositive(1);// false

inheritedisPositive

  • isPositive(this, self): boolean

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

    Number.isPositive(-1);// false
    Number.isPositive(0);// false
    Number.isPositive(1);// true

inheritedisZero

  • isZero(this, self): boolean

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

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

inheritedmax

  • max(this, left, right): T

  • "maximum" operator

    type T;
    const TCompare: Comparable<T>;
    const smallerT: T;
    const greaterT: T;
    TCompare.max(smallerT, greaterT); // greaterT

inheritedmin

  • min(this, left, right): T

  • "minimum" operator

    type T;
    const TCompare: Comparable<T>;
    const smallerT: T;
    const greaterT: T;
    TCompare.min(smallerT, greaterT); // smallerT

inheritednegate

  • negate(this, self): T

  • Negates the given value.

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

inheritedsign

  • sign(this, value): T

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

    Number.sign(-2.5);// -1
    Number.sign(0);// 0
    Number.sign(2.5);// 1

inheritedzero

  • zero(this): T

  • Returns the additive identity element of T, 0.

    Number.zero(); // 0

Functions

__call__

Add

  • Add(): Numeric.Add<number>
  • Add<T>(BaseType): Numeric.Add<T>

Bounded

  • Bounded(): Bounded<number>
  • Bounded<T>(BaseType): Bounded<T>

  • Creates a Bounded instance for a type T that can be converted to and from Int.


    interface MyType { custom: boolean; value: number; } const MyTypeConversion: NumberConversion

    <MyType>
    = { fromInt: (v) => ({ custom: true, value: v }), asInt: (v) => v.value as Int, } const MyTypeBounded = NumberConversion.Bounded
    <MyType>
    (MyTypeConversion); ```

Comparable

  • Comparable(): CoreComparable<number>
  • Comparable<T>(BaseType): CoreComparable<T>

Multiply

  • Multiply(): Numeric.Multiply<number>
  • Multiply<T>(BaseType): Numeric.Multiply<T>

Negate

  • Negate(): Numeric.Negate<number>
  • Negate<T>(BaseType): Numeric.Negate<T>

Power

  • Power(): Numeric.Power<number>
  • Power<T>(BaseType): Numeric.Power<T>

Remainder

  • Remainder(): Numeric.Remainder<number>
  • Remainder<T>(BaseType): Numeric.Remainder<T>

Signed

  • Signed(): Numeric.Signed<number>
  • Signed<T>(BaseType): Numeric.Signed<T>

Subtract

  • Subtract(): Numeric.Subtract<number>
  • Subtract<T>(BaseType): Numeric.Subtract<T>

Zero

  • Zero(): Numeric.Zero<number>
  • Zero<T>(BaseType): Numeric.Zero<T>
Page Options