src/razor

Search:
Group by:

Procs

proc `!=`(s: Series; value: Value): seq[bool] {....raises: [], tags: [],
    forbids: [].}
Element-wise inequality comparison 
proc `!=`[T](s: Series; value: T): seq[bool]
Element-wise inequality comparison with automatic conversion 
proc `$`(df: DataFrame): string {....raises: [KeyError], tags: [], forbids: [].}
proc `$`(s: Series): string {....raises: [], tags: [], forbids: [].}
proc `$`(v: Value): string {....raises: [], tags: [], forbids: [].}
proc `*`(a, b: Series): Series {....raises: [ValueError], tags: [], forbids: [].}
Element-wise multiplication of two Series 
proc `*`(a, b: Value): Value {....raises: [ValueError], tags: [], forbids: [].}
proc `+`(a, b: Series): Series {....raises: [ValueError], tags: [], forbids: [].}
Element-wise addition of two Series 
proc `+`(a, b: Value): Value {....raises: [ValueError], tags: [], forbids: [].}
proc `-`(a, b: Series): Series {....raises: [ValueError], tags: [], forbids: [].}
Element-wise subtraction of two Series 
proc `-`(a, b: Value): Value {....raises: [ValueError], tags: [], forbids: [].}
proc `/`(a, b: Series): Series {....raises: [ValueError], tags: [], forbids: [].}
Element-wise division of two Series (always returns float) 
proc `/`(a, b: Value): Value {....raises: [ValueError], tags: [], forbids: [].}
proc `<`(a, b: Value): bool {....raises: [], tags: [], forbids: [].}
proc `<`(s: Series; value: Value): seq[bool] {....raises: [], tags: [], forbids: [].}
Element-wise less than comparison 
proc `<`[T](s: Series; value: T): seq[bool]
Element-wise less than comparison with automatic conversion 
proc `<=`(a, b: Value): bool {....raises: [], tags: [], forbids: [].}
proc `<=`(s: Series; value: Value): seq[bool] {....raises: [], tags: [],
    forbids: [].}
Element-wise less than or equal comparison 
proc `<=`[T](s: Series; value: T): seq[bool]
Element-wise less than or equal comparison with automatic conversion 
proc `==`(a, b: Value): bool {....raises: [], tags: [], forbids: [].}
proc `==`(s: Series; value: Value): seq[bool] {....raises: [], tags: [],
    forbids: [].}
Element-wise equality comparison 
proc `==`(values: seq[Value]; expected: seq[int64]): bool {....raises: [],
    tags: [], forbids: [].}
proc `==`[T](s: Series; value: T): seq[bool]
Element-wise equality comparison with automatic conversion 
proc `>`(a, b: Value): bool {....raises: [], tags: [], forbids: [].}
proc `>`(s: Series; value: Value): seq[bool] {....raises: [], tags: [], forbids: [].}
Element-wise greater than comparison 
proc `>`[T](s: Series; value: T): seq[bool]
Element-wise greater than comparison with automatic conversion 
proc `>=`(a, b: Value): bool {....raises: [], tags: [], forbids: [].}
proc `>=`(s: Series; value: Value): seq[bool] {....raises: [], tags: [],
    forbids: [].}
Element-wise greater than or equal comparison 
proc `>=`[T](s: Series; value: T): seq[bool]
Element-wise greater than or equal comparison with automatic conversion 
proc `[]`(df: DataFrame; col: string): Series {....raises: [KeyError], tags: [],
    forbids: [].}
proc `[]`(s: Series; idx: int): Value {....raises: [], tags: [], forbids: [].}
proc `[]`(s: Series; idx: string): Value {....raises: [KeyError], tags: [],
    forbids: [].}
proc `[]=`(df: DataFrame; col: string; series: Series) {....raises: [], tags: [],
    forbids: [].}
proc `[]=`(s: Series; idx: int; val: Value) {....raises: [], tags: [], forbids: [].}
proc agg(grouped: GroupedDataFrame; column: string; operations: seq[string]): DataFrame {.
    ...raises: [KeyError, ValueError], tags: [], forbids: [].}
Apply multiple aggregation operations to a column 
proc concat(dfl, dfr: DataFrame): DataFrame {....raises: [ValueError, KeyError],
    tags: [], forbids: [].}

Concatenate two dataframes vertically.

Ensure both dataframes have the same columns and dtypes.

proc count(grouped: GroupedDataFrame): OrderedTable[string, int] {....raises: [],
    tags: [], forbids: [].}
Count number of rows in each group 
proc dateRange(start: DateTime; periods: int; freq = "D"): Series {....raises: [],
    tags: [], forbids: [].}
proc describe(df: DataFrame): DataFrame {....raises: [ValueError], tags: [],
    forbids: [].}
proc dropNa(df: DataFrame; how = "any"): DataFrame {....raises: [], tags: [],
    forbids: [].}
Remove rows with missing values from a DataFrame. 
proc dropNa(s: Series): Series {....raises: [], tags: [], forbids: [].}
Remove missing values from a Series. 
proc dropna(df: DataFrame): DataFrame {....raises: [], tags: [], forbids: [].}
proc fillNa(df: DataFrame; fillValue: Value): DataFrame {....raises: [], tags: [],
    forbids: [].}
Fill missing values in all columns of a DataFrame with the specified fill value 
proc fillNa(df: DataFrame; fillValues: OrderedTable[string, Value]): DataFrame {.
    ...raises: [KeyError], tags: [], forbids: [].}
Fill missing values in specific columns with different fill values 
proc fillNa(s: Series; fillValue: Value): Series {....raises: [], tags: [],
    forbids: [].}
Fill missing values in a Series with the specified fill value. 
proc groupBy(df: DataFrame; by: string): GroupedDataFrame {....raises: [KeyError],
    tags: [], forbids: [].}
proc head(df: DataFrame; n = 5): DataFrame {....raises: [], tags: [], forbids: [].}
proc head(s: Series; n = 5): Series {....raises: [], tags: [], forbids: [].}
proc info(df: DataFrame): string {....raises: [], tags: [], forbids: [].}
proc isNa(v: Value): bool {....raises: [], tags: [], forbids: [].}
Check if a value is considered missing/null. 
proc len(df: DataFrame): int {....raises: [], tags: [], forbids: [].}
proc len(s: Series): int {....raises: [], tags: [], forbids: [].}
proc loc(df: DataFrame; mask: seq[bool]): DataFrame {....raises: [ValueError],
    tags: [], forbids: [].}
proc loc(s: Series; mask: seq[bool]): Series {....raises: [ValueError], tags: [],
    forbids: [].}
proc mask(df: DataFrame; mask: seq[bool]): DataFrame {....raises: [ValueError],
    tags: [], forbids: [].}
proc mask(s: Series; mask: seq[bool]): Series {....raises: [ValueError], tags: [],
    forbids: [].}
Filter Series using a boolean mask, keeping only true values 
proc max(grouped: GroupedDataFrame; column: string): OrderedTable[string, Value] {.
    ...raises: [KeyError, ValueError], tags: [], forbids: [].}
Compute maximum of a column for each group 
proc max(s: Series): Value {....raises: [ValueError], tags: [], forbids: [].}
proc mean(grouped: GroupedDataFrame; column: string): OrderedTable[string,
    float64] {....raises: [KeyError, ValueError], tags: [], forbids: [].}
Compute mean of a column for each group 
proc mean(s: Series): float64 {....raises: [ValueError], tags: [], forbids: [].}
proc min(grouped: GroupedDataFrame; column: string): OrderedTable[string, Value] {.
    ...raises: [KeyError, ValueError], tags: [], forbids: [].}
Compute minimum of a column for each group 
proc min(s: Series): Value {....raises: [ValueError], tags: [], forbids: [].}
proc newDataFrame(): DataFrame {....raises: [], tags: [], forbids: [].}
proc newDataFrame(data: OrderedTable[string, Series]): DataFrame {.
    ...raises: [Exception], tags: [RootEffect], forbids: [].}
proc newSeries(data: seq[bool]; name = ""): Series {....raises: [], tags: [],
    forbids: [].}
proc newSeries(data: seq[float64]; name = ""): Series {....raises: [], tags: [],
    forbids: [].}
proc newSeries(data: seq[int64]; name = ""): Series {....raises: [], tags: [],
    forbids: [].}
proc newSeries(data: seq[int]; name = ""): Series {....raises: [], tags: [],
    forbids: [].}
proc newSeries(data: seq[string]; name = ""): Series {....raises: [], tags: [],
    forbids: [].}
proc newSeriesWithDataType(data: seq[Value]; name = "";
                           dtype: DataType = dtString): Series {....raises: [],
    tags: [], forbids: [].}
Create a new series given a sequence of data, the name, and the datatype itself. 
proc readCsv(filename: string; sep = ","): DataFrame {.
    ...raises: [IOError, KeyError], tags: [ReadDirEffect, ReadIOEffect],
    forbids: [].}
proc renameColumn(df: DataFrame; oldName, newName: string) {.
    ...raises: [ValueError, KeyError], tags: [], forbids: [].}
proc resample(df: DataFrame; rule: string; dateCol: string): DataFrame {.
    ...raises: [], tags: [], forbids: [].}
proc slice(df: DataFrame; colNames: seq[string]): DataFrame {.
    ...raises: [KeyError], tags: [], forbids: [].}
Slice the DataFrame by column names. Returns a new DataFrame with only the specified columns. 
proc slice(df: DataFrame; rowSlice: Slice[int]): DataFrame {....raises: [KeyError],
    tags: [], forbids: [].}
Slice the DataFrame by row range using Nim's Slice syntax. 
proc slice(df: DataFrame; startRow: int = 0; endRow: int = -1;
           startCol: int = 0; endCol: int = -1): DataFrame {....raises: [KeyError],
    tags: [], forbids: [].}

Slice the dataframe by rows and columns.

Parameters:

  • startRow: Starting row index (inclusive, default 0)
  • endRow: Ending row index (exclusive, -1 means all rows)
  • startCol: Starting column index (inclusive, default 0)
  • endCol: Ending column index (exclusive, -1 means all columns)
proc sort(df: DataFrame; by: string; ascending = true): DataFrame {.
    ...raises: [KeyError], tags: [], forbids: [].}
proc sort(s: Series; ascending = true): Series {....raises: [], tags: [],
    forbids: [].}
proc sum(grouped: GroupedDataFrame; column: string): OrderedTable[string, Value] {.
    ...raises: [KeyError, ValueError], tags: [], forbids: [].}
Compute sum of a column for each group 
proc sum(s: Series): Value {....raises: [ValueError], tags: [], forbids: [].}
proc tail(df: DataFrame; n = 5): DataFrame {....raises: [], tags: [], forbids: [].}
proc tail(s: Series; n = 5): Series {....raises: [], tags: [], forbids: [].}
proc toCsv(df: DataFrame; filename: string; sep = ","; index = false) {.
    ...raises: [KeyError, IOError], tags: [WriteIOEffect], forbids: [].}

Create a CSV file given the dataframe and filename.

Optionally: The delimiter and whether or not to utilize index.

proc toDateTime(s: string; format = "yyyy-MM-dd"): DateTime {.
    ...raises: [TimeParseError, TimeFormatParseError], tags: [TimeEffect],
    forbids: [].}
proc toJson(df: DataFrame): JsonNode {....raises: [], tags: [], forbids: [].}
proc toParquet(df: DataFrame; filename: string) {....raises: [IOError],
    tags: [WriteIOEffect], forbids: [].}
TODO: Add real parquet output. 
proc toSeq(series: Series): seq[Value] {....raises: [], tags: [], forbids: [].}
proc unique(s: Series): Series {....raises: [], tags: [], forbids: [].}
proc updateShape(df: DataFrame) {....raises: [], tags: [], forbids: [].}
proc valueCounts(s: Series): DataFrame {....raises: [Exception],
    tags: [RootEffect], forbids: [].}

Made with Nim. Generated: 2025-07-22 18:20:01 UTC