import { MixedSet } from "../utility/MixedSet.js";
import * as Result from "../utility/result.js";
import * as XYShape from "../XYShape.js";
import * as AlgebraicShapeCombination from "./AlgebraicShapeCombination.js";
import { DiscreteShape } from "./Discrete.js";
import { MixedShape } from "./Mixed.js";
import * as MixedPoint from "./MixedPoint.js";
import { ConvolutionOperation, DistributionType, PointSet } from "./PointSet.js";
export type SerializedContinuousShape = {
    xyShape: XYShape.XYShape;
    interpolation: XYShape.InterpolationStrategy;
    integralSumCache?: number;
    integralCache?: SerializedContinuousShape;
};
export declare class ContinuousShape implements PointSet<ContinuousShape> {
    readonly xyShape: XYShape.XYShape;
    readonly interpolation: XYShape.InterpolationStrategy;
    private _integralSumCache?;
    private _integralCache?;
    constructor(args: {
        xyShape: XYShape.XYShape;
        interpolation?: XYShape.InterpolationStrategy;
        integralSumCache?: number;
        integralCache?: ContinuousShape;
    });
    get integralCache(): ContinuousShape | undefined;
    get integralSumCache(): number | undefined;
    withAdjustedIntegralSum(integralSumCache: number): ContinuousShape;
    lastY(): number;
    minX(): number;
    maxX(): number;
    isEqual(t: ContinuousShape): boolean;
    mapY(fn: (y: number) => number, integralSumCacheFn?: ((sum: number) => number | undefined) | undefined, integralCacheFn?: ((cache: ContinuousShape) => ContinuousShape | undefined) | undefined): ContinuousShape;
    mapYResult<E>(fn: (y: number) => Result.result<number, E>, integralSumCacheFn: ((sum: number) => number | undefined) | undefined, integralCacheFn: ((cache: ContinuousShape) => ContinuousShape | undefined) | undefined): Result.result<ContinuousShape, E>;
    toDiscreteProbabilityMassFraction(): number;
    xToY(f: number): MixedPoint.MixedPoint;
    truncate(leftCutoff: number | undefined, rightCutoff: number | undefined): ContinuousShape;
    integral(): ContinuousShape;
    integralSum(): number;
    integralXtoY(f: number): number;
    integralYtoX(f: number): number;
    private shapeMap;
    downsample(length: number): ContinuousShape;
    isEmpty(): boolean;
    toContinuous(): this;
    toDiscrete(): undefined;
    toMixed(): MixedShape;
    scaleBy(scale: number): ContinuousShape;
    normalize(): ContinuousShape;
    mean(): number;
    private integrate;
    getMeanOfSquares(): number;
    variance(): number;
    downsampleEquallyOverX(length: number): ContinuousShape;
    yTransform(): MixedShape;
    support(): MixedSet;
    serialize(): SerializedContinuousShape;
    static deserialize(value: SerializedContinuousShape): ContinuousShape;
}
export declare const empty: () => ContinuousShape;
export declare const stepwiseToLinear: (t: ContinuousShape) => ContinuousShape;
export declare const combinePointwise: <E>(t1: ContinuousShape, t2: ContinuousShape, fn: (v1: number, v2: number) => Result.result<number, E>, distributionType?: DistributionType, integralSumCachesFn?: (v1: number, v2: number) => number | undefined) => Result.result<ContinuousShape, E>;
export declare const sum: (continuousShapes: ContinuousShape[]) => ContinuousShape;
export declare const combineAlgebraicallyWithDiscrete: (op: ConvolutionOperation, t1: ContinuousShape, t2: DiscreteShape, discretePosition: AlgebraicShapeCombination.ArgumentPosition) => ContinuousShape;
export declare const combineAlgebraically: (op: ConvolutionOperation, t1: ContinuousShape, t2: ContinuousShape) => ContinuousShape;
//# sourceMappingURL=Continuous.d.ts.map