public ClEditOrStayConstraint(ClVariable var, ClStrength strength, double weight) : base(strength, weight) { _variable = var; _expression = new ClLinearExpression(_variable, -1.0, _variable.Value); }
public ClLinearEquation(ClLinearExpression cle, ClAbstractVariable clv, ClStrength strength, double weight) : base((ClLinearExpression)cle.Clone(), strength, weight) { _expression.AddVariable(clv, -1.0); }
/// <summary> /// Add a stay of the given strength (default to ClStrength#Weak) /// of a variable to the tableau.. /// <param name="v"> /// Variable to add the stay constraint to. /// </param> /// </summary> public ClSimplexSolver AddStay(ClVariable v, ClStrength strength, double weight) /* throws ExClRequiredFailure, ExClInternalError */ { ClStayConstraint cn = new ClStayConstraint(v, strength, weight); return(AddConstraint(cn)); }
public ClLinearEquation(ClAbstractVariable clv, double val, ClStrength strength, double weight) : base(new ClLinearExpression(val), strength, weight) { _expression.AddVariable(clv, -1.0); }
/// <remarks> /// Default to weight 1.0. /// </remarks> public ClSimplexSolver AddStay(ClVariable v, ClStrength strength) /* throws ExClRequiredFailure, ExClInternalError */ { AddStay(v, strength, 1.0); return(this); }
public ClLinearInequality(ClLinearExpression cle1, byte op_enum, ClLinearExpression cle2, ClStrength strength) : this(cle1, op_enum, cle2, strength, 1.0) /* throws ExClInternalError */ { }
public ClLinearEquation(ClLinearExpression cle, ClAbstractVariable clv, ClStrength strength, double weight) : base((ClLinearExpression) cle.Clone(), strength, weight) { _expression.AddVariable(clv, -1.0); }
public ClLinearInequality(ClLinearExpression cle, byte op_enum, ClAbstractVariable clv, ClStrength strength) : this(cle, op_enum, clv, strength, 1.0) /* throws ExClInternalError */ { }
public ClLinearInequality(ClVariable clv1, byte op_enum, ClVariable clv2, ClStrength strength) : this(clv1, op_enum, clv2, strength, 1.0) /* throws ExClInternalError */ { }
public ClLinearEquation(ClLinearExpression cle1, ClLinearExpression cle2, ClStrength strength, double weight) : base((ClLinearExpression)cle1.Clone(), strength, weight) { _expression.AddExpression(cle2, -1.0); }
/// <summary> /// Add an edit constraint for a variable with a given strength. /// <param name="v">Variable to add an edit constraint to.</param> /// <param name="strength">Strength of the edit constraint.</param> /// </summary> private void AddEditVar(ClVariable v, ClStrength strength) { try { AddConstraint(new ClEditConstraint(v, strength)); } catch (CassowaryRequiredFailureException) { // should not get this throw new CassowaryInternalException("Required failure when adding an edit variable"); } }
public ClLinearInequality(ClVariable clv, byte op_enum, double val, ClStrength strength, double weight) : base(new ClLinearExpression(val), strength, weight) /* throws ExClInternalError */ { switch (op_enum) { case Cl.GEQ: _expression.MultiplyMe(-1.0); _expression.AddVariable(clv); break; case Cl.LEQ: _expression.AddVariable(clv, -1.0); break; default: // invalid operator throw new ExClInternalError("Invalid operator in ClLinearInequality constructor"); } }
public ClLinearInequality(ClLinearExpression cle1, byte op_enum, ClLinearExpression cle2, ClStrength strength, double weight) : base((ClLinearExpression)cle2.Clone(), strength, weight) /* throws ExClInternalError */ { switch (op_enum) { case Cl.GEQ: _expression.MultiplyMe(-1.0); _expression.AddExpression(cle1); break; case Cl.LEQ: _expression.AddExpression(cle1, -1.0); break; default: // invalid operator throw new ExClInternalError("Invalid operator in ClLinearInequality constructor"); } }
/// <summary> /// Add an edit constraint for a variable with a given strength. /// <param name="v">Variable to add an edit constraint to.</param> /// <param name="strength">Strength of the edit constraint.</param> /// </summary> public ClSimplexSolver AddEditVar(ClVariable v, ClStrength strength) /* throws ExClInternalError */ { try { ClEditConstraint cnEdit = new ClEditConstraint(v, strength); return AddConstraint(cnEdit); } catch (ExClRequiredFailure) { // should not get this throw new ExClInternalError("Required failure when adding an edit variable"); } }
public ClLinearEquation(ClLinearExpression cle1, ClLinearExpression cle2, ClStrength strength, double weight) : base((ClLinearExpression) cle1.Clone(), strength, weight) { _expression.AddExpression(cle2, -1.0); }
public static ClSimplexSolver AddConstraint(this ClSimplexSolver solver, ClAbstractVariable a, ClAbstractVariable b, ClAbstractVariable c, ClAbstractVariable d, Expression <Func <double, double, double, double, bool> > constraint, ClStrength strength = null) { Dictionary <string, ClAbstractVariable> variables = ConstructVariables(constraint.Parameters, a, b, c, d); return(AddConstraint(solver, variables, constraint.Body, strength)); }
private static ClSimplexSolver AddConstraint(this ClSimplexSolver solver, IEnumerable <ParameterExpression> parameters, Expression body, ClStrength strength) { Dictionary <string, ClAbstractVariable> variables = parameters.Select(a => solver.GetVariable(a.Name) ?? new ClVariable(a.Name)).ToDictionary(a => a.Name); return(AddConstraint(solver, variables, body, strength)); }
public ClLinearEquation(ClLinearExpression cle, ClStrength strength, double weight) : base(cle, strength, weight) {}
public ClLinearInequality(ClLinearExpression cle1, byte op_enum, ClLinearExpression cle2, ClStrength strength, double weight) : base((ClLinearExpression) cle2.Clone(), strength, weight) /* throws ExClInternalError */ { switch (op_enum) { case Cl.GEQ: _expression.MultiplyMe(-1.0); _expression.AddExpression(cle1); break; case Cl.LEQ: _expression.AddExpression(cle1, -1.0); break; default: // invalid operator throw new ExClInternalError("Invalid operator in ClLinearInequality constructor"); } }
public ClLinearInequality(ClLinearExpression cle, ClStrength strength, double weight) : base(cle, strength, weight) { }
public ClLinearInequality(ClVariable clv, byte op_enum, double val, ClStrength strength) : this(clv, op_enum, val, strength, 1.0) /* throws ExClInternalError */ {}
public ClStayConstraint(ClVariable var, ClStrength strength, double weight) : base(var, strength, weight) { }
public ClLinearInequality(ClLinearExpression cle, ClStrength strength) : base(cle, strength) {}
public ClLinearInequality(ClLinearExpression cle, ClStrength strength, double weight) : base(cle, strength, weight) {}
public ClLinearInequality(ClLinearExpression cle, byte op_enum, ClAbstractVariable clv, ClStrength strength) : this(cle, op_enum, clv, strength, 1.0) /* throws ExClInternalError */ {}
public ClLinearInequality(ClLinearExpression cle1, byte op_enum, ClLinearExpression cle2, ClStrength strength) : this(cle1, op_enum, cle2, strength, 1.0) /* throws ExClInternalError */ {}
/// <remarks> /// Default to weight 1.0. /// </remarks> public ClSimplexSolver AddStay(ClVariable v, ClStrength strength) /* throws ExClRequiredFailure, ExClInternalError */ { AddStay(v, strength, 1.0); return this; }
public static ClSimplexSolver AddConstraint(this ClSimplexSolver solver, Expression <Func <double, double, double, double, bool> > constraint, ClStrength strength = null) { return(AddConstraint(solver, constraint.Parameters, constraint.Body, strength)); }
public ClLinearConstraint(ClLinearExpression cle, ClStrength strength, double weight) : base(strength, weight) { _expression = cle; }
private static ClConstraint CreateEquality(IDictionary <string, ClAbstractVariable> variables, BinaryExpression expression, ClStrength strength) { return(new ClLinearEquation(CreateLinearExpression(variables, expression.Left), CreateLinearExpression(variables, expression.Right), strength)); }
public ClLinearConstraint(ClLinearExpression cle, ClStrength strength) : base(strength, 1.0) { _expression = cle; }
private static ClSimplexSolver AddConstraint(this ClSimplexSolver solver, IDictionary <string, ClAbstractVariable> variables, Expression body, ClStrength strength) { var constraints = FromExpression(variables, body, strength ?? _defaultStrength); foreach (var c in constraints) { solver.AddConstraint(c); } return(solver); }
public ClConstraint(ClStrength strength, double weight) { _strength = strength; _weight = weight; }
public ClLinearEquation(ClLinearExpression cle, ClStrength strength) : base(cle, strength) {}
public ClConstraint(ClStrength strength) { _strength = strength; _weight = 1.0; }
public ClLinearEquation(ClAbstractVariable clv, double val, ClStrength strength) : this(clv, val, strength, 1.0) {}
public ClEditOrStayConstraint(ClVariable var, ClStrength strength) : this(var, strength, 1.0) { }
public ClLinearEquation(ClLinearExpression cle, ClAbstractVariable clv, ClStrength strength) : this(cle, clv, strength, 1.0) {}
public ClLinearEquation(ClLinearExpression cle1, ClLinearExpression cle2, ClStrength strength) : this(cle1, cle2, strength, 1.0) {}
public ClEditConstraint(ClVariable clv, ClStrength strength, double weight) : base(clv, strength, weight) {}
/// <summary> /// Add a stay of the given strength (default to ClStrength#Weak) /// of a variable to the tableau.. /// <param name="v"> /// Variable to add the stay constraint to. /// </param> /// </summary> public ClSimplexSolver AddStay(ClVariable v, ClStrength strength, double weight) /* throws ExClRequiredFailure, ExClInternalError */ { ClStayConstraint cn = new ClStayConstraint(v, strength, weight); return AddConstraint(cn); }
public ClEditConstraint(ClVariable clv, ClStrength strength) : base(clv, strength) {}
private static ClLinearInequality CreateLinearInequality(IDictionary <string, ClAbstractVariable> variables, BinaryExpression expression, ClStrength strength) { Cl.Operator op; switch (expression.NodeType) { case ExpressionType.GreaterThan: op = Cl.Operator.GreaterThan; break; case ExpressionType.GreaterThanOrEqual: op = Cl.Operator.GreaterThanOrEqualTo; break; case ExpressionType.LessThan: op = Cl.Operator.LessThan; break; case ExpressionType.LessThanOrEqual: op = Cl.Operator.LessThanOrEqualTo; break; default: throw new NotSupportedException(string.Format("Unsupported linear inequality operator \"{0}\"", expression.NodeType)); } return(new ClLinearInequality(CreateLinearExpression(variables, expression.Left), op, CreateLinearExpression(variables, expression.Right), strength)); }
public ClLinearInequality(ClLinearExpression cle, ClStrength strength) : base(cle, strength) { }
private static IEnumerable <ClConstraint> FromExpression(IDictionary <string, ClAbstractVariable> variables, Expression expression, ClStrength strength) { switch (expression.NodeType) { case ExpressionType.AndAlso: case ExpressionType.And: { foreach (var c in FromExpression(variables, ((BinaryExpression)expression).Left, strength)) { yield return(c); } foreach (var c in FromExpression(variables, ((BinaryExpression)expression).Right, strength)) { yield return(c); } break; } case ExpressionType.Equal: { yield return(CreateEquality(variables, (BinaryExpression)expression, strength)); break; } case ExpressionType.LessThanOrEqual: case ExpressionType.GreaterThanOrEqual: case ExpressionType.LessThan: case ExpressionType.GreaterThan: { yield return(CreateLinearInequality(variables, (BinaryExpression)expression, strength)); break; } } }
public ClEditConstraint(ClVariable clv, ClStrength strength, double weight) : base(clv, strength, weight) { }
public ClStayConstraint(ClVariable var, ClStrength strength) : base(var, strength, 1.0) { }
public ClEditOrStayConstraint(ClVariable var, ClStrength strength) : this(var, strength, 1.0) {}
public ClEditConstraint(ClVariable clv, ClStrength strength) : base(clv, strength) { }