Module org.chocosolver
Package org.chocosolver.solver.variables

Interface IntVar

    • Field Detail

      • MIN_INT_BOUND

        static final int MIN_INT_BOUND
        Provide a minimum value for integer variable lower bound. Do not prevent from underflow, but may avoid it, somehow.
        See Also:
        Constant Field Values

      • MAX_INT_BOUND

        static final int MAX_INT_BOUND
        Provide a minimum value for integer variable lower bound. Do not prevent from overflow, but may avoid it, somehow.
        See Also:
        Constant Field Values

    • Method Detail

      • removeValue

        boolean removeValue​(int value,
                    ICause cause)
             throws ContradictionException
        Removes valuefrom the domain of this. The instruction comes from propagator.
        • If value is out of the domain, nothing is done and the return value is false,
        • if removing value leads to a dead-end (domain wipe-out), a ContradictionException is thrown,
        • otherwise, if removing value from the domain can be done safely, the event type is created (the original event can be promoted) and observers are notified and the return value is true
        Parameters:
        value - value to remove from the domain (int)
        cause - removal releaser
        Returns:
        true if the value has been removed, false otherwise
        Throws:
        ContradictionException - if the domain become empty due to this action

      • removeValues

        boolean removeValues​(IntIterableSet values,
                     ICause cause)
              throws ContradictionException
        Removes the value in valuesfrom the domain of this. The instruction comes from propagator.
        • If all values are out of the domain, nothing is done and the return value is false,
        • if removing a value leads to a dead-end (domain wipe-out), a ContradictionException is thrown,
        • otherwise, if removing the values from the domain can be done safely, the event type is created (the original event can be promoted) and observers are notified and the return value is true
        Parameters:
        values - set of ordered values to remove
        cause - removal release
        Returns:
        true if at least a value has been removed, false otherwise
        Throws:
        ContradictionException - if the domain become empty due to this action

      • removeAllValuesBut

        boolean removeAllValuesBut​(IntIterableSet values,
                           ICause cause)
                    throws ContradictionException
        Removes all values from the domain of this except those in values. The instruction comes from propagator.
        • If all values are out of the domain, a ContradictionException is thrown,
        • if the domain is a subset of values, nothing is done and the return value is false,
        • otherwise, if removing all values but values from the domain can be done safely, the event type is created (the original event can be promoted) and observers are notified and the return value is true
        Parameters:
        values - set of ordered values to keep in the domain
        cause - removal release
        Returns:
        true if a at least a value has been removed, false otherwise
        Throws:
        ContradictionException - if the domain become empty due to this action

      • removeInterval

        boolean removeInterval​(int from,
                       int to,
                       ICause cause)
                throws ContradictionException
        Removes values between [from, to] from the domain of this. The instruction comes from propagator.
        • If union between values and the current domain is empty, nothing is done and the return value is false,
        • if removing a value leads to a dead-end (domain wipe-out), a ContradictionException is thrown,
        • otherwise, if removing at least a value from the domain can be done safely, the event type is created (the original event can be promoted) and observers are notified and the return value is true
        Parameters:
        from - lower bound of the interval to remove (int)
        to - upper bound of the interval to remove(int)
        cause - removal releaser
        Returns:
        true if the value has been removed, false otherwise
        Throws:
        ContradictionException - if the domain become empty due to this action

      • instantiateTo

        boolean instantiateTo​(int value,
                      ICause cause)
               throws ContradictionException
        Instantiates the domain of this to value. The instruction comes from propagator.
        • If the domain of this is already instantiated to value, nothing is done and the return value is false,
        • If the domain of this is already instantiated to another value, then a ContradictionException is thrown,
        • Otherwise, the domain of this is restricted to value and the observers are notified and the return value is true.
        Parameters:
        value - instantiation value (int)
        cause - instantiation releaser
        Returns:
        true if the instantiation is done, false otherwise
        Throws:
        ContradictionException - if the domain become empty due to this action

      • updateLowerBound

        boolean updateLowerBound​(int value,
                         ICause cause)
                  throws ContradictionException
        Updates the lower bound of the domain of this to value. The instruction comes from propagator.
        • If value is smaller than the lower bound of the domain, nothing is done and the return value is false,
        • if updating the lower bound to value leads to a dead-end (domain wipe-out), a ContradictionException is thrown,
        • otherwise, if updating the lower bound to value can be done safely, the event type is created (the original event can be promoted) and observers are notified and the return value is true
        Parameters:
        value - new lower bound (included)
        cause - updating releaser
        Returns:
        true if the lower bound has been updated, false otherwise
        Throws:
        ContradictionException - if the domain become empty due to this action

      • updateUpperBound

        boolean updateUpperBound​(int value,
                         ICause cause)
                  throws ContradictionException
        Updates the upper bound of the domain of this to value. The instruction comes from propagator.
        • If value is greater than the upper bound of the domain, nothing is done and the return value is false,
        • if updating the upper bound to value leads to a dead-end (domain wipe-out), a ContradictionException is thrown,
        • otherwise, if updating the upper bound to value can be done safely, the event type is created (the original event can be promoted) and observers are notified and the return value is true
        Parameters:
        value - new upper bound (included)
        cause - update releaser
        Returns:
        true if the upper bound has been updated, false otherwise
        Throws:
        ContradictionException - if the domain become empty due to this action

      • updateBounds

        boolean updateBounds​(int lb,
                     int ub,
                     ICause cause)
              throws ContradictionException
        Updates the lower bound and the upper bound of the domain of this to, resp. lb and ub. The instruction comes from propagator.

        • If lb is smaller than the lower bound of the domain and ub is greater than the upper bound of the domain,

          nothing is done and the return value is false,

        • if updating the lower bound to lb, or updating the upper bound to ub leads to a dead-end (domain wipe-out), or if lb is strictly greater than ub, a ContradictionException is thrown,
        • otherwise, if updating the lower bound to lb and/or the upper bound to ub can be done safely can be done safely, the event type is created (the original event can be promoted) and observers are notified and the return value is true
        Parameters:
        lb - new lower bound (included)
        ub - new upper bound (included)
        cause - update releaser
        Returns:
        true if the upper bound has been updated, false otherwise
        Throws:
        ContradictionException - if the domain become empty due to this action

      • contains

        boolean contains​(int value)
        Checks if a value v belongs to the domain of this
        Parameters:
        value - int
        Returns:
        true if the value belongs to the domain of this, false otherwise.

      • isInstantiatedTo

        boolean isInstantiatedTo​(int value)
        Checks wether this is instantiated to val
        Parameters:
        value - int
        Returns:
        true if this is instantiated to val, false otherwise

      • getValue

        int getValue()
        Retrieves the current value of the variable if instantiated, otherwier the lower bound.
        Returns:
        the current value (or lower bound if not yet instantiated).

      • getLB

        int getLB()
        Retrieves the lower bound of the variable
        Returns:
        the lower bound

      • getUB

        int getUB()
        Retrieves the upper bound of the variable
        Returns:
        the upper bound

      • getDomainSize

        int getDomainSize()
        Returns the size of this domain, that is the number of elements in this domain.
        Returns:
        size of the domain

      • getRange

        int getRange()
        Returns the range of this domain, that is, the difference between the upper bound and the lower bound.
        Returns:
        the range of this domain

      • nextValue

        int nextValue​(int v)
        Returns the first value just after v in this which is in the domain. If no such value exists, returns Integer.MAX_VALUE;

        To iterate over the values in a IntVar, use the following loop: 

         int ub = iv.getUB();
 for (int i = iv.getLB(); i <= ub; i = iv.nextValue(i)) {
     // operate on value i here
 }
        Parameters:
        v - the value to start checking (exclusive)
        Returns:
        the next value in the domain

      • nextValueOut

        int nextValueOut​(int v)
        Returns the first value just after v in this which is out of the domain. If v is less than or equal to getLB()-2, returns v + 1, if v is greater than or equal to getUB(), returns v + 1.
        Parameters:
        v - the value to start checking (exclusive)
        Returns:
        the next value out of the domain

      • previousValue

        int previousValue​(int v)
        Returns the previous value just before v in this. If no such value exists, returns Integer.MIN_VALUE;

        To iterate over the values in a IntVar, use the following loop: 

         int lb = iv.getLB();
 for (int i = iv.getUB(); i >= lb; i = iv.previousValue(i)) {
     // operate on value i here
 }
        Parameters:
        v - the value to start checking (exclusive)
        Returns:
        the previous value in the domain

      • previousValueOut

        int previousValueOut​(int v)
        Returns the first value just before v in this which is out of the domain. If v is greater than or equal to getUB()+2, returns v - 1, if v is less than or equal to getLB(), returns v - 1.
        Parameters:
        v - the value to start checking (exclusive)
        Returns:
        the previous value out of the domain

      • getValueIterator

        DisposableValueIterator getValueIterator​(boolean bottomUp)
        Retrieves an iterator over values of this.

        The values can be iterated in a bottom-up way or top-down way.

        To bottom-up iterate over the values in a IntVar, use the following loop: 

         DisposableValueIterator vit = var.getValueIterator(true);
 while(vit.hasNext()){
     int v = vit.next();
     // operate on value v here
 }
 vit.dispose();
        To top-down iterate over the values in a IntVar, use the following loop: 
         DisposableValueIterator vit = var.getValueIterator(false);
 while(vit.hasPrevious()){
     int v = vit.previous();
     // operate on value v here
 }
 vit.dispose();
        Using both previous and next can lead to unexpected behaviour.
        Parameters:
        bottomUp - way to iterate over values. true means from lower bound to upper bound, false means from upper bound to lower bound.
        Returns:
        a disposable iterator over values of this.

      • getRangeIterator

        DisposableRangeIterator getRangeIterator​(boolean bottomUp)
        Retrieves an iterator over ranges (or intervals) of this.

        The ranges can be iterated in a bottom-up way or top-down way.

        To bottom-up iterate over the values in a IntVar, use the following loop: 

         DisposableRangeIterator rit = var.getRangeIterator(true);
 while (rit.hasNext()) {
     int from = rit.min();
     int to = rit.max();
     // operate on range [from,to] here
     rit.next();
 }
 rit.dispose();
        To top-down iterate over the values in a IntVar, use the following loop: 
         DisposableRangeIterator rit = var.getRangeIterator(false);
 while (rit.hasPrevious()) {
     int from = rit.min();
     int to = rit.max();
     // operate on range [from,to] here
     rit.previous();
 }
 rit.dispose();
        Using both previous and next can lead to unexpected behaviour.
        Parameters:
        bottomUp - way to iterate over ranges. true means from lower bound to upper bound, false means from upper bound to lower bound.
        Returns:
        a disposable iterator over ranges of this.

      • hasEnumeratedDomain

        boolean hasEnumeratedDomain()
        Indicates wether (or not) this has an enumerated domain (represented in extension) or not (only bounds)
        Returns:
        true if the domain is enumerated, false otherwise.

      • monitorDelta

        IIntDeltaMonitor monitorDelta​(ICause propagator)
        Allow to monitor removed values of this.
        Parameters:
        propagator - the cause that requires to monitor delta
        Returns:
        a delta monitor

      • isBool

        boolean isBool()
        Returns:
        true iff the variable has a binary domain

      • forEachIntVar

        default void forEachIntVar​(Consumer<IntVar> action)
        Description copied from interface: ICause
        Apply an action on each variable declared on the scope of this cause, if any.
        Specified by:
        forEachIntVar in interface ICause
        Parameters:
        action - action to perform on each variable declared in this cause.

      • transformEvent

        default IEventType transformEvent​(IEventType evt)
        Parameters:
        evt - original event
        Returns:
        transforms the original event wrt this IntVar

      • intVar

        default IntVar intVar()
        Specified by:
        intVar in interface ArExpression
        Returns:
        the arithmetic expression as an IntVar. If necessary, it creates intermediary variable and posts intermediary constraints

      • getNoChild

        default int getNoChild()
        Specified by:
        getNoChild in interface ArExpression
        Returns:
        the child of this expression, or null if thid

      • isExpressionLeaf

        default boolean isExpressionLeaf()
        Specified by:
        isExpressionLeaf in interface ArExpression
        Returns:
        true if this expression is a leaf, ie a variable, false otherwise