Index

Modules: measuremancer, measuremancer/math_utils.

API symbols

`$`:

• measuremancer: proc `$`[T: FloatLike](m: Measurement[T]): string

`**`:

• measuremancer: proc `**`[T: FloatLike](m: Measurement[T]; p: static SomeInteger): auto
• measuremancer: proc `**`[T: FloatLikeSupportsPow; U: FloatLikeCanBePowExp](a: Measurement[T]; b: Measurement[U]): Measurement[T]
• measuremancer: proc `**`[T: FloatLikeSupportsPow; U: FloatLikeNotInt](m: Measurement[T]; p: U): Measurement[ T]
• measuremancer: proc `**`[T: FloatLikeUnchangedUnderPow](m: Measurement[T]; p: SomeInteger): Measurement[ T]

`*=`:

• measuremancer: proc `*=`[T: FloatLike](a: var Measurement[T]; b: Measurement[T])
• measuremancer: proc `*=`[T: FloatLike](a: var Measurement[T]; b: T)

`*`:

• measuremancer: proc `*`[T: FloatLike; U: FloatLike](x: T{lit}; m: Measurement[U]): Measurement[U]
• measuremancer: proc `*`[T: FloatLike; U: FloatLike](a: Measurement[T]; b: Measurement[U]): auto
• measuremancer: proc `*`[U: FloatLike; T: FloatLike](m: Measurement[U]; x: T{lit}): Measurement[U]
• measuremancer: proc `*`[T: FloatLike; U: FloatLike](m: Measurement[U]; x: T): auto
• measuremancer: proc `*`[T: FloatLike; U: FloatLike](x: T; m: Measurement[U]): auto

`+-`:

• measuremancer: proc `+-`[T: FloatLike](val, uncer: T): Measurement[T]

`+/`:

• measuremancer: proc `+/`[F](x, y: Measurement[F]): Measurement[F]

`+=`:

• measuremancer: proc `+=`[T: FloatLike](a: var Measurement[T]; b: Measurement[T])

`+`:

• measuremancer: proc `+`[T: FloatLike; U: FloatLike](x`gensym7: `{}`(T, lit); m`gensym7: Measurement[U]): Measurement[U]
• measuremancer: proc `+`[U: FloatLike; T: FloatLike](m`gensym7: Measurement[U]; x`gensym7: `{}`(T, lit)): Measurement[U]
• measuremancer: proc `+`[T: FloatLike](m`gensym7: Measurement[T]; x`gensym7: T): Measurement[T]
• measuremancer: proc `+`[T: FloatLike](a, b: Measurement[T]): Measurement[T]
• measuremancer: proc `+`[T: FloatLike](x`gensym7: T; m`gensym7: Measurement[T]): Measurement[T]

`-=`:

• measuremancer: proc `-=`[T: FloatLike](a: var Measurement[T]; b: Measurement[T])

`-`:

• measuremancer: proc `-`[T: FloatLike; U: FloatLike](x`gensym8: `{}`(T, lit); m`gensym8: Measurement[U]): Measurement[U]
• measuremancer: proc `-`[U: FloatLike; T: FloatLike](m`gensym8: Measurement[U]; x`gensym8: `{}`(T, lit)): Measurement[U]
• measuremancer: proc `-`[T: FloatLike](m`gensym8: Measurement[T]; x`gensym8: T): Measurement[T]
• measuremancer: proc `-`[T: FloatLike](m: Measurement[T]): Measurement[T]
• measuremancer: proc `-`[T: FloatLike](a, b: Measurement[T]): Measurement[T]
• measuremancer: proc `-`[T: FloatLike](x`gensym8: T; m`gensym8: Measurement[T]): Measurement[T]

`/`:

• measuremancer: proc `/`[T: FloatLike; U: FloatLike](x: T{lit}; m: Measurement[U]): auto
• measuremancer: proc `/`[T: FloatLike; U: FloatLike](a: Measurement[T]; b: Measurement[U]): auto
• measuremancer: proc `/`[T: FloatLike; U: FloatLike](m: Measurement[T]; x: U): auto
• measuremancer: proc `/`[U: FloatLike; T: FloatLike](m: Measurement[U]; x: T{lit}): Measurement[U]
• measuremancer: proc `/`[T: FloatLike; U: FloatLike](x: T; m: Measurement[U]): auto

`<=`:

• measuremancer: proc `<=`[T: FloatLike](a`gensym106, b`gensym106: Measurement[T]): bool
• measuremancer: proc `<=`[T: FloatLike; U: FloatLike](a`gensym106: Measurement[T]; b`gensym106: `{}`(U, lit)): bool
• measuremancer: proc `<=`[T: FloatLike; U: FloatLike](a`gensym106: `{}`(U, lit); b`gensym106: Measurement[T]): bool
• measuremancer: proc `<=`[T: FloatLike](a`gensym106: Measurement[T]; b`gensym106: T): bool
• measuremancer: proc `<=`[T: FloatLike](a`gensym106: T; b`gensym106: Measurement[T]): bool

`<`:

• measuremancer: proc `<`[T: FloatLike](a`gensym105, b`gensym105: Measurement[T]): bool
• measuremancer: proc `<`[T: FloatLike; U: FloatLike](a`gensym105: Measurement[T]; b`gensym105: `{}`(U, lit)): bool
• measuremancer: proc `<`[T: FloatLike; U: FloatLike](a`gensym105: `{}`(U, lit); b`gensym105: Measurement[T]): bool
• measuremancer: proc `<`[T: FloatLike](a`gensym105: Measurement[T]; b`gensym105: T): bool
• measuremancer: proc `<`[T: FloatLike](a`gensym105: T; b`gensym105: Measurement[T]): bool

`==`:

• measuremancer: proc `==`[T: FloatLike](k1, k2: DerivKey[T]): bool
• measuremancer: proc `==`[T: FloatLike](m1, m2: Measurement[T]): bool
• measuremancer: proc `==`[T: FloatLike; U: FloatLike](m1: Measurement[T]; m2: Measurement[U]): bool
• measuremancer: proc `==`[T: FloatLike](m: Measurement[T]; x: T): bool
• measuremancer: proc `==`[T: FloatLike](x: T; m: Measurement[T]): bool

`^`:

• measuremancer: proc `^`[T: FloatLike](m: Measurement[T]; p: static SomeInteger): auto
• measuremancer: proc `^`[T: FloatLikeSupportsPow; U: FloatLikeCanBePowExp](a: Measurement[T]; b: Measurement[U]): Measurement[T]
• measuremancer: proc `^`[T: FloatLikeSupportsPow; U: FloatLikeNotInt](m: Measurement[T]; p: U): Measurement[ T]
• measuremancer: proc `^`[T: FloatLikeUnchangedUnderPow](m: Measurement[T]; p: SomeInteger): Measurement[ T]

abs:

• measuremancer: proc abs[T: FloatLike](m: Measurement[T]): Measurement[T]

abs2:

• measuremancer: proc abs2[T](m: Measurement[T]): auto

arccos:

• measuremancer: proc arccos[T](m: Measurement[T]): auto

arccosh:

• measuremancer: proc arccosh[T](m: Measurement[T]): auto

arccot:

• measuremancer: proc arccot[T](m: Measurement[T]): auto

arccoth:

• measuremancer: proc arccoth[T](m: Measurement[T]): auto

arccsc:

• measuremancer: proc arccsc[T](m: Measurement[T]): auto

arccsch:

• measuremancer: proc arccsch[T](m: Measurement[T]): auto

arcsec:

• measuremancer: proc arcsec[T](m: Measurement[T]): auto

arcsech:

• measuremancer: proc arcsech[T](m: Measurement[T]): auto

arcsin:

• measuremancer: proc arcsin[T](m: Measurement[T]): auto

arcsinh:

• measuremancer: proc arcsinh[T](m: Measurement[T]): auto

arctan:

• measuremancer: proc arctan[T](m: Measurement[T]): auto

arctanh:

• measuremancer: proc arctanh[T](m: Measurement[T]): auto

cbrt:

• measuremancer: proc cbrt[T](m: Measurement[T]): auto

copysign:

• measuremancer: proc copysign[T: FloatLike](a, b: Measurement[T]): Measurement[T]
• measuremancer: proc copysign[T: FloatLike; U: FloatLike](a: Measurement[T]; b: U): Measurement[T]
• measuremancer: proc copysign[T: FloatLike; U: FloatLike](a: U; b: Measurement[T]): U

cos:

• measuremancer: proc cos[T](m: Measurement[T]): auto

cosh:

• measuremancer: proc cosh[T](m: Measurement[T]): auto

cot:

• measuremancer: proc cot[T](m: Measurement[T]): auto

coth:

• measuremancer: proc coth[T](m: Measurement[T]): auto

csc:

• measuremancer: proc csc[T](m: Measurement[T]): auto

csch:

• measuremancer: proc csch[T](m: Measurement[T]): auto

deg2rad:

• measuremancer: proc deg2rad[T](m: Measurement[T]): auto

erf:

• measuremancer: proc erf[T](m: Measurement[T]): auto

erfc:

• measuremancer: proc erfc[T](m: Measurement[T]): auto

erfcinv:

• measuremancer: proc erfcinv[T](m: Measurement[T]): auto

erfi:

• measuremancer: proc erfi[T](m: Measurement[T]): auto

erfinv:

• measuremancer: proc erfinv[T](m: Measurement[T]): auto

error:

• measuremancer: proc error[T: FloatLike](m: Measurement[T]): T

exp:

• measuremancer: proc exp[T](m: Measurement[T]): auto

exp2:

• measuremancer: proc exp2[T](m: Measurement[T]): auto

expm1:

• measuremancer: proc expm1[T](m: Measurement[T]): auto

FloatLike:

• measuremancer: type FloatLike

FloatLikeCanBePowExp:

• measuremancer: type FloatLikeCanBePowExp

FloatLikeNotInt:

• measuremancer: type FloatLikeNotInt

FloatLikeSupportsPow:

• measuremancer: type FloatLikeSupportsPow

FloatLikeUnchangedUnderPow:

• measuremancer: type FloatLikeUnchangedUnderPow

hash:

• measuremancer: proc hash[T: FloatLike](key: DerivKey[T]): Hash

inv:

• measuremancer: proc inv[T](m: Measurement[T]): auto

isInf:

• measuremancer: proc isInf[T: FloatLike](m: Measurement[T]): bool

isNegInf:

• measuremancer: proc isNegInf[T: FloatLike](m: Measurement[T]): bool

ln:

• measuremancer: proc ln[T](m: Measurement[T]): auto

log:

• measuremancer: proc log[T](m: Measurement[T]): auto

log10:

• measuremancer: proc log10[T](m: Measurement[T]): auto

log1p:

• measuremancer: proc log1p[T](m: Measurement[T]): auto

log2:

• measuremancer: proc log2[T](m: Measurement[T]): auto

mean:

• measuremancer: proc mean[F](x: varargs[Measurement[F]]): Measurement[F]

Measurement:

• measuremancer: object Measurement

measurement:

• measuremancer: proc measurement[T: FloatLike](val, uncer: T{lit}): Measurement[float]
• measuremancer: proc measurement[T: FloatLike](value, uncertainty: T): Measurement[T]

mmErrPrec:

• measuremancer: const mmErrPrec

power:

• math_utils: proc power[T](x: T; num: SomeInteger): T
• math_utils: macro power(x: typed; num: static int): untyped

pretty:

• measuremancer: proc pretty[T: FloatLike](m: Measurement[T]; precision: int; merge = false): string

print:

• measuremancer: template print(arg: untyped): untyped

rad2deg:

• measuremancer: proc rad2deg[T](m: Measurement[T]): auto

sec:

• measuremancer: proc sec[T](m: Measurement[T]): auto

sech:

• measuremancer: proc sech[T](m: Measurement[T]): auto

signbit:

• measuremancer: proc signbit[T: FloatLike](m: Measurement[T]): bool

sin:

• measuremancer: proc sin[T](m: Measurement[T]): auto

sinh:

• measuremancer: proc sinh[T](m: Measurement[T]): auto

sqrt:

• measuremancer: proc sqrt[T](m: Measurement[T]): auto

tan:

• measuremancer: proc tan[T](m: Measurement[T]): auto

tanh:

• measuremancer: proc tanh[T](m: Measurement[T]): auto

to:

• measuremancer: proc to[T: FloatLike; U](m: Measurement[T]; dtype: typedesc[U]): Measurement[U]
• measuremancer: proc to[T: SomeNumber; U](x: T; _: typedesc[U]): U

toFloat:

• measuremancer: proc toFloat[T: SomeFloat](x: T): float
• measuremancer: proc toFloat[T: SomeInteger](x: T): float

uncertainty:

• measuremancer: proc uncertainty[T: FloatLike](m: Measurement[T]): T

value:

• measuremancer: proc value[T: FloatLike](m: Measurement[T]): T

±:

• measuremancer: proc ±[T: FloatLike](val, uncer: T{lit}): Measurement[float]
• measuremancer: proc ±[T: FloatLike](val, uncer: T): Measurement[T]