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)