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);
}
public void TestManyMinuses()
{
UnaryExpression a = new UnaryExpression(Polynomial.CreateNamedVariable("x"), new Sin());
AbstractExpr b = a.C * a; //new UnaryExpression(a, new Square());
IAbstractExpr[] exprs = new IAbstractExpr[] {
a,
b,
new UnaryExpression(Polynomial.CreateNamedVariable("x"), new FormalSquareroot()),
new UnaryExpression(Polynomial.CreateNamedVariable("x"), new PositiveSquareroot()),
-a,
a + b,
a * b,
a / b
};
IAbstractExpr[] exprs2 = exprs;
var foldingVisitor = new PolynomialFoldingVisitor();
for (int i = 0; i < 4; i++) {
exprs2 = exprs2.Select(e => -(-e.C).C).ToArray();
for (int j = 0; j < exprs.Length; j++) {
Assert.AreEqual(exprs[j], exprs2[j].Accept(foldingVisitor, Ig.nore));
//Assert.AreEqual(exprs[j], exprs2[j].Accept(foldingVisitor, 0));
}
}
}
public VariableWithBacksubstitution(IVariable variable, IAbstractExpr expr)
: base(variable)
{
Expr = expr;
}
private static void TestManyMinuses(IAbstractExpr a)
{
IAbstractExpr b = a;
var foldingVisitor = new PolynomialFoldingVisitor();
for (int i = 0; i < 4; i++) {
b = -(-b.C);
Assert.AreEqual(a, b.Accept(foldingVisitor, Ig.nore));
}
}
private IAbstractExpr Fold(IAbstractExpr expr)
{
return expr.Accept(new PolynomialFoldingVisitor(), Ig.nore);
//return expr.Accept(new PolynomialFoldingVisitor(), 0);
}
private EqualsZeroConstraint CreateEqualsZero(IAbstractExpr lhs, IAbstractExpr rhs)
{
return new EqualsZeroConstraint(BinaryScalarOperator.MINUS.CreateSolverExpression(lhs, rhs));
}
public IAbstractExpr[] CreateSolverExpressions(IAbstractExpr[] lhsExpr, IAbstractExpr rhsExpr)
{
return _create(lhsExpr, rhsExpr);
}
public IAbstractExpr CreateSolverExpression(IAbstractExpr[] innerExpr)
{
return _create(innerExpr);
}
private static IAbstractExpr Times(IAbstractExpr[] lhsExpr, IAbstractExpr[] rhsExpr)
{
var x = BinaryScalarOperator.TIMES.CreateSolverExpression(lhsExpr[0], rhsExpr[0]);
var y = BinaryScalarOperator.TIMES.CreateSolverExpression(lhsExpr[1], rhsExpr[1]);
var z = BinaryScalarOperator.TIMES.CreateSolverExpression(lhsExpr[2], rhsExpr[2]);
return BinaryScalarOperator.PLUS.CreateSolverExpression(x,
BinaryScalarOperator.PLUS.CreateSolverExpression(y, z));
}
private static IAbstractExpr Angle(IAbstractExpr[] lhsExpr, IAbstractExpr[] rhsExpr)
{
return BinaryScalarOperator.DIVIDE.CreateSolverExpression(
Times(lhsExpr, rhsExpr),
BinaryScalarOperator.TIMES.CreateSolverExpression(
UnaryVectorScalarOperator.LENGTH.CreateSolverExpression(lhsExpr),
UnaryVectorScalarOperator.LENGTH.CreateSolverExpression(rhsExpr))
);
}
private static IAbstractExpr[] Times(IAbstractExpr[] lhsExpr, IAbstractExpr rhsExpr)
{
return new[] {
BinaryScalarOperator.TIMES.CreateSolverExpression(lhsExpr[0], rhsExpr),
BinaryScalarOperator.TIMES.CreateSolverExpression(lhsExpr[1], rhsExpr),
BinaryScalarOperator.TIMES.CreateSolverExpression(lhsExpr[2], rhsExpr),
};
}
private static IAbstractExpr[] Rotate2D(IAbstractExpr[] lhsExpr, IAbstractExpr rhsExpr)
{
// X = x cos phi - y sin phi
// Y = x sin phi + y cos phi
// Z = z
var sin = new UnaryExpression(rhsExpr, new Sin());
var cos = new UnaryExpression(rhsExpr, new Cos());
var a11 = BinaryScalarOperator.TIMES.CreateSolverExpression(lhsExpr[0], cos);
var a12 = BinaryScalarOperator.TIMES.CreateSolverExpression(lhsExpr[1], sin);
var a21 = BinaryScalarOperator.TIMES.CreateSolverExpression(lhsExpr[0], sin);
var a22 = BinaryScalarOperator.TIMES.CreateSolverExpression(lhsExpr[1], cos);
return new[] {
BinaryScalarOperator.MINUS.CreateSolverExpression(a11, a12),
BinaryScalarOperator.PLUS.CreateSolverExpression(a21, a22),
lhsExpr[2]
};
}
