Index: lutinmatrix/src/java/org/codelutin/math/matrix/AbstractMatrixND.java
diff -u lutinmatrix/src/java/org/codelutin/math/matrix/AbstractMatrixND.java:1.1.1.1 lutinmatrix/src/java/org/codelutin/math/matrix/AbstractMatrixND.java:1.2
--- lutinmatrix/src/java/org/codelutin/math/matrix/AbstractMatrixND.java:1.1.1.1	Tue Nov  2 16:25:32 2004
+++ lutinmatrix/src/java/org/codelutin/math/matrix/AbstractMatrixND.java	Thu Nov  4 13:50:17 2004
@@ -23,14 +23,15 @@
  * Created: 29 oct. 2004
  *
  * @author Benjamin Poussin <poussin@codelutin.com>
- * @version $Revision: 1.1.1.1 $
+ * @version $Revision: 1.2 $
  *
- * Mise a jour: $Date: 2004/11/02 16:25:32 $
+ * Mise a jour: $Date: 2004/11/04 13:50:17 $
  * par : $Author: bpoussin $
  */
 
 package org.codelutin.math.matrix;
 
+import org.codelutin.util.ArrayUtil;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
@@ -68,35 +69,33 @@
             semantics[i] = Collections.nCopies(dim[i], null);
         }
     }
+    public AbstractMatrixND(List[] semantics){
+        int [] dim = new int[semantics.length];
+        for(int i=0; i<dim.length; i++){
+            dim[i] = semantics[i].size();
+        }
+        init(dim);
+        for(int i=0; i<getNbDim(); i++){
+            setSemantics(i, semantics[i]);
+        }
+    }
 
     public AbstractMatrixND(String name, int [] dim){
         this(dim);
         setName(name);
     }
-    public AbstractMatrixND(String name, int [] dim, List[] semantics){
-        init(dim);
+    public AbstractMatrixND(String name, List[] semantics){
+        this(semantics);
         setName(name);
-        for(int i=0; i<getNbDim(); i++){
-            setSemantics(i, semantics[i]);
-        }
     }
 
-    public AbstractMatrixND(String name, int [] dim, List[] semantics, String [] dimNames){
-        init(dim);
-        setName(name);
+    public AbstractMatrixND(String name, List[] semantics, String [] dimNames){
+        this(name, semantics);
         for(int i=0; i<getNbDim(); i++){
-            setSemantics(i, semantics[i]);
             setDimensionName(i, dimNames[i]);
         }
     }
 
-    public AbstractMatrixND(MatrixND matrix){
-        this(matrix.getName(), matrix.getDim(), matrix.getSemantics(), matrix.getDimensionName());
-        for(MatrixIterator i=matrix.iterator(); i.next();){
-            setValue(i.getCoordinates(), i.getValue());
-        }
-    }
-
     public List[] getSemantics(){
         return semantics;
     }
@@ -235,37 +234,82 @@
         return result;
     }
 
-//    public boolean dimValid(int [] dim){
-//        boolean result = getNbDim() == dim.length;
-//        for(int i=0; result && i<dim.length; i++){
-//                result = 0 <= dim[i] && dim[i] < getDim(i);
-//        }
-//        return result;
-//    }
+    public boolean isValidCoordinates(int [] dim){
+        boolean result = getNbDim() == dim.length;
+        for(int i=0; result && i<dim.length; i++){
+            result = 0 <= dim[i] && dim[i] < getDim(i);
+        }
+        return result;
+    }
 
     public MatrixND sumOverDim(int dim){
-        return sumOverDim(dim, 1);
+        return sumOverDim(dim, getDim(dim));
     }
-    public MatrixND sumOverDim(int dim, int pas){
-        int [] dimensions = new int[getNbDim()];
-        System.arraycopy(getDim(), 0, dimensions, 0, getNbDim());
-        dimensions[dim] = pas;
+
+    public MatrixND sumOverDim(int dim, int step){
+        if(step < 0){
+            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);
+        }
+
+        // le nombre d'element qu'il y aura dans la dim pour le resultat
+        int nbDim = getDim(dim) / step;
+
         List [] semantics = new List[getNbDim()];
         System.arraycopy(getSemantics(), 0, semantics, 0, getNbDim());
-        semantics[dim] = semantics[dim].subList(0, pas);
-        MatrixND result = new MatrixNDImpl(getName(), dimensions, semantics, getDimensionName());
-        for(int i=0; i<getDim(dim); i+=pas){
-            result.add(getSubMatrix(dim, i, pas));
+        semantics[dim] = semantics[dim].subList(0, nbDim);
+
+        // creation du resultat
+        MatrixND result = new MatrixNDImpl(getName(), semantics, getDimensionName());
+
+        for(int i=0; i<result.getDim(dim); i++){
+            MatrixND temp = getSubMatrix(dim, i*step, step);
+            MatrixND sum = result.getSubMatrix(dim, i, 1);
+            for(int s=0; s<temp.getDim(dim); s++){
+                sum.add(temp.getSubMatrix(dim, s, 1));
+            }
         }
         return result;
     }
+
     public MatrixND cut(int dim, int[] toCut){
-        // TODO
+        throw new UnsupportedOperationException("Méthode non implantée");
+    }
+
+    public MatrixND paste(MatrixND mat){
+        return paste(new int[getNbDim()], mat);
+    }
+
+    public MatrixND paste(int [] origin,  MatrixND mat){
+        for(MatrixIterator mi=mat.iterator(); mi.next();){
+            int [] coordinates = ArrayUtil.sum(origin, mi.getCoordinates());
+            if(isValidCoordinates(coordinates)){
+                setValue(coordinates, mi.getValue());
+            }
+        }
         return this;
     }
+
     public MatrixND getSubMatrix(int dim, int start, int nb){
+        if(dim < 0){
+            dim = getNbDim() + dim;
+        }
+        if(start < 0){
+            start = getDim(dim) + start;
+        }
+        if(nb <= 0){
+            nb = getDim(dim) - start;
+        }
         return new SubMatrix(this, dim, start, nb);
     }
+
+    public MatrixND getSubMatrix(int dim, Object start, int nb){
+        int begin = MatrixHelper.indexOf(getSemantics(), dim, start);
+        return getSubMatrix(dim, begin, nb);
+    }
+
     public MatrixND add(MatrixND m){
         for(MatrixIterator i=iterator(); i.next();){
             i.setValue(i.getValue() + m.getValue(i.getCoordinates()));
@@ -285,13 +329,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 int[]{1, getDim(0)}, new List[]{Collections.nCopies(1, null), getSemantics(0)}, new String[]{"Dimension 0", getDimensionName(0)});
+            MatrixND result = new MatrixNDImpl(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 int[]{getDim(1), getDim(0)}, new List[]{getSemantics(1), getSemantics(0)}, new String[]{getDimensionName(1), getDimensionName(0)});
+            MatrixND result = new MatrixNDImpl(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));
@@ -299,6 +343,92 @@
             }
             return result;
         }
+    }
+
+    public MatrixND reduce(){
+        // tableau permettant de faire la correspondance entre les dimensions
+        // de la matrice actuelle et les dimentsions de la nouvelle matrice
+        // l'element i du tableau qui correcpond à la dimensions i de la
+        // nouvelle matrice contient la dimension equivalente dans
+        // la matrice actuelle
+        int [] correspondance = new int[getNbDim()];
+        // les nouvelles semantiques
+        List sem = new ArrayList();
+        // les nouveaux noms de dimensions
+        List dimName = new ArrayList();
+        for (int j=0; j<getNbDim(); j++){
+            if (getDim(j) > 1 ){
+                // on ne conserve que les dimensions supérieure à 1
+                correspondance[sem.size()] = j;
+                sem.add(getSemantics(j));
+                dimName.add(getDimensionName(j));
+            }
+        }
+
+        if(sem.size() == 0){
+            // on a pas retrouve de dimension avec plus de 1 element
+            // on utilise alors les infos de la premiere dimension
+            correspondance[0] = 0;
+            sem.add(getSemantics(0));
+            dimName.add(getDimensionName(0));
+        }
+
+        List [] newSemantics = (List[])sem.toArray(new List[sem.size()]);
+        String [] newDimNames = (String[])dimName.toArray(new String[dimName.size()]);
+
+        MatrixND result = new MatrixNDImpl(getName(), newSemantics, newDimNames);
+
+        // on reprend les valeurs
+        int [] newCoordinates = new int[result.getNbDim()];
+        for(MatrixIterator mi=iterator(); mi.next();){
+            int [] oldCoordinates = mi.getCoordinates();
+            for(int i=0; i<newCoordinates.length; i++){
+                newCoordinates[i] = oldCoordinates[correspondance[i]];
+                result.setValue(newCoordinates, mi.getValue());
+            }
+        }
+        return result;
+    }
+
+    public MatrixND mult(MatrixND m)throws MatrixException{
+        if(this.getNbDim()>2 || m.getNbDim()>2){
+            throw new MatrixException("La multiplication de matrice n'est pas applicable aux matrices de plus de 2 dimensions");
+        }
+        if (!((this.getDim(1) == m.getDim(0)))){
+            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),
+        m.getDim(1)});
+        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);
+                for (int k=1; k<this.getDim(1); k++){
+                    d += this.getValue(x, k) * m.getValue(k, y);
+                }
+                result.setValue(x,y, d);
+            }
+        }
+        return result;
+    }
+
+    public MatrixND mults(final double d){
+        map(new MapFunction(){
+            public double apply(double val){
+                return val * d;
+            }
+        });
+        return this;
+    }
+
+    public MatrixND divs(final double d){
+        map(new MapFunction(){
+            public double apply(double val){
+                return val / d;
+            }
+        });
+        return this;
     }
 
 } // AbstractMatrixND

Index: lutinmatrix/src/java/org/codelutin/math/matrix/MatrixHelper.java
diff -u lutinmatrix/src/java/org/codelutin/math/matrix/MatrixHelper.java:1.2 lutinmatrix/src/java/org/codelutin/math/matrix/MatrixHelper.java:1.3
--- lutinmatrix/src/java/org/codelutin/math/matrix/MatrixHelper.java:1.2	Tue Nov  2 16:47:52 2004
+++ lutinmatrix/src/java/org/codelutin/math/matrix/MatrixHelper.java	Thu Nov  4 13:50:17 2004
@@ -23,16 +23,21 @@
  * Created: 28 oct. 2004
  *
  * @author Benjamin Poussin <poussin@codelutin.com>
- * @version $Revision: 1.2 $
+ * @version $Revision: 1.3 $
  *
- * Mise a jour: $Date: 2004/11/02 16:47:52 $
+ * Mise a jour: $Date: 2004/11/04 13:50:17 $
  * par : $Author: bpoussin $
  */
 
 package org.codelutin.math.matrix;
 
+import java.io.IOException;
+import java.io.StringReader;
+import java.io.StringWriter;
 import java.util.Arrays;
 import java.util.List;
+import java.util.logging.Level;
+import java.util.logging.Logger;
 import java.util.NoSuchElementException;
 
 public class MatrixHelper { // MatrixHelper
@@ -125,9 +130,10 @@
     * @param o l'objet à rechercher
     * @return la position de l'objet dans la dimension demandée
     */
-    static protected int indexOf(List [] semantics, int dim, Object o) throws NoSuchElementException{
-        if(o instanceof Integer)
+    static public int indexOf(List [] semantics, int dim, Object o) throws NoSuchElementException{
+        if(o instanceof Integer){
             return ((Integer)o).intValue();
+        }
         int result = -1;
         if((0 <= dim) && (dim < semantics.length)){
             result = semantics[dim].indexOf(o);
@@ -213,6 +219,23 @@
             result = current;
         }
         return result;
+    }
+
+    static public String encodeToXML(MatrixND mat){
+        try{
+            StringWriter out = new StringWriter();
+            MatrixEncoder encoder = new MatrixEncoder(out);
+            encoder.writeMatrice(mat);
+            return out.toString();
+        }catch(IOException eee){
+            Logger.getLogger(MatrixHelper.class + ".encodeToXML").log(Level.WARNING, "Normalement cette exception ne doit pas apparaitre, car on ecrit dans une chaine de caractere", eee);
+            throw new MatrixException("Erreur inattendue", eee);
+        }
+    }
+
+    static public MatrixND decodeFromXML(String xml){
+        MatrixDecoder decoder = new MatrixDecoder(new StringReader(xml));
+        return decoder.readMatrix();
     }
 
 //

Index: lutinmatrix/src/java/org/codelutin/math/matrix/MatrixND.java
diff -u lutinmatrix/src/java/org/codelutin/math/matrix/MatrixND.java:1.1.1.1 lutinmatrix/src/java/org/codelutin/math/matrix/MatrixND.java:1.2
--- lutinmatrix/src/java/org/codelutin/math/matrix/MatrixND.java:1.1.1.1	Tue Nov  2 16:25:31 2004
+++ lutinmatrix/src/java/org/codelutin/math/matrix/MatrixND.java	Thu Nov  4 13:50:17 2004
@@ -23,9 +23,9 @@
 * Created: 29 oct. 2004
 *
 * @author Benjamin Poussin <poussin@codelutin.com>
-* @version $Revision: 1.1.1.1 $
+* @version $Revision: 1.2 $
 *
-* Mise a jour: $Date: 2004/11/02 16:25:31 $
+* Mise a jour: $Date: 2004/11/04 13:50:17 $
 * par : $Author: bpoussin $
 */
 
@@ -235,8 +235,9 @@
 
 
     /**
-    * Somme la matrice sur une dimension donnée. Si la matrice avait
-    * 3 dimensions le résultat aura 2 dimensions.
+    * Somme la matrice sur une dimension donnée. La matrice résultat à le
+    * même nombre de dimension, pas la dimension sommer, ne contient qu'une
+    * ligne.
     * <p>
     * par exemple pour la matrice suivante si on somme sur la dimension 1
     * cela donnera
@@ -271,8 +272,22 @@
     * </pre>
     * c'est à dire que la ligne 0 et la ligne 2 sont sommées.
     * ainsi que la ligne 1 avec la ligne 3.
+    * @param dim la dimension sur lequel il faut faire les sommes
+    * @param step le pas qu'il faut utiliser pour regrouper les elements.
+    * Si le pas est inférieur à 0, le pas se comporte comme si on avait
+    * passé en argument la taille de la dimension. Un pas de 0 ou 1, retourne
+    * juste une copie de la matrice actuelle.
+    * si la division du pas avec la taille de la dimension ne donne pas un
+    * nombre entier, les elements restants ne sont pas pris en compte. Par
+    * exemple si la dimension a 10 élements et que l'on donne un pas de 3,
+    * dans la matrice resultat la dimension aura 3 elements qui seront la
+    * somme par 3 des 9 premiers element de la matrice courante. Le 10eme
+    * element sera perdu.
+    * @return une nouvelle matrice avec le meme nombre de dimension mais
+    * dont la dimension passé en paramètre aura comme taille, le resultat
+    * de la division entier de la taille actuelle par le step
     */
-    public MatrixND sumOverDim(int dim, int pas);
+    public MatrixND sumOverDim(int dim, int step);
 
     /**
     * Permet de supprimer des éléments de la matrice.
@@ -296,6 +311,25 @@
     */
     public MatrixND cut(int dim, int[] toCut);
 
+    /**
+    * Copie une matrice dans la matrice actuelle. La matrice à copier à le
+    * même nombre de dimension. Si la matrice à copier est trop grande
+    * seul les éléments pouvant être copier le seront.
+    * @param mat la matrice à copier
+    * @return return la matrice courante.
+    */
+    public MatrixND paste(MatrixND mat);
+
+    /**
+    * Copie une matrice dans la matrice actuelle. La matrice à copier à le
+    * même nombre de dimension. Si la matrice à copier est trop grande
+    * seul les éléments pouvant être copier le seront.
+    * @param origin le point à partir duquel il faut faire la copie
+    * @param mat la matrice à copier
+    * @return return la matrice courante.
+    */
+    public MatrixND paste(int [] origin,  MatrixND mat);
+
 //    /**
 //    * Permet de prendre une sous matrice dans la matrice.
 //    * par exemple pour la matrice suivante
@@ -331,6 +365,28 @@
 //    public MatrixND getSubMatrix(int [] origin, int [] toExtract, int [] nbToExtract);
 
     /**
+    * Permet de prendre une sous matrice dans la matrice courante. La sous
+    * matrice a le même nombre de dimensions mais sur une des dimensions
+    * on ne prend que certain élément.
+    * @param dim la dimension dans lequel on veut une sous matrice
+    * si dim est négatif alors la dimension est prise à partir de la fin
+    * par exemple si l'on veut la derniere dimension il faut passer -1 pour
+    * dim
+    * @param start la position dans dim d'ou il faut partir pour prendre
+    * la sous matrice.
+    * si start est négatif alors la position de départ est calculé par rapport
+    * à la fin de la dimension, pour avoir le dernier élément il faut passer
+    * -1
+    * @param nb le nombre d'élément à prendre dans la dimension. si nb est
+    * inférieur ou égal à 0 alors cela indique qu'il faut prendre tous les
+    * éléments jusqu'à la fin de la dimension.
+    */
+    public MatrixND getSubMatrix(int dim, Object start, int nb);
+
+    /**
+    * Permet de prendre une sous matrice dans la matrice courante. La sous
+    * matrice a le même nombre de dimensions mais sur une des dimensions
+    * on ne prend que certain élément.
     * @param dim la dimension dans lequel on veut une sous matrice
     * @param start la position dans dim d'ou il faut partir pour prendre
     * la sous matrice. 0 <= start < dim.size
@@ -354,24 +410,33 @@
     */
     public MatrixND transpose();
 
-//    /**
-//    * Multiplication normal de 2 matrices 2D. Retourne une nouvelle matrice
-//    */
-//    public MatrixND mult(MatrixND m);
+    /**
+    * Reduit la matrice de sorte que toutes les dimensions qui n'ont qu'un
+    * élement soit supprimée. Au pire cette méthode retourne une matrice
+    * à une seule dimension à un seul élément.
+    * @return une nouvelle matrice plus petite ou que la matrice actuelle
+    * ou egal s'il n'y a aucune dimension à supprimer
+    */
+    public MatrixND reduce();
+
+    /**
+    * Multiplication normal de 2 matrices 2D. Retourne une nouvelle matrice
+    */
+    public MatrixND mult(MatrixND m);
 
 //    /**
 //    * multiplication terme a terme de la matrice courante avec la
 //    * matrice passe en parametre et ce retourne elle meme
 //    */
 //    public MatrixND multm(MatrixND m);
-//    /**
-//    * Multiplication d'une matrice par un scalaire
-//    */
-//    public MatrixND mults(double d);
-//    /**
-//    * Multiplication d'une matrice par un scalaire
-//    */
-//    public MatrixND divs(double d);
+    /**
+    * Multiplication d'une matrice par un scalaire
+    */
+    public MatrixND mults(final double d);
+    /**
+    * Multiplication d'une matrice par un scalaire
+    */
+    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.1.1.1 lutinmatrix/src/java/org/codelutin/math/matrix/MatrixNDImpl.java:1.2
--- lutinmatrix/src/java/org/codelutin/math/matrix/MatrixNDImpl.java:1.1.1.1	Tue Nov  2 16:25:31 2004
+++ lutinmatrix/src/java/org/codelutin/math/matrix/MatrixNDImpl.java	Thu Nov  4 13:50:17 2004
@@ -23,9 +23,9 @@
 * Created: 29 oct. 2004
 *
 * @author Benjamin Poussin <poussin@codelutin.com>
-* @version $Revision: 1.1.1.1 $
+* @version $Revision: 1.2 $
 *
-* Mise a jour: $Date: 2004/11/02 16:25:31 $
+* Mise a jour: $Date: 2004/11/04 13:50:17 $
 * par : $Author: bpoussin $
 */
 
@@ -41,25 +41,32 @@
         super(dim);
         matrix = new BasicMatrix(dim);
     }
+    public MatrixNDImpl(List[] semantics){
+        super(semantics);
+        matrix = new BasicMatrix(dim);
+    }
 
     public MatrixNDImpl(String name, int [] dim){
         super(name, dim);
         matrix = new BasicMatrix(dim);
     }
 
-    public MatrixNDImpl(String name, int [] dim, List[] semantics){
-        super(name, dim, semantics);
+    public MatrixNDImpl(String name, List[] semantics){
+        super(name, semantics);
         matrix = new BasicMatrix(dim);
     }
 
-    public MatrixNDImpl(String name, int [] dim, List[] semantics, String [] dimNames){
-        super(name, dim, semantics, dimNames);
+    public MatrixNDImpl(String name, List[] semantics, String [] dimNames){
+        super(name, semantics, dimNames);
         matrix = new BasicMatrix(dim);
     }
 
     public MatrixNDImpl(MatrixND matrix){
-        super(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());
+        }
     }
 
     public MatrixIterator iterator(){

Index: lutinmatrix/src/java/org/codelutin/math/matrix/SubMatrix.java
diff -u lutinmatrix/src/java/org/codelutin/math/matrix/SubMatrix.java:1.1.1.1 lutinmatrix/src/java/org/codelutin/math/matrix/SubMatrix.java:1.2
--- lutinmatrix/src/java/org/codelutin/math/matrix/SubMatrix.java:1.1.1.1	Tue Nov  2 16:25:31 2004
+++ lutinmatrix/src/java/org/codelutin/math/matrix/SubMatrix.java	Thu Nov  4 13:50:17 2004
@@ -23,9 +23,9 @@
  * Created: 29 oct. 2004
  *
  * @author Benjamin Poussin <poussin@codelutin.com>
- * @version $Revision: 1.1.1.1 $
+ * @version $Revision: 1.2 $
  *
- * Mise a jour: $Date: 2004/11/02 16:25:31 $
+ * Mise a jour: $Date: 2004/11/04 13:50:17 $
  * par : $Author: bpoussin $
  */
 
@@ -47,7 +47,7 @@
     protected MatrixND matrix = null;
 
     public SubMatrix(MatrixND matrix, int dim, int start, int nb){
-        super(matrix.getName(), matrix.getDim(), matrix.getSemantics(), matrix.getDimensionName());
+        super(matrix.getName(), matrix.getSemantics(), matrix.getDimensionName());
         this.matrix = matrix;
         this.dim = dim;
         this.start = start;