Index: lutinmatrix/src/java/org/codelutin/math/matrix/AbstractMatrixND.java
diff -u lutinmatrix/src/java/org/codelutin/math/matrix/AbstractMatrixND.java:1.5 lutinmatrix/src/java/org/codelutin/math/matrix/AbstractMatrixND.java:1.6
--- lutinmatrix/src/java/org/codelutin/math/matrix/AbstractMatrixND.java:1.5	Wed Oct  5 20:25:05 2005
+++ lutinmatrix/src/java/org/codelutin/math/matrix/AbstractMatrixND.java	Thu Oct 20 20:58:04 2005
@@ -23,9 +23,9 @@
  * Created: 29 oct. 2004
  *
  * @author Benjamin Poussin <poussin@codelutin.com>
- * @version $Revision: 1.5 $
+ * @version $Revision: 1.6 $
  *
- * Mise a jour: $Date: 2005/10/05 20:25:05 $
+ * Mise a jour: $Date: 2005/10/20 20:58:04 $
  * par : $Author: bpoussin $
  */
 
@@ -40,16 +40,17 @@
 public abstract class AbstractMatrixND implements MatrixND { // AbstractMatrixND
 
     abstract public MatrixIterator iterator();
-    abstract public float getValue(int [] coordinates);
-    abstract public void setValue(int [] coordinates, float d);
+    abstract public double getValue(int [] coordinates);
+    abstract public void setValue(int [] coordinates, double d);
 
     protected DimensionHelper dimHelper = new DimensionHelper();
 
+    protected MatrixFactory factory = null;
     protected int [] dim = null;
     protected List[] semantics = null;
     protected String name = "";
     protected String [] dimNames = null;
-    protected float defaultValue = 0;
+    protected double defaultValue = 0;
 
     protected void init(int [] dim){
         this.dim = new int[dim.length];
@@ -60,16 +61,20 @@
         Arrays.fill(dimNames, "");
     }
 
-    protected AbstractMatrixND(){}
+    protected AbstractMatrixND(MatrixFactory factory){
+        this.factory = factory;
+    }
 
-    public AbstractMatrixND(int [] dim){
+    public AbstractMatrixND(MatrixFactory factory, int [] dim){
+        this(factory);
         init(dim);
         for(int i=0; i<getNbDim(); i++){
             // par defaut les listes des semantiques contiennent des nulls
             semantics[i] = Collections.nCopies(dim[i], null);
         }
     }
-    public AbstractMatrixND(List[] semantics){
+    public AbstractMatrixND(MatrixFactory factory, List[] semantics){
+        this(factory);
         int [] dim = new int[semantics.length];
         for(int i=0; i<dim.length; i++){
             dim[i] = semantics[i].size();
@@ -80,22 +85,30 @@
         }
     }
 
-    public AbstractMatrixND(String name, int [] dim){
-        this(dim);
+    public AbstractMatrixND(MatrixFactory factory, String name, int [] dim){
+        this(factory, dim);
         setName(name);
     }
-    public AbstractMatrixND(String name, List[] semantics){
-        this(semantics);
+    public AbstractMatrixND(MatrixFactory factory, String name, List[] semantics){
+        this(factory, semantics);
         setName(name);
     }
 
-    public AbstractMatrixND(String name, List[] semantics, String [] dimNames){
-        this(name, semantics);
+    public AbstractMatrixND(MatrixFactory factory, String name, List[] semantics, String [] dimNames){
+        this(factory, name, semantics);
         for(int i=0; i<getNbDim(); i++){
             setDimensionName(i, dimNames[i]);
         }
     }
 
+    /**
+    * Retourne la factory utilisée pour créer cette matrice, la factory
+    * peut-être réutilisé pour créer d'autre matrice si besoin.
+    */
+    public MatrixFactory getFactory() {
+        return factory;
+    }
+
     public List[] getSemantics(){
         return semantics;
     }
@@ -125,7 +138,7 @@
     public String [] getDimensionName(){
         return dimNames;
     }
-    public float getMaxOccurence(){
+    public double getMaxOccurence(){
         // on creer un tableau dans cette classe, car on ne sait pas sur quelle
         // implantation on s'appuie. Mais dans les sous classes, si on a deja
         // un tableau il ne faut pas le recréer, on peut le passer directement
@@ -133,7 +146,7 @@
         for(int i=0; i<getNbDim(); i++){
             nbelem *=getDim(i);
         }
-        float [] data = new float[nbelem];
+        double [] data = new double[nbelem];
         int i =0;
         for(MatrixIterator mi=iterator(); mi.next();){
             data[i++] = mi.getValue();
@@ -149,96 +162,71 @@
     public int getDim(int d){
         return dim[d];
     }
-    public void map(MapFunction f){
+    /**
+    * Retourne la matrice elle meme. Les modifications sont faites directement
+    * dessus
+    */
+    public MatrixND map(MapFunction f){
         for(MatrixIterator i=iterator(); i.next();){
             i.setValue(f.apply(i.getValue()));
         }
+        return this;
     }
-    public float getValue(Object [] coordinates){
+    public double getValue(Object [] coordinates){
         return getValue(MatrixHelper.semanticsToDimension(getSemantics(), coordinates));
     }
-    public float getValue(Object x){
+    public double getValue(Object x){
         // on peut utiliser dimHelper car le get ne le reutilisera pas en interne
         return getValue(dimHelper.get(x));
     }
-    public float getValue(Object x, Object y){
+    public double getValue(Object x, Object y){
         return getValue(dimHelper.get(x, y));
     }
-    public float getValue(Object x, Object y, Object z){
+    public double getValue(Object x, Object y, Object z){
         return getValue(dimHelper.get(x, y, z));
     }
-    public float getValue(Object x, Object y, Object z, Object t){
+    public double getValue(Object x, Object y, Object z, Object t){
         return getValue(dimHelper.get(x, y, z, t));
     };
-    public float getValue(int x){
+    public double getValue(int x){
         // on peut utiliser dimHelper car le get ne le reutilisera pas en interne
         return getValue(dimHelper.get(x));
     }
-    public float getValue(int x, int y){
+    public double getValue(int x, int y){
         return getValue(dimHelper.get(x, y));
     }
-    public float getValue(int x, int y, int z){
+    public double getValue(int x, int y, int z){
         return getValue(dimHelper.get(x, y, z));
     }
-    public float getValue(int x, int y, int z, int t){
+    public double getValue(int x, int y, int z, int t){
         return getValue(dimHelper.get(x, y, z, t));
     };
-    public void setValue(Object [] coordinates, float d){
-        setValue(MatrixHelper.semanticsToDimension(getSemantics(), coordinates), d);
-    }
-    public void setValue(Object x, float d){
-        setValue(dimHelper.get(x), d);
-    }
-    public void setValue(Object x, Object y, float d){
-        setValue(dimHelper.get(x, y), d);
-    }
-    public void setValue(Object x, Object y, Object z, float d){
-        setValue(dimHelper.get(x, y, z), d);
-    }
-    public void setValue(Object x, Object y, Object z, Object t, float d){
-        setValue(dimHelper.get(x, y, z, t), d);
-    }
-    public void setValue(int x, float d){
-        setValue(dimHelper.get(x), d);
-    }
-    public void setValue(int x, int y, float d){
-        setValue(dimHelper.get(x, y), d);
-    }
-    public void setValue(int x, int y, int z, float d){
-        setValue(dimHelper.get(x, y, z), d);
-    }
-    public void setValue(int x, int y, int z, int t, float d){
-        setValue(dimHelper.get(x, y, z, t), d);
-    }
-
-    // Hack pour ne pas a avoir a caster les double en float pour que l'appel
-    // se passe bien (surtout util au travers de langage de script
     public void setValue(Object [] coordinates, double d){
-        setValue(coordinates, (float)d);
+        setValue(MatrixHelper.semanticsToDimension(getSemantics(), coordinates), d);
     }
     public void setValue(Object x, double d){
-        setValue(x, (float)d);
+        setValue(dimHelper.get(x), d);
     }
     public void setValue(Object x, Object y, double d){
-        setValue(x, y, (float)d);
+        setValue(dimHelper.get(x, y), d);
     }
     public void setValue(Object x, Object y, Object z, double d){
-        setValue(x, y, z, (float)d);
+        setValue(dimHelper.get(x, y, z), d);
     }
     public void setValue(Object x, Object y, Object z, Object t, double d){
-        setValue(x, y, z, t, (float)d);
+        setValue(dimHelper.get(x, y, z, t), d);
     }
     public void setValue(int x, double d){
-        setValue(x, (float)d);
+        setValue(dimHelper.get(x), d);
     }
     public void setValue(int x, int y, double d){
-        setValue(x, y,(float)d);
+        setValue(dimHelper.get(x, y), d);
     }
     public void setValue(int x, int y, int z, double d){
-        setValue(x, y, z, (float)d);
+        setValue(dimHelper.get(x, y, z), d);
     }
     public void setValue(int x, int y, int z, int t, double d){
-        setValue(x, y, z, t, (float)d);
+        setValue(dimHelper.get(x, y, z, t), d);
     }
 
 
@@ -299,7 +287,7 @@
             step = getDim(dim);
         }else if(step <= 1){
             // il n'y a rien a faire, on fait une copie et on la retrourne
-            return new MatrixNDImpl(this);
+            return getFactory().create(this);
         }
 
         // le nombre d'element qu'il y aura dans la dim pour le resultat
@@ -310,7 +298,7 @@
         semantics[dim] = semantics[dim].subList(0, nbDim);
 
         // creation du resultat
-        MatrixND result = new MatrixNDImpl(getName(), semantics, getDimensionName());
+        MatrixND result = getFactory().create(getName(), semantics, getDimensionName());
 
         for(int i=0; i<result.getDim(dim); i++){
             MatrixND temp = getSubMatrix(dim, i*step, step);
@@ -326,11 +314,25 @@
         throw new UnsupportedOperationException("Méthode non implantée");
     }
 
+    /**
+    * Modifie la matrice actuel en metant les valeurs de mat passé en parametre
+    */
     public MatrixND paste(MatrixND mat){
         return paste(new int[getNbDim()], mat);
     }
 
+    /**
+    * Modifie la matrice actuel en metant les valeurs de mat passé en parametre
+    * @param origin le point d'origine a partir duquel on colle la matrice
+    * @param mat une matrice avec le meme nombre de dimension, si la matrice
+    * que l'on colle est trop grande, les valeurs qui depasse ne sont pas prises
+    * en compte
+    */
     public MatrixND paste(int [] origin,  MatrixND mat){
+        // TODO, si les matrice mat et this on les memes dimensions
+        // et que origin est 0
+        // on doit pouvoir optimiser en appeler une methode paste
+        // sur BasicMatrix qui l'appel sur le vector
         for(MatrixIterator mi=mat.iterator(); mi.next();){
             int [] coordinates = ArrayUtil.sum(origin, mi.getCoordinates());
             if(isValidCoordinates(coordinates)){
@@ -370,14 +372,30 @@
         return new SubMatrix(this, dim, elem);
     }
 
+    /**
+    * Modifie la matrice actuelle en lui ajoutant les valeurs de la matrice
+    * passé en parametre. La matrice passé en parametre doit avoir le meme
+    * nombre de dimension, et chacune de ses dimensions doit avoir un nombre
+    * d'element au moins egal a cette matrice.
+    */
     public MatrixND add(MatrixND m){
+        // TODO si les dimensions sont exactment les memes, on doit pouvoir
+        // gagner du temps en travaillant directement au niveau du vector
         for(MatrixIterator i=iterator(); i.next();){
             i.setValue(i.getValue() + m.getValue(i.getCoordinates()));
             // TODO faire une variante de add avec les semantiques
         }
         return this;
     }
+    /**
+    * Modifie la matrice actuelle en lui soustrayant les valeurs de la matrice
+    * passé en parametre. La matrice passé en parametre doit avoir le meme
+    * nombre de dimension, et chacune de ses dimensions doit avoir un nombre
+    * d'element au moins egal a cette matrice.
+    */
     public MatrixND minus(MatrixND m){
+        // TODO si les dimensions sont exactment les memes, on doit pouvoir
+        // gagner du temps en travaillant directement au niveau du vector
         for(MatrixIterator i=iterator(); i.next();){
             i.setValue(i.getValue() - m.getValue(i.getSemanticsCoordinates()));
         }
@@ -389,13 +407,13 @@
             throw new MatrixException("La transpose ne peut-être fait que sur une matrice ayant 2 dimensions ou moins");
         }
         if(getNbDim() == 1){
-            MatrixND result = new MatrixNDImpl(getName(), new List[]{Collections.nCopies(1, null), getSemantics(0)}, new String[]{"Dimension 0", getDimensionName(0)});
+            MatrixND result = getFactory().create(getName(), new List[]{Collections.nCopies(1, null), getSemantics(0)}, new String[]{"Dimension 0", getDimensionName(0)});
             for (int x=0; x<getDim(0); x++){
                 result.setValue(0,x, getValue(x));
             }
             return result;
         }else{
-            MatrixND result = new MatrixNDImpl(getName(), new List[]{getSemantics(1), getSemantics(0)}, new String[]{getDimensionName(1), getDimensionName(0)});
+            MatrixND result = getFactory().create(getName(), new List[]{getSemantics(1), getSemantics(0)}, new String[]{getDimensionName(1), getDimensionName(0)});
             for (int x=0; x<getDim(0); x++){
                 for (int y=0; y<getDim(1); y++){
                     result.setValue(y,x, getValue(x,y));
@@ -446,7 +464,7 @@
         }
         correspondance = tmpcorrespondance;
 
-        MatrixND result = new MatrixNDImpl(getName(), newSemantics, newDimNames);
+        MatrixND result = getFactory().create(getName(), newSemantics, newDimNames);
 
         // on reprend les valeurs
         int [] newCoordinates = new int[result.getNbDim()];
@@ -468,9 +486,9 @@
             throw new MatrixException("Le nombre de colonnes de la matrice m1 doit etre egal au nombre de lignes de la matrice m2");
         }
 
-        MatrixND result = new MatrixNDImpl(new int[]{this.getDim(0),
+        MatrixND result = getFactory().create(new int[]{this.getDim(0),
         m.getDim(1)});
-        float d;
+        double d;
         for (int x=0; x<this.getDim(0); x++){
             for (int y=0; y<m.getDim(1); y++){
                 d = this.getValue(x, 0) * m.getValue(0, y);
@@ -483,18 +501,18 @@
         return result;
     }
 
-    public MatrixND mults(final float d){
+    public MatrixND mults(final double d){
         map(new MapFunction(){
-            public float apply(float val){
+            public double apply(double val){
                 return val * d;
             }
         });
         return this;
     }
 
-    public MatrixND divs(final float d){
+    public MatrixND divs(final double d){
         map(new MapFunction(){
-            public float apply(float val){
+            public double apply(double val){
                 return val / d;
             }
         });

Index: lutinmatrix/src/java/org/codelutin/math/matrix/BasicMatrix.java
diff -u lutinmatrix/src/java/org/codelutin/math/matrix/BasicMatrix.java:1.3 lutinmatrix/src/java/org/codelutin/math/matrix/BasicMatrix.java:1.4
--- lutinmatrix/src/java/org/codelutin/math/matrix/BasicMatrix.java:1.3	Wed Oct  5 20:25:05 2005
+++ lutinmatrix/src/java/org/codelutin/math/matrix/BasicMatrix.java	Thu Oct 20 20:58:04 2005
@@ -23,9 +23,9 @@
  * Created: 27 oct. 2004
  *
  * @author Benjamin Poussin <poussin@codelutin.com>
- * @version $Revision: 1.3 $
+ * @version $Revision: 1.4 $
  *
- * Mise a jour: $Date: 2005/10/05 20:25:05 $
+ * Mise a jour: $Date: 2005/10/20 20:58:04 $
  * par : $Author: bpoussin $
  */
 
@@ -36,15 +36,17 @@
 import org.codelutin.i18n.I18n;
 
 /**
-* Objet matrice qui ne permet que le stockage de float dans un matrice à
+* Objet matrice qui ne permet que le stockage de double dans un matrice à
 * autant de dimension que l'on souhaite.
 */
 public class BasicMatrix { // BasicMatrix
 
+    /** La factory */
+    protected MatrixFactory factory = null;
     /** Les dimensions de la matrice */
     protected int [] dimensions = null;
     /** La matrice en représentation linéaire */
-    protected float [] data = null;
+    protected Vector data = null;
     /** tableau de facteur permettant de convertir les coordonnées dans la
     * matrice en un indice dans la représentation linéaire de la matrice */
     protected int [] linearFactor = null;
@@ -52,7 +54,8 @@
     /**
     * Crée une nouvelle matrice ayant les dimensions demandées
     */
-    public BasicMatrix(int [] dimensions){
+    public BasicMatrix(MatrixFactory factory, int [] dimensions){
+        this.factory = factory;
         checkDim(dimensions);
 
         // copie des dimensions pour que personne à l'extérieur de l'objet
@@ -68,7 +71,7 @@
         }
 
         // creation de la matrice lineaire
-        data = new float[linearFactor[0] * dimensions[0]];
+        data = factory.createVector(linearFactor[0] * dimensions[0]);
     }
 
     /**
@@ -78,8 +81,8 @@
     * @return la valeur la plus nombreuse dans la matrice, ou la plus petite
     * si plusieurs valeur se retourve le même nombre de fois
     */
-    public float getMaxOccurence(){
-        return MatrixHelper.maxOccurence(data);
+    public double getMaxOccurence(){
+        return data.getMaxOccurence();
     }
 
     /**
@@ -114,9 +117,9 @@
     * Retourne un element de la matrice
     * @param pos la position de l'element à retourner
     */
-    public float getValue(int [] pos){
+    public double getValue(int [] pos){
         int indice = coordonatesToLinear(pos);
-        return data[indice];
+        return data.getValue(indice);
     }
 
     /**
@@ -124,9 +127,9 @@
     * @param pos la position de l'element à modifier
     * @param value la nouvelle valeur à mettre dans la matrice
     */
-    public void setValue(int [] pos, float value){
+    public void setValue(int [] pos, double value){
         int indice = coordonatesToLinear(pos);
-        data[indice] = value;
+        data.setValue(indice, value);
     }
 
     /**
@@ -143,9 +146,13 @@
     * @param f la fonction a appliquer à chaque élement de la matrice
     */
     public void map(MapFunction f){
-        for(int i=0; i<data.length; i++){
-            float result = f.apply(data[i]);
-            data[i] = result;
+        if (data.isImplementedMap()) {
+            data.map(f);
+        } else {
+            for(int i=0; i<data.size(); i++){
+                double result = f.apply(data.getValue(i));
+                data.setValue(i,result);
+            }
         }
     }
 
@@ -226,8 +233,8 @@
         StringBuffer result = new StringBuffer();
         if(getNbDim() == 1){
             result.append("matrix1D [");
-            for(int i=0; i<data.length; i++){
-                result.append(data[i] + ",");
+            for(int i=0; i<data.size(); i++){
+                result.append(data.getValue(i) + ",");
             }
             result.append("]");
         }else if(getNbDim() == 2){
@@ -246,8 +253,8 @@
                 result.append(dimensions[i] + ",");
             }
             result.append("\n]\nmatrice = [\n");
-            for(int i=0; i<data.length; i++){
-                result.append(data[i] + ",");
+            for(int i=0; i<data.size(); i++){
+                result.append(data.getValue(i) + ",");
             }
             result.append("\n]\nlinearFactor = [\n");
             for(int i=0; i<linearFactor.length; i++){
@@ -261,7 +268,9 @@
     public boolean equals(Object o){
         if(o instanceof BasicMatrix){
             BasicMatrix other = (BasicMatrix)o;
-            return Arrays.equals(this.dimensions, other.dimensions) && Arrays.equals(this.data, other.data);
+            return this == o ||
+                (Arrays.equals(this.dimensions, other.dimensions) &&
+                this.data.equals(other.data));
         }
         return false;
     }
@@ -283,7 +292,7 @@
         }
 
         public boolean hasNext(){
-            return pos + 1 < matrix.data.length;
+            return pos + 1 < matrix.data.size();
         }
 
         public boolean next(){
@@ -295,12 +304,12 @@
             }
         }
 
-        public float getValue(){
-            return matrix.data[pos];
+        public double getValue(){
+            return matrix.data.getValue(pos);
         }
 
-        public void setValue(float value){
-            matrix.data[pos] = value;
+        public void setValue(double value){
+            matrix.data.setValue(pos, value);
         }
 
         public int [] getCoordinates(){
@@ -308,8 +317,6 @@
         }
 
     } // BasicMatrixIteratorImpl
-
-
 
 } // BasicMatrix
 

Index: lutinmatrix/src/java/org/codelutin/math/matrix/BasicMatrixIterator.java
diff -u lutinmatrix/src/java/org/codelutin/math/matrix/BasicMatrixIterator.java:1.2 lutinmatrix/src/java/org/codelutin/math/matrix/BasicMatrixIterator.java:1.3
--- lutinmatrix/src/java/org/codelutin/math/matrix/BasicMatrixIterator.java:1.2	Wed Oct  5 20:25:05 2005
+++ lutinmatrix/src/java/org/codelutin/math/matrix/BasicMatrixIterator.java	Thu Oct 20 20:58:04 2005
@@ -23,9 +23,9 @@
  * Created: 28 oct. 2004
  *
  * @author Benjamin Poussin <poussin@codelutin.com>
- * @version $Revision: 1.2 $
+ * @version $Revision: 1.3 $
  *
- * Mise a jour: $Date: 2005/10/05 20:25:05 $
+ * Mise a jour: $Date: 2005/10/20 20:58:04 $
  * par : $Author: bpoussin $
  */
 
@@ -52,12 +52,12 @@
     /**
     * Retourne la valeur courant pointé par l'iterator
     */
-    public float getValue();
+    public double getValue();
 
     /**
     * Modifie la valeur courant pointé par l'iterator
     */
-    public void setValue(float value);
+    public void setValue(double value);
 
 } // BasicMatrixIterator
 

Index: lutinmatrix/src/java/org/codelutin/math/matrix/MapFunction.java
diff -u lutinmatrix/src/java/org/codelutin/math/matrix/MapFunction.java:1.2 lutinmatrix/src/java/org/codelutin/math/matrix/MapFunction.java:1.3
--- lutinmatrix/src/java/org/codelutin/math/matrix/MapFunction.java:1.2	Wed Oct  5 20:25:05 2005
+++ lutinmatrix/src/java/org/codelutin/math/matrix/MapFunction.java	Thu Oct 20 20:58:04 2005
@@ -23,9 +23,9 @@
  * Created: 27 oct. 2004
  *
  * @author Benjamin Poussin <poussin@codelutin.com>
- * @version $Revision: 1.2 $
+ * @version $Revision: 1.3 $
  *
- * Mise a jour: $Date: 2005/10/05 20:25:05 $
+ * Mise a jour: $Date: 2005/10/20 20:58:04 $
  * par : $Author: bpoussin $
  */
 
@@ -40,7 +40,7 @@
     * @return la nouvelle valeur à mettre dans la matrice à la place de
     * l'ancienne.
     */
-    public float apply(float value);
+    public double apply(double value);
 
 } // MapFunction
 

Index: lutinmatrix/src/java/org/codelutin/math/matrix/MatrixHelper.java
diff -u lutinmatrix/src/java/org/codelutin/math/matrix/MatrixHelper.java:1.5 lutinmatrix/src/java/org/codelutin/math/matrix/MatrixHelper.java:1.6
--- lutinmatrix/src/java/org/codelutin/math/matrix/MatrixHelper.java:1.5	Wed Oct  5 20:25:05 2005
+++ lutinmatrix/src/java/org/codelutin/math/matrix/MatrixHelper.java	Thu Oct 20 20:58:04 2005
@@ -23,9 +23,9 @@
  * Created: 28 oct. 2004
  *
  * @author Benjamin Poussin <poussin@codelutin.com>
- * @version $Revision: 1.5 $
+ * @version $Revision: 1.6 $
  *
- * Mise a jour: $Date: 2005/10/05 20:25:05 $
+ * Mise a jour: $Date: 2005/10/20 20:58:04 $
  * par : $Author: bpoussin $
  */
 
@@ -155,28 +155,28 @@
     * @param value la valeur de remplissage
     * @return la matrice passé en paramètre
     */
-    static public MatrixND fill(MatrixND mat, final float value){
+    static public MatrixND fill(MatrixND mat, final double value){
         mat.map(new MapFunction(){
-            public float apply(float v){
+            public double apply(double v){
                 return value;
             }
         });
         return mat;
     }
 
-    /**
-    * Crée une nouvelle matrice identité. Une matrice identité est une matrice
-    * à 2 dimensions dont tous les éléments de la diagonal vaut 1
-    * @param size la taille de la matrice
-    * @return une nouvelle matrice identité
-    */
-    static public MatrixND matrixId(int size){
-        MatrixND result = new MatrixNDImpl(new int[]{size, size});
-        for(int i=0; i<size; i++){
-            result.setValue(i, i , 1);
-        }
-        return result;
-    }
+    // /**
+    // * Crée une nouvelle matrice identité. Une matrice identité est une matrice
+    // * à 2 dimensions dont tous les éléments de la diagonal vaut 1
+    // * @param size la taille de la matrice
+    // * @return une nouvelle matrice identité
+    // */
+    // static public MatrixND matrixId(int size){
+    //     MatrixND result = new MatrixNDImpl(new int[]{size, size});
+    //     for(int i=0; i<size; i++){
+    //         result.setValue(i, i , 1);
+    //     }
+    //     return result;
+    // }
 
     /**
     * Retourne la valeur la plus courrement rencontrer dans un tableau.
@@ -185,12 +185,30 @@
     * @param tab le tableau de valeur
     * @return la valeur la plus nombreuse dans le tableau
     */
-    static public float maxOccurence(float [] tab){
-        if(tab.length == 0){
+    static public double maxOccurence(double [] tab){
+        double [] tmp = new double[tab.length];
+        System.arraycopy(tab, 0, tmp, 0, tab.length);
+        return maxOccurence1(tmp);
+    }
+
+    static public double maxOccurence(float [] tab){
+        double [] tmp = new double[tab.length];
+        for(int i=0; i<tab.length; i++){
+            tmp[i] = tab[i];
+        }
+        return maxOccurence1(tmp);
+    }
+
+    /**
+    * le tableau en entre est trie durant l'execution de la methode, il est
+    * donc modifié
+    */
+    static protected double maxOccurence1(double [] tmp){
+        if(tmp.length == 0){
             throw new IllegalArgumentException("Array must be not empty");
         }
-        float [] tmp = new float[tab.length];
-        System.arraycopy(tab, 0, tmp, 0, tab.length);
+        // double [] tmp = new double[tab.length];
+        // System.arraycopy(tab, 0, tmp, 0, tab.length);
         Arrays.sort(tmp);
 
         // le nombre de fois que l'on a rencontrer la valeur la plus nombreuse
@@ -198,11 +216,11 @@
         // le nombre de fois que l'on a rencontrer la valeur courante
         int count = 1;
         // la valeur la plus rencontrer
-        float result = tmp[0];
+        double result = tmp[0];
         // la valeur que l'on vient de traiter précédement
-        float old = tmp[0];
+        double old = tmp[0];
         // la valeur courante lu dans le tableaux
-        float current = tmp[0];
+        double current = tmp[0];
         // tant que l'on peut encore trouve un element plus nombreux dans le
         // tableau on le parcours
         for(int i=1; max<tmp.length-i+count && i<tmp.length; i++){
@@ -266,11 +284,11 @@
 //    /**
 //     * Multiplication d'une matrice par un scalaire
 //     */
-//    public MatriceND mults(float d)throws MatriceException;
+//    public MatriceND mults(double d)throws MatriceException;
 //    /**
 //     * Multiplication d'une matrice par un scalaire
 //     */
-//    public MatriceND divs(float d)throws MatriceException;
+//    public MatriceND divs(double d)throws MatriceException;
 //    /**
 //     * Multiplication d'une vecteur [i] avec une matrice [i,j],
 //     * le resultat est result[i,j]=matrice[i,j]*vecteur[i]

Index: lutinmatrix/src/java/org/codelutin/math/matrix/MatrixIteratorImpl.java
diff -u lutinmatrix/src/java/org/codelutin/math/matrix/MatrixIteratorImpl.java:1.2 lutinmatrix/src/java/org/codelutin/math/matrix/MatrixIteratorImpl.java:1.3
--- lutinmatrix/src/java/org/codelutin/math/matrix/MatrixIteratorImpl.java:1.2	Wed Oct  5 20:25:05 2005
+++ lutinmatrix/src/java/org/codelutin/math/matrix/MatrixIteratorImpl.java	Thu Oct 20 20:58:04 2005
@@ -23,9 +23,9 @@
  * Created: 28 oct. 2004
  *
  * @author Benjamin Poussin <poussin@codelutin.com>
- * @version $Revision: 1.2 $
+ * @version $Revision: 1.3 $
  *
- * Mise a jour: $Date: 2005/10/05 20:25:05 $
+ * Mise a jour: $Date: 2005/10/20 20:58:04 $
  * par : $Author: bpoussin $
  */
 
@@ -62,11 +62,11 @@
         return iterator.getCoordinates();
     }
 
-    public float getValue(){
+    public double getValue(){
         return iterator.getValue();
     }
 
-    public void setValue(float value){
+    public void setValue(double value){
         iterator.setValue(value);
     }
 

Index: lutinmatrix/src/java/org/codelutin/math/matrix/MatrixND.java
diff -u lutinmatrix/src/java/org/codelutin/math/matrix/MatrixND.java:1.4 lutinmatrix/src/java/org/codelutin/math/matrix/MatrixND.java:1.5
--- lutinmatrix/src/java/org/codelutin/math/matrix/MatrixND.java:1.4	Wed Oct  5 20:25:05 2005
+++ lutinmatrix/src/java/org/codelutin/math/matrix/MatrixND.java	Thu Oct 20 20:58:04 2005
@@ -23,9 +23,9 @@
 * Created: 29 oct. 2004
 *
 * @author Benjamin Poussin <poussin@codelutin.com>
-* @version $Revision: 1.4 $
+* @version $Revision: 1.5 $
 *
-* Mise a jour: $Date: 2005/10/05 20:25:05 $
+* Mise a jour: $Date: 2005/10/20 20:58:04 $
 * par : $Author: bpoussin $
 */
 
@@ -36,6 +36,11 @@
 public interface MatrixND { // MatrixND
 
     /**
+    * Retourne la factory qui a permit de creer la matrice
+    */
+    public MatrixFactory getFactory();
+
+    /**
     * Donne toutes les semantiques de la matrice
     * Si la matrice n'a pas de semantique retourne null
     */
@@ -93,7 +98,7 @@
     * @param tab le tableau de valeur
     * @return la valeur la plus nombreuse dans le tableau
     */
-    public float getMaxOccurence();
+    public double getMaxOccurence();
 
     /**
     * Retourne le nombre de dimensions de la matrice.
@@ -118,7 +123,7 @@
     /**
     * Applique une fonction sur chaque valeur de la matrice
     */
-    public void map(MapFunction f);
+    public MatrixND map(MapFunction f);
 
 //    /**
 //    * Retourne la sous matrice demandée en fonction des dimensions
@@ -152,19 +157,19 @@
     * tableau doit contenir toutes les dimensions de la matrice, et
     * seulement des nombres positif
     *
-    * @return un entier float.
+    * @return un entier double.
     */
-    public float getValue(int [] dim);
-    public float getValue(int x);
-    public float getValue(int x, int y);
-    public float getValue(int x, int y, int z);
-    public float getValue(int x, int y, int z, int t);
-
-    public float getValue(Object [] coordinates);
-    public float getValue(Object x);
-    public float getValue(Object x, Object y);
-    public float getValue(Object x, Object y, Object z);
-    public float getValue(Object x, Object y, Object z, Object t);
+    public double getValue(int [] dim);
+    public double getValue(int x);
+    public double getValue(int x, int y);
+    public double getValue(int x, int y, int z);
+    public double getValue(int x, int y, int z, int t);
+
+    public double getValue(Object [] coordinates);
+    public double getValue(Object x);
+    public double getValue(Object x, Object y);
+    public double getValue(Object x, Object y, Object z);
+    public double getValue(Object x, Object y, Object z, Object t);
 
 //    /**
 //    * Modifie la sous matrice demandée en fonction des dimensions
@@ -198,20 +203,20 @@
     *
     * @param dimensions les différentes dimension à extraire.
     *
-    * @param d l'entier float qui doit remplacer l'entier float spécifié
+    * @param d l'entier double qui doit remplacer l'entier double spécifié
     * par l'argument dimensions
     */
-    public void setValue(int [] dimensions, float d);
-    public void setValue(int x, float d);
-    public void setValue(int x, int y, float d);
-    public void setValue(int x, int y, int z, float d);
-    public void setValue(int x, int y, int z, int t, float d);
-
-    public void setValue(Object [] coordinates, float d);
-    public void setValue(Object x, float d);
-    public void setValue(Object x, Object y, float d);
-    public void setValue(Object x, Object y, Object z, float d);
-    public void setValue(Object x, Object y, Object z, Object t, float d);
+    public void setValue(int [] dimensions, double d);
+    public void setValue(int x, double d);
+    public void setValue(int x, int y, double d);
+    public void setValue(int x, int y, int z, double d);
+    public void setValue(int x, int y, int z, int t, double d);
+
+    public void setValue(Object [] coordinates, double d);
+    public void setValue(Object x, double d);
+    public void setValue(Object x, Object y, double d);
+    public void setValue(Object x, Object y, Object z, double d);
+    public void setValue(Object x, Object y, Object z, Object t, double d);
 
 //    /**
 //    * Copy la matrice pour pouvoir la modifier sans perdre les
@@ -464,11 +469,11 @@
     /**
     * Multiplication d'une matrice par un scalaire
     */
-    public MatrixND mults(final float d);
+    public MatrixND mults(final double d);
     /**
     * Multiplication d'une matrice par un scalaire
     */
-    public MatrixND divs(final float d);
+    public MatrixND divs(final double d);
 //    /**
 //    * Multiplication d'une vecteur [i] avec une matrice [i,j],
 //    * le resultat est result[i,j]=matrice[i,j]*vecteur[i]

Index: lutinmatrix/src/java/org/codelutin/math/matrix/MatrixNDImpl.java
diff -u lutinmatrix/src/java/org/codelutin/math/matrix/MatrixNDImpl.java:1.4 lutinmatrix/src/java/org/codelutin/math/matrix/MatrixNDImpl.java:1.5
--- lutinmatrix/src/java/org/codelutin/math/matrix/MatrixNDImpl.java:1.4	Wed Oct  5 20:25:05 2005
+++ lutinmatrix/src/java/org/codelutin/math/matrix/MatrixNDImpl.java	Thu Oct 20 20:58:04 2005
@@ -23,69 +23,62 @@
 * Created: 29 oct. 2004
 *
 * @author Benjamin Poussin <poussin@codelutin.com>
-* @version $Revision: 1.4 $
+* @version $Revision: 1.5 $
 *
-* Mise a jour: $Date: 2005/10/05 20:25:05 $
+* Mise a jour: $Date: 2005/10/20 20:58:04 $
 * par : $Author: bpoussin $
 */
 
 package org.codelutin.math.matrix;
 
+import java.util.Arrays;
 import java.util.List;
 
 public class MatrixNDImpl extends AbstractMatrixND { // MatrixNDImpl
 
     protected BasicMatrix matrix = null;
 
-    public MatrixNDImpl(int [] dim){
-        super(dim);
-        matrix = new BasicMatrix(dim);
+    protected MatrixNDImpl(MatrixFactory factory, int [] dim){
+        super(factory, dim);
+        matrix = new BasicMatrix(factory, dim);
     }
-    public MatrixNDImpl(List[] semantics){
-        super(semantics);
-        matrix = new BasicMatrix(dim);
+    protected MatrixNDImpl(MatrixFactory factory, List[] semantics){
+        super(factory, semantics);
+        matrix = new BasicMatrix(factory, dim);
     }
 
-    public MatrixNDImpl(String name, int [] dim){
-        super(name, dim);
-        matrix = new BasicMatrix(dim);
+    protected MatrixNDImpl(MatrixFactory factory, String name, int [] dim){
+        super(factory, name, dim);
+        matrix = new BasicMatrix(factory, dim);
     }
 
-    public MatrixNDImpl(String name, List[] semantics){
-        super(name, semantics);
-        matrix = new BasicMatrix(dim);
+    protected MatrixNDImpl(MatrixFactory factory, String name, List[] semantics){
+        super(factory, name, semantics);
+        matrix = new BasicMatrix(factory, dim);
     }
 
-    public MatrixNDImpl(String name, List[] semantics, String [] dimNames){
-        super(name, semantics, dimNames);
-        matrix = new BasicMatrix(dim);
+    protected MatrixNDImpl(MatrixFactory factory, String name, List[] semantics, String [] dimNames){
+        super(factory, name, semantics, dimNames);
+        matrix = new BasicMatrix(factory, dim);
     }
 
-    public MatrixNDImpl(MatrixND matrix){
-        super(matrix.getName(), matrix.getSemantics(), matrix.getDimensionName());
-        this.matrix = new BasicMatrix(dim);
-        for(MatrixIterator i=matrix.iterator(); i.next();){
-            setValue(i.getCoordinates(), i.getValue());
-        }
+    protected MatrixNDImpl(MatrixFactory factory, MatrixND matrix){
+        super(factory, matrix.getName(), matrix.getSemantics(), matrix.getDimensionName());
+        this.matrix = new BasicMatrix(factory, dim);
+        this.paste(matrix);
     }
 
     public MatrixIterator iterator(){
         return new MatrixIteratorImpl(matrix.iterator(), getSemantics());
     }
-    public float getValue(int [] coordinates){
+    public double getValue(int [] coordinates){
         return matrix.getValue(coordinates);
     }
-    public void setValue(int [] coordinates, float d){
-        matrix.setValue(coordinates, d);
-    }
-
-    // Hack pour ne pas a avoir a caster les double en float pour que l'appel
-    // se passe bien (surtout util au travers de langage de script
     public void setValue(int [] coordinates, double d){
-        setValue(coordinates, (float)d);
+        matrix.setValue(coordinates, d);
     }
 
-    public float getMaxOccurence(){
+    public double getMaxOccurence(){
         return matrix.getMaxOccurence();
     }
 
@@ -93,5 +86,64 @@
         return getName() + " " + matrix.toString();
     }
 
+    // Un peu d'optimisation pour les matrices entieres (pas de sub matrix)
+    /**
+    * Si le vector utilise par la BasicMatix supporte la method map,
+    * on l'utilise pour gagner du temps
+    */
+    public MatrixND map(MapFunction f){
+        if (matrix.data.isImplementedMap()) {
+            matrix.data.map(f);
+        } else {
+            super.map(f);
+        }
+        return this;
+    }
+
+    /**
+    * Si on peut on utilise le paste du vector de BasicMatix, sinon
+    * on utilise la methode de AbstractMatrixND.
+    */
+    public MatrixND paste(int [] origin,  MatrixND mat){
+        // permet de savoir si l'origin est bien le point 0 de la matrice
+        boolean origin0 = true;
+        for (int i=0; i<origin.length && origin0; i++) {
+            origin0 = origin0 && origin[i] == 0;
+        }
+        if (origin0 && mat instanceof MatrixNDImpl &&
+            Arrays.equals(mat.getDim(), this.getDim()) &&
+            matrix.data.isImplementedPaste(((MatrixNDImpl)mat).matrix.data)){
+            matrix.data.paste(((MatrixNDImpl)mat).matrix.data);
+        } else {
+            super.paste(origin, mat);
+        }
+        return this;
+    }
+
+    public MatrixND add(MatrixND m){
+        if (m instanceof MatrixNDImpl &&
+            matrix.data.isImplementedAdd(((MatrixNDImpl)m).matrix.data)){
+            matrix.data.add(((MatrixNDImpl)m).matrix.data);
+        } else {
+            super.add(m);
+        }
+        return this;
+    }
+
+    /**
+    * Modifie la matrice actuelle en lui soustrayant les valeurs de la matrice
+    * passé en parametre. La matrice passé en parametre doit avoir le meme
+    * nombre de dimension, et chacune de ses dimensions doit avoir un nombre
+    * d'element au moins egal a cette matrice.
+    */
+    public MatrixND minus(MatrixND m){
+        if (m instanceof MatrixNDImpl &&
+            matrix.data.isImplementedMinus(((MatrixNDImpl)m).matrix.data)){
+            matrix.data.minus(((MatrixNDImpl)m).matrix.data);
+        } else {
+            super.minus(m);
+        }
+        return this;
+    }
 } // MatrixNDImpl
 

Index: lutinmatrix/src/java/org/codelutin/math/matrix/MatrixXMLDelegator.java
diff -u lutinmatrix/src/java/org/codelutin/math/matrix/MatrixXMLDelegator.java:1.2 lutinmatrix/src/java/org/codelutin/math/matrix/MatrixXMLDelegator.java:1.3
--- lutinmatrix/src/java/org/codelutin/math/matrix/MatrixXMLDelegator.java:1.2	Wed Oct  5 20:25:05 2005
+++ lutinmatrix/src/java/org/codelutin/math/matrix/MatrixXMLDelegator.java	Thu Oct 20 20:58:04 2005
@@ -23,9 +23,9 @@
  * Created: 5 nov. 2004
  *
  * @author Benjamin Poussin <poussin@codelutin.com>
- * @version $Revision: 1.2 $
+ * @version $Revision: 1.3 $
  *
- * Mise a jour: $Date: 2005/10/05 20:25:05 $
+ * Mise a jour: $Date: 2005/10/20 20:58:04 $
  * par : $Author: bpoussin $
  */
 
@@ -53,7 +53,7 @@
     public Element encodeVersion(XMLEncoderDecoder ed, Object o){
         MatrixND matrix = (MatrixND)o;
 
-        float defaultValue = matrix.getMaxOccurence();
+        double defaultValue = matrix.getMaxOccurence();
 
         Element result = DocumentHelper.createElement("matrix");
         result.addAttribute("defaultValue", ""+defaultValue);
@@ -97,7 +97,7 @@
 
         // ecriture des valeur de la matrice
         for(MatrixIterator i=matrix.iterator(); i.next();){
-            float val = i.getValue();
+            double val = i.getValue();
             if(val != defaultValue){
                 String path = MatrixHelper.coordinatesToString(i.getCoordinates());
                 result.addElement("element").addAttribute("path", path).addAttribute("value", ""+val);
@@ -117,11 +117,11 @@
         int [] dims = ArrayUtil.asIntArray(dimensions);
 
         // creation du resultat
-        MatrixND result = new MatrixNDImpl(dims);
+        MatrixND result = MatrixFactory.getInstance().create(dims);
 
         // recuperation de la valeur par defaut de la matrice
         String defaultValueString = root.attributeValue("defaultElem", "0");
-        float defaultValue = Float.parseFloat(defaultValueString);
+        double defaultValue = Double.parseDouble(defaultValueString);
         MatrixHelper.fill(result, defaultValue);
 
         //on remet toutes les valeurs dans la matrice
@@ -132,7 +132,7 @@
             int [] dim = ArrayUtil.asIntArray(path);
 
             String v = elem.attributeValue("function");
-            result.setValue(dim, Float.parseFloat(v));
+            result.setValue(dim, Double.parseDouble(v));
         }
 
         return result;
@@ -149,11 +149,11 @@
         int [] dims = ArrayUtil.asIntArray(dimensions);
 
         // creation du resultat
-        MatrixND result = new MatrixNDImpl(dims);
+        MatrixND result = MatrixFactory.getInstance().create(dims);
 
         // recuperation de la valeur par defaut de la matrice
         String defaultValueString = root.attributeValue("defaultValue", "0");
-        float defaultValue = Float.parseFloat(defaultValueString);
+        double defaultValue = Double.parseDouble(defaultValueString);
         MatrixHelper.fill(result, defaultValue);
 
         // on change le nom
@@ -199,7 +199,7 @@
             int [] dim = ArrayUtil.asIntArray(path);
 
             String v = elem.attributeValue("value");
-            result.setValue(dim, Float.parseFloat(v));
+            result.setValue(dim, Double.parseDouble(v));
         }
 
         return result;

Index: lutinmatrix/src/java/org/codelutin/math/matrix/SubMatrix.java
diff -u lutinmatrix/src/java/org/codelutin/math/matrix/SubMatrix.java:1.4 lutinmatrix/src/java/org/codelutin/math/matrix/SubMatrix.java:1.5
--- lutinmatrix/src/java/org/codelutin/math/matrix/SubMatrix.java:1.4	Wed Oct  5 20:25:05 2005
+++ lutinmatrix/src/java/org/codelutin/math/matrix/SubMatrix.java	Thu Oct 20 20:58:04 2005
@@ -23,9 +23,9 @@
  * Created: 29 oct. 2004
  *
  * @author Benjamin Poussin <poussin@codelutin.com>
- * @version $Revision: 1.4 $
+ * @version $Revision: 1.5 $
  *
- * Mise a jour: $Date: 2005/10/05 20:25:05 $
+ * Mise a jour: $Date: 2005/10/20 20:58:04 $
  * par : $Author: bpoussin $
  */
 
@@ -47,7 +47,7 @@
     protected DimensionConverter converter = null;
 
     public SubMatrix(MatrixND matrix, int dim, int start, int nb){
-        super(matrix.getName(), matrix.getSemantics(), matrix.getDimensionName());
+        super(matrix.getFactory(), matrix.getName(), matrix.getSemantics(), matrix.getDimensionName());
         this.matrix = matrix;
 
         converter = new ShiftConverter(dim, start, nb);
@@ -56,7 +56,7 @@
     }
 
     public SubMatrix(MatrixND matrix, int dim, int [] elem){
-        super(matrix.getName(), matrix.getSemantics(), matrix.getDimensionName());
+        super(matrix.getFactory(), matrix.getName(), matrix.getSemantics(), matrix.getDimensionName());
         this.matrix = matrix;
 
         converter = new MappingConverter(dim, elem);
@@ -74,11 +74,11 @@
         return new SubMatrixIteratorImpl(this);
     }
 
-    public float getValue(int [] coordinates){
+    public double getValue(int [] coordinates){
         return matrix.getValue(converter.convertCoordinates(coordinates));
     }
 
-    public void setValue(int [] coordinates, float d){
+    public void setValue(int [] coordinates, double d){
         matrix.setValue(converter.convertCoordinates(coordinates), d);
     }
 
@@ -125,11 +125,11 @@
             return result;
         }
 
-        public float getValue(){
+        public double getValue(){
             return subMatrix.getValue(getCoordinates());
         }
 
-        public void setValue(float value){
+        public void setValue(double value){
             subMatrix.setValue(getCoordinates(), value);
         }