Class DataFrame<S>

Type Parameters

S extends Row = Row

Index

Constructors

constructor

new DataFrame<S extends Row = Row>(
table: TableView,
runtime?: Runtime,
): DataFrame<S>
Type Parameters
- S extends Row = Row
Parameters
- table: TableView
- Optionalruntime: Runtime
Returns DataFrame<S>
- Defined in core/dist/index.d.ts:806

Properties

`Readonly`table

table: TableView

Accessors

columns

get columns(): string[]
Returns string[]
- Defined in core/dist/index.d.ts:808

dtypes

get dtypes(): Record<string, DType>
Returns Record<string, DType>
- Defined in core/dist/index.d.ts:809

shape

get shape(): [number, number]
Returns [number, number]
- Defined in core/dist/index.d.ts:807

Methods

acf

acf(
column: string,
options?: { confidence?: number; maxLag?: number },
): AcfResult
Sample ACF.
Parameters
- column: string
- Optionaloptions: { confidence?: number; maxLag?: number }
Returns AcfResult
- Defined in advanced/dist/index.d.ts:4689

adfTest

adfTest(
column: string,
options?: { lags?: number; regression?: "c" | "ct" | "n" },
): UnitRootResult
Augmented Dickey–Fuller unit-root test on a series column.
Parameters
- column: string
- Optionaloptions: { lags?: number; regression?: "c" | "ct" | "n" }
Returns UnitRootResult
- Defined in advanced/dist/index.d.ts:4934

altRegression

altRegression(
    time: string,
    stress: string,
    options?: {
        censor?: string;
        confidence?: number;
        distribution?: LifeDistribution;
        percentiles?: number[];
        relation?: AccelerationRelation;
        useStress?: number;
    },
): AltResult
Accelerated life testing on a stress column.
Parameters
- time: string
- stress: string
- Optionaloptions: {
      censor?: string;
      confidence?: number;
      distribution?: LifeDistribution;
      percentiles?: number[];
      relation?: AccelerationRelation;
      useStress?: number;
  }
Returns AltResult
- Defined in advanced/dist/index.d.ts:4873

ancova

ancova(y: string, group: string, covariate: string): AncovaResult
One-way ANCOVA: y by group adjusting for covariate.
Parameters
- y: string
- group: string
- covariate: string
Returns AncovaResult
- Defined in advanced/dist/index.d.ts:4954

anova

anova(column: string, by: string): AnovaResult
One-way ANOVA of column across the levels of by (Minitab One-Way ANOVA).
Parameters
- column: string
- by: string
Returns AnovaResult
- Defined in advanced/dist/index.d.ts:4453

anovaTwoWay

anovaTwoWay(
    y: string,
    row: string,
    col: string,
    options?: { interaction?: boolean },
): AnovaTwoWayResult
Two-way ANOVA Type III via anovaTwoWay.
Parameters
- y: string
- row: string
- col: string
- Optionaloptions: { interaction?: boolean }
Returns AnovaTwoWayResult
- Defined in advanced/dist/index.d.ts:4455

antiJoin

antiJoin<R extends Row>(
other: LazyFrame<R> | DataFrame<R>,
on: string | string[],
): LazyFrame<S>
Type Parameters
- R extends Row
Parameters
- other: LazyFrame<R> | DataFrame<R>
- on: string | string[]
Returns LazyFrame<S>
- Defined in core/dist/index.d.ts:879

arima

arima(
    column: string,
    options?: {
        d?: number;
        horizon?: number;
        includeMean?: boolean;
        method?: "CSS" | "CSS-ML" | "ML";
        p?: number;
        q?: number;
        seasonal?: { D?: number; P?: number; period: number; Q?: number };
        xreg?: string[];
    },
): ArimaResult
ARIMA / SARIMA / ARIMAX via CSS-ML.
Parameters
- column: string
- Optionaloptions: {
      d?: number;
      horizon?: number;
      includeMean?: boolean;
      method?: "CSS" | "CSS-ML" | "ML";
      p?: number;
      q?: number;
      seasonal?: { D?: number; P?: number; period: number; Q?: number };
      xreg?: string[];
  }
Returns ArimaResult
- Defined in advanced/dist/index.d.ts:4694

assign

assign(
    cols:
        | Record<string, AnyExpr>
        | ((c: ColRefs<S>) => Record<string, AnyExpr>),
): LazyFrame<Row>
Parameters
- cols: Record<string, AnyExpr> | ((c: ColRefs<S>) => Record<string, AnyExpr>)
Returns LazyFrame<Row>
- Defined in core/dist/index.d.ts:829

autoArima

autoArima(
    column: string,
    options?: {
        horizon?: number;
        information?: "aic" | "bic";
        maxD?: number;
        maxP?: number;
        maxQ?: number;
        seasonalPeriod?: number;
    },
): ArimaResult
Auto-ARIMA (stepwise AIC/BIC).
Parameters
- column: string
- Optionaloptions: {
      horizon?: number;
      information?: "aic" | "bic";
      maxD?: number;
      maxP?: number;
      maxQ?: number;
      seasonalPeriod?: number;
  }
Returns ArimaResult
- Defined in advanced/dist/index.d.ts:4740

autoModel

autoModel(
    y: string,
    predictors: string[],
    options?: {
        folds?: number;
        models?: ModelKind[];
        nTrees?: number;
        seed?: number;
        task?: "regression" | "classification";
    },
): AutoModelResult
Automated model selection over the tree learners (+ OLS / logistic).
Parameters
- y: string
- predictors: string[]
- Optionaloptions: {
      folds?: number;
      models?: ModelKind[];
      nTrees?: number;
      seed?: number;
      task?: "regression" | "classification";
  }
Returns AutoModelResult
- Defined in advanced/dist/index.d.ts:4921

bestSubsets

bestSubsets(
    y: string,
    predictors: string[],
    options?: { include?: string[]; maxK?: number; nBest?: number },
): BestSubsetsResult
Best Subsets over the predictor columns.
Parameters
- y: string
- predictors: string[]
- Optionaloptions: { include?: string[]; maxK?: number; nBest?: number }
Returns BestSubsetsResult
- Defined in advanced/dist/index.d.ts:4574

between

between(
    column: keyof S & string,
    low: string | number,
    high: string | number,
): LazyFrame<S>
Parameters
- column: keyof S & string
- low: string | number
- high: string | number
Returns LazyFrame<S>
- Defined in core/dist/index.d.ts:834

bfill

bfill(columns?: string[]): LazyFrame<S>
Parameters
- Optionalcolumns: string[]
Returns LazyFrame<S>
- Defined in core/dist/index.d.ts:889

boxplotStats

boxplotStats(column: string, by?: string): BoxplotStats | BoxplotStats[]
Boxplot statistics, optionally per level of by.
Parameters
- column: string
- Optionalby: string
Returns BoxplotStats | BoxplotStats[]
- Defined in advanced/dist/index.d.ts:4824

capability

capability(
    column: string,
    options: {
        confidence?: number;
        lsl?: number;
        method?: "r" | "s";
        subgroup?: number;
        target?: number;
        usl?: number;
    },
): CapabilityResult
Process capability (normal) of a column.
Parameters
- column: string
- options: {
      confidence?: number;
      lsl?: number;
      method?: "r" | "s";
      subgroup?: number;
      target?: number;
      usl?: number;
  }
Returns CapabilityResult
- Defined in advanced/dist/index.d.ts:4634

capabilitySixpack

capabilitySixpack(
    column: string,
    options: {
        confidence?: number;
        lsl?: number;
        method?: "r" | "s";
        subgroup?: number;
        target?: number;
        usl?: number;
    },
): CapabilitySixpackResult
Capability Sixpack plot-ready panels.
Parameters
- column: string
- options: {
      confidence?: number;
      lsl?: number;
      method?: "r" | "s";
      subgroup?: number;
      target?: number;
      usl?: number;
  }
Returns CapabilitySixpackResult
- Defined in advanced/dist/index.d.ts:4779

cart

cart(y: string, predictors: string[], options?: CartOptions): CartResult
CART on predictors → response.
Parameters
- y: string
- predictors: string[]
- Optionaloptions: CartOptions
Returns CartResult
- Defined in advanced/dist/index.d.ts:4805

chi2test

chi2test(a: string, b: string, options?: { correction?: boolean }): Chi2Result
Chi-square test of independence between two categorical columns.
Parameters
- a: string
- b: string
- Optionaloptions: { correction?: boolean }
Returns Chi2Result
- Defined in advanced/dist/index.d.ts:4488

clusterVariables

clusterVariables(
    columns: string[],
    options?: {
        distance?: "correlation" | "absolute correlation";
        method?: "average" | "single" | "complete" | "ward";
        nClusters?: number;
    },
): ClusterVariablesResult
Cluster Variables (correlation-distance hierarchical clustering).
Parameters
- columns: string[]
- Optionaloptions: {
      distance?: "correlation" | "absolute correlation";
      method?: "average" | "single" | "complete" | "ward";
      nClusters?: number;
  }
Returns ClusterVariablesResult
- Defined in advanced/dist/index.d.ts:4896

col

col<K extends string>(name: K): Series<Cell<S[K]>>
Alias of getColumn.
Type Parameters
- K extends string
Parameters
- name: K
Returns Series<Cell<S[K]>>
- Defined in core/dist/index.d.ts:979

collect

collect(): Promise<DataFrame<S>>
Returns Promise<DataFrame<S>>
- Defined in core/dist/index.d.ts:959

collectWithReport

collectWithReport(
opts?: ExecuteOptions,
): Promise<{ frame: DataFrame<S>; report: ExecutionReport }>
Parameters
- Optionalopts: ExecuteOptions
Returns Promise<{ frame: DataFrame<S>; report: ExecutionReport }>
- Defined in core/dist/index.d.ts:955

controlChart

controlChart(column: string, options?: ControlChartOptions): ControlChartResult
Control chart on a column (I-MR by default; pass subgroup / type for X̄-R / X̄-S / attributes).
Parameters
- column: string
- Optionaloptions: ControlChartOptions
Returns ControlChartResult
- Defined in advanced/dist/index.d.ts:4617

corr

corr(options?: { columns?: string[]; method?: CorrMethod }): LazyFrame<Row>
Parameters
- Optionaloptions: { columns?: string[]; method?: CorrMethod }
Returns LazyFrame<Row>
- Defined in core/dist/index.d.ts:909

corrTest

corrTest(
    a: string,
    b: string,
    options?: {
        alternative?: Alternative;
        confidence?: number;
        method?: "pearson" | "spearman" | "kendall";
    },
): CorrTestResult
Correlation between two columns with p-value and CI.
Parameters
- a: string
- b: string
- Optionaloptions: {
      alternative?: Alternative;
      confidence?: number;
      method?: "pearson" | "spearman" | "kendall";
  }
Returns CorrTestResult
- Defined in advanced/dist/index.d.ts:4506

cov

cov(options?: { columns?: string[] }): LazyFrame<Row>
Parameters
- Optionaloptions: { columns?: string[] }
Returns LazyFrame<Row>
- Defined in core/dist/index.d.ts:913

coxPH

coxPH(
    time: string,
    predictors: string[],
    options?: {
        cause?: string | number;
        censor?: string;
        cluster?: string;
        confidence?: number;
        eventType?: string;
        frailtyBands?: string;
        frailtyGroup?: string;
        frailtyProcess?: "piecewise" | "ar1";
        start?: string;
        strata?: string;
    },
): CoxPHResult
Cox PH regression; predictors are numeric columns.
Parameters
- time: string
- predictors: string[]
- Optionaloptions: {
      cause?: string | number;
      censor?: string;
      cluster?: string;
      confidence?: number;
      eventType?: string;
      frailtyBands?: string;
      frailtyGroup?: string;
      frailtyProcess?: "piecewise" | "ar1";
      start?: string;
      strata?: string;
  }
Returns CoxPHResult
- Defined in advanced/dist/index.d.ts:4727

crossJoin

crossJoin<R extends Row>(
other: LazyFrame<R> | DataFrame<R>,
): LazyFrame<{ [K in string | number | symbol]: (S & R)[K] }>
Type Parameters
- R extends Row
Parameters
- other: LazyFrame<R> | DataFrame<R>
Returns LazyFrame<{ [K in string | number | symbol]: (S & R)[K] }>
- Defined in core/dist/index.d.ts:880

crossValidate

crossValidate(
    y: string,
    predictors: string[],
    options: {
        folds?: number;
        model: ModelKind;
        nTrees?: number;
        seed?: number;
        task?: "regression" | "classification";
    },
): CvResult
k-fold cross-validation of a learner on predictor columns → response.
Parameters
- y: string
- predictors: string[]
- options: {
      folds?: number;
      model: ModelKind;
      nTrees?: number;
      seed?: number;
      task?: "regression" | "classification";
  }
Returns CvResult
- Defined in advanced/dist/index.d.ts:4913

cusum

cusum(
    column: string,
    options?: {
        h?: number;
        k?: number;
        mu?: number;
        sigma?: number;
        vMask?: boolean;
    },
): CusumResult
Tabular CUSUM chart.
Parameters
- column: string
- Optionaloptions: { h?: number; k?: number; mu?: number; sigma?: number; vMask?: boolean }
Returns CusumResult
- Defined in advanced/dist/index.d.ts:4626

decompose

decompose(
column: string,
options: { method?: "additive" | "multiplicative"; seasonLength: number },
): DecompositionResult
Classical seasonal decomposition.
Parameters
- column: string
- options: { method?: "additive" | "multiplicative"; seasonLength: number }
Returns DecompositionResult
- Defined in advanced/dist/index.d.ts:4671

describe

describe(options?: { quantileMethod?: QuantileMethod }): DataFrame<Row>
Sync describe on a materialized frame (LazyFrame.describe stays lazy).
Parameters
- Optionaloptions: { quantileMethod?: QuantileMethod }
Returns DataFrame<Row>
- Defined in core/dist/index.d.ts:906

descriptiveStats

descriptiveStats(
columns: string | string[],
options?: { by?: string },
): DescriptiveStats[]
Display Descriptive Statistics for one or more columns, optionally by a grouping column.
Parameters
- columns: string | string[]
- Optionaloptions: { by?: string }
Returns DescriptiveStats[]
- Defined in advanced/dist/index.d.ts:4811

drop

drop<K extends string>(
...columns: K[],
): LazyFrame<{ [K in string | number | symbol]: Omit<S, K>[K] }>
Type Parameters
- K extends string
Parameters
- ...columns: K[]
Returns LazyFrame<{ [K in string | number | symbol]: Omit<S, K>[K] }>
- Defined in core/dist/index.d.ts:819

dropNull

dropNull(columns?: string[]): LazyFrame<S>
Parameters
- Optionalcolumns: string[]
Returns LazyFrame<S>
- Defined in core/dist/index.d.ts:890

dunnett

dunnett(
    column: string,
    by: string,
    options: { alpha?: number; alternative?: Alternative; control: string },
): DunnettResult
Dunnett comparisons of every level of by against control.
Parameters
- column: string
- by: string
- options: { alpha?: number; alternative?: Alternative; control: string }
Returns DunnettResult
- Defined in advanced/dist/index.d.ts:4469

engine

engine(kind: EngineKind, options?: { strict?: boolean }): LazyFrame<S>
Parameters
- kind: EngineKind
- Optionaloptions: { strict?: boolean }
Returns LazyFrame<S>
- Defined in core/dist/index.d.ts:951

equalVariances

equalVariances(
    column: string,
    by: string,
    method?: "levene" | "bartlett" | "bonett",
): VarianceTestResult
Test for equal variances: Levene / Brown–Forsythe (default, as Minitab), Bartlett, or Bonett.
Parameters
- column: string
- by: string
- Optionalmethod: "levene" | "bartlett" | "bonett"
Returns VarianceTestResult
- Defined in advanced/dist/index.d.ts:4484

equivalence

equivalence(
    column: string,
    options: {
        alpha?: number;
        by?: string;
        equalVar?: boolean;
        limits: [number, number];
        paired?: string;
        reference?: string;
    },
): TostResult
Equivalence test (TOST): one-sample by default, two-sample with by (test level − reference level, pass reference to name it), paired with paired.
Parameters
- column: string
- options: {
      alpha?: number;
      by?: string;
      equalVar?: boolean;
      limits: [number, number];
      paired?: string;
      reference?: string;
  }
Returns TostResult
- Defined in advanced/dist/index.d.ts:4548

ets

ets(
    column: string,
    options?: {
        horizon?: number;
        method?: "ses" | "des" | "winters-add" | "winters-mul";
        seasonLength?: number;
    },
): EtsResult
Exponential smoothing (SES / DES / Winters).
Parameters
- column: string
- Optionaloptions: {
      horizon?: number;
      method?: "ses" | "des" | "winters-add" | "winters-mul";
      seasonLength?: number;
  }
Returns EtsResult
- Defined in advanced/dist/index.d.ts:4683

ewma

ewma(
column: string,
options?: { L?: number; lambda?: number; mu?: number; sigma?: number },
): EwmaResult
EWMA chart.
Parameters
- column: string
- Optionaloptions: { L?: number; lambda?: number; mu?: number; sigma?: number }
Returns EwmaResult
- Defined in advanced/dist/index.d.ts:4619

exclude

exclude<K extends string>(
...columns: K[],
): LazyFrame<{ [K in string | number | symbol]: Omit<S, K>[K] }>
Type Parameters
- K extends string
Parameters
- ...columns: K[]
Returns LazyFrame<{ [K in string | number | symbol]: Omit<S, K>[K] }>
- Defined in core/dist/index.d.ts:820

expanding

expanding<N extends string>(
    name: N,
    column: keyof S & string,
    agg?: AggKind,
): LazyFrame<
    { [K in string
    | number
    | symbol]: (Omit<S, N> & Record<N, number>)[K] },
>
Type Parameters
- N extends string
Parameters
- name: N
- column: keyof S & string
- Optionalagg: AggKind
Returns LazyFrame<
    { [K in string
    | number
    | symbol]: (Omit<S, N> & Record<N, number>)[K] },
>
- Defined in core/dist/index.d.ts:933

explain

explain(): string
Returns string
- Defined in core/dist/index.d.ts:954

explode

explode(column: string): LazyFrame<Row>
Parameters
- column: string
Returns LazyFrame<Row>
- Defined in core/dist/index.d.ts:858

ffill

ffill(columns?: string[]): LazyFrame<S>
Parameters
- Optionalcolumns: string[]
Returns LazyFrame<S>
- Defined in core/dist/index.d.ts:888

fillNull

fillNull(value: string | number | boolean, columns?: string[]): LazyFrame<S>
Parameters
- value: string | number | boolean
- Optionalcolumns: string[]
Returns LazyFrame<S>
- Defined in core/dist/index.d.ts:886
fillNull(map: Record<string, number | string | boolean>): LazyFrame<S>
Parameters
- map: Record<string, number | string | boolean>
Returns LazyFrame<S>
- Defined in core/dist/index.d.ts:887

filter

filter(predicate: ExprOrFn<S, Expr<boolean, any>>): LazyFrame<S>
Parameters
- predicate: ExprOrFn<S, Expr<boolean, any>>
Returns LazyFrame<S>
- Defined in core/dist/index.d.ts:830

fineGray

fineGray(
    time: string,
    predictors: string[],
    options: {
        cause: string | number;
        censor?: string;
        confidence?: number;
        eventType: string;
    },
): FineGrayResult
Fine–Gray competing risks.
Parameters
- time: string
- predictors: string[]
- options: {
      cause: string | number;
      censor?: string;
      confidence?: number;
      eventType: string;
  }
Returns FineGrayResult
- Defined in advanced/dist/index.d.ts:4770

fisher

fisher(
    column: string,
    by: string,
    options?: { alpha?: number },
): FisherResult & { familyAlpha: number }
Fisher LSD pairwise comparisons (individual error rate).
Parameters
- column: string
- by: string
- Optionaloptions: { alpha?: number }
Returns FisherResult & { familyAlpha: number }
- Defined in advanced/dist/index.d.ts:4463

fittedLine

fittedLine(
    x: string,
    y: string,
    options?: {
        confidence?: number;
        degree?: 2 | 1 | 3;
        logX?: boolean;
        logY?: boolean;
    },
): OlsResult & {
    degree: number;
    equation: string;
    curve(x: number): number;
}
Fitted Line Plot: polynomial (degree 1–3) regression of y on x with the fitted curve.
Parameters
- x: string
- y: string
- Optionaloptions: { confidence?: number; degree?: 2 | 1 | 3; logX?: boolean; logY?: boolean }
Returns OlsResult & { degree: number; equation: string; curve(x: number): number }
- Defined in advanced/dist/index.d.ts:4561

friedman

friedman(column: string, treatment: string, block: string): FriedmanResult
Friedman test: column by treatment within block (one observation per cell).
Parameters
- column: string
- treatment: string
- block: string
Returns FriedmanResult
- Defined in advanced/dist/index.d.ts:4538

`Static`fromArrow

fromArrow<S extends Row = Row>(arrow: ArrowLike): DataFrame<S>
Type Parameters
- S extends Row = Row
Parameters
- arrow: ArrowLike
Returns DataFrame<S>

Deprecated
Takes columna's ArrowLike JSON, not Apache Arrow. Use fromArrowIpc() for real Arrow bytes or fromArrowLike().
- Defined in core/dist/index.d.ts:994

`Static`fromArrowIpc

fromArrowIpc<S extends Row = Row>(
bytes: ArrayBuffer | Uint8Array<ArrayBufferLike>,
): DataFrame<S>
Parse Apache Arrow IPC bytes (stream or file format) — e.g. tableToIPC(table) from apache-arrow, a DuckDB arrow() result, pyarrow / Polars output. Int8…Int64, UInt8…UInt64, Float16/32/64, Bool, Utf8, LargeUtf8, Timestamp (any unit), Date32/64, Null and dictionary-encoded strings are accepted; nested, decimal, binary and compressed batches throw with the column name. S is an assertion, not verified.
Type Parameters
- S extends Row = Row
Parameters
- bytes: ArrayBuffer | Uint8Array<ArrayBufferLike>
Returns DataFrame<S>
- Defined in core/dist/index.d.ts:1002

`Static`fromArrowLike

fromArrowLike<S extends Row = Row>(arrow: ArrowLike): DataFrame<S>
Type Parameters
- S extends Row = Row
Parameters
- arrow: ArrowLike
Returns DataFrame<S>
- Defined in core/dist/index.d.ts:995

`Static`fromColumns

fromColumns<
    C extends
        Record<
            string,
            | readonly (string | number | boolean | Date | null)[]
            | Float64Array<ArrayBufferLike>
            | Float32Array<ArrayBufferLike>
            | Int32Array<ArrayBufferLike>
            | Uint32Array<ArrayBufferLike>
            | Uint8Array<ArrayBufferLike>
            | { codes: Uint32Array; dictionary: string[] },
        >,
>(
    cols: C,
    options?: { copy?: boolean },
): DataFrame<
    {
        [K in string
        | number
        | symbol]: { [K in string | number | symbol]: ColumnValue<C[K]> }[K]
    },
>
Type Parameters
- C extends Record<
      string,
      | readonly (string | number | boolean | Date | null)[]
      | Float64Array<ArrayBufferLike>
      | Float32Array<ArrayBufferLike>
      | Int32Array<ArrayBufferLike>
      | Uint32Array<ArrayBufferLike>
      | Uint8Array<ArrayBufferLike>
      | { codes: Uint32Array; dictionary: string[] },
  >
Parameters
- cols: C
- Optionaloptions: { copy?: boolean }
Returns DataFrame<
    {
        [K in string
        | number
        | symbol]: { [K in string | number | symbol]: ColumnValue<C[K]> }[K]
    },
>
- Defined in core/dist/index.d.ts:986

`Static`fromCSV

fromCSV<S extends Row = Row>(
csv: string,
options?: ReadCsvOptions,
): DataFrame<S>
Parse CSV text. S is an assertion about the file, not something the compiler can verify.
Type Parameters
- S extends Row = Row
Parameters
- csv: string
- Optionaloptions: ReadCsvOptions
Returns DataFrame<S>
- Defined in core/dist/index.d.ts:1007

`Static`fromCSVRows

fromCSVRows(csv: string, options?: ReadCsvOptions): DataFrame
Parameters
- csv: string
- Optionaloptions: ReadCsvOptions
Returns DataFrame

Deprecated
internal: previous row-object implementation of fromCSV, kept for parity tests.
- Defined in core/dist/index.d.ts:1009

`Static`fromCSVUrl

fromCSVUrl(url: string, options?: ReadCsvOptions): Promise<DataFrame<Row>>
Parameters
- url: string
- Optionaloptions: ReadCsvOptions
Returns Promise<DataFrame<Row>>

Deprecated
Prefer readCsv(url, options).
- Defined in core/dist/index.d.ts:1011

`Static`fromJSON

fromJSON<S extends Row = Row>(
data: string | Record<string, unknown>[],
options?: ReadJsonOptions,
): DataFrame<S>
Type Parameters
- S extends Row = Row
Parameters
- data: string | Record<string, unknown>[]
- Optionaloptions: ReadJsonOptions
Returns DataFrame<S>
- Defined in core/dist/index.d.ts:992

`Static`fromRows

fromRows<T extends Row>(rows: readonly T[]): DataFrame<T>
Build a frame from row objects. The schema is the union of the keys of every row, in order of first appearance (a key missing from a row reads as null); dtypes are inferred over the whole column, so a late fractional / out-of-Int32 / string value widens the column instead of being coerced.
Type Parameters
- T extends Row
Parameters
- rows: readonly T[]
Returns DataFrame<T>
- Defined in core/dist/index.d.ts:985

fullJoin

fullJoin<R extends Row>(
    other: LazyFrame<R> | DataFrame<R>,
    on: string | string[],
): LazyFrame<
    { [K in string
    | number
    | symbol]: (Nullable<S> & Nullable<R>)[K] },
>
Type Parameters
- R extends Row
Parameters
- other: LazyFrame<R> | DataFrame<R>
- on: string | string[]
Returns LazyFrame<{ [K in string | number | symbol]: (Nullable<S> & Nullable<R>)[K] }>
- Defined in core/dist/index.d.ts:876

gageRR

gageRR(
    options: {
        design?: "crossed" | "nested";
        measurement: string;
        operator?: string;
        part: string;
    },
): GageRRResult
Gage R&R (ANOVA) with part / operator / measurement columns.
Parameters
- options: {
      design?: "crossed" | "nested";
      measurement: string;
      operator?: string;
      part: string;
  }
Returns GageRRResult
- Defined in advanced/dist/index.d.ts:4649

gamesHowell

gamesHowell(
    column: string,
    by: string,
    options?: { alpha?: number },
): GamesHowellResult
Games–Howell pairwise comparisons.
Parameters
- column: string
- by: string
- Optionaloptions: { alpha?: number }
Returns GamesHowellResult
- Defined in advanced/dist/index.d.ts:4788

gChart

gChart(
    column: string,
    options?: {
        alpha?: number;
        estimator?: "mle" | "mvue";
        limits?: "probability" | "sigma";
    },
): RareEventChartResult
G chart (opportunities between events) on a count column.
Parameters
- column: string
- Optionaloptions: { alpha?: number; estimator?: "mle" | "mvue"; limits?: "probability" | "sigma" }
Returns RareEventChartResult
- Defined in advanced/dist/index.d.ts:4837

getColumn

getColumn<K extends string>(name: K): Series<Cell<S[K]>>
Type Parameters
- K extends string
Parameters
- name: K
Returns Series<Cell<S[K]>>
- Defined in core/dist/index.d.ts:977

getRuntime

getRuntime(): Runtime
The runtime plans derived from this frame execute on.

Returns Runtime
- Defined in core/dist/index.d.ts:814

glm

glm(
    y: string,
    predictors: string[],
    options: Omit<GlmOptions, "names" | "weights" | "trials" | "offset"> & {
        offset?: string;
        trials?: string;
        weights?: string;
    },
): GlmResult
Generalized linear model; family: 'binomial' is Binary Logistic, 'poisson' Poisson Regression. trials / offset / weights name columns.
Parameters
- y: string
- predictors: string[]
- options: Omit<GlmOptions, "names" | "weights" | "trials" | "offset"> & {
      offset?: string;
      trials?: string;
      weights?: string;
  }
Returns GlmResult
- Defined in advanced/dist/index.d.ts:4580

glmm

glmm(
    y: string,
    options: {
        confidence?: number;
        family: "binomial" | "poisson" | "negbin";
        fixed: string[];
        group: string;
        method?: "pql" | "laplace" | "agq";
        nAGQ?: number;
        slope?: string;
        trials?: string;
    },
): GlmmResult
GLMM (binomial/Poisson/negbin) with random intercept (+ optional slope).
Parameters
- y: string
- options: {
      confidence?: number;
      family: "binomial" | "poisson" | "negbin";
      fixed: string[];
      group: string;
      method?: "pql" | "laplace" | "agq";
      nAGQ?: number;
      slope?: string;
      trials?: string;
  }
Returns GlmmResult
- Defined in advanced/dist/index.d.ts:4759

graphicalSummary

graphicalSummary(
column: string,
options?: { bins?: number; confidence?: number },
): GraphicalSummary
Graphical Summary: descriptives, Anderson–Darling, CIs, histogram and boxplot data.
Parameters
- column: string
- Optionaloptions: { bins?: number; confidence?: number }
Returns GraphicalSummary
- Defined in advanced/dist/index.d.ts:4815

groupBy

groupBy<K extends string>(...keys: K[]): GroupBy<S, K>
Type Parameters
- K extends string
Parameters
- ...keys: K[]
Returns GroupBy<S, K>
- Defined in core/dist/index.d.ts:862

head

head(n?: number): DataFrame<S>
Sync peek — returns a materialized frame (LazyFrame.head stays lazy).
Parameters
- Optionaln: number
Returns DataFrame<S>
- Defined in core/dist/index.d.ts:843

hsu

hsu(
    column: string,
    by: string,
    options?: { alpha?: number; best?: "largest" | "smallest" },
): HsuResult
Hsu's multiple comparisons with the best.
Parameters
- column: string
- by: string
- Optionaloptions: { alpha?: number; best?: "largest" | "smallest" }
Returns HsuResult
- Defined in advanced/dist/index.d.ts:4475

individualDistributionID

individualDistributionID(column: string): IdResult
Individual Distribution Identification on a column.
Parameters
- column: string
Returns IdResult
- Defined in advanced/dist/index.d.ts:4664

innerJoin

innerJoin<R extends Row>(
other: LazyFrame<R> | DataFrame<R>,
on: string | string[],
): LazyFrame<{ [K in string | number | symbol]: (S & R)[K] }>
Type Parameters
- R extends Row
Parameters
- other: LazyFrame<R> | DataFrame<R>
- on: string | string[]
Returns LazyFrame<{ [K in string | number | symbol]: (S & R)[K] }>
- Defined in core/dist/index.d.ts:877

interactionPlot

interactionPlot(y: string, a: string, b: string): InteractionPlot
Interaction plot data (cell means) for two factor columns.
Parameters
- y: string
- a: string
- b: string
Returns InteractionPlot
- Defined in advanced/dist/index.d.ts:4833

interpolate

interpolate(columns?: string[]): LazyFrame<S>
Parameters
- Optionalcolumns: string[]
Returns LazyFrame<S>
- Defined in core/dist/index.d.ts:861

intervalPlot

intervalPlot(
    column: string,
    by: string,
    options?: { confidence?: number; pooled?: boolean },
): IntervalPlotRow[]
Interval plot data: group means with confidence intervals.
Parameters
- column: string
- by: string
- Optionaloptions: { confidence?: number; pooled?: boolean }
Returns IntervalPlotRow[]
- Defined in advanced/dist/index.d.ts:4826

isNull

isNull(column: keyof S & string): LazyFrame<S>
Parameters
- column: keyof S & string
Returns LazyFrame<S>
- Defined in core/dist/index.d.ts:832

itemAnalysis

itemAnalysis(columns: string[]): ItemAnalysisResult
Item Analysis (Cronbach's α) over item columns.
Parameters
- columns: string[]
Returns ItemAnalysisResult
- Defined in advanced/dist/index.d.ts:4907

join

join<R extends Row, How extends JoinKind = "inner">(
    other: LazyFrame<R> | DataFrame<R>,
    options?: {
        how?: How;
        leftOn?: string | string[];
        lSuffix?: string;
        on?: string | string[];
        rightOn?: string | string[];
        rSuffix?: string;
        suffix?: string;
        validate?: "1:1" | "1:m" | "m:1";
    },
): LazyFrame<JoinResult<S, R, How>>
Type Parameters
- R extends Row
- How extends JoinKind = "inner"
Parameters
- other: LazyFrame<R> | DataFrame<R>
- Optionaloptions: {
      how?: How;
      leftOn?: string | string[];
      lSuffix?: string;
      on?: string | string[];
      rightOn?: string | string[];
      rSuffix?: string;
      suffix?: string;
      validate?: "1:1" | "1:m" | "m:1";
  }
Returns LazyFrame<JoinResult<S, R, How>>
- Defined in core/dist/index.d.ts:863

joinAsof

joinAsof<R extends Row>(
    other: LazyFrame<R> | DataFrame<R>,
    options: {
        leftOn: string;
        rightOn?: string;
        strategy?: "backward" | "forward" | "nearest";
    },
): LazyFrame<{ [K in string | number | symbol]: (S & Nullable<R>)[K] }>
Type Parameters
- R extends Row
Parameters
- other: LazyFrame<R> | DataFrame<R>
- options: {
      leftOn: string;
      rightOn?: string;
      strategy?: "backward" | "forward" | "nearest";
  }
Returns LazyFrame<{ [K in string | number | symbol]: (S & Nullable<R>)[K] }>
- Defined in core/dist/index.d.ts:881

kaplanMeier

kaplanMeier(
time: string,
options?: { censor?: string; confidence?: number },
): KaplanMeierResult
Kaplan–Meier estimate.
Parameters
- time: string
- Optionaloptions: { censor?: string; confidence?: number }
Returns KaplanMeierResult
- Defined in advanced/dist/index.d.ts:4716

kmeans

kmeans(
columns: string[],
options: { k: number; maxIter?: number; seed?: number },
): KMeansResult
k-means on the named numeric columns.
Parameters
- columns: string[]
- options: { k: number; maxIter?: number; seed?: number }
Returns KMeansResult
- Defined in advanced/dist/index.d.ts:4799

kpssTest

kpssTest(
column: string,
options?: { lags?: number; regression?: "c" | "ct" },
): UnitRootResult
KPSS stationarity test on a series column.
Parameters
- column: string
- Optionaloptions: { lags?: number; regression?: "c" | "ct" }
Returns UnitRootResult
- Defined in advanced/dist/index.d.ts:4939

kruskal

kruskal(column: string, by: string): KruskalResult
Kruskal–Wallis test across the levels of by.
Parameters
- column: string
- by: string
Returns KruskalResult
- Defined in advanced/dist/index.d.ts:4482

ksTwoSample

ksTwoSample(column: string, by: string): KsTwoSampleResult
Two-sample Kolmogorov–Smirnov between the two levels of by.
Parameters
- column: string
- by: string
Returns KsTwoSampleResult
- Defined in advanced/dist/index.d.ts:4956

lasso

lasso(
    y: string,
    predictors: string[],
    options?: { alpha?: number; maxIter?: number; tol?: number },
): PenalizedResult
Lasso regression of y on predictor columns.
Parameters
- y: string
- predictors: string[]
- Optionaloptions: { alpha?: number; maxIter?: number; tol?: number }
Returns PenalizedResult
- Defined in advanced/dist/index.d.ts:4948

lazy

lazy(): LazyFrame<S>
Returns LazyFrame<S>
- Defined in core/dist/index.d.ts:810

leftJoin

leftJoin<R extends Row>(
other: LazyFrame<R> | DataFrame<R>,
on: string | string[],
): LazyFrame<{ [K in string | number | symbol]: (S & Nullable<R>)[K] }>
Type Parameters
- R extends Row
Parameters
- other: LazyFrame<R> | DataFrame<R>
- on: string | string[]
Returns LazyFrame<{ [K in string | number | symbol]: (S & Nullable<R>)[K] }>
- Defined in core/dist/index.d.ts:873

lifeRegression

lifeRegression(
    time: string,
    predictors: string[],
    options?: {
        censor?: string;
        confidence?: number;
        distribution?: LifeDistribution;
        time2?: string;
    },
): LifeRegressionResult
Regression with life data (AFT) with optional censor column (0 exact, 1 right, 2 left, 3 interval + time2).
Parameters
- time: string
- predictors: string[]
- Optionaloptions: {
      censor?: string;
      confidence?: number;
      distribution?: LifeDistribution;
      time2?: string;
  }
Returns LifeRegressionResult
- Defined in advanced/dist/index.d.ts:4866

limit

limit(n: number, offset?: number): LazyFrame<S>
Parameters
- n: number
- Optionaloffset: number
Returns LazyFrame<S>
- Defined in core/dist/index.d.ts:850

linearModel

linearModel(
formula: string,
options?: { confidence?: number; factors?: string[] },
): LinearModelResult
General Linear Model from a formula over the columns: df.linearModel('y ~ a*b + x').
Parameters
- formula: string
- Optionaloptions: { confidence?: number; factors?: string[] }
Returns LinearModelResult
- Defined in advanced/dist/index.d.ts:4603

logistic

logistic(
    y: string,
    predictors: string[],
    options?: Omit<
        GlmOptions,
        "names"
        | "weights"
        | "trials"
        | "offset"
        | "family",
    > & { offset?: string; trials?: string; weights?: string },
): GlmResult
Binary Logistic Regression (glm with the binomial family).
Parameters
- y: string
- predictors: string[]
- Optionaloptions: Omit<GlmOptions, "names" | "weights" | "trials" | "offset" | "family"> & {
      offset?: string;
      trials?: string;
      weights?: string;
  }
Returns GlmResult
- Defined in advanced/dist/index.d.ts:4586

logRank

logRank(
    time: string,
    group: string,
    options?: {
        censor?: string;
        strata?: string;
        weight?: "logrank" | "wilcoxon" | "tarone-ware";
    },
): LogRankResult
Mantel–Haenszel / Wilcoxon / Tarone–Ware log-rank across levels of group.
Parameters
- time: string
- group: string
- Optionaloptions: {
      censor?: string;
      strata?: string;
      weight?: "logrank" | "wilcoxon" | "tarone-ware";
  }
Returns LogRankResult
- Defined in advanced/dist/index.d.ts:4721

mainEffectsPlot

mainEffectsPlot(y: string, factors: string[]): MainEffectsPlot
Main effects plot data for several factor columns.
Parameters
- y: string
- factors: string[]
Returns MainEffectsPlot
- Defined in advanced/dist/index.d.ts:4831

mannWhitney

mannWhitney(
    column: string,
    by: string,
    options?: MannWhitneyOptions,
): MannWhitneyResult
Mann–Whitney test between the two levels of by (first level − second, sorted).
Parameters
- column: string
- by: string
- Optionaloptions: MannWhitneyOptions
Returns MannWhitneyResult
- Defined in advanced/dist/index.d.ts:4480

manova

manova(responses: string[], by: string): ManovaResult
One-way MANOVA on response columns by group.
Parameters
- responses: string[]
- by: string
Returns ManovaResult
- Defined in advanced/dist/index.d.ts:4792

manovaModel

manovaModel(
    responses: string[],
    rhs: string,
    options?: { factors?: string[] },
): ManovaModelResult
General MANOVA: responses on a model formula right-hand side, e.g. 'a*b + x'.
Parameters
- responses: string[]
- rhs: string
- Optionaloptions: { factors?: string[] }
Returns ManovaModelResult
- Defined in advanced/dist/index.d.ts:4909

melt

melt(
    options: {
        idVars: string[];
        valueName?: string;
        valueVars: string[];
        varName?: string;
    },
): LazyFrame<Row>
Parameters
- options: { idVars: string[]; valueName?: string; valueVars: string[]; varName?: string }
Returns LazyFrame<Row>
- Defined in core/dist/index.d.ts:891

mewma

mewma(
columns: string[],
options?: { arl0?: number; h?: number; lambda?: number },
): MewmaResult
MEWMA chart on several columns.
Parameters
- columns: string[]
- Optionaloptions: { arl0?: number; h?: number; lambda?: number }
Returns MewmaResult
- Defined in advanced/dist/index.d.ts:4854

mixedModel

mixedModel(
    y: string,
    options: {
        confidence?: number;
        fixed: string[];
        group: string;
        group2?: string;
        groupNested?: string;
        reml?: boolean;
        slope?: string;
    },
): MixedModelResult
Random-intercept (+ optional slope / nested) linear mixed model.
Parameters
- y: string
- options: {
      confidence?: number;
      fixed: string[];
      group: string;
      group2?: string;
      groupNested?: string;
      reml?: boolean;
      slope?: string;
  }
Returns MixedModelResult
- Defined in advanced/dist/index.d.ts:4749

mlogit

mlogit(
    y: string,
    predictors: string[],
    options?: {
        confidence?: number;
        maxIter?: number;
        reference?: string | number;
    },
): NominalResult
Nominal Logistic Regression (multinomial).
Parameters
- y: string
- predictors: string[]
- Optionaloptions: { confidence?: number; maxIter?: number; reference?: string | number }
Returns NominalResult
- Defined in advanced/dist/index.d.ts:4597

mood

mood(column: string, by: string): MoodResult
Mood's median test across the levels of by.
Parameters
- column: string
- by: string
Returns MoodResult
- Defined in advanced/dist/index.d.ts:4536

multipleCorrespondence

multipleCorrespondence(
columns: string[],
options?: { method?: "indicator" | "burt"; nComponents?: number },
): McaResult
Multiple Correspondence Analysis of categorical columns.
Parameters
- columns: string[]
- Optionaloptions: { method?: "indicator" | "burt"; nComponents?: number }
Returns McaResult
- Defined in advanced/dist/index.d.ts:4902

nestedAnova

nestedAnova(y: string, factors: string[]): NestedAnovaResult
Fully nested ANOVA.
Parameters
- y: string
- factors: string[]
Returns NestedAnovaResult
- Defined in advanced/dist/index.d.ts:4777

nls

nls(
    model: NlsModel,
    x: string | string[],
    y: string,
    options: NlsOptions,
): NlsResult
Nonlinear regression of column y on column(s) x with a model function and start values.
Parameters
- model: NlsModel
- x: string | string[]
- y: string
- options: NlsOptions
Returns NlsResult
- Defined in advanced/dist/index.d.ts:4608

normalityTest

normalityTest(column: string, method?: NormalityMethod): NormalityResult
Normality test: Anderson–Darling (default, as Minitab), Ryan–Joiner, Kolmogorov–Smirnov or Shapiro–Wilk.
Parameters
- column: string
- Optionalmethod: NormalityMethod
Returns NormalityResult
- Defined in advanced/dist/index.d.ts:4486

notNull

notNull(column: keyof S & string): LazyFrame<S>
Parameters
- column: keyof S & string
Returns LazyFrame<S>
- Defined in core/dist/index.d.ts:833

nunique

nunique(): DataFrame<{ column: string; nunique: number }>
Per-column unique counts (sync peek).

Returns DataFrame<{ column: string; nunique: number }>
- Defined in core/dist/index.d.ts:917

ologit

ologit(
    y: string,
    predictors: string[],
    options?: { confidence?: number; maxIter?: number },
): OrdinalResult
Ordinal Logistic Regression (proportional odds) of a categorical / integer response.
Parameters
- y: string
- predictors: string[]
- Optionaloptions: { confidence?: number; maxIter?: number }
Returns OrdinalResult
- Defined in advanced/dist/index.d.ts:4592

orthogonalRegression

orthogonalRegression(
    x: string,
    y: string,
    options?: { confidence?: number; errorVarianceRatio?: number },
): OrthogonalResult
Orthogonal (Deming) regression of y on x.
Parameters
- x: string
- y: string
- Optionaloptions: { confidence?: number; errorVarianceRatio?: number }
Returns OrthogonalResult
- Defined in advanced/dist/index.d.ts:4610

outerJoin

outerJoin<R extends Row>(
    other: LazyFrame<R> | DataFrame<R>,
    on: string | string[],
): LazyFrame<
    { [K in string
    | number
    | symbol]: (Nullable<S> & Nullable<R>)[K] },
>
Type Parameters
- R extends Row
Parameters
- other: LazyFrame<R> | DataFrame<R>
- on: string | string[]
Returns LazyFrame<{ [K in string | number | symbol]: (Nullable<S> & Nullable<R>)[K] }>
- Defined in core/dist/index.d.ts:875

outlierTest

outlierTest(
    column: string,
    options?: {
        alpha?: number;
        alternative?: "min" | "max" | "two-sided";
        method?: "grubbs" | "dixon";
    },
): OutlierResult
Outlier test: Grubbs (default) or Dixon.
Parameters
- column: string
- Optionaloptions: {
      alpha?: number;
      alternative?: "min" | "max" | "two-sided";
      method?: "grubbs" | "dixon";
  }
Returns OutlierResult
- Defined in advanced/dist/index.d.ts:4517

pareto

pareto(column: string, options?: { weights?: string }): ParetoResult
Pareto of a categorical column.
Parameters
- column: string
- Optionaloptions: { weights?: string }
Returns ParetoResult
- Defined in advanced/dist/index.d.ts:4656

partialCorr

partialCorr(
    a: string,
    b: string,
    controls: string | string[],
    options?: { alternative?: Alternative; method?: "pearson" | "spearman" },
): PartialCorrResult
Partial correlation controlling for one or more columns.
Parameters
- a: string
- b: string
- controls: string | string[]
- Optionaloptions: { alternative?: Alternative; method?: "pearson" | "spearman" }
Returns PartialCorrResult
- Defined in advanced/dist/index.d.ts:4512

pca

pca(
columns: string[],
options?: { nComponents?: number; scale?: boolean },
): PcaResult
PCA on the named numeric columns.
Parameters
- columns: string[]
- Optionaloptions: { nComponents?: number; scale?: boolean }
Returns PcaResult
- Defined in advanced/dist/index.d.ts:4794

periodogram

periodogram(
    column: string,
    options?: {
        detrend?: "mean" | "none" | "linear";
        spans?: number[];
        taper?: number;
    },
): PeriodogramResult
Periodogram / spectral analysis of a series column.
Parameters
- column: string
- Optionaloptions: { detrend?: "mean" | "none" | "linear"; spans?: number[]; taper?: number }
Returns PeriodogramResult
- Defined in advanced/dist/index.d.ts:4860

persist

persist(): LazyFrame<S>
Returns LazyFrame<S>
- Defined in core/dist/index.d.ts:960

pipe

pipe<T>(fn: (df: DataFrame<S>) => T): T
Type Parameters
- T
Parameters
- fn: (df: DataFrame<S>) => T
Returns T
- Defined in core/dist/index.d.ts:934

pivot

pivot(
    options: {
        agg?: AggKind;
        columns: string;
        index: string | string[];
        values: string;
    },
): LazyFrame<Row>
Parameters
- options: { agg?: AggKind; columns: string; index: string | string[]; values: string }
Returns LazyFrame<Row>
- Defined in core/dist/index.d.ts:897

pls

pls(
    y: string | string[],
    predictors: string[],
    options?: Omit<PlsOptions, "names" | "responseNames">,
): PlsResult
Partial least squares of one or more response columns on the predictor columns.
Parameters
- y: string | string[]
- predictors: string[]
- Optionaloptions: Omit<PlsOptions, "names" | "responseNames">
Returns PlsResult
- Defined in advanced/dist/index.d.ts:4615

poissonGof

poissonGof(column: string, options?: { minExpected?: number }): PoissonGofResult
Goodness-of-fit test for Poisson on a column of counts.
Parameters
- column: string
- Optionaloptions: { minExpected?: number }
Returns PoissonGofResult
- Defined in advanced/dist/index.d.ts:4820

powerLawNHPP

powerLawNHPP(
    time: string,
    options: {
        confidence?: number;
        endTime: number | number[];
        system?: string;
    },
): NhppResult
Power-law NHPP (Crow–AMSAA) on a column of failure times, optionally per system.
Parameters
- time: string
- options: { confidence?: number; endTime: number | number[]; system?: string }
Returns NhppResult
- Defined in advanced/dist/index.d.ts:4882

print

print(n?: number): this
Alias for show.
Parameters
- Optionaln: number
Returns this
- Defined in core/dist/index.d.ts:849

probitAnalysis

probitAnalysis(
    events: string,
    trials: string,
    stress: string,
    options?: {
        confidence?: number;
        distribution?: "normal" | "logistic";
        logStress?: boolean;
        naturalResponse?: number;
        percentiles?: number[];
    },
): ProbitResult
Probit analysis from events / trials / stress columns.
Parameters
- events: string
- trials: string
- stress: string
- Optionaloptions: {
      confidence?: number;
      distribution?: "normal" | "logistic";
      logStress?: boolean;
      naturalResponse?: number;
      percentiles?: number[];
  }
Returns ProbitResult
- Defined in advanced/dist/index.d.ts:4888

profile

profile(): ProfileReport
Returns ProfileReport
- Defined in core/dist/index.d.ts:950

propTest

propTest(eventsCol: string, options: DataFramePropTestOptions): PropTestResult
1 or 2 Proportions: without by, sums eventsCol and trials for propTest1; with by (2 levels), aggregates per group (binary column or events + trials columns) for propTest2.
Parameters
- eventsCol: string
- options: DataFramePropTestOptions
Returns PropTestResult
- Defined in advanced/dist/index.d.ts:4932

randomForest

randomForest(
    y: string,
    predictors: string[],
    options?: CartOptions & { nTrees?: number },
): RandomForestResult
Random Forest on predictors → response.
Parameters
- y: string
- predictors: string[]
- Optionaloptions: CartOptions & { nTrees?: number }
Returns RandomForestResult
- Defined in advanced/dist/index.d.ts:4807

`Static`readArrowIpc

readArrowIpc<S extends Row = Row>(
source: IoSource,
options?: IoLoadOptions,
): Promise<DataFrame<S>>
Read Apache Arrow IPC (stream or file / Feather v2) from a path, URL or bytes under the IO policy.
Type Parameters
- S extends Row = Row
Parameters
- source: IoSource
- Optionaloptions: IoLoadOptions
Returns Promise<DataFrame<S>>
- Defined in core/dist/index.d.ts:1004

`Static`readCsv

readCsv<S extends Row = Row>(
source: IoSource,
options?: ReadCsvOptions,
): Promise<DataFrame<S>>
Read CSV from a path / URL / bytes / text. S is an assertion about the file, not something the compiler can verify.
Type Parameters
- S extends Row = Row
Parameters
- source: IoSource
- Optionaloptions: ReadCsvOptions
Returns Promise<DataFrame<S>>
- Defined in core/dist/index.d.ts:1014

`Static`readCsvRows

readCsvRows(source: IoSource, options?: ReadCsvOptions): Promise<DataFrame<Row>>
Parameters
- source: IoSource
- Optionaloptions: ReadCsvOptions
Returns Promise<DataFrame<Row>>

Deprecated
internal: previous row-object implementation of readCsv, kept for parity tests.
- Defined in core/dist/index.d.ts:1016

`Static`readDatabase

readDatabase(
    sql: string,
    connection: SqlConnection,
    options?: ReadSqlOptions,
): Promise<DataFrame<Row>>
Alias of readSql.
Parameters
- sql: string
- connection: SqlConnection
- Optionaloptions: ReadSqlOptions
Returns Promise<DataFrame<Row>>
- Defined in core/dist/index.d.ts:1031

`Static`readExcel

readExcel<S extends Row = Row>(
source: IoSource,
options?: ReadExcelOptions,
): Promise<DataFrame<S>>
Read Excel (.xls / .xlsx) from path, URL, or bytes.
Type Parameters
- S extends Row = Row
Parameters
- source: IoSource
- Optionaloptions: ReadExcelOptions
Returns Promise<DataFrame<S>>
- Defined in core/dist/index.d.ts:1020

`Static`readFile

readFile(
    file: Blob & { name?: string },
    options?: { format?: "csv" | "json" | "parquet" | "excel" } & IoPolicy & {
        content?: boolean;
        encoding?: string;
        floors?: IoPolicy[];
        mode?: IoSourceMode;
    } & {
        comment?: string;
        decimal?: string;
        delimiter?: string;
        dtypes?: Record<string, DType>;
        falseValues?: string | string[];
        hasHeader?: boolean;
        header?: number | boolean;
        names?: string[];
        nRows?: number;
        nullValues?: string | string[];
        quoteChar?: string;
        separator?: string;
        skipBlankLines?: boolean;
        skipInitialSpace?: boolean;
        skipRows?: number;
        thousands?: string;
        trueValues?: string | string[];
        usecols?: (string | number)[];
    } & {
        lines?: boolean;
        nRows?: number;
        orient?: "records"
        | "columns"
        | "values"
        | "lines";
        skipRows?: number;
    },
): Promise<DataFrame<Row>>
Read from a browser File / Blob (CSV/JSON inferred by name or format).
Parameters
- file: Blob & { name?: string }
- Optionaloptions: { format?: "csv" | "json" | "parquet" | "excel" } & IoPolicy & {
      content?: boolean;
      encoding?: string;
      floors?: IoPolicy[];
      mode?: IoSourceMode;
  } & {
      comment?: string;
      decimal?: string;
      delimiter?: string;
      dtypes?: Record<string, DType>;
      falseValues?: string | string[];
      hasHeader?: boolean;
      header?: number | boolean;
      names?: string[];
      nRows?: number;
      nullValues?: string | string[];
      quoteChar?: string;
      separator?: string;
      skipBlankLines?: boolean;
      skipInitialSpace?: boolean;
      skipRows?: number;
      thousands?: string;
      trueValues?: string | string[];
      usecols?: (string | number)[];
  } & {
      lines?: boolean;
      nRows?: number;
      orient?: "records"
      | "columns"
      | "values"
      | "lines";
      skipRows?: number;
  }
  - Optionalformat?: "csv" | "json" | "parquet" | "excel"
  - Optionalcontent?: boolean
    
    Treat a string source as raw content, never as a path (alias of mode: 'text').
  - Optionalencoding?: string
    
    Text encoding when reading bytes/files (default utf-8).
  - Optionalfloors?: IoPolicy[]
    
    Additional policy floors — a Session's policy, for instance. Every floor is enforced like the process-wide one (each must pass; byte caps and timeouts take the minimum), and per-call fields cannot widen any of them.
  - Optionalmode?: IoSourceMode
    
    Interpret a bare string as content / path / URL instead of guessing (default 'auto').
  - Optionalcomment?: string
    
    Lines starting with this prefix are ignored.
  - Optionaldecimal?: string
    
    Decimal mark (default .).
  - Optionaldelimiter?: string
    
    Alias of separator (pandas-style).
  - Optionaldtypes?: Record<string, DType>
    
    Force column dtypes after parse.
  - OptionalfalseValues?: string | string[]
    
    Values treated as boolean false.
  - OptionalhasHeader?: boolean
    
    Polars alias for header !== false.
  - Optionalheader?: number | boolean
    
    First row is header (default true). Number = header row index after skipRows.
  - Optionalnames?: string[]
    
    Explicit column names (used when header is false, or to override).
  - OptionalnRows?: number
    
    Max data rows to read (after header).
  - OptionalnullValues?: string | string[]
    
    Values treated as null.
  - OptionalquoteChar?: string
    
    Quote character (default ").
  - Optionalseparator?: string
    
    Column separator (default ,). Alias of delimiter.
  - OptionalskipBlankLines?: boolean
    
    Skip empty lines (default true).
  - OptionalskipInitialSpace?: boolean
    
    Trim whitespace after delimiter (default false).
  - OptionalskipRows?: number
    
    Rows to skip at the start of the file (before header).
  - Optionalthousands?: string
    
    Thousands separator to strip before parsing numbers.
  - OptionaltrueValues?: string | string[]
    
    Values treated as boolean true.
  - Optionalusecols?: (string | number)[]
    
    Keep only these columns (names or 0-based indices).
  - Optionallines?: boolean
    
    Read newline-delimited JSON (NDJSON). Alias of orient:'lines'.
  - OptionalnRows?: number
    
    Max records to read.
  - Optionalorient?: "records" | "columns" | "values" | "lines"
    
    records = array of objects (default); columns = {col: values[]}; lines = NDJSON.
  - OptionalskipRows?: number
    
    Skip first N lines (NDJSON) or N array elements.
Returns Promise<DataFrame<Row>>
- Defined in core/dist/index.d.ts:1048

`Static`readJson

readJson<S extends Row = Row>(
source: IoSource,
options?: ReadJsonOptions,
): Promise<DataFrame<S>>
Read JSON / NDJSON from path, URL, string content, or bytes.
Type Parameters
- S extends Row = Row
Parameters
- source: IoSource
- Optionaloptions: ReadJsonOptions
Returns Promise<DataFrame<S>>
- Defined in core/dist/index.d.ts:1018

`Static`readKafka

readKafka(
connection: KafkaConnection,
options?: Partial<ReadKafkaOptions>,
): Promise<DataFrame<Row>>
Consume a bounded batch from Kafka into a DataFrame.

Nested JSON values are flattened to dotted columns by default (user.address.city). Driver: optional peer kafkajs.
Parameters
- connection: KafkaConnection
- Optionaloptions: Partial<ReadKafkaOptions>
Returns Promise<DataFrame<Row>>
Example
```
await DataFrame.readKafka({
  brokers: ['localhost:9092'],
  topic: 'events',
  fromBeginning: true,
  nMessages: 1000,
})
```
- Defined in core/dist/index.d.ts:1046

`Static`readParquet

readParquet<S extends Row = Row>(
source: IoSource,
options?: ReadParquetOptions,
): Promise<DataFrame<S>>
Read Parquet from path, URL, or bytes.
Type Parameters
- S extends Row = Row
Parameters
- source: IoSource
- Optionaloptions: ReadParquetOptions
Returns Promise<DataFrame<S>>
- Defined in core/dist/index.d.ts:1022

`Static`readSql

readSql(
    sql: string,
    connection: SqlConnection,
    options?: ReadSqlOptions,
): Promise<DataFrame<Row>>
Load a query result from a database (pandas read_sql / polars read_database).

Built-in dialects: postgres, mssql, clickhouse, mysql, sqlite. Drivers are optional peer packages (pg, mssql, @clickhouse/client, mysql2, better-sqlite3).
Parameters
- sql: string
- connection: SqlConnection
- Optionaloptions: ReadSqlOptions
Returns Promise<DataFrame<Row>>
- Defined in core/dist/index.d.ts:1029

regress

regress(
    y: string,
    predictors: string[],
    options?: Omit<OlsOptions, "names" | "weights"> & { weights?: string },
): OlsResult
Regression (OLS) of y on the predictor columns: coefficient table, ANOVA, R², diagnostics, predict().
Parameters
- y: string
- predictors: string[]
- Optionaloptions: Omit<OlsOptions, "names" | "weights"> & { weights?: string }
Returns OlsResult
- Defined in advanced/dist/index.d.ts:4557

reliabilityFit

reliabilityFit(
    time: string,
    options?: {
        censor?: string;
        distribution?: "exponential" | "weibull" | "lognormal";
        method?: "MLE" | "LSXY";
    },
): ParametricSurvival
Parametric reliability fit (Weibull / lognormal / exponential).
Parameters
- time: string
- Optionaloptions: {
      censor?: string;
      distribution?: "exponential" | "weibull" | "lognormal";
      method?: "MLE" | "LSXY";
  }
Returns ParametricSurvival
- Defined in advanced/dist/index.d.ts:4710

rename

rename<const M extends { [K in string]?: string }>(
mapping: M,
): LazyFrame<{ [K in string | number | symbol]: Renamed<S, M>[K] }>
Type Parameters
- const M extends { [K in string]?: string }
Parameters
- mapping: M
Returns LazyFrame<{ [K in string | number | symbol]: Renamed<S, M>[K] }>
- Defined in core/dist/index.d.ts:821
rename(fn: (name: string) => string): LazyFrame<Row>
Parameters
- fn: (name: string) => string
Returns LazyFrame<Row>
- Defined in core/dist/index.d.ts:824

ridge

ridge(
    y: string,
    predictors: string[],
    options?: { alpha?: number },
): PenalizedResult
Ridge regression of y on predictor columns.
Parameters
- y: string
- predictors: string[]
- Optionaloptions: { alpha?: number }
Returns PenalizedResult
- Defined in advanced/dist/index.d.ts:4944

rightJoin

rightJoin<R extends Row>(
other: LazyFrame<R> | DataFrame<R>,
on: string | string[],
): LazyFrame<{ [K in string | number | symbol]: (Nullable<S> & R)[K] }>
Type Parameters
- R extends Row
Parameters
- other: LazyFrame<R> | DataFrame<R>
- on: string | string[]
Returns LazyFrame<{ [K in string | number | symbol]: (Nullable<S> & R)[K] }>
- Defined in core/dist/index.d.ts:874

rolling

rolling<N extends string>(
    name: N,
    column: keyof S & string,
    window: number,
    agg?: AggKind,
): LazyFrame<
    { [K in string
    | number
    | symbol]: (Omit<S, N> & Record<N, number>)[K] },
>
Type Parameters
- N extends string
Parameters
- name: N
- column: keyof S & string
- window: number
- Optionalagg: AggKind
Returns LazyFrame<
    { [K in string
    | number
    | symbol]: (Omit<S, N> & Record<N, number>)[K] },
>
- Defined in core/dist/index.d.ts:932

runChart

runChart(column: string, options?: { alpha?: number }): RunChartResult
Run chart tests on a column.
Parameters
- column: string
- Optionaloptions: { alpha?: number }
Returns RunChartResult
- Defined in advanced/dist/index.d.ts:4660

runsTest

runsTest(
column: string,
options?: { correction?: boolean; k?: number },
): RunsTestResult
Runs test for randomness about the mean (or k).
Parameters
- column: string
- Optionaloptions: { correction?: boolean; k?: number }
Returns RunsTestResult
- Defined in advanced/dist/index.d.ts:4540

sample

sample(options?: { fraction?: number; n?: number; seed?: number }): LazyFrame<S>
Parameters
- Optionaloptions: { fraction?: number; n?: number; seed?: number }
Returns LazyFrame<S>
- Defined in core/dist/index.d.ts:853

select

select<K extends string>(
...columns: K[],
): LazyFrame<{ [K in string]: Pick<S, K>[K] }>
Type Parameters
- K extends string
Parameters
- ...columns: K[]
Returns LazyFrame<{ [K in string]: Pick<S, K>[K] }>
- Defined in core/dist/index.d.ts:815
select<E extends readonly AnyExpr[]>(
    ...exprs: E,
): LazyFrame<
    {
        [K in string
        | number
        | symbol]: UnionToIntersection<
            {
                [I in string
                | number
                | symbol]: string extends NameOf<E[I]>
                    ? Record<never, never>
                    : Record<NameOf<E[I]>, TypeOf<E[I]>>
            }[number],
        >[K]
    },
>
Type Parameters
- E extends readonly AnyExpr[]
Parameters
- ...exprs: E
Returns LazyFrame<
    {
        [K in string
        | number
        | symbol]: UnionToIntersection<
            {
                [I in string
                | number
                | symbol]: string extends NameOf<E[I]>
                    ? Record<never, never>
                    : Record<NameOf<E[I]>, TypeOf<E[I]>>
            }[number],
        >[K]
    },
>
- Defined in core/dist/index.d.ts:816
select<const E extends readonly AnyExpr[]>(
    fn: (c: ColRefs<S>) => E,
): LazyFrame<
    {
        [K in string
        | number
        | symbol]: UnionToIntersection<
            {
                [I in string
                | number
                | symbol]: string extends NameOf<E[I]>
                    ? Record<never, never>
                    : Record<NameOf<E[I]>, TypeOf<E[I]>>
            }[number],
        >[K]
    },
>
Type Parameters
- const E extends readonly AnyExpr[]
Parameters
- fn: (c: ColRefs<S>) => E
Returns LazyFrame<
    {
        [K in string
        | number
        | symbol]: UnionToIntersection<
            {
                [I in string
                | number
                | symbol]: string extends NameOf<E[I]>
                    ? Record<never, never>
                    : Record<NameOf<E[I]>, TypeOf<E[I]>>
            }[number],
        >[K]
    },
>
- Defined in core/dist/index.d.ts:817
select(...columns: (keyof S & string | AnyExpr)[]): LazyFrame<Row>
Parameters
- ...columns: (keyof S & string | AnyExpr)[]
Returns LazyFrame<Row>
- Defined in core/dist/index.d.ts:818

selectDtypes

selectDtypes(...dtypes: DType[]): LazyFrame<Row>
Parameters
- ...dtypes: DType[]
Returns LazyFrame<Row>
- Defined in core/dist/index.d.ts:835

selectNumeric

selectNumeric(): LazyFrame<Row>
Returns LazyFrame<Row>
- Defined in core/dist/index.d.ts:836

semiJoin

semiJoin<R extends Row>(
other: LazyFrame<R> | DataFrame<R>,
on: string | string[],
): LazyFrame<S>
Type Parameters
- R extends Row
Parameters
- other: LazyFrame<R> | DataFrame<R>
- on: string | string[]
Returns LazyFrame<S>
- Defined in core/dist/index.d.ts:878

show

show(n?: number): this
Print head(n) as markdown to the console; returns this for chaining.
Parameters
- Optionaln: number
Returns this
- Defined in core/dist/index.d.ts:847

signTest

signTest(
    column: string,
    options?: {
        alternative?: Alternative;
        confidence?: number;
        median?: number;
    },
): SignTestResult
1-Sample Sign test.
Parameters
- column: string
- Optionaloptions: { alternative?: Alternative; confidence?: number; median?: number }
Returns SignTestResult
- Defined in advanced/dist/index.d.ts:4523

slice

slice(start: number, end?: number): LazyFrame<S>
Parameters
- start: number
- Optionalend: number
Returns LazyFrame<S>
- Defined in core/dist/index.d.ts:851

sort

sort(
    ...by: (
        | keyof S & string
        | AnyExpr
        | { descending: boolean; expr: AnyExpr; nullsLast?: boolean }
        | ((c: ColRefs<S>) => SortKey | SortKey[])
    )[],
): LazyFrame<S>
Parameters
- ...by: (
      | keyof S & string
      | AnyExpr
      | { descending: boolean; expr: AnyExpr; nullsLast?: boolean }
      | ((c: ColRefs<S>) => SortKey | SortKey[])
  )[]
Returns LazyFrame<S>
- Defined in core/dist/index.d.ts:837

stabilityStudy

stabilityStudy(
    response: string,
    time: string,
    batch: string,
    options: StabilityOptions,
): StabilityResult
Stability Study: response vs time with a batch factor; shelf life against spec limits.
Parameters
- response: string
- time: string
- batch: string
- options: StabilityOptions
Returns StabilityResult
- Defined in advanced/dist/index.d.ts:4835

stepwise

stepwise(
    y: string,
    predictors: string[],
    options?: Omit<StepwiseOptions, "names">,
): StepwiseResult
Stepwise / forward / backward selection among the predictor columns.
Parameters
- y: string
- predictors: string[]
- Optionaloptions: Omit<StepwiseOptions, "names">
Returns StepwiseResult
- Defined in advanced/dist/index.d.ts:4572

stl

stl(
    column: string,
    options: {
        robust?: boolean;
        seasonalSpan?: number;
        seasonLength: number;
        trendSpan?: number;
    },
): StlResult
STL (LOESS) seasonal-trend decomposition.
Parameters
- column: string
- options: {
      robust?: boolean;
      seasonalSpan?: number;
      seasonLength: number;
      trendSpan?: number;
  }
Returns StlResult
- Defined in advanced/dist/index.d.ts:4676

t2Chart

t2Chart(
columns: string[],
options?: { alpha?: number; phase?: 2 | 1; subgroup?: string },
): T2ChartResult
Hotelling T² chart on several columns (optionally subgrouped).
Parameters
- columns: string[]
- Optionaloptions: { alpha?: number; phase?: 2 | 1; subgroup?: string }
Returns T2ChartResult
- Defined in advanced/dist/index.d.ts:4848

tail

tail(n?: number): DataFrame<S>
Sync peek from the end — returns a materialized frame.
Parameters
- Optionaln: number
Returns DataFrame<S>
- Defined in core/dist/index.d.ts:845

take

take(indices: number[]): LazyFrame<S>
Parameters
- indices: number[]
Returns LazyFrame<S>
- Defined in core/dist/index.d.ts:852

tChart

tChart(
column: string,
options?: { alpha?: number; distribution?: "exponential" | "weibull" },
): RareEventChartResult
T chart (time between events).
Parameters
- column: string
- Optionaloptions: { alpha?: number; distribution?: "exponential" | "weibull" }
Returns RareEventChartResult
- Defined in advanced/dist/index.d.ts:4843

toArray

toArray(): S[]
Rows as objects, typed by the schema.

Returns S[]
- Defined in core/dist/index.d.ts:963

toArrow

toArrow(): ArrowLike
Returns ArrowLike

Deprecated
Returns columna's ArrowLike JSON, not Apache Arrow. Use toArrowIpc() for real Arrow bytes or toArrowLike().
- Defined in core/dist/index.d.ts:965

toArrowIpc

toArrowIpc(options?: ArrowIpcWriteOptions): Uint8Array
Apache Arrow IPC bytes — the streaming format by default ({ format: 'file' } for Feather v2). Zero-copy consumers: tableFromIPC() of apache-arrow, DuckDB(-Wasm) insertArrowFromIPCStream, pyarrow.ipc, polars.read_ipc_stream, pandas.read_feather (file format). f64/f32/i32/u32/bool/utf8 map 1:1, category → Dictionary<Int32, Utf8>, datetime → Timestamp(ms). Round-trips with DataFrame.fromArrowIpc.
Parameters
- Optionaloptions: ArrowIpcWriteOptions
Returns Uint8Array
- Defined in core/dist/index.d.ts:974

toArrowLike

toArrowLike(): ArrowLike
columna's own JSON columnar form (schema + plain arrays). Not Apache Arrow — see toArrowIpc().

Returns ArrowLike
- Defined in core/dist/index.d.ts:967

toBlob

toBlob(format?: "csv" | "parquet-like", options?: CsvWriteOptions): Blob
Parameters
- Optionalformat: "csv" | "parquet-like"
- Optionaloptions: CsvWriteOptions
Returns Blob
- Defined in core/dist/index.d.ts:949

toCsv

toCsv(options?: CsvWriteOptions): string
CSV text. { escapeFormulas: true } neutralises text cells a spreadsheet would run as formulas (leading = + - @ tab CR → "'"-prefixed, quoted) — use it for exports of untrusted text that will be opened in Excel-like applications; the default writes the data unchanged.
Parameters
- Optionaloptions: CsvWriteOptions
Returns string
- Defined in core/dist/index.d.ts:940

toHTML

toHTML(maxRows?: number): string
Parameters
- OptionalmaxRows: number
Returns string
- Defined in core/dist/index.d.ts:948

toleranceInterval

toleranceInterval(
    column: string,
    options?: {
        confidence?: number;
        coverage?: number;
        method?: "normal" | "nonparametric";
    },
): ToleranceIntervalResult
Tolerance interval for a column.
Parameters
- column: string
- Optionaloptions: { confidence?: number; coverage?: number; method?: "normal" | "nonparametric" }
Returns ToleranceIntervalResult
- Defined in advanced/dist/index.d.ts:4643

toMarkdown

toMarkdown(maxRows?: number): string
Parameters
- OptionalmaxRows: number
Returns string
- Defined in core/dist/index.d.ts:947

transpose

transpose(headerColumn?: string): LazyFrame<Row>
Parameters
- OptionalheaderColumn: string
Returns LazyFrame<Row>
- Defined in core/dist/index.d.ts:860

trendAnalysis

trendAnalysis(
    column: string,
    options?: {
        horizon?: number;
        model?: "linear" | "quadratic" | "exponential" | "s-curve";
    },
): TrendResult
Trend Analysis on a time-series column.
Parameters
- column: string
- Optionaloptions: { horizon?: number; model?: "linear" | "quadratic" | "exponential" | "s-curve" }
Returns TrendResult
- Defined in advanced/dist/index.d.ts:4666

ttest

ttest(column: string, options?: DataFrameTTestOptions): TTestResult
t-test on a column (Minitab 1-Sample t / 2-Sample t / Paired t): df.ttest('x', { mu: 50 }) // one-sample, H0: mean = 50 df.ttest('x', { by: 'group' }) // two-sample (Welch) between the two levels of group df.ttest('after', { paired: 'before' }) // paired, after − before
Parameters
- column: string
- Optionaloptions: DataFrameTTestOptions
Returns TTestResult
- Defined in advanced/dist/index.d.ts:4451

tukey

tukey(column: string, by: string, options?: { alpha?: number }): TukeyResult
Tukey HSD pairwise comparisons across the levels of by.
Parameters
- column: string
- by: string
- Optionaloptions: { alpha?: number }
Returns TukeyResult
- Defined in advanced/dist/index.d.ts:4459

unique

unique(columns?: string[], keep?: "first" | "last" | "none"): LazyFrame<S>
Parameters
- Optionalcolumns: string[]
- Optionalkeep: "first" | "last" | "none"
Returns LazyFrame<S>
- Defined in core/dist/index.d.ts:903

unnest

unnest(column: string, separator?: string): LazyFrame<Row>
Parameters
- column: string
- Optionalseparator: string
Returns LazyFrame<Row>
- Defined in core/dist/index.d.ts:859

unpersist

unpersist(): LazyFrame<S>
Returns LazyFrame<S>
- Defined in core/dist/index.d.ts:961

valueCounts

valueCounts(column: string, normalize?: boolean): LazyFrame<Row>
Parameters
- column: string
- Optionalnormalize: boolean
Returns LazyFrame<Row>
- Defined in core/dist/index.d.ts:904

varTest

varTest(
    column: string,
    options: {
        alternative?: Alternative;
        confidence?: number;
        method?: "bonett" | "chi-square";
        sigma0: number;
    },
): VarTest1Result
1 Variance: χ² (default) or Bonett.
Parameters
- column: string
- options: {
      alternative?: Alternative;
      confidence?: number;
      method?: "bonett" | "chi-square";
      sigma0: number;
  }
Returns VarTest1Result
- Defined in advanced/dist/index.d.ts:4499

where

where(predicate: ExprOrFn<S, Expr<boolean, any>>): LazyFrame<S>
Parameters
- predicate: ExprOrFn<S, Expr<boolean, any>>
Returns LazyFrame<S>
- Defined in core/dist/index.d.ts:831

wilcoxon

wilcoxon(
    column: string,
    options?: {
        alternative?: Alternative;
        confidence?: number;
        median?: number;
        method?: "auto" | "exact" | "asymptotic";
    },
): WilcoxonResult
1-Sample Wilcoxon signed-rank test.
Parameters
- column: string
- Optionaloptions: {
      alternative?: Alternative;
      confidence?: number;
      median?: number;
      method?: "auto" | "exact" | "asymptotic";
  }
Returns WilcoxonResult
- Defined in advanced/dist/index.d.ts:4529

withColumn

withColumn<N extends string, T>(
    name: N,
    expr: ExprOrFn<S, Expr<T, any>>,
): LazyFrame<
    { [K in string
    | number
    | symbol]: (Omit<S, N> & Record<N, T>)[K] },
>
Type Parameters
- N extends string
- T
Parameters
- name: N
- expr: ExprOrFn<S, Expr<T, any>>
Returns LazyFrame<{ [K in string | number | symbol]: (Omit<S, N> & Record<N, T>)[K] }>
- Defined in core/dist/index.d.ts:825

withColumns

withColumns<E extends readonly AnyExpr[]>(
    ...exprs: E,
): LazyFrame<
    {
        [K in string
        | number
        | symbol]: (
            Omit<
                S,
                keyof UnionToIntersection<
                    {
                        [I in string
                        | number
                        | symbol]: string extends NameOf<(...)>
                            ? Record<(...), (...)>
                            : Record<(...), (...)>
                    }[number],
                >,
            > & UnionToIntersection<
                {
                    [I in string
                    | number
                    | symbol]: string extends NameOf<E[I]>
                        ? Record<never, never>
                        : Record<NameOf<(...)[(...)]>, TypeOf<(...)[(...)]>>
                }[number],
            >
        )[K]
    },
>
Type Parameters
- E extends readonly AnyExpr[]
Parameters
- ...exprs: E
Returns LazyFrame<
    {
        [K in string
        | number
        | symbol]: (
            Omit<
                S,
                keyof UnionToIntersection<
                    {
                        [I in string
                        | number
                        | symbol]: string extends NameOf<(...)>
                            ? Record<(...), (...)>
                            : Record<(...), (...)>
                    }[number],
                >,
            > & UnionToIntersection<
                {
                    [I in string
                    | number
                    | symbol]: string extends NameOf<E[I]>
                        ? Record<never, never>
                        : Record<NameOf<(...)[(...)]>, TypeOf<(...)[(...)]>>
                }[number],
            >
        )[K]
    },
>
- Defined in core/dist/index.d.ts:826
withColumns<const E extends readonly AnyExpr[]>(
    fn: (c: ColRefs<S>) => E,
): LazyFrame<
    {
        [K in string
        | number
        | symbol]: (
            Omit<
                S,
                keyof UnionToIntersection<
                    {
                        [I in string
                        | number
                        | symbol]: string extends NameOf<(...)>
                            ? Record<(...), (...)>
                            : Record<(...), (...)>
                    }[number],
                >,
            > & UnionToIntersection<
                {
                    [I in string
                    | number
                    | symbol]: string extends NameOf<E[I]>
                        ? Record<never, never>
                        : Record<NameOf<(...)[(...)]>, TypeOf<(...)[(...)]>>
                }[number],
            >
        )[K]
    },
>
Type Parameters
- const E extends readonly AnyExpr[]
Parameters
- fn: (c: ColRefs<S>) => E
Returns LazyFrame<
    {
        [K in string
        | number
        | symbol]: (
            Omit<
                S,
                keyof UnionToIntersection<
                    {
                        [I in string
                        | number
                        | symbol]: string extends NameOf<(...)>
                            ? Record<(...), (...)>
                            : Record<(...), (...)>
                    }[number],
                >,
            > & UnionToIntersection<
                {
                    [I in string
                    | number
                    | symbol]: string extends NameOf<E[I]>
                        ? Record<never, never>
                        : Record<NameOf<(...)[(...)]>, TypeOf<(...)[(...)]>>
                }[number],
            >
        )[K]
    },
>
- Defined in core/dist/index.d.ts:827
withColumns(
...cols: (AnyExpr | Record<string, AnyExpr> | [string, AnyExpr])[],
): LazyFrame<Row>
Parameters
- ...cols: (AnyExpr | Record<string, AnyExpr> | [string, AnyExpr])[]
Returns LazyFrame<Row>
- Defined in core/dist/index.d.ts:828

withRuntime

withRuntime(runtime: Runtime): DataFrame<S>
The same table bound to another runtime (its engine, memory policy and persist() cache) — see Session.
Parameters
- runtime: Runtime
Returns DataFrame<S>
- Defined in core/dist/index.d.ts:812

withWindow

withWindow<N extends string>(
    name: N,
    fn: "rank" | "lag" | "lead" | "cumsum" | "rowNumber",
    options?: {
        expr?: AnyExpr;
        method?: RankMethod;
        offset?: number;
        orderBy?: (string | AnyExpr | { descending: boolean; expr: AnyExpr })[];
        partitionBy?: string[];
    },
): LazyFrame<
    { [K in string
    | number
    | symbol]: (Omit<S, N> & Record<N, number>)[K] },
>
Type Parameters
- N extends string
Parameters
- name: N
- fn: "rank" | "lag" | "lead" | "cumsum" | "rowNumber"
- Optionaloptions: {
      expr?: AnyExpr;
      method?: RankMethod;
      offset?: number;
      orderBy?: (string | AnyExpr | { descending: boolean; expr: AnyExpr })[];
      partitionBy?: string[];
  }
  - Optionalexpr?: AnyExpr
  - Optionalmethod?: RankMethod
    
    rank only: tie handling, default 'average' (pandas / Minitab)
  - Optionaloffset?: number
  - OptionalorderBy?: (string | AnyExpr | { descending: boolean; expr: AnyExpr })[]
  - OptionalpartitionBy?: string[]
Returns LazyFrame<
    { [K in string
    | number
    | symbol]: (Omit<S, N> & Record<N, number>)[K] },
>
- Defined in core/dist/index.d.ts:921

writeArrowIpc

writeArrowIpc(
path?: string,
options?: ArrowIpcWriteOptions,
): Promise<Uint8Array<ArrayBufferLike>>
Write Apache Arrow IPC to a Node path (.arrow / .feather with { format: 'file' }) or return the bytes.
Parameters
- Optionalpath: string
- Optionaloptions: ArrowIpcWriteOptions
Returns Promise<Uint8Array<ArrayBufferLike>>
- Defined in core/dist/index.d.ts:976

writeCsv

writeCsv(path?: string, options?: CsvWriteOptions): Promise<string>
Write CSV to a path (streamed, memory bounded by one chunk; resolves to '') or return the text when no path is given.
Parameters
- Optionalpath: string
- Optionaloptions: CsvWriteOptions
Returns Promise<string>
- Defined in core/dist/index.d.ts:942

writeParquet

writeParquet(path?: string): Promise<Uint8Array<ArrayBufferLike>>
Write Apache Parquet (hyparquet-writer; round-trips with readParquet).
Parameters
- Optionalpath: string
Returns Promise<Uint8Array<ArrayBufferLike>>
- Defined in core/dist/index.d.ts:944

writeParquetLike

writeParquetLike(path?: string): Promise<Uint8Array<ArrayBufferLike>>
Write columna's JSON "parquet-like" format (round-trips with readParquetLike, not Apache Parquet).
Parameters
- Optionalpath: string
Returns Promise<Uint8Array<ArrayBufferLike>>
- Defined in core/dist/index.d.ts:946

ztest

ztest(
    column: string,
    options: {
        alternative?: Alternative;
        confidence?: number;
        mu?: number;
        sigma: number;
    },
): ZTestResult
1-Sample Z with known sigma.
Parameters
- column: string
- options: { alternative?: Alternative; confidence?: number; mu?: number; sigma: number }
Returns ZTestResult
- Defined in advanced/dist/index.d.ts:4492

Class DataFrame<S>

Type Parameters

Index

Constructors

Properties

Accessors

Methods

Constructors

constructor

Type Parameters

Parameters

Returns DataFrame<S>

Properties

Readonlytable

Accessors

columns

Returns string[]

dtypes

Returns Record<string, DType>

shape

Returns [number, number]

Methods

acf

Parameters

Returns AcfResult

adfTest

Parameters

Returns UnitRootResult

altRegression

Parameters

Returns AltResult

ancova

Parameters

Returns AncovaResult

anova

Parameters

Returns AnovaResult

anovaTwoWay

Parameters

Returns AnovaTwoWayResult

antiJoin

Type Parameters

Parameters

Returns LazyFrame<S>

arima

Parameters

Returns ArimaResult

assign

Parameters

Returns LazyFrame<Row>

autoArima

Parameters

Returns ArimaResult

autoModel

Parameters

Returns AutoModelResult

bestSubsets

Parameters

Returns BestSubsetsResult

between

Parameters

Returns LazyFrame<S>

bfill

Parameters

Returns LazyFrame<S>

boxplotStats

Parameters

Returns BoxplotStats | BoxplotStats[]

capability

Parameters

Returns CapabilityResult

capabilitySixpack

Parameters

Returns CapabilitySixpackResult

cart

Parameters

Returns CartResult

chi2test

Parameters

Returns Chi2Result

`Readonly`table