Index

Modules: pmath, pmath/basic, pmath/constants, pmath/core/types, pmath/core/utils, pmath/expanded, pmath/private/utils, pmath/templates, pmath/types.

API symbols

`!!`:

• types: macro `!!`(body: untyped): untyped
• types: macro `!!`(body: untyped): untyped

`!`:

• types: template `!`(i: SomeNumber): untyped
• types: template `!`(i: SomeNumber): untyped

`$`:

• types: proc `$`(p: PNum): string
• types: proc `$`(p: PNum): string

`*=`:

• basic: template `*=`(a: var PNum; b: PNum): untyped
• utils: template `*=`(a: var BigInt; b: SomeInteger): untyped
• utils: template `*=`(a: var BigInt; b: SomeInteger): untyped

`*`:

• basic: proc `*`(a: PNum; b: PNum): PNum
• utils: template `*`(a: BigInt; b: SomeInteger): untyped
• utils: template `*`(a: BigInt; b: SomeInteger): untyped
• templates: template `*`(a: PNum; b: SomeNumber): untyped

`+=`:

• basic: template `+=`(a: var PNum; b: PNum): untyped

`+`:

• basic: proc `+`(a: PNum; b: PNum): PNum
• templates: template `+`(a: PNum; b: SomeNumber): untyped

`-=`:

• basic: template `-=`(a: var PNum; b: PNum): untyped

`-`:

• basic: template `-`(a: PNum): PNum
• basic: template `-`(a, b: PNum): PNum
• templates: template `-`(a: PNum; b: SomeNumber): untyped

`/=`:

• basic: template `/=`(a: var PNum; b: PNum): untyped

`/`:

• basic: proc `/`(a: PNum; b: PNum): PNum
• utils: proc `/`(a: BigInt; b: BigInt): BiggestFloat
• utils: proc `/`(a: BigInt; b: BigInt): BiggestFloat
• templates: template `/`(a: PNum; b: SomeNumber): untyped

`<=`:

• basic: template `<=`(a: PNum; b: PNum): untyped

`<`:

• basic: template `<`(a: PNum; b: PNum): untyped
• utils: template `<`(a: BigInt; b: SomeInteger): untyped
• utils: template `<`(a: SomeInteger; b: BigInt): untyped
• utils: template `<`(a: BigInt; b: SomeInteger): untyped
• utils: template `<`(a: SomeInteger; b: BigInt): untyped

`==`:

• basic: proc `==`(a: PNum; b: PNum): bool
• utils: template `==`(a: (BigInt, BigInt); b: (SomeInteger, SomeInteger)): untyped
• utils: template `==`(a: BigInt; b: SomeInteger): untyped
• utils: template `==`(a: (BigInt, BigInt); b: (SomeInteger, SomeInteger)): untyped
• utils: template `==`(a: BigInt; b: SomeInteger): untyped

`>=`:

• basic: template `>=`(a: PNum; b: PNum): untyped

`>`:

• basic: proc `>`(a: PNum; b: PNum): bool

`^=`:

• basic: template `^=`(a: var PNum; b: PNum): untyped

`^`:

• basic: proc `^`(a: PNum; p: PNum): PNum
• utils: proc `^`[T: BigInt | Natural](a: BigInt; b: T): BigInt
• utils: proc `^`[T: BigInt | Natural](a: BigInt; b: T): BigInt
• templates: template `^`(a: PNum; b: SomeNumber): untyped

`mod`:

• basic: proc `mod`(a, b: PNum): PNum

adjustRadical:

• types: proc adjustRadical(pn: PNum; pow: int): PNum
• types: proc adjustRadical(pn: PNum; pow: int): PNum

BigIntDanger:

• utils: object BigIntDanger
• utils: object BigIntDanger

cbrt:

• basic: proc cbrt(a: PNum): PNum

copyToRef:

• types: proc copyToRef(pn: PNum): PNumRef
• types: proc copyToRef(pn: PNum): PNumRef

decimalToFraction:

• utils: proc decimalToFraction(d: BiggestFloat): (BiggestInt, BiggestInt)
• utils: proc decimalToFraction(d: BiggestFloat): (BiggestInt, BiggestInt)

ensureRadical:

• types: proc ensureRadical(pn: PNum): PNum
• types: proc ensureRadical(pn: PNum): PNum

flip:

• types: proc flip(pn: PNum): PNum
• types: proc flip(pn: PNum): PNum

i:

• constants: template i(c: PMathConstants): untyped

inc:

• basic: template inc(a: var PNum): untyped

isImaginary:

• types: proc isImaginary(pn: PNum): bool
• types: proc isImaginary(pn: PNum): bool

isNegative:

• types: proc isNegative(pn: PNum): bool
• types: proc isNegative(pn: PNum): bool

newPNum:

• types: proc newPNum(a: BigInt): PNum
• types: proc newPNum(a: BigInt; b: BigInt): PNum
• types: proc newPNum(i: SomeFloat): PNum
• types: proc newPNum(i: SomeInteger): PNum
• types: proc newPNum(a: SomeInteger; b: SomeInteger): PNum
• types: proc newPNum(a: BigInt): PNum
• types: proc newPNum(a: BigInt; b: BigInt): PNum
• types: proc newPNum(i: SomeFloat): PNum
• types: proc newPNum(i: SomeInteger): PNum
• types: proc newPNum(a: SomeInteger; b: SomeInteger): PNum

newRadical:

• types: proc newRadical(radicand: PNum; power: int; negative = false): PNum
• types: proc newRadical(radicand: PNum; power: int; negative = false): PNum

nthRoot:

• basic: proc nthRoot(a: PNum; n: PNum): PNum
• utils: proc nthRoot(a: BiggestFloat; n: BiggestFloat): BiggestFloat
• utils: proc nthRoot(a: BiggestFloat; n: BiggestFloat): BiggestFloat

pmathBigInts:

• utils: const pmathBigInts
• utils: const pmathBigInts

pmathConstants:

• constants: let pmathConstants

pnkFraction:

• types: PNumKind.pnkFraction
• types: PNumKind.pnkFraction

pnkRadical:

• types: PNumKind.pnkRadical
• types: PNumKind.pnkRadical

PNum:

• types: object PNum
• types: object PNum

PNumKind:

• types: enum PNumKind
• types: enum PNumKind

PNumRef:

• types: type PNumRef
• types: type PNumRef

setNegative:

• types: proc setNegative(pn: var PNum; n: bool)
• types: proc setNegative(pn: var PNum; n: bool)

simplify:

• types: proc simplify(pn: var PNum)
• types: proc simplify(pn: var PNum)

simplifyRadicalFrac:

• utils: proc simplifyRadicalFrac(n: BiggestInt; d: BiggestInt; pow: int): (int, int)
• utils: proc simplifyRadicalFrac(n: BigInt; d: BigInt; pow: int): (BigInt, BigInt)
• utils: proc simplifyRadicalFrac(n: BiggestInt; d: BiggestInt; pow: int): (int, int)
• utils: proc simplifyRadicalFrac(n: BigInt; d: BigInt; pow: int): (BigInt, BigInt)

sqrt:

• basic: proc sqrt(a: PNum): PNum

toBiggestFloat:

• types: converter toBiggestFloat(pn: PNum): BiggestFloat
• types: converter toBiggestFloat(pn: PNum): BiggestFloat

toBiggestInt:

• utils: converter toBiggestInt(i: BigInt): BiggestInt
• utils: converter toBiggestInt(i: BigInt): BiggestInt

toComplex:

• types: converter toComplex(pn: PNum): Complex[BiggestFloat]
• types: converter toComplex(pn: PNum): Complex[BiggestFloat]

toFloat:

• types: converter toFloat(pn: PNum): float
• types: converter toFloat(pn: PNum): float

toInt:

• types: converter toInt(pn: PNum): int
• types: converter toInt(pn: PNum): int

toIntC:

• utils: proc toIntC[T: SomeInteger](i: BigInt): T
• utils: proc toIntC[T: SomeInteger](i: BigInt): T

toPNum:

• types: converter toPNum(n: SomeNumber): PNum
• types: converter toPNum(n: SomeNumber): PNum

undefined:

• constants: template undefined(c: PMathConstants): untyped