Index

Modules: column, dataframe, datamancer, df_types, formula, formulaExp, formulaNameMacro, io, value.

API symbols

`$`:

• column: `$`(c: Column): string
• dataframe: `$`(df: DataFrame): string
• formula: `$`(node: FormulaNode): string
• formulaExp: `$`(p: Preface): string
• value: `$`(v: Value): string

`%~`:

• column: `%~`(v: Value): Value
• value: `%~`(v: bool): Value
• value: `%~`(c: char): Value
• value: `%~`[T: not Value](s: openArray[T]): seq[Value]
• value: `%~`(v: OrderedTable[string, Value]): Value
• value: `%~`(v: SomeFloat): Value
• value: `%~`(v: SomeInteger): Value
• value: `%~`(v: string): Value
• value: `%~`(s: openArray[Value]): seq[Value]

`<=`:

• value: `<=`(v, w: Value): bool

`<`:

• value: `<`(v, w: Value): bool

`*`:

• value: `*`(v`gensym94, w`gensym94: Value): Value

`+`:

• value: `+`(v`gensym86, w`gensym86: Value): Value

`-`:

• value: `-`(v`gensym90, w`gensym90: Value): Value

`/`:

• value: `/`(v`gensym98, w`gensym98: Value): Value

`==`:

• value: `==`(v, w: Value): bool

`[]=`:

• column: `[]=`[T](c: var Column; idx: int; val: T)
• column: `[]=`(c: var Column; slice: Slice[int]; col: Column)
• column: `[]=`[T](c: var Column; slice: Slice[int]; t: Tensor[T])
• dataframe: `[]=`[T](df: var DataFrame; fn: FormulaNode; key: string; val: T)
• dataframe: `[]=`(df: var DataFrame; k: string; col: Column)
• dataframe: `[]=`[T](df: var DataFrame; k: string; idx: int; val: T)
• dataframe: `[]=`[T: SomeNumber | string | bool](df: var DataFrame; k: string; t: T)
• dataframe: `[]=`[T: Tensor | seq | array](df: var DataFrame; k: string; t: T)
• value: `[]=`(v: var Value; key: string; val: Value)

`[]`:

• column: `[]`[T](c: Column; idx: int; dtype: typedesc[T]): T
• column: `[]`(c: Column; slice: Slice[int]): Column
• dataframe: `[]`(df: DataFrame; idx: array[1, int]): Column
• dataframe: `[]`[T, U](df: DataFrame; rowSlice: HSlice[T, U]): DataFrame
• dataframe: `[]`(df: DataFrame; k: string): var Column
• dataframe: `[]`(df: DataFrame; k: string; idx: int): Value
• dataframe: `[]`[T](df: DataFrame; k: string; idx: int; dtype: typedesc[T]): T
• dataframe: `[]`(df: DataFrame; k: string; slice: Slice[int]): Column
• dataframe: `[]`[T](df: DataFrame; k: string; slice: Slice[int]; dtype: typedesc[T]): Tensor[ T]
• dataframe: `[]`[T](df: DataFrame; key: string; dtype: typedesc[T]): Tensor[T]
• dataframe: `[]`(df: DataFrame; k: Value): Column
• value: `[]`(v: Value; key: string): Value

`{}`:

• formula: `{}`(x: untyped{ident}; y: untyped): untyped

add:

• column: add(c1, c2: Column): Column
• dataframe: add(df: var DataFrame; dfToAdd: DataFrame)
• dataframe: add[T: tuple](df: var DataFrame; args: T)
• dataframe: add(df: var DataFrame; args: varargs[untyped]): untyped

almostEqual:

• value: almostEqual(a, b: float; epsilon = 1e-8): bool

arrange:

• dataframe: arrange(df: DataFrame; by: varargs[string]; order = SortOrder.Ascending): DataFrame

asgn:

• dataframe: asgn(df: var DataFrame; k: string; col: Column)

Assign:

• formulaExp: Assign

AssignKind:

• formulaExp: AssignKind

assignStack:

• dataframe: assignStack(dfs: seq[DataFrame]): DataFrame

asValue:

• column: asValue[T](t: Tensor[T]): Tensor[Value]

bind_rows:

• dataframe: bind_rows(dfs: varargs[(string, DataFrame)]; id: string = ""): DataFrame
• dataframe: bind_rows(dfs: varargs[DataFrame]; id: string = ""): DataFrame

buildName:

• formulaNameMacro: buildName(n: NimNode): string

buildResultColName:

• formulaNameMacro: buildResultColName(n: NimNode): NimNode

byCustom:

• AssignKind.byCustom

byIndex:

• AssignKind.byIndex

byTensor:

• AssignKind.byTensor

calcNewColumn:

• dataframe: calcNewColumn(df: DataFrame; fn: FormulaNode): (string, Column)

calcNewConstColumnFromScalar:

• dataframe: calcNewConstColumnFromScalar(df: DataFrame; fn: FormulaNode): (string, Column)

clone:

• column: clone(c: Column): Column
• dataframe: clone(df: DataFrame): DataFrame

colBool:

• ColKind.colBool

colConstant:

• ColKind.colConstant

colFloat:

• ColKind.colFloat

colInt:

• ColKind.colInt

ColKind:

• column: ColKind

colMax:

• dataframe: colMax(df: DataFrame; col: string; ignoreInf = true): float

colMin:

• dataframe: colMin(df: DataFrame; col: string; ignoreInf = true): float

colNone:

• ColKind.colNone

colObject:

• ColKind.colObject

colsToDf:

• dataframe: colsToDf(s: varargs[untyped]): untyped

colString:

• ColKind.colString

Column:

• column: Column

combinedColKind:

• column: combinedColKind(c: seq[Column]): ColKind

compatibleColumns:

• column: compatibleColumns(c1, c2: Column): bool

compileFormulaImpl:

• formula: compileFormulaImpl(rawName: static string; funcKind: static FormulaKind): untyped

constantColumn:

• column: constantColumn[T](val: T; len: int): Column

constantToFull:

• column: constantToFull(c: Column): Column

contains:

• column: contains[T: float | string | int | bool | Value](c: Column; val: T): bool
• dataframe: contains(df: DataFrame; key: string): bool
• value: contains(v: Value; key: string): bool
• value: contains(v: Value; has: Value): bool

convenienceValueComparisons:

• value: convenienceValueComparisons(): untyped

count:

• dataframe: count(df: DataFrame; col: string; name = "n"): DataFrame

dataFrame:

• dataframe: dataFrame(s: varargs[untyped]): untyped

DataFrame:

• df_types: DataFrame

DataFrameKind:

• df_types: DataFrameKind

dfGrouped:

• DataFrameKind.dfGrouped

dfNormal:

• DataFrameKind.dfNormal

drop:

• dataframe: drop(df: var DataFrame; key: string)
• dataframe: drop(df: DataFrame; keys: varargs[string]): DataFrame

drop_null:

• dataframe: drop_null(df: DataFrame; cols: varargs[string]; convertColumnKind = false; failIfConversionFails: bool = false): DataFrame

DtypeOrderMap:

• formulaExp: DtypeOrderMap

Dtypes:

• formulaExp: Dtypes

DtypesAll:

• formulaExp: DtypesAll

equal:

• column: equal(c1: Column; idx1: int; c2: Column; idx2: int): bool

evaluate:

• dataframe: evaluate(node: FormulaNode): Value
• dataframe: evaluate(node: FormulaNode; df: DataFrame): Column

extendShortColumns:

• dataframe: extendShortColumns(df: var DataFrame)

extractCall:

• formulaExp: extractCall(stmts: NimNode; id: string): NimNode

filter:

• dataframe: filter(df: DataFrame; conds: varargs[FormulaNode]): DataFrame

filterToIdx:

• dataframe: filterToIdx[T: seq[int] | Tensor[int]](df: DataFrame; indices: T; keys: seq[string] = @[]): DataFrame

fkAssign:

• FormulaKind.fkAssign

fkNone:

• FormulaKind.fkNone

fkScalar:

• FormulaKind.fkScalar

fkVariable:

• FormulaKind.fkVariable

fkVector:

• FormulaKind.fkVector

fn:

• formula: fn(x: untyped): untyped

formula:

• formula: formula(n: untyped): untyped

FormulaCT:

• formulaExp: FormulaCT

FormulaKind:

• formulaExp: FormulaKind

FormulaMismatchError:

• formula: FormulaMismatchError

FormulaNode:

• formula: FormulaNode

FormulaTypes:

• formulaExp: FormulaTypes

gather:

• dataframe: gather(df: DataFrame; cols: varargs[string]; key = "key"; value = "value"; dropNulls = false): DataFrame

generateClosure:

• formulaExp: generateClosure(fct: FormulaCT): NimNode

get:

• dataframe: get(df: DataFrame; key: string): Column

getKeys:

• dataframe: getKeys(df: DataFrame): seq[string]

group_by:

• dataframe: group_by(df: DataFrame; by: varargs[string]; add = false): DataFrame

groups:

• dataframe: groups(df: DataFrame; order = SortOrder.Ascending): (seq[(string, Value)], DataFrame)

hasExplicitTypeHint:

• formulaExp: hasExplicitTypeHint(n: NimNode): bool

hash:

• formula: hash(fn: FormulaNode): Hash
• value: hash(x: Value): Hash

head:

• dataframe: head(df: DataFrame; num: int): DataFrame

HeuristicType:

• formulaExp: HeuristicType

high:

• column: high(c: Column): int
• dataframe: high(df: DataFrame): int

innerJoin:

• dataframe: innerJoin(df1, df2: DataFrame; by: string): DataFrame

isBool:

• value: isBool(s: string): bool

isColumn:

• dataframe: isColumn(fn: FormulaNode; df: DataFrame): bool

isColumnType:

• formulaExp: isColumnType(n: NimNode): bool

isConstant:

• column: isConstant(c: Column): bool
• dataframe: isConstant(fn: FormulaNode; df: DataFrame): bool

isInt:

• value: isInt(s: string): bool
• value: isInt(v: Value): bool

isNull:

• value: isNull(v: Value): Value

isNumber:

• value: isNumber(s: string): bool
• value: isNumber(v: Value): bool

isValidType:

• formulaExp: isValidType(n: NimNode): bool

items:

• dataframe: items(df: DataFrame): Value
• value: items(row: Value): Value

keys:

• dataframe: keys(df: DataFrame): string
• value: keys(row: Value): string

lag:

• column: lag(c: Column; n = 1): Column
• column: lag[T](t: Tensor[T]; n = 1; fill: T = default(T)): Tensor[T]

largerOrFalse:

• value: largerOrFalse(v: Value; f: float): bool

lead:

• column: lead(c: Column; n = 1): Column
• column: lead[T](t: Tensor[T]; n = 1; fill: T = default(T)): Tensor[T]

len:

• dataframe: len[T](t: Tensor[T]): int

Lift:

• formulaExp: Lift

liftScalarToColumn:

• column: liftScalarToColumn(name: untyped): untyped

map:

• column: map[T; U](c: Column; fn: (T -> U)): Column

map_inline:

• column: map_inline(c: Column; body: untyped): Column

max:

• column: max(c`gensym949: Column): Value

mutate:

• dataframe: mutate(df: DataFrame; fns: varargs[FormulaNode]): DataFrame

mutateInplace:

• dataframe: mutateInplace(df: var DataFrame; fns: varargs[FormulaNode])

nativeColKind:

• column: nativeColKind(col: Column): ColKind

ncols:

• dataframe: ncols(df: DataFrame): int

newColumn:

• column: newColumn(kind = colNone; length = 0): Column

newDataFrame:

• dataframe: newDataFrame(size = 8; kind = dfNormal): DataFrame

newVObject:

• value: newVObject(length = 8): Value

nodeIsDf:

• formulaExp: nodeIsDf(n: NimNode): bool

nodeIsDfIdx:

• formulaExp: nodeIsDfIdx(n: NimNode): bool

null:

• value: null(): Value

nullColumn:

• column: nullColumn(num: int): Column

pairs:

• value: pairs(row: Value): tuple[key: string, val: Value]

parseCsvString:

• io: parseCsvString(csvData: string; sep: char = ','; header: string = ""; skipLines = 0; toSkip: set[char] = {}; colNames: seq[string] = @[]; skipInitialSpace = true; quote = '\"'; maxGuesses = 20; lineBreak = ' '; eat = '\r'): DataFrame

parsePreface:

• formulaExp: parsePreface(n: NimNode): Preface

Preface:

• formulaExp: Preface

pretty:

• column: pretty(c: Column): string
• dataframe: pretty(df: DataFrame; numLines = 20; precision = 4; header = true): string
• value: pretty(v: Value; precision = 4; emphStrNumber = true): string

raw:

• formula: raw(node: FormulaNode): string

readCsv:

• io: readCsv(s: Stream; sep = ','; header = ""; skipLines = 0; colNames: seq[string] = @[]; fname = "<unknown>"): OrderedTable[string, seq[string]]
• io: readCsv(fname: string; sep: char = ','; header: string = ""; skipLines = 0; toSkip: set[char] = {}; colNames: seq[string] = @[]; skipInitialSpace = true; quote = '\"'; maxGuesses = 20; lineBreak = ' '; eat = '\r'): DataFrame

readCsvAlt:

• io: readCsvAlt(fname: string; sep = ','; header = ""; skipLines = 0; colNames: seq[string] = @[]): OrderedTable[string, seq[string]]

reduce:

• dataframe: reduce(node: FormulaNode; df: DataFrame): Value

relocate:

• dataframe: relocate[T: string | FormulaNode](df: DataFrame; cols: seq[T]): DataFrame
• dataframe: relocate[T: string | FormulaNode](df: DataFrame; cols: varargs[T]; after = ""; before = ""): DataFrame

rename:

• dataframe: rename(df: DataFrame; cols: varargs[FormulaNode]): DataFrame

row:

• dataframe: row(df: DataFrame; idx: int; cols: varargs[string]): Value

select:

• dataframe: select[T: string | FormulaNode](df: DataFrame; cols: varargs[T]): DataFrame

selectInplace:

• dataframe: selectInplace[T: string | FormulaNode](df: var DataFrame; cols: varargs[T])

seqsToDf:

• dataframe: seqsToDf(s: varargs[untyped]): untyped

setDiff:

• dataframe: setDiff(df1, df2: DataFrame; symmetric = false): DataFrame

shallowCopy:

• dataframe: shallowCopy(df: DataFrame): DataFrame

showBrowser:

• io: showBrowser(df: DataFrame; fname = "df.html"; path = getTempDir(); toRemove = false)

smallerOrFalse:

• value: smallerOrFalse(v: Value; f: float): bool

sortTypes:

• formulaExp: sortTypes(s: seq[NimNode]): seq[string]
• formulaExp: sortTypes(s: seq[string]): seq[string]

spread:

• dataframe: spread[T](df: DataFrame; namesFrom, valuesFrom: string; valuesFill: T = 0): DataFrame

strTabToDf:

• dataframe: strTabToDf(t: OrderedTable[string, seq[string]]): DataFrame

summarize:

• dataframe: summarize(df: DataFrame; fns: varargs[FormulaNode]): DataFrame

tail:

• dataframe: tail(df: DataFrame; num: int): DataFrame

to:

• value: to[T: int | float | string | bool](v: Value; dtype: typedesc[T]): T

toBool:

• value: toBool(v: Value): bool

toColKind:

• column: toColKind[T](dtype: typedesc[T]): ColKind
• column: toColKind(vKind: ValueKind): ColKind

toColumn:

• column: toColumn[T: SomeFloat | SomeInteger | string | bool | Value](s: openArray[T]): Column
• column: toColumn[T: SomeFloat | SomeInteger | string | bool | Value](x: T): Column
• column: toColumn[T: SomeFloat | SomeInteger | string | bool | Value](t: Tensor[T]): Column
• column: toColumn(c: Column): Column

toDf:

• dataframe: toDf(s: varargs[untyped]): untyped

toFloat:

• value: toFloat(v: Value; allowNull: static bool = false): float

toHashSet:

• dataframe: toHashSet[T](t: Tensor[T]): HashSet[T]

toInt:

• value: toInt(v: Value): int

toNativeColumn:

• column: toNativeColumn(c: Column; failIfImpossible: static bool = true): Column
• column: toNativeColumn(s: openArray[Value]): Column

toNimType:

• column: toNimType(colKind: ColKind): string

toObject:

• column: toObject(c: Column): Column
• value: toObject(s: (string, Value)): Value
• value: toObject(s: seq[(string, Value)]): Value

toObjectColumn:

• column: toObjectColumn(c: Column): Column

toStr:

• value: toStr(v: Value): string

toStrType:

• formulaExp: toStrType(n: NimNode): NimNode

toTab:

• dataframe: toTab(args: varargs[untyped]): untyped

toTensor:

• column: toTensor[T](c: Column; slice: Slice[int]; dtype: typedesc[T]): Tensor[T]
• column: toTensor[T](c: Column; dtype: typedesc[T]; dropNulls: static bool = false): Tensor[ T]

toUgly:

• formula: toUgly(result: var string; node: FormulaNode)

toValKind:

• value: toValKind[T](dtype: typedesc[T]): ValueKind

toValueKind:

• column: toValueKind(col: ColKind): ValueKind
• column: toValueKind(col: Column): ValueKind

transmute:

• dataframe: transmute(df: DataFrame; fns: varargs[FormulaNode]): DataFrame

transmuteInplace:

• dataframe: transmuteInplace(df: var DataFrame; fns: varargs[FormulaNode])

TypeHint:

• formulaExp: TypeHint

unique:

• dataframe: unique(c: Column): Column
• dataframe: unique(df: DataFrame; cols: varargs[string]; keepAll = true): DataFrame

valTabToDf:

• dataframe: valTabToDf(t: OrderedTable[string, seq[Value]]): DataFrame

Value:

• value: Value

ValueKind:

• value: ValueKind

ValueNull:

• dataframe: ValueNull

values:

• dataframe: values(df: DataFrame; cols: varargs[string]): Tensor[Value]

valueTo:

• column: valueTo[T](t: Tensor[Value]; dtype: typedesc[T]; dropNulls: static bool = false): Tensor[ T]

VBool:

• ValueKind.VBool

VFloat:

• ValueKind.VFloat

VInt:

• ValueKind.VInt

VNull:

• ValueKind.VNull

VObject:

• ValueKind.VObject

VString:

• ValueKind.VString

withCombinedType:

• dataframe: withCombinedType(df: DataFrame; cols: seq[string]; body: untyped): untyped

withDtypeByColKind:

• column: withDtypeByColKind(colKind: ColKind; body: untyped): untyped

withNative:

• column: withNative(c: Column; idx: int; valName: untyped; body: untyped): untyped
• value: withNative(v: Value; valName: untyped; body: untyped): untyped

withNative2:

• column: withNative2(c1, c2: Column; idx1, idx2: int; valName1, valName2: untyped; body: untyped): untyped

withNativeConversion:

• value: withNativeConversion(kind: ValueKind; procName: untyped; body: untyped): untyped

withNativeDtype:

• column: withNativeDtype(c: Column; body: untyped): untyped

withNativeTensor:

• column: withNativeTensor(c: Column; valName: untyped; body: untyped): untyped

writeCsv:

• io: writeCsv(df: DataFrame; filename: string; sep = ','; header = ""; precision = 4)