Index

Modules: fixedpoint, fixedpoint/arithmetic, fixedpoint/base, fixedpoint/comparison, fixedpoint/trig, fixedpoint/util.

API symbols

`$`:

• base: proc `$`(d: FixedPoint): string

`*=`:

• arithmetic: proc `*=`(a`gensym15: var FixedPoint; b`gensym15: typeof(a`gensym15))

`*`:

• arithmetic: proc `*`(a, b: FixedPoint): typeof(a)
• arithmetic: proc `*`(a`gensym10: FixedPoint; b`gensym10: SomeNumber): typeof(a`gensym10)
• arithmetic: proc `*`(a`gensym10: SomeNumber; b`gensym10: FixedPoint): typeof(b`gensym10)

`+=`:

• arithmetic: proc `+=`(a`gensym13: var FixedPoint; b`gensym13: typeof(a`gensym13))

`+`:

• arithmetic: proc `+`(a, b: FixedPoint): typeof(a)
• arithmetic: proc `+`(a`gensym8: FixedPoint; b`gensym8: SomeNumber): typeof(a`gensym8)
• arithmetic: proc `+`(a`gensym8: SomeNumber; b`gensym8: FixedPoint): typeof(b`gensym8)

`-=`:

• arithmetic: proc `-=`(a`gensym14: var FixedPoint; b`gensym14: typeof(a`gensym14))

`-`:

• arithmetic: proc `-`(value`gensym17: FixedPoint): typeof(value`gensym17)
• arithmetic: proc `-`(a, b: FixedPoint): typeof(a)
• arithmetic: proc `-`(a`gensym9: FixedPoint; b`gensym9: SomeNumber): typeof(a`gensym9)
• arithmetic: proc `-`(a`gensym9: SomeNumber; b`gensym9: FixedPoint): typeof(b`gensym9)

`/=`:

• arithmetic: proc `/=`(a`gensym16: var FixedPoint; b`gensym16: typeof(a`gensym16))

`/`:

• arithmetic: proc `/`(a, b: FixedPoint): typeof(a)
• arithmetic: proc `/`(a`gensym11: FixedPoint; b`gensym11: SomeNumber): typeof(a`gensym11)
• arithmetic: proc `/`(a`gensym11: SomeNumber; b`gensym11: FixedPoint): typeof(b`gensym11)

`<=`:

• comparison: proc `<=`(a`gensym2, b`gensym2: FixedPoint): bool
• comparison: proc `<=`(a`gensym2: FixedPoint; b`gensym2: SomeNumber): bool
• comparison: proc `<=`(a`gensym2: SomeNumber; b`gensym2: FixedPoint): bool

`<`:

• comparison: proc `<`(a`gensym1, b`gensym1: FixedPoint): bool
• comparison: proc `<`(a`gensym1: FixedPoint; b`gensym1: SomeNumber): bool
• comparison: proc `<`(a`gensym1: SomeNumber; b`gensym1: FixedPoint): bool

`==`:

• comparison: proc `==`(a`gensym0, b`gensym0: FixedPoint): bool
• comparison: proc `==`(a`gensym0: FixedPoint; b`gensym0: SomeNumber): bool
• comparison: proc `==`(a`gensym0: SomeNumber; b`gensym0: FixedPoint): bool

`as`:

• base: template `as`(value: typed; prototype: FixedPoint): typeof(prototype)

`div`:

• arithmetic: proc `div`(a`gensym12: FixedPoint; b`gensym12: SomeNumber): typeof(a`gensym12)
• arithmetic: proc `div`(a`gensym12: SomeNumber; b`gensym12: FixedPoint): typeof(b`gensym12)
• arithmetic: template `div`(a, b: FixedPoint): auto

abs:

• arithmetic: proc abs(value`gensym18: FixedPoint): typeof(value`gensym18)

arctan2:

• trig: proc arctan2(y, x: FixedPoint): typeof(y)

cos:

• trig: proc cos(value: FixedPoint): typeof(value)

degToRad:

• trig: proc degToRad(value: FixedPoint): typeof(value)

FixedPoint:

• base: type FixedPoint

fp32:

• base: proc fp32(value: SomeFloat; precision: static Natural): FPInt32[precision]
• base: proc fp32(value: SomeInteger; precision: static Natural): FPInt32[precision]

fp64:

• base: proc fp64(value: SomeFloat; precision: static Natural): FPInt64[precision]
• base: proc fp64(value: SomeInteger; precision: static Natural): FPInt64[precision]

FPInt32:

• base: type FPInt32

FPInt64:

• base: type FPInt64

high:

• base: proc high(typ: typedesc[FixedPoint]): typ:type

isqrt:

• util: proc isqrt(n: SomeInteger): SomeInteger

low:

• base: proc low(typ: typedesc[FixedPoint]): typ:type

lowestPositive:

• base: proc lowestPositive(typ: typedesc[FixedPoint]): typ:type

normalizeRads:

• trig: proc normalizeRads(value: FixedPoint): typeof(value)

precision:

• base: macro precision(num: FixedPoint): Natural

radToDeg:

• trig: proc radToDeg(value: FixedPoint): typeof(value)

rand:

• base: proc rand[T: FixedPoint](x: HSlice[T, T]): T

sgn:

• base: proc sgn(value: FixedPoint): typeof(value)

sin:

• trig: proc sin(value: FixedPoint): typeof(value)

sqrt:

• arithmetic: proc sqrt(value: FixedPoint): typeof(value)

to:

• base: proc to(value: FixedPoint; typ: typedesc[SomeNumber]): typ:type

toFloat:

• base: proc toFloat(d: FixedPoint): auto

toFp32:

• base: proc toFp32(value: FixedPoint): auto

toFp64:

• base: proc toFp64(value: FixedPoint): auto

toInt:

• base: proc toInt(d: FixedPoint): auto

underlying:

• base: template underlying(value: FixedPoint | typedesc[FixedPoint]): typedesc