This file contains a reference for all methods in the lp_solve library and the Java wrapper. The first column of the following table contains the C functions of the lp_solve library, the second column the corresponding methods of the Java wrapper.
| C function | Java wrapper method (LpSolve class) |
|---|---|
| unsigned char add_column (lprec* lp, REAL* column) | void addColumn(double[] column) throws LpSolveException |
| unsigned char add_columnex (lprec* lp, int count, REAL* column, int* rowno) | void addColumnex(int count, double[] column, int[] rowno) throws LpSolveException |
| unsigned char add_constraint (lprec* lp, REAL *row, int constr_type, REAL rh) | void addConstraint(double[] row, int constrType, double rh) throws LpSolveException |
| unsigned char add_constraintex (lprec *lp, int count, REAL *row, int *colno, int constr_type, REAL rh) | void addConstraintex(int count, double[] row, int[] colno, int constrType, double rh) throws LpSolveException |
| unsigned char add_lag_con (lprec* lp, REAL *row, int con_type, REAL rhs) | void addLagCon(double[] row, int constrType, double rh) throws LpSolveException |
| int add_SOS (lprec* lp, char *name, int sostype, int priority, int count, int *sosvars, REAL *weights) | void addSOS(String name, int sostype, int priority, int count, int[] sosvars, double[] weights) throws LpSolveException |
| int column_in_lp (lprec* lp, REAL *column) | int columnInLp(double[] column) |
| void default_basis (lprec* lp) | void defaultBasis() |
| unsigned char del_column(lprec *lp, int column) | void delColumn(int columnnr) throws LpSolveException |
| unsigned char del_constraint(lprec *lp, int del_row) | void delConstraint(int rownr) throws LpSolveException |
| void delete_lp(lprec *lp) | void deleteLp() |
| void free_lp(lprec **plp) | <Not implemented, use deleteLp() instead> |
| int get_anti_degen(lprec *lp) | int getAntiDegen() |
| void get_basis(lprec *lp, int *bascolumn, unsigned char nonbasic) | void getBasis(int[] bascolumn, boolean nonbasic) |
| int get_basiscrash(lprec *lp) | int getBasiscrash() |
| int get_bb_depthlimit(lprec *lp) | int getBbDepthlimit() |
| int get_bb_floorfirst(lprec *lp) | int getBbFloorfirst() |
| int get_bb_rule(lprec *lp) | int getBbRule() |
| unsigned char get_bounds_tighter(lprec *lp) | boolean getBoundsTighter() |
| REAL get_break_at_value(lprec *lp) | double getBreakAtValue() |
| char *get_col_name(lprec *lp, int column) | String getColName(int colnr) throws LpSolveException |
| unsigned char get_column(lprec *lp, int col_nr, REAL *column) | void getColumn(int columnrnr, double[] column) throws LpSolveException |
| <Not implemented> | double[] getPtrColumn(int columnrnr) throws LpSolveException |
| int get_constr_type(lprec *lp, int row) | short getConstrType(int rownr) throws LpSolveException |
| unsigned char get_constraints(lprec *lp, REAL *constr) | void getConstraints(double[] var) throws LpSolveException |
| unsigned char get_dual_solution(lprec *lp, REAL *duals) | void getDualSolution(double[] duals) throws LpSolveException |
| REAL get_epsb(lprec *lp) | double getEpsb() |
| REAL get_epsd(lprec *lp) | double getEpsd() |
| REAL get_epsel(lprec *lp) | double getEpsel() |
| REAL get_epsint(lprec *lp) | double getEpsint() |
| REAL get_epsperturb(lprec *lp) | double getEpsperturb() |
| REAL get_epspivot(lprec *lp) | double getEpspivot() |
| int get_improve(lprec *lp) | int getImprove() |
| REAL get_infinite(lprec *lp) | double getInfinite() |
| unsigned char get_lambda(lprec *lp, REAL *lambda) | void getLambda(double[] lambda) throws LpSolveException |
| REAL get_lowbo(lprec *lp, int column) | double getLowbo(int colnr) throws LpSolveException |
| int get_lp_index(lprec *lp, int orig_index) | int getLpIndex(int index) |
| char *get_lp_name(lprec *lp) | String getLpName() throws LpSolveException |
| int get_Lrows(lprec *lp) | int getLrows() |
| REAL get_mat(lprec *lp, int row, int column) | double getMat(int row, int column) |
| int get_max_level(lprec *lp) | int getMaxLevel() |
| int get_maxpivot(lprec *lp) | int getMaxpivot() |
| REAL get_mip_gap(lprec *lp, unsigned char absolute) | double getMipGap(boolean absolute) |
| int get_Ncolumns(lprec *lp) | int getNcolumns() |
| REAL get_negrange(lprec *lp) | double getNegrange() |
| int get_nonzeros(lprec *lp) | int getNonzeros() |
| int get_Norig_columns(lprec *lp) | int getNorigColumns() |
| int get_Norig_rows(lprec *lp) | int getNorigRows() |
| int get_Nrows(lprec *lp) | int getNrows() |
| REAL get_obj_bound(lprec *lp) | double getObjBound() |
| REAL get_objective(lprec *lp) | getObjective() |
| int get_orig_index(lprec *lp, int lp_index) | int getOrigIndex(int index) |
| char *get_origcol_name(lprec *lp, int column) | String getOrigcolName(int colnr) throws LpSolveException |
| char *get_origrow_name(lprec *lp, int row) | String getOrigrowName(int rownr) throws LpSolveException |
| int get_pivoting(lprec *lp) | int getPivoting() |
| int get_presolve(lprec *lp) | int getPresolve() |
| unsigned char get_primal_solution(lprec *lp, REAL *pv) | void getPrimalSolution(double[] pv) throws LpSolveException |
| int get_print_sol(lprec *lp) | int getPrintSol() |
| unsigned char get_ptr_constraints(lprec *lp, REAL **ptr_constr) | double[] getPtrConstraints() throws LpSolveException |
| unsigned char get_ptr_dual_solution(lprec *lp, REAL **ptr_duals) | double[] getPtrDualSolution() throws LpSolveException |
| unsigned char get_ptr_lambda(lprec *lp, REAL **ptr_lambda) | double[] getPtrLambda() throws LpSolveException |
| unsigned char get_ptr_primal_solution(lprec *lp, REAL **ptr_pv) | double[] getPtrPrimalSolution() throws LpSolveException |
| unsigned char get_ptr_sensitivity_obj(lprec *lp, REAL **ptr_objfrom, REAL **ptr_objtill) | double[][] getPtrSensitivityObj() throws LpSolveException |
| unsigned char get_ptr_sensitivity_objex(lprec *lp, REAL **ptr_objfrom, REAL **ptr_objtill, REAL *ptr_objfromvalue, REAL *ptr_objtillvalue) | double[][] getPtrSensitivityObjex() throws LpSolveException |
| unsigned char get_ptr_sensitivity_rhs(lprec *lp, REAL **ptr_duals, REAL **ptr_dualsfrom, REAL **ptr_dualstill) | double[][] getPtrSensitivityRhs() throws LpSolveException |
| unsigned char get_ptr_variables(lprec *lp, REAL **ptr_var) | double[] getPtrVariables() throws LpSolveException |
| REAL get_rh(lprec *lp, int row) | double getRh(int row) |
| REAL get_rh_range(lprec *lp, int row) | double getRhRange(int rownr) throws LpSolveException |
| unsigned char get_row(lprec *lp, int row_nr, REAL *row) | void getRow(int rownr, double[] row) throws LpSolveException |
| <Not implemented> | double[] getPtrRow(int rownr) throws LpSolveException |
| char *get_row_name(lprec *lp, int row) | String getRowName(int rownr) throws LpSolveException |
| REAL get_scalelimit(lprec *lp) | double getScalelimit() |
| int get_scaling(lprec *lp) | int getScaling() |
| unsigned char get_sensitivity_obj(lprec *lp, REAL *objfrom, REAL *objtill) | void getSensitivityObj(double[] objfrom, double[] objtill) throws LpSolveException |
| unsigned char get_sensitivity_objex(lprec *lp, REAL *objfrom, REAL *objtill, REAL *objfromvalue, REAL *objtillvalue) | void getSensitivityObjex(double[] objfrom, double[] objtill, double[] objfromvalue, double[] objtillvalue) throws LpSolveException |
| unsigned char get_sensitivity_rhs(lprec *lp, REAL *duals, REAL *dualsfrom, REAL *dualstill) | void getSensitivityRhs(double[] duals, double[] dualsfrom, double[] dualstill) throws LpSolveException |
| int get_simplextype(lprec *lp) | int getSimplextype() |
| int get_solutioncount(lprec *lp) | int getSolutioncount() |
| int get_solutionlimit(lprec *lp) | int getSolutionlimit() |
| int get_status(lprec *lp) | int getStatus() |
| char *get_statustext(lprec *lp, int statuscode) | String getStatustext(int statuscode) |
| long get_timeout(lprec *lp) | long getTimeout() |
| int get_total_iter(lprec *lp) | int getTotalIter() |
| int get_total_nodes(lprec *lp) | int getTotalNodes() |
| REAL get_upbo(lprec *lp, int column) | double getUpbo(int colnr) throws LpSolveException |
| int get_var_branch(lprec *lp, int column) | int getVarBranch(int colnr) throws LpSolveException |
| REAL get_var_dualresult(lprec *lp, int index) | double getVarDualresult(int index) throws LpSolveException |
| REAL get_var_primalresult(lprec *lp, int index) | double getVarPrimalresult(int index) throws LpSolveException |
| int get_var_priority(lprec *lp, int column) | int getVarPriority(int colnr) throws LpSolveException |
| unsigned char get_variables(lprec *lp, REAL *var) | void getVariables(double[] var) throws LpSolveException |
| int get_verbose(lprec *lp) | int getVerbose() |
| REAL get_working_objective(lprec *lp) | double getWorkingObjective() throws LpSolveException |
| unsigned char guess_basis(lprec *lp, double *guessvector, int *basisvector) | void guessBasis(double[] guessvector, int[] basisvector) throws LpSolveException |
| unsigned char has_BFP(lprec *lp) | boolean hasBFP() |
| unsigned char has_XLI(lprec *lp) | boolean hasXLI() |
| unsigned char is_add_rowmode(lprec *lp) | boolean isAddRowmode() |
| unsigned char is_anti_degen(lprec *lp, int testmask) | boolean isAntiDegen(int testmask) |
| unsigned char is_binary(lprec *lp, int column) | boolean isBinary(int colnr) |
| unsigned char is_break_at_first(lprec *lp) | boolean isBreakAtFirst() |
| unsigned char is_constr_type(lprec *lp, int row, int mask) | boolean isConstrType(int row, int mask) |
| unsigned char is_debug(lprec *lp) | boolean isDebug() |
| unsigned char is_feasible(lprec *lp, REAL *values, REAL threshold) | boolean isFeasible(double[] values, double threshold) throws LpSolveException |
| unsigned char is_free(lprec *lp, int column) | boolean isFree(int colnr) |
| unsigned char is_infinite(lprec *lp, REAL value) | boolean isInfinite(double value) |
| unsigned char is_int(lprec *lp, int column) | boolean isInt(int colnr) |
| unsigned char is_integerscaling(lprec *lp) | boolean isIntegerscaling() |
| unsigned char is_lag_trace(lprec *lp) | boolean isLagTrace() |
| unsigned char is_maxim(lprec *lp) | boolean isMaxim() |
| unsigned char is_nativeBFP(lprec *lp) | boolean isNativeBFP() |
| unsigned char is_nativeXLI(lprec *lp) | boolean isNativeXLI() |
| unsigned char is_negative(lprec *lp, int column) | boolean isNegative(int colnr) |
| unsigned char is_piv_mode(lprec *lp, int testmask) | boolean isPivMode(int testmask) |
| unsigned char is_piv_rule(lprec *lp, int rule) | boolean isPivRule(int rule) |
| unsigned char is_presolve(lprec *lp, int testmask) | boolean isPresolve(int testmask) |
| unsigned char is_scalemode(lprec *lp, int testmask) | boolean isScalemode(int testmask) |
| unsigned char is_scaletype(lprec *lp, int scaletype) | boolean isScaletype(int scaletype) |
| unsigned char is_semicont(lprec *lp, int column) | boolean isSemicont(int colnr) |
| unsigned char is_SOS_var(lprec *lp, int column) | boolean isSOSVar(int colnr) throws LpSolveException |
| unsigned char is_trace(lprec *lp) | boolean isTrace() |
| int lag_solve(lprec *lp, REAL start_bound, int num_iter, short verbose) | <Function is currently not exported from lp_solve dll> |
| void lp_solve_version(int *majorversion, int *minorversion, int *release, int *build) | static VersionInfo lpSolveVersion() |
| lprec *make_lp(int rows, int columns) | static LpSolve makeLp(int rows, int columns) throws LpSolveException |
| void print_constraints(lprec *lp, int columns) | void printConstraints(int columns) |
| unsigned char print_debugdump(lprec *lp, char *filename) | void printDebugdump(String filename) throws LpSolveException |
| void print_duals(lprec *lp) | void printDuals() |
| void print_lp(lprec *lp) | void printLp() |
| void print_objective(lprec *lp) | void printObjective() |
| void print_scales(lprec *lp) | void printScales() |
| void print_solution(lprec *lp, int columns) | void printSolution(int columns) |
| void print_str(lprec *lp, char *str) | void printStr(String str) |
| void print_tableau(lprec *lp) | void printTableau() |
| void put_abortfunc(lprec *lp, ctrlcfunc newctrlc, void *ctrlchandle) | void putAbortfunc(AbortListener listener, Object userhandle) throws LpSolveException |
| void put_logfunc(lprec *lp, logfunc newlog, void *loghandle) | void putLogfunc(LogListener listener, Object userhandle) throws LpSolveException |
| void put_msgfunc(lprec *lp, msgfunc newmsg, void *msghandle, int mask) | void putMsgfunc(MsgListener listener, Object userhandle, int mask) throws LpSolveException |
| lprec *read_freeMPS(char *filename, int options) | static LpSolve readFreeMps(String filename, int options) throws LpSolveException |
| lprec *read_freemps(FILE *stream, int options) | <Not implemented, use readFreeMps instead> |
| lprec *read_lp(FILE *stream, int verbose, char *lp_name) | <Not implemented, use readLp instead> |
| lprec *read_LP(char *filename, int verbose, char *lp_name) | static LpSolve readLp(String filename, int verbose, String lpName) throws LpSolveException |
| lprec *read_lpt(FILE *stream, int verbose, char *lp_name) | <Not implemented, use readLpt instead> |
| lprec *read_LPT(char *filename, int verbose, char *lp_name) | static LpSolve readLpt(String filename, int verbose, String lpName) throws LpSolveException |
| lprec *read_mps(FILE *stream, int options) | <Not implemented, use readMps instead> |
| lprec *read_MPS(char *filename, int options) | static LpSolve readMps(String filename, int options) throws LpSolveException |
| lprec *read_XLI(char *xliname, char *modelname, char *dataname, char *options, int verbose) | static LpSolve readXLI(String xliname, String modelname, String dataname, String options, int verbose) throws LpSolveException |
| void reset_basis(lprec *lp) | void resetBasis() |
| unsigned char resize_lp(lprec *lp, int rows, int columns) | void resizeLp(int rows, int columns) throws LpSolveException |
| unsigned char set_add_rowmode(lprec *lp, unsigned char turnon) | boolean setAddRowmode(boolean turnon) |
| void set_anti_degen(lprec *lp, int anti_degen) | void setAntiDegen(int antiDegen) |
| unsigned char set_basis(lprec *lp, int *bascolumn, unsigned char nonbasic) | void setBasis(int[] bascolumn, boolean nonbasic) throws LpSolveException |
| void set_basiscrash(lprec *lp, int mode) | void setBasiscrash(int mode) |
| void set_bb_depthlimit(lprec *lp, int bb_maxlevel) | void setBbDepthlimit(int bbMaxlevel) |
| void set_bb_floorfirst(lprec *lp, int bb_floorfirst) | void setBbFloorfirst(int floorFirst) |
| void set_bb_rule(lprec *lp, int bb_rule) | void setBbRule(int bbRule) |
| unsigned char set_BFP(lprec *lp, char *filename) | void setBFP(String filename) throws LpSolveException |
| unsigned char set_XLI(lprec *lp, char *filename) | void setXLI(String filename) throws LpSolveException |
| unsigned char set_binary(lprec *lp, int column, unsigned char must_be_bin) | void setBinary(int colnr, boolean mustBeBin) throws LpSolveException |
| unsigned char set_bounds(lprec *lp, int column, REAL lower, REAL upper) | void setBounds(int colnr, double lower, double upper) throws LpSolveException |
| void set_bounds_tighter(lprec *lp, unsigned char tighten) | void setBoundsTighter(boolean tighten) |
| void set_break_at_first(lprec *lp, unsigned char break_at_first) | void setBreakAtFirst(boolean breakAtFirst) |
| void set_break_at_value(lprec *lp, REAL break_at_value) | void setBreakAtValue(double breakAtValue) |
| unsigned char set_col_name(lprec *lp, int column, char *new_name) | void setColName(int colnr, String name) throws LpSolveException |
| unsigned char set_column(lprec *lp, int col_no, REAL *column) | void setColumn(int colno, double[] column) throws LpSolveException |
| unsigned char set_columnex(lprec *lp, int col_no, int count, REAL *column, int *rowno) | void setColumnex(int colno, int count, double[] column, int[] rowno) throws LpSolveException |
| unsigned char set_constr_type(lprec *lp, int row, int con_type) | void setConstrType(int rownr, int constrType) throws LpSolveException |
| void set_debug(lprec *lp, unsigned char debug) | void setDebug(boolean debug) |
| void set_epsb(lprec *lp, REAL epsb) | void setEpsb(double value) |
| void set_epsd(lprec *lp, REAL epsd) | void setEpsd(double value) |
| void set_epsel(lprec *lp, REAL epsel) | void setEpsel(double value) |
| void set_epsint(lprec *lp, REAL epsint) | void setEpsint(double value) |
| void set_epsperturb(lprec *lp, REAL epsperturb) | void setEpsperturb(double value) |
| void set_epspivot(lprec *lp, REAL epspivot) | void setEpspivot(double value) |
| unsigned char set_free(lprec *lp, int column) | void setFree(int colnr) throws LpSolveException |
| void set_improve(lprec *lp, int improve) | void setImprove(int improve) |
| void set_infinite(lprec *lp, REAL infinite) | void setInfinite(double value) |
| unsigned char set_int(lprec *lp, int column, unsigned char must_be_int) | void setInt(int colnr, boolean mustBeInteger) throws LpSolveException |
| void set_lag_trace(lprec *lp, unsigned char lag_trace) | void setLagTrace(boolean lagTrace) |
| unsigned char set_lowbo(lprec *lp, int column, REAL value) | void setLowbo(int colnr, double value) throws LpSolveException |
| unsigned char set_lp_name(lprec *lp, char *lpname) | void setLpName(String name) throws LpSolveException |
| unsigned char set_mat(lprec *lp, int row, int column, REAL value) | void setMat(int row, int column, double value) throws LpSolveException |
| void set_maxim(lprec *lp) | void setMaxim() |
| void set_maxpivot(lprec *lp, int max_num_inv) | void setMaxpivot(int maxNumInv) |
| void set_minim(lprec *lp) | void setMinim() |
| void set_mip_gap(lprec *lp, unsigned char absolute, REAL mip_gap) | void setMipGap(boolean absolute, double value) |
| void set_negrange(lprec *lp, REAL negrange) | void setNegrange(double negRange) |
| void set_obj_bound(lprec *lp, REAL obj_bound) | void setObjBound(double objBound) |
| unsigned char set_obj_fn(lprec *lp, REAL *row) | void setObjFn(double[] row) throws LpSolveException |
| unsigned char set_obj_fnex(lprec *lp, int count, REAL *row, int *colno) | void setObjFnex(int count, double[] row, int[] colno) throws LpSolveException |
| unsigned char set_obj(lprec *lp, int column, REAL value) | void setObj(int column, double value) throws LpSolveException |
| void set_outputstream(lprec *lp, FILE *stream) | <Not implemented, use setOutputfile instead> |
| unsigned char set_outputfile(lprec *lp, char *filename) | void setOutputfile(String filename) throws LpSolveException |
| void set_pivoting(lprec *lp, int pivoting) | void setPivoting(int pivRule) |
| void set_preferdual(lprec *lp, unsigned char dodual) | void setPreferdual(int dodual) |
| void set_presolve(lprec *lp, int do_presolve) | void setPresolve(int doPresolve) |
| void set_print_sol(lprec *lp, int print_sol) | void setPrintSol(int printSol) |
| unsigned char set_rh(lprec *lp, int row, REAL value) | void setRh(int row, double value) throws LpSolveException |
| unsigned char set_rh_range(lprec *lp, int row, REAL deltavalue) | void setRhRange(int rownr, double range) throws LpSolveException |
| void set_rh_vec(lprec *lp, REAL *rh) | void setRhVec(double[] rh) throws LpSolveException |
| unsigned char set_row(lprec *lp, int row_no, REAL *row) | void setRow(int rowno, double[] row) throws LpSolveException |
| unsigned char set_rowex(lprec *lp, int row_no, int count, REAL *row, int *colno) | void setRowex(int rowno, int count, double[] row, int[] colno) throws LpSolveException |
| unsigned char set_row_name(lprec *lp, int row, char *new_name) | void setRowName(int rownr, String name) throws LpSolveException |
| void set_scalelimit(lprec *lp, REAL scalelimit) | void setScalelimit(double scalelimit) |
| void set_scaling(lprec *lp, int scalemode) | void setScaling(int scalemode) |
| unsigned char set_semicont(lprec *lp, int column, unsigned char must_be_sc) | void setSemicont(int colnr, boolean mustBeSc) throws LpSolveException |
| void set_sense(lprec *lp, unsigned char maximize) | void setSense(boolean maximize) |
| void set_simplextype(lprec *lp, int simplextype) | void setSimplextype(int simplextype) |
| void set_solutionlimit(lprec *lp, int limit) | void setSolutionlimit(int limit) |
| void set_timeout(lprec *lp, long sectimeout) | void setTimeout(long timeout) |
| void set_trace(lprec *lp, unsigned char trace) | void setTrace(boolean trace) |
| unsigned char set_upbo(lprec *lp, int column, REAL value) | void setUpbo(int colnr, double value) throws LpSolveException |
| unsigned char set_var_branch(lprec *lp, int column, int branch_mode) | void setVarBranch(int colnr, int branchMode) throws LpSolveException |
| unsigned char set_var_weights(lprec *lp, REAL *weights) | void setVarWeights(double[] weights) throws LpSolveException |
| void set_verbose(lprec *lp, int verbose) | void setVerbose(int verbose) |
| int solve(lprec *lp) | int solve() throws LpSolveException |
| unsigned char str_add_column (lprec* lp, char* col_string) | void strAddColumn(String column) throws LpSolveException |
| unsigned char str_add_constraint (lprec* lp, char *row_string, int constr_type, REAL rh) | void strAddConstraint(String row, int constrType, double rh) throws LpSolveException |
| unsigned char str_add_lag_con (lprec* lp, char *row_string, int con_type, REAL rhs) | void strAddLagCon(String row, int constrType, double rh) throws LpSolveException |
| unsigned char str_set_obj_fn(lprec *lp, char *row_string) | void strSetObjFn(String row) throws LpSolveException |
| unsigned char str_set_rh_vec(lprec *lp, char *rh_string) | void strSetRhVec(String rh) throws LpSolveException |
| REAL time_elapsed(lprec *lp) | double timeElapsed() |
| void unscale(lprec *lp) | void unscale() |
| unsigned char write_freeMPS(lprec *lp, FILE *stream) | <Not implemented, use writeFreeMps instead> |
| unsigned char write_freemps(lprec *lp, char *filename) | void writeFreeMps(String filename) throws LpSolveException |
| unsigned char write_lp(lprec *lp, char *filename) | void writeLp(String filename) throws LpSolveException |
| unsigned char write_LP(lprec *lp, FILE *stream) | <Not implemented, use writeLp instead> |
| unsigned char write_mps(lprec *lp, char *filename) | void writeMps(String filename) throws LpSolveException |
| unsigned char write_MPS(lprec *lp, FILE *stream) | <Not implemented, use writeMps instead> |
| unsigned char write_XLI(lprec *lp, char *filename, char *options, unsigned char results) | void writeXLI(String filename, String options, boolean results) throws LpSolveException |