干货 | 关于数学规划求解器lp_solve 这里有份超全面超详细的教程，你离lpsolve高手只有一步之遥！

 1>> lp=mxlpsolve('make_lp', 0, 4);
 2>> mxlpsolve('set_verbose', lp, 3);
 3>> mxlpsolve('set_obj_fn', lp, [1, 3, 6.24, 0.1]);
 4>> mxlpsolve('add_constraint', lp, [0, 78.26, 0, 2.9], 2, 92.3);
 5>> mxlpsolve('add_constraint', lp, [0.24, 0, 11.31, 0], 1, 14.8);
 6>> mxlpsolve('add_constraint', lp, [12.68, 0, 0.08, 0.9], 2, 4);
 7>> mxlpsolve('set_lowbo', lp, 1, 28.6);
 8>> mxlpsolve('set_lowbo', lp, 4, 18);
 9>> mxlpsolve('set_upbo', lp, 4, 48.98);
10>> mxlpsolve('set_col_name', lp, 1, 'COLONE');
11>> mxlpsolve('set_col_name', lp, 2, 'COLTWO');
12>> mxlpsolve('set_col_name', lp, 3, 'COLTHREE');
13>> mxlpsolve('set_col_name', lp, 4, 'COLFOUR');
14>> mxlpsolve('set_row_name', lp, 1, 'THISROW');
15>> mxlpsolve('set_row_name', lp, 2, 'THATROW');
16>> mxlpsolve('set_row_name', lp, 3, 'LASTROW');
17>> mxlpsolve('write_lp', lp, 'a.lp');
18>> mxlpsolve('get_mat', lp, 1, 2)
19
20ans =
21
22   78.2600
23
24>> mxlpsolve('solve', lp)
25
26ans =
27
28     0
29
30>> mxlpsolve('get_objective', lp)
31
32ans =
33
34   31.7828
35
36>> mxlpsolve('get_variables', lp)
37
38ans =
39
40   28.6000
41         0
42         0
43   31.8276
44
45>> mxlpsolve('get_constraints', lp)
46
47ans =
48
49   92.3000
50    6.8640
51  391.2928

 1>> f = [4 2 1];
 2>> A = [2 1 0; 1 0 2; 1 1 1];
 3>> b = [1; 2; 1];
 4>> l = [ 0 0 0];
 5>> u = [ 1 1 2];
 6>> lp = lp_maker(f, A, b, [-1; -1; 0], l, u, [], 1, 0); 
 7>> solvestat = mxlpsolve('solve', lp)　　
 8
 9     solvestat = 0　　
10
11>> obj = mxlpsolve('get_objective', lp)　　
12
13     obj = 2.5000　　
14
15>> x = mxlpsolve('get_variables', lp)　　
16
17     x = 0.5000         　　
18
19         0    　　
20
21         0.5000　　
22
23>> mxlpsolve('delete_lp', lp)

1>>> f = [4, 2, 1]
2>>> A = [[2, 1, 0], [1, 0, 2], [1, 1, 1]]
3>>> b = [1, 2, 1]
4>>> l = [ 0, 0, 0]
5>>> u = [ 1, 1, 2]

 1>>> from lpsolve55 import *
 2>>> from lp_maker import *
 3>>> lp = lp_maker(f, A, b, [-1, -1, 0], l, u, None, 1, 0)
 4>>> solvestat = lpsolve('solve', lp)
 5>>> obj = lpsolve('get_objective', lp)
 6>>> print obj
 72.5 8>>> x = lpsolve('get_variables', lp)[0]
 9>>> print x
10[0.5, 0.0, 0.5]
11>>> lpsolve('delete_lp', lp)

  1#include "lp_lib.h"
  2   # define WIN32
  3#pragma comment(lib, "lpsolve55.lib")
  4
  5int demo()
  6{
  7    lprec *lp;
  8    int Ncol, *colno = NULL, j, ret = 0;
  9    REAL *row = NULL;
 10
 11    /* We will build the model row by row
 12    So we start with creating a model with 0 rows and 2 columns */
 13    Ncol = 2; /* there are two variables in the model */
 14    lp = make_lp(0, Ncol);
 15    if (lp == NULL)
 16        ret = 1; /* couldn't construct a new model... */
 17
 18    if (ret == 0) {
 19        /* let us name our variables. Not required, but can be useful for debugging */
 20        set_col_name(lp, 1, "x");
 21        set_col_name(lp, 2, "y");
 22
 23        /* create space large enough for one row */
 24        colno = (int *)malloc(Ncol * sizeof(*colno));
 25        row = (REAL *)malloc(Ncol * sizeof(*row));
 26        if ((colno == NULL) || (row == NULL))
 27            ret = 2;
 28    }
 29
 30    if (ret == 0) {
 31        set_add_rowmode(lp, TRUE);  /* makes building the model faster if it is done rows by row */
 32
 33                                    /* construct first row (120 x + 210 y <= 15000) */
 34        j = 0;
 35
 36        colno[j] = 1; /* first column */
 37        row[j++] = 120;
 38
 39        colno[j] = 2; /* second column */
 40        row[j++] = 210;
 41
 42        /* add the row to lpsolve */
 43        if (!add_constraintex(lp, j, row, colno, LE, 15000))
 44            ret = 3;
 45    }
 46
 47    if (ret == 0) {
 48        /* construct second row (110 x + 30 y <= 4000) */
 49        j = 0;
 50
 51        colno[j] = 1; /* first column */
 52        row[j++] = 110;
 53
 54        colno[j] = 2; /* second column */
 55        row[j++] = 30;
 56
 57        /* add the row to lpsolve */
 58        if (!add_constraintex(lp, j, row, colno, LE, 4000))
 59            ret = 3;
 60    }
 61
 62    if (ret == 0) {
 63        /* construct third row (x + y <= 75) */
 64        j = 0;
 65
 66        colno[j] = 1; /* first column */
 67        row[j++] = 1;
 68
 69        colno[j] = 2; /* second column */
 70        row[j++] = 1;
 71
 72        /* add the row to lpsolve */
 73        if (!add_constraintex(lp, j, row, colno, LE, 75))
 74            ret = 3;
 75    }
 76
 77    if (ret == 0) {
 78        set_add_rowmode(lp, FALSE); /* rowmode should be turned off again when done building the model */
 79
 80                                    /* set the objective function (143 x + 60 y) */
 81        j = 0;
 82
 83        colno[j] = 1; /* first column */
 84        row[j++] = 143;
 85
 86        colno[j] = 2; /* second column */
 87        row[j++] = 60;
 88
 89        /* set the objective in lpsolve */
 90        if (!set_obj_fnex(lp, j, row, colno))
 91            ret = 4;
 92    }
 93
 94    if (ret == 0) {
 95        /* set the object direction to maximize */
 96        set_maxim(lp);
 97
 98        /* just out of curioucity, now show the model in lp format on screen */
 99        /* this only works if this is a console application. If not, use write_lp and a filename */
100        write_LP(lp, stdout);
101        /* write_lp(lp, "model.lp"); */
102
103        /* I only want to see important messages on screen while solving */
104        set_verbose(lp, IMPORTANT);
105
106        /* Now let lpsolve calculate a solution */
107        ret = solve(lp);
108        if (ret == OPTIMAL)
109            ret = 0;
110        else
111            ret = 5;
112    }
113
114    if (ret == 0) {
115        /* a solution is calculated, now lets get some results */
116
117        /* objective value */
118        printf("Objective value: %f\n", get_objective(lp));
119
120        /* variable values */
121        get_variables(lp, row);
122        for (j = 0; j < Ncol; j++)
123            printf("%s: %f\n", get_col_name(lp, j + 1), row[j]);
124
125        /* we are done now */
126    }
127
128    /* free allocated memory */
129    if (row != NULL)
130        free(row);
131    if (colno != NULL)
132        free(colno);
133
134    if (lp != NULL) {
135        /* clean up such that all used memory by lpsolve is freed */
136        delete_lp(lp);
137    }
138
139    return(ret);
140}
141
142int main()
143{
144    demo();
145}

  1package lpsolve_test;
  2import lpsolve.*;
  3import java.util.Arrays;
  4
  5
  6public class Optimator {
  7    private static LpSolve problem;
  8    /**
  9     * 求解整数规划问题
 10     * @param goal          目标函数矩阵，由于LpSolve读取数组时从下标1开始读取，数据需从下标1开始填充，0-1的放前面，有上限的放后面
 11     * @param stIeMatrix    不等式约束方程矩阵，由于LpSolve读取数组时从下标1开始读取，内层数据需从下标1开始填充
 12     * @param stEqMatrix    等式约束方程矩阵，由于LpSolve读取数组时从下标1开始读取，内层数据需从下标1开始填充
 13     * @param stIeRest      不等式约束条件矩阵，每次传入的是单个数字，不需要从1开始填充
 14     * @param stEqRest      等式约束条件矩阵，每次传入的是单个数字，不需要从1开始填充
 15     * @param ups           上限约束矩阵
 16     */
 17    public static void optimate(double[] goal,double[][] stIeMatrix,double[][] stEqMatrix,
 18            double[] stIeRest,double[] stEqRest,double[] ups) throws LpSolveException{
 19
 20        //1、创建LpSolve对象
 21        problem = LpSolve.makeLp(0, goal.length-1);
 22        //2、添加目标函数，会从下标1开始读取!下标1的参数会被忽略
 23        problem.setObjFn(goal);
 24
 25        //3、循环添加不等式约束，外层循环一次代表一个不等式
 26        if(stIeMatrix!=null){
 27            for(int i=0;i<stIeMatrix.length;i++){
 28                //同样数组的读取会从下标1开始
 29                problem.addConstraint(stIeMatrix[i], LpSolve.LE, stIeRest[i]);
 30            }
 31        }
 32
 33        //4、循环添加等式约束，外层循环一次代表一个等式
 34        if(stEqMatrix!=null){
 35            for(int i=0;i<stEqMatrix.length;i++){
 36                //同样数组的读取会从下标1开始
 37                problem.addConstraint(stEqMatrix[i], LpSolve.EQ, stEqRest[i]);
 38            }
 39        }
 40
 41        //5、设置参数的整数约束，1代表第一个参数
 42        for(int i=1;i<goal.length;i++){
 43            problem.setInt(i, true);
 44        }
 45
 46        //6、设置指定参数的上限值
 47        for(int i=1;i<=ups.length;i++){
 48            problem.setUpbo(i, ups[i-1]);
 49        }
 50
 51        problem.printLp();
 52        //求解
 53        problem.solve();
 54    }
 55    /**
 56     * 得到最优解
 57     * @return
 58     * @throws LpSolveException
 59     */
 60    public static double getObjective() throws LpSolveException{
 61        if(problem!=null){
 62            return problem.getWorkingObjective();
 63        }else{
 64            try {
 65                throw new Exception("还没有进行求解！");
 66            } catch (Exception e) {
 67                // TODO Auto-generated catch block
 68                e.printStackTrace();
 69            } 
 70            return 0;
 71        }
 72    }
 73    /**
 74     * 得到最优解对应的变量
 75     * @return
 76     * @throws LpSolveException
 77     */
 78    public static double[] getVariables() throws LpSolveException{
 79        if(problem!=null){
 80            return problem.getPtrVariables();
 81        }else{
 82            try {
 83                throw new Exception("还没有进行求解！");
 84            } catch (Exception e) {
 85                // TODO Auto-generated catch block
 86                e.printStackTrace();
 87            } 
 88            return null;
 89        }
 90    }
 91
 92//测试
 93    public static void main(String[] args) {
 94        try {
 95            double[][] stIeMatrix = new double[1][];
 96            stIeMatrix[0] = new double[]{0,1,2,3,4};
 97            double[] stRest = new double[]{1};
 98            optimate(new double[]{0,1,2,3,4},stIeMatrix,stIeMatrix,stRest,stRest,new double[]{1,1,5,6});
 99            System.out.println(getObjective());
100            System.out.println(Arrays.toString(getVariables()));
101        } catch (LpSolveException e) {
102            // TODO Auto-generated catch block
103            e.printStackTrace();
104        }
105    }
106}