Esempio n. 1
0
        private bool ReviseRight(VariableNode leftNode, VariableNode rightNode, BinaryConstraintExpression expression)
        {
            var leftDomainRange     = leftNode.Variable.Domain;
            var rightDomainRange    = rightNode.Variable.Domain;
            var valueEvaluator      = new RightValueEvaluator(leftDomainRange.PossibleValues, expression);
            var valuesToRemove      = new List <int>();
            var expressionEvaluator = new ExpressionEvaluator();

            foreach (var possibleValue in rightDomainRange.PossibleValues)
            {
                var evaluatedPossibleValue = expressionEvaluator.Evaluate(expression.Node.InnerExpression.RightExpression, possibleValue);
                if (!valueEvaluator.EvaluateRight(evaluatedPossibleValue))
                {
                    valuesToRemove.Add(possibleValue);
                }
            }

            rightDomainRange.RemoveAll(valuesToRemove);

            return(valuesToRemove.Any());
        }
Esempio n. 2
0
        private bool ReviseLeft(VariableNode leftNode, VariableNode rightNode, BinaryConstraintExpression expression)
        {
            var leftDomainRange = leftNode.Variable.Domain;
            IReadOnlyCollection <int> rightPossibleValues;

            if (!expression.Node.InnerExpression.RightExpression.IsLiteral)
            {
                rightPossibleValues = rightNode.Variable.Domain.PossibleValues;
            }
            else
            {
                var lhsVariable = _modelSolverMap.GetModelVariableByName(leftNode.Variable.Name);
                var range       = _valueMapper.GetDomainValueFor(lhsVariable);
                var modelValue  = expression.Node.InnerExpression.RightExpression.GetLiteral();
                var solverValue = range.MapTo(modelValue);
                rightPossibleValues = new ReadOnlyCollection <int>(new List <int> {
                    solverValue
                });
            }

            var valueEvaluator      = new LeftValueEvaluator(rightPossibleValues, expression);
            var valuesToRemove      = new List <int>();
            var expressionEvaluator = new ExpressionEvaluator();

            foreach (var possibleValue in leftDomainRange.PossibleValues)
            {
                var evaluatedPossibleValue = expressionEvaluator.Evaluate(expression.Node.InnerExpression.LeftExpression, possibleValue);
                if (!valueEvaluator.EvaluateLeft(evaluatedPossibleValue))
                {
                    valuesToRemove.Add(possibleValue);
                }
            }

            leftDomainRange.RemoveAll(valuesToRemove);

            return(valuesToRemove.Any());
        }
Esempio n. 3
0
 private NodeConnector CreateConnectorFrom(Node left, Node right, BinaryConstraintExpression constraint)
 {
     return(new ConstraintExpressionConnector(left, right, constraint));
 }
Esempio n. 4
0
 internal RightValueEvaluator(IReadOnlyCollection <int> leftPossibleValues, BinaryConstraintExpression constraint)
 {
     _leftPossibleValues = leftPossibleValues;
     _expression         = constraint;
 }
Esempio n. 5
0
 internal LeftValueEvaluator(IReadOnlyCollection <int> rightPossibleValues, BinaryConstraintExpression constraint)
 {
     _rightPossibleValues = rightPossibleValues;
     _expression          = constraint;
 }