From 93930f8a236ee6ffbd8c8368f5cfe64a7d015a3f Mon Sep 17 00:00:00 2001 From: Michael Mclaughlin Date: Sat, 10 Mar 2018 22:00:51 +0000 Subject: [PATCH] Put global ts definitions in separate file (see bignumber.js #143) --- README.md | 2 +- decimal.d.ts | 223 ++++++++++++++----------------- decimal.global.d.ts | 316 ++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 418 insertions(+), 123 deletions(-) create mode 100644 decimal.global.d.ts diff --git a/README.md b/README.md index 7fdc60c..34189e9 100644 --- a/README.md +++ b/README.md @@ -159,7 +159,7 @@ pi.toFraction(1000) // [ '355', '113' ] All calculations are rounded according to the number of significant digits and rounding mode specified by the `precision` and `rounding` properties of the Decimal constructor. -Multiple Decimal constructors can be created, each with their own independent configuration which +For advanced usage, multiple Decimal constructors can be created, each with their own independent configuration which applies to all Decimal numbers created from it. ```js diff --git a/decimal.d.ts b/decimal.d.ts index 0b0446b..9be1998 100644 --- a/decimal.d.ts +++ b/decimal.d.ts @@ -32,62 +32,41 @@ export default Decimal; export namespace Decimal { - export type Config = DecimalConfig; - export type Constructor = DecimalConstructor; - export type Instance = DecimalInstance; - export type Modulo = DecimalModulo; - export type Rounding = DecimalRounding; - export type Value = DecimalValue; -} + export type Constructor = typeof Decimal; + export type Instance = Decimal; + export type Rounding = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8; + export type Modulo = Rounding | 9; + export type Value = string | number | Decimal; -declare global { - const Decimal: DecimalConstructor; - type Decimal = DecimalInstance; - - namespace Decimal { - type Config = DecimalConfig; - type Constructor = DecimalConstructor; - type Instance = DecimalInstance; - type Modulo = DecimalModulo; - type Rounding = DecimalRounding; - type Value = DecimalValue; + // http://mikemcl.github.io/decimal.js/#constructor-properties + export interface Config { + precision?: number; + rounding?: Rounding; + toExpNeg?: number; + toExpPos?: number; + minE?: number; + maxE?: number; + crypto?: boolean; + modulo?: Modulo; + defaults?: boolean; } } -type DecimalInstance = Decimal; -type DecimalConstructor = typeof Decimal; -type DecimalValue = string | number | Decimal; -type DecimalRounding = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8; -type DecimalModulo = DecimalRounding | 9; - -// http://mikemcl.github.io/decimal.js/#constructor-properties -interface DecimalConfig { - precision?: number; - rounding?: DecimalRounding; - toExpNeg?: number; - toExpPos?: number; - minE?: number; - maxE?: number; - crypto?: boolean; - modulo?: DecimalModulo; - defaults?: boolean; -} - export declare class Decimal { readonly d: number[]; readonly e: number; readonly s: number; private readonly name: string; - constructor(n: DecimalValue); + constructor(n: Decimal.Value); absoluteValue(): Decimal; abs(): Decimal; ceil(): Decimal; - comparedTo(n: DecimalValue): number; - cmp(n: DecimalValue): number; + comparedTo(n: Decimal.Value): number; + cmp(n: Decimal.Value): number; cosine(): Decimal; cos(): Decimal; @@ -98,22 +77,22 @@ export declare class Decimal { decimalPlaces(): number; dp(): number; - dividedBy(n: DecimalValue): Decimal; - div(n: DecimalValue): Decimal; + dividedBy(n: Decimal.Value): Decimal; + div(n: Decimal.Value): Decimal; - dividedToIntegerBy(n: DecimalValue): Decimal; - divToInt(n: DecimalValue): Decimal; + dividedToIntegerBy(n: Decimal.Value): Decimal; + divToInt(n: Decimal.Value): Decimal; - equals(n: DecimalValue): boolean; - eq(n: DecimalValue): boolean; + equals(n: Decimal.Value): boolean; + eq(n: Decimal.Value): boolean; floor(): Decimal; - greaterThan(n: DecimalValue): boolean; - gt(n: DecimalValue): boolean; + greaterThan(n: Decimal.Value): boolean; + gt(n: Decimal.Value): boolean; - greaterThanOrEqualTo(n: DecimalValue): boolean; - gte(n: DecimalValue): boolean; + greaterThanOrEqualTo(n: Decimal.Value): boolean; + gte(n: Decimal.Value): boolean; hyperbolicCosine(): Decimal; cosh(): Decimal; @@ -157,20 +136,20 @@ export declare class Decimal { isZero(): boolean; - lessThan(n: DecimalValue): boolean; - lt(n: DecimalValue): boolean; + lessThan(n: Decimal.Value): boolean; + lt(n: Decimal.Value): boolean; - lessThanOrEqualTo(n: DecimalValue): boolean; - lte(n: DecimalValue): boolean; + lessThanOrEqualTo(n: Decimal.Value): boolean; + lte(n: Decimal.Value): boolean; - logarithm(n?: DecimalValue): Decimal; - log(n?: DecimalValue): Decimal; + logarithm(n?: Decimal.Value): Decimal; + log(n?: Decimal.Value): Decimal; - minus(n: DecimalValue): Decimal; - sub(n: DecimalValue): Decimal; + minus(n: Decimal.Value): Decimal; + sub(n: Decimal.Value): Decimal; - modulo(n: DecimalValue): Decimal; - mod(n: DecimalValue): Decimal; + modulo(n: Decimal.Value): Decimal; + mod(n: Decimal.Value): Decimal; naturalExponential(): Decimal; exp(): Decimal; @@ -181,8 +160,8 @@ export declare class Decimal { negated(): Decimal; neg(): Decimal; - plus(n: DecimalValue): Decimal; - add(n: DecimalValue): Decimal; + plus(n: Decimal.Value): Decimal; + add(n: Decimal.Value): Decimal; precision(includeZeros?: boolean): number; sd(includeZeros?: boolean): number; @@ -198,49 +177,49 @@ export declare class Decimal { tangent() : Decimal; tan() : Decimal; - times(n: DecimalValue): Decimal; - mul(n: DecimalValue) : Decimal; + times(n: Decimal.Value): Decimal; + mul(n: Decimal.Value) : Decimal; toBinary(significantDigits?: number): string; - toBinary(significantDigits: number, rounding: DecimalRounding): string; + toBinary(significantDigits: number, rounding: Decimal.Rounding): string; toDecimalPlaces(decimalPlaces?: number): Decimal; - toDecimalPlaces(decimalPlaces: number, rounding: DecimalRounding): Decimal; + toDecimalPlaces(decimalPlaces: number, rounding: Decimal.Rounding): Decimal; toDP(decimalPlaces?: number): Decimal; - toDP(decimalPlaces: number, rounding: DecimalRounding): Decimal; + toDP(decimalPlaces: number, rounding: Decimal.Rounding): Decimal; toExponential(decimalPlaces?: number): string; - toExponential(decimalPlaces: number, rounding: DecimalRounding): string; + toExponential(decimalPlaces: number, rounding: Decimal.Rounding): string; toFixed(decimalPlaces?: number): string; - toFixed(decimalPlaces: number, rounding: DecimalRounding): string; + toFixed(decimalPlaces: number, rounding: Decimal.Rounding): string; - toFraction(max_denominator?: DecimalValue): Decimal[]; + toFraction(max_denominator?: Decimal.Value): Decimal[]; toHexadecimal(significantDigits?: number): string; - toHexadecimal(significantDigits: number, rounding: DecimalRounding): string; + toHexadecimal(significantDigits: number, rounding: Decimal.Rounding): string; toHex(significantDigits?: number): string; - toHex(significantDigits: number, rounding?: DecimalRounding): string; + toHex(significantDigits: number, rounding?: Decimal.Rounding): string; toJSON(): string; - toNearest(n: DecimalValue, rounding?: DecimalRounding): Decimal; + toNearest(n: Decimal.Value, rounding?: Decimal.Rounding): Decimal; toNumber(): number; toOctal(significantDigits?: number): string; - toOctal(significantDigits: number, rounding: DecimalRounding): string; + toOctal(significantDigits: number, rounding: Decimal.Rounding): string; - toPower(n: DecimalValue): Decimal; - pow(n: DecimalValue): Decimal; + toPower(n: Decimal.Value): Decimal; + pow(n: Decimal.Value): Decimal; toPrecision(significantDigits?: number): string; - toPrecision(significantDigits: number, rounding: DecimalRounding): string; + toPrecision(significantDigits: number, rounding: Decimal.Rounding): string; toSignificantDigits(significantDigits?: number): Decimal; - toSignificantDigits(significantDigits: number, rounding: DecimalRounding): Decimal; + toSignificantDigits(significantDigits: number, rounding: Decimal.Rounding): Decimal; toSD(significantDigits?: number): Decimal; - toSD(significantDigits: number, rounding: DecimalRounding): Decimal; + toSD(significantDigits: number, rounding: Decimal.Rounding): Decimal; toString(): string; @@ -249,59 +228,59 @@ export declare class Decimal { valueOf(): string; - static abs(n: DecimalValue): Decimal; - static acos(n: DecimalValue): Decimal; - static acosh(n: DecimalValue): Decimal; - static add(x: DecimalValue, y: DecimalValue): Decimal; - static asin(n: DecimalValue): Decimal; - static asinh(n: DecimalValue): Decimal; - static atan(n: DecimalValue): Decimal; - static atanh(n: DecimalValue): Decimal; - static atan2(y: DecimalValue, x: DecimalValue): Decimal; - static cbrt(n: DecimalValue): Decimal; - static ceil(n: DecimalValue): Decimal; - static clone(object?: DecimalConfig): DecimalConstructor; - static config(object: DecimalConfig): DecimalConstructor; - static cos(n: DecimalValue): Decimal; - static cosh(n: DecimalValue): Decimal; - static div(x: DecimalValue, y: DecimalValue): Decimal; - static exp(n: DecimalValue): Decimal; - static floor(n: DecimalValue): Decimal; - static hypot(...n: DecimalValue[]): Decimal; + static abs(n: Decimal.Value): Decimal; + static acos(n: Decimal.Value): Decimal; + static acosh(n: Decimal.Value): Decimal; + static add(x: Decimal.Value, y: Decimal.Value): Decimal; + static asin(n: Decimal.Value): Decimal; + static asinh(n: Decimal.Value): Decimal; + static atan(n: Decimal.Value): Decimal; + static atanh(n: Decimal.Value): Decimal; + static atan2(y: Decimal.Value, x: Decimal.Value): Decimal; + static cbrt(n: Decimal.Value): Decimal; + static ceil(n: Decimal.Value): Decimal; + static clone(object?: Decimal.Config): Decimal.Constructor; + static config(object: Decimal.Config): Decimal.Constructor; + static cos(n: Decimal.Value): Decimal; + static cosh(n: Decimal.Value): Decimal; + static div(x: Decimal.Value, y: Decimal.Value): Decimal; + static exp(n: Decimal.Value): Decimal; + static floor(n: Decimal.Value): Decimal; + static hypot(...n: Decimal.Value[]): Decimal; static isDecimal(object: any): boolean - static ln(n: DecimalValue): Decimal; - static log(n: DecimalValue, base?: DecimalValue): Decimal; - static log2(n: DecimalValue): Decimal; - static log10(n: DecimalValue): Decimal; - static max(...n: DecimalValue[]): Decimal; - static min(...n: DecimalValue[]): Decimal; - static mod(x: DecimalValue, y: DecimalValue): Decimal; - static mul(x: DecimalValue, y: DecimalValue): Decimal; - static noConflict(): DecimalConstructor; // Browser only - static pow(base: DecimalValue, exponent: DecimalValue): Decimal; + static ln(n: Decimal.Value): Decimal; + static log(n: Decimal.Value, base?: Decimal.Value): Decimal; + static log2(n: Decimal.Value): Decimal; + static log10(n: Decimal.Value): Decimal; + static max(...n: Decimal.Value[]): Decimal; + static min(...n: Decimal.Value[]): Decimal; + static mod(x: Decimal.Value, y: Decimal.Value): Decimal; + static mul(x: Decimal.Value, y: Decimal.Value): Decimal; + static noConflict(): Decimal.Constructor; // Browser only + static pow(base: Decimal.Value, exponent: Decimal.Value): Decimal; static random(significantDigits?: number): Decimal; - static round(n: DecimalValue): Decimal; - static set(object: DecimalConfig): DecimalConstructor; - static sign(n: DecimalValue): Decimal; - static sin(n: DecimalValue): Decimal; - static sinh(n: DecimalValue): Decimal; - static sqrt(n: DecimalValue): Decimal; - static sub(x: DecimalValue, y: DecimalValue): Decimal; - static tan(n: DecimalValue): Decimal; - static tanh(n: DecimalValue): Decimal; - static trunc(n: DecimalValue): Decimal; + static round(n: Decimal.Value): Decimal; + static set(object: Decimal.Config): Decimal.Constructor; + static sign(n: Decimal.Value): Decimal; + static sin(n: Decimal.Value): Decimal; + static sinh(n: Decimal.Value): Decimal; + static sqrt(n: Decimal.Value): Decimal; + static sub(x: Decimal.Value, y: Decimal.Value): Decimal; + static tan(n: Decimal.Value): Decimal; + static tanh(n: Decimal.Value): Decimal; + static trunc(n: Decimal.Value): Decimal; - static readonly default?: DecimalConstructor; - static readonly Decimal?: DecimalConstructor; + static readonly default?: Decimal.Constructor; + static readonly Decimal?: Decimal.Constructor; static readonly precision: number; - static readonly rounding: DecimalRounding; + static readonly rounding: Decimal.Rounding; static readonly toExpNeg: number; static readonly toExpPos: number; static readonly minE: number; static readonly maxE: number; static readonly crypto: boolean; - static readonly modulo: DecimalModulo; + static readonly modulo: Decimal.Modulo; static readonly ROUND_UP: 0; static readonly ROUND_DOWN: 1; diff --git a/decimal.global.d.ts b/decimal.global.d.ts new file mode 100644 index 0000000..0b0446b --- /dev/null +++ b/decimal.global.d.ts @@ -0,0 +1,316 @@ +// Type definitions for decimal.js >=7.0.0 +// Project: https://github.com/MikeMcl/decimal.js +// Definitions by: Michael Mclaughlin +// Definitions: https://github.com/MikeMcl/decimal.js +// +// Documentation: http://mikemcl.github.io/decimal.js/ +// +// Exports (available globally or when using import): +// +// class Decimal (default export) +// type Decimal.Constructor +// type Decimal.Instance +// type Decimal.Modulo +// type Decimal.Rounding +// type Decimal.Value +// interface Decimal.Config +// +// Example (alternative syntax commented-out): +// +// import {Decimal} from "decimal.js" +// //import Decimal from "decimal.js" +// +// let r: Decimal.Rounding = Decimal.ROUND_UP; +// let c: Decimal.Configuration = {precision: 4, rounding: r}; +// Decimal.set(c); +// let v: Decimal.Value = '12345.6789'; +// let d: Decimal = new Decimal(v); +// //let d: Decimal.Instance = new Decimal(v); +// +// The use of compiler option `--strictNullChecks` is recommended. + +export default Decimal; + +export namespace Decimal { + export type Config = DecimalConfig; + export type Constructor = DecimalConstructor; + export type Instance = DecimalInstance; + export type Modulo = DecimalModulo; + export type Rounding = DecimalRounding; + export type Value = DecimalValue; +} + +declare global { + const Decimal: DecimalConstructor; + type Decimal = DecimalInstance; + + namespace Decimal { + type Config = DecimalConfig; + type Constructor = DecimalConstructor; + type Instance = DecimalInstance; + type Modulo = DecimalModulo; + type Rounding = DecimalRounding; + type Value = DecimalValue; + } +} + +type DecimalInstance = Decimal; +type DecimalConstructor = typeof Decimal; +type DecimalValue = string | number | Decimal; +type DecimalRounding = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8; +type DecimalModulo = DecimalRounding | 9; + +// http://mikemcl.github.io/decimal.js/#constructor-properties +interface DecimalConfig { + precision?: number; + rounding?: DecimalRounding; + toExpNeg?: number; + toExpPos?: number; + minE?: number; + maxE?: number; + crypto?: boolean; + modulo?: DecimalModulo; + defaults?: boolean; +} + +export declare class Decimal { + readonly d: number[]; + readonly e: number; + readonly s: number; + private readonly name: string; + + constructor(n: DecimalValue); + + absoluteValue(): Decimal; + abs(): Decimal; + + ceil(): Decimal; + + comparedTo(n: DecimalValue): number; + cmp(n: DecimalValue): number; + + cosine(): Decimal; + cos(): Decimal; + + cubeRoot(): Decimal; + cbrt(): Decimal; + + decimalPlaces(): number; + dp(): number; + + dividedBy(n: DecimalValue): Decimal; + div(n: DecimalValue): Decimal; + + dividedToIntegerBy(n: DecimalValue): Decimal; + divToInt(n: DecimalValue): Decimal; + + equals(n: DecimalValue): boolean; + eq(n: DecimalValue): boolean; + + floor(): Decimal; + + greaterThan(n: DecimalValue): boolean; + gt(n: DecimalValue): boolean; + + greaterThanOrEqualTo(n: DecimalValue): boolean; + gte(n: DecimalValue): boolean; + + hyperbolicCosine(): Decimal; + cosh(): Decimal; + + hyperbolicSine(): Decimal; + sinh(): Decimal; + + hyperbolicTangent(): Decimal; + tanh(): Decimal; + + inverseCosine(): Decimal; + acos(): Decimal; + + inverseHyperbolicCosine(): Decimal; + acosh(): Decimal; + + inverseHyperbolicSine(): Decimal; + asinh(): Decimal; + + inverseHyperbolicTangent(): Decimal; + atanh(): Decimal; + + inverseSine(): Decimal; + asin(): Decimal; + + inverseTangent(): Decimal; + atan(): Decimal; + + isFinite(): boolean; + + isInteger(): boolean; + isInt(): boolean; + + isNaN(): boolean; + + isNegative(): boolean; + isNeg(): boolean; + + isPositive(): boolean; + isPos(): boolean; + + isZero(): boolean; + + lessThan(n: DecimalValue): boolean; + lt(n: DecimalValue): boolean; + + lessThanOrEqualTo(n: DecimalValue): boolean; + lte(n: DecimalValue): boolean; + + logarithm(n?: DecimalValue): Decimal; + log(n?: DecimalValue): Decimal; + + minus(n: DecimalValue): Decimal; + sub(n: DecimalValue): Decimal; + + modulo(n: DecimalValue): Decimal; + mod(n: DecimalValue): Decimal; + + naturalExponential(): Decimal; + exp(): Decimal; + + naturalLogarithm(): Decimal; + ln(): Decimal; + + negated(): Decimal; + neg(): Decimal; + + plus(n: DecimalValue): Decimal; + add(n: DecimalValue): Decimal; + + precision(includeZeros?: boolean): number; + sd(includeZeros?: boolean): number; + + round(): Decimal; + + sine() : Decimal; + sin() : Decimal; + + squareRoot(): Decimal; + sqrt(): Decimal; + + tangent() : Decimal; + tan() : Decimal; + + times(n: DecimalValue): Decimal; + mul(n: DecimalValue) : Decimal; + + toBinary(significantDigits?: number): string; + toBinary(significantDigits: number, rounding: DecimalRounding): string; + + toDecimalPlaces(decimalPlaces?: number): Decimal; + toDecimalPlaces(decimalPlaces: number, rounding: DecimalRounding): Decimal; + toDP(decimalPlaces?: number): Decimal; + toDP(decimalPlaces: number, rounding: DecimalRounding): Decimal; + + toExponential(decimalPlaces?: number): string; + toExponential(decimalPlaces: number, rounding: DecimalRounding): string; + + toFixed(decimalPlaces?: number): string; + toFixed(decimalPlaces: number, rounding: DecimalRounding): string; + + toFraction(max_denominator?: DecimalValue): Decimal[]; + + toHexadecimal(significantDigits?: number): string; + toHexadecimal(significantDigits: number, rounding: DecimalRounding): string; + toHex(significantDigits?: number): string; + toHex(significantDigits: number, rounding?: DecimalRounding): string; + + toJSON(): string; + + toNearest(n: DecimalValue, rounding?: DecimalRounding): Decimal; + + toNumber(): number; + + toOctal(significantDigits?: number): string; + toOctal(significantDigits: number, rounding: DecimalRounding): string; + + toPower(n: DecimalValue): Decimal; + pow(n: DecimalValue): Decimal; + + toPrecision(significantDigits?: number): string; + toPrecision(significantDigits: number, rounding: DecimalRounding): string; + + toSignificantDigits(significantDigits?: number): Decimal; + toSignificantDigits(significantDigits: number, rounding: DecimalRounding): Decimal; + toSD(significantDigits?: number): Decimal; + toSD(significantDigits: number, rounding: DecimalRounding): Decimal; + + toString(): string; + + truncated(): Decimal; + trunc(): Decimal; + + valueOf(): string; + + static abs(n: DecimalValue): Decimal; + static acos(n: DecimalValue): Decimal; + static acosh(n: DecimalValue): Decimal; + static add(x: DecimalValue, y: DecimalValue): Decimal; + static asin(n: DecimalValue): Decimal; + static asinh(n: DecimalValue): Decimal; + static atan(n: DecimalValue): Decimal; + static atanh(n: DecimalValue): Decimal; + static atan2(y: DecimalValue, x: DecimalValue): Decimal; + static cbrt(n: DecimalValue): Decimal; + static ceil(n: DecimalValue): Decimal; + static clone(object?: DecimalConfig): DecimalConstructor; + static config(object: DecimalConfig): DecimalConstructor; + static cos(n: DecimalValue): Decimal; + static cosh(n: DecimalValue): Decimal; + static div(x: DecimalValue, y: DecimalValue): Decimal; + static exp(n: DecimalValue): Decimal; + static floor(n: DecimalValue): Decimal; + static hypot(...n: DecimalValue[]): Decimal; + static isDecimal(object: any): boolean + static ln(n: DecimalValue): Decimal; + static log(n: DecimalValue, base?: DecimalValue): Decimal; + static log2(n: DecimalValue): Decimal; + static log10(n: DecimalValue): Decimal; + static max(...n: DecimalValue[]): Decimal; + static min(...n: DecimalValue[]): Decimal; + static mod(x: DecimalValue, y: DecimalValue): Decimal; + static mul(x: DecimalValue, y: DecimalValue): Decimal; + static noConflict(): DecimalConstructor; // Browser only + static pow(base: DecimalValue, exponent: DecimalValue): Decimal; + static random(significantDigits?: number): Decimal; + static round(n: DecimalValue): Decimal; + static set(object: DecimalConfig): DecimalConstructor; + static sign(n: DecimalValue): Decimal; + static sin(n: DecimalValue): Decimal; + static sinh(n: DecimalValue): Decimal; + static sqrt(n: DecimalValue): Decimal; + static sub(x: DecimalValue, y: DecimalValue): Decimal; + static tan(n: DecimalValue): Decimal; + static tanh(n: DecimalValue): Decimal; + static trunc(n: DecimalValue): Decimal; + + static readonly default?: DecimalConstructor; + static readonly Decimal?: DecimalConstructor; + + static readonly precision: number; + static readonly rounding: DecimalRounding; + static readonly toExpNeg: number; + static readonly toExpPos: number; + static readonly minE: number; + static readonly maxE: number; + static readonly crypto: boolean; + static readonly modulo: DecimalModulo; + + static readonly ROUND_UP: 0; + static readonly ROUND_DOWN: 1; + static readonly ROUND_CEIL: 2; + static readonly ROUND_FLOOR: 3; + static readonly ROUND_HALF_UP: 4; + static readonly ROUND_HALF_DOWN: 5; + static readonly ROUND_HALF_EVEN: 6; + static readonly ROUND_HALF_CEIL: 7; + static readonly ROUND_HALF_FLOOR: 8; + static readonly EUCLID: 9; +}