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

     <?xml version="1.0" encoding="UTF-8"?>
     <projectDescription>
     	<name>org.txm.r</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.r.core/src/org/txm/stat/package.html (revision 210)
	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

     // 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.stat.utils;
     import java.util.HashMap;
     import java.util.Map;
     import org.txm.Messages;
     // 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(Messages.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(Messages.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.stat.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.stat.utils;
     import org.txm.Messages;
     // 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(Messages.VectorizeArray_0);
+    		}
     		int inner_length = matrix[0].length;
     		if (inner_length < 1) {
     			throw new IllegalArgumentException(Messages.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(Messages.VectorizeArray_10);
+    			}
     			if (inner_length != matrix[i].length) {
     				throw new IllegalArgumentException(Messages.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(Messages.VectorizeArray_4);
+    		}
     		int inner_length = matrix[0].length;
     		if (inner_length < 1) {
     			throw new IllegalArgumentException(Messages.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(Messages.VectorizeArray_10);
+    			}
     			if (inner_length != matrix[i].length) {
     				throw new IllegalArgumentException(Messages.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(Messages.VectorizeArray_8);
+    		}
     		int inner_length = matrix[0].length;
     		int outer_length = matrix.length;
     		if (inner_length < 1) {
     			throw new IllegalArgumentException(Messages.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(Messages.VectorizeArray_10);
+    			}
     			if (inner_length != matrix[i].length) {
     				throw new IllegalArgumentException(Messages.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.stat.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.stat.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;
+    	}
+    }

tmp/org.txm.r.core/src/org/txm/stat/utils/package.html (revision 210)
	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:$
     // $LastChangedRevision:$
     // $LastChangedBy:$
     //
     package org.txm.stat;
     import org.rosuda.REngine.REXP;
     import org.rosuda.REngine.RList;
     import org.rosuda.REngine.Rserve.RConnection;
     // TODO: Auto-generated Javadoc
     /**
      * The Class ConnectToRserve.
      */
     class ConnectToRserve {
     	/**
     	 * The main method.
+    	 *
     	 * @param args the arguments
     	 */
     	public static void main(String args[]) {
     		try {
     			RConnection c = new RConnection();
     			String userhome = System.getProperty("user.home"); //$NON-NLS-1$
     			RList ret = c.eval("source('"+userhome+"/Bureau/R/Rdata')").asList(); //$NON-NLS-1$ //$NON-NLS-2$
     			System.out.println("source ret : "+ret.get(1)); //$NON-NLS-1$
     			System.out.println(ret);
     			REXP ret2 = c.eval("print(lexicaltable)"); //$NON-NLS-1$
     			System.out.println("lexicaltable :"+ret2); //$NON-NLS-1$
+    		}
     		catch(Exception e) {
     			org.txm.utils.logger.Log.printStackTrace(e);
+    		}
+    	}
+    }

     // 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 (Mon, 06 May 2013) $
     // $LastChangedRevision: 2386 $
     // $LastChangedBy: mdecorde $
     //
     package org.txm.stat.engine.r.data;
     import org.txm.stat.engine.r.RWorkspaceException;
     import cern.colt.matrix.DoubleMatrix2D;
     // TODO: Auto-generated Javadoc
     /**
      * A double matrix, backed to the R engine.
+     *
      * @author sloiseau
      */
     public class DoubleMatrix extends MatrixImpl {
     	/**
     	 * Instantiates a new double matrix.
+    	 *
     	 * @param matrix the matrix
     	 * @throws RWorkspaceException the r workspace exception
     	 */
     	public DoubleMatrix(DoubleMatrix2D matrix) throws RWorkspaceException {
     		super(matrix);
     		// TODO Auto-generated constructor stub
+    	}
     	/**
     	 * Instantiates a new double matrix.
+    	 *
     	 * @param mat the mat
     	 * @throws RWorkspaceException the r workspace exception
     	 */
     	public DoubleMatrix(double[][] mat) throws RWorkspaceException {
     		super(mat);
+    	}
     	/**
     	 * Instantiates a new double matrix.
+    	 *
     	 * @param symbol the symbol
     	 * @throws RWorkspaceException the r workspace exception
     	 */
     	public DoubleMatrix(String symbol) throws RWorkspaceException {
     		super(symbol);
     		// TODO Auto-generated constructor stub
+    	}
     	/**
     	 * Instantiates a new double matrix.
+    	 *
     	 * @param matrix the matrix
     	 * @param rowNames the row names
     	 * @param columnNames the column names
     	 * @throws RWorkspaceException the r workspace exception
     	 */
     	public DoubleMatrix(DoubleMatrix2D matrix, String[] rowNames,
     			String[] columnNames) throws RWorkspaceException {
     		super(matrix, rowNames, columnNames);
     		// TODO Auto-generated constructor stub
+    	}
+    }

     // 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 (Mon, 06 May 2013) $
     // $LastChangedRevision: 2386 $
     // $LastChangedBy: mdecorde $
     //
     package org.txm.stat.engine.r.data;
     import org.txm.stat.engine.r.RWorkspaceException;
     // TODO: Auto-generated Javadoc
     /**
      * Exception thrown if a symbol without corresponding object in the R workspace
      * is used.
+     *
      * @author sloiseau
      */
     public class RObjectDoesNotExist extends RWorkspaceException {
     	/** The Constant serialVersionUID. */
     	private static final long serialVersionUID = -1344530765750521820L;
     	/**
     	 * Instantiates a new r object does not exist.
     	 */
     	public RObjectDoesNotExist() {
     		super();
+    	}
     	/**
     	 * Instantiates a new r object does not exist.
+    	 *
     	 * @param arg0 the arg0
     	 * @param arg1 the arg1
     	 */
     	public RObjectDoesNotExist(String arg0, Throwable arg1) {
     		super(arg0, arg1);
+    	}
     	/**
     	 * Instantiates a new r object does not exist.
+    	 *
     	 * @param arg0 the arg0
     	 */
     	public RObjectDoesNotExist(String arg0) {
     		super(arg0);
+    	}
     	/**
     	 * Instantiates a new r object does not exist.
+    	 *
     	 * @param arg0 the arg0
     	 */
     	public RObjectDoesNotExist(Throwable arg0) {
     		super(arg0);
+    	}
+    }

     // 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-08-29 14:23:55 +0200 (Thu, 29 Aug 2013) $
     // $LastChangedRevision: 2519 $
     // $LastChangedBy: nilskredens $
     //
     package org.txm.stat.engine.r.data;
     import java.util.List;
     import org.rosuda.REngine.REXP;
     import org.rosuda.REngine.REXPMismatchException;
     import org.txm.stat.StatException;
     import org.txm.stat.data.Vector;
     import org.txm.stat.engine.r.RWorkspaceException;
     import org.txm.stat.utils.ArrayIndex;
     // TODO: Auto-generated Javadoc
     /**
      * Implementation of the {@link Vector} interface, wrapping a R vector.
+     *
      * @author sloiseau
      */
     public class VectorImpl extends QuantitativeDataStructureImpl implements Vector {
     	/**
     	 * This is final in order to be sure that a length is always defined, and
     	 * defined only once, on a vector.
     	 */
     	private int length;
     	/**
     	 * Instantiates a new vector.
+    	 *
     	 * @param data the data
     	 * @throws RWorkspaceException the r workspace exception
     	 */
     	public VectorImpl(int[] data) throws RWorkspaceException {
     		super();
     		rw.addVectorToWorkspace(symbol, data);
     		length = data.length;
+    	}
     	/**
     	 * Instantiates a new vector impl.
+    	 *
     	 * @param data the data
     	 * @throws RWorkspaceException the r workspace exception
     	 */
     	public VectorImpl(double[] data) throws RWorkspaceException {
     		super();
     		rw.addVectorToWorkspace(symbol, data);
     		length = data.length;
+    	}
     	/**
     	 * Instantiates a new vector impl.
+    	 *
     	 * @param data the data
     	 * @throws RWorkspaceException the r workspace exception
     	 */
     	public VectorImpl(String[] data) throws RWorkspaceException {
     		super();
     		rw.addVectorToWorkspace(symbol, data);
     		length = data.length;
+    	}
     	/**
     	 * Instantiates a new vector.
+    	 *
     	 * @param data the data
     	 * @param symbol the symbol
     	 * @throws RWorkspaceException the r workspace exception
     	 */
     	public VectorImpl(int[] data, String symbol) throws RWorkspaceException {
     		super();
     		this.symbol = symbol;
     		rw.addVectorToWorkspace(symbol, data);
     		length = data.length;
+    	}
     	/**
     	 * Instantiates a new vector impl.
+    	 *
     	 * @param data the data
     	 * @param symbol the symbol
     	 * @throws RWorkspaceException the r workspace exception
     	 */
     	public VectorImpl(double[] data, String symbol) throws RWorkspaceException {
     		super();
     		this.symbol = symbol;
     		rw.addVectorToWorkspace(symbol, data);
     		length = data.length;
+    	}
     	/**
     	 * Instantiates a new vector impl.
+    	 *
     	 * @param data the data
     	 * @param symbol the symbol
     	 * @throws RWorkspaceException the r workspace exception
     	 */
     	public VectorImpl(String[] data, String symbol) throws RWorkspaceException {
     		super();
     		this.symbol = symbol;
     		rw.addVectorToWorkspace(symbol, data);
     		length = data.length;
+    	}
     	/**
     	 * Constructing a Vector when the R object already exists in the workspace:
     	 * we only want to record its symbol in a java object.
+    	 *
     	 * @param symbol the symbol
     	 * @throws RWorkspaceException the r workspace exception
     	 */
     	public VectorImpl(String symbol) throws RWorkspaceException {
     		super(symbol);
     		try {
     			length = rw.eval("length(" + symbol + ")").asInteger(); //$NON-NLS-1$ //$NON-NLS-2$
     		} catch (REXPMismatchException e) {
     			throw new RWorkspaceException(e);
+    		}
+    	}
     	/**
     	 * Sets the r names.
+    	 *
     	 * @param vals the new r names
     	 * @throws RWorkspaceException the r workspace exception
     	 */
     	public void setRNames(String[] vals) throws RWorkspaceException {
     		Vector names = new VectorImpl(vals);
     		StringBuffer exp = new StringBuffer();
     		exp.append("names("); //$NON-NLS-1$
     		exp.append(symbol);
     		exp.append(")"); //$NON-NLS-1$
     		exp.append("<-"); //$NON-NLS-1$
     		exp.append(names.getSymbol());
     		exp.append(";"); //$NON-NLS-1$
     		rw.voidEval(exp.toString());
     		rw.voidEval("rm(" + names.getSymbol() + ");"); //$NON-NLS-1$ //$NON-NLS-2$
+    	}
     	/**
     	 * Gets the r names.
+    	 *
     	 * @param string
     	 *            the string
+    	 *
     	 * @return the r names
+    	 *
     	 * @throws RWorkspaceException
     	 *             the r workspace exception
     	 */
     	public void getRNames(String[] string) throws RWorkspaceException {
     		getAttribute("names"); //$NON-NLS-1$
+    	}
     	/**
     	 * Get a new vector with a copy of the value at the specif ied index in this
     	 * vector.
+    	 *
     	 * @param index the index
     	 * @return the vector
     	 * @throws RWorkspaceException the r workspace exception
     	 */
     	@Override
     	public Vector get(int[] index) throws RWorkspaceException {
     		int[] rIndex = ArrayIndex.zeroToOneBasedIndex(index, this.length);
     		// TODO Auto-generated method stub
     		String name_index = createSymbole(Vector.class);
     		rw.addVectorToWorkspace(name_index, rIndex);
     		String name = createSymbole(Vector.class);
     		rw.voidEval(name + "<- " + symbol + "[ " + name_index + "];"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
     		return new VectorImpl(name);
+    	}
     	/**
     	 * Throw a {@link RWorkspaceException} if the vector is not of type integer.
+    	 *
     	 * @return the int[]
     	 * @throws RWorkspaceException the r workspace exception
     	 */
     	@Override
     	public int[] asIntArray() throws RWorkspaceException {
     		try {
     			return rw.eval(symbol).asIntegers();
     		} catch (REXPMismatchException e) {
     			throw new RWorkspaceException(e);
+    		}
+    	}
     	/* (non-Javadoc)
     	 * @see org.txm.stat.data.Vector#asStringsArray()
     	 */
     	@Override
     	public String[] asStringsArray() throws StatException {
     		try {
     			return rw.eval(symbol).asStrings();
     		} catch (REXPMismatchException e) {
     			throw new RWorkspaceException(e);
+    		}
+    	}
     	/* (non-Javadoc)
     	 * @see org.txm.stat.data.Vector#asDoubleArray()
     	 */
     	@Override
     	public double[] asDoubleArray() throws StatException {
     		try {
     			return rw.eval(symbol).asDoubles();
     		} catch (REXPMismatchException e) {
     			throw new RWorkspaceException(e);
+    		}
+    	}
     	/* (non-Javadoc)
     	 * @see org.txm.stat.data.Vector#getLength()
     	 */
     	@Override
     	public int getLength() throws StatException {
     		return length;
+    	}
     	/* (non-Javadoc)
     	 * @see org.txm.stat.data.Vector#remove(int)
     	 */
     	@Override
     	public boolean remove(int index) {
     		try {
     			if (index < this.length) {
     				rw.eval(symbol + " <- " + symbol + "[-" + (index + 1) + "];"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
     				length--;
+    			}
     		} catch (RWorkspaceException e) {
     			org.txm.utils.logger.Log.printStackTrace(e);
     			return false;
+    		}
     		return true;
+    	}
     	/* (non-Javadoc)
     	 * @see org.txm.stat.data.Vector#setString(int, java.lang.String)
     	 */
     	@Override
     	public void setString(int index, String value) {
     		try {
     			if (index < this.length) {
     				rw.eval(symbol + "[" + (index + 1) + "] <-\"" + value + "\";"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
+    			}
     		} catch (RWorkspaceException e) {
     			org.txm.utils.logger.Log.printStackTrace(e);
+    		}
+    	}
     	/* (non-Javadoc)
     	 * @see org.txm.stat.data.Vector#setDouble(int, double)
     	 */
     	@Override
     	public void setDouble(int index, double value) {
     		try {
     			if (index < this.length) {
     				rw.eval(symbol + "[" + (index + 1) + "] <-" + value + ";"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
+    			}
     		} catch (RWorkspaceException e) {
     			org.txm.utils.logger.Log.printStackTrace(e);
+    		}
+    	}
     	/* (non-Javadoc)
     	 * @see org.txm.stat.data.Vector#setInt(int, int)
     	 */
     	@Override
     	public void setInt(int index, int value) {
     		try {
     			if (index < this.length) {
     				rw.eval(symbol + "[" + (index + 1) + "] <-" + value + ";"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
+    			}
     		} catch (RWorkspaceException e) {
     			org.txm.utils.logger.Log.printStackTrace(e);
+    		}
+    	}
     	/* (non-Javadoc)
     	 * @see org.txm.stat.data.Vector#sort(java.lang.Boolean)
     	 */
     	@Override
     	public void sort(Boolean reverse) {
     		try {
     			//System.out.println("R sort rownames Reverse" + reverse);
     			REXP r = rw
     					.eval(symbol
     							+ "<- " + symbol + "[order(" + symbol + ", decreasing = " + reverse.toString().toUpperCase() + ")];"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
     		} catch (RWorkspaceException e) {
     			// TODO Auto-generated catch block
     			org.txm.utils.logger.Log.printStackTrace(e);
+    		}
+    	}
     	/* (non-Javadoc)
     	 * @see org.txm.stat.data.Vector#setOrder(java.util.List, java.lang.Boolean)
     	 */
     	@Override
     	public void setOrder(List<Integer> neworder, Boolean reverse) {
     		if (neworder.size() != this.length)
     			return;
     		String order = "c("; //$NON-NLS-1$
     		if (reverse) {
     			for (int i = neworder.size() - 1; i >= 0; i--)
     				order += "" + (neworder.get(i) + 1) + ", "; //$NON-NLS-1$ //$NON-NLS-2$
     		} else {
     			for (Integer i : neworder)
     				order += "" + (i + 1) + ", "; //$NON-NLS-1$ //$NON-NLS-2$
+    		}
     		order = order.substring(0, order.length() - 2);
     		order += ")"; //$NON-NLS-1$
     		try {
     			// System.out.println("R sort rownames Reverse"+reverse);
     			REXP r = rw.eval(symbol + "<- " + symbol + "[" + order + "];"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
     		} catch (RWorkspaceException e) {
     			// TODO Auto-generated catch block
     			org.txm.utils.logger.Log.printStackTrace(e);
+    		}
+    	}
     	/* (non-Javadoc)
     	 * @see org.txm.stat.data.Vector#cut(int)
     	 */
     	@Override
     	public void cut(int nlines) {
     		try {
     			// cut nlines
     			REXP r = rw.eval(symbol + "<- " + symbol + "[1:" + (nlines) + "];"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
     		} catch (RWorkspaceException e) {
     			// TODO Auto-generated catch block
     			org.txm.utils.logger.Log.printStackTrace(e);
+    		}
+    	}
+    }

     // 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: 2015-05-22 09:06:15 +0200 (Fri, 22 May 2015) $
     // $LastChangedRevision: 2973 $
     // $LastChangedBy: mdecorde $
     //
     package org.txm.stat.engine.r.data;
     import java.io.BufferedReader;
     import java.io.File;
     import java.io.FileInputStream;
     import java.io.InputStreamReader;
     import java.util.ArrayList;
     import java.util.Arrays;
     import java.util.Collections;
     import java.util.List;
     import org.eclipse.core.runtime.Platform;
     import org.rosuda.REngine.REXP;
     import org.rosuda.REngine.REXPMismatchException;
     import org.txm.stat.StatException;
     import org.txm.stat.data.Matrix;
     import org.txm.stat.data.Vector;
     import org.txm.stat.engine.r.RException;
     import org.txm.stat.engine.r.RWorkspace;
     import org.txm.stat.engine.r.RWorkspaceException;
     import org.txm.stat.utils.ArrayIndex;
     import org.txm.utils.CharsetDetector;
     import org.txm.utils.OSDetector;
     import cern.colt.matrix.DoubleMatrix2D;
     import org.txm.Messages;
     // TODO: Auto-generated Javadoc
     /**
      * Implementation of the {@link Matrix} interface, wrapping a R matrix.
+     *
      * define the methods to edit/delete elements in the matrix
+     *
      * @author sloiseau
      */
     public class MatrixImpl extends QuantitativeDataStructureImpl
     implements Matrix {
     	public static int[][] asIntMatrix(REXP r) throws REXPMismatchException {
     		int[] ct = r.asIntegers();
     		if (ct == null) return null;
     		REXP dim = r.getAttribute("dim"); //$NON-NLS-1$
     		int[] ds = dim.asIntegers();
     		if (ds == null || ds.length != 2)
     			return null; // matrix must be 2-dimensional
     		int m = ds[0], n = ds[1];
     		int[][] rez = new int[m][n];
     		// R stores matrices as matrix(c(1,2,3,4),2,2) = col1:(1,2), col2:(3,4)
     		// we need to copy everything, since we create 2d array from 1d array
     		int i = 0, k = 0;
     		while (i < n) {
     			int j = 0;
     			while (j < m) {
     				rez[j++][i] = ct[k++];
+    			}
     			i++;
+    		}
     		return rez;
+    	}
     	//	/** The ncol. */
     	//	protected int ncol;
     	//
     	//	/** The nrow. */
     	//	protected int nrow;
     	/**
     	 * Instantiates a new matrix impl.
+    	 *
     	 * @param matrix the matrix
     	 * @throws RWorkspaceException the r workspace exception
     	 */
     	public MatrixImpl(double[][] matrix) throws RWorkspaceException {
     		super();
     		rw.addMatrixToWorkspace(symbol, matrix);
     		//		this.nrow = matrix.length;
     		//		this.ncol = matrix[0].length;
     		//this.rows = null;
     		//this.cols = null;
+    	}
     	/**
     	 * Instantiates a new matrix impl.
+    	 *
     	 * @param matrix the matrix
     	 * @throws RWorkspaceException the r workspace exception
     	 */
     	public MatrixImpl(DoubleMatrix2D matrix) throws RWorkspaceException {
     		super();
     		rw.addMatrixToWorkspace(symbol, matrix);
     		//		this.nrow = matrix.rows();
     		//		this.ncol = matrix.columns();
     		//this.rows = null;
     		//this.cols = null;
+    	}
     	/**
     	 * Create a new matrix given a {@link DoubleMatrix2D}, with row and col
     	 * names.
+    	 *
     	 * @param matrix the matrix
     	 * @param rowNames row names.
     	 * @param columnNames the column names
     	 * @throws RWorkspaceException the r workspace exception
     	 */
     	public MatrixImpl(DoubleMatrix2D matrix, String[] rowNames,
     			String[] columnNames) throws RWorkspaceException {
     		this(matrix);
     		if (rowNames == null) {
     			throw new IllegalArgumentException(Messages.MatrixImpl_4);
+    		}
     		//		if (rowNames.length != nrow) {
     		//			throw new IllegalArgumentException(Messages.MatrixImpl_5);
     		//		}
     		//this.rows = new VectorImpl(rowNames);
     		rw.assignRowNamesToMatrix(symbol, new VectorImpl(rowNames).getSymbol());
     		if (columnNames == null) {
     			throw new IllegalArgumentException(Messages.MatrixImpl_6);
+    		}
     		//		if (columnNames.length != ncol) {
     		//			throw new IllegalArgumentException(Messages.MatrixImpl_7
     		//					+ columnNames.length + ", " + ncol + ")."); //$NON-NLS-1$//$NON-NLS-2$ //$NON-NLS-3$
     		//		}
     		//this.cols = new VectorImpl(columnNames);
     		rw.assignColNamesToMatrix(symbol, new VectorImpl(columnNames).getSymbol());
+    	}
     	/**
     	 * Instantiates a new matrix impl.
+    	 *
     	 * @param matrix the matrix
     	 * @throws RWorkspaceException the r workspace exception
     	 */
     	public MatrixImpl(int[][] matrix) throws RWorkspaceException {
     		super();
     		rw.addMatrixToWorkspace(symbol, matrix);
     		//		this.nrow = matrix.length;
     		//		if (matrix.length > 0)
     		//			this.ncol = matrix[0].length;
     		//		else
     		//			this.ncol = 0;
     		//this.rows = null;
     		//this.cols = null;
+    	}
     	public void exchangeColumns(int c1, int c2) {
     		try {
     			RWorkspace rw = RWorkspace.getRWorkspaceInstance();
     			rw.eval("tmp <- "+symbol+"[,"+c1+"]"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
     			rw.eval(symbol+"[,"+c1+"] <- "+symbol+"[,"+c2+"]"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
     			rw.eval(symbol+"[,"+c2+"] <- tmp"); //$NON-NLS-1$ //$NON-NLS-2$
     			rw.eval("tmp <- colnames("+symbol+")["+c1+"]"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
     			rw.eval("colnames("+symbol+")["+c1+"] <- colnames("+symbol+")["+c2+"]"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$
     			rw.eval("colnames("+symbol+")["+c2+"] <- tmp"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
     		} catch (RWorkspaceException e) {
     			// TODO Auto-generated catch block
     			org.txm.utils.logger.Log.printStackTrace(e);
+    		}
+    	}
     	/**
     	 * Instantiates a new matrix impl.
+    	 *
     	 * @param matrix the matrix

Laboratoire ICAR » Plateforme TXM

Révision 210