Menu
▾
▴
fudaa-cvs-commit
|
From: <de...@us...> - 2003-12-19 12:10:40
|
Update of /cvsroot/fudaa/fudaa_devel/dodico/src/org/fudaa/dodico/mesure
In directory sc8-pr-cvs1:/tmp/cvs-serv28839/mesure
Modified Files:
DEvolutionSerieIrreguliere.java
Added Files:
EvolutionListener.java EvolutionListenerDispatcher.java
EvolutionListenerDispatcherDefault.java EvolutionManager.java
EvolutionReader.java EvolutionReguliere.java
Log Message:
Update for h2d model
Add support for evolution
--- NEW FILE: EvolutionListener.java ---
(This appears to be a binary file; contents omitted.)
--- NEW FILE: EvolutionListenerDispatcher.java ---
(This appears to be a binary file; contents omitted.)
--- NEW FILE: EvolutionListenerDispatcherDefault.java ---
(This appears to be a binary file; contents omitted.)
--- NEW FILE: EvolutionManager.java ---
/*
* @file H2dEvolutionManager.java
* @creation 14 nov. 2003
* @modification $Date: 2003/12/19 12:10:37 $
* @license GNU General Public License 2
* @copyright (c)1998-2001 CETMEF 2 bd Gambetta F-60231 Compiegne
* @mail de...@fu...
*/
package org.fudaa.dodico.mesure;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import java.util.Vector;
import javax.swing.ComboBoxModel;
import javax.swing.DefaultComboBoxModel;
import org.fudaa.ctulu.CtuluLib;
import org.fudaa.dodico.commun.DodicoResource;
/**
* @author deniger
* @version $Id: EvolutionManager.java,v 1.1 2003/12/19 12:10:37 deniger Exp $
*/
public class EvolutionManager {
protected ArrayList evols_;
protected EvolutionListenerDispatcher listener_;
public EvolutionManager() {
this(null);
}
/**
*
*/
public EvolutionManager(EvolutionListenerDispatcher _listener) {
evols_= new ArrayList();
listener_= _listener;
}
public EvolutionManager(EvolutionListenerDispatcher _listener, Set _s) {
listener_= _listener;
evols_= new ArrayList(_s);
for (Iterator it= evols_.iterator(); it.hasNext();) {
((EvolutionReguliere)it.next()).setListener(listener_);
}
Collections.sort(evols_);
}
public boolean containsName(String _n) {
return indexOf(_n) >= 0;
}
public void remove(EvolutionReguliere _evol) {
if (evols_.remove(_evol))
fireEvolRemove(_evol);
}
public void remove(EvolutionReguliere[] _evol) {
if (_evol != null) {
for (int i= _evol.length - 1; i >= 0; i--) {
remove(_evol[i]);
}
}
}
public boolean containsEvol(EvolutionReguliere _evol) {
//rapide car recherche binaire
if (!containsName(_evol.getNom()))
return false;
//recherche normal.
return evols_.contains(_evol);
}
public int indexOf(String _n) {
return indexOfNameEvol(_n, evols_);
}
public static int indexOfNameEvol(String _n, List _evol) {
int low= 0;
int high= _evol.size() - 1;
while (low <= high) {
int mid= (low + high) / 2;
int cmp= ((EvolutionReguliere)_evol.get(mid)).getNom().compareTo(_n);
if (cmp < 0)
low= mid + 1;
else if (cmp > 0)
high= mid - 1;
else
return mid;
}
return - (low + 1);
}
public static double[] getXMinMaxYMinMax(List _l) {
if (_l == null)
return null;
double[] r= new double[4];
if (_l.size() == 0)
return r;
int n= _l.size() - 1;
EvolutionReguliere e= (EvolutionReguliere)_l.get(n);
r[0]= e.getMinX();
r[1]= e.getMaxX();
r[2]= e.getMinY();
r[3]= e.getMaxY();
double temp;
for (int i= n - 1; i >= 0; i--) {
e= (EvolutionReguliere)_l.get(i);
temp= e.getMinX();
if (temp < r[0])
r[0]= temp;
temp= e.getMinY();
if (temp < r[2])
r[2]= temp;
temp= e.getMaxX();
if (temp > r[1])
r[1]= temp;
temp= e.getMaxY();
if (temp > r[3])
r[3]= temp;
}
return r;
}
public synchronized void add(EvolutionReguliere[] _l) {
if (_l != null) {
for (int i= _l.length - 1; i >= 0; i--) {
add(_l[i]);
}
}
}
public void addListener(EvolutionListener _l) {
listener_.addEvolutionListener(_l);
}
public void removeListener(EvolutionListener _l) {
listener_.removeEvolutionListener(_l);
}
public boolean containsListener(EvolutionListener _l) {
return listener_.containsEvolutionListener(_l);
}
public synchronized void add(EvolutionReguliere _l) {
if (addEvol(_l))
fireEvolAdd(_l);
}
private synchronized boolean addEvol(EvolutionReguliere _l) {
if (_l != null) {
if (!containsEvol(_l)) {
if ((_l.getNom() == null) || (_l.getNom().length() == 0))
_l.setNom(DodicoResource.getS("Inconnu"));
int i= indexOf(_l.getNom());
if (i < 0) {
if (-i > evols_.size()) {
evols_.add(_l);
} else
evols_.add(-i - 1, _l);
_l.setListener(listener_);
return true;
}
if (i >= 0) {
_l.setNom(changeNom(i, evols_));
i= indexOf(_l.getNom());
if (i >= 0) {
new Throwable().printStackTrace();
return false;
} else {
if (-i > evols_.size()) {
evols_.add(_l);
} else
evols_.add(-i - 1, _l);
_l.setListener(listener_);
return true;
}
}
}
}
return false;
}
public static String changeNom(int _idx, List _l) {
//le nom en doublon est n.
//on recherche un nouveau nom non contenu dans la list l.
String n= ((EvolutionReguliere)_l.get(_idx)).getNom();
//les noms crees seront du type nom - idx
int nameIdx= getNomIdx(n);
if (nameIdx < 0) {
n= n + "-" + CtuluLib.UN;
nameIdx= indexOfNameEvol(n, _l);
if (nameIdx < 0)
return n;
else
return changeNom(nameIdx, _l);
} else {
int max= nameIdx;
String pref= n.substring(0, n.lastIndexOf('-')).trim();
//les evolutions sont rangees dans l'ordre, donc il suffit de partir de _idx
//dans l'ordre croissant
for (int i= _idx; i < _l.size(); i++) {
n= ((EvolutionReguliere)_l.get(i)).getNom();
if (n.startsWith(pref)) {
nameIdx= getNomIdx(n);
if (nameIdx > max)
max= nameIdx;
} else
break;
}
//dans l'ordre decroissant
for (int i= _idx - 1; i >= 0; i--) {
n= ((EvolutionReguliere)_l.get(i)).getNom();
if (n.startsWith(pref)) {
nameIdx= getNomIdx(n);
if (nameIdx > max)
max= nameIdx;
} else
break;
}
n= pref + "-" + CtuluLib.getString(max + 1);
if (indexOfNameEvol(n, _l) >= 0) {
new Throwable().printStackTrace();
return null;
}
return n;
}
}
public static int getNomIdx(String _name) {
if (_name == null) {
new Throwable().printStackTrace();
return -1;
}
int idx= _name.lastIndexOf('-');
if (idx < 0)
return -1;
int rf= -1;
try {
rf= Integer.parseInt(_name.substring(idx + 1).trim());
} catch (NumberFormatException e) {}
return rf;
}
public int getNbEvol() {
return evols_.size();
}
public List createList() {
return new ArrayList(evols_);
}
public Vector createVector() {
return new Vector(evols_);
}
public ComboBoxModel createComboBoxModel() {
return new DefaultComboBoxModel(createVector());
}
private void fireEvolAdd(EvolutionReguliere _evol) {
if (listener_ != null)
listener_.evolutionAdd(_evol);
}
private void fireEvolRemove(EvolutionReguliere _evol) {
if (listener_ != null)
listener_.evolutionRemove(_evol);
}
public ComboBoxModel createComboBoxModelWithEmpty(EvolutionReguliere _empty) {
Vector v= new Vector(getNbEvol() + 1);
v.add(_empty);
v.addAll(evols_);
return new DefaultComboBoxModel(v);
}
public static void main(String[] args) {
System.out.println(getNomIdx("toto -1") + "=1");
System.out.println(getNomIdx("toto - 100") + "=100");
System.out.println(getNomIdx("toto - 10a0") + "=-1");
}
}
--- NEW FILE: EvolutionReader.java ---
(This appears to be a binary file; contents omitted.)
--- NEW FILE: EvolutionReguliere.java ---
/*
* @file DodicoDoubleDoubleSortedList.java
* @creation 26 juin 2003
* @modification $Date: 2003/12/19 12:10:37 $
* @license GNU General Public License 2
* @copyright (c)1998-2001 CETMEF 2 bd Gambetta F-60231 Compiegne
* @mail de...@fu...
*/
package org.fudaa.dodico.mesure;
import gnu.trove.TDoubleArrayList;
import gnu.trove.TDoubleHashSet;
import org.fudaa.ctulu.CtuluLib;
/**
* Une evolution reguliere qui n'utilise pas les objets corba.
* @see org.fudaa.dodico.test.TestEvolution
* @author deniger
* @version $Id: EvolutionReguliere.java,v 1.1 2003/12/19 12:10:37 deniger Exp $
*/
public class EvolutionReguliere implements Comparable {
TDoubleArrayList t_;
TDoubleArrayList val_;
String nom_;
String unite_;
protected EvolutionListenerDispatcher listener_;
public EvolutionReguliere() {
t_= new TDoubleArrayList();
val_= new TDoubleArrayList();
}
public EvolutionReguliere(String _s) {
this();
nom_= _s;
}
public double[] getArrayX(){
return t_.toNativeArray();
}
public EvolutionReguliere(EvolutionReguliere _l) {
initFromEvolutionReguliere(_l);
}
/**
*
*/
public EvolutionListenerDispatcher getListener() {
return listener_;
}
/**
*
*/
public void setListener(EvolutionListenerDispatcher _listener) {
listener_= _listener;
}
protected final void initFromEvolutionReguliere(EvolutionReguliere _evol) {
nom_= _evol.nom_;
unite_= _evol.unite_;
t_= new TDoubleArrayList(_evol.t_.toNativeArray());
val_= new TDoubleArrayList(_evol.val_.toNativeArray());
}
/**
*
*/
public int compareTo(Object o) {
if (o instanceof EvolutionReguliere) {
return nom_.compareTo(((EvolutionReguliere)o).getNom());
} else
throw new IllegalAccessError();
}
/**
* Recupere la valeur en y correspondant a t (en interpolant si nécessaire).
* Si _t est en dehors des bornes, renvoie la valeur de la borne la plus proche.
*/
public double getValue(double _t) {
if (_t >= getMaxX()) {
return val_.isEmpty() ? 0 : val_.getQuick(t_.size() - 1);
} else if (_t <= getMinX())
return val_.isEmpty() ? 0 : val_.getQuick(0);
else {
int index= indexOfKey(_t);
//chance: la valeur existe
if (index >= 0)
return val_.getQuick(index);
//interpolation
else {
index= -index - 2;
//l'index d'insertion. _t se trouve entre index-2 et index-1
double y0= val_.getQuick(index);
double x0= t_.getQuick(index);
return (val_.getQuick(index + 1) - y0)
* (_t - x0)
/ (t_.getQuick(index + 1) - x0)
+ y0;
}
}
}
/**
* Cree une nouvelle evolution avec comme base de temps le tableau
* <code>_newT</code> et comme valeurs les interpolations issues
* de cette evolution
* Create a new evolution containing the time step <code>_newT</code>
* and the value are interpolated from this evolution
*/
public EvolutionReguliere createEvolutionFromInterpolation(double[] _newT) {
if (_newT == null)
return null;
EvolutionReguliere r= new EvolutionReguliere(_newT.length);
int n= _newT.length;
for (int i= 0; i < n; i++) {
r.put(_newT[i], getValue(_newT[i]));
}
return r;
}
/**
* Ajoute tous les instants du tableau <code>_newT</code> en interpolant les valeurs.
* Add all the time step from the array <code>_newT</code> and the values are
* interpolated.
*/
public void addNewInterpolationValues(double[] _newT) {
if (_newT == null)
return;
int n= _newT.length;
for (int i= 0; i < n; i++) {
put(_newT[i], getValue(_newT[i]));
}
}
/**
* @return true si l'instant t est compris dans les bornes de cette evolution.
* @return true if the time t is included in this evolution
*/
public boolean isInclude(double _t) {
return (getMinX() <= _t) && (getMaxX() >= _t);
}
public boolean isEquivalentTo(EvolutionReguliere _e) {
if (_e == null)
return false;
if (_e.size() != size())
return false;
return (_e.t_.equals(t_)) && (_e.val_.equals(val_));
}
public boolean containsKey(double _key) {
return indexOfKey(_key) >= 0;
}
public void ensureCapacity(int _c) {
t_.ensureCapacity(_c);
val_.ensureCapacity(_c);
}
public double getMinX() {
return (t_.size() == 0) ? 0 : t_.getQuick(0);
}
public double getMaxX() {
int n= t_.size() - 1;
return n < 0 ? 0 : t_.getQuick(n);
}
public double getMinY() {
int n= t_.size() - 1;
if (n < 0)
return 0;
double r= val_.getQuick(n);
double temp;
for (int i= n - 1; i >= 0; i--) {
temp= val_.getQuick(i);
if (temp < r)
r= temp;
}
return r;
}
public double getMaxY() {
int n= t_.size() - 1;
if (n < 0)
return 0;
double r= val_.getQuick(n);
double temp;
for (int i= n - 1; i >= 0; i--) {
temp= val_.getQuick(i);
if (temp > r)
r= temp;
}
return r;
}
/**
*
*/
public EvolutionReguliere(int _n) {
t_= new TDoubleArrayList(_n);
val_= new TDoubleArrayList(_n);
}
public int size() {
return t_.size();
}
public void put(double _t, double _val) {
if (t_.size() == 0) {
t_.add(_t);
val_.add(_val);
} else {
int k= t_.binarySearch(_t);
if (k < 0) {
k= -k;
if (k > t_.size()) {
t_.add(_t);
val_.add(_val);
} else {
t_.insert(k - 1, _t);
val_.insert(k - 1, _val);
}
} else {
val_.set(k, _val);
}
}
}
public void removeKey(double _key) {
int index= indexOfKey(_key);
if (index >= 0) {
t_.remove(index);
val_.remove(index);
}
}
public void removeValue(double _val) {
int index= indexOfValue(_val);
if (index >= 0) {
t_.remove(index);
val_.remove(index);
}
}
/**
* Recherche binaire pour le temps _t
* @see TDoubleArrayList#binarySearch(double)
*/
public int indexOfKey(double _t) {
return t_.binarySearch(_t);
}
public int indexOfValue(double _val) {
return val_.binarySearch(_val);
}
public double getKeyAtIndex(int _offset) {
return t_.get(_offset);
}
public double getQuickKeyAtIndex(int _offset) {
return t_.getQuick(_offset);
}
public double getValueAtIndex(int _offset) {
return val_.get(_offset);
}
public double getQuickValueAtIndex(int _offset) {
return val_.getQuick(_offset);
}
public double getValueForKey(double _key) {
int i= indexOfKey(_key);
return i < 0 ? (double)0 : val_.getQuick(i);
}
public double getKeyForValue(double _val) {
int i= indexOfValue(_val);
return i < 0 ? (double)0 : t_.getQuick(i);
}
public static void main(String[] args) {
EvolutionReguliere l= new EvolutionReguliere(15);
l.put(1d, 1d);
l.put(3d, 3d);
l.put(5d, 5d);
l.put(4d, 5d);
l.put(0d, 0d);
l.put(4d, 4d);
System.out.println(l.toString());
System.out.println(l.getValueForKey(1d));
System.out.println(l.getKeyForValue(5d));
System.out.println(l.containsKey(0d));
l.removeKey(4d);
l.removeValue(1d);
System.out.println(l.toString());
}
/**
*
*/
public String getNom() {
return nom_;
}
/**
*
*/
public String getUnite() {
return unite_;
}
/**
*
*/
public void setNom(String _string) {
nom_= _string;
}
/**
*
*/
public void setUnite(String _string) {
unite_= _string;
}
public String toString() {
return nom_;
}
public String getDescriptionTotale() {
StringBuffer b= new StringBuffer();
b.append(toString()).append(CtuluLib.LINE_SEP);
StringBuffer t= new StringBuffer();
StringBuffer v= new StringBuffer();
for (int i= 0; i < size(); i++) {
if (i > 0) {
t.append(",");
v.append(",");
}
t.append(getQuickKeyAtIndex(i));
v.append(getQuickValueAtIndex(i));
}
b.append("time steps=[").append(t.toString()).append("]").append(
CtuluLib.LINE_SEP);
b.append("values=[").append(v.toString()).append("]").append(
CtuluLib.LINE_SEP);
return b.toString();
}
/**
* Compare les X de cette evolution avec <code>_toCompare</code>. Si les x sont différents
* renvoie false et stocke dans <code>_commonX</code> l'union des valeurs des x.
*/
public boolean isEvolutionWithSameX(
EvolutionReguliere _toCompare,
TDoubleHashSet _commonX) {
if(_toCompare==null) return false;
if (t_.equals(_toCompare.t_))
return true;
else {
if (_commonX != null) {
_commonX.ensureCapacity(t_.size() + _toCompare.t_.size());
_commonX.addAll(t_.toNativeArray());
_commonX.addAll(_toCompare.t_.toNativeArray());
}
return false;
}
}
}
Index: DEvolutionSerieIrreguliere.java
===================================================================
RCS file: /cvsroot/fudaa/fudaa_devel/dodico/src/org/fudaa/dodico/mesure/DEvolutionSerieIrreguliere.java,v
retrieving revision 1.6
retrieving revision 1.7
diff -C2 -d -r1.6 -r1.7
*** DEvolutionSerieIrreguliere.java 25 Nov 2003 10:11:43 -0000 1.6
--- DEvolutionSerieIrreguliere.java 19 Dec 2003 12:10:37 -0000 1.7
***************
*** 105,109 ****
this,
"La valeur demandee est en dehors de l'intervalle "
! + "de definition de l'evolution");
return serie_[i];
}
--- 105,109 ----
this,
"La valeur demandee est en dehors de l'intervalle "
! + "de definition de l'evolution (en dessous)");
return serie_[i];
}
***************
*** 112,116 ****
this,
"La valeur demandee est en dehors de l'intervalle "
! + "de definition de l'evolution");
return serie_[u.length - 1];
}
--- 112,116 ----
this,
"La valeur demandee est en dehors de l'intervalle "
! + "de definition de l'evolution (au dessus)");
return serie_[u.length - 1];
}
|
Thanks for helping keep SourceForge clean.
X