[Fudaa-cvs-commit] fudaa_devel/dodico/src/org/fudaa/dodico/mesure EvolutionListener.java,NONE,1.1 EvolutionListenerDispatcher.java,NONE,1.1 EvolutionListenerDispatcherDefault.java,NONE,1.1 EvolutionManager.java,NONE,1.1 EvolutionReader.java,NONE,1.1 EvolutionReguliere.java,NONE,1.1 DEvolutionSerieIrreguliere.java,1.6,1.7

[<de...@us...>]

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];
      }