package com.exigen.ie.constrainer.impl;
import java.util.Map;
import com.exigen.ie.constrainer.EventOfInterest;
import com.exigen.ie.constrainer.Failure;
import com.exigen.ie.constrainer.FloatExp;
import com.exigen.ie.constrainer.FloatVar;
import com.exigen.ie.constrainer.NonLinearExpression;
import com.exigen.ie.constrainer.Observer;
import com.exigen.ie.constrainer.Subject;
///////////////////////////////////////////////////////////////////////////////
/*
* Copyright Exigen Group 1998, 1999, 2000
* 320 Amboy Ave., Metuchen, NJ, 08840, USA, www.exigengroup.com
*
* The copyright to the computer program(s) herein
* is the property of Exigen Group, USA. All rights reserved.
* The program(s) may be used and/or copied only with
* the written permission of Exigen Group
* or in accordance with the terms and conditions
* stipulated in the agreement/contract under which
* the program(s) have been supplied.
*/
///////////////////////////////////////////////////////////////////////////////
/**
* An implementation of the expression: <code>(FloatExp1 * FloatExp2)</code>
* where both expressions are non-negative.
*/
public final class FloatExpMulExpPP extends FloatExpImpl
{
private FloatExp _exp1, _exp2;
private ExpressionObserver _observer;
private FloatVar _product;
static final private int[] event_map = { MIN, MIN,
MAX, MAX,
};
private boolean checkMe(String s)
{
if(calc_max()!=_product.max() || calc_min()!=_product.min())
{
System.out.println(s+"[" + calc_min() + ".." + calc_max() + "]!=" + this);
return false;
}
return true;
}
class FloatExpMulExpPPObserver extends ExpressionObserver
{
FloatExpMulExpPPObserver()
{
super(event_map);
}
public void update(Subject subject, EventOfInterest event)
throws Failure
{
_product.setMax(calc_max());
_product.setMin(calc_min());
// checkMe("FloatExpMulExpPPObserver:");
}
public String toString()
{
return "FloatExpMulExpPPObserver: " + _exp1 + " x " + _exp2;
}
public Object master()
{
return FloatExpMulExpPP.this;
}
} //~ FloatExpMulExpPPObserver
public FloatExpMulExpPP(FloatExp exp1, FloatExp exp2)
{
super(exp1.constrainer(),"");//exp1.name()+"*"+exp2.name());
_exp1 = exp1;
_exp2 = exp2;
int trace = 0;
_product = constrainer().addFloatVarTraceInternal(calc_min(), calc_max(), "mul", trace);
_observer = new FloatExpMulExpPPObserver();
_exp1.attachObserver(_observer);
_exp2.attachObserver(_observer);
}
double calc_max()
{
return _exp1.max() * _exp2.max();
}
double calc_min()
{
return _exp1.min() * _exp2.min();
}
public void onMaskChange()
{
_observer.publish(publisherMask(), _exp1);
_observer.publish(publisherMask(), _exp2);
}
public void attachObserver(Observer observer)
{
super.attachObserver(observer);
_product.attachObserver(observer);
}
public void reattachObserver(Observer observer)
{
super.reattachObserver(observer);
_product.reattachObserver(observer);
}
public void detachObserver(Observer observer)
{
super.detachObserver(observer);
_product.detachObserver(observer);
}
public double max()
{
return _product.max();
}
public double min()
{
return _product.min();
}
public void setMax(double max) throws Failure
{
if (max >= max())
return;
// System.out.println("setmax: " + max + " in " + this);
if (max < min())
constrainer().fail("FloatExpMulExpPP.setMax(): max < min()");
// max(max(x1)) <= max(max/any(x2)) = max/min(x2)
double v, Max;
v = _exp2.min();
if (v > 0)
{
Max = max / v;
// System.out.println("setmax 1: " + Max + " in " + this);
_exp1.setMax(Max); // may fail
}
v = _exp1.min();
if (v > 0)
{
Max = max / v;
// System.out.println("setmax 2: " + Max + " in " + this);
_exp2.setMax(Max); // may fail
}
}
public void setMin(double min) throws Failure
{
if (min <= min())
return;
// System.out.println("setmin: " + min + " in " + this);
if (min > max())
constrainer().fail("FloatExpMulExpPP.setMin(): min > max()");
// min(min(x1)) >= min(min/any(x2)) = min/max(x2)
double Min, v;
v = _exp2.max();
if (v > 0)
{
Min = min / v;
// System.out.println("setmin 1: " + Min + " in " + this);
_exp1.setMin(Min); // may fail
}
v = _exp1.max();
if (v > 0)
{
Min = min / v;
// System.out.println("setmin 2: " + Min + " in " + this);
_exp2.setMin(Min); // may fail
}
}
public void setValue(double value) throws Failure
{
setMin(value);
setMax(value);
}
public boolean isLinear(){
if (! ((_exp1.bound()) || (_exp2.bound())) )
return false;
return (_exp1.isLinear() && _exp2.isLinear());
}
public double calcCoeffs(Map map, double factor) throws NonLinearExpression{
if (_exp1.bound())
return _exp2.calcCoeffs(map,factor*_exp1.max());
if (_exp2.bound())
return _exp1.calcCoeffs(map, factor*_exp2.max());
throw new NonLinearExpression(this);
}
public String toString()
{
return (_exp1+ " x "+ _exp2 );
}
} // ~FloatExpMulPP