/ - Diff - Plateforme TXM - Forge du Centre Blaise Pascal

     <?xml version="1.0" encoding="UTF-8"?>
     <classpath>
     	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.6"/>
     	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
     	<classpathentry kind="src" path="src"/>
     	<classpathentry kind="output" path="bin"/>
     </classpath>

     Manifest-Version: 1.0
     Bundle-ManifestVersion: 2
     Bundle-Name: Statistics Engine Core
     Bundle-SymbolicName: org.txm.statsengine.core
     Bundle-Version: 1.0.0.qualifier
     Bundle-RequiredExecutionEnvironment: JavaSE-1.6
     Export-Package: org.txm.statsengine.core,
      org.txm.statsengine.core.data,
      org.txm.statsengine.core.messages,
      org.txm.statsengine.core.utils
     Require-Bundle: org.txm.core;bundle-version="0.7.0",
      org.txm.utils;bundle-version="1.0.0"
     Bundle-Vendor: Textometrie.org

     <?xml version="1.0" encoding="UTF-8"?>
     <projectDescription>
     	<name>org.txm.statsengine.core</name>
     	<comment></comment>
     	<projects>
     	</projects>
     	<buildSpec>
     		<buildCommand>
     			<name>org.eclipse.jdt.core.javabuilder</name>
     			<arguments>
     			</arguments>
     		</buildCommand>
     		<buildCommand>
     			<name>org.eclipse.pde.ManifestBuilder</name>
     			<arguments>
     			</arguments>
     		</buildCommand>
     		<buildCommand>
     			<name>org.eclipse.pde.SchemaBuilder</name>
     			<arguments>
     			</arguments>
     		</buildCommand>
     	</buildSpec>
     	<natures>
     		<nature>org.eclipse.pde.PluginNature</nature>
     		<nature>org.eclipse.jdt.core.javanature</nature>
     	</natures>
     </projectDescription>

tmp/org.txm.statsengine.core/src/org/txm/statsengine/core/utils/package.html (revision 276)
	1	<html>
	2	<body>
	3	<p>Utility functions for dealing with array (vectorizing, indexing, checking consistency...).</p>
	4	</body>
	5	</html>
0	6

     // Copyright © 2010-2013 ENS de Lyon.
     // Copyright © 2007-2010 ENS de Lyon, CNRS, INRP, University of
     // Lyon 2, University of Franche-Comté, University of Nice
     // Sophia Antipolis, University of Paris 3.
     //
     // The TXM platform 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.
     //
     // The TXM platform 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 the TXM platform. If not, see
     // http://www.gnu.org/licenses.
     //
     //
     //
     // $LastChangedDate: 2013-05-06 17:38:43 +0200 (lun., 06 mai 2013) $
     // $LastChangedRevision: 2386 $
     // $LastChangedBy: mdecorde $
     //
     package org.txm.statsengine.core.utils;
     import java.util.HashMap;
     import java.util.Map;
     import org.txm.statsengine.core.messages.StatsEngineCoreMessages;
     // TODO: Auto-generated Javadoc
     /**
      * Utilities for managing index of vector.
+     *
      * @author sloiseau
+     *
      */
     public final class ArrayIndex {
     	/**
     	 * Convert an array of zero-based index to an array of one-base index, that
     	 * is, add <code>1</code> to all elements.
+    	 *
     	 * This method check every index (see exception thrown).
+    	 *
     	 * @param zero_based the zero based index.
     	 * @param length the number of elements that can be indexed.
     	 * @return the one base index.
     	 */
     	public static final int[] zeroToOneBasedIndex(int[] zero_based, int length) {
     		if (zero_based == null || zero_based.length == 0) {
     			throw new IllegalArgumentException(StatsEngineCoreMessages.ArrayIndex_0);
+    		}
     		int[] one_based = new int[zero_based.length];
     		for (int i = 0; i < zero_based.length; i++) {
     			if (zero_based[i] < 0 || zero_based[i] >= length) {
     				throw new IllegalArgumentException(StatsEngineCoreMessages.ArrayIndex_1);
+    			}
     			one_based[i] = zero_based[i] + 1;
+    		}
     		return one_based;
+    	}
     	/**
     	 * Zero to one based index.
+    	 *
     	 * @param zero_based the zero_based
     	 * @return the int
     	 */
     	public static final int zeroToOneBasedIndex(int zero_based) {
     		return zero_based + 1;
+    	}
     	/**
     	 * Get the index (0-based) of the element of subvector into vector. Return
     	 * <code>-1</code> when no element in vector correspond to the element in
     	 * subvector.
+    	 *
     	 * @param vector the vector
     	 * @param subvector the subvector
     	 * @return the index
     	 */
     	public static int[] getIndex(String[] vector, String[] subvector) {
     		int[] result = new int[subvector.length];
     		Map<String, Integer> index = new HashMap<String, Integer>();
     		for (int i = 0; i < subvector.length; i++) {
     			index.put(subvector[i], i);
     			result[i] = -1;
+    		}
     		for (int i = 0; i < vector.length; i++) {
     			if (index.containsKey(vector[i])) {
     				result[index.get(vector[i])] = i;
+    			}
+    		}
     		return result;
+    	}
+    }

     // Copyright © 2010-2013 ENS de Lyon.
     // Copyright © 2007-2010 ENS de Lyon, CNRS, INRP, University of
     // Lyon 2, University of Franche-Comté, University of Nice
     // Sophia Antipolis, University of Paris 3.
     //
     // The TXM platform 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.
     //
     // The TXM platform 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 the TXM platform. If not, see
     // http://www.gnu.org/licenses.
     //
     //
     //
     // $LastChangedDate: 2013-05-06 17:38:43 +0200 (lun., 06 mai 2013) $
     // $LastChangedRevision: 2386 $
     // $LastChangedBy: mdecorde $
     //
     package org.txm.statsengine.core.utils;
     import java.util.Arrays;
     // TODO: Auto-generated Javadoc
     /**
      * Utility methods for testing for equality of arrays.
+     *
      * @author sloiseau
+     *
      */
     public final class ArrayEquals {
     	/**
     	 * Test for equality of both array. For consistency with Arrays.equals
     	 * contract, the two arrays are equals if both are <code>null</code>.
+    	 *
     	 * @param array1 the array1
     	 * @param array2 the array2
     	 * @return <code>true</code> if (1) both arrays are <code>null</code> or if
     	 * (2) both arrays have the same length and contain pair of arrays
     	 * equals to each other according to
     	 * {@link Arrays#equals(int[], int[])}.
     	 */
     	public static final boolean deepEquals(int[][] array1, int[][] array2) {
     		if (array1 == null && array2 == null)
     			return true;
     		if (array1 == null || array2 == null)
     			return false;
     		if (array1.length != array2.length)
     			return false;
     		for (int i = 0; i < array2.length; i++) {
     			if (!Arrays.equals(array1[i], array2[i]))
     				return false;
+    		}
     		return true;
+    	}
+    }

     // Copyright © 2010-2013 ENS de Lyon.
     // Copyright © 2007-2010 ENS de Lyon, CNRS, INRP, University of
     // Lyon 2, University of Franche-Comté, University of Nice
     // Sophia Antipolis, University of Paris 3.
     //
     // The TXM platform 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.
     //
     // The TXM platform 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 the TXM platform. If not, see
     // http://www.gnu.org/licenses.
     //
     //
     //
     // $LastChangedDate: 2013-05-06 17:38:43 +0200 (lun., 06 mai 2013) $
     // $LastChangedRevision: 2386 $
     // $LastChangedBy: mdecorde $
     //
     package org.txm.statsengine.core.utils;
     import org.txm.statsengine.core.messages.StatsEngineCoreMessages;
     // TODO: Auto-generated Javadoc
     /**
      * Static methods for dealing vectorization of Arrays.
+     *
      * @author sloiseau
+     *
      */
     public final class VectorizeArray {
     	/**
     	 * Convert a <code>double * double</code> array in a <code>double</code>
     	 * array. Each inner array of the argument is added one after the other into
     	 * the result array.
+    	 *
     	 * <pre>
     	 * [
     	 * [1, 2, 3],
     	 * [4, 5, 6]
     	 * ]
     	 * </pre>
+    	 *
     	 * result in :
+    	 *
     	 * <pre>
     	 * [1, 2, 3, 4, 5, 6]
     	 * </pre>
+    	 *
     	 * that is, "row first".
+    	 *
     	 * @param matrix a <code>double * double</code> array where all inner arrays
     	 * have the same length.
     	 * @return an array of <code>double</code> produced by vectorization of the
     	 * matrix.
     	 */
     	public final static double[] vectorizeByInner(double[][] matrix) {
     		if (matrix == null || matrix.length == 0) {
     			throw new IllegalArgumentException(StatsEngineCoreMessages.VectorizeArray_0);
+    		}
     		int inner_length = matrix[0].length;
     		if (inner_length < 1) {
     			throw new IllegalArgumentException(StatsEngineCoreMessages.VectorizeArray_1);
+    		}
     		double[] vector = new double[matrix.length * matrix[0].length];
     		for (int i = 0; i < matrix.length; i++) {
     			if (matrix[i] == null) {
     				throw new IllegalArgumentException(StatsEngineCoreMessages.VectorizeArray_10);
+    			}
     			if (inner_length != matrix[i].length) {
     				throw new IllegalArgumentException(StatsEngineCoreMessages.VectorizeArray_3);
+    			}
     			System.arraycopy(matrix[i], 0, vector, i * inner_length,
     					inner_length);
+    		}
     		return vector;
+    	}
     	/**
     	 * Convert a <code>int * int</code> array in a <code>double</code> array.
     	 * Each inner array of the argument is added one after the other into the
     	 * result array.
+    	 *
     	 * <pre>
     	 * [
     	 * [1, 2, 3],
     	 * [4, 5, 6]
     	 * ]
     	 * </pre>
+    	 *
     	 * result in :
+    	 *
     	 * <pre>
     	 * [1, 2, 3, 4, 5, 6]
     	 * </pre>
+    	 *
     	 * that is, "row first".
+    	 *
     	 * @param matrix a <code>int * int</code> array where all inner arrays have the
     	 * same length.
     	 * @return an array of <code>int</code> produced by vectorization of the
     	 * matrix.
     	 */
     	public final static int[] vectorizeByInner(int[][] matrix) {
     		if (matrix == null || matrix.length == 0) {
     			throw new IllegalArgumentException(StatsEngineCoreMessages.VectorizeArray_4);
+    		}
     		int inner_length = matrix[0].length;
     		if (inner_length < 1) {
     			throw new IllegalArgumentException(StatsEngineCoreMessages.VectorizeArray_5);
+    		}
     		int[] vector = new int[matrix.length * matrix[0].length];
     		for (int i = 0; i < matrix.length; i++) {
     			if (matrix[i] == null) {
     				throw new IllegalArgumentException(StatsEngineCoreMessages.VectorizeArray_10);
+    			}
     			if (inner_length != matrix[i].length) {
     				throw new IllegalArgumentException(StatsEngineCoreMessages.VectorizeArray_7);
+    			}
     			System.arraycopy(matrix[i], 0, vector, i * inner_length,
     					inner_length);
+    		}
     		return vector;
+    	}
     	/**
     	 * Convert a <code>double * double</code> array in a <code>double</code>
     	 * array. The elements of the input array are assembled in the output array
     	 * so that elements of same index in the outer array are consecutive. So :
+    	 *
     	 * <pre>
     	 * [
     	 * [1, 2, 3],
     	 * [4, 5, 6]
     	 * ]
     	 * </pre>
+    	 *
     	 * result in :
+    	 *
     	 * <pre>
     	 * [1, 4, 2, 5, 3, 6]
     	 * </pre>
+    	 *
     	 * that is, "column first".
+    	 *
     	 * @param matrix a <code>double * double</code> array where all inner arrays
     	 * have the same length.
     	 * @return an array of <code>double</code> produced by vectorization of the
     	 * matrix.
     	 */
     	public final static double[] vectorizeByOuter(double[][] matrix) {
     		if (matrix == null || matrix.length == 0) {
     			throw new IllegalArgumentException(StatsEngineCoreMessages.VectorizeArray_8);
+    		}
     		int inner_length = matrix[0].length;
     		int outer_length = matrix.length;
     		if (inner_length < 1) {
     			throw new IllegalArgumentException(StatsEngineCoreMessages.VectorizeArray_9);
+    		}
     		double[] vector = new double[matrix.length * matrix[0].length];
     		for (int i = 0; i < matrix.length; i++) {
     			if (matrix[i] == null) {
     				throw new IllegalArgumentException(StatsEngineCoreMessages.VectorizeArray_10);
+    			}
     			if (inner_length != matrix[i].length) {
     				throw new IllegalArgumentException(StatsEngineCoreMessages.VectorizeArray_11);
+    			}
     			for (int j = 0; j < matrix[i].length; j++) {
     				vector[(j * outer_length) + i] = matrix[i][j];
+    			}
+    		}
     		return vector;
+    	}
+    }

     // Copyright © 2010-2013 ENS de Lyon.
     // Copyright © 2007-2010 ENS de Lyon, CNRS, INRP, University of
     // Lyon 2, University of Franche-Comté, University of Nice
     // Sophia Antipolis, University of Paris 3.
     //
     // The TXM platform 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.
     //
     // The TXM platform 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 the TXM platform. If not, see
     // http://www.gnu.org/licenses.
     //
     //
     //
     // $LastChangedDate: 2013-05-06 17:38:43 +0200 (lun., 06 mai 2013) $
     // $LastChangedRevision: 2386 $
     // $LastChangedBy: mdecorde $
     //
     package org.txm.statsengine.core.utils;
     import java.util.Arrays;
     // TODO: Auto-generated Javadoc
     /**
      * Various utilities method for printing arrays.
+     *
      * @author sloiseau
+     *
      */
     public final class PrintArray {
     	/**
     	 * Double array.
+    	 *
     	 * @param matrix the matrix
     	 * @return the string
     	 */
     	public final static String doubleArray(double[][] matrix) {
     		// DoubleMatrix2D m = new SparseDoubleMatrix2D(matrix);
     		// return m.toString();
     		StringBuffer sb = new StringBuffer();
     		for (int i = 0; i < matrix.length; i++) {
     			sb.append(Arrays.toString(matrix[i]));
+    		}
     		return sb.toString();
+    	}
     	/**
     	 * Int array.
+    	 *
     	 * @param matrix the matrix
     	 * @return the string
     	 */
     	public final static String intArray(int[][] matrix) {
     		double[][] doublematrix = new double[matrix.length][matrix[0].length];
     		for (int i = 0; i < matrix.length; i++) {
     			for (int j = 0; j < doublematrix[i].length; j++) {
     				doublematrix[i][j] = matrix[i][j];
+    			}
+    		}
     		return doubleArray(doublematrix);
+    	}
+    }

     // Copyright © 2010-2013 ENS de Lyon.
     // Copyright © 2007-2010 ENS de Lyon, CNRS, INRP, University of
     // Lyon 2, University of Franche-Comté, University of Nice
     // Sophia Antipolis, University of Paris 3.
     //
     // The TXM platform 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.
     //
     // The TXM platform 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 the TXM platform. If not, see
     // http://www.gnu.org/licenses.
     //
     //
     //
     // $LastChangedDate: 2013-05-06 17:38:43 +0200 (lun., 06 mai 2013) $
     // $LastChangedRevision: 2386 $
     // $LastChangedBy: mdecorde $
     //
     package org.txm.statsengine.core.utils;
     // TODO: Auto-generated Javadoc
     /**
      * Various utility methods for checking consistency of matrix as java array of
      * arrays.
+     *
      * @author sloiseau
+     *
      */
     public final class CheckArray {
     	/**
     	 * Check if an array is not null (or 0-length), does not include null inner
     	 * array (or 0 length), and if all inner arrays have the same length.
+    	 *
     	 * @param array the array
     	 * @return <code>true</code> if the condition are satisfied,
     	 * <code>false</code> otherwise.
     	 */
     	public final static boolean checkMatrixRepresentation(int[][] array) {
     		// same code as in #checkMatrixRepresentation(double[][])
     		if (array == null)
     			return false;
     		int length = array.length;
     		if (length < 1)
     			return false;
     		if (array[0] == null)
     			return false;
     		int firstElementLength = array[0].length;
     		if (firstElementLength == 0)
     			return false;
     		for (int i = 0; i < array.length; i++) {
     			if (array[i] == null)
     				return false;
     			if (array[i].length != firstElementLength)
     				return false;
+    		}
     		return true;
+    	}
     	/**
     	 * Check if an array is not null (or 0-length), does not include null inner
     	 * array (or 0 length), and if all inner arrays have the same length.
+    	 *
     	 * @param array the array
     	 * @return <code>true</code> if the condition are satisfied,
     	 * <code>false</code> otherwise.
     	 */
     	public final static boolean checkMatrixRepresentation(double[][] array) {
     		// same code as in #checkMatrixRepresentation(int[][])
     		if (array == null)
     			return false;
     		int length = array.length;
     		if (length < 1)
     			return false;
     		if (array[0] == null)
     			return false;
     		int firstElementLength = array[0].length;
     		if (firstElementLength == 0)
     			return false;
     		for (int i = 0; i < array.length; i++) {
     			if (array[i] == null)
     				return false;
     			if (array[i].length != firstElementLength)
     				return false;
+    		}
     		return true;
+    	}
+    }

     VectorizeArray_0  = ** Nothing to do with an empty matrix
     VectorizeArray_1  = ** Inner arrays must be of dimension > 0.
     VectorizeArray_10 = ** An inner array cannot be null.
     VectorizeArray_11 = ** All the inner array do not have the same length.
     VectorizeArray_3  = ** All the inner array do not have the same length.
     VectorizeArray_4  = ** Nothing to do with an empty matrix
     VectorizeArray_5  = ** Inner arrays must be of dimension > 0.
     VectorizeArray_7  = ** All the inner array do not have the same length.
     VectorizeArray_8  = ** Nothing to do with an empty matrix
     VectorizeArray_9  = ** Inner arrays must be of dimension > 0.
     ArrayIndex_0 = ** The index array can not be null or empty.
     ArrayIndex_1 = ** A zero-based index cannot be < 0 or > to the number of indexed elements.
     Factor_0 = ** Not implemented
     MatrixImpl_0  = A variable ("
     MatrixImpl_1  = ") does not exist in the R workspace.
     MatrixImpl_10 = Row index (
     MatrixImpl_11 = ) too big (max
     MatrixImpl_13 = Col index (
     MatrixImpl_14 = ) too big (max
     MatrixImpl_19 = R object evaluated to null.
     MatrixImpl_2  = dim(
     MatrixImpl_20 = Unknown type:
     MatrixImpl_21 = mode
     MatrixImpl_22 = Row index (
     MatrixImpl_23 = ) too big (max
     MatrixImpl_28 = Column index (
     MatrixImpl_29 = ) too big (max
     MatrixImpl_4  = Row names of a contingency table cannot be null.
     MatrixImpl_5  = Row names vector length must be equal to the number of rows of the matrix.
     MatrixImpl_6  = Column names of a contingency table cannot be null
     MatrixImpl_67 = Matrix: failed to get nrow:
     MatrixImpl_7  = Col names vector length must be equals to the number of columns of the matrix (
     MatrixImpl_73 = MatrixImpl: Error: column size differs: original
     MatrixImpl_79 = Failed to get row names
     MatrixImpl_88 = Cannot delete all lines
     QuantitativeDataStructureImpl_0 = No object with name "
     QuantitativeDataStructureImpl_1 = " in the workspace
     QuantitativeDataStructureImpl_2 = ** Cannot delete a non-existing object.

     package org.txm.statsengine.core.messages;
     import org.txm.utils.messages.Utf8NLS;
     public class StatsEngineCoreMessages extends Utf8NLS {
     	private static final String BUNDLE_NAME = "org.txm.statsengine.core.messages.messages"; //$NON-NLS-1$
     	public static String VectorizeArray_0;
     	public static String VectorizeArray_1;
     	public static String VectorizeArray_10;
     	public static String VectorizeArray_11;
     	public static String VectorizeArray_3;
     	public static String VectorizeArray_4;
     	public static String VectorizeArray_5;
     	public static String VectorizeArray_7;
     	public static String VectorizeArray_8;
     	public static String VectorizeArray_9;
     	public static String ArrayIndex_0;
     	public static String ArrayIndex_1;
     	public static String Factor_0;
     	public static String MatrixImpl_0;
     	public static String MatrixImpl_1;
     	public static String MatrixImpl_10;
     	public static String MatrixImpl_11;
     	public static String MatrixImpl_13;
     	public static String MatrixImpl_14;
     	public static String MatrixImpl_19;
     	public static String MatrixImpl_2;
     	public static String MatrixImpl_20;
     	public static String MatrixImpl_21;
     	public static String MatrixImpl_22;
     	public static String MatrixImpl_23;
     	public static String MatrixImpl_28;
     	public static String MatrixImpl_29;
     	public static String MatrixImpl_4;
     	public static String MatrixImpl_5;
     	public static String MatrixImpl_6;
     	public static String MatrixImpl_67;
     	public static String MatrixImpl_7;
     	public static String MatrixImpl_73;
     	public static String MatrixImpl_79;
     	public static String MatrixImpl_88;
     	public static String QuantitativeDataStructureImpl_0;
     	public static String QuantitativeDataStructureImpl_1;
     	public static String QuantitativeDataStructureImpl_2;
     	static {
     		// initialize resource bundle
     		Utf8NLS.initializeMessages(BUNDLE_NAME, StatsEngineCoreMessages.class);
+    	}
     	private StatsEngineCoreMessages() {
+    	}
+    }

     VectorizeArray_0  = ** Rien à faire avec une matrice vide
     VectorizeArray_1  = ** Les tableaux internes doivent avoir une dimension supérieure à 0
     VectorizeArray_10 = ** Un tableau interne ne peut pas être nul
     VectorizeArray_11 = ** Les tableaux internes n'ont pas tous la même dimension.
     VectorizeArray_3  = ** Les tableaux internes n'ont pas tous la même dimension.
     VectorizeArray_4  = ** Rien à faire avec une matrice vide
     VectorizeArray_5  = ** Les tableaux internes doivent avoir une dimension supérieure à 0
     VectorizeArray_7  = * Les tableaux internes n'ont pas tous la même dimension.
     VectorizeArray_8  = ** Rien à faire avec une matrice vide
     VectorizeArray_9  = ** Les tableaux internes doivent avoir une dimension supérieure à 0
     ArrayIndex_0 = ** Le tableau d'index ne peut pas être nul ou vide.
     ArrayIndex_1 = ** Un index commençant à 0 ne peut pas être inférieur à 0 ou supérieur au nombre d'éléments indexés.
     Factor_0 = ** Non implémenté
     MatrixImpl_0  = Une variable ("
     MatrixImpl_1  = ") n'existe pas dans l'espace de travail R.
     MatrixImpl_10 = Index de ligne (
     MatrixImpl_11 = ) trop grand (max
     MatrixImpl_13 = Index de colonne (
     MatrixImpl_14 = ) trop grand (max
     MatrixImpl_19 = L'objet R a une valeur nulle.
     MatrixImpl_2  = dim(
     MatrixImpl_20 = Type inconnu :
     MatrixImpl_21 = mode
     MatrixImpl_22 = Index de ligne (
     MatrixImpl_23 = ) trop grand (max
     MatrixImpl_28 = Index de colonne (
     MatrixImpl_29 = ) trop grand (max
     MatrixImpl_4  = Les noms de lignes d'une matrice de contingence ne peuvent pas être nuls.
     MatrixImpl_5  = La dimension du vecteur des noms de lignes doit être égale au nombre de lignes de la matrice.
     MatrixImpl_6  = Les noms de colonnes d'une matrice de contingence ne peuvent pas être nuls.
     MatrixImpl_67 = Matrice: impossible d'obtenir le nombre de lignes:
     MatrixImpl_7  = La dimension du vecteur des noms de colonnes doit être égale au nombre de colonnes de la matrice (
     MatrixImpl_73 = MatrixImpl: Erreur: la taille des colonnes diffère de l'originale
     MatrixImpl_79 = Impossible d'obtenir les noms de lignes
     MatrixImpl_88 = Impossible de supprimer toutes les lignes
     QuantitativeDataStructureImpl_0 = Aucun objet de nom "
     QuantitativeDataStructureImpl_1 = " dans l'espace de travail
     QuantitativeDataStructureImpl_2 = ** Impossible de supprimer un objet qui n'existe pas.

tmp/org.txm.statsengine.core/src/org/txm/statsengine/core/data/package.html (revision 276)
	1	<html>
	2	<body>
	3	<p>Definition of quantitative data structures for representing corpus.</p>
	4	</body>
	5	</html>
0	6

     // Copyright © 2010-2013 ENS de Lyon.
     // Copyright © 2007-2010 ENS de Lyon, CNRS, INRP, University of
     // Lyon 2, University of Franche-Comté, University of Nice
     // Sophia Antipolis, University of Paris 3.
     //
     // The TXM platform 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.
     //
     // The TXM platform 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 the TXM platform. If not, see
     // http://www.gnu.org/licenses.
     //
     //
     //
     // $LastChangedDate: 2013-05-06 17:38:43 +0200 (lun., 06 mai 2013) $
     // $LastChangedRevision: 2386 $
     // $LastChangedBy: mdecorde $
     //
     package org.txm.statsengine.core.data;
     import java.util.List;
     import org.txm.statsengine.core.StatException;
     // TODO: Auto-generated Javadoc
     /**
      * The interface Vector.
+     *
      * @author sloiseau
      */
     public interface Vector extends QuantitativeDataStructure {
     	/**
     	 * Get the sub-vector given index.
+    	 *
     	 * @param index
     	 *            0-based index.
+    	 *
     	 * @return a new vector, copy to the selected values (modif ication to the
     	 *         vector returned does not modif y the vector).
+    	 *
     	 * @throws StatException
     	 *             if anything goes wrong.
     	 */
     	public Vector get(int[] index) throws StatException;
     	/**
     	 * Convert the vector to a java array of <code>int</code>, if possible.
+    	 *
     	 * @return a java array of <code>int</code>.
+    	 *
     	 * @throws StatException
     	 *             if anything goes wrong, ni particular if this Vector cannot
     	 *             be converted into <code>int</code>.
     	 */
     	public int[] asIntArray() throws StatException;
     	/**
     	 * Convert the vector to a java array of <code>double</code>, if possible.
+    	 *
     	 * @return a java array of <code>double</code>.
+    	 *
     	 * @throws StatException
     	 *             if anything goes wrong, ni particular if this Vector cannot
     	 *             be converted into <code>double</code>.
     	 */
     	public double[] asDoubleArray() throws StatException;
     	/**
     	 * Convert the vector to a java array of <code>String</code>, if possible.
+    	 *
     	 * @return a java array of <code>String</code>.
+    	 *
     	 * @throws StatException
     	 *             if anything goes wrong, ni particular if this Vector cannot
     	 *             be converted into <code>String</code>.
     	 */
     	public String[] asStringsArray() throws StatException;
     	/**
     	 * Get the length of the vector.
+    	 *
     	 * @return the length.
+    	 *
     	 * @throws StatException
     	 *             if anything goes wrong.
     	 */
     	public int getLength() throws StatException;
     	/**
     	 * Removes the.
+    	 *
     	 * @param col the col
     	 * @return true, if successful
     	 */
     	public boolean remove(int col);
     	/**
     	 * Sets the string.
+    	 *
     	 * @param i the i
     	 * @param value the value
     	 */
     	public void setString(int i, String value);
     	/**
     	 * Sets the int.
+    	 *
     	 * @param i the i
     	 * @param value the value
     	 */
     	public void setInt(int i, int value);
     	/**
     	 * Sets the double.
+    	 *
     	 * @param i the i
     	 * @param value the value
     	 */
     	public void setDouble(int i, double value);
     	/**
     	 * Sort.
+    	 *
     	 * @param reverse the reverse
     	 */
     	public void sort(Boolean reverse);
     	/**
     	 * Sets the order.
+    	 *
     	 * @param neworder the neworder
     	 * @param reverse the reverse
     	 */
     	public void setOrder(List<Integer> neworder, Boolean reverse);
     	/**
     	 * Cut.
+    	 *
     	 * @param nlines the nlines
     	 */
     	public void cut(int nlines);
     	// public String get(int i);
+    }

     // Copyright © 2010-2013 ENS de Lyon.
     // Copyright © 2007-2010 ENS de Lyon, CNRS, INRP, University of
     // Lyon 2, University of Franche-Comté, University of Nice
     // Sophia Antipolis, University of Paris 3.
     //
     // The TXM platform 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.
     //
     // The TXM platform 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 the TXM platform. If not, see
     // http://www.gnu.org/licenses.
     //
     //
     //
     // $LastChangedDate: 2013-05-06 17:38:43 +0200 (lun., 06 mai 2013) $
     // $LastChangedRevision: 2386 $
     // $LastChangedBy: mdecorde $
     //
     package org.txm.statsengine.core.data;
     import org.txm.statsengine.core.StatException;
     // TODO: Auto-generated Javadoc
     /**
      * The Interface Matrix, root of all other matrix-like structure.
+     *
      * @author sloiseau
      */
     public interface Matrix extends QuantitativeDataStructure {
     	/**
     	 * Get the value at the specif ied cell.
+    	 *
     	 * @param row 0-based row index
     	 * @param col 0-based column index
     	 * @return the value as a <code>double</code>
     	 * @throws StatException the stat exception
     	 */
     	public double get(int row, int col) throws StatException;
     	/**
     	 * The number of rows in the contingency table.
+    	 *
     	 * @return the number of raw
     	 */
     	public abstract int getNRows();
     	/**
     	 * Exchange 2 columns in the lexical table
     	 * @param c1 1..N+1
     	 * @param c2 1..N+1
     	 */
     	public abstract void exchangeColumns(int c1, int c2);
     	/**
     	 * The number of columns in the contingency table.
+    	 *
     	 * @return the number of columns
     	 */
     	public abstract int getNColumns();
     	/**
     	 * Get the row names or null if no row names.
+    	 *
     	 * Row names are available if the
+    	 *
     	 * @return the row names
     	 * {@link #Matrix(DoubleMatrix2D, String[], String[], Header)} constructor
     	 * has been used for this object.
     	 */
     	public abstract Vector getRowNames();
     	/**
     	 * Get the col names or null if no col names.
+    	 *
     	 * Col names are available if the
+    	 *
     	 * @return the col names
     	 * {@link #Matrix(DoubleMatrix2D, String[], String[], Header)} constructor
     	 * has been used for this object.
     	 */
     	public abstract Vector getColNames();
     	/**
     	 * Gets a row vector as a Vector object.
+    	 *
     	 * @param index 0-based row index.
     	 * @return the row
     	 * @throws StatException the stat exception
     	 */
     	public abstract Vector getRow(int index) throws StatException;
     	/**
     	 * Gets a column vector as a Vector object.
+    	 *
     	 * @param index 0-based index column index.
     	 * @return the row
     	 * @throws StatException the stat exception
     	 */
     	public abstract Vector getCol(int index) throws StatException;
     	/**
     	 * Gets a column vector as a Vector object.
+    	 *
     	 * @param column the column name
     	 * @return the column vector
     	 * @throws StatException the stat exception
     	 */
     	public abstract Vector getCol(String column) throws StatException;
     	/**
     	 * Gets a row vector as a Vector object.
+    	 *
     	 * @param row the row name
     	 * @return the row vector
     	 * @throws StatException the stat exception
     	 */
     	public abstract Vector getRow(String row) throws StatException;
+    }

     // Copyright © 2010-2013 ENS de Lyon.
     // Copyright © 2007-2010 ENS de Lyon, CNRS, INRP, University of
     // Lyon 2, University of Franche-Comté, University of Nice
     // Sophia Antipolis, University of Paris 3.
     //
     // The TXM platform 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.
     //
     // The TXM platform 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 the TXM platform. If not, see
     // http://www.gnu.org/licenses.
     //
     //
     //
     // $LastChangedDate: 2013-05-06 17:38:43 +0200 (lun., 06 mai 2013) $
     // $LastChangedRevision: 2386 $
     // $LastChangedBy: mdecorde $
     //
     package org.txm.statsengine.core.data;
     import org.txm.statsengine.core.StatException;
     // TODO: Auto-generated Javadoc
     /**
      * The Interface ContingencyTable.
+     *
      * @author sloiseau
      */
     public interface ContingencyTable extends Matrix {
     	/**
     	 * Gets the row margin.
+    	 *
     	 * @return the row margin
+    	 *
     	 * @throws RWorkspaceException
     	 *             the r workspace exception
     	 */
     	public Vector getRowMarginsVector() throws StatException;
     	/**
     	 * Gets the col margin.
+    	 *
     	 * @return the col margin
+    	 *
     	 * @throws RWorkspaceException
     	 *             the r workspace exception
     	 */
     	public Vector getColMarginsVector() throws StatException;
     	/**
     	 * Gets the col margin.
+    	 *
     	 * @return the col margin
+    	 *
     	 * @throws RWorkspaceException
     	 *             the r workspace exception
     	 */
     	public int[] getColMargins() throws Exception;
     	/**
     	 * Gets the col margin.
+    	 *
     	 * @return the col margin
+    	 *
     	 * @throws RWorkspaceException
     	 *             the r workspace exception
     	 */
     	public int[] getRowMargins() throws Exception;
     	/**
     	 * Gets the total.
+    	 *
     	 * @return the total
+    	 *
     	 * @throws RWorkspaceException
     	 *             the r workspace exception
     	 */
     	public int getTotal() throws StatException;
+    }

     // Copyright © 2010-2013 ENS de Lyon.
     // Copyright © 2007-2010 ENS de Lyon, CNRS, INRP, University of
     // Lyon 2, University of Franche-Comté, University of Nice
     // Sophia Antipolis, University of Paris 3.
     //
     // The TXM platform 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.
     //
     // The TXM platform 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 the TXM platform. If not, see
     // http://www.gnu.org/licenses.
     //
     //
     //
     // $LastChangedDate: 2013-05-06 17:38:43 +0200 (lun., 06 mai 2013) $
     // $LastChangedRevision: 2386 $
     // $LastChangedBy: mdecorde $
     //
     package org.txm.statsengine.core.data;
     import org.txm.core.results.ITXMResult;
     // TODO: Auto-generated Javadoc
     /**
      * The root of all other data structures.
+     *
      * @author sloiseau
      */
     public interface QuantitativeDataStructure extends ITXMResult {
     	/**
     	 * The symbol is a the name of the data structure in a wrapped statistical
     	 * engine.
+    	 *
     	 * @return the symbol of this data structure.
     	 */
     	public String getSymbol();
+    }

     // Copyright © 2010-2013 ENS de Lyon.
     // Copyright © 2007-2010 ENS de Lyon, CNRS, INRP, University of
     // Lyon 2, University of Franche-Comté, University of Nice
     // Sophia Antipolis, University of Paris 3.
     //
     // The TXM platform 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.
     //
     // The TXM platform 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 the TXM platform. If not, see
     // http://www.gnu.org/licenses.
     //
     //
     //
     // $LastChangedDate: 2013-05-06 17:38:43 +0200 (lun., 06 mai 2013) $
     // $LastChangedRevision: 2386 $
     // $LastChangedBy: mdecorde $
     //
     package org.txm.statsengine.core;
     // TODO: Auto-generated Javadoc
     /**
      * General exception in statistical computing, the super class of all exceptions
      * related to statistical computing.
+     *
      * @author sloiseau
+     *
      */
     public class StatException extends Exception {
     	/** The Constant serialVersionUID. */
     	private static final long serialVersionUID = 7220819361950262761L;
     	/**
     	 * Instantiates a new stat exception.
     	 */
     	public StatException() {
     		super();
     		// TODO Auto-generated constructor stub
+    	}
     	/**
     	 * Instantiates a new stat exception.
+    	 *
     	 * @param message the message
     	 * @param cause the cause
     	 */
     	public StatException(String message, Throwable cause) {
     		super(message, cause);
     		// TODO Auto-generated constructor stub
+    	}
     	/**
     	 * Instantiates a new stat exception.
+    	 *
     	 * @param message the message
     	 */
     	public StatException(String message) {
     		super(message);
     		// TODO Auto-generated constructor stub
+    	}
     	/**
     	 * Instantiates a new stat exception.
+    	 *
     	 * @param cause the cause
     	 */
     	public StatException(Throwable cause) {
     		super(cause);
     		// TODO Auto-generated constructor stub
+    	}
+    }

tmp/org.txm.statsengine.core/src/org/txm/statsengine/core/package.html (revision 276)
	1	<html>
	2	<body>
	3	<p>Root package of all statistical and numeric computing functions of the toolbox.</p>
	4	</body>
	5	</html>
0	6

tmp/org.txm.statsengine.core/build.properties (revision 276)
	1	source.. = src/
	2	output.. = bin/
	3	bin.includes = META-INF/,\
	4	.
0	5

     eclipse.preferences.version=1
     org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
     org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.6
     org.eclipse.jdt.core.compiler.compliance=1.6
     org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
     org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
     org.eclipse.jdt.core.compiler.source=1.6

Laboratoire ICAR » Plateforme TXM

Révision 276