[Nuiton-matrix-commits] r443 - trunk/nuiton-matrix/src/main/java/org/nuiton/math/matrix

31 Aug 2012

Author: bpoussin
Date: 2012-08-31 15:08:24 +0200 (Fri, 31 Aug 2012)
New Revision: 443

Url: http://nuiton.org/repositories/revision/nuiton-matrix/443

Log:
ajout la possibilite de convertir les semantiques automatiquement


Added:
   trunk/nuiton-matrix/src/main/java/org/nuiton/math/matrix/MatrixSemanticsDecorator.java
   trunk/nuiton-matrix/src/main/java/org/nuiton/math/matrix/SemanticsDecorator.java
Modified:
   trunk/nuiton-matrix/src/main/java/org/nuiton/math/matrix/MatrixFactory.java
   trunk/nuiton-matrix/src/main/java/org/nuiton/math/matrix/MatrixNDImpl.java

Modified: trunk/nuiton-matrix/src/main/java/org/nuiton/math/matrix/MatrixFactory.java
===================================================================

--- trunk/nuiton-matrix/src/main/java/org/nuiton/math/matrix/MatrixFactory.java	2012-08-30 22:52:26 UTC (rev 442)
+++ trunk/nuiton-matrix/src/main/java/org/nuiton/math/matrix/MatrixFactory.java	2012-08-31 13:08:24 UTC (rev 443)
@@ -140,6 +140,19 @@
         return new MatrixNDImpl(this, name, dim, dimNames);
     }
 
+    /**
+     * Create new matrix and force backend to be data.
+     * 
+     * @param name matrix's name (can be null)
+     * @param dim matrix's dimension (must be provided)
+     * @param dimNames dimensions' name (can be null)
+     * @param data backend used to new matrix
+     * @return  new Matrix with specified backend
+     */
+    public MatrixND create(String name, int[] dim, String[] dimNames, Vector data) {
+        return new MatrixNDImpl(this, name, dim, dimNames);
+    }
+
     public MatrixND create(String name, List<?>[] semantics) {
         return new MatrixNDImpl(this, name, semantics);
     }
@@ -149,6 +162,19 @@
     }
 
     /**
+     * Create new matrix and force backend to be data.
+     *
+     * @param name matrix's name (can be null)
+     * @param semantics semantiques (must be provided)
+     * @param dimNames dimensions' name (can be null)
+     * @param data backend used to new matrix
+     * @return new Matrix with specified backend
+     */
+    public MatrixND create(String name, List<?>[] semantics, String[] dimNames, Vector data) {
+        return new MatrixNDImpl(this, name, semantics, dimNames, data);
+    }
+
+    /**
      * Create new matrix by copying matrix in argument
      * @param matrix
      * @return

Modified: trunk/nuiton-matrix/src/main/java/org/nuiton/math/matrix/MatrixNDImpl.java
===================================================================
--- trunk/nuiton-matrix/src/main/java/org/nuiton/math/matrix/MatrixNDImpl.java	2012-08-30 22:52:26 UTC (rev 442)
+++ trunk/nuiton-matrix/src/main/java/org/nuiton/math/matrix/MatrixNDImpl.java	2012-08-31 13:08:24 UTC (rev 443)
@@ -67,6 +67,12 @@
         matrix = new BasicMatrix(factory, dim);
     }
 
+    protected MatrixNDImpl(MatrixFactory factory, String name, int[] dim,
+            String[] dimNames, Vector data) {
+        super(factory, name, dim, dimNames);
+        matrix = new BasicMatrix(factory, data, dim);
+    }
+
     protected MatrixNDImpl(MatrixFactory factory, String name,
             List<?>[] semantics) {
         super(factory, name, semantics);
@@ -79,6 +85,12 @@
         matrix = new BasicMatrix(factory, dim);
     }
 
+    protected MatrixNDImpl(MatrixFactory factory, String name,
+            List<?>[] semantics, String[] dimNames, Vector data) {
+        super(factory, name, semantics, dimNames);
+        matrix = new BasicMatrix(factory, data, dim);
+    }
+
     protected MatrixNDImpl(MatrixFactory factory, MatrixND matrix) {
         super(factory, matrix.getName(), matrix.getSemantics(), matrix
                 .getDimensionNames());

Added: trunk/nuiton-matrix/src/main/java/org/nuiton/math/matrix/MatrixSemanticsDecorator.java
===================================================================
--- trunk/nuiton-matrix/src/main/java/org/nuiton/math/matrix/MatrixSemanticsDecorator.java	                        (rev 0)
+++ trunk/nuiton-matrix/src/main/java/org/nuiton/math/matrix/MatrixSemanticsDecorator.java	2012-08-31 13:08:24 UTC (rev 443)
@@ -0,0 +1,482 @@
+package org.nuiton.math.matrix;
+
+
+import java.io.File;
+import java.io.IOException;
+import java.io.Reader;
+import java.io.Writer;
+import java.util.ArrayList;
+import java.util.List;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+
+/**
+ * Permet d'interpreter les semantics, par exemple convertir un Id en une
+ * entite via le SemanticMapper passe en argument
+ *
+ * @author poussin
+ * @version $Revision$
+ *
+ * Last update: $Date$
+ * by : $Author$
+ */
+public class MatrixSemanticsDecorator implements MatrixND {
+
+    /** to use log facility, just put in your code: log.info(\"...\"); */
+    static private Log log = LogFactory.getLog(MatrixSemanticsDecorator.class);
+    
+    protected MatrixND matrix;
+    protected SemanticsDecorator decorator;
+
+    /**
+     *
+     * @param matrix La matrice dont il faut decorer les semantiques
+     * @param decorator l'objet utilise pour la decoration
+     */
+    public MatrixSemanticsDecorator(MatrixND matrix, SemanticsDecorator decorator) {
+        this.matrix = matrix;
+        this.decorator = decorator;
+    }
+
+    /**
+     * Les matrices retournees par cette classe doivent etre wrapper pour que
+     * les semantiques continues de fonctionner
+     * 
+     * @param m
+     * @return
+     */
+    protected MatrixND wrap(MatrixND m) {
+        return new MatrixSemanticsDecorator(m, decorator);
+    }
+
+    @Override
+    public MatrixFactory getFactory() {
+        return matrix.getFactory();
+    }
+
+    @Override
+    public List<?>[] getSemantics() {
+        List[] tmp = matrix.getSemantics();
+        List[] result = new ArrayList[tmp.length];
+        for (int i=0; i<tmp.length; i++) {
+            result[i] = new ArrayList();
+            for (Object o : tmp[i]) {
+                o = decorator.decorate(o);
+                result[i].add(o);
+            }
+        }
+        return result;
+    }
+
+    @Override
+    public List<?> getSemantics(int dim) {
+        return getSemantic(dim);
+    }
+
+    @Override
+    public List<?> getSemantic(int dim) {
+        List tmp = matrix.getSemantic(dim);
+        List result = new ArrayList(tmp.size());
+        for (Object o : tmp) {
+            o = decorator.decorate(o);
+            result.add(o);
+        }
+        return result;
+    }
+
+    @Override
+    public <E> void setSemantics(int dim, List<E> sem) {
+        setSemantic(dim, sem);
+    }
+
+    @Override
+    public <E> void setSemantic(int dim, List<E> sem) {
+        List undecorate = new ArrayList(sem.size());
+        for (Object o : sem) {
+            o = decorator.undecorate(o);
+            undecorate.add(o);
+        }
+        matrix.setSemantic(dim, undecorate);
+    }
+
+    @Override
+    public void setName(String name) {
+        matrix.setName(name);
+    }
+
+    @Override
+    public String getName() {
+        return matrix.getName();
+    }
+
+    @Override
+    public void setDimensionName(String[] names) {
+        matrix.setDimensionName(names);
+    }
+
+    @Override
+    public void setDimensionNames(String[] names) {
+        matrix.setDimensionNames(names);
+    }
+
+    @Override
+    public String[] getDimensionName() {
+        return matrix.getDimensionName();
+    }
+
+    @Override
+    public String[] getDimensionNames() {
+        return matrix.getDimensionNames();
+    }
+
+    @Override
+    public void setDimensionName(int dim, String name) {
+        matrix.setDimensionName(dim, name);
+    }
+
+    @Override
+    public String getDimensionName(int dim) {
+        return matrix.getDimensionName(dim);
+    }
+
+    @Override
+    public double getMaxOccurence() {
+        return matrix.getMaxOccurence();
+    }
+
+    @Override
+    public double getMaxOccurrence() {
+        return matrix.getMaxOccurrence();
+    }
+
+    @Override
+    public int getNbDim() {
+        return matrix.getNbDim();
+    }
+
+    @Override
+    public int getDimCount() {
+        return matrix.getDimCount();
+    }
+
+    @Override
+    public int[] getDim() {
+        return matrix.getDim();
+    }
+
+    @Override
+    public int getDim(int d) {
+        return matrix.getDim(d);
+    }
+
+    @Override
+    public MatrixIterator iterator() {
+        return matrix.iterator();
+    }
+
+    @Override
+    public MatrixND map(MapFunction f) {
+        return wrap(matrix.map(f));
+    }
+
+    @Override
+    public double getValue(int[] dimensions) {
+        return matrix.getValue(dimensions);
+    }
+
+    @Override
+    public double getValue(int x) {
+        return matrix.getValue(x);
+    }
+
+    @Override
+    public double getValue(int x, int y) {
+        return matrix.getValue(x, y);
+    }
+
+    @Override
+    public double getValue(int x, int y, int z) {
+        return matrix.getValue(x, y, z);
+    }
+
+    @Override
+    public double getValue(int x, int y, int z, int t) {
+        return matrix.getValue(x, y, z, t);
+    }
+
+    @Override
+    public double getValue(Object[] coordinates) {
+        return matrix.getValue(coordinates);
+    }
+
+    @Override
+    public double getValue(Object x) {
+        return matrix.getValue(x);
+    }
+
+    @Override
+    public double getValue(Object x, Object y) {
+        return matrix.getValue(x, y);
+    }
+
+    @Override
+    public double getValue(Object x, Object y, Object z) {
+        return matrix.getValue(x, y, z);
+    }
+
+    @Override
+    public double getValue(Object x, Object y, Object z, Object t) {
+        return matrix.getValue(x, y, z, t);
+    }
+
+    @Override
+    public void setValue(int[] dimensions, double d) {
+        matrix.setValue(dimensions, d);
+    }
+
+    @Override
+    public void setValue(int x, double d) {
+        matrix.setValue(x, d);
+    }
+
+    @Override
+    public void setValue(int x, int y, double d) {
+        matrix.setValue(x, y, d);
+    }
+
+    @Override
+    public void setValue(int x, int y, int z, double d) {
+        matrix.setValue(x, y, z, d);
+    }
+
+    @Override
+    public void setValue(int x, int y, int z, int t, double d) {
+        matrix.setValue(x, y, z, t, d);
+    }
+
+    @Override
+    public void setValue(Object[] coordinates, double d) {
+        matrix.setValue(coordinates, d);
+    }
+
+    @Override
+    public void setValue(Object x, double d) {
+        matrix.setValue(x, d);
+    }
+
+    @Override
+    public void setValue(Object x, Object y, double d) {
+        matrix.setValue(x, y, d);
+    }
+
+    @Override
+    public void setValue(Object x, Object y, Object z, double d) {
+        matrix.setValue(x, y, z, d);
+    }
+
+    @Override
+    public void setValue(Object x, Object y, Object z, Object t, double d) {
+        matrix.setValue(x, y, z, t, d);
+    }
+
+    @Override
+    public MatrixND copy() {
+        return wrap(matrix.copy());
+    }
+
+    @Override
+    public MatrixND clone() {
+        return wrap(matrix.clone());
+    }
+
+    @Override
+    public double sumAll() {
+        return matrix.sumAll();
+    }
+
+    @Override
+    public MatrixND sumOverDim(int dim) {
+        return wrap(matrix.sumOverDim(dim));
+    }
+
+    @Override
+    public MatrixND sumOverDim(int dim, int step) {
+        return wrap(matrix.sumOverDim(dim, step));
+    }
+
+    @Override
+    public MatrixND sumOverDim(int dim, int start, int nb) {
+        return wrap(matrix.sumOverDim(dim, start, nb));
+    }
+
+    @Override
+    public double meanAll() {
+        return matrix.meanAll();
+    }
+
+    @Override
+    public MatrixND meanOverDim(int dim) {
+        return wrap(matrix.meanOverDim(dim));
+    }
+
+    @Override
+    public MatrixND meanOverDim(int dim, int step) {
+        return wrap(matrix.meanOverDim(dim, step));
+    }
+
+    @Override
+    public MatrixND cut(int dim, int[] toCut) {
+        return wrap(matrix.cut(dim, toCut));
+    }
+
+    @Override
+    public MatrixND paste(MatrixND mat) {
+        matrix.paste(mat);
+        return this;
+    }
+
+    @Override
+    public MatrixND paste(int[] origin, MatrixND mat) {
+        matrix.paste(origin, mat);
+        return this;
+    }
+
+    @Override
+    public MatrixND pasteSemantics(MatrixND mat) {
+        matrix.pasteSemantics(mat);
+        return this;
+    }
+
+    @Override
+    public MatrixND getSubMatrix(int dim, Object start, int nb) {
+        return wrap(matrix.getSubMatrix(dim, start, nb));
+    }
+
+    @Override
+    public MatrixND getSubMatrix(int dim, int start, int nb) {
+        return wrap(matrix.getSubMatrix(dim, start, nb));
+    }
+
+    @Override
+    public MatrixND getSubMatrix(int dim, Object... elem) {
+        return wrap(matrix.getSubMatrix(dim, elem));
+    }
+
+    @Override
+    public MatrixND getSubMatrix(int dim, int[] elem) {
+        return wrap(matrix.getSubMatrix(dim, elem));
+    }
+
+    @Override
+    public MatrixND getSubMatrix(Object[]... elem) {
+        return wrap(matrix.getSubMatrix(elem));
+    }
+
+    @Override
+    public MatrixND getSubMatrix(int[]... elems) {
+        return wrap(matrix.getSubMatrix(elems));
+    }
+
+    @Override
+    public MatrixND add(MatrixND m) {
+        matrix.add(m);
+        return this;
+    }
+
+    @Override
+    public MatrixND minus(MatrixND m) {
+        matrix.minus(m);
+        return this;
+    }
+
+    @Override
+    public MatrixND transpose() {
+        return wrap(matrix.transpose());
+    }
+
+    @Override
+    public MatrixND reduce() {
+        return wrap(matrix.reduce());
+    }
+
+    @Override
+    public MatrixND reduce(int minNbDim) {
+        return wrap(matrix.reduce(minNbDim));
+    }
+
+    @Override
+    public MatrixND reduceDims(int... dims) {
+        return wrap(matrix.reduceDims(dims));
+    }
+
+    @Override
+    public MatrixND mult(MatrixND m) {
+        matrix.mult(m);
+        return this;
+    }
+
+    @Override
+    public MatrixND mults(double d) {
+        matrix.mults(d);
+        return this;
+    }
+
+    @Override
+    public MatrixND divs(double d) {
+        matrix.divs(d);
+        return this;
+    }
+
+    @Override
+    public MatrixND adds(double d) {
+        matrix.adds(d);
+        return this;
+    }
+
+    @Override
+    public MatrixND minuss(double d) {
+        matrix.minuss(d);
+        return this;
+    }
+
+    @Override
+    public List<?> toList() {
+        return matrix.toList();
+    }
+
+    @Override
+    public void fromList(List<?> list) {
+        matrix.fromList(list);
+    }
+
+    @Override
+    public boolean isSupportedCSV() {
+        return matrix.isSupportedCSV();
+    }
+
+    @Override
+    public void importCSV(Reader reader, int[] origin) throws IOException {
+        matrix.importCSV(reader, origin);
+    }
+
+    @Override
+    public void importCSV(Reader reader, int[] origin, String matrixName) throws IOException {
+        matrix.importCSV(reader, origin, matrixName);
+    }
+
+    @Override
+    public void importCSV(File file, int[] origin) throws IOException {
+        matrix.importCSV(file, origin);
+    }
+
+    @Override
+    public void exportCSV(Writer writer, boolean withSemantics) throws IOException {
+        matrix.exportCSV(writer, withSemantics);
+    }
+
+    @Override
+    public boolean equalsValues(MatrixND mat) {
+        return matrix.equalsValues(mat);
+    }
+
+}

Added: trunk/nuiton-matrix/src/main/java/org/nuiton/math/matrix/SemanticsDecorator.java
===================================================================
--- trunk/nuiton-matrix/src/main/java/org/nuiton/math/matrix/SemanticsDecorator.java	                        (rev 0)
+++ trunk/nuiton-matrix/src/main/java/org/nuiton/math/matrix/SemanticsDecorator.java	2012-08-31 13:08:24 UTC (rev 443)
@@ -0,0 +1,28 @@
+package org.nuiton.math.matrix;
+
+/**
+ *
+ * Permet de convertir automatiquement une semantics vers une autre representation
+ * Par exemple d'une representation String vers une Entity
+ *
+ * @author poussin
+ * @version $Revision$
+ *
+ * Last update: $Date$
+ * by : $Author$
+ */
+public interface SemanticsDecorator {
+    /**
+     * Decore la valeur de la semantique
+     * @param internalValue la valeur interne non decoree
+     * @return la valeur decoree
+     */
+    public Object decorate(Object internalValue);
+    /**
+     * supprime la decoration de la valeur en argument
+     * @param decoratedValue la valeur decoree
+     * @return la valeur decoree
+     */
+    public Object undecorate(Object decoratedValue);
+
+}

    

[Nuiton-matrix-commits] r443 - trunk/nuiton-matrix/src/main/java/org/nuiton/math/matrix

bpoussin＠users.nuiton.org