C# Model.Solve方法代码示例

 public static void Main(string[] args)
 {
   using (Model M  = new Model("sdo1"))
   {
     // Setting up the variables
     Variable X  = M.Variable("X", Domain.InPSDCone(3));
     Variable x  = M.Variable("x", Domain.InQCone(3));
     
     DenseMatrix C  = new DenseMatrix ( new double[][] { new double[] {2,1,0}, new double[] {1,2,1}, new double[] {0,1,2}} );
     DenseMatrix A1 = new DenseMatrix ( new double[][] { new double[] {1,0,0}, new double[] {0,1,0}, new double[] {0,0,1}} );
     DenseMatrix A2 = new DenseMatrix ( new double[][] { new double[] {1,1,1}, new double[] {1,1,1}, new double[] {1,1,1}} );
     
     // Objective
     M.Objective(ObjectiveSense.Minimize, Expr.Add(Expr.Dot(C, X), x.Index(0)));
     
     // Constraints
     M.Constraint("c1", Expr.Add(Expr.Dot(A1, X), x.Index(0)), Domain.EqualsTo(1.0));
     M.Constraint("c2", Expr.Add(Expr.Dot(A2, X), Expr.Sum(x.Slice(1,3))), Domain.EqualsTo(0.5));
     
     M.Solve();
     
     Console.WriteLine("[{0}]", (new Utils.StringBuffer()).A(X.Level()).ToString());
     Console.WriteLine("[{0}]", (new Utils.StringBuffer()).A(x.Level()).ToString());
   }
 }

        public static void Main(string[] args)
        {
          double[][] A =
            { new double[] { 3.0, 2.0, 0.0, 1.0 },
              new double[] { 2.0, 3.0, 1.0, 1.0 },
              new double[] { 0.0, 0.0, 3.0, 2.0 } };
          double[] c = { 3.0, 5.0, 1.0, 1.0  };

          // Create a model with the name 'lo1'
          Model M = new Model("lo1");
            
          // Create variable 'x' of length 3
          Variable x = M.Variable("x", 3, Domain.GreaterThan(0.0));
          // Create variable 'y' of length 1
          Variable y = M.Variable("y", 1, Domain.InRange(0.0, 10.0));
          // Create a variable vector consisting of x and y
          Variable z = Variable.Vstack(x,y);
            
          // Create three constraints
          M.Constraint("c1", Expr.Dot(A[0], z), Domain.EqualsTo(30.0));
          M.Constraint("c2", Expr.Dot(A[1], z), Domain.GreaterThan(15.0));
          M.Constraint("c3", Expr.Dot(A[2], z), Domain.LessThan(25.0));
            
          // Set the objective function to (c^t * x)
          M.Objective("obj", ObjectiveSense.Maximize, Expr.Dot(c, z));
                  
          // Solve the problem
          M.Solve();
            
          // Get the solution values
          double[] sol = z.Level();
          Console.WriteLine("x1,x2,x3,y = {0}, {1}, {2}, {3}",sol[0],sol[1],sol[2],sol[3]);
        }

    public static void Main(string[] args)
    {
      double[][] A = 
        { new double[] { 50.0, 31.0 },
          new double[] { 3.0,  -2.0 } };
      double[] c = { 1.0, 0.64 };
      using (Model M = new Model("milo1"))
      {
        Variable x = M.Variable("x", 2, Domain.GreaterThan(0.0), Domain.IsInteger());

        // Create the constraints
        //      50.0 x[0] + 31.0 x[1] <= 250.0
        //       3.0 x[0] -  2.0 x[1] >= -4.0
        M.Constraint("c1", Expr.Dot(A[0], x), Domain.LessThan(250.0));
        M.Constraint("c2", Expr.Dot(A[1], x), Domain.GreaterThan(-4.0));

        // Set max solution time
        M.SetSolverParam("mioMaxTime", 60.0);
        // Set max relative gap (to its default value)
        M.SetSolverParam("mioTolRelGap", 1e-4);
        // Set max absolute gap (to its default value)
        M.SetSolverParam("mioTolAbsGap", 0.0);

        // Set the objective function to (c^T * x)
        M.Objective("obj", ObjectiveSense.Maximize, Expr.Dot(c, x));

        // Solve the problem
        M.Solve();

        // Get the solution values
        double[] sol = x.Level();
        Console.WriteLine("x1,x2 = {0}, {1}", sol[0], sol[1]);
        Console.WriteLine("MIP rel gap = {0} ({0})",M.GetSolverDoubleInfo("mioObjRelGap"),M.GetSolverDoubleInfo("mioObjAbsGap"));
      }
    }

        public static void Main(String[] args)
        {
          using (Model M = new Model("alan"))
          {
            Variable x = M.Variable("x",        numsec, Domain.GreaterThan(0.0));
            Variable t = M.Variable("variance", Domain.GreaterThan(0.0));
            M.Objective("minvar", ObjectiveSense.Minimize, t.AsExpr());
            
            // sum securities to 1.0
            M.Constraint("wealth",  Expr.Sum(x), Domain.EqualsTo(1.0));
            // define target expected return 
            M.Constraint("dmean", Expr.Dot(mean, x), Domain.GreaterThan(target));
            
            M.Constraint(Expr.Vstack(Expr.ConstTerm(1,0.5),
                                     t.AsExpr(), 
                                     Expr.Mul(U,x)), 
                         Domain.InRotatedQCone());
            Console.WriteLine("Solve...");
            M.Solve();
            Console.WriteLine("... Solved.");
            double[] solx = x.Level();

            Console.WriteLine("Primal solution = {0}", solx[0]);
            for (int i = 1; i < numsec; ++i)
              Console.Write(", {0}", solx[i]);
            Console.WriteLine("");
          }
        }

 public static void Main(string[] args)
 {
   Matrix recipe = new DenseMatrix(recipe_data);
   using (Model M = new Model("Recipe"))
   {
     // "production" defines the amount of each product to bake.
     Variable production = M.Variable("production", 
                                      new StringSet(productnames), 
                                      Domain.GreaterThan(0.0));
     // The objective is to maximize the total revenue.
     M.Objective("revenue",
                 ObjectiveSense.Maximize, 
                 Expr.Dot(revenue, production));
     
     // The prodoction is constrained by stock:
     M.Constraint(Expr.Mul(recipe, production), Domain.LessThan(stock));
     M.SetLogHandler(Console.Out);
   
     // We solve and fetch the solution:
     M.Solve();
     double[] res = production.Level();
     Console.WriteLine("Solution:");
     for (int i = 0; i < res.Length; ++i)
     {
       Console.WriteLine(" Number of {0} : {1}", productnames[i], res[i]);
     }
     Console.WriteLine(" Revenue : ${0}", 
                       res[0] * revenue[0] + res[1] * revenue[1]);
   }
 }

        public static void Main(string[] argv)
        {
          int N = 5;
          var A = new double[][]
              { new double[] { 0.0,  0.5,  -0.1,  -0.2,   0.5},
                new double[] { 0.5,  1.25, -0.05, -0.1,   0.25},
                new double[] {-0.1, -0.05,  0.51,  0.02, -0.05},
                new double[] {-0.2, -0.1,   0.02,  0.54, -0.1},
                new double[] { 0.5,  0.25, -0.05, -0.1,   1.25} };

          // Create a model with the name 'NearestCorrelation
          using (var M = new Model("NearestCorrelation"))
          {
            // Setting up the variables
            var X = M.Variable("X", Domain.InPSDCone(N));
            var t = M.Variable("t", 1, Domain.Unbounded());

            // (t, vec (A-X)) \in Q
            M.Constraint( Expr.Vstack(t, Vec(Expr.Sub(new DenseMatrix(A),X))), Domain.InQCone() );

            // diag(X) = e
            M.Constraint(X.Diag(), Domain.EqualsTo(1.0));

            // Objective: Minimize t
            M.Objective(ObjectiveSense.Minimize, t);
                              
            // Solve the problem
            M.Solve();

            // Get the solution values
            Console.WriteLine("X = {0}",arrtostr(X.Level()));
            
            Console.WriteLine("t = {0}", arrtostr(t.Level()));
          } 
        }

 public static void Main(string[] args)
 {
   using (Model M = new Model("cqo1"))
   {
           
     Variable x = M.Variable("x", 3, Domain.GreaterThan(0.0));
     Variable y = M.Variable("y", 3, Domain.Unbounded());
           
     // Create the aliases 
     //      z1 = [ y[0],x[0],x[1] ]
     //  and z2 = [ y[1],y[2],x[2] ]
     Variable z1 = Variable.Vstack(y.Index(0),  x.Slice(0,2));
     Variable z2 = Variable.Vstack(y.Slice(1,3),x.Index(2));
         
     // Create the constraint
     //      x[0] + x[1] + 2.0 x[2] = 1.0
     double[] aval = new double[] {1.0, 1.0, 2.0};
     M.Constraint("lc", Expr.Dot(aval, x), Domain.EqualsTo(1.0));
         
     // Create the constraints
     //      z1 belongs to C_3
     //      z2 belongs to K_3
     // where C_3 and K_3 are respectively the quadratic and
     // rotated quadratic cone of size 3, i.e.
     //                 z1[0] > sqrt(z1[1]^2 + z1[2]^2)
     //  and  2.0 z2[0] z2[1] > z2[2]^2
     Constraint qc1 = M.Constraint("qc1", z1.AsExpr(), Domain.InQCone());
     Constraint qc2 = M.Constraint("qc2", z2.AsExpr(), Domain.InRotatedQCone());
         
     // Set the objective function to (y[0] + y[1] + y[2])
     M.Objective("obj", ObjectiveSense.Minimize, Expr.Sum(y));
         
     // Solve the problem
     M.Solve();
         
     // Get the linearsolution values
     double[] solx = x.Level();
     double[] soly = y.Level();
         
     Console.WriteLine("x1,x2,x3 = {0}, {1}, {2}",solx[0],solx[1],solx[2]);
     Console.WriteLine("y1,y2,y3 = {0}, {1}, {2}",soly[0],soly[1],soly[2]);
     // Get conic solution of qc1
     double[] qc1lvl = qc1.Level();
     double[] qc1sn  = qc1.Dual();
                 
     Console.Write("qc1 levels = {0}", qc1lvl[0]);
     for (int i = 1; i < qc1lvl.Length; ++i)
       Console.Write(", {0}", qc1lvl[i]);
     Console.WriteLine();
         
     Console.Write("qc1 dual conic var levels = {0}", qc1sn[0]);
     for (int i = 1; i < qc1sn.Length; ++i)
       Console.Write(", {0}", qc1sn[i]);
     Console.WriteLine();
   }
 }

          public static void Main(string[] args) 
          {
              double[][] A =  new double[][] { new double[] { -0.5, 1.0 }  };
              double[]   b =  new double[] { 1.0 };
              double[]   c =  new double[] { 1.0, 1.0 };

              using (Model M = new Model("duality"))
              {
                Variable x = M.Variable("x", 2, Domain.GreaterThan(0.0));

                Constraint con = M.Constraint(Expr.Sub(b, Expr.Mul(new DenseMatrix(A), x)), Domain.EqualsTo(0.0));

                M.Objective("obj", ObjectiveSense.Minimize, Expr.Dot(c, x));

                M.Solve();
                double[] xsol = x.Level();
                double[] ysol = con.Dual();

                Console.WriteLine("x1,x2,y = {0}, {1}, {2}\n",xsol[0],xsol[1],ysol[0]);
              }
          }

   public static void Main(string[] args)
   {
     // Create a model object
     using (Model M = new Model("simple"))
     {
 
       // Add two variables
       Variable x = M.Variable("x",1,Domain.InRange(0.0,1.0));
       Variable y = M.Variable("y",1,Domain.Unbounded());
   
       // Add a constraint on the variables
       M.Constraint("bound y", Expr.Sub(y,x), Domain.InRange(-1.0, 2.0));
   
       // Define the objective
       M.Objective("obj", ObjectiveSense.Maximize, Expr.Add(x,y));
   
       // Solve the problem
       M.Solve();
   
       // Print the solution
       Console.WriteLine("Solution. x = {0}, y = {1}",x.Level()[0],y.Level()[0]);
     }
   }

        public static void Main(string[] args)
        {
          using (Model M = new Model("FacilityLocation"))
          {
  // Variable holding the facility location
            Variable f = M.Variable("facility",new NDSet(1,2),Domain.Unbounded());
            // Variable defining the euclidian distances to each customer
            Variable d = M.Variable("dist", new NDSet(N,1), Domain.GreaterThan(0.0));
            // Variable defining the x and y differences to each customer;
            Variable t = M.Variable("t",new NDSet(N,2), Domain.Unbounded());
            M.Constraint("dist measure", 
                         Variable.Stack(new Variable[][] { new Variable[] { d, t }}), 
                         Domain.InQCone(N,3));

            Variable fxy = Variable.Repeat(f, N);
            M.Constraint("xy diff", Expr.Add(t, fxy), Domain.EqualsTo(customerloc));

            M.Objective("total_dist", ObjectiveSense.Minimize, Expr.Sum(d));
            
            M.Solve();
            double[] floc = f.Level();
            Console.WriteLine("Facility location = {0},{1}",floc[0],floc[1]);
          }
        }

        public static double[] fitpoly(double[,] data, int n)
        {
          using (var M = new Model("smooth poly"))
          {
            int m = data.GetLength(0);
            double[] Adata = new double[m * (n+1)];
            for (int j = 0, k = 0; j < m; ++j)
              for (int i = 0; i < n+1; ++i, ++k)
                 Adata[k] = Math.Pow(data[j,0], i);

            Matrix A = new DenseMatrix(m,n+1,Adata);
            double[] b = new double[m]; 
            for (int j = 0; j < m; ++j)
              b[j] = data[j,1];
                    
            Variable x  = M.Variable("x", n+1, Domain.Unbounded());
            Variable z  = M.Variable("z", 1,   Domain.Unbounded());
            Variable dx = diff(M, x);
                               
            M.Constraint(Expr.Mul(A, x), Domain.EqualsTo(b));
                                
            // z - f'(t) >= 0, for all t \in [a, b]
            Variable ub = M.Variable(n, Domain.Unbounded());
            M.Constraint(Expr.Sub(ub, 
                                  Expr.Vstack(Expr.Sub(z,dx.Index(0)), Expr.Neg(dx.Slice(1,n)))), 
                         Domain.EqualsTo(0.0));            
            nn_finite(M, ub, data[0,0], data[m-1,0]);
                    
            // f'(t) + z >= 0, for all t \in [a, b]
            Variable lb = M.Variable(n, Domain.Unbounded());
            M.Constraint(Expr.Sub(lb, 
                                  Expr.Vstack(Expr.Add(z, dx.Index(0)), dx.Slice(1,n).AsExpr())), 
                         Domain.EqualsTo(0.0));
            nn_finite(M, lb, data[0,0], data[m-1,0]);

            M.Objective(ObjectiveSense.Minimize, z);
            M.Solve();
            return x.Level();
          }
        }

        /*
            Description:
                Extends the basic Markowitz model with a market cost term.

            Input:
                n: Number of assets
                mu: An n dimmensional vector of expected returns
                GT: A matrix with n columns so (GT")*GT  = covariance matrix"
                x0: Initial holdings 
                w: Initial cash holding
                gamma: Maximum risk (=std. dev) accepted
                f: If asset j is traded then a fixed cost f_j must be paid
                g: If asset j is traded then a cost g_j must be paid for each unit traded

            Output:
               Optimal expected return and the optimal portfolio     

        */
        public static double[] MarkowitzWithTransactionsCost
          ( int n, 
            double[] mu,
            DenseMatrix GT,
            double[] x0,
            double   w,
            double   gamma,
            double[] f,
            double[] g)
        {

          // Upper bound on the traded amount
          double[] u = new double[n];
          {
            double v = w+sum(x0);
            for (int i = 0; i < n; ++i) u[i] = v;
          }

          using( Model M = new Model("Markowitz portfolio with transaction costs") )
          {
            Console.WriteLine("\n-------------------------------------------------------------------------");
            Console.WriteLine("Markowitz portfolio optimization with transaction cost\n");
            Console.WriteLine("------------------------------------------------------------------------\n");
          
            //M.SetLogHandler(Console.Out);

            // Defines the variables. No shortselling is allowed.
            Variable x = M.Variable("x", n, Domain.GreaterThan(0.0));

            // Addtional "helper" variables 
            Variable z = M.Variable("z", n, Domain.Unbounded());
            // Binary varables
            Variable y = M.Variable("y", n, Domain.InRange(0.0,1.0), Domain.IsInteger());

            //  Maximize expected return
            M.Objective("obj", ObjectiveSense.Maximize, Expr.Dot(mu,x));

            // Invest amount + transactions costs = initial wealth
            M.Constraint("budget", Expr.Add(Expr.Add(Expr.Sum(x),Expr.Dot(f,y)),Expr.Dot(g,z)),
                         Domain.EqualsTo(w+sum(x0)));

            // Imposes a bound on the risk
            M.Constraint("risk", Expr.Vstack(Expr.ConstTerm(new double[] {gamma}),Expr.Mul(GT,x)), Domain.InQCone());

            // z >= |x-x0| 
            M.Constraint("buy",  Expr.Sub(z,Expr.Sub(x,x0)),Domain.GreaterThan(0.0));
            M.Constraint("sell", Expr.Sub(z,Expr.Sub(x0,x)),Domain.GreaterThan(0.0));

            //M.constraint("trade", Expr.hstack(z.asExpr(),Expr.sub(x,x0)), Domain.inQcone())"

            // Consraints for turning y off and on. z-diag(u)*y<=0 i.e. z_j <= u_j*y_j
            M.Constraint("y_on_off", Expr.Sub(z,Expr.Mul(Matrix.Diag(u),y)), Domain.LessThan(0.0));

            // Integer optimization problems can be very hard to solve so limiting the 
            // maximum amount of time is a valuable safe guard
            M.SetSolverParam("mioMaxTime", 180.0);
            M.Solve();
            Console.WriteLine("Expected return: {0:e4} Std. deviation: {1:e4} Transactions cost: {2:e4}",
                   dot(mu, x.Level()), gamma, dot(f, y.Level()) + dot(g, z.Level()));
            return x.Level();
          }
        }

        public static double[][] lownerjohn_outer(double[][] x)
        {
          using( Model M = new Model("lownerjohn_outer") )
          {
            // Direct log output to the terminal for debugging. 
            M.SetLogHandler(Console.Out);  
            int m = x.Length;
            int n = x[0].Length;

            // Setup variables
            Variable t = M.Variable("t", 1, Domain.GreaterThan(0.0));
            Variable P = M.Variable("P", new NDSet(n,n), Domain.Unbounded());
            Variable c = M.Variable("c", n, Domain.Unbounded());

            // (1, P(*xi+c)) \in Q 
            for (int i = 0; i < m; ++i)
              M.Constraint( "qc" + i, Expr.Vstack(Expr.Ones(1), Expr.Sub(Expr.Mul(P,x[i]), c)), Domain.InQCone() );

            // t <= det(P)^{1/n}
            det_rootn(M, P, t);
                             
            // Objective: Maximize t
            M.Objective(ObjectiveSense.Maximize, t);
            M.Solve();
          
            double[] Plvl = P.Level();
            double[] clvl = c.Level();

            double[][] Pc = new double[n+1][];
            for (int i = 0; i < n; ++i)
            {
              Pc[i] = new double[n];
              System.Array.Copy(Plvl,i*n, Pc[i],0, n);
            }
            Pc[n] = clvl;

            return Pc;
          } 
        }

        public static double[][] lownerjohn_inner(double[][] A, double[] b)
        {
          using( Model M = new Model("lownerjohn_inner"))
          {
            // Direct log output to the terminal for debugging. 
            M.SetLogHandler(Console.Out);  
            int m = A.Length;
            int n = A[0].Length; 

            // Setup variables
            Variable t = M.Variable("t", 1, Domain.GreaterThan(0.0));   
            Variable C = M.Variable("C", new NDSet(n,n), Domain.Unbounded());
            Variable d = M.Variable("d", n, Domain.Unbounded());        
          
            // (bi - ai^T*d, C*ai) \in Q 
            for (int i = 0; i < m; ++i)
              M.Constraint( "qc" + i, Expr.Vstack(Expr.Sub(b[i],Expr.Dot(A[i],d)), Expr.Mul(C,A[i])), Domain.InQCone() );

            // t <= det(C)^{1/n}
            det_rootn(M, C, t);
                                 
            // Objective: Maximize t
            M.Objective(ObjectiveSense.Maximize, t);
            M.Solve();
          
            double[] Clvl = C.Level();
            double[] dlvl = d.Level();

            double[][] Cres_d = new double[n+1][];
            for (int i = 0; i < n; ++i)
            {
              Cres_d[i] = new double[n];
              System.Array.Copy(Clvl,i*n,Cres_d[i],0, n);
            }
            Cres_d[n] = dlvl;
            return Cres_d;
          }
        }