Index

Modules: numericalnim, numericalnim/common/commonTypes, numericalnim/differentiate, numericalnim/integrate, numericalnim/interpolate, numericalnim/ode, numericalnim/optimize, numericalnim/private/arraymancerOverloads, numericalnim/rbf, numericalnim/utils.

API symbols

`$`:

• utils: proc `$`(v: Vector): string

`*.=`:

• utils: proc `*.=`[T](v1: var Vector[T]; v2: Vector[T])

`*.`:

• utils: proc `*.`[T](v1, v2: Vector[T]): Vector[T]

`*=`:

• utils: proc `*=`[T](v1: var Vector[T]; d: float)

`*`:

• arraymancerOverloads: proc `*`[T: not SomeNumber](t1: Tensor[float]; t2: Tensor[T]): Tensor[T]
• arraymancerOverloads: proc `*`[T: not SomeNumber](t1: Tensor[T]; t2: Tensor[float]): Tensor[T]
• arraymancerOverloads: proc `*`[T: not SomeNumber](t1: Tensor[T]; t2: Tensor[T]): Tensor[T]
• utils: proc `*`[T](d: float; v1: Vector[T]): Vector[T]
• utils: proc `*`[T](v1: Vector[T]; d: float): Vector[T]
• utils: proc `*`[T](v1, v2: Vector[T]): float

`+.=`:

• utils: template `+.=`[T](v1: var Vector[T]; d: float)

`+.`:

• utils: template `+.`[T](d: float; v1: Vector[T]): Vector[T]
• utils: template `+.`[T](v1: Vector[T]; d: float): Vector[T]

`+=`:

• utils: proc `+=`[T](v1: var Vector[T]; d: float)
• utils: proc `+=`[T](v1: var Vector[T]; d: T)
• utils: proc `+=`[T](v1: var Vector[T]; v2: Vector[T])

`+`:

• arraymancerOverloads: proc `+`[T: not SomeNumber](t1: Tensor[T]; t2: Tensor[T]): Tensor[T]
• utils: proc `+`[T](d: float; v1: Vector[T]): Vector[T]
• utils: proc `+`[T](d: T; v1: Vector[T]): Vector[T]
• utils: proc `+`[T](v1: Vector[T]; d: float): Vector[T]
• utils: proc `+`[T](v1: Vector[T]; d: T): Vector[T]
• utils: proc `+`[T](v1, v2: Vector[T]): Vector[T]

`-.=`:

• utils: template `-.=`[T](v1: var Vector[T]; d: float)

`-.`:

• utils: template `-.`[T](d: float; v1: Vector[T]): Vector[T]
• utils: template `-.`[T](v1: Vector[T]; d: float): Vector[T]

`-=`:

• utils: proc `-=`[T](v1: var Vector[T]; d: float)
• utils: proc `-=`[T](v1: var Vector[T]; d: T)
• utils: proc `-=`[T](v1: var Vector[T]; v2: Vector[T])

`-`:

• utils: proc `-`[T](d: float; v1: Vector[T]): Vector[T]
• utils: proc `-`[T](d: T; v1: Vector[T]): Vector[T]
• utils: proc `-`[T](v1: Vector[T]): Vector[T]
• utils: proc `-`[T](v1: Vector[T]; d: float): Vector[T]
• utils: proc `-`[T](v1: Vector[T]; d: T): Vector[T]
• utils: proc `-`[T](v1, v2: Vector[T]): Vector[T]

`/.=`:

• utils: proc `/.=`[T](v1: var Vector[T]; v2: Vector[T])

`/.`:

• utils: proc `/.`[T](v1, v2: Vector[T]): Vector[T]

`/=`:

• utils: proc `/=`[T](v1: var Vector[T]; d: float)

`/`:

• utils: proc `/`[T](v1: Vector[T]; d: float): Vector[T]

`==`:

• utils: proc `==`[T](v1, v2: Vector[T]): bool

`@`:

• utils: proc `@`[T](v: Vector[T]): seq[T]
• utils: proc `@`[T](v: Vector[Vector[T]]): seq[seq[T]]
• utils: proc `@`[T](v: Vector[Vector[Vector[T]]]): seq[seq[seq[T]]]

`[]=`:

• commonTypes: proc `[]=`[T; U](ctx: NumContext[T, U]; key: enum; val: T)
• commonTypes: proc `[]=`[T; U](ctx: NumContext[T, U]; key: string; val: T)
• utils: proc `[]=`[T](v: var Vector[T]; i: int; value: T)

`[]`:

• commonTypes: proc `[]`[T; U](ctx: NumContext[T, U]; key: enum): T
• commonTypes: proc `[]`[T; U](ctx: NumContext[T, U]; key: string): T
• utils: proc `[]`[T](v: Vector[T]; i: int): T
• utils: proc `[]`[T](v: var Vector[T]; i: int): var T

`^`:

• utils: proc `^`[float](v: Vector[float]; power: float): Vector[float]
• utils: proc `^`[float](v: Vector[float]; power: Natural): Vector[float]

abs:

• utils: proc abs[T](v1: Vector[T]): Vector[T]

adaptiveGauss:

• integrate: proc adaptiveGauss[T; U](f_in: NumContextProc[T, U]; xStart_in, xEnd_in: U; tol = 1e-8; initialPoints: openArray[U] = @[]; maxintervals: int = 10000; ctx: NumContext[T, U] = nil): T

adaptiveGaussLocal:

• integrate: proc adaptiveGaussLocal[T](f: NumContextProc[T, float]; xStart, xEnd: float; tol = 1e-8; ctx: NumContext[T, float] = nil): T

adaptiveODE:

• ode: const adaptiveODE

adaptiveSimpson:

• integrate: proc adaptiveSimpson[T](f: NumContextProc[T, float]; xStart, xEnd: float; tol = 1e-8; ctx: NumContext[T, float] = nil): T

adaptiveSimpson2:

• integrate: proc adaptiveSimpson2[T](f: NumContextProc[T, float]; xStart, xEnd: float; tol = 1e-8; ctx: NumContext[T, float] = nil): T

allODE:

• ode: const allODE

arange:

• utils: proc arange(x1, x2, dx: float; includeStart = true; includeEnd = false): seq[float]

Armijo:

• optimize: LineSearchCriterion.Armijo

benchmarkit:

• utils: template benchmarkit[T](s: untyped; n = 100; msg = ""; answer: T; onlyEfficiency = false): untyped

bfgs:

• optimize: proc bfgs[U; T: not Tensor](f: proc (x: Tensor[U]): T; x0: Tensor[U]; options: OptimOptions[ U, StandardOptions] = bfgsOptions[U](); analyticGradient: proc (x: Tensor[U]): Tensor[T] = nil): Tensor[ U]

bfgs_old:

• optimize: proc bfgs_old[U; T: not Tensor](f: proc (x: Tensor[U]): T; x0: Tensor[U]; alpha: U = U(1); tol: U = U(0.000001); fastMode: bool = false; analyticGradient: proc ( x: Tensor[U]): Tensor[T] = nil): Tensor[U]

bfgsOptions:

• optimize: proc bfgsOptions[U](tol: U = U(0.000001); alpha: U = U(1); fastMode: bool = false; maxIterations: int = 10000; lineSearchCriterion: LineSearchCriterion = NoLineSearch): OptimOptions[ U, StandardOptions]

calcError:

• utils: proc calcError[T](y_true, y: T): auto

checkGradient:

• differentiate: proc checkGradient[U; T: not Tensor](f: proc (x: Tensor[U]): T; fGrad: proc (x: Tensor[U]): Tensor[T]; x0: Tensor[U]; tol: T): bool
• differentiate: proc checkGradient[U; T](f: proc (x: Tensor[U]): Tensor[T]; fGrad: proc (x: Tensor[U]): Tensor[T]; x0: Tensor[U]; tol: T): bool

checkVectorSizes:

• utils: proc checkVectorSizes(v1, v2: Vector)

chi2:

• utils: proc chi2[T](yData, yFit, yError: seq[T] or Tensor[T]): T

clone:

• utils: proc clone[T](x: T): T

cmpInterval:

• integrate: proc cmpInterval[T; U; V](interval1, interval2: IntervalType[T, U, V]): int

compactRbfFunc:

• rbf: proc compactRbfFunc(r: Tensor[float]; epsilon: float): Tensor[float]

compactRbfFuncScalar:

• rbf: template compactRbfFuncScalar(r: float; epsilon: float): float

conjugate_gradient:

• optimize: proc conjugate_gradient[T](A, b, x_0: Tensor[T]; tolerance: float64): Tensor[T]

Constant:

• interpolate: ExtrapolateKind.Constant

constructMeshedPatches:

• rbf: proc constructMeshedPatches[T](grid: RbfGrid[T]): Tensor[float]

cumGauss:

• integrate: proc cumGauss[T](f_in: NumContextProc[T, float]; X: openArray[float]; tol = 1e-8; initialPoints: openArray[float] = @[]; maxintervals: int = 10000; ctx: NumContext[T, float] = nil): seq[T]

cumGaussSpline:

• integrate: proc cumGaussSpline[T; U](f_in: NumContextProc[T, U]; xStart_in, xEnd_in: U; tol = 1e-8; initialPoints: openArray[U] = @[]; maxintervals: int = 10000; ctx: NumContext[T, U] = nil): InterpolatorType[ T]

cumsimpson:

• integrate: proc cumsimpson[T](f: NumContextProc[T, float]; X: openArray[float]; ctx: NumContext[T, float] = nil; dx = 0.00001): seq[T]
• integrate: proc cumsimpson[T](Y: openArray[T]; X: openArray[float]): seq[T]

cumtrapz:

• integrate: proc cumtrapz[T](f: NumContextProc[T, float]; X: openArray[float]; ctx: NumContext[T, float] = nil; dx = 0.00001): seq[T]
• integrate: proc cumtrapz[T](Y: openArray[T]; X: openArray[float]): seq[T]

delete:

• utils: proc delete[T](s: var seq[T]; idx: seq[int])

derivEval:

• interpolate: proc derivEval[T; U](interpolator: InterpolatorType[T]; x: float; extrap: ExtrapolateKind = Native; extrapValue: U = missing()): T
• interpolate: proc derivEval[T; U](spline: InterpolatorType[T]; x: openArray[float]; extrap: ExtrapolateKind = Native; extrapValue: U = missing()): seq[ T]

derivEval_cubicspline:

• interpolate: proc derivEval_cubicspline[T](spline: InterpolatorType[T]; x: float): T

derivEval_hermitespline:

• interpolate: proc derivEval_hermitespline[T](spline: InterpolatorType[T]; x: float): T

derivEval_linear1d:

• interpolate: proc derivEval_linear1d[T](spline: InterpolatorType[T]; x: float): T

diff1dBackward:

• differentiate: proc diff1dBackward[U, T](f: proc (x: U): T; x0: U; h: U = U(0.000001)): T

diff1dCentral:

• differentiate: proc diff1dCentral[U, T](f: proc (x: U): T; x0: U; h: U = U(0.000001)): T

diff1dForward:

• differentiate: proc diff1dForward[U, T](f: proc (x: U): T; x0: U; h: U = U(0.000001)): T

dot:

• arraymancerOverloads: proc dot[T: not SomeNumber](t1: Tensor[float]; t2: Tensor[T]): T
• utils: proc dot[T](v1, v2: Vector[T]): float

Edge:

• interpolate: ExtrapolateKind.Edge

Error:

• interpolate: ExtrapolateKind.Error

eval:

• interpolate: proc eval[T; U](interpolator: InterpolatorType[T]; x: float; extrap: ExtrapolateKind = Native; extrapValue: U = missing()): T
• interpolate: proc eval[T; U](spline: InterpolatorType[T]; x: openArray[float]; extrap: ExtrapolateKind = Native; extrapValue: U = missing()): seq[T]
• interpolate: template eval[T](interpolator: Interpolator2DType[T]; x, y: float): untyped
• interpolate: template eval[T](interpolator: Interpolator3DType[T]; x, y, z: float): untyped
• interpolate: template eval[T, U](interpolator: InterpolatorUnstructured2DType[T, U]; x, y: T): untyped
• rbf: proc eval[T](rbf: RbfBaseType[T]; x: Tensor[float]): Tensor[T]
• rbf: proc eval[T](rbf: RbfType[T]; x: Tensor[float]): Tensor[T]

Eval2DHandler:

• interpolate: type Eval2DHandler

Eval3DHandler:

• interpolate: type Eval3DHandler

evalAlt:

• rbf: proc evalAlt[T](rbf: RbfType[T]; x: Tensor[float]): Tensor[T]

eval_barycentric2d:

• interpolate: proc eval_barycentric2d[T, U](self: InterpolatorUnstructured2DType[T, U]; x, y: float): U

eval_bicubic:

• interpolate: proc eval_bicubic[T](self: Interpolator2DType[T]; x, y: float): T

eval_bilinear:

• interpolate: proc eval_bilinear[T](self: Interpolator2DType[T]; x, y: float): T

eval_cubicspline:

• interpolate: proc eval_cubicspline[T](spline: InterpolatorType[T]; x: float): T

EvalHandler:

• interpolate: type EvalHandler

eval_hermitespline:

• interpolate: proc eval_hermitespline[T](spline: InterpolatorType[T]; x: float): T

eval_linear1d:

• interpolate: proc eval_linear1d[T](spline: InterpolatorType[T]; x: float): T

eval_nearestneigh:

• interpolate: proc eval_nearestneigh[T](self: Interpolator2DType[T]; x, y: float): T

eval_trilinear:

• interpolate: proc eval_trilinear[T](self: Interpolator3DType[T]; x, y, z: float): T

EvalUnstructured2DHandler:

• interpolate: type EvalUnstructured2DHandler

ExtrapolateKind:

• interpolate: enum ExtrapolateKind

findAllBetween:

• rbf: proc findAllBetween[T](grid: RbfGrid[T]; x: Tensor[float]; rho1, rho2: float): seq[ int]

findAllWithin:

• rbf: proc findAllWithin[T](grid: RbfGrid[T]; x: Tensor[float]; rho: float): seq[int]

findDuplicates:

• utils: proc findDuplicates[T](x: openArray[T]; isSorted: bool = false): seq[seq[int]]

findIndex:

• rbf: proc findIndex[T](grid: RbfGrid[T]; point: Tensor[float]): int

findInterval:

• interpolate: proc findInterval(list: openArray[float]; x: float): int

fixedODE:

• ode: const fixedODE

gaussQuad:

• integrate: proc gaussQuad[T](f: NumContextProc[T, float]; xStart, xEnd: float; N = 100; nPoints = 7; ctx: NumContext[T, float] = nil): T

getF:

• commonTypes: proc getF[T; U](ctx: NumContext[T, U]; key: enum): U
• commonTypes: proc getF[T; U](ctx: NumContext[T, U]; key: string): U

getIndexTable:

• utils: proc getIndexTable[T](x: openArray[T]): Table[T, seq[int]]

hermiteInterpolate:

• utils: proc hermiteInterpolate[T](x: openArray[float]; t: openArray[float]; y, dy: openArray[T]): seq[T]

hermiteSpline:

• utils: proc hermiteSpline[T](x, x1, x2: float; y1, y2, dy1, dy2: T): T

insert:

• integrate: proc insert[T; U; V](intervalList: var IntervalList[T, U, V]; el: IntervalType[T, U, V])

IntegratorProc:

• ode: type IntegratorProc

Interpolator2DType:

• interpolate: type Interpolator2DType

Interpolator3DType:

• interpolate: type Interpolator3DType

InterpolatorProc:

• commonTypes: type InterpolatorProc

InterpolatorType:

• interpolate: type InterpolatorType

InterpolatorUnstructured2DType:

• interpolate: type InterpolatorUnstructured2DType

isClose:

• utils: proc isClose[T](y1, y2: T; tol: float = 0.001): bool

items:

• utils: iterator items[T](v: Vector[T]): T

lbfgs:

• optimize: proc lbfgs[U; T: not Tensor](f: proc (x: Tensor[U]): T; x0: Tensor[U]; options: OptimOptions[ U, LBFGSOptions[U]] = lbfgsOptions[U](); analyticGradient: proc (x: Tensor[U]): Tensor[T] = nil): Tensor[ U]

LBFGSOptions:

• optimize: object LBFGSOptions

lbfgsOptions:

• optimize: proc lbfgsOptions[U](savedIterations: int = 10; tol: U = U(0.000001); alpha: U = U(1); fastMode: bool = false; maxIterations: int = 10000; lineSearchCriterion: LineSearchCriterion = NoLineSearch): OptimOptions[ U, LBFGSOptions[U]]

levmarq:

• optimize: proc levmarq[U; T: not Tensor](f: proc (params: Tensor[U]; x: U): T; params0: Tensor[U]; xData: Tensor[U]; yData: Tensor[T]; options: OptimOptions[U, LevMarqOptions[U]] = levmarqOptions[U](); yError: Tensor[T] = ones_like(yData)): Tensor[U]

LevMarqOptions:

• optimize: object LevMarqOptions

levmarqOptions:

• optimize: proc levmarqOptions[U](lambda0: U = U(1); tol: U = U(0.000001); alpha: U = U(1); fastMode: bool = false; maxIterations: int = 10000; lineSearchCriterion: LineSearchCriterion = NoLineSearch): OptimOptions[ U, LevMarqOptions[U]]

Linear:

• interpolate: ExtrapolateKind.Linear

line_search:

• optimize: proc line_search[U, T](alpha: var U; p: Tensor[T]; x0: Tensor[U]; f: proc (x: Tensor[U]): T; criterion: LineSearchCriterion; fastMode: bool = false)

LineSearchCriterion:

• optimize: enum LineSearchCriterion

linspace:

• utils: proc linspace(x1, x2: float; N: int): seq[float]

mean_squared_error:

• utils: proc mean_squared_error[T](y_true, y: T): auto
• utils: proc mean_squared_error[T](v1, v2: Vector[T]): float

meshgrid:

• utils: proc meshgrid[T](ts: varargs[Tensor[T]]): Tensor[T]

meshgridFlat:

• utils: proc meshgridFlat[T](x, y: Tensor[T]): (Tensor[T], Tensor[T])

mitems:

• utils: iterator mitems[T](v: var Vector[T]): var T

mixedDerivative:

• differentiate: proc mixedDerivative[U, T](f: proc (x: Tensor[U]): T; x0: var Tensor[U]; indices: (int, int); h: U = U(0.000001)): T

Native:

• interpolate: ExtrapolateKind.Native

neighbours:

• rbf: iterator neighbours[T](grid: RbfGrid[T]; k: int; searchLevels: int = 1): int

neighboursExcludingCenter:

• rbf: iterator neighboursExcludingCenter[T](grid: RbfGrid[T]; k: int): int

newBarycentric2D:

• interpolate: proc newBarycentric2D[T: SomeFloat; U](points: Tensor[T]; values: Tensor[U]): InterpolatorUnstructured2DType[ T, U]

newBicubicSpline:

• interpolate: proc newBicubicSpline[T](z: Tensor[T]; xlim, ylim: (float, float)): Interpolator2DType[ T]

newBilinearSpline:

• interpolate: proc newBilinearSpline[T](z: Tensor[T]; xlim, ylim: (float, float)): Interpolator2DType[ T]

newCubicSpline:

• interpolate: proc newCubicSpline[T: SomeFloat](X: openArray[float]; Y: openArray[T]): InterpolatorType[ T]

newHermiteSpline:

• interpolate: proc newHermiteSpline[T](X: openArray[float]; Y: openArray[T]): InterpolatorType[T]
• interpolate: proc newHermiteSpline[T](X: openArray[float]; Y, dY: openArray[T]): InterpolatorType[ T]

newLinear1D:

• interpolate: proc newLinear1D[T](X: openArray[float]; Y: openArray[T]): InterpolatorType[T]

newNearestNeighbour2D:

• interpolate: proc newNearestNeighbour2D[T](z: Tensor[T]; xlim, ylim: (float, float)): Interpolator2DType[ T]

newNumContext:

• commonTypes: proc newNumContext[T; U](fValues: Table[string, U] = initTable[string, U](); tValues: Table[string, T] = initTable[string, T]()): NumContext[ T, U]

newODEoptions:

• ode: proc newODEoptions(dt: float = 0.0001; absTol: float = 0.0001; relTol: float = 0.0001; dtMax: float = 0.01; dtMin: float = 0.0001; scaleMax: float = 4.0; scaleMin: float = 0.1; tStart: float = 0.0): ODEoptions

newRbf:

• rbf: proc newRbf[T](points: Tensor[float]; values: Tensor[T]; gridSize: int = 0; rbfFunc: RbfFunc = compactRbfFunc; epsilon: float = 1): RbfType[T]

newRbfBase:

• rbf: proc newRbfBase[T](points: Tensor[float]; values: Tensor[T]; rbfFunc: RbfFunc = compactRbfFunc; epsilon: float = 1): RbfBaseType[ T]

newRbfGrid:

• rbf: proc newRbfGrid[T](points: Tensor[float]; values: Tensor[T]; gridSize: int = 0): RbfGrid[ T]

newton:

• optimize: proc newton[U; T: not Tensor](f: proc (x: Tensor[U]): T; x0: Tensor[U]; options: OptimOptions[ U, StandardOptions] = newtonOptions[U](); analyticGradient: proc (x: Tensor[U]): Tensor[T] = nil): Tensor[ U]

newtonOptions:

• optimize: proc newtonOptions[U](tol: U = U(0.000001); alpha: U = U(1); fastMode: bool = false; maxIterations: int = 10000; lineSearchCriterion: LineSearchCriterion = NoLineSearch): OptimOptions[ U, StandardOptions]

newtons:

• optimize: proc newtons(f: proc (x: float64): float64; deriv: proc (x: float64): float64; start: float64; precision: float64 = 0.00001; max_iters: Natural = 1000): float64

newTrilinearSpline:

• interpolate: proc newTrilinearSpline[T](f: Tensor[T]; xlim, ylim, zlim: (float, float)): Interpolator3DType[ T]

newVector:

• utils: proc newVector[T](components: openArray[T]): Vector[T]

NoLineSearch:

• optimize: LineSearchCriterion.NoLineSearch

norm:

• utils: proc norm(v1: Vector; p: int = 2): float64

NumContext:

• commonTypes: type NumContext

NumContextProc:

• commonTypes: type NumContextProc

ODEoptions:

• ode: object ODEoptions

ODEProc:

• commonTypes: type ODEProc
• ode: type ODEProc

OptimOptions:

• optimize: object OptimOptions

optimOptions:

• optimize: proc optimOptions[U](tol: U = U(0.000001); alpha: U = U(1); fastMode: bool = false; maxIterations: int = 10000; lineSearchCriterion: LineSearchCriterion = NoLineSearch): OptimOptions[ U, StandardOptions]

pairs:

• utils: iterator pairs[T](v: Vector[T]): (int, T)

paramUncertainties:

• optimize: proc paramUncertainties[U; T](params: Tensor[U]; fitFunc: proc (params: Tensor[U]; x: U): T; xData: Tensor[U]; yData: Tensor[T]; yError: Tensor[T]; returnFullCov = false): Tensor[T]

pop:

• integrate: proc pop[T; U; V](intervalList: var IntervalList[T, U, V]): IntervalType[T, U, V]

RbfBaseType:

• rbf: object RbfBaseType

RbfFunc:

• rbf: type RbfFunc

RbfGrid:

• rbf: object RbfGrid

RbfType:

• rbf: object RbfType

removeDuplicates:

• utils: proc removeDuplicates[Tx, Ty](x: seq[Tx]; y: seq[seq[Ty]]): tuple[x: seq[Tx], y: seq[seq[Ty]]]

romberg:

• integrate: proc romberg[T](f: NumContextProc[T, float]; xStart, xEnd: float; depth = 8; tol = 1e-8; ctx: NumContext[T, float] = nil): T
• integrate: proc romberg[T](Y: openArray[T]; X: openArray[float]): T

scalePoint:

• rbf: proc scalePoint(x: Tensor[float]; limits: tuple[upper: Tensor[float], lower: Tensor[float]]): Tensor[ float]

secant:

• optimize: proc secant(f: proc (x: float64): float64; start: array[2, float64]; precision: float64 = 0.00001; max_iters: Natural = 1000): float64

secondDiff1dBackward:

• differentiate: proc secondDiff1dBackward[U, T](f: proc (x: U): T; x0: U; h: U = U(0.000001)): T

secondDiff1dCentral:

• differentiate: proc secondDiff1dCentral[U, T](f: proc (x: U): T; x0: U; h: U = U(0.000001)): T

secondDiff1dForward:

• differentiate: proc secondDiff1dForward[U, T](f: proc (x: U): T; x0: U; h: U = U(0.000001)): T

setF:

• commonTypes: proc setF[T; U](ctx: NumContext[T, U]; key: enum; val: U)
• commonTypes: proc setF[T; U](ctx: NumContext[T, U]; key: string; val: U)

simpson:

• integrate: proc simpson[T](f: NumContextProc[T, float]; xStart, xEnd: float; N = 500; ctx: NumContext[T, float] = nil): T
• integrate: proc simpson[T](Y: openArray[T]; X: openArray[float]): T

size:

• utils: proc size[T](v: Vector[T]): int

solveODE:

• ode: proc solveODE[T](f: ODEProc[T]; y0: T; tspan: openArray[float]; options: ODEoptions = DEFAULT_ODEoptions; ctx: NumContext[T, float] = nil; integrator = "dopri54"): ( seq[float], seq[T])

sortAndTrimDataset:

• utils: proc sortAndTrimDataset[Tx, Ty](x: seq[Tx]; y: seq[seq[Ty]]; sortOrder: SortOrder = Ascending): tuple[x: seq[Tx], y: seq[seq[Ty]]]
• utils: proc sortAndTrimDataset[Tx, Ty](x: seq[Tx]; y: seq[Ty]; sortOrder: SortOrder = Ascending): tuple[x: seq[Tx], y: seq[Ty]]

sortDataset:

• utils: proc sortDataset[T](X: openArray[float]; Y: openArray[T]): seq[(float, T)]
• utils: proc sortDataset[Tx, Ty](x: seq[Tx]; y: seq[seq[Ty]]; sortOrder: SortOrder = Ascending): tuple[x: seq[Tx], y: seq[seq[Ty]]]
• utils: proc sortDataset[Tx, Ty](x: seq[Tx]; y: seq[Ty]; sortOrder: SortOrder = Ascending): tuple[ x: seq[Tx], y: seq[Ty]]

StandardOptions:

• optimize: object StandardOptions

steepest_descent:

• optimize: proc steepest_descent(deriv: proc (x: float64): float64; start: float64; gamma: float64 = 0.01; precision: float64 = 0.00001; max_iters: Natural = 1000): float64

steepestDescent:

• optimize: proc steepestDescent[U; T: not Tensor](f: proc (x: Tensor[U]): T; x0: Tensor[U]; options: OptimOptions[U, StandardOptions] = steepestDescentOptions[U](); analyticGradient: proc (x: Tensor[U]): Tensor[T] = nil): Tensor[U]

steepestDescentOptions:

• optimize: proc steepestDescentOptions[U](tol: U = U(0.000001); alpha: U = U(0.001); fastMode: bool = false; maxIterations: int = 10000; lineSearchCriterion: LineSearchCriterion = NoLineSearch): OptimOptions[U, StandardOptions]

sum:

• utils: proc sum[T](v: Vector[T]): T

tensorGradient:

• differentiate: proc tensorGradient[U; T: not Tensor](f: proc (x: Tensor[U]): T; x0: Tensor[U]; h: U = U(0.000001); fastMode: bool = false): Tensor[ T]
• differentiate: proc tensorGradient[U, T](f: proc (x: Tensor[U]): Tensor[T]; x0: Tensor[U]; h: U = U(0.000001); fastMode: bool = false): Tensor[T]

tensorHessian:

• differentiate: proc tensorHessian[U; T: not Tensor](f: proc (x: Tensor[U]): T; x0: Tensor[U]; h: U = U(0.000001)): Tensor[T]

tensorJacobian:

• differentiate: proc tensorJacobian[U, T](f: proc (x: Tensor[U]): Tensor[T]; x0: Tensor[U]; h: U = U(0.000001); fastMode: bool = false): Tensor[T]

timeit:

• utils: template timeit(s: untyped; n = 100; msg = ""): untyped

toDerivNumContextProc:

• interpolate: proc toDerivNumContextProc[T](spline: InterpolatorType[T]): NumContextProc[T, float]

toDerivProc:

• interpolate: proc toDerivProc[T](spline: InterpolatorType[T]): InterpolatorProc[T]

toNumContextProc:

• interpolate: converter toNumContextProc[T](spline: InterpolatorType[T]): NumContextProc[T, float]

toProc:

• interpolate: proc toProc[T](spline: InterpolatorType[T]): InterpolatorProc[T]

toTensor:

• utils: proc toTensor(v: Vector): Tensor[float]

trapz:

• integrate: proc trapz[T](f: NumContextProc[T, float]; xStart, xEnd: float; N = 500; ctx: NumContext[T, float] = nil): T
• integrate: proc trapz[T](Y: openArray[T]; X: openArray[float]): T

Vector:

• utils: object Vector

vectorNorm:

• optimize: proc vectorNorm[T](v: Tensor[T]): T

Wolfe:

• optimize: LineSearchCriterion.Wolfe

WolfeStrong:

• optimize: LineSearchCriterion.WolfeStrong