import org.apache.commons.math3.optim.linear.LinearObjectiveFunction; //导入依赖的package包/类
@Override
public void solve(double[] dir)
{
    /* Check the dimension of the vectorspace where lives dir */
    if (dir.length != d)
        throw new LinearProgrammingSolverException(dddirMessage);
    /* Update the constraints set of the simplex solver if modification */
    if (lcListModified)
    {
        List <LinearConstraint> lcList = new ArrayList <LinearConstraint>();
        int n = dirList.size();
        for (int i = 0 ; i < n ; i++) lcList.add(new LinearConstraint(dirList.get(i), Relationship.LEQ, valList.get(i)));
        lcSet = new LinearConstraintSet(lcList);
    }
    /* Evaluation */
    PointValuePair res = solver.optimize(new LinearObjectiveFunction(dir, 0), lcSet, GoalType.MAXIMIZE);
    /* Update the results and the flags */
    point = res.getPoint ();
    value = res.getSecond ();
    evaluated = true;
    lcListModified = false;
}
 

import org.apache.commons.math3.optim.linear.LinearObjectiveFunction; //导入依赖的package包/类
private double[] getOptimalFeasibleSolution(double[] histA, 
		double[] histB, double[] bins, int dimension) {
	int num = bins.length / dimension;
	Collection<LinearConstraint> constraints = new ArrayList<LinearConstraint>();
	double[] coefficients = new double[num * 2];
	for (int i = 0; i < num; i++) {
		for (int j = 0; j < num; j++) {
			coefficients = setIJ(coefficients, i, j);
			double dist = DistanceUtil.getGroundDist(DistanceUtil.getBin(bins, dimension, i),
					DistanceUtil.getBin(bins, dimension, j), DistanceType.LTWO, null);
			constraints.add(new LinearConstraint(coefficients, Relationship.LEQ, dist));
		}
	}
	
	for (int i = 0; i < num; i++) {
		coefficients[i] = histA[i];
		coefficients[i + num] = histB[i];
	}
	
	LinearObjectiveFunction objective = new LinearObjectiveFunction(coefficients, 0);
	LinearConstraintSet consSet = new LinearConstraintSet(constraints);
	NonNegativeConstraint nonNeg = new NonNegativeConstraint(false);
	optimal = solver.optimize(objective, consSet, nonNeg, GoalType.MAXIMIZE, maxIter);
	return optimal.getPoint();
}
 

import org.apache.commons.math3.optim.linear.LinearObjectiveFunction; //导入依赖的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.LinearObjectiveFunction; //导入依赖的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.LinearObjectiveFunction; //导入依赖的package包/类
public Solution(ProblemParameters problemParameters, PatternKind patternKind, PatternPlacement patternPlacement)
{
    this.fitnessValueSolution = null;
    this.patternKind = patternKind;
    this.patternPlacement = patternPlacement;
    
    diagnosis.TimeDiagnosis td = new TimeDiagnosis();
    td.tick();
    
    SolutionGenerator sg = new IncrementalSolutionGenerator(patternPlacement, patternKind, 100000, 1000000, 0.001);
    
    int nbPatterns = 2;
    while(!sg.compute(nbPatterns) || !isPossible(sg.getPatterns(), patternKind, patternPlacement))
    {
        if(nbPatterns < problemParameters.getMaxNumberOfPatterns())
            nbPatterns++;
    }
    
    this.patterns = sg.getPatterns();
    
    System.out.println(td.tick());
    System.out.println("Solution de départ trouvée ["+nbPatterns+"]. Application de l'algorithme...");
    
    this.coefs = new double[nbPatterns];
    
    for(int i = 0; i < this.coefs.length; i++)
        this.coefs[i] = problemParameters.getPrintPrice();
    f = new LinearObjectiveFunction(this.coefs, problemParameters.getConstant());
    
    System.out.println(this);
}
 

import org.apache.commons.math3.optim.linear.LinearObjectiveFunction; //导入依赖的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.LinearObjectiveFunction; //导入依赖的package包/类
/**
 * Compute the EMD between two histograms, using Simplex method
 * @param histA the first histogram
 * @param histB the second histogram
 * @param dimension the dimension of bins
 * @param bins the bins of the histogram
 * @param distType the ground distance type 
 * @param costMatrix specific cost matrix used for ground distance, only valid if distType is ARBITRARY
 * @return the exact EMD
 */
public static double getEmd(double[] histA, double[] histB, int dimension, double[] bins, DistanceType distType, HashMap<String, Double> costMatrix) {
	if (HistUtil.sum(histA) != HistUtil.sum(histB)) {
		//System.out.println("Infeasible: " + FormatUtil.toString(histA) + " - " + FormatUtil.toString(histB));
		histA = HistUtil.normalizeArray(histA);
		histB = HistUtil.normalizeArray(histB);
	}
	int numBins = bins.length / dimension;
	double[] coefficients = new double[numBins*numBins];
	if (numBins != histA.length || histA.length != histB.length) {
		return -1.0;
	}
	Collection<LinearConstraint> constraints = new ArrayList<LinearConstraint>();
	for (int i = 0; i < numBins; i++) {
		for (int j = 0; j < numBins; j++) {
			coefficients[i*numBins + j] = getGroundDist(getBin(bins, dimension, i), getBin(bins, dimension, j), distType, costMatrix);
		}
	}
	for (int i = 0; i < numBins; i++) {
		double[] flowFrom = getFlow(numBins, i, true);
		double[] flowTo = getFlow(numBins, i, false);
		constraints.add(new LinearConstraint(flowFrom, Relationship.LEQ, histA[i]));
		constraints.add(new LinearConstraint(flowTo, Relationship.LEQ, histB[i]));
		if (histA[i] - histB[i] > 0) {
			constraints.add(new LinearConstraint(subtract(flowFrom, flowTo), Relationship.EQ, histA[i] - histB[i]));
		}
		else {
			constraints.add(new LinearConstraint(subtract(flowTo, flowFrom), Relationship.EQ, histB[i] - histA[i]));
		}
	}
	LinearObjectiveFunction minF = new LinearObjectiveFunction(coefficients, 0);
	LinearConstraintSet constraintSet = new LinearConstraintSet(constraints);
	NonNegativeConstraint nonNegConstraint = new NonNegativeConstraint(true);
	solution = solver.optimize(minF, constraintSet, nonNegConstraint, GoalType.MINIMIZE, maxIter);
	return solution.getValue();
}
 

import org.apache.commons.math3.optim.linear.LinearObjectiveFunction; //导入依赖的package包/类
public static double getIndMinEmd(double[] histA, double[] histB, int dimension, double[] bins, DistanceType distType, HashMap<String, Double> costMatrix) {
		if (HistUtil.sum(histA) != HistUtil.sum(histB)) {
			//System.out.println("Infeasible: " + FormatUtil.toString(histA) + " - " + FormatUtil.toString(histB));
			histA = HistUtil.normalizeArray(histA);
			histB = HistUtil.normalizeArray(histB);
		}
		int numBins = bins.length / dimension;
		double[] coefficients = new double[numBins*numBins];
		if (numBins != histA.length || histA.length != histB.length) {
			return -1.0;
		}
		Collection<LinearConstraint> constraints = new ArrayList<LinearConstraint>();
		for (int i = 0; i < numBins; i++) {
			for (int j = 0; j < numBins; j++) {
				coefficients[i*numBins + j] = getGroundDist(getBin(bins, dimension, i), getBin(bins, dimension, j), distType, costMatrix);
			}
		}
		for (int i = 0; i < numBins; i++) {
			double[] flowFrom = getFlow(numBins, i, true);
			double[] flowTo = getFlow(numBins, i, false);
			constraints.add(new LinearConstraint(flowFrom, Relationship.LEQ, histA[i]));
//			constraints.add(new LinearConstraint(flowTo, Relationship.LEQ, histB[i]));
			if (histA[i] - histB[i] > 0) {
				constraints.add(new LinearConstraint(subtract(flowFrom, flowTo), Relationship.EQ, histA[i] - histB[i]));
			}
//			else {
//				constraints.add(new LinearConstraint(subtract(flowTo, flowFrom), Relationship.LEQ, histB[i] - histA[i]));
//			}
		}
		LinearObjectiveFunction minF = new LinearObjectiveFunction(coefficients, 0);
		LinearConstraintSet constraintSet = new LinearConstraintSet(constraints);
		NonNegativeConstraint nonNegConstraint = new NonNegativeConstraint(true);
		solution = solver.optimize(minF, constraintSet, nonNegConstraint, GoalType.MINIMIZE, maxIter);
		return solution.getValue();
	}
 

import org.apache.commons.math3.optim.linear.LinearObjectiveFunction; //导入依赖的package包/类
public LinearObjectiveFunction getObjectiveFunction()
{
    return f;
}