// Model logistic regression (regularized with full 2-norm of theta) // X - n x d matrix of data points // y - length n vector classifying training points // lamb - regularization parameter public static Model logisticRegression(double[,] X, bool[] y, double lamb) { int n = X.GetLength(0); int d = X.GetLength(1); // num samples, dimension Model M = new Model(); Variable theta = M.Variable("theta", d); Variable t = M.Variable(n); Variable reg = M.Variable(); M.Objective(ObjectiveSense.Minimize, Expr.Add(Expr.Sum(t), Expr.Mul(lamb, reg))); M.Constraint(Var.Vstack(reg, theta), Domain.InQCone()); double[] signs = new double[n]; for (int i = 0; i < n; i++) { if (y[i]) { signs[i] = -1; } else { signs[i] = 1; } } softplus(M, t, Expr.MulElm(Expr.Mul(X, theta), signs)); return(M); }
/// <summary> /// Expands the foreach loop if it iterates over a numeric range. /// </summary> private NodeBase expandRange(Context ctx) { var signVar = ctx.Scope.DeclareImplicit(ctx, _VariableType, false); var idxVar = ctx.Scope.DeclareImplicit(ctx, _VariableType, false); return(Expr.Block( Expr.Set(idxVar, RangeStart), Expr.Set( signVar, Expr.Invoke( "Math", "Sign", Expr.Sub(RangeEnd, Expr.Get(idxVar)) ) ), Expr.While( Expr.NotEqual(Expr.Get(idxVar), RangeEnd), Expr.Block( getIndexAssignment(Expr.Get(idxVar)), Body, Expr.Set( idxVar, Expr.Add( Expr.Get(idxVar), Expr.Get(signVar) ) ) ) ) )); }
public void ConstantDeclaration() { var src = @"let v = 1 + 1"; var result = Expr.Let("v", Expr.Add(Expr.Int(1), Expr.Int(1))); TestParser(src, result); }
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 void OperatorPriority2() { var src = "1 + 2 - 3 * 4 / 5 % 6 ** 7"; var result = Expr.Sub( Expr.Add( Expr.Int(1), Expr.Int(2) ), Expr.Mod( Expr.Div( Expr.Mult( Expr.Int(3), Expr.Int(4) ), Expr.Int(5) ), Expr.Pow( Expr.Int(6), Expr.Int(7) ) ) ); TestParser(src, result); }
/// <summary> /// Expands the foreach loop if it iterates over T[]. /// </summary> private NodeBase expandArray(Context ctx) { var arrayVar = ctx.Scope.DeclareImplicit(ctx, IterableExpression.Resolve(ctx), false); var idxVar = ctx.Scope.DeclareImplicit(ctx, typeof(int), false); var lenVar = ctx.Scope.DeclareImplicit(ctx, typeof(int), false); return(Expr.Block( Expr.Set(idxVar, Expr.Int(0)), Expr.Set(arrayVar, IterableExpression), Expr.Set(lenVar, Expr.GetMember(Expr.Get(arrayVar), "Length")), Expr.While( Expr.Less( Expr.Get(idxVar), Expr.Get(lenVar) ), Expr.Block( getIndexAssignment( Expr.GetIdx( Expr.Get(arrayVar), Expr.Get(idxVar) ) ), Expr.Set( idxVar, Expr.Add(Expr.Get(idxVar), Expr.Int(1)) ), Body ) ) )); }
// 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.GetSize() - 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)); } } }
public void Algebraic2() { var src = @" type TestType Small of int Large of int var a = new Small 1 var b = new Large 100 a.Tag + b.Tag"; var result = new NodeBase[] { Expr.Type( "TestType", Expr.Label("Small", "int"), Expr.Label("Large", "int") ), Expr.Var("a", Expr.New("Small", Expr.Int(1))), Expr.Var("b", Expr.New("Large", Expr.Int(100))), Expr.Add( Expr.GetMember(Expr.Get("a"), "Tag"), Expr.GetMember(Expr.Get("b"), "Tag") ) }; TestParser(src, result); }
public static void Main(string[] args) { using (Model M = new Model("FacilityLocation")) { // Variable holding the facility location Variable f = M.Variable("facility", Set.Make(1, 2), Domain.Unbounded()); // Variable defining the euclidian distances to each customer Variable d = M.Variable("dist", Set.Make(N, 1), Domain.GreaterThan(0.0)); // Variable defining the x and y differences to each customer; Variable t = M.Variable("t", Set.Make(N, 2), Domain.Unbounded()); M.Constraint("dist measure", Var.Hstack(new Variable[] { d, t }), Domain.InQCone(N, 3)); Variable fxy = Var.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(); M.WriteTask("facility_location.task"); double[] floc = f.Level(); Console.WriteLine("Facility location = {0},{1}", floc[0], floc[1]); } }
public void VariableDeclaration() { var src = @"var v = 1 + 1"; var result = Expr.Var("v", Expr.Add(Expr.Int(1), Expr.Int(1))); TestParser(src, result); }
public void ParseTest() { AssertExpr(Expr.Constant(0.5), Parser.Parse("0.5")); AssertExpr(Expr.Constant(1.0), Parser.Parse("(((((1)))))")); AssertExpr(Expr.UnaryPlus(Expr.Constant(1.0)), Parser.Parse("+1")); AssertExpr(Expr.Negate(Expr.UnaryPlus(Expr.UnaryPlus(Expr.Constant(0.5)))), Parser.Parse("-++0.5")); AssertExpr(Expr.Add(Expr.Constant(1.0), Expr.Constant(2.0)), Parser.Parse("1+2")); AssertExpr(Expr.Add( Expr.Constant(1.0), Expr.Add( Expr.Constant(2.0), Expr.Add( Expr.Constant(3.0), Expr.Constant(4.0)))), Parser.Parse("1+2+3+4")); AssertExpr(Expr.Multiply(Expr.Constant(1.0), Expr.Constant(2.0)), Parser.Parse("1*2")); AssertExpr(Expr.Add( Expr.Constant(1.0), Expr.Multiply( Expr.Constant(2.0), Expr.Constant(3.0))), Parser.Parse("1+2*3")); AssertExpr(Expr.Multiply( Expr.Add( Expr.Constant(1.0), Expr.Constant(2.0)), Expr.Constant(3.0)), Parser.Parse("(1+2)*3")); AssertExpr(Expr.Function("do", new Expr[] { }), Parser.Parse("do()")); AssertExpr(Expr.Add( Expr.Constant(1.0), Expr.Function("PI", new Expr[] { })), Parser.Parse("1 + PI()")); AssertExpr(Expr.Function("print", new Expr[] { Expr.Function("plus", new Expr[] { Expr.Constant(1.0), Expr.Constant(1.0) }) }), Parser.Parse("print(plus(1, 1))")); }
//TAG:begin-nearestcorr-nucnorm-code public static void nearestcorr_nn(Matrix A, double[] gammas, double[] res, int[] rank) { int N = A.NumRows(); using (var M = new Model("NucNorm")) { // Setup variables var t = M.Variable("t", 1, Domain.Unbounded()); var X = M.Variable("X", Domain.InPSDCone(N)); var w = M.Variable("w", N, Domain.GreaterThan(0.0)); // (t, vec (X + diag(w) - A)) in Q var D = Expr.MulElm(Matrix.Eye(N), Var.Repeat(w, 1, N)); M.Constraint(Expr.Vstack(t, Vec(Expr.Sub(Expr.Add(X, D), A))), Domain.InQCone()); //M.SetLogHandler(Console.Out); var d = new double[N]; for (var k = 0; k < gammas.Length; ++k) { // Objective: Minimize t + gamma*Tr(X) var gamm_trX = Expr.Mul(gammas[k], Expr.Sum(X.Diag())); M.Objective(ObjectiveSense.Minimize, Expr.Add(t, gamm_trX)); M.Solve(); var Xl = X.Level(); var wl = w.Level(); var r_sqr = 0.0; for (var j = 0; j < N; ++j) { for (var i = j + 1; i < N; ++i) { r_sqr += 2 * (A.Get(j, i) - Xl[i + j * N]) * (A.Get(j, i) - Xl[i + j * N]); } } for (var i = 0; i < N; ++i) { r_sqr += (A.Get(i, i) - Xl[i + i * N] - wl[i]) * (A.Get(i, i) - Xl[i + i * N] - wl[i]); } mosek.LinAlg.syeig(mosek.uplo.lo, N, X.Level(), d); var rnk = 0; foreach (var v in d) { if (v > 1e-6) { ++rnk; } } res[k] = Math.Sqrt(r_sqr); rank[k] = rnk; } } }
/* * 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, double[,] 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")) { //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.Binary()); // 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(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,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(); return(x.Level()); } }
public void ExpressionResultShouldBeSixDueToMultiplicationOperationPriority() { // Arrange var tokenParser = makeTokenParser(Language.JavaStyle); var reservedOp = tokenParser.ReservedOp; // Natural parser var natural = from n in tokenParser.Natural select Expr.Natural(n); // Binary operator expression factory Func <Expr, Expr, Expr> binaryOp(string op) => (Expr lhs, Expr rhs) => op == "+" ? Expr.Add(lhs, rhs) : op == "-" ? Expr.Sub(lhs, rhs) : op == "/" ? Expr.Div(lhs, rhs) : op == "*" ? Expr.Mul(lhs, rhs) : throw new NotSupportedException(); // Binary operator parser builder Operator <Expr> binary(string op, Assoc assoc) => Operator.Infix(assoc, from x in reservedOp(op) select binaryOp(op)); // Operator table Operator <Expr>[][] table = { new[] { binary("+", Assoc.Left), binary("-", Assoc.Left) }, new[] { binary("*", Assoc.Left), binary("/", Assoc.Left) } }; // Null because it will be not null later and can be used by the lazyp parser Parser <Expr> expr = null; // Build up the expression term var term = either( attempt(natural), tokenParser.Parens(lazyp(() => expr))); // Build the expression parser expr = buildExpressionParser(table, term).label("expression"); var expression = "2 + 2 * 2"; var exprectedResult = 6; // Act var actualResult = parse(expr, expression) .ToOption() .Map(ex => ex.Eval()) .IfNone(0); // Assert Assert.Equal(exprectedResult, actualResult); }
private Expr ComputeExpr(Expr ptrExpr, Expr access) { Expr result = null; if (access is NAryExpr) { var a = (access as NAryExpr).Args[1]; if (ptrExpr is NAryExpr) { var ptr = ptrExpr as NAryExpr; if (!(ptr.Args[1] is LiteralExpr) || !(a is LiteralExpr)) { return(result); } int l = (ptr.Args[1] as LiteralExpr).asBigNum.ToInt; int r = (a as LiteralExpr).asBigNum.ToInt; if (ptr.Fun.FunctionName == "$add" || ptr.Fun.FunctionName == "+") { if ((access as NAryExpr).Fun.FunctionName == "$add" || (access as NAryExpr).Fun.FunctionName == "+") { result = Expr.Add(ptr.Args[0], new LiteralExpr(Token.NoToken, BigNum.FromInt(l + r))); } } } else if (ptrExpr is IdentifierExpr) { if (this.AC.GetNumOfEntryPointRelatedFunctions(this.EP.Name) > WhoopCommandLineOptions.Get().EntryPointFunctionCallComplexity) { return(result); } var ptr = ptrExpr as IdentifierExpr; if (!ptr.Type.IsInt) { return(result); } if ((access as NAryExpr).Fun.FunctionName == "$add" || (access as NAryExpr).Fun.FunctionName == "+") { result = Expr.Add(ptr, new LiteralExpr(Token.NoToken, (a as LiteralExpr).asBigNum)); } } } else { result = ptrExpr; } return(result); }
/* * 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); } } }
public void SetDynamicMember2() { var src = "(1 + 2).someShit = a"; var result = Expr.SetMember( Expr.Add(Expr.Int(1), Expr.Int(2)), "someShit", Expr.Get("a") ); TestParser(src, result); }
public void ArrayDeclaration() { var src = @"new [1; 2; 1 + 2]"; var result = Expr.Array( Expr.Int(1), Expr.Int(2), Expr.Add(Expr.Int(1), Expr.Int(2)) ); TestParser(src, result); }
// t >= log( 1 + exp(u) ) coordinatewise public static void softplus(Model M, Expression t, Expression u) { int n = t.GetShape()[0]; Variable z1 = M.Variable(n); Variable z2 = M.Variable(n); M.Constraint(Expr.Add(z1, z2), Domain.EqualsTo(1)); M.Constraint(Expr.Hstack(z1, Expr.ConstTerm(n, 1.0), Expr.Sub(u, t)), Domain.InPExpCone()); M.Constraint(Expr.Hstack(z2, Expr.ConstTerm(n, 1.0), Expr.Neg(t)), Domain.InPExpCone()); }
public void InvocationTestParser() { var result = Expr.Invoke( Expr.Get("sqrt"), Expr.Add( Expr.Get("sq1"), Expr.Get("sq2") ) ); TestParser("sqrt (sq1 + sq2)", result); }
public void Should_iterate_n_times() { var loc = Expr.LocalVariable(typeof(int), "i"); var func = CreateFunc <int, int>( Expr.DeclareLocal(loc, Expr.Constant(0)), Expr.Loop(Expr.IfThenElse( Expr.Equal(Expr.ReadLocal(loc), Expr.Parameter(0, typeof(int))), Expr.LoopBreak(), Expr.WriteLocal(loc, Expr.Add(Expr.ReadLocal(loc), Expr.Constant(1))))), Expr.Return(Expr.ReadLocal(loc))); Assert.That(func(5), Is.EqualTo(5)); }
// Models log(sum(exp(Ax+b))) <= 0. // Each row of [A b] describes one of the exp-terms public static void logsumexp(Model M, double[,] A, Variable x, double[] b) { int k = A.GetLength(0); Variable u = M.Variable(k); M.Constraint(Expr.Sum(u), Domain.EqualsTo(1.0)); M.Constraint(Expr.Hstack(u, Expr.ConstTerm(k, 1.0), Expr.Add(Expr.Mul(A, x), b)), Domain.InPExpCone()); }
public void SimpleAdd() { var constant = new LiteralExpr(Token.NoToken, BigNum.FromInt(18)); // Integer var constant2 = new LiteralExpr(Token.NoToken, BigNum.FromInt(19)); // Integer var add = Expr.Add(constant, constant2); var add2 = Expr.Add(constant, constant2); Assert.AreNotSame(constant, constant2); // These are different references Assert.AreNotSame(add, add2); // These are different references Assert.IsTrue(add.Equals(add2)); // These are "structurally equal" Assert.AreEqual(add.GetHashCode(), add2.GetHashCode()); // If the .Equals() is true then hash codes must be the same }
public void Should_allow_break_in_catch_block() { var loc = Expr.LocalVariable(typeof(int), "i"); var func = CreateFunc <int>( Expr.WriteLocal(loc, Expr.Constant(0)), Expr.Loop(Expr.TryCatch( Expr.Block( Expr.WriteLocal(loc, Expr.Add(Expr.ReadLocal(loc), Expr.Constant(1))), Expr.Throw(Expr.New(typeof(Exception)))), new CatchBlock(Expr.LoopBreak()))), Expr.Return(Expr.ReadLocal(loc))); Assert.That(func(), Is.EqualTo(2)); }
public static Expr ComputeLiteralsInExpr(Expr expr) { if (!(expr is NAryExpr) || !((expr as NAryExpr).Args[0] is NAryExpr)) { return(expr); } int l1 = ((expr as NAryExpr).Args[1] as LiteralExpr).asBigNum.ToInt; int l2 = (((expr as NAryExpr).Args[0] as NAryExpr).Args[1] as LiteralExpr).asBigNum.ToInt; Expr result = ((expr as NAryExpr).Args[0] as NAryExpr).Args[0]; return(Expr.Add(result, new LiteralExpr(Token.NoToken, BigNum.FromInt(l1 + l2)))); }
public static void Main(string[] args) { // Sample data in sparse, symmetric triplet format int[] C1_k = { 0, 2 }; int[] C1_l = { 0, 2 }; double[] C1_v = { 1, 6 }; int[] A1_k = { 0, 2, 0, 2 }; int[] A1_l = { 0, 0, 2, 2 }; double[] A1_v = { 1, 1, 1, 2 }; int[] C2_k = { 0, 1, 0, 1, 2 }; int[] C2_l = { 0, 0, 1, 1, 2 }; double[] C2_v = { 1, -3, -3, 2, 1 }; int[] A2_k = { 1, 0, 1, 3 }; int[] A2_l = { 0, 1, 1, 3 }; double[] A2_v = { 1, 1, -1, -3 }; double b = 23; double k = -3; // Convert input data into Fusion sparse matrices Matrix C1 = Matrix.Sparse(3, 3, C1_k, C1_l, C1_v); Matrix C2 = Matrix.Sparse(4, 4, C2_k, C2_l, C2_v); Matrix A1 = Matrix.Sparse(3, 3, A1_k, A1_l, A1_v); Matrix A2 = Matrix.Sparse(4, 4, A2_k, A2_l, A2_v); using (Model M = new Model("sdo2")) { // Two semidefinite variables Variable X1 = M.Variable(Domain.InPSDCone(3)); Variable X2 = M.Variable(Domain.InPSDCone(4)); // Objective M.Objective(ObjectiveSense.Minimize, Expr.Add(Expr.Dot(C1, X1), Expr.Dot(C2, X2))); // Equality constraint M.Constraint(Expr.Add(Expr.Dot(A1, X1), Expr.Dot(A2, X2)), Domain.EqualsTo(b)); // Inequality constraint M.Constraint(X2.Index(new int[] { 0, 1 }), Domain.LessThan(k)); // Solve M.SetLogHandler(Console.Out); M.Solve(); // Print solution Console.WriteLine("Solution (vectorized):"); Console.WriteLine("[{0}]", (new Utils.StringBuffer()).A(X1.Level()).ToString()); Console.WriteLine("[{0}]", (new Utils.StringBuffer()).A(X2.Level()).ToString()); } }
public static Expr increment(Variable v1) { if (useIntArithmetic) { return(Expr.Add(Expr.Ident(v1), Expr.Literal(1))); } else { var args = new List <Expr>(); args.Add(Expr.Ident(v1)); args.Add(new LiteralExpr(Token.NoToken, Microsoft.BaseTypes.BigNum.FromInt(1), 32)); return(new NAryExpr(Token.NoToken, new FunctionCall(getBvAdd()), args)); } }
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 = Matrix.Dense(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()); } }
public void PureFunction() { var src = @"pure fun add:int (x:int y:int) -> x + y"; var result = Expr.Fun( "add", "int", true, new[] { Expr.Arg("x", "int"), Expr.Arg("y", "int") }, Expr.Add( Expr.Get("x"), Expr.Get("y") ) ); TestParser(src, result); }
/* * 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, double[,] 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)); // Variables computing market impact Variable t = M.Variable("t", 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(gamma, Expr.Mul(GT, x)), Domain.InQCone()); // t >= |x-x0|^1.5 using a power cone M.Constraint("tz", Expr.Hstack(t, Expr.ConstTerm(n, 1.0), Expr.Sub(x, x0)), Domain.InPPowerCone(2.0 / 3.0)); M.Solve(); if (xsol != null) { Array.Copy(x.Level(), xsol, n); } if (tsol != null) { Array.Copy(t.Level(), tsol, n); } } }