import org.apache.commons.math3.optim.linear.SimplexSolver; //导入依赖的package包/类
public PointValuePair calculatePrimal() {
    SimplexSolver solver = new SimplexSolver();
    //All variables are nonnegative
    NonNegativeConstraint nonneg = new NonNegativeConstraint(true);
    //objective function is of the form MAX w+ - w- (+0x1,etc)
    LinearObjectiveFunction objective = new LinearObjectiveFunction(new double[] {1.0, -1.0, 0.0,0.0,0.0}, 0.0);
    ArrayList<LinearConstraint> constraints = new ArrayList<>();
    //probabilities must sum to 1.0
    double[] probabilityConstraint = new double[values.length + 2];
    probabilityConstraint[0] = probabilityConstraint[1] = 0.0;
    for(int i=2; i<probabilityConstraint.length; i++)
        probabilityConstraint[i]=1.0;
    constraints.add(new LinearConstraint(probabilityConstraint, Relationship.EQ, 1.0));
    //input game parameters
    //constraints supports two-sided equation
    double[] wConstraint = new double[values.length + 2];
    wConstraint[0] = 1.0;
    wConstraint[1] = -1.0;
    for(int i=0; i<values.length; i++) {
        double[] constr = new double[values.length+2];
        for(int j=2; j<constr.length; j++)
            constr[j]=values[i][j-2];
        constraints.add(new LinearConstraint(wConstraint, 0.0, Relationship.LEQ, constr, 0.0));
    }
    LinearConstraintSet constraintSet = new LinearConstraintSet(constraints);
    PointValuePair optimal = solver.optimize(objective, nonneg, constraintSet, GoalType.MAXIMIZE);
    return optimal;
}
 

import org.apache.commons.math3.optim.linear.SimplexSolver; //导入依赖的package包/类
public PointValuePair calculateDual() {
        SimplexSolver solver = new SimplexSolver();
        //All variables are nonnegative
        NonNegativeConstraint nonneg = new NonNegativeConstraint(true);
        //objective function is of the form MAX w+ - w- (+0x1,etc)
        LinearObjectiveFunction objective = new LinearObjectiveFunction(new double[] {1.0, -1.0, 0.0,0.0,0.0}, 0.0);
        ArrayList<LinearConstraint> constraints = new ArrayList<>();
        //probabilities must sum to 1.0
        double[] probabilityConstraint = new double[values.length + 2];
        probabilityConstraint[0] = probabilityConstraint[1] = 0.0;
        for(int i=2; i<probabilityConstraint.length; i++)
            probabilityConstraint[i]=1.0;
        constraints.add(new LinearConstraint(probabilityConstraint, Relationship.EQ, 1.0));
        //input game parameters
        //constraints supports two-sided equation
        double[] wConstraint = new double[values.length +2];
        wConstraint[0] = 1.0;
        wConstraint[1] = -1.0;
        for(int i=0; i<values.length; i++) {
            double[] constr = new double[values.length+2];
            for(int j=2; j<constr.length; j++)
                constr[j]=values[j-2][i];
            constraints.add(new LinearConstraint(wConstraint, 0.0, Relationship.GEQ, constr, 0.0));
        }
//        constraints.add(new LinearConstraint(new double[] {1.0,-1.0,0.0,0.0,0.0}, 0.0, Relationship.GEQ, new double[] {0.0,0.0,values[0][0],values[1][0],values[2][0]}, 0.0));
//        constraints.add(new LinearConstraint(new double[] {1.0,-1.0,0.0,0.0,0.0}, 0.0, Relationship.GEQ, new double[] {0.0,0.0,values[0][1],values[1][1],values[2][1]}, 0.0));
//        constraints.add(new LinearConstraint(new double[] {1.0,-1.0,0.0,0.0,0.0}, 0.0, Relationship.GEQ, new double[] {0.0,0.0,values[0][2],values[1][2],values[2][2]}, 0.0));
        LinearConstraintSet constraintSet = new LinearConstraintSet(constraints);
        PointValuePair optimal = solver.optimize(objective, nonneg, constraintSet, GoalType.MINIMIZE);
        return optimal;
    }
 

import org.apache.commons.math3.optim.linear.SimplexSolver; //导入依赖的package包/类
private void computeFitnessValue()
{
    fitnessValueSolution = new SimplexSolver()
            .optimize(new MaxIter(500),
                    f,
                    new LinearConstraintSet(getConstraints()),
                    GoalType.MINIMIZE,
                    new NonNegativeConstraint(true));
}
 

import org.apache.commons.math3.optim.linear.SimplexSolver; //导入依赖的package包/类
/**
     * 
     * @param A ресурсы на выпуск всех товаров (юнитов) [номер ресурса][номер юнита]
     * @param b предел ресурсов (ограничение)
     * @param c выгода
     * @param x out кол-во выпуска (план выпуска, ответ)
     * @return суммарная выгода плана x
     */
public static double simplexDouble(double[][] A, double[] b, double[] c, double[] x) {
      
//    return justOneMaximize(A,b,c, x); // maybe fast, but not precission
    
    // - - -
    LinearObjectiveFunction f = new LinearObjectiveFunction(c, 0); // !!!

    ArrayList<LinearConstraint> constraints = new ArrayList<LinearConstraint>();
    for(int i=0; i<A.length; i++) { // Ограничения
        constraints.add( new LinearConstraint(A[i], Relationship.LEQ, b[i]) ); // _c[i]*x[i]<=V_Res[i]
        double[] zeroV = new double[A[i].length];
        Arrays.fill(zeroV, 0);
        constraints.add( new LinearConstraint(zeroV, Relationship.GEQ, 0) ); // _c[i]*x[i]<=V_Res[i]
    }
    // TODO при переработке энергии в металл можно учесть с помощью двух переменных и ограничения!!!

    // FIXME precission - do not use between 0.00001 and 1.0, only 1,2,3...
    SimplexSolver solver = new SimplexSolver();
    PointValuePair optSolution = solver.optimize(new MaxIter(1000), f,
            new LinearConstraintSet(constraints),
            GoalType.MAXIMIZE,
            new NonNegativeConstraint(true));

    //double[] solution = optSolution.getPoint();
    double[] x_=optSolution.getPointRef(); // TODO it is bad fix for n*1.0. To do iteration.
    for (int i=0;i<x_.length;i++) if (x_[i]>0) x_[i]=Math.round(x_[i]-0.5);

    System.arraycopy(x_, 0, x, 0, x.length);
    return optSolution.getValue();
    // - - -    
}
 

import org.apache.commons.math3.optim.linear.SimplexSolver; //导入依赖的package包/类
public void configure(final SimplexSolver solver, final Options options) {
    // TODO Auto-generated method stub
}
 

import org.apache.commons.math3.optim.linear.SimplexSolver; //导入依赖的package包/类
public Optimisation.Result solve(final Result kickStarter) {

        //        final InitialGuess guess = new InitialGuess(kickStarter.toRawCopy1D());
        //
        //        myModelData.add(guess);

        Optimisation.State state = Optimisation.State.FAILED;
        double value = Double.NaN;
        Access1D<?> solution = kickStarter;

        try {

            final SimplexSolver solver = new SimplexSolver();

            DEFAULT.configure(solver, myOptions);
            final Optional<Configurator> optional = myOptions.getConfigurator(Configurator.class);
            if (optional.isPresent()) {
                optional.get().configure(solver, myOptions);
            }

            final PointValuePair solutionAndValue = solver.optimize(myModelData.toArray(new OptimizationData[myModelData.size()]));

            state = Optimisation.State.OPTIMAL;
            value = solutionAndValue.getValue();
            solution = Access1D.wrap(solutionAndValue.getPoint());

        } catch (final NoFeasibleSolutionException infeasible) {

            state = Optimisation.State.INFEASIBLE;

        } catch (final UnboundedSolutionException unbounded) {

            state = Optimisation.State.UNBOUNDED;
        }

        final Optimisation.Result result = new Optimisation.Result(state, value, solution);

        return result;
    }