package cn.sgnxotsmicf.Demo;

//二元多项式求导
import java.util.ArrayList;
import java.util.Scanner;
public class test0005 {
    public static void main(String[] args) {
        ArrayList<Double> var  = new ArrayList<>();//变量系数
        ArrayList<Double> exp  = new ArrayList<>();//幂次幂次
        ArrayList<Double> varX1  = new ArrayList<>();//求x1时x2幂次
        ArrayList<Double> varX2  = new ArrayList<>();//求x2时x1幂次
        Scanner sc = new Scanner(System.in);
        x1_x2Judge(sc,var,exp,varX1,varX2);
        input(var,exp,varX1,varX2);
    }

    private static void x1_x2Judge(Scanner sc,ArrayList<Double> var,ArrayList<Double> exp,
                                   ArrayList<Double> varX1,ArrayList<Double> varX2) {
        int i =0;
        System.out.println("输入1对x1求导:");
        int instruct1 = sc.nextInt();
        System.out.println("请输入关于x"+instruct1+"的项数:");
        int number1 = sc.nextInt();
        int tempt =operation(sc,var,exp,i,number1,instruct1,varX1,varX2);
        System.out.println("输入2对x2求导:");
        int instruct2= sc.nextInt();
        System.out.println("请输入关于x"+instruct2+"的项数:");
        int number2 = sc.nextInt();
        operation(sc,var,exp,tempt,number2,instruct2,varX1,varX2);
    }
    private static int operation(Scanner sc,ArrayList<Double> var,ArrayList<Double> exp,int i,int number,int instruct,
                                 ArrayList<Double> varX1,ArrayList<Double> varX2){
        int tempt = 0;
        do {
            System.out.println("请输入第" + (tempt + 1) + "个变量系数:");
            var.add(sc.nextDouble());
            System.out.println("请输入第" + (tempt + 1) + "个变量幂次:");
            exp.add(sc.nextDouble());
            if (instruct == 1) {
                derivation_Operation(var, exp, i);
            }else if (instruct == 2){
                derivation_Operation(var,exp,i);
            }
            Judge(instruct,sc,varX1,varX2);
            i++;
            tempt++;
        } while (tempt < number);
        return i;
    }
    private static void Judge(int instruct,Scanner sc,ArrayList<Double> varX1,ArrayList<Double> varX2) {
        if (instruct==1){
            System.out.println("该x"+instruct+"项(有/无)x2项相乘？");
            varX1_X2_Operation(sc,varX1);
        }else if (instruct==2){
            System.out.println("该x"+instruct+"项(有/无)x1项相乘？");
            varX1_X2_Operation(sc,varX2);
        }
    }

    private static void varX1_X2_Operation(Scanner sc,ArrayList<Double> varX) {
        String answer = sc.next();
        if (answer.equals("有")){
            System.out.println("幂次为多少？");
            double x = sc.nextInt();
            varX.add(x);
        }else if (answer.equals("无")){
            varX.add(0.0);
        }
    }

    private static void input(ArrayList<Double> var, ArrayList<Double> exp, ArrayList<Double> varX1,ArrayList<Double> varX2) {
        System.out.println("变量系数:"+var.toString());
        System.out.println("变量幂次:"+exp.toString());
        System.out.println("求x1时x2幂次:"+varX1.toString());
        System.out.println("求x2时x1幂次:"+varX2.toString());
    }

    private static void derivation_Operation(ArrayList<Double> var,ArrayList<Double> exp,int i) {
        if (var.get(i)==0||exp.get(i)==0){
            var.set(i,0.0);
            exp.set(i,0.0);
        }else {
            var.set(i,var.get(i)*exp.get(i));
            exp.set(i,exp.get(i)-1);
        }
    }
}

package cn.sgnxotsmicf.Demo;
import java.text.DecimalFormat;
import java.time.LocalDateTime;
import java.time.temporal.ChronoUnit;
import java.util.ArrayList;
import java.util.Scanner;
public class Demo_Number {
    staticdouble T = 0.618;
    static {
        System.out.println("======0.618法求解最优化问题======");
    }
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        ArrayList<Double> Data = new ArrayList<>();
        inPut(sc,Data);
    }

    private static void inPut(Scanner sc,ArrayList<Double> Data) {
        System.out.println("请输入允许误差ε:");
        double c = sc.nextDouble();
        System.out.println("给定搜索左区间a:");
        double a = sc.nextInt();
        System.out.println("给定搜索右区间b:");
        double b = sc.nextInt();
        LocalDateTime startTime = LocalDateTime.now();
        Init(Data,a,b);
        Judge(Data,c);
        LocalDateTime endTime = LocalDateTime.now();
        System.out.println("迭代时间大约为:"+ChronoUnit.MICROS.between(startTime, endTime)+"微秒");
    }

    /**
     ！！！注意：函数在此方法下修改
     */
    private static double function(double tempt){
        return tempt*tempt-tempt+2;//0.554
    }

    private static void Init(ArrayList<Double> Data,double a, double b) {
        double L = a+(1-T)*(b-a);
        double U = a+T*(b-a);
        double L1 = function(L);
        double U1 = function(U);
        Data.add(L);//0
        Data.add(U);//1
        Data.add(L1);//2
        Data.add(U1);//3
        Data.add(a);//4
        Data.add(b);//5
    }

    private static void Judge(ArrayList<Double> Data,double c) {
        while(true) {
            if(Math.abs(Data.get(4)-Data.get(5))>c) {
                if(Data.get(2)<Data.get(3)) {
                    Data.set(5, Data.get(1));//b的值
                    Data.set(1, Data.get(0));
                    Data.set(3, Data.get(2));
                    Data.set(0, Data.get(4)+(1-T)*(Data.get(5)-Data.get(4)));
                    double tempt = Data.set(0, Data.get(4)+(1-T)*(Data.get(5)-Data.get(4)));
                    Data.set(2, function(tempt));
                }else {
                    Data.set(4, Data.get(0));//a的值
                    Data.set(0,Data.get(1));
                    Data.set(2,Data.get(3));
                    Data.set(1,Data.get(4)+T*(Data.get(5)-Data.get(4)));
                    double tempt = Data.set(1,Data.get(4)+T*(Data.get(5)-Data.get(4)));
                    Data.set(3,function(tempt));
                }
            }else {
                DecimalFormat sc = new DecimalFormat("0.000");
                System.out.println("最优解x="+sc.format((Data.get(4)+Data.get(5))/2));
                break;
            }
        }
    }
}

package cn.sgnxotsmicf.Demo;
import java.text.DecimalFormat;
import java.util.Scanner;

public class Simplex_Method_Data {
    public static double[] c;  // 目标函数中变量xj的价值系数cj
    public static double[] pi; // 检验系数π
    public static double[] theta; // 入基时对应的θ
    public static double[] b0; // 基本可行解中基变量的值
    public static int m; // 秩
    public static int n; // 变量个数
    public static int[] basicVar; //用来存储基变量的索引
    public static double var;
    public static int[] MData;
    public static String YN;
    public static double[][] centreMatrix_Creat(Scanner sc){
        System.out.println("请输入约束矩阵A的秩:");
        m = sc.nextInt();
        System.out.println("请输入约束矩阵变量个数:"); // 同时也确定了基变量和非基变量的个数
        n = sc.nextInt();
        double[][]A = new double[m][n];
         inputA(A,sc);
         return A;
    }

    /**
     * 用于初始化A
     * @param A 为初始约束条件系数矩阵
     */
    public static void inputA(double[][]A,Scanner sc) {
        for (int i = 0; i < m; i++) {
            System.out.println("请输入第"+(i+1)+"行元素:");
            for (int j = 0; j < n; j++) {
                A[i][j] = sc.nextDouble();
            }
        }
    }

    /**
     * 打印单纯性表
     */
    public static void printMatrix(double[][] E){
        DecimalFormat sc = new DecimalFormat("0.00");
        for (int i = 0; i < m; i++) {
            System.out.print(sc.format(b0[i])+",");
            for (int j = 0; j < n; j++) {
                System.out.print(sc.format(E[i][j])+(j==n-1?"":","));
            }
            System.out.println();
        }
        System.out.print(var+",");
        for (int j = 0; j < n; j++) {
            System.out.print(sc.format(pi[j])+(j==n-1?"":","));
        }
        System.out.println();
    }
}

package cn.sgnxotsmicf.Demo;

import java.text.DecimalFormat;
import java.time.LocalDateTime;
import java.time.temporal.ChronoUnit;
import java.util.Arrays;
import java.util.Scanner;

public class Simplex_Method extends Simplex_Method_Data{
    static {
        System.out.println("==================单纯形法求解线性规划=================");
    }

    /**
     * 主方法
     */
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        double[][] A = centreMatrix_Creat(sc);
        Search_XB(sc);
        Init(sc,A);
        LocalDateTime startTime = LocalDateTime.now();
        LogicLoopJudge(A);
        LocalDateTime endTime = LocalDateTime.now();
        IterationTime(startTime,endTime);
    }

    /**
     *用于计算迭代时间
     * @param startTime 迭代前时间
     * @param endTime  迭代后时间
     *
     */
    private static void IterationTime(LocalDateTime startTime, LocalDateTime endTime) {
        System.out.println("迭代时间大约为:"+ ChronoUnit.MILLIS.between(startTime, endTime)+"毫秒");
    }

    private static void LogicLoopJudge(double[][] A) {
        int number = 0;
        while (true){
            int tempt = 0;
            int negativeIndex = 0;
            for (int i = 0; i < pi.length; i++) {
                if (pi[i]<=0){
                    tempt++;
                }
                else if (pi[i]>0) {
                    for (int j = 0;j < m;j++){
                        if (A[j][i]<=0){
                            negativeIndex++;
                        }
                    }
                    if (negativeIndex ==m){
                        System.out.println("此线性规划问题无最优解！");
                        return;
                    }
                }
            }
            if (tempt == n){
                printResult(A,number);
                break;
            }
            // 开始操作；
            System.out.println("=================开始第"+(number+1)+"次迭代================");
            int index = IntoBaseVar_Judge();//入基索引
            UpDataTheta(A,index);
            int index2 = OutOfBaseVar_Judge(index);//出基索引
            RotationTransformation(A,index,index2);
            number++;
        }
    }

    /**
     *用于A的旋转变化，更新A
     * @param index 入基变量
     * @param index2 出基变量
     */
    private static void RotationTransformation(double[][] A,int index,int index2) {
        if (A[index2][index] != 1) {
            double positiveFactor = A[index2][index];
            //A[index2][index] = 1;
            for (int j = 0; j < n; j++) {
                A[index2][j] /= positiveFactor; //初等行变化
            }
            b0[index2] /= positiveFactor;
        }
        RotatingCenter(A,index,index2);
    }

    private static void RotatingCenter(double[][] A, int index, int index2) {
        for (int i = 0; i < m; i++) {
            if (A[i][index]!=0 && i!=index2){
                double factor = -A[index2][index]*A[i][index];
                double b0_factor = factor*b0[index2];
                b0[i] += b0_factor;
                for (int j = 0; j < n; j++) {
                    double A_factor = A[index2][j]*factor;
                    A[i][j] += A_factor;
                }
            }
        }
        double factor = -A[index2][index]*pi[index];
        for (int j = 0; j < n; j++) {
            double pi_factor = factor*A[index2][j];
            pi[j] += pi_factor;
        }
    }

    private static void printResult(double[][] A,int number) {
        for (int i = 0; i < m; i++) {
           var += c[basicVar[i]]*b0[i];
        }
        System.out.println("======================循环结束======================");
        System.out.println("最优值为:"+var);
        System.out.println("最优解为:");
        boolean logic = OptimalSolution();
        if (!logic){
            return;
        }
        System.out.println("基向量为:");
        for (int j : basicVar) {
            System.out.print("x" + (j + 1)+"\t");
        }
        System.out.println();
        System.out.println("迭代次数:"+number);
        System.out.println("最后一步单纯形表为:");
        printMatrix(A);
    }

    private static boolean OptimalSolution() {
        DecimalFormat sc = new DecimalFormat("0.00");
        String[] OptimalSData = new String[n];
        for (int i = 0; i < basicVar.length; i++) {
            OptimalSData[basicVar[i]] = sc.format(b0[i]);
        }
        for (int i = 0; i < OptimalSData.length; i++) {
            if (OptimalSData[i] == null){
                OptimalSData[i] = "0.00";
            }
        }
        System.out.println(Arrays.toString(OptimalSData));
        //0.25 0 0 1 0 -0.25   -2 0 -1 0 1 -3    1 1 0 0 0 1   1.5 6 10   2 3 0 0 10000 10000
        if (YN.equals("yes")) {
            for (int mDatum : MData) {
                for (int j = 0; j < m; j++) {
                    if (mDatum == basicVar[j] && b0[j] != 0) {
                        System.out.println("由于最优解中存在正的人工变量，则原问题是不可行的");
                        return false;
                    }
                }
            }
        }
        return true;
    }

    /**
     *
     * @param index 为入基索引
     * @return 返回出基索引
     * 使用的是Dantzig出基规则
     */
    private static int OutOfBaseVar_Judge(int index) {
        int index2 = 0;
        for (int i = 1; i < m; i++) {
            if (theta[index2]>theta[i]){
                index2 = i;
            }
        }
        System.out.println("出基变量为:x"+((basicVar[index2]+1)));
        basicVar[index2] = index;
        return index2;
    }

    /**
     *
     * @return 返回的是入基索引
     * 使用的是Dantzig入基规则
     */
    private static int IntoBaseVar_Judge() {
        int index = 0;
        for (int i = 1; i < n; i++) {
            if (pi[index]<pi[i]){
                index = i;
            }
        }
        System.out.println("入基变量为:x"+(index+1));
        return index;
    }

    /**
     * 用于更新θ
     * @param index 入基变量
     */
    private static void UpDataTheta(double[][] A,int index) {
            theta = new double[m];
        for (int i = 0; i < m; i++) {
            if (A[i][index]<=0){
                theta[i] = 1000;
            }else {
            theta[i] = b0[i]/A[i][index];
            }
        }
    }

    /**
     * 搜索单位矩阵
     */
    private static void Search_XB(Scanner sc) {
        basicVar = new int[m];
        System.out.println("请输入单位矩阵所对应的"+m+"个初始基变量的下标:");
        for (int i = 0; i < m; i++) {
            int tempt = sc.nextInt();
            basicVar[i] = (tempt-1);
        }
        System.out.println("基变量为:");
        for (int j : basicVar) {
            System.out.print("x" + (j + 1) + " ");
        }
        System.out.println();
    }

    /**
     * 数据初始化
     */
    private static void Init(Scanner sc,double[][] A) {
        int MJudge = TheBigMMethod(sc);
        // 初始化基变量的值
        b0 = new double[m];
        if (MJudge == 1){
            System.out.println("请输入人工变量的个数:");
            int M = sc.nextInt();
             MData= new int[M];
            for (int i = 0; i < M; i++) {
                System.out.println("请输入第"+(i+1)+"个人工变量下标:");
                int tempt = sc.nextInt();
                MData[i] = (tempt-1); //人工变量索引
            }
        }
        System.out.println("请输入基本可行解中基变量的初始值:"); //等于B^-1*b ---基于初始单位阵I
        for (int i = 0; i < m; i++) {
            b0[i] = sc.nextDouble();
        }
        // 初始化 价值系数c
        c = new double[n];
        System.out.println("请输入目标函数中变量xj的价值系数cj:");
        for (int i = 0; i < n; i++) {
            c[i] = sc.nextDouble();
        }

        // 初始检验数
        initPi(A);
    }

    /**
     * 大M法判断
     * @return 返回判断逻辑
     */
    private static int TheBigMMethod(Scanner sc) {
        System.out.println("是否有人工变量？(yes/no)");
        String MJudge = sc.next();
        YN = MJudge;
        if (MJudge.equals("yes")){
            System.out.println("==================下面进行大M法求解线性最优化问题=============");
            return 1;
        }
        return 0;
    }

    /**
     *初始化检验数π
     */
    private static void initPi(double[][] A) {
        pi = new double[n];
        for (int i = 0; i < n; i++) {
                for (int j = 0; j < m; j++) {
                    pi[i] += c[basicVar[j]]*A[j][i];
                }
            pi[i] -= c[i];
        }
    }
}