Pfthb

the problem is follow:

object:min z
s.t.
 r1 >= 0 
 r2 >= 0
 r3 >= 0 
 r1 + r2 + r3 = 1
 15 * (1 - r1) <= z
 12 * (1 - r2) <= z
 12 * (1 - r3) <= z
 240 * r1 <= z
 27 * r2 <= z
 27 * r3 <= z

or like this format:

object:
 min z; z = max( 15 * (1 - r1), 12 * (1 - r2), 12 * (1 - r3) ,240 * r1, 27 * r2, 27 * r3)
s.t.
 r1 >= 0 
 r2 >= 0
 r3 >= 0 
 r1 + r2 + r3 = 1

This problem is from a paper, in this paper, the author used Gurobi to solve the problem. I download Gurobi and studied the LP examples, but the example's object is like min x + y + 2 z.
I want to know if this problem can be solved by Guribo,if the answer is yes, how to write the model.
Thank u very much.

I should admit I'm not a big fan of java and it's the first time I used Gurobi's Java Interface, so it might not be the most elegant solution. Anyway, here's a way to model and solve your problem in Java:

// example.java
import gurobi.*;

public class example 
 public static void main(String args) 
 try 
 GRBEnv env = new GRBEnv("example.log");
 GRBModel model = new GRBModel(env);

 // Create variables
 GRBVar r1 = model.addVar(0.0, GRB.INFINITY, 0.0, GRB.CONTINUOUS, "r1");
 GRBVar r2 = model.addVar(0.0, GRB.INFINITY, 0.0, GRB.CONTINUOUS, "r2");
 GRBVar r3 = model.addVar(0.0, GRB.INFINITY, 0.0, GRB.CONTINUOUS, "r3");
 GRBVar z = model.addVar(-GRB.INFINITY, GRB.INFINITY, 1.0, GRB.CONTINUOUS, "z");

 // Set objective: minimize z
 GRBLinExpr expr = new GRBLinExpr();
 expr.addTerm(1.0, z);
 model.setObjective(expr, GRB.MINIMIZE);

 // Add constraint: r1 + r2 + r3 = 1
 expr = new GRBLinExpr();
 expr.addTerm(1.0, r1); expr.addTerm(1.0, r2); expr.addTerm(1.0, r3);
 model.addConstr(expr, GRB.EQUAL, 1.0, "c0");

 // Add constraint: 15 * (1-r1) <= z <-> -15 r1 - z <= -15
 expr = new GRBLinExpr();
 expr.addTerm(-15.0, r1); expr.addTerm(-1.0, z);
 model.addConstr(expr, GRB.LESS_EQUAL, -15.0, "c1");

 // Add constraint: 12 * (1-r2) <= z <-> -12 r2 - z <= -12
 expr = new GRBLinExpr();
 expr.addTerm(-12.0, r2); expr.addTerm(-1.0, z);
 model.addConstr(expr, GRB.LESS_EQUAL, -12.0, "c1");

 // Add constraint: 12 * (1-r3) <= z <-> -12 r3 - z <= -12
 expr = new GRBLinExpr();
 expr.addTerm(-12.0, r3); expr.addTerm(-1.0, z);
 model.addConstr(expr, GRB.LESS_EQUAL, -12.0, "c1");

 // Add constraint: 240 r1 <= z <-> 240 r1 - z <= 0
 expr = new GRBLinExpr();
 expr.addTerm(240.0, r1); expr.addTerm(-1.0, z);
 model.addConstr(expr, GRB.LESS_EQUAL, 0.0, "c1");

 // Add constraint: 27 r2 <= z <-> 27 r2 - z <= 0
 expr = new GRBLinExpr();
 expr.addTerm(27.0, r2); expr.addTerm(-1.0, z);
 model.addConstr(expr, GRB.LESS_EQUAL, 0.0, "c1");

 // Add constraint: 27 r3 <= z <-> 27 r3 - z <= 0
 expr = new GRBLinExpr();
 expr.addTerm(27.0, r3); expr.addTerm(-1.0, z);
 model.addConstr(expr, GRB.LESS_EQUAL, 0.0, "c1");

 // Optimize model
 model.write("model.lp");
 model.optimize();

 System.out.println(r1.get(GRB.StringAttr.VarName)
 + " " +r1.get(GRB.DoubleAttr.X));
 System.out.println(r2.get(GRB.StringAttr.VarName)
 + " " +r2.get(GRB.DoubleAttr.X));
 System.out.println(r3.get(GRB.StringAttr.VarName)
 + " " +r3.get(GRB.DoubleAttr.X));

 System.out.println("Obj: " + model.get(GRB.DoubleAttr.ObjVal));

 // Dispose of model and environment

 model.dispose();
 env.dispose();

 catch (GRBException e) 
 System.out.println("Error code: " + e.getErrorCode() + ". " +
 e.getMessage());
 
 

This will also create a model.lp file which contains your LP:

Minimize
 obj: z
Subject To
 c0: r1 + r2 + r3 = 1
 c1: -15 r1 - z <= -15
 c2: -12 r2 - z <= -12
 c3: -12 r3 - z <= -12
 c4: 240 r1 - z <= 0
 c5: 27 r2 - z <= 0
 c6: 27 r3 - z <= 0
Bounds
 r1 >= 0
 r2 >= 0
 r3 >= 0
End

For such a small problem I'd recommend to write your LP directly in such a model file. Then you can solve it from the command line via Gurobi's command line tool:

gurobi_cl ResultFile=model.sol model.lp 

where model.sol is the file containing the solution.

Note that you don't need to use Gurobi for such a simple LP. There are a handful of good non-commercial solvers (
lp_solve or GLPK for example) that can solve this problem easily. With GLPK you could solve it via

glpsol --cpxlp model.lp -o solution.txt

from the command line. The --cpxlp flag tells glpk that model.lp is written in the cplex format, while -o solution.txt tells glpk to write the solution to the file solution.txt.