import { ops, scalar, scalarRational, scalarExt } from './core';
import complex, { complexT } from './complex';
import rational, { rationalB } from './rational';
type normalized<T> = T extends bigint ? rationalB : T;
type realRoots<T> = T extends number ? number[] : T extends bigint ? rationalB[] : T extends scalar<any> ? T[] : never;
type complexRoots<T> = T extends number ? complex[] : T extends scalarExt<infer R> ? complexT<R>[] : never;
type rationalRoots<T> = T extends number ? rational[] : T extends bigint ? rationalB[] : T extends rational ? rational[] : T extends rationalB ? rationalB[] : T extends scalarRational<any> ? rationalB[] : never;
type PolyNTypes = number | ops<any, any>;
type PolyTypes = PolyNTypes | bigint;
export interface PolynomialN<C> {
    c: C[];
    degree(): number;
    dup(): PolynomialN<C>;
    evaluate(t: C): C;
    evaluate(t: C[]): C[];
    deriv(): Polynomial<C>;
    mul(b: PolynomialN<C>): PolynomialN<C>;
    divmod(b: PolynomialN<C>): Polynomial<C>;
    rationalRoots(): rationalRoots<C>;
    realRoots(epsilon?: number): realRoots<C>;
    allRoots(epsilon?: number): complexRoots<C>;
    refine_roots(x: realRoots<C>, count?: number): realRoots<C>;
}
export interface Polynomial<C> extends PolynomialN<C> {
    leadCoeff(): C;
    dup(): Polynomial<C>;
    add(b: C | Polynomial<C>): Polynomial<C>;
    sub(b: C | Polynomial<C>): Polynomial<C>;
    scale(b: C): Polynomial<C>;
    rscale(b: C): Polynomial<C>;
    mul(b: Polynomial<C>): Polynomial<C>;
    divmod(b: Polynomial<C>): Polynomial<C>;
    div(b: Polynomial<C>): Polynomial<C>;
    selfAdd(b: C | Polynomial<C>): void;
    selfSub(b: C | Polynomial<C>): void;
    selfScale(b: C): void;
    selfRscale(b: C): void;
    pseudoRemainder(b: Polynomial<C>): void;
    content(): C;
    abs(): Polynomial<C>;
    sign(): number;
    normalise(epsilon?: number): PolynomialN<normalized<C>>;
    map<U extends PolyTypes>(func: (c: C, i: number) => U): Polynomial<U>;
}
export declare function PolynomialN(c: readonly number[]): PolynomialN<number>;
export declare function PolynomialN<T extends ops<T>>(c: T[]): PolynomialN<T>;
export declare function Polynomial(c: readonly number[]): Polynomial<number>;
export declare function Polynomial(c: readonly bigint[]): Polynomial<bigint>;
export declare function Polynomial<T extends ops<T>>(c: T[]): Polynomial<T>;
export declare function Polynomial<T extends PolyTypes>(c: T[]): Polynomial<T>;
declare class polynomialT<T extends ops<T>> implements Polynomial<T> {
    c: T[];
    constructor(c: T[]);
    degree(): number;
    leadCoeff(): T;
    dup(): polynomialT<T>;
    evaluate(t: T): T;
    evaluate(t: T[]): T[];
    deriv(): polynomialT<T>;
    add(b: T | polynomialT<T>): polynomialT<T>;
    sub(b: T | polynomialT<T>): polynomialT<T>;
    scale(b: number | T): polynomialT<T>;
    rscale(b: number | T): polynomialT<T>;
    mul(b: polynomialT<T>): polynomialT<T>;
    div(b: polynomialT<T>): polynomialT<T>;
    selfAdd(b: T | polynomialT<T>): void;
    selfSub(b: T | polynomialT<T>): void;
    selfScale(b: number | T): void;
    selfRscale(b: number | T): void;
    divmod(b: polynomialT<T>): polynomialT<T>;
    pseudoRemainder(b: polynomialT<T>): void;
    content(): T extends scalar<any> ? T : never;
    abs(): Polynomial<T>;
    sign(): number;
    normalise(epsilon?: number): PolynomialN<normalized<T>>;
    rationalRoots(): rationalRoots<T>;
    realRoots(epsilon?: number): realRoots<T>;
    allRoots(epsilon?: number): complexRoots<T>;
    map<U extends PolyTypes>(func: (c: T, i: number) => U): Polynomial<U>;
    refine_roots(x: realRoots<T>, count?: number): realRoots<T>;
    toString(debug?: boolean): string;
}
export declare function polyGCD<T extends PolyNTypes>(A: Polynomial<T>, B: Polynomial<T>): Polynomial<T>;
export declare function squareFreeFactorization<T extends PolyNTypes>(f: Polynomial<T>): {
    factor: Polynomial<T>;
    multiplicity: number;
}[];
export declare function multiplicityAt<T extends number | scalar<any>>(poly: Polynomial<T> | PolynomialN<T>, x: T, epsilon?: number): number;
export declare function interpolate<T extends PolyNTypes>(points: [T, T][], one?: T): Polynomial<T>;
export declare function sylvesterMatrix<T>(p: T[], q: T[], zero: T): T[][];
export declare function resultant<T extends number | scalar<any>>(p: Polynomial<T>, q: Polynomial<T>): T;
export declare function discriminant<T extends number | scalar<any>>(p: Polynomial<T>): T;
/**
 * Generate Vieta's formulas for a polynomial of given degree
 * Returns equations relating roots to coefficients
 *
 * For degree n with roots r₁, r₂, ..., rₙ and coefficients c₁, c₂, ..., cₙ:
 * - σ₁ = r₁ + r₂ + ... + rₙ = -c₁
 * - σ₂ = r₁r₂ + r₁r₃ + ... = c₂
 * - σ₃ = r₁r₂r₃ + ... = -c₃
 * - ...
 * - σₙ = r₁r₂...rₙ = (-1)ⁿcₙ
 */
export declare function vietasFormulas<T extends scalar<T>>(poly: polynomialT<T>, roots: T[]): T[];
export declare function legendrePolynomial(n: number): Polynomial<number>;
export declare function legendreTable(n: number): [number, number][];
export {};