Ejemplo n.º 1
0
  private Constraint createAttributeConstraint(AttributeConstraint attributeConstraint) {
    Constraint result = null;

    Constraint constraint = null;
    AttributeOperand leftOperand = attributeConstraint.getLeftOperand();
    IntegerVariable leftOperandVariable = getVariableForAttributeOperand(leftOperand);

    AttributeOperand rightOperand = attributeConstraint.getRightOperand();
    IntegerVariable rightOperandVariable = getVariableForAttributeOperand(rightOperand);

    Relop operator = attributeConstraint.getOperator();
    switch (operator) {
      case EQUAL:
        constraint = Choco.eq(leftOperandVariable, rightOperandVariable);
        break;
      case GREATER_THAN:
        constraint = Choco.gt(leftOperandVariable, rightOperandVariable);
        break;
      case GREATER_THAN_OR_EQUAL:
        constraint = Choco.geq(leftOperandVariable, rightOperandVariable);
        break;
      case LESS_THAN:
        constraint = Choco.lt(leftOperandVariable, rightOperandVariable);
        break;
      case LESS_THAN_OR_EQUAL:
        constraint = Choco.leq(leftOperandVariable, rightOperandVariable);
        break;
      case UNEQUAL:
        constraint = Choco.neq(leftOperandVariable, rightOperandVariable);
        break;
      default:
        break;
    }

    IntegerVariable leftFeatureVariable = getFeatureVariableForOperand(leftOperand);
    IntegerVariable rightFeatureVariable = getFeatureVariableForOperand(rightOperand);
    // if both are features and both are selected, then the attribute constraint must be evaluated
    if (leftFeatureVariable != null && rightFeatureVariable != null) {
      Constraint leftFeatureSelected = Choco.eq(leftFeatureVariable, 1);
      Constraint rightFeatureSelected = Choco.eq(rightFeatureVariable, 1);
      Constraint and = Choco.and(leftFeatureSelected, rightFeatureSelected);
      result = Choco.implies(and, constraint);
    } else {
      // if one of the two operand is a constant,the constraint will be evaluated if the host
      // feature is selected
      if (leftFeatureVariable != null) {
        result = getFeatureAttributeValueConstraint(leftFeatureVariable, constraint);
      } else if (rightFeatureVariable != null) {
        result = getFeatureAttributeValueConstraint(rightFeatureVariable, constraint);
      }
    }

    return result;
  }
Ejemplo n.º 2
0
  public Constraint generateConstraint(
      ExpressionNode leftNode, ExpressionNode rightNode, InfixExpression.Operator operator) {
    IntegerExpressionVariable leftVariable = null, rightVariable = null;
    if (leftNode.getType() != ExpressionType.single_int) {
      leftVariable = constraintVariableModeling(leftNode);
    }
    if (rightNode.getType() != ExpressionType.single_int) {
      rightVariable = constraintVariableModeling(rightNode);
    }
    Constraint constraint = null;
    if (leftVariable != null && rightVariable != null) {
      if (operator.equals(InfixExpression.Operator.LESS)) {
        constraint = Choco.lt(leftVariable, rightVariable);
      } else if (operator.equals(InfixExpression.Operator.LESS_EQUALS)) {
        constraint = Choco.leq(leftVariable, rightVariable);
      } else if (operator.equals(InfixExpression.Operator.GREATER)) {
        constraint = Choco.gt(leftVariable, rightVariable);
      } else if (operator.equals(InfixExpression.Operator.GREATER_EQUALS)) {
        constraint = Choco.geq(leftVariable, rightVariable);
      } else if (operator.equals(InfixExpression.Operator.EQUALS)) {
        constraint = Choco.eq(leftVariable, rightVariable);
      } else if (operator.equals(InfixExpression.Operator.NOT_EQUALS)) {
        constraint = Choco.neq(leftVariable, rightVariable);
      } else {
        System.out.println("Constraint solver can't do with the operator: " + operator);
      }
    } else if (leftVariable != null && rightVariable == null) {
      int rightValue = Integer.parseInt(rightNode.getValue());
      if (operator.equals(InfixExpression.Operator.LESS)) {
        constraint = Choco.lt(leftVariable, rightValue);
      } else if (operator.equals(InfixExpression.Operator.LESS_EQUALS)) {
        constraint = Choco.leq(leftVariable, rightValue);
      } else if (operator.equals(InfixExpression.Operator.GREATER)) {
        constraint = Choco.gt(leftVariable, rightValue);
      } else if (operator.equals(InfixExpression.Operator.GREATER_EQUALS)) {
        constraint = Choco.geq(leftVariable, rightValue);
      } else if (operator.equals(InfixExpression.Operator.EQUALS)) {
        constraint = Choco.eq(leftVariable, rightValue);
      } else if (operator.equals(InfixExpression.Operator.NOT_EQUALS)) {
        constraint = Choco.neq(leftVariable, rightValue);
      } else {
        System.out.println("Constraint solver can't do with the operator: " + operator);
      }
    } else if (leftVariable == null && rightVariable != null) {
      int leftValue = Integer.parseInt(leftNode.getValue());
      if (operator.equals(InfixExpression.Operator.LESS)) {
        constraint = Choco.lt(leftValue, rightVariable);
      } else if (operator.equals(InfixExpression.Operator.LESS_EQUALS)) {
        constraint = Choco.leq(leftValue, rightVariable);
      } else if (operator.equals(InfixExpression.Operator.GREATER)) {
        constraint = Choco.gt(leftValue, rightVariable);
      } else if (operator.equals(InfixExpression.Operator.GREATER_EQUALS)) {
        constraint = Choco.geq(leftValue, rightVariable);
      } else if (operator.equals(InfixExpression.Operator.EQUALS)) {
        constraint = Choco.eq(leftValue, rightVariable);
      } else if (operator.equals(InfixExpression.Operator.NOT_EQUALS)) {
        constraint = Choco.neq(leftValue, rightVariable);
      } else {
        System.out.println("Constraint solver can't do with the operator: " + operator);
      }
    } else if (leftVariable == null && rightVariable == null) {
      int leftValue = Integer.parseInt(leftNode.getValue()),
          rightValue = Integer.parseInt(rightNode.getValue());
      boolean logicResult;
      Constraint
          falseConstraint =
              Choco.lt(Choco.makeIntVar("bigger", 5, 6), Choco.makeIntVar("smaller", 1, 2)),
          trueConstraint =
              Choco.gt(Choco.makeIntVar("bigger", 5, 6), Choco.makeIntVar("smaller", 1, 2));

      if (operator.equals(InfixExpression.Operator.LESS)) {
        if (leftValue < rightValue) {
          constraint = trueConstraint;
        } else {
          constraint = falseConstraint;
        }
      } else if (operator.equals(InfixExpression.Operator.LESS_EQUALS)) {
        if (leftValue <= rightValue) {
          constraint = trueConstraint;
        } else {
          constraint = falseConstraint;
        }
      } else if (operator.equals(InfixExpression.Operator.GREATER)) {
        if (leftValue > rightValue) {
          constraint = trueConstraint;
        } else {
          constraint = falseConstraint;
        }
      } else if (operator.equals(InfixExpression.Operator.GREATER_EQUALS)) {
        if (leftValue >= rightValue) {
          constraint = trueConstraint;
        } else {
          constraint = falseConstraint;
        }
      } else if (operator.equals(InfixExpression.Operator.EQUALS)) {
        if (leftValue == rightValue) {
          constraint = trueConstraint;
        } else {
          constraint = falseConstraint;
        }
      } else if (operator.equals(InfixExpression.Operator.NOT_EQUALS)) {
        if (leftValue != rightValue) {
          constraint = trueConstraint;
        } else {
          constraint = falseConstraint;
        }
      } else {
        System.out.println("Constraint solver can't do with the operator: " + operator);
      }
    }
    if (constraint == null) {
      System.out.println("can't solve this kind of constraint");
    }
    return constraint;
  }
Ejemplo n.º 3
0
 public Object lt(Object exp, int value) {
   return Choco.lt((IntegerExpressionVariable) exp, value);
 }
Ejemplo n.º 4
0
 public Object lt(Object exp1, Object exp2) {
   return Choco.lt((IntegerExpressionVariable) exp1, (IntegerExpressionVariable) exp2);
 }
Ejemplo n.º 5
0
 public Object lt(int value, Object exp) {
   return Choco.lt(value, (IntegerExpressionVariable) exp);
 }