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);
}
public ClEditOrStayConstraint(ClVariable var,
ClStrength strength,
double weight) : base(strength, weight)
{
_variable = var;
_expression = new ClLinearExpression(_variable, -1.0, _variable.Value);
}
/// <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);
}
public ClLinearEquation(ClAbstractVariable clv,
double val,
ClStrength strength,
double weight) : base(new ClLinearExpression(val), strength, weight)
{
_expression.AddVariable(clv, -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(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 ClLinearConstraint(ClLinearExpression cle,
ClStrength strength) : base(strength, 1.0)
{
_expression = cle;
}
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)
{}
public ClConstraint(ClStrength strength, double weight)
{
_strength = strength;
_weight = weight;
}
public ClConstraint(ClStrength strength)
{
_strength = strength;
_weight = 1.0;
}
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 ClLinearConstraint(ClLinearExpression cle,
ClStrength strength,
double weight) : base(strength, weight)
{
_expression = cle;
}
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)
{
}
