declare const FromNum: {
    /**
     * A generic roll. Anything larger than 100 will be true,
     * lesser than 0 will be false.
     * @param percentage 0~100
     * @returns Fail(false)/Success(true)
     */
    roll(percentage: number): boolean;
    /**
     * Dice roll for your typical TRPG game.
     * Ex) FromNum.diceRoll(3).D(20) = Roll 3 D20 Dice.
     * Ex) FromNum.diceRoll(1).D(6) = Roll 1 D6 Dice.
     * @param num Number of dice to roll
     */
    diceRoll(num: number): {
        /**
         * @param diceType Type of dice (e.g. 6, 10, 20).
         * @returns number[]
         */
        D: (diceType: number) => number[];
    };
    /**
     * Scale number down to 0 ~ 1.
     * @param x  Input number
     * @param min Min number
     * @param max Max number
     */
    minMaxScale(x: number, min: number, max: number): number;
    /**
     * Return scaled down number back to normal.
     * @param x  Input number
     * @param min Min number
     * @param max Max number
     */
    unMinMaxScale(x: number, min: number, max: number): number;
    /**
     * Return the sum of the values.
     * @param nums Array of numbers
     */
    sum(nums: number[]): number;
    /**
     * SoftMax / normalized exponential function.
     * Returns a probability distribution of K possible outcomes.
     * @param input Array of numbers
     */
    softMax(input: number[]): number[];
    /**
     * Return the arithmetic mean of a list of numbers.
     * @param input Array of numbers
     */
    mean(input: number[]): number;
    /**
     * Convert numeric values into Roman Numeral string.
     * @param number Input number.
     */
    toRomanNumeral(number: number): string;
    /**
     * Sigmoid function — bounded, differentiable, defined for all real inputs.
     * @param x number or number[]
     */
    sigmoid(x: number | number[]): number | number[];
    /**
     * ReLU (Rectified Linear Unit) — f(x) = max(0, x).
     * Outputs input directly if positive, otherwise zero.
     * @param xs number[]
     */
    relu(xs: number[]): number[];
    /**
     * Softplus — smooth version of ReLU. f(x) = log(1 + exp(x))
     * @param xs number[]
     */
    softPlus(xs: number[]): number[];
    /**
     * Round number to nearest specified multiple.
     * @param n Number to round
     * @param r Multiple to round to
     */
    toNearest(n: number, r: number): number;
    /**
     * Convert number into a short readable string.
     * Does not round when truncating decimals.
     * @param n Input number
     * @param decimal Default = 2, number of decimal places to retain.
     * @param maxLen Default = 3, maximum digit length (overwrites decimal).
     */
    toShortReadable(n: number, decimal?: number, maxLen?: number): string;
};

export { FromNum };