public void TestVariableInExpr()
{
AbstractExpr input = Polynomial.CreateNamedVariable("a").C + Polynomial.CreateNamedVariable("c");
var visitor = new RewritingVisitor(Polynomial.CreateNamedVariable("a"), Polynomial.CreateConstant(1));
IAbstractExpr result = input.Accept(visitor, Ig.nore);
Assert.AreEqual(Polynomial.CreateConstant(1).C + Polynomial.CreateNamedVariable("c"), result);
}
public void TestPolynomial()
{
var input = Polynomial.CreatePolynomial(Polynomial.CreateNamedVariable("a"), 1, 2, 3); // x²+2x+3
var visitor = new RewritingVisitor(Polynomial.CreateNamedVariable("a"), Polynomial.CreateConstant(2));
IAbstractExpr result = input.Accept(visitor, Ig.nore);
// lambda x.x²+2x+3 (2) = 4+4+3 = 11
Assert.AreEqual(Polynomial.CreateConstant(11), result);
}
private void ResolveBacksubstitutions()
{
//var foldingVisitor = new ConstantFoldingVisitor();
var foldingVisitor = new PolynomialFoldingVisitor();
// The "ToArrays" are necessary because we modify _closedVariables below. Without them,
// we get InvalidOperationExceptions telling us that the "Collection was modified."
var varsWithValue = ClosedVariables.Values.OfType<VariableWithValue>().ToArray();
var varsWithBacksubstitutions = ClosedVariables.Values.OfType<VariableWithBacksubstitution>().ToArray();
while (varsWithBacksubstitutions.Any()) {
if (!varsWithValue.Any()) {
Debug.WriteLine("---- No complete backsubstitution possible ----");
foreach (var vb in varsWithBacksubstitutions) {
Debug.WriteLine(vb);
}
throw new InvalidOperationException("No solution found - " +
"there are more variables to substitute, but still open substitutions");
}
var newVarsWithValue = new Dictionary<IVariable, VariableWithValue>();
foreach (var varWithValue in varsWithValue) {
var newVarsWithBacksubstitutions = new List<VariableWithBacksubstitution>();
// We substitute each variable into all open backsubstitutions.
//var rewriter = new RewritingVisitor(new Dictionary<IAbstractExpr, IAbstractExpr>
// { { varWithValue.Variable,
// Polynomial.CreateConstant(varWithValue.Value)
// } });
var rewriter = new RewritingVisitor(varWithValue.Variable,
Polynomial.CreateConstant(varWithValue.Value));
foreach (var varWithBacksub in varsWithBacksubstitutions) {
IAbstractExpr rewritten = varWithBacksub.Expr
.Accept(rewriter)
.Accept(foldingVisitor);
// If the result, after constant folding, is a constant, we have found a new solution value.
// Otherwise, we still have a - maybe smaller - backsubstitution for this variable.
if (rewritten is IConstant) {
var result = new VariableWithValue(varWithBacksub.Variable, ((IConstant)rewritten).Value);
newVarsWithValue.Add(varWithBacksub.Variable, result);
ClosedVariables[varWithBacksub.Variable] = result;
} else {
var result = new VariableWithBacksubstitution(varWithBacksub.Variable, rewritten);
newVarsWithBacksubstitutions.Add(result);
}
}
newVarsWithBacksubstitutions.RemoveAll(v => ClosedVariables.ContainsKey(v.Variable) && ClosedVariables[v.Variable] is VariableWithValue);
varsWithBacksubstitutions = newVarsWithBacksubstitutions.ToArray();
}
varsWithValue = newVarsWithValue.Values.ToArray();
}
}
private SolverNode CloseVariable(IVariable variable,
IAbstractExpr expression,
AbstractConstraint sourceConstraintToBeRemoved)
{
//var foldingVisitor = new ConstantFoldingVisitor();
var foldingVisitor = new PolynomialFoldingVisitor();
expression = expression.Accept(foldingVisitor);
// Rewrite all constraints
//var rewriter = new RewritingVisitor(
// new Dictionary<IAbstractExpr, IAbstractExpr> { { variable, expression } });
var rewriter = new RewritingVisitor(variable, expression);
IEnumerable<AbstractConstraint> rewrittenConstraints =
Constraints.Except(sourceConstraintToBeRemoved)
.Select(c => c.Accept(rewriter, Ig.nore));
// Create new variable->value knowledge or new backsubstition.
var newBacksubstitutions = new Dictionary<IVariable, AbstractClosedVariable>(ClosedVariables) {{
variable, expression is IConstant
? (AbstractClosedVariable)
new VariableWithValue(variable, ((IConstant) expression).Value)
: new VariableWithBacksubstitution(variable, expression)
}};
// Create new node.
return new SolverNode(rewrittenConstraints, newBacksubstitutions, this);
}
