import { Operators, scalarRational } from "./core";
import { FractionOptions } from "./string";
declare class _rational {
    num: number;
    den: number;
    constructor(num: number, den?: number);
    from(n: number): rational;
    dup(): rational;
    neg(): rational;
    recip(): rational;
    abs(): rational;
    frac(): rational;
    floor(): number;
    sign(): number;
    mag(): number;
    set(b: rational): rational;
    scale(b: number): rational;
    mul(b: rational): rational;
    add(b: rational): rational;
    sub(b: rational): rational;
    div(b: rational): rational;
    mod(b: rational): rational;
    ipow(b: number): rational;
    divmod(b: rational): number;
    lt(b: rational): boolean;
    eq(b: rational): boolean;
    compare(b: rational): number;
    valueOf(): number;
    isInteger(): boolean;
    is0(): boolean;
    is1(): boolean;
    toString(opts?: FractionOptions): string;
}
export declare const rational: ((num: number, den?: number) => rational) & Operators<rational> & {
    zero(): rational;
    from(n: number, maxDen?: number): rational;
    fromContinuedFraction(terms: number[], maxDen?: number): rational;
    simplified(num: number, den: number): rational;
};
export type rational = _rational;
export default rational;
declare class _rationalB {
    num: bigint;
    den: bigint;
    constructor(num: bigint, den?: bigint);
    from(n: number | bigint): rationalB;
    dup(): rationalB;
    simplify(): rationalB;
    neg(): rationalB;
    recip(): rationalB;
    abs(): rationalB;
    frac(): rationalB;
    floor(): bigint;
    sign(): number;
    mag(): number;
    set(b: rationalB): rationalB;
    scale(b: number | bigint): rationalB;
    mul(b: rationalB): rationalB;
    add(b: rationalB): rationalB;
    sub(b: rationalB): rationalB;
    div(b: rationalB): rationalB;
    mod(b: rationalB): rationalB;
    ipow(b: number): rationalB;
    divmod(b: rationalB): bigint;
    compare(b: rationalB): number;
    lt(b: rationalB): boolean;
    eq(b: rationalB): boolean;
    toString(): string;
    valueOf(): number;
}
export declare const rationalB: ((num: bigint, den?: bigint) => _rationalB) & {
    from(n: number | bigint | scalarRational<any>, maxDen?: bigint): rationalB;
    fromContinuedFraction(terms: (bigint | number)[], maxDen?: bigint): rationalB;
};
export type rationalB = _rationalB;