EqualToSum.java

  1. /* Copyright 2015 Laurent COCAULT
  2.  * Licensed to Laurent COCAULT under one or more contributor license agreements.
  3.  * See the NOTICE file distributed with this work for additional information
  4.  * regarding copyright ownership. Laurent COCAULT licenses this file to You
  5.  * under the Apache License, Version 2.0 (the "License"); you may not use this
  6.  * file except in compliance with the License.  You may obtain a copy of the
  7.  * License at
  8.  *
  9.  *   http://www.apache.org/licenses/LICENSE-2.0
  10.  *
  11.  * Unless required by applicable law or agreed to in writing, software
  12.  * distributed under the License is distributed on an "AS IS" BASIS,
  13.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14.  * See the License for the specific language governing permissions and
  15.  * limitations under the License.
  16.  */
  17. package org.csp.constraint.model.integer;

  19. import org.csp.constraint.model.TernaryConstraint;

  21. /**
  22.  * Constraint specifying that one specific integer variable is the sum of two
  23.  * other integer variables.
  24.  */
  25. public class EqualToSum extends TernaryConstraint<IntValue> {

  27.     /**
  28.      * Constructor of the constraint "FIRST + SECOND = SUM".
  29.      * @param first
  30.      *            First variable
  31.      * @param second
  32.      *            Second variable
  33.      * @param sum
  34.      *            Sum of the two other variables
  35.      */
  36.     public EqualToSum(final IntVar first, final IntVar second, final IntVar sum) {
  37.         super(first.getName() + "+" + second.getName() + "=" + sum.getName(),
  38.                 first, second, sum);
  39.     }

  41.     /**
  42.      * {@inheritDoc}
  43.      */
  44.     @Override
  45.     public void propagate() {

  47.         // The sum minimum is the sum of the other variables minimum and the
  48.         // sum maximum is the sum of the other variables maximum.
  49.         final IntValue sumMin = IntValue.sum(getFirst().getMinValue(),
  50.                 getSecond().getMinValue());
  51.         final boolean sumMinChanged = getSum().reduceWithMinValue(sumMin);
  52.         final IntValue sumMax = IntValue.sum(getFirst().getMaxValue(),
  53.                 getSecond().getMaxValue());
  54.         final boolean sumMaxChanged = getSum().reduceWithMaxValue(sumMax);
  55.         if (sumMaxChanged || sumMinChanged) {
  56.             addRecentChangedVariable(getSum());
  57.         }

  59.         // Propagate the constraint on the first variable
  60.         propagateOnArgument(getFirst(), getSecond(), getSum());

  62.         // Propagate the constraint on the second variable
  63.         propagateOnArgument(getSecond(), getFirst(), getSum());
  64.     }

  66.     /**
  67.      * Propagate the constraint on an argument. The propagation algorithm is the
  68.      * same on the first or the second argument of the constraint: the current
  69.      * method is therefore applied twice with a permutation of the variables.
  70.      * @param argument
  71.      *            Argument on which to propagate the constraint
  72.      * @param other
  73.      *            Other argument in the sum
  74.      * @param sum
  75.      *            Sum of the two arguments
  76.      */
  77.     private void propagateOnArgument(final IntVar argument, final IntVar other,
  78.             final IntVar sum) {

  80.         // The argument maximum shall not be greater than the difference between
  81.         // the "sum" maximum and the "other" minimum.
  82.         final IntValue newMax = IntValue.diff(sum.getMaxValue(),
  83.                 other.getMinValue());
  84.         final boolean maxChanged = argument.reduceWithMaxValue(newMax);

  86.         // The argument minimum shall not be lesser than the difference between
  87.         // the "sum" minimum and the "other" maximum.
  88.         final IntValue newMin = IntValue.diff(sum.getMinValue(),
  89.                 other.getMaxValue());
  90.         final boolean minChanged = argument.reduceWithMinValue(newMin);

  92.         if (maxChanged || minChanged) {
  93.             addRecentChangedVariable(argument);
  94.         }
  95.     }

  97.     /**
  98.      * Get the first argument of the constraint.
  99.      * @return First argument
  100.      */
  101.     protected IntVar getFirst() {
  102.         return (IntVar) getFirstVariable();
  103.     }

  105.     /**
  106.      * Get the second argument of the constraint.
  107.      * @return Second argument
  108.      */
  109.     protected IntVar getSecond() {
  110.         return (IntVar) getSecondVariable();
  111.     }

  113.     /**
  114.      * Get the sum.
  115.      * @return Sum (third variable)
  116.      */
  117.     protected IntVar getSum() {
  118.         return (IntVar) getThirdVariable();
  119.     }

  121. }
Created with JaCoCo 0.7.4.201502262128