index.d.ts

declare module "javascript-lp-solver" {

    /**
 * Specifies how to constrain a variable in the model.
 */
    export interface IModelVariableConstraint {
        /** The variable should be grater or equal to this value. */
        min?: number;
        /** The variable should be less or equal to this value. */
        max?: number;
        /** The variable should be equal to this value. */
        equal?: number;
    }

    /**
     * Specifies the options when solving the problem.
     */
    export interface IModelOptions {
        /**
         * For MILP problems, specifies the relative tolerance of the objective,
         * where `0` means 0% and `1` means 100%.
         */
        tolerance?: number;
        /**
         * How many milliseconds you want to allow for the solver to try
         * and solve the model you're running.
         */
        timeout?: number;
        /**
         * Use MIR cuts.
         * @deprecated NOT WORKING
         */
        useMIRCuts?: boolean;
        /**
         * Defaults to `true`.
         */
        exitOnCycles?: boolean;
    }

    /**
     * Represents an LP/MILP problem.
     * @typeparam TSolutionVar the decision variables that will be outputed to the `Solution` object.
     * @typeparam TInternalVar the decision variables that will not be outputed to the `Solution` object.
     */
    export interface IModel<TSolutionVar extends string = string, TInternalVar extends string = string> {
        /** Name of the variable that will be the optimization objective. */
        optimize: (TSolutionVar | TInternalVar);
        /** To which direction to optimize the objective. */
        opType: "max" | "min";
        /**
         * Optimization constraints.
         * Specify an object with variable name as keys.
        */
        constraints: { [variable in (TSolutionVar | TInternalVar)]?: IModelVariableConstraint };
        /**
         * Variable identity relations.
         * Specify an object with variable name as keys. These variables will be outputted into solution.
         * The values of the object represents a linear combination of all the (rest of) variables.
         * @example
         *      ```
         *      {
         *          x: { x1: 10, x2: 5, x3: 2, x: 1 }       // x = 10 x1 + 5 x2 + 2 x3
         *      }
         *      ```
         */
        variables: { [variable in TSolutionVar]?: { [variable in (TSolutionVar | TInternalVar)]?: number } };
        /**
         * For each variable in the MILP problem, specifies whether it is an integer variable.
         * You need to specify `true` or `1` for integer variable.
         * If not specified, all the variables are continual non-negative (range `[0,+∞)`).
         */
        ints?: { [variable in (TSolutionVar | TInternalVar)]?: boolean | 0 | 1 };
        /**
         * For each variable in the MILP problem, specifies whether it is a binary variable.
         * You need to specify `true` or `1` for binary variable.
         * If not specified, all the variables are continual non-negative (range `[0,+∞)`).
         */
        binaries?: { [variable in (TSolutionVar | TInternalVar)]?: boolean | 0 | 1 };
        /**
         * For each variable in the MILP problem, specifies whether it is an unrestricted variable (range `(-∞,+∞)`).
         * You need to specify `true` or `1` for unrestricted variable.
         * If not specified, all the variables are continual non-negative (range `[0,+∞)`).
         */
        unrestricted?: { [variable in (TSolutionVar | TInternalVar)]?: boolean | 0 | 1 };
        /**
         * Options for solving this problem.
         */
        options?: IModelOptions;
    }

    /**
     * Represents the solution status of an LP/MILP problem.
     */
    export interface ISolutionStatus {
        /** Whether the problem is feasible. */
        feasible: boolean;
        /** Value pf the objective function. */
        result: number;
        /** Whether the decision variables are bounded. */
        bounded?: boolean;
        /** For MILP problem, whether an integral solution has been reached. */
        isIntegral?: boolean;
    }

    /**
     * Represents a LP/MILP solution with its status.
     * @remarks If a variable has value `0`, it will be neglected from the output.
     */
    export type Solution<TSolutionVar extends string> = ISolutionStatus & { [variable in TSolutionVar]?: number };

    /**
     * Gets the last solved model.
     */
    export const lastSolvedModel: IModel;


    /**
     * Converts the LP file content into a model object that jsLPSolver can handle.
     * @param model Array of string containing raw content of model we want solver to operate on,
     *      each item is a line of content, without suffixing `"\n"`.
     *      See http://lpsolve.sourceforge.net/5.5/lp-format.htm for the spec.
     */
    export function ReformatLP(model: string[]): IModel;
    /**
     * Convert a friendly JSON model into a model for a real solving library...
     *      in this case lp_solver.
     * @param model The model we want solver to operate on.
     */
    export function ReformatLP(model: IModel<any, any>): string;

    /**
     * Solves an LP/MILP problem.
     * @param model The model we want solver to operate on.
     * @param precision If we're solving a MILP, how tight
     *      do we want to define an integer, given
     *      that `20.000000000000001` is not an integer.
     *      (defaults to `1e-9`)
     * @param full *get better description*
     * @param validate if left blank, it will get ignored; otherwise
     *      it will run the model through all validation
     *      functions in the *Validate* module
     */
    export function Solve<TSolutionVar extends string, TInternalVar extends string>(
        model: IModel<TSolutionVar, TInternalVar>, precision?: number,
        full?: boolean, validate?: unknown): Solution<TSolutionVar>;


    //==================== WIP BELOW ====================//
    // Members below this line are automatically generated and need to be sorted out.
    // I will gradually move the members up across this line.

    /** Declaration file generated by dts-gen */

    export class Constraint {
        constructor(rhs: any, isUpperBound: any, index: any, model: any);

        addTerm(coefficient: any, variable: any): any;

        relax(weight: any, priority: any): void;

        removeTerm(term: any): any;

        setRightHandSide(newRhs: any): any;

        setVariableCoefficient(newCoefficient: any, variable: any): any;
    }

    export class Model {
        constructor(precision: any, name: any);

        activateMIRCuts(useMIRCuts: any): void;

        addVariable(cost: any, id: any, isInteger: any, isUnrestricted: any, priority: any): any;

        debug(debugCheckForCycles: any): void;

        equal(rhs: any): any;

        getNumberOfIntegerVariables(): any;

        greaterThan(rhs: any): any;

        isFeasible(): any;

        loadJson(jsonModel: any): any;

        log(message: any): any;

        maximize(): any;

        minimize(): any;

        removeConstraint(constraint: any): any;

        removeVariable(variable: any): any;

        restore(): any;

        save(): any;

        setCost(cost: any, variable: any): any;

        smallerThan(rhs: any): any;

        solve(): any;

        updateConstraintCoefficient(constraint: any, variable: any, difference: any): any;

        updateRightHandSide(constraint: any, difference: any): any;
    }

    export class Tableau {
        constructor(precision: any);

        addConstraint(constraint: any): void;

        addCutConstraints(cutConstraints: any): void;

        addVariable(variable: any): void;

        applyCuts(branchingCuts: any): void;

        applyMIRCuts(): void;

        branchAndCut(): void;

        checkForCycles(varIndexes: any): any;

        computeFractionalVolume(ignoreIntegerValues: any): any;

        copy(): any;

        countIntegerValues(): any;

        density(): any;

        getFractionalVarWithLowestCost(): any;

        getMostFractionalVar(): any;

        getNewElementIndex(): any;

        getSolution(): any;

        initialize(width: any, height: any, variables: any, unrestrictedVars: any): void;

        isIntegral(): any;

        log(message: any, force: any): any;

        phase1(): any;

        phase2(): any;

        pivot(pivotRowIndex: any, pivotColumnIndex: any): void;

        removeConstraint(constraint: any): void;

        removeVariable(variable: any): void;

        restore(): void;

        save(): void;

        setEvaluation(): void;

        setModel(model: any): any;

        setOptionalObjective(priority: any, column: any, cost: any): any;

        simplex(): any;

        solve(): any;

        updateConstraintCoefficient(constraint: any, variable: any, difference: any): void;

        updateCost(variable: any, difference: any): void;

        updateRightHandSide(constraint: any, difference: any): void;

        updateVariableValues(): void;

    }

    export const External: {
    };

    export const Numeral: any;

    export const branchAndCut: {
    };


    export function MultiObjective(model: any): any;

    export function Term(variable: any, coefficient: any): void;

    export function Variable(id: any, cost: any, index: any, priority: any): void;
}