Index: lutinmatrix/src/java/org/codelutin/math/matrix/AbstractMatrixND.java
diff -u lutinmatrix/src/java/org/codelutin/math/matrix/AbstractMatrixND.java:1.2 lutinmatrix/src/java/org/codelutin/math/matrix/AbstractMatrixND.java:1.3
--- lutinmatrix/src/java/org/codelutin/math/matrix/AbstractMatrixND.java:1.2	Thu Nov  4 13:50:17 2004
+++ lutinmatrix/src/java/org/codelutin/math/matrix/AbstractMatrixND.java	Mon Nov  8 13:49:54 2004
@@ -23,9 +23,9 @@
  * Created: 29 oct. 2004
  *
  * @author Benjamin Poussin <poussin@codelutin.com>
- * @version $Revision: 1.2 $
+ * @version $Revision: 1.3 $
  *
- * Mise a jour: $Date: 2004/11/04 13:50:17 $
+ * Mise a jour: $Date: 2004/11/08 13:49:54 $
  * par : $Author: bpoussin $
  */
 
@@ -310,6 +310,18 @@
         return getSubMatrix(dim, begin, nb);
     }
 
+    public MatrixND getSubMatrix(int dim, Object [] elem){
+        int [] ielem = new int[elem.length];
+        for(int i=0; i<ielem.length; i++){
+            ielem[i] = MatrixHelper.indexOf(getSemantics(), dim, elem[i]);
+        }
+        return getSubMatrix(dim, ielem);
+    }
+
+    public MatrixND getSubMatrix(int dim, int [] elem){
+        return new SubMatrix(this, dim, elem);
+    }
+
     public MatrixND add(MatrixND m){
         for(MatrixIterator i=iterator(); i.next();){
             i.setValue(i.getValue() + m.getValue(i.getCoordinates()));
@@ -346,6 +358,10 @@
     }
 
     public MatrixND reduce(){
+        return reduce(1);
+    }
+
+    public MatrixND reduce(int minNbDim){
         // 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
@@ -356,25 +372,31 @@
         List sem = new ArrayList();
         // les nouveaux noms de dimensions
         List dimName = new ArrayList();
-        for (int j=0; j<getNbDim(); j++){
-            if (getDim(j) > 1 ){
+        for (int j=getNbDim()-1; j>=0 ; j--){
+            // si la dimension à plus d'un élément ou si on a pas assez de
+            // dimension pour avoir le minimum demandé on prend la dimension
+            if (getDim(j) > 1 || j < minNbDim){
                 // on ne conserve que les dimensions supérieure à 1
                 correspondance[sem.size()] = j;
                 sem.add(getSemantics(j));
                 dimName.add(getDimensionName(j));
+                // on vient de prendre une dimension il nous en faut une de moins
+                minNbDim--;
             }
         }
 
-        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));
+        // on converti les listes en tableau en inversant l'ordre car on
+        // a fait un parcours en sens inverse
+        int nbDim = sem.size();
+        List [] newSemantics = new List[nbDim];
+        String [] newDimNames = new String[nbDim];
+        int [] tmpcorrespondance = new int[nbDim];
+        for(int i=0; i<nbDim; i++){
+            newSemantics[i] = (List)sem.get(nbDim-1-i);
+            newDimNames[i] = (String)dimName.get(nbDim-1-i);
+            tmpcorrespondance[i] = correspondance[nbDim-1-i];
         }
-
-        List [] newSemantics = (List[])sem.toArray(new List[sem.size()]);
-        String [] newDimNames = (String[])dimName.toArray(new String[dimName.size()]);
+        correspondance = tmpcorrespondance;
 
         MatrixND result = new MatrixNDImpl(getName(), newSemantics, newDimNames);
 

Index: lutinmatrix/src/java/org/codelutin/math/matrix/BasicMatrix.java
diff -u lutinmatrix/src/java/org/codelutin/math/matrix/BasicMatrix.java:1.1.1.1 lutinmatrix/src/java/org/codelutin/math/matrix/BasicMatrix.java:1.2
--- lutinmatrix/src/java/org/codelutin/math/matrix/BasicMatrix.java:1.1.1.1	Tue Nov  2 16:25:31 2004
+++ lutinmatrix/src/java/org/codelutin/math/matrix/BasicMatrix.java	Mon Nov  8 13:49:54 2004
@@ -23,9 +23,9 @@
  * Created: 27 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/08 13:49:54 $
  * par : $Author: bpoussin $
  */
 
@@ -189,8 +189,8 @@
     */
     protected void checkDim(int [] dim){
         for(int i=0; i<dim.length; i++){
-            if(dim[i] < 0){
-                throw new IllegalArgumentException(I18n._("Les dimensions de la matrice ne doivent pas être négative or la dimension {0} vaut {1}", new Object[]{new Integer(i), new Integer(dim[i])}));
+            if(dim[i] <= 0){
+                throw new IllegalArgumentException(I18n._("Les dimensions de la matrice ne doivent être supérieur à 0 or la dimension {0} vaut {1}", new Object[]{new Integer(i), new Integer(dim[i])}));
             }
         }
     }
@@ -223,19 +223,38 @@
     }
 
     public String toString(){
-        StringBuffer result = new StringBuffer("dimensions = [\n");
-        for(int i=0; i<dimensions.length; i++){
-            result.append(dimensions[i] + ",");
-        }
-        result.append("\n]\nmatrice = [\n");
-        for(int i=0; i<data.length; i++){
-            result.append(data[i] + ",");
-        }
-        result.append("\n]\nlinearFactor = [\n");
-        for(int i=0; i<linearFactor.length; i++){
-            result.append(linearFactor[i] + ",");
+        StringBuffer result = new StringBuffer();
+        if(getNbDim() == 1){
+            result.append("matrix1D [");
+            for(int i=0; i<data.length; i++){
+                result.append(data[i] + ",");
+            }
+            result.append("]");
+        }else if(getNbDim() == 2){
+            DimensionHelper dimHelper = new DimensionHelper();
+            result.append("matrix2D [");
+            for(int y=0; y<getDim(1); y++){
+                result.append("\n");
+                for(int x=0; x<getDim(0); x++){
+                    result.append(getValue(dimHelper.get(x,y)) + ",");
+                }
+            }
+            result.append("]");
+        }else{
+            result.append("dimensions = [\n");
+            for(int i=0; i<dimensions.length; i++){
+                result.append(dimensions[i] + ",");
+            }
+            result.append("\n]\nmatrice = [\n");
+            for(int i=0; i<data.length; i++){
+                result.append(data[i] + ",");
+            }
+            result.append("\n]\nlinearFactor = [\n");
+            for(int i=0; i<linearFactor.length; i++){
+                result.append(linearFactor[i] + ",");
+            }
+            result.append("\n]\n");
         }
-        result.append("\n]\n");
         return result.toString();
     }
 

Index: lutinmatrix/src/java/org/codelutin/math/matrix/MatrixHelper.java
diff -u lutinmatrix/src/java/org/codelutin/math/matrix/MatrixHelper.java:1.3 lutinmatrix/src/java/org/codelutin/math/matrix/MatrixHelper.java:1.4
--- lutinmatrix/src/java/org/codelutin/math/matrix/MatrixHelper.java:1.3	Thu Nov  4 13:50:17 2004
+++ lutinmatrix/src/java/org/codelutin/math/matrix/MatrixHelper.java	Mon Nov  8 13:49:54 2004
@@ -23,9 +23,9 @@
  * Created: 28 oct. 2004
  *
  * @author Benjamin Poussin <poussin@codelutin.com>
- * @version $Revision: 1.3 $
+ * @version $Revision: 1.4 $
  *
- * Mise a jour: $Date: 2004/11/04 13:50:17 $
+ * Mise a jour: $Date: 2004/11/08 13:49:54 $
  * par : $Author: bpoussin $
  */
 
@@ -39,9 +39,14 @@
 import java.util.logging.Level;
 import java.util.logging.Logger;
 import java.util.NoSuchElementException;
+import org.codelutin.xml.XMLEncoderDecoder;
 
 public class MatrixHelper { // MatrixHelper
 
+    static {
+        XMLEncoderDecoder.registerType(MatrixND.class, new MatrixXMLDelegator());
+    }
+
     /**
     * permet de donner une représentation String d'un tableau de coordonnées
     * @param coordinates les coordonnées
@@ -222,21 +227,18 @@
     }
 
     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);
-        }
+        StringWriter out = new StringWriter();
+        XMLEncoderDecoder.getInstance().encode(out, mat);
+        return out.toString();
     }
 
     static public MatrixND decodeFromXML(String xml){
-        MatrixDecoder decoder = new MatrixDecoder(new StringReader(xml));
-        return decoder.readMatrix();
-    }
+        try{
+            return (MatrixND)XMLEncoderDecoder.getInstance().decode(new StringReader(xml));
+        }catch(Exception eee){
+            throw new MatrixException("Erreur durant le decodage de la matrice", eee);
+        }
+   }
 
 //
 //        public MatriceND sommer(int dim)throws MatriceException;

Index: lutinmatrix/src/java/org/codelutin/math/matrix/MatrixND.java
diff -u lutinmatrix/src/java/org/codelutin/math/matrix/MatrixND.java:1.2 lutinmatrix/src/java/org/codelutin/math/matrix/MatrixND.java:1.3
--- lutinmatrix/src/java/org/codelutin/math/matrix/MatrixND.java:1.2	Thu Nov  4 13:50:17 2004
+++ lutinmatrix/src/java/org/codelutin/math/matrix/MatrixND.java	Mon Nov  8 13:49:54 2004
@@ -23,9 +23,9 @@
 * Created: 29 oct. 2004
 *
 * @author Benjamin Poussin <poussin@codelutin.com>
-* @version $Revision: 1.2 $
+* @version $Revision: 1.3 $
 *
-* Mise a jour: $Date: 2004/11/04 13:50:17 $
+* Mise a jour: $Date: 2004/11/08 13:49:54 $
 * par : $Author: bpoussin $
 */
 
@@ -374,9 +374,6 @@
     * 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.
@@ -390,11 +387,35 @@
     * @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
-    * @param nb le nombre d'élément à prendre dans la dimension
+    * 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, int 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 elem les éléments dans la dimension à conserver
+    */
+    public MatrixND getSubMatrix(int dim, Object [] elem);
+
+    /**
+    * 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 elem les éléments dans la dimension à conserver
+    */
+    public MatrixND getSubMatrix(int dim, int [] elem);
+
+
+    /**
     * Addition la matrice courante avec la matrice passe en parametre et
     * ce retourne elle meme
     */
@@ -414,10 +435,21 @@
     * 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
+    * @return une nouvelle matrice plus petite que la matrice actuelle
     * ou egal s'il n'y a aucune dimension à supprimer
     */
     public MatrixND reduce();
+
+    /**
+    * 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.
+    * @param minNbDim le nombre minimum de dimension que l'on souhaite pour
+    * la matrice résultat
+    * @return une nouvelle matrice plus petite que la matrice actuelle
+    * ou egal s'il n'y a aucune dimension à supprimer
+    */
+    public MatrixND reduce(int minNbDim);
 
     /**
     * Multiplication normal de 2 matrices 2D. Retourne une nouvelle matrice

Index: lutinmatrix/src/java/org/codelutin/math/matrix/MatrixNDImpl.java
diff -u lutinmatrix/src/java/org/codelutin/math/matrix/MatrixNDImpl.java:1.2 lutinmatrix/src/java/org/codelutin/math/matrix/MatrixNDImpl.java:1.3
--- lutinmatrix/src/java/org/codelutin/math/matrix/MatrixNDImpl.java:1.2	Thu Nov  4 13:50:17 2004
+++ lutinmatrix/src/java/org/codelutin/math/matrix/MatrixNDImpl.java	Mon Nov  8 13:49:54 2004
@@ -23,9 +23,9 @@
 * Created: 29 oct. 2004
 *
 * @author Benjamin Poussin <poussin@codelutin.com>
-* @version $Revision: 1.2 $
+* @version $Revision: 1.3 $
 *
-* Mise a jour: $Date: 2004/11/04 13:50:17 $
+* Mise a jour: $Date: 2004/11/08 13:49:54 $
 * par : $Author: bpoussin $
 */
 
@@ -84,7 +84,7 @@
     }
 
     public String toString(){
-        return matrix.toString();
+        return getName() + " " + matrix.toString();
     }
 
 } // MatrixNDImpl

Index: lutinmatrix/src/java/org/codelutin/math/matrix/SubMatrix.java
diff -u lutinmatrix/src/java/org/codelutin/math/matrix/SubMatrix.java:1.2 lutinmatrix/src/java/org/codelutin/math/matrix/SubMatrix.java:1.3
--- lutinmatrix/src/java/org/codelutin/math/matrix/SubMatrix.java:1.2	Thu Nov  4 13:50:17 2004
+++ lutinmatrix/src/java/org/codelutin/math/matrix/SubMatrix.java	Mon Nov  8 13:49:54 2004
@@ -23,15 +23,17 @@
  * Created: 29 oct. 2004
  *
  * @author Benjamin Poussin <poussin@codelutin.com>
- * @version $Revision: 1.2 $
+ * @version $Revision: 1.3 $
  *
- * Mise a jour: $Date: 2004/11/04 13:50:17 $
+ * Mise a jour: $Date: 2004/11/08 13:49:54 $
  * par : $Author: bpoussin $
  */
 
 package org.codelutin.math.matrix;
 
 import java.util.Arrays;
+import java.util.LinkedList;
+import java.util.List;
 import java.util.NoSuchElementException;
 
 /**
@@ -41,47 +43,43 @@
 */
 public class SubMatrix extends AbstractMatrixND { // SubMatrix
 
-    protected int dim;
-    protected int start;
-    protected int nb;
     protected MatrixND matrix = null;
+    protected DimensionConverter converter = null;
 
     public SubMatrix(MatrixND matrix, int dim, int start, int nb){
         super(matrix.getName(), matrix.getSemantics(), matrix.getDimensionName());
         this.matrix = matrix;
-        this.dim = dim;
-        this.start = start;
-        this.nb = nb;
 
+        converter = new ShiftConverter(dim, start, nb);
         setSemantics(dim, getSemantics(dim).subList(start, start + nb));
         getDim()[dim] = nb;
     }
 
+    public SubMatrix(MatrixND matrix, int dim, int [] elem){
+        super(matrix.getName(), matrix.getSemantics(), matrix.getDimensionName());
+        this.matrix = matrix;
+
+        converter = new MappingConverter(dim, elem);
+
+        List oldSemantic = getSemantics(dim);
+        List newSemantic = new LinkedList();
+        for(int i=0; i<elem.length; i++){
+            newSemantic.add(oldSemantic.get(elem[i]));
+        }
+        setSemantics(dim, newSemantic);
+        getDim()[dim] = elem.length;
+    }
+
     public MatrixIterator iterator(){
         return new SubMatrixIteratorImpl(this);
     }
 
     public double getValue(int [] coordinates){
-        return matrix.getValue(convertCoordinates(coordinates));
+        return matrix.getValue(converter.convertCoordinates(coordinates));
     }
 
     public void setValue(int [] coordinates, double d){
-        matrix.setValue(convertCoordinates(coordinates), d);
-    }
-
-    /**
-    * Permet de convertir les coordonnées données pour la sous-matrice
-    * en coordonnées pour la matrice sous jacente.
-    */
-    protected int [] convertCoordinates(int [] coordinates){
-        if(coordinates[dim] < nb){
-            int [] result = new int[coordinates.length];
-            System.arraycopy(coordinates, 0, result, 0, result.length);
-            result[dim] = result[dim] + start;
-            return result;
-        }else{
-            throw new NoSuchElementException("L'indice est supérieur au nombre d'élement de la sous matrice pour cette dimension.");
-        }
+        matrix.setValue(converter.convertCoordinates(coordinates), d);
     }
 
     protected class SubMatrixIteratorImpl implements MatrixIterator {
@@ -135,6 +133,62 @@
             subMatrix.setValue(getCoordinates(), value);
         }
 
+    }
+
+
+    /**
+    * Permet de faire une conversion de la dimension demandé dans la sous
+    * matrice avec la position reel de la matrice sous jacente.
+    */
+    protected interface DimensionConverter {
+        public int [] convertCoordinates(int [] coordinates);
+    }
+
+    /**
+    * La conversion est juste un decalage d'indice
+    */
+    protected class ShiftConverter implements DimensionConverter {
+        protected int dim;
+        protected int start;
+        protected int nb;
+        public ShiftConverter(int dim, int start, int nb){
+            this.dim = dim;
+            this.start = start;
+            this.nb = nb;
+        }
+        public int [] convertCoordinates(int [] coordinates){
+            if(coordinates[dim] < nb){
+                int [] result = new int[coordinates.length];
+                System.arraycopy(coordinates, 0, result, 0, result.length);
+                result[dim] = result[dim] + start;
+                return result;
+            }else{
+                throw new NoSuchElementException("L'indice est supérieur au nombre d'élement de la sous matrice pour cette dimension.");
+            }
+        }
+    }
+
+    /**
+    * La conversion est le mapping d'un element vers un autre element
+    */
+    protected class MappingConverter implements DimensionConverter {
+        protected int dim;
+        protected int [] elem = null;
+        public MappingConverter(int dim, int [] elem){
+            this.dim = dim;
+            this.elem = new int[elem.length];
+            System.arraycopy(elem, 0, this.elem, 0, elem.length);
+        }
+        public int [] convertCoordinates(int [] coordinates){
+            if(coordinates[dim] < elem.length){
+                int [] result = new int[coordinates.length];
+                System.arraycopy(coordinates, 0, result, 0, result.length);
+                result[dim] = elem[coordinates[dim]];
+                return result;
+            }else{
+                throw new NoSuchElementException("L'indice est supérieur au nombre d'élement de la sous matrice pour cette dimension.");
+            }
+        }
     }
 
 } // SubMatrix

Index: lutinmatrix/src/java/org/codelutin/math/matrix/MatrixXMLDelegator.java
diff -u /dev/null lutinmatrix/src/java/org/codelutin/math/matrix/MatrixXMLDelegator.java:1.1
--- /dev/null	Mon Nov  8 13:50:00 2004
+++ lutinmatrix/src/java/org/codelutin/math/matrix/MatrixXMLDelegator.java	Mon Nov  8 13:49:54 2004
@@ -0,0 +1,211 @@
+/* *##%
+ * Copyright (C) 2002, 2003, 2004 Code Lutin, Cédric Pineau,
+ *    Benjamin Poussin
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *##%*/
+
+/* *
+ * MatrixEncoderDecoder.java
+ *
+ * Created: 5 nov. 2004
+ *
+ * @author Benjamin Poussin <poussin@codelutin.com>
+ * @version $Revision: 1.1 $
+ *
+ * Mise a jour: $Date: 2004/11/08 13:49:54 $
+ * par : $Author: bpoussin $
+ */
+
+package org.codelutin.math.matrix;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+import org.dom4j.DocumentHelper;
+import org.dom4j.Element;
+import org.codelutin.xml.XMLEncoderDecoder;
+import org.codelutin.xml.XMLEncoderDecoderDelegatorVersioned;
+import org.codelutin.util.ArrayUtil;
+
+public class MatrixXMLDelegator extends XMLEncoderDecoderDelegatorVersioned { // MatrixXMLDelegator
+
+    /** version d'encodage de la matrice */
+    static final protected String CURRENT_VERSION = "1";
+
+    public String getVersion(){
+        return CURRENT_VERSION;
+    }
+
+    public Element encodeVersion(XMLEncoderDecoder ed, Object o){
+        MatrixND matrix = (MatrixND)o;
+
+        double defaultValue = matrix.getMaxOccurence();
+
+        Element result = DocumentHelper.createElement("matrix");
+        result.addAttribute("defaultValue", ""+defaultValue);
+        result.addAttribute("name", matrix.getName());
+        result.addAttribute("dimensions", MatrixHelper.coordinatesToString(matrix.getDim()));
+        result.addAttribute("type", matrix.getClass().getName());
+
+        // ecriture des noms des dimensions
+        for(int i=0; i<matrix.getNbDim(); i++){
+            String dimName = matrix.getDimensionName(i);
+            // si le nom est non null et non vide on l'ecrit,
+            // sinon c la valeur par defaut lorsqu'on relit la matrice
+            // donc ca ne sert a rien de le mettre dans le XML
+            if(dimName != null && !"".equals(dimName)){
+                result.addElement("dimensionName").addAttribute("dim", ""+i).addText(dimName);
+            }
+        }
+
+        // ecriture de la semantique
+        for(int i=0; i<matrix.getNbDim(); i++){
+            List semantic = matrix.getSemantics(i);
+
+            // si tous les elements de la sem sont null on ne les ecrira pas
+            // donc pour l'instant on cree un element independant de result
+            Element semanticsXML = DocumentHelper.createElement("semantics");
+            semanticsXML.addAttribute("dim", ""+i);
+            for(int index=0; index<semantic.size(); index++){
+                Object semElem = semantic.get(index);
+                if(semElem != null){
+                    Element semXML = semanticsXML.addElement("sem");
+                    semXML.addAttribute("index", ""+index);
+                    semXML.add(ed.encode(semElem));
+                }
+            }
+            if(semanticsXML.hasContent()){
+                // on ne l'ajout que si au moins un des elements de la
+                // semantique est non null
+                result.add(semanticsXML);
+            }
+        }
+
+        // ecriture des valeur de la matrice
+        for(MatrixIterator i=matrix.iterator(); i.next();){
+            double val = i.getValue();
+            if(val != defaultValue){
+                String path = MatrixHelper.coordinatesToString(i.getCoordinates());
+                result.addElement("element").addAttribute("path", path).addAttribute("value", ""+val);
+            }
+        }
+
+        return result;
+    }
+
+    /**
+    * Lecture des matrices de version 0, cette version correspond à l'ancienne
+    * représentation des matrices de la librairie Lutin-dev
+    */
+    public Object decodeVersion0(XMLEncoderDecoder ed, Element root) throws Exception {
+        // recuperation des dimensions de la matrice
+        String [] dimensions = root.attributeValue("dimensions").split(";");
+        int [] dims = ArrayUtil.asIntArray(dimensions);
+
+        // creation du resultat
+        MatrixND result = new MatrixNDImpl(dims);
+
+        // recuperation de la valeur par defaut de la matrice
+        String defaultValueString = root.attributeValue("defaultElem", "0");
+        double defaultValue = Double.parseDouble(defaultValueString);
+        MatrixHelper.fill(result, defaultValue);
+
+        //on remet toutes les valeurs dans la matrice
+        for(Iterator i=root.elementIterator("Element"); i.hasNext();){
+            Element elem = (Element)i.next();
+
+            String [] path = elem.attributeValue("path").split(";");
+            int [] dim = ArrayUtil.asIntArray(path);
+
+            String v = elem.attributeValue("function");
+            result.setValue(dim, Double.parseDouble(v));
+        }
+
+        return result;
+
+    }
+
+    /**
+    * Lecture des matrices de version 1, cette version est la première après
+    * la reprise des matrices depuis Lutin-dev
+    */
+    public Object decodeVersion1(XMLEncoderDecoder ed, Element root) throws Exception {
+        // recuperation des dimensions de la matrice
+        String [] dimensions = root.attributeValue("dimensions").split(",");
+        int [] dims = ArrayUtil.asIntArray(dimensions);
+
+        // creation du resultat
+        MatrixND result = new MatrixNDImpl(dims);
+
+        // recuperation de la valeur par defaut de la matrice
+        String defaultValueString = root.attributeValue("defaultValue", "0");
+        double defaultValue = Double.parseDouble(defaultValueString);
+        MatrixHelper.fill(result, defaultValue);
+
+        // on change le nom
+        String name = root.attributeValue("name", "");
+        result.setName(name);
+
+        //on remet les noms des dimensions
+        for(Iterator i=root.elementIterator("dimensionName"); i.hasNext();){
+            Element elem = (Element)i.next();
+            String dimString = elem.attributeValue("dim");
+            int dim = Integer.parseInt(dimString);
+            result.setDimensionName(dim, elem.getText());
+        }
+
+        // lecture de la semantique
+        for(Iterator sems=root.elementIterator("semantics"); sems.hasNext();){
+            Element sem = (Element)sems.next();
+            String dimString = sem.attributeValue("dim");
+            int dim = Integer.parseInt(dimString);
+
+            // on creer la semantique avec des nulls
+            List semantics = new ArrayList(Collections.nCopies(dims[dim], null));
+
+            for(Iterator objs=sem.elementIterator("sem"); objs.hasNext();){
+                Element obj = (Element)objs.next();
+                List childs = obj.elements();
+                if(childs.size() > 0){
+                    Object o = ed.decode((Element)childs.get(0));
+                    // on remet l'objet a la bonne place
+                    String indexString = obj.attributeValue("index");
+                    int index = Integer.parseInt(indexString);
+                    semantics.set(index, o);
+                }
+            }
+            result.setSemantics(dim, semantics);
+        }
+
+        //on remet toutes les valeurs dans la matrice
+        for(Iterator i=root.elementIterator("element"); i.hasNext();){
+            Element elem = (Element)i.next();
+
+            String [] path = elem.attributeValue("path").split(",");
+            int [] dim = ArrayUtil.asIntArray(path);
+
+            String v = elem.attributeValue("value");
+            result.setValue(dim, Double.parseDouble(v));
+        }
+
+        return result;
+
+
+    }
+
+} // MatrixXMLDelegator
+