ts-arima-forecast/dist/utils/strategies.d.ts

TypeScript library for ARIMA, SARIMA (soon), and SARIMAX (soon) forecasting

import { ARIMA } from "../models/arima";
interface ForecastResult {
    forecasts: number[];
    confidenceIntervals: {
        lower: number[];
        upper: number[];
    };
}
export interface StepwiseForecastResult extends ForecastResult {
    updatedModels: ARIMA[];
    errors: number[];
    actualValues: number[];
}
export interface RealTimeForecastResult extends ForecastResult {
    errors?: number[];
    actualValues?: number[];
}
export declare abstract class ForecastStrategy {
    protected baseModel: ARIMA;
    protected initialData: number[];
    constructor(baseModel: ARIMA, initialData: number[]);
    abstract forecast(steps: number): ForecastResult;
    abstract forecastWithRealTimeData(actualObservations: number[]): RealTimeForecastResult;
    abstract addObservationAndForecast(newObservation: number): {
        forecast: number;
        lowerBound: number;
        upperBound: number;
        error?: number;
    };
}
export declare class Stepwise extends ForecastStrategy {
    private refitModel;
    private verbose;
    private currentData;
    private currentModel;
    private lastForecast;
    constructor(baseModel: ARIMA, initialData: number[], options?: {
        refitModel?: boolean;
        verbose?: boolean;
    });
    forecast(steps: number): ForecastResult;
    forecastWithRealTimeData(actualObservations: number[]): StepwiseForecastResult;
    addObservationAndForecast(newObservation: number): {
        forecast: number;
        lowerBound: number;
        upperBound: number;
        error?: number;
    };
    reset(newInitialData: number[]): void;
    getCurrentData(): number[];
    getCurrentModel(): ARIMA;
}
export declare class RollingWindow extends ForecastStrategy {
    private windowSize;
    private verbose;
    private currentData;
    private lastForecast;
    constructor(baseModel: ARIMA, initialData: number[], options?: {
        windowSize?: number;
        verbose?: boolean;
    });
    forecast(steps: number): ForecastResult;
    forecastWithRealTimeData(actualObservations: number[]): RealTimeForecastResult;
    addObservationAndForecast(newObservation: number): {
        forecast: number;
        lowerBound: number;
        upperBound: number;
        error?: number;
    };
    setWindowSize(newWindowSize: number): void;
    getWindowSize(): number;
    getCurrentData(): number[];
    reset(newInitialData: number[]): void;
}
export declare class Adaptive extends ForecastStrategy {
    private stepwiseStrategy;
    private rollingStrategy;
    private adaptationThreshold;
    private errorWindow;
    private maxErrorWindowSize;
    private currentStrategy;
    private verbose;
    constructor(baseModel: ARIMA, initialData: number[], options?: {
        windowSize?: number;
        adaptationThreshold?: number;
        maxErrorWindowSize?: number;
        verbose?: boolean;
    });
    forecast(steps: number): ForecastResult;
    forecastWithRealTimeData(actualObservations: number[]): RealTimeForecastResult;
    addObservationAndForecast(newObservation: number): {
        forecast: number;
        lowerBound: number;
        upperBound: number;
        error?: number;
    };
    private shouldSwitchStrategy;
    private addError;
    private switchStrategy;
    getCurrentStrategy(): 'stepwise' | 'rolling';
    reset(newInitialData: number[]): void;
}
export {};
//# sourceMappingURL=strategies.d.ts.map