Example #1
0
    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"));
      }
    }
Example #2
0
        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("");
          }
        }
Example #3
0
 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());
   }
 }
Example #4
0
        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]);
        }
Example #5
0
        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()));
          } 
        }
Example #6
0
 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();
   }
 }
Example #7
0
 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]);
   }
 }
Example #8
0
        // Models the cone of nonnegative polynomials on the real axis
        public static void nn_inf(Model M, Variable x)
        {
          int m = (int)x.Size() - 1;
          int n = (m/2); // degree of polynomial is 2*n

          //assert(m == 2*n)    

          // Setup variables
          Variable X = M.Variable(Domain.InPSDCone(n+1));

          // x_i = Tr H(n, i) * X  i=0,...,m
          for (int i = 0; i < m+1; ++i)
            M.Constraint( Expr.Sub(x.Index(i), Expr.Dot(Hankel(n,i,1.0),X)), Domain.EqualsTo(0.0));
        }
Example #9
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]);
          }
        }
Example #10
0
        // Models the cone of nonnegative polynomials on the semi-infinite interval [0,inf)
        public static void nn_semiinf(Model M, Variable x)
        {
          int n = (int)x.Size()-1;
          int n1 = n/2, 
              n2 = (n-1)/2;
          
          // Setup variables
          Variable X1 = M.Variable(Domain.InPSDCone(n1+1));
          Variable X2 = M.Variable(Domain.InPSDCone(n2+1));

          // x_i = Tr H(n1, i) * X1 + Tr H(n2,i-1) * X2, i=0,...,n
          for (int i = 0; i < n+1; ++i)
            M.Constraint( Expr.Sub(x.Index(i), 
                                   Expr.Add(Expr.Dot(Hankel(n1,i,1.0),  X1), 
                                            Expr.Dot(Hankel(n2,i-1,1.0),X2))), Domain.EqualsTo(0.0) );
        }
Example #11
0
          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]);
              }
          }
Example #12
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]);
     }
   }
Example #13
0
        /*
            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
                m: It is assumed that  market impact cost for the j'th asset is
                   m_j|x_j-x0_j|^3/2

            Output:
               Optimal expected return and the optimal portfolio     

        */
        public static void MarkowitzWithMarketImpact
          ( int n,
            double[] mu,
            DenseMatrix GT,
            double[] x0,
            double   w,
            double   gamma,
            double[] m,
            
            double[] xsol,
            double[] tsol)
        {
          using(Model M = new Model("Markowitz portfolio with market impact"))
          {

            //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 t = M.Variable("t", n, Domain.Unbounded());
            Variable z = M.Variable("z", n, Domain.Unbounded());  
            Variable v = M.Variable("v", n, Domain.Unbounded());      

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

            // Invested amount + slippage cost = initial wealth
            M.Constraint("budget", Expr.Add(Expr.Sum(x),Expr.Dot(m,t)), 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));

            // t >= z^1.5, z >= 0.0. Needs two rotated quadratic cones to model this term
            M.Constraint("ta", Expr.Hstack(v.AsExpr(),t.AsExpr(),z.AsExpr()),Domain.InRotatedQCone());

            M.Constraint("tb", Expr.Hstack(z.AsExpr(),Expr.ConstTerm(n,1.0/8.0),v.AsExpr()),
                         Domain.InRotatedQCone());
            M.Solve();  
       
            if (xsol != null) 
              Array.Copy(x.Level(),xsol,n);
            if (tsol != null)
              Array.Copy(t.Level(),tsol,n);
          }
        }
Example #14
0
        /** 
            Purpose: Models the convex set 

              S = { (x, t) \in R^n x R | x >= 0, t <= (x1 * x2 * ... *xn)^(1/n) }.

            as the intersection of rotated quadratic cones and affine hyperplanes,
            see [1, p. 105].  This set can be interpreted as the hypograph of the 
            geometric mean of x.

            We illustrate the modeling procedure using the following example.
            Suppose we have 

               t <= (x1 * x2 * x3)^(1/3)

            for some t >= 0, x >= 0. We rewrite it as

               t^4 <= x1 * x2 * x3 * x4,   x4 = t

            which is equivalent to (see [1])

               x11^2 <= 2*x1*x2,   x12^2 <= 2*x3*x4,

               x21^2 <= 2*x11*x12,

               sqrt(8)*x21 = t, x4 = t.

            References:
            [1] "Lectures on Modern Optimization", Ben-Tal and Nemirovski, 2000. 
        */ 
        public static void geometric_mean(Model M, Variable x, Variable t)
        {
          int n = (int)x.Size();
          int l = (int)System.Math.Ceiling(log2(n));
          int m = pow2(l) - n;
                  
          Variable x0;

          if (m == 0)
              x0 = x;
          else    
              x0 = Variable.Vstack(x, M.Variable(m, Domain.GreaterThan(0.0)));

          Variable z = x0;

          for (int i = 0; i < l-1; ++i)
          {
            Variable xi = M.Variable(pow2(l-i-1), Domain.GreaterThan(0.0));
            for (int k = 0; k < pow2(l-i-1); ++k)
              M.Constraint(Variable.Vstack(z.Index(2*k),z.Index(2*k+1),xi.Index(k)),
                           Domain.InRotatedQCone());
              z = xi;
          }
              
          Variable t0 = M.Variable(1, Domain.GreaterThan(0.0));
          M.Constraint(Variable.Vstack(z, t0), Domain.InRotatedQCone());

          M.Constraint(Expr.Sub(Expr.Mul(System.Math.Pow(2,0.5*l),t),t0), Domain.EqualsTo(0.0));

          for (int i = pow2(l-m); i < pow2(l); ++i)
            M.Constraint(Expr.Sub(x0.Index(i), t), Domain.EqualsTo(0.0));
        }
Example #15
0
        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;
          } 
        }
Example #16
0
        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;
          }
        }
Example #17
0
        /**
            Purpose: Models the hypograph of the n-th power of the
            determinant of a positive definite matrix.

            The convex set (a hypograph)

              C = { (X, t) \in S^n_+ x R |  t <= det(X)^{1/n} },

            can be modeled as the intersection of a semidefinite cone
            
              [ X, Z; Z^T Diag(Z) ] >= 0  

            and a number of rotated quadratic cones and affine hyperplanes,

              t <= (Z11*Z22*...*Znn)^{1/n}  (see geometric_mean).

            References:
            [1] "Lectures on Modern Optimization", Ben-Tal and Nemirovski, 2000. 
         */

        public static void det_rootn(Model M, Variable X, Variable t)
        {
          int n = X.Shape.Dim(0);

          // Setup variables
          Variable Y = M.Variable(Domain.InPSDCone(2*n));
          
          // Setup Y = [X, Z; Z^T diag(Z)] 
          Variable Y11 = Y.Slice(new int[] {0, 0}, new int[] {n, n});
          Variable Y21 = Y.Slice(new int[] {n, 0}, new int[] {2*n, n});
          Variable Y22 = Y.Slice(new int[] {n, n}, new int[] {2*n, 2*n});
          
          
          Matrix S = Matrix.Sparse(n, n, irange(0,n), irange(0,n), ones(n));
          M.Constraint( Expr.Sub(Expr.MulElm(S,Y21), Y22), Domain.EqualsTo(0.0));
          M.Constraint( Expr.Sub(X, Y11), Domain.EqualsTo(0.0) );

          // t^n <= (Z11*Z22*...*Znn)
          Variable[] tmpv = new Variable[n];
          for (int i = 0; i < n; ++i) tmpv[i] = Y22.Index(i,i);
          Variable z = Variable.Reshape(Variable.Vstack(tmpv), n);
          geometric_mean(M, z, t);
        }
Example #18
0
 // returns variables u representing the derivative of    
 //  x(0) + x(1)*t + ... + x(n)*t^n,
 // with u(0) = x(1), u(1) = 2*x(2), ..., u(n-1) = n*x(n).
 public static Variable diff(Model M, Variable x)
 {
   int n = (int)x.Size()-1;
   Variable u = M.Variable(n, Domain.Unbounded());
   Variable tmp = Variable.Reshape(x.Slice(1,n+1),new NDSet(1,n));    
   M.Constraint(Expr.Sub(u, Expr.MulElm(new DenseMatrix(1,n,Range(1.0,n+1)), tmp)), Domain.EqualsTo(0.0));
   return u;
 }
Example #19
0
        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();
          }
        }
Example #20
0
        /*
        Purpose:
            Computes the optimal portfolio for a given risk 
         
        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
         
        Output:
            Optimal expected return and the optimal portfolio     
        */ 
        public static double BasicMarkowitz
          ( int n,
            double[] mu,
            DenseMatrix GT,
            double[] x0,
            double   w,
            double   gamma)
        {
          
          using( Model M = new Model("Basic Markowitz"))
          {

            // Redirect log output from the solver to stdout for debugging. 
            // ifuncommented.
            //M.SetLogHandler(Console.Out);
          
            // Defines the variables (holdings). Shortselling is not allowed.
            Variable x = M.Variable("x", n, Domain.GreaterThan(0.0));
          
            //  Maximize expected return
            M.Objective("obj", ObjectiveSense.Maximize, Expr.Dot(mu,x));

            // The amount invested  must be identical to intial wealth
            M.Constraint("budget", Expr.Sum(x), 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());
            // Solves the model.
            M.Solve();

            return dot(mu,x.Level());
          }
        }
Example #21
0
        /*
            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();
          }
        }
Example #22
0
        /*
          Purpose:
              Computes several portfolios on the optimal portfolios by 

                  for alpha in alphas: 
                      maximize   expected return - alpha * standard deviation
                      subject to the constraints  
              
          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
              alphas: List of the alphas
                          
          Output:
              The efficient frontier as list of tuples (alpha,expected return,risk)
         */ 
        public static void EfficientFrontier
          ( int n,
            double[] mu,
            DenseMatrix GT,
            double[]    x0,
            double      w,
            double[]    alphas,
            
            double[]    frontier_mux,
            double[]    frontier_s)
        {
          using(Model M = new Model("Efficient frontier"))
          {
            //M.SetLogHandler(Console.Out);
       
            // Defines the variables (holdings). Shortselling is not allowed.
            Variable x = M.Variable("x", n, Domain.GreaterThan(0.0)); // Portfolio variables
            Variable s = M.Variable("s", 1, Domain.Unbounded()); // Risk variable

            M.Constraint("budget", Expr.Sum(x), Domain.EqualsTo(w+sum(x0)));

            // Computes the risk
            M.Constraint("risk", Expr.Vstack(s.AsExpr(),Expr.Mul(GT,x)),Domain.InQCone());

            for (int i = 0; i < alphas.Length; ++i)
            {
              //  Define objective as a weighted combination of return and risk
              M.Objective("obj", ObjectiveSense.Maximize, Expr.Sub(Expr.Dot(mu,x),Expr.Mul(alphas[i],s)));

              M.Solve();
             
              frontier_mux[i] = dot(mu,x.Level());
              frontier_s[i]   = s.Level()[0];
            }
          }
        }
Example #23
0
        // Models the cone of nonnegative polynomials on the finite interval [a,b]
        public static void nn_finite(Model M, Variable x, double a, double b)
        {
          //assert(a < b)
          int m = (int)x.Size()-1;
          int n = m/2;

          if (m == 2*n)
          {
            Variable X1 = M.Variable(Domain.InPSDCone(n+1));
            Variable X2 = M.Variable(Domain.InPSDCone(n));

            // x_i = Tr H(n,i)*X1 + (a+b)*Tr H(n-1,i-1) * X2 - a*b*Tr H(n-1,i)*X2 - Tr H(n-1,i-2)*X2, i=0,...,m
            for (int i = 0; i < m+1; ++i)
              M.Constraint( Expr.Sub(x.Index(i), 
                                     Expr.Add(Expr.Sub(Expr.Dot(Hankel(n, i,1.0),      X1), Expr.Dot(Hankel(n-1, i, a*b), X2)), 
                                              Expr.Sub(Expr.Dot(Hankel(n-1, i-1, a+b), X2), Expr.Dot(Hankel(n-1, i-2,1.0),  X2)))), 
                            Domain.EqualsTo(0.0) );
          }
          else
          {
            Variable X1 = M.Variable(Domain.InPSDCone(n+1));
            Variable X2 = M.Variable(Domain.InPSDCone(n+1));

            // x_i = Tr H(n,i-1)*X1 - a*Tr H(n,i)*X1 + b*Tr H(n,i)*X2 - Tr H(n,i-1)*X2, i=0,...,m
            for (int i = 0; i < m+1; ++i)
              M.Constraint( Expr.Sub(x.Index(i), 
                                     Expr.Add(Expr.Sub(Expr.Dot(Hankel(n, i-1,1.0),  X1), Expr.Dot(Hankel(n, i, a), X1)), 
                                              Expr.Sub(Expr.Dot(Hankel(n, i, b),     X2), Expr.Dot(Hankel(n, i-1,1.0),  X2)))), 
                            Domain.EqualsTo(0.0) );
          }
        }