/*
* Copyright (c) 1999-2014, Ecole des Mines de Nantes
* All rights reserved.
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the Ecole des Mines de Nantes nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE REGENTS AND CONTRIBUTORS BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package solver.variables.view;
import gnu.trove.map.hash.THashMap;
import solver.ICause;
import solver.Solver;
import solver.exception.ContradictionException;
import solver.explanations.Deduction;
import solver.explanations.Explanation;
import solver.explanations.VariableState;
import solver.variables.IntVar;
import solver.variables.RealVar;
import solver.variables.VariableFactory;
import solver.variables.delta.NoDelta;
import solver.variables.events.IEventType;
import solver.variables.events.IntEventType;
import solver.variables.events.RealEventType;
import solver.variables.impl.AbstractVariable;
/**
* <br/>
*
* @author Charles Prud'homme, Jean-Guillaume Fages
* @since 20/07/12
*/
public class RealView extends AbstractVariable implements IView, RealVar {
protected final IntVar var;
protected final double precision;
public RealView(IntVar var, double precision) {
super("(real)" + var.getName(), var.getSolver());
this.var = var;
this.precision = precision;
this.var.subscribeView(this);
}
@Override
public IntVar getVariable() {
return var;
}
@Override
public void transformEvent(IEventType evt, ICause cause) throws ContradictionException {
RealEventType realevt;
IntEventType intevt = (IntEventType) evt;
switch (intevt){
case INSTANTIATE:
case BOUND:
realevt = RealEventType.BOUND;break;
case INCLOW:realevt = RealEventType.INCLOW;break;
case DECUPP:realevt = RealEventType.DECUPP;break;
case REMOVE:return;
default:throw new UnsupportedOperationException("unexpected event transformation in RealView");
}
notifyPropagators(realevt, this);
}
@Override
public void recordMask(int mask) {
super.recordMask(mask);
var.recordMask(mask);
}
@Override
public String toString() {
return "(real)" + var.toString();
}
///////////// SERVICES REQUIRED FROM CAUSE ////////////////////////////
@Override
public double getLB() {
return var.getLB();
}
@Override
public double getUB() {
return var.getUB();
}
@Override
public boolean updateLowerBound(double value, ICause cause) throws ContradictionException {
if (var.updateLowerBound((int) Math.ceil(value - precision), this)) {
notifyPropagators(RealEventType.INCLOW, cause);
return true;
}
return false;
}
@Override
public boolean updateUpperBound(double value, ICause cause) throws ContradictionException {
if (var.updateUpperBound((int) Math.floor(value + precision), this)) {
notifyPropagators(RealEventType.INCLOW, cause);
return true;
}
return false;
}
@Override
public boolean updateBounds(double lowerbound, double upperbound, ICause cause) throws ContradictionException {
int c = 0;
c += (var.updateLowerBound((int) Math.ceil(lowerbound - precision), this) ? 1 : 0);
c += (var.updateUpperBound((int) Math.floor(upperbound + precision), this) ? 2 : 0);
switch (c) {
case 3:
notifyPropagators(RealEventType.BOUND, cause);
return true;
case 2:
notifyPropagators(RealEventType.DECUPP, cause);
return true;
case 1:
notifyPropagators(RealEventType.INCLOW, cause);
return true;
default: //cas 0;
return false;
}
}
@Override
public double getPrecision() {
return precision;
}
@Override
public boolean isInstantiated() {
return var.isInstantiated();
}
@Override
public NoDelta getDelta() {
return NoDelta.singleton;
}
@Override
public void createDelta() {
}
@Override
public void notifyMonitors(IEventType event) throws ContradictionException {
for (int i = mIdx - 1; i >= 0; i--) {
monitors[i].onUpdate(this, event);
}
}
@Override
public void contradiction(ICause cause, IEventType event, String message) throws ContradictionException {
solver.getEngine().fails(cause, this, message);
}
@Override
public int getTypeAndKind() {
return VIEW | REAL;
}
@Override
public RealVar duplicate() {
return VariableFactory.real(this.var, this.precision);
}
@Override
public void duplicate(Solver solver, THashMap<Object, Object> identitymap) {
if (!identitymap.containsKey(this)) {
this.var.duplicate(solver, identitymap);
RealView clone = new RealView((IntVar) identitymap.get(this.var), this.precision);
identitymap.put(this, clone);
}
}
@Override
public void explain(Deduction d, Explanation e) {
}
@Override
public void explain(VariableState what, Explanation to) {
}
@Override
public void explain(VariableState what, int val, Explanation to) {
}
}