columna API reference - v0.5.0
    Preparing search index...

    Class LazyFrame<S>

    Type Parameters

    Index
    constructor
    plan
    acf adfTest altRegression ancova anova anovaTwoWay antiJoin arima assign autoArima autoModel bestSubsets between bfill boxplotStats capability cart chi2test clusterVariables collect collectWithReport concat controlChart corr corrTest cov coxPH crossJoin crossValidate cusum decompose describe descriptiveStats drop dropNull dunnett engine equalVariances equivalence ets ewma exclude expanding explain explode ffill fillNull filter fisher fittedLine friedman fullJoin gageRR gamesHowell gChart getRuntime glm glmm graphicalSummary groupBy head hsu individualDistributionID innerJoin interactionPlot interpolate intervalPlot isNull itemAnalysis join joinAsof kaplanMeier kmeans kpssTest kruskal ksTwoSample lasso leftJoin lifeRegression limit linearModel logistic logRank mainEffectsPlot mannWhitney manova manovaModel melt mewma mixedModel mlogit mood multipleCorrespondence nls normalityTest notNull ologit orthogonalRegression outerJoin outlierTest pareto partialCorr pca periodogram persist pipe pivot pls poissonGof powerLawNHPP probitAnalysis propTest randomForest regress reliabilityFit rename ridge rightJoin rolling runChart runsTest sample select selectDtypes selectNumeric semiJoin signTest slice sort stabilityStudy stepwise stl t2Chart tail take tChart toArray toArrow toArrowIpc toArrowLike toleranceInterval transpose trendAnalysis ttest tukey unique unnest unpersist valueCounts varTest where wilcoxon withColumn withColumns withRuntime withWindow ztest
    plan: PlanNode

    • Parameters

      • column: string
      • Optionaloptions: { confidence?: number; maxLag?: number }

      Returns Promise<AcfResult>

    • Parameters

      • column: string
      • Optionaloptions: { lags?: number; regression?: "c" | "ct" | "n" }

      Returns Promise<UnitRootResult>

    • Parameters

      • time: string
      • stress: string
      • Optionaloptions: {
            censor?: string;
            confidence?: number;
            distribution?: LifeDistribution;
            percentiles?: number[];
            relation?: AccelerationRelation;
            useStress?: number;
        }

      Returns Promise<AltResult>

    • Parameters

      • y: string
      • group: string
      • covariate: string

      Returns Promise<AncovaResult>

    • Parameters

      • column: string
      • by: string

      Returns Promise<AnovaResult>

    • Parameters

      • y: string
      • row: string
      • col: string
      • Optionaloptions: { interaction?: boolean }

      Returns Promise<AnovaTwoWayResult>

    • 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 Promise<ArimaResult>

    • Parameters

      • column: string
      • Optionaloptions: {
            horizon?: number;
            information?: "aic" | "bic";
            maxD?: number;
            maxP?: number;
            maxQ?: number;
            seasonalPeriod?: number;
        }

      Returns Promise<ArimaResult>

    • Parameters

      • y: string
      • predictors: string[]
      • Optionaloptions: {
            folds?: number;
            models?: ModelKind[];
            nTrees?: number;
            seed?: number;
            task?: "regression" | "classification";
        }

      Returns Promise<AutoModelResult>

    • Parameters

      • y: string
      • predictors: string[]
      • Optionaloptions: { include?: string[]; maxK?: number; nBest?: number }

      Returns Promise<BestSubsetsResult>

    • Parameters

      • column: keyof S & string
      • low: string | number
      • high: string | number

      Returns LazyFrame<S>

    • Backward-fill nulls within each column (trailing nulls stay null).

      Parameters

      • Optionalcolumns: string[]

      Returns LazyFrame<S>

    • Parameters

      • column: string
      • options: {
            confidence?: number;
            lsl?: number;
            method?: "r" | "s";
            subgroup?: number;
            target?: number;
            usl?: number;
        }

      Returns Promise<CapabilityResult>

    • Parameters

      • y: string
      • predictors: string[]
      • Optionaloptions: CartOptions

      Returns Promise<CartResult>

    • Parameters

      • a: string
      • b: string
      • Optionaloptions: { correction?: boolean }

      Returns Promise<Chi2Result>

    • Parameters

      • columns: string[]
      • Optionaloptions: {
            distance?: "correlation" | "absolute correlation";
            method?: "average" | "single" | "complete" | "ward";
            nClusters?: number;
        }

      Returns Promise<ClusterVariablesResult>

    • Execute the plan. { signal } aborts cooperatively (checked between operators; rejects with ExecutionAbortedError), { timeoutMs } is a deadline checked at the same points, { memory } overrides the memory policy for this run.

      Parameters

      Returns Promise<DataFrame<S>>

    • collect() plus an execution report: which backend ran each node, which kernel (Rust / native / workers / GPU), why a node fell back to the CPU, and timings (for GPU nodes transfer vs. compute, plus the CPU gather). Use it for benchmarks — "engine('wasm')" is a request, the report is the fact.

      Parameters

      Returns Promise<{ frame: DataFrame<S>; report: ExecutionReport }>

    • Stack frames vertically (same columns) or horizontally. The result runs on the inputs' runtime — a session's frames stay on that session — following resolveRuntime: unbound (process-default) inputs adopt it, frames of two different sessions throw RuntimeMismatchError unless { runtime } says which one executes.

      Type Parameters

      Parameters

      • frames: F[]
      • Optionalhow: "vertical" | "horizontal"
      • Optionaloptions: { runtime?: Runtime }

      Returns LazyFrame<F extends LazyFrame<X> ? X : F extends DataFrame<Y> ? Y : Row>

    • Pairwise correlation matrix of numeric columns (pandas df.corr()): a column label column plus one f64 column per variable. Uses pairwise-complete rows; NaN when fewer than two pairs or zero variance.

      Parameters

      • Optionaloptions: { columns?: string[]; method?: CorrMethod }

      Returns LazyFrame<Row>

    • Parameters

      • a: string
      • b: string
      • Optionaloptions: {
            alternative?: Alternative;
            confidence?: number;
            method?: "pearson" | "spearman" | "kendall";
        }

      Returns Promise<CorrTestResult>

    • Sample covariance matrix (n−1) of numeric columns (pandas df.cov()); same layout as corr().

      Parameters

      • Optionaloptions: { columns?: string[] }

      Returns LazyFrame<Row>

    • 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 Promise<CoxPHResult>

    • Parameters

      • y: string
      • predictors: string[]
      • options: {
            folds?: number;
            model: ModelKind;
            nTrees?: number;
            seed?: number;
            task?: "regression" | "classification";
        }

      Returns Promise<CvResult>

    • Parameters

      • column: string
      • Optionaloptions: { h?: number; k?: number; mu?: number; sigma?: number; vMask?: boolean }

      Returns Promise<CusumResult>

    • Parameters

      • column: string
      • options: { method?: "additive" | "multiplicative"; seasonLength: number }

      Returns Promise<DecompositionResult>

    • count / mean / std / min / 25% / 50% / 75% / max per numeric column. quantileMethod: 'minitab' switches the quartiles to Minitab's p(n + 1) definition (type 6).

      Parameters

      • Optionaloptions: { quantileMethod?: QuantileMethod }

      Returns LazyFrame<Row>

    • Parameters

      • columns: string | string[]
      • Optionaloptions: { by?: string }

      Returns Promise<DescriptiveStats[]>

    • Type Parameters

      • K extends string

      Parameters

      • ...columns: K[]

      Returns LazyFrame<{ [K in string | number | symbol]: Omit<S, K>[K] }>

    • Parameters

      • Optionalcolumns: string[]

      Returns LazyFrame<S>

    • Parameters

      • column: string
      • by: string
      • options: { alpha?: number; alternative?: Alternative; control: string }

      Returns Promise<DunnettResult>

    • Force a backend. strict: true makes the choice a contract: if that engine cannot run the plan, throws, or hands every node to another engine, collect() rejects with EngineStrictError listing the reasons instead of silently running elsewhere. Without it, engine() is a preference with CPU fallback.

      Parameters

      • kind: EngineKind
      • Optionaloptions: { strict?: boolean }

      Returns LazyFrame<S>

    • Parameters

      • column: string
      • by: string
      • Optionalmethod: "levene" | "bartlett" | "bonett"

      Returns Promise<VarianceTestResult>

    • Parameters

      • column: string
      • options: {
            alpha?: number;
            by?: string;
            equalVar?: boolean;
            limits: [number, number];
            paired?: string;
            reference?: string;
        }

      Returns Promise<TostResult>

    • Parameters

      • column: string
      • Optionaloptions: {
            horizon?: number;
            method?: "ses" | "des" | "winters-add" | "winters-mul";
            seasonLength?: number;
        }

      Returns Promise<EtsResult>

    • Parameters

      • column: string
      • Optionaloptions: { L?: number; lambda?: number; mu?: number; sigma?: number }

      Returns Promise<EwmaResult>

    • Alias of drop.

      Type Parameters

      • K extends string

      Parameters

      • ...columns: K[]

      Returns LazyFrame<{ [K in string | number | symbol]: Omit<S, K>[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] },
      >

    • The plan and the backend it is dispatched to. What ran is only known after execution: see collectWithReport().

      Returns string

    • Parameters

      • column: string

      Returns LazyFrame<Row>

    • Forward-fill nulls within each column (leading nulls stay null).

      Parameters

      • Optionalcolumns: string[]

      Returns LazyFrame<S>

    • Parameters

      • value: string | number | boolean
      • Optionalcolumns: string[]

      Returns LazyFrame<S>

    • Parameters

      • map: Record<string, number | string | boolean>

      Returns LazyFrame<S>

    • Keep rows where the predicate is true. A typed frame checks the predicate is boolean: df.filter((c) => c.age.gt(18)).

      Parameters

      • predicate: ExprOrFn<S, Expr<boolean, any>>

      Returns LazyFrame<S>

    • Parameters

      • column: string
      • by: string
      • Optionaloptions: { alpha?: number }

      Returns Promise<FisherResult & { familyAlpha: number }>

    • Parameters

      • x: string
      • y: string
      • Optionaloptions: { confidence?: number; degree?: 2 | 1 | 3; logX?: boolean; logY?: boolean }

      Returns Promise<
          OlsResult & {
              degree: number;
              equation: string;
              curve(x: number): number;
          },
      >

    • Parameters

      • column: string
      • treatment: string
      • block: string

      Returns Promise<FriedmanResult>

    • Alias of outerJoin.

      Type Parameters

      Parameters

      Returns LazyFrame<{ [K in string | number | symbol]: (Nullable<S> & Nullable<R>)[K] }>

    • Parameters

      • options: {
            design?: "crossed" | "nested";
            measurement: string;
            operator?: string;
            part: string;
        }

      Returns Promise<GageRRResult>

    • Parameters

      • column: string
      • by: string
      • Optionaloptions: { alpha?: number }

      Returns Promise<GamesHowellResult>

    • Parameters

      • column: string
      • Optionaloptions: { alpha?: number; estimator?: "mle" | "mvue"; limits?: "probability" | "sigma" }

      Returns Promise<RareEventChartResult>

    • The runtime this plan will execute on.

      Returns Runtime

    • Parameters

      • y: string
      • predictors: string[]
      • options: Omit<GlmOptions, "names" | "weights" | "trials" | "offset"> & {
            offset?: string;
            trials?: string;
            weights?: string;
        }

      Returns Promise<GlmResult>

    • 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 Promise<GlmmResult>

    • Parameters

      • column: string
      • Optionaloptions: { bins?: number; confidence?: number }

      Returns Promise<GraphicalSummary>

    • Type Parameters

      • K extends string

      Parameters

      • ...keys: K[]

      Returns GroupBy<S, K>

    • Parameters

      • Optionaln: number

      Returns LazyFrame<S>

    • Parameters

      • column: string
      • by: string
      • Optionaloptions: { alpha?: number; best?: "largest" | "smallest" }

      Returns Promise<HsuResult>

    • Parameters

      • column: string

      Returns Promise<IdResult>

    • Type Parameters

      Parameters

      Returns LazyFrame<{ [K in string | number | symbol]: (S & R)[K] }>

    • Parameters

      • y: string
      • a: string
      • b: string

      Returns Promise<InteractionPlot>

    • Parameters

      • Optionalcolumns: string[]

      Returns LazyFrame<S>

    • Parameters

      • column: string
      • by: string
      • Optionaloptions: { confidence?: number; pooled?: boolean }

      Returns Promise<IntervalPlotRow[]>

    • Parameters

      • column: keyof S & string

      Returns LazyFrame<S>

    • Type Parameters

      Parameters

      • other: LazyFrame<R> | DataFrame<R>
      • Optionaloptions: {
            how?: How;
            leftOn?: string | string[];
            lSuffix?: string;
            on?: string | string[];
            rightOn?: string | string[];
            rSuffix?: string;
            runtime?: Runtime;
            suffix?: string;
            validate?: "1:1" | "1:m" | "m:1";
        }
        • Optionalhow?: How
        • OptionalleftOn?: string | string[]
        • OptionallSuffix?: string

          Suffix for colliding left non-key columns (pandas lsuffix).

        • Optionalon?: string | string[]
        • OptionalrightOn?: string | string[]
        • OptionalrSuffix?: string

          Suffix for colliding right non-key columns (pandas rsuffix; default _right).

        • Optionalruntime?: Runtime

          Runtime that executes the result when the inputs are bound to different sessions (see resolveRuntime).

        • Optionalsuffix?: string

          Shorthand for rSuffix (default _right when omitted).

        • Optionalvalidate?: "1:1" | "1:m" | "m:1"

          Assert join-key uniqueness before joining.

      Returns LazyFrame<JoinResult<S, R, How>>

    • Type Parameters

      Parameters

      • other: LazyFrame<R> | DataFrame<R>
      • options: {
            leftOn: string;
            rightOn?: string;
            runtime?: Runtime;
            strategy?: "backward" | "forward" | "nearest";
        }

      Returns LazyFrame<{ [K in string | number | symbol]: (S & Nullable<R>)[K] }>

    • Parameters

      • time: string
      • Optionaloptions: { censor?: string; confidence?: number }

      Returns Promise<KaplanMeierResult>

    • Parameters

      • columns: string[]
      • options: { k: number; maxIter?: number; seed?: number }

      Returns Promise<KMeansResult>

    • Parameters

      • column: string
      • Optionaloptions: { lags?: number; regression?: "c" | "ct" }

      Returns Promise<UnitRootResult>

    • Parameters

      • column: string
      • by: string

      Returns Promise<KruskalResult>

    • Parameters

      • column: string
      • by: string

      Returns Promise<KsTwoSampleResult>

    • Parameters

      • y: string
      • predictors: string[]
      • Optionaloptions: { alpha?: number; maxIter?: number; tol?: number }

      Returns Promise<PenalizedResult>

    • Type Parameters

      Parameters

      Returns LazyFrame<{ [K in string | number | symbol]: (S & Nullable<R>)[K] }>

    • Parameters

      • time: string
      • predictors: string[]
      • Optionaloptions: {
            censor?: string;
            confidence?: number;
            distribution?: LifeDistribution;
            time2?: string;
        }

      Returns Promise<LifeRegressionResult>

    • Parameters

      • n: number
      • Optionaloffset: number

      Returns LazyFrame<S>

    • Parameters

      • formula: string
      • Optionaloptions: { confidence?: number; factors?: string[] }

      Returns Promise<LinearModelResult>

    • Parameters

      • y: string
      • predictors: string[]
      • Optionaloptions: Omit<GlmOptions, "names" | "weights" | "trials" | "offset" | "family"> & {
            offset?: string;
            trials?: string;
            weights?: string;
        }

      Returns Promise<GlmResult>

    • Parameters

      • time: string
      • group: string
      • Optionaloptions: {
            censor?: string;
            strata?: string;
            weight?: "logrank" | "wilcoxon" | "tarone-ware";
        }

      Returns Promise<LogRankResult>

    • Parameters

      • y: string
      • factors: string[]

      Returns Promise<MainEffectsPlot>

    • Parameters

      • responses: string[]
      • by: string

      Returns Promise<ManovaResult>

    • Parameters

      • responses: string[]
      • rhs: string
      • Optionaloptions: { factors?: string[] }

      Returns Promise<ManovaModelResult>

    • Parameters

      • options: { idVars: string[]; valueName?: string; valueVars: string[]; varName?: string }

      Returns LazyFrame<Row>

    • Parameters

      • columns: string[]
      • Optionaloptions: { arl0?: number; h?: number; lambda?: number }

      Returns Promise<MewmaResult>

    • Parameters

      • y: string
      • options: {
            confidence?: number;
            fixed: string[];
            group: string;
            groupNested?: string;
            reml?: boolean;
            slope?: string;
        }

      Returns Promise<MixedModelResult>

    • Parameters

      • y: string
      • predictors: string[]
      • Optionaloptions: { confidence?: number; maxIter?: number; reference?: string | number }

      Returns Promise<NominalResult>

    • Parameters

      • column: string
      • by: string

      Returns Promise<MoodResult>

    • Parameters

      • columns: string[]
      • Optionaloptions: { method?: "indicator" | "burt"; nComponents?: number }

      Returns Promise<McaResult>

    • Parameters

      Returns Promise<NlsResult>

    • Parameters

      • column: keyof S & string

      Returns LazyFrame<S>

    • Parameters

      • y: string
      • predictors: string[]
      • Optionaloptions: { confidence?: number; maxIter?: number }

      Returns Promise<OrdinalResult>

    • Parameters

      • x: string
      • y: string
      • Optionaloptions: { confidence?: number; errorVarianceRatio?: number }

      Returns Promise<OrthogonalResult>

    • Type Parameters

      Parameters

      Returns LazyFrame<{ [K in string | number | symbol]: (Nullable<S> & Nullable<R>)[K] }>

    • Parameters

      • column: string
      • Optionaloptions: {
            alpha?: number;
            alternative?: "min" | "max" | "two-sided";
            method?: "grubbs" | "dixon";
        }

      Returns Promise<OutlierResult>

    • Parameters

      • column: string
      • Optionaloptions: { weights?: string }

      Returns Promise<ParetoResult>

    • Parameters

      • a: string
      • b: string
      • controls: string | string[]
      • Optionaloptions: { alternative?: Alternative; method?: "pearson" | "spearman" }

      Returns Promise<PartialCorrResult>

    • Parameters

      • columns: string[]
      • Optionaloptions: { nComponents?: number; scale?: boolean }

      Returns Promise<PcaResult>

    • Parameters

      • column: string
      • Optionaloptions: { detrend?: "mean" | "none" | "linear"; spans?: number[]; taper?: number }

      Returns Promise<PeriodogramResult>

    • Mark this plan for LRU caching: the next collect materializes and stores the table; subsequent collects of an identical plan return the cached table (report.cacheHit). Not cached (the report's cacheSkipped says why): plans over frames built with fromColumns(…, { copy: false }), and plans that call mapElements unless { trustUdfs: true } asserts the functions are pure. A strict engine request is served only from an entry that engine produced.

      Parameters

      • Optionaloptions: PersistOptions

      Returns this

    • Type Parameters

      • T

      Parameters

      Returns T

    • Parameters

      • options: { agg?: AggKind; columns: string; index: string | string[]; values: string }

      Returns LazyFrame<Row>

    • Parameters

      • y: string | string[]
      • predictors: string[]
      • Optionaloptions: Omit<PlsOptions, "names" | "responseNames">

      Returns Promise<PlsResult>

    • Parameters

      • column: string
      • Optionaloptions: { minExpected?: number }

      Returns Promise<PoissonGofResult>

    • Parameters

      • time: string
      • options: { confidence?: number; endTime: number | number[]; system?: string }

      Returns Promise<NhppResult>

    • Parameters

      • events: string
      • trials: string
      • stress: string
      • Optionaloptions: {
            confidence?: number;
            distribution?: "normal" | "logistic";
            logStress?: boolean;
            naturalResponse?: number;
            percentiles?: number[];
        }

      Returns Promise<ProbitResult>

    • Parameters

      • y: string
      • predictors: string[]
      • Optionaloptions: CartOptions & { nTrees?: number }

      Returns Promise<RandomForestResult>

    • Parameters

      • y: string
      • predictors: string[]
      • Optionaloptions: Omit<OlsOptions, "names" | "weights"> & { weights?: string }

      Returns Promise<OlsResult>

    • Parameters

      • time: string
      • Optionaloptions: {
            censor?: string;
            distribution?: "exponential" | "weibull" | "lognormal";
            method?: "MLE" | "LSXY";
        }

      Returns Promise<ParametricSurvival>

    • Type Parameters

      • const M extends { [K in string]?: string }

      Parameters

      • mapping: M

      Returns LazyFrame<{ [K in string | number | symbol]: Renamed<S, M>[K] }>

    • Parameters

      • fn: (name: string) => string

      Returns LazyFrame<Row>

    • Parameters

      • y: string
      • predictors: string[]
      • Optionaloptions: { alpha?: number }

      Returns Promise<PenalizedResult>

    • Type Parameters

      Parameters

      Returns LazyFrame<{ [K in string | number | symbol]: (Nullable<S> & R)[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] },
      >

    • Parameters

      • column: string
      • Optionaloptions: { alpha?: number }

      Returns Promise<RunChartResult>

    • Parameters

      • column: string
      • Optionaloptions: { correction?: boolean; k?: number }

      Returns Promise<RunsTestResult>

    • Parameters

      • Optionaloptions: { fraction?: number; n?: number; seed?: number }

      Returns LazyFrame<S>

    • Keep only these columns (names are checked against the schema) …

      Type Parameters

      • K extends string

      Parameters

      • ...columns: K[]

      Returns LazyFrame<{ [K in string]: Pick<S, K>[K] }>

    • … or build new ones from (aliased) expressions, optionally from typed column refs.

      Type Parameters

      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]
          },
      >

    • Keep only these columns (names are checked against the schema) …

      Type Parameters

      • const E extends readonly AnyExpr[]

      Parameters

      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]
          },
      >

    • Keep only these columns (names are checked against the schema) …

      Parameters

      • ...columns: (AnyExpr | keyof S & string)[]

      Returns LazyFrame<Row>

    • Parameters

      • column: string
      • Optionaloptions: { alternative?: Alternative; confidence?: number; median?: number }

      Returns Promise<SignTestResult>

    • Parameters

      • start: number
      • Optionalend: number

      Returns LazyFrame<S>

    • Parameters

      • ...by: (
            | AnyExpr
            | keyof S & string
            | { descending: boolean; expr: AnyExpr; nullsLast?: boolean }
            | ((c: ColRefs<S>) => SortKey | SortKey[])
        )[]

      Returns LazyFrame<S>

    • Parameters

      • y: string
      • predictors: string[]
      • Optionaloptions: Omit<StepwiseOptions, "names">

      Returns Promise<StepwiseResult>

    • Parameters

      • column: string
      • options: {
            robust?: boolean;
            seasonalSpan?: number;
            seasonLength: number;
            trendSpan?: number;
        }

      Returns Promise<StlResult>

    • Parameters

      • columns: string[]
      • Optionaloptions: { alpha?: number; phase?: 2 | 1; subgroup?: string }

      Returns Promise<T2ChartResult>

    • Parameters

      • Optionaln: number

      Returns LazyFrame<S>

    • Parameters

      • indices: number[]

      Returns LazyFrame<S>

    • Parameters

      • column: string
      • Optionaloptions: { alpha?: number; distribution?: "exponential" | "weibull" }

      Returns Promise<RareEventChartResult>

    • Returns Promise<S[]>

    • Returns Promise<ArrowLike>

      Returns columna's ArrowLike JSON, not Apache Arrow. Use toArrowIpc() for real Arrow bytes or toArrowLike().

    • Returns Promise<ArrowLike>

    • Parameters

      • column: string
      • Optionaloptions: { confidence?: number; coverage?: number; method?: "normal" | "nonparametric" }

      Returns Promise<ToleranceIntervalResult>

    • Parameters

      • OptionalheaderColumn: string

      Returns LazyFrame<Row>

    • Parameters

      • column: string
      • Optionaloptions: { horizon?: number; model?: "linear" | "quadratic" | "exponential" | "s-curve" }

      Returns Promise<TrendResult>

    • Parameters

      • column: string
      • by: string
      • Optionaloptions: { alpha?: number }

      Returns Promise<TukeyResult>

    • Parameters

      • Optionalcolumns: string[]
      • Optionalkeep: "first" | "last" | "none"

      Returns LazyFrame<S>

    • Parameters

      • column: string
      • Optionalseparator: string

      Returns LazyFrame<Row>

    • Drop a previously persisted plan from the LRU cache.

      Returns this

    • Parameters

      • column: string
      • Optionalnormalize: boolean

      Returns LazyFrame<Row>

    • Parameters

      • column: string
      • options: {
            alternative?: Alternative;
            confidence?: number;
            method?: "bonett" | "chi-square";
            sigma0: number;
        }

      Returns Promise<VarTest1Result>

    • Alias of filter.

      Parameters

      • predicate: ExprOrFn<S, Expr<boolean, any>>

      Returns LazyFrame<S>

    • Parameters

      • column: string
      • Optionaloptions: {
            alternative?: Alternative;
            confidence?: number;
            median?: number;
            method?: "auto" | "exact" | "asymptotic";
        }

      Returns Promise<WilcoxonResult>

    • Add or replace one column; the result schema knows its name and the expression's value type.

      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] }>

    • Add/replace multiple columns in one plan node. Aliased expressions extend the schema by name.

      Type Parameters

      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]
          },
      >

    • Add/replace multiple columns in one plan node. Aliased expressions extend the schema by name.

      Type Parameters

      • const E extends readonly AnyExpr[]

      Parameters

      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]
          },
      >

    • Add/replace multiple columns in one plan node. Aliased expressions extend the schema by name.

      Parameters

      Returns LazyFrame<Row>

    • The same plan on another runtime (its engine, memory policy and persist() cache) — see Session.

      Parameters

      Returns LazyFrame<S>

    • 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] },
      >

    • Parameters

      • column: string
      • options: { alternative?: Alternative; confidence?: number; mu?: number; sigma: number }

      Returns Promise<ZTestResult>

    Settings
    Member Visibility

    On This Page
    Constructors
    Properties
    Methods
    acfadfTestaltRegressionancovaanovaanovaTwoWayantiJoinarimaassignautoArimaautoModelbestSubsetsbetweenbfillboxplotStatscapabilitycartchi2testclusterVariablescollectcollectWithReportconcatcontrolChartcorrcorrTestcovcoxPHcrossJoincrossValidatecusumdecomposedescribedescriptiveStatsdropdropNulldunnettengineequalVariancesequivalenceetsewmaexcludeexpandingexplainexplodeffillfillNullfilterfisherfittedLinefriedmanfullJoingageRRgamesHowellgChartgetRuntimeglmglmmgraphicalSummarygroupByheadhsuindividualDistributionIDinnerJoininteractionPlotinterpolateintervalPlotisNullitemAnalysisjoinjoinAsofkaplanMeierkmeanskpssTestkruskalksTwoSamplelassoleftJoinlifeRegressionlimitlinearModellogisticlogRankmainEffectsPlotmannWhitneymanovamanovaModelmeltmewmamixedModelmlogitmoodmultipleCorrespondencenlsnormalityTestnotNullologitorthogonalRegressionouterJoinoutlierTestparetopartialCorrpcaperiodogrampersistpipepivotplspoissonGofpowerLawNHPPprobitAnalysispropTestrandomForestregressreliabilityFitrenameridgerightJoinrollingrunChartrunsTestsampleselectselectDtypesselectNumericsemiJoinsignTestslicesortstabilityStudystepwisestlt2CharttailtaketCharttoArraytoArrowtoArrowIpctoArrowLiketoleranceIntervaltransposetrendAnalysisttesttukeyuniqueunnestunpersistvalueCountsvarTestwherewilcoxonwithColumnwithColumnswithRuntimewithWindowztest