Laboratoire ICAR » Plateforme TXM

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

<?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 exported="true" kind="lib" path="REngine.jar"/>

	<classpathentry exported="true" kind="lib" path="RserveEngine.jar"/>

	<classpathentry exported="true" kind="lib" path="colt-1.2.0.jar"/>

	<classpathentry kind="output" path="bin"/>

</classpath>

Manifest-Version: 1.0

Bundle-ManifestVersion: 2

Bundle-Name: R Core

Bundle-SymbolicName: org.txm.r

Bundle-Version: 1.0.0.qualifier

Require-Bundle: org.eclipse.ui,

 org.eclipse.core.runtime,

 org.txm.utils;bundle-version="1.0.0"

Bundle-RequiredExecutionEnvironment: JavaSE-1.6

Bundle-ActivationPolicy: lazy

Export-Package: cern.clhep,

 cern.colt,

 cern.colt.bitvector,

 cern.colt.buffer,

 cern.colt.function,

 cern.colt.list,

 cern.colt.list.adapter,

 cern.colt.map,

 cern.colt.matrix,

 cern.colt.matrix.bench,

 cern.colt.matrix.doublealgo,

 cern.colt.matrix.impl,

 cern.colt.matrix.linalg,

 cern.colt.matrix.objectalgo,

 cern.jet.math,

 cern.jet.random,

 cern.jet.random.engine,

 cern.jet.random.sampling,

 cern.jet.stat,

 cern.jet.stat.quantile,

 corejava,

 hep.aida,

 hep.aida.bin,

 hep.aida.ref,

 org.rosuda.REngine,

 org.rosuda.REngine.Rserve,

 org.rosuda.REngine.Rserve.protocol,

 org.txm.stat,

 org.txm.stat.data,

 org.txm.stat.engine.r,

 org.txm.stat.engine.r.data,

 org.txm.stat.engine.r.rcolt,

 org.txm.stat.utils

Bundle-ClassPath: REngine.jar,

 RserveEngine.jar,

 .,

 colt-1.2.0.jar

<?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>

// 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;

// 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

	}

}

<html>

<body>

<p>Root package of all statistical and numeric computing functions of the toolbox.</p>

</body>

</html>

// 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;

	}

}

<html>

<body>

<p>Utility functions for dealing with array (vectorizing, indexing, checking consistency...).</p>

</body>

</html>

// 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:$

// $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);

		}

	}

}

<html>

<body>

<p>Converting colt data structure into data structure suited for the R language (mainly vectorized version of matrix).</p>

</body>

</html>

// 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.rcolt;

import cern.colt.function.IntIntDoubleFunction;

import cern.colt.matrix.DoubleMatrix2D;

// TODO: Auto-generated Javadoc

/**

 * Method for transformation of colt matrix into various array.

 * 

 * @author sloiseau

 * 

 */

public final class RColt {

	/**

	 * Double matrix2 d2 int int array.

	 *

	 * @param matrix the matrix

	 * @return the int[][]

	 */

	public final static int[][] doubleMatrix2D2IntIntArray(DoubleMatrix2D matrix) {

		int rows = matrix.rows();

		int columns = matrix.columns();

		int[][] values = new int[rows][columns];

		for (int row = rows; --row >= 0;) {

			int[] currentRow = values[row];

			for (int column = columns; --column >= 0;) {

				currentRow[column] = (int) matrix.getQuick(row, column);

			}

		}

		return values;

		// final IntIntDoubleFunction fun = new CreateIntIntArray(matrix.rows(),

		// matrix.columns());

		// matrix.forEachNonZero(fun);

		// return ((CreateIntIntArray)fun).getIntIntArray();

	}

	/**

	 * Double matrix2 d2 double double array.

	 *

	 * @param matrix the matrix

	 * @return the double[][]

	 */

	public final static double[][] doubleMatrix2D2DoubleDoubleArray(

			DoubleMatrix2D matrix) {

		matrix.trimToSize();

		return matrix.toArray();

	}

	/*

	 * public final static int[][] intMatrix2D2IntIntArray (IntMatrix2D matrix)

	 * { matrix.trimToSize(); return matrix.toArray(); }

	 */

	/**

	 * Transform a Colt {@link DoubleMatrix2D} into an array of <code>int</code>

	 * .

	 * 

	 * The value of the matrix are stored by column (the values of the first

	 * column, then the values of the second column, etc.)

	 *

	 * @param matrix the matrix

	 * @return an array of <code>int</code>

	 * @todo use {@link DoubleMatrix2D#trimToSize()} and

	 * {@link DoubleMatrix2D#toArray()}

	 */

	public final static int[] doubleMatrix2D2IntArray(DoubleMatrix2D matrix) {

		final IntIntDoubleFunction fun = new CreateIntArray(matrix.rows(),

				matrix.columns());

		matrix.forEachNonZero(fun);

		return ((CreateIntArray) fun).getIntArray();

	}

	// public final static REXP DoubleMatrix2D2REXP(DoubleMatrix2D matrix,

	// Rengine engine, String varName) {

	// final IntIntDoubleFunction fun = new CreateIntIntArray(matrix.rows(),

	// matrix.columns());

	// matrix.forEachNonZero(fun);

	// int[][] m = ((CreateIntIntArray)fun).getIntIntArray();

	// engine.assign(varName, m);

	// return ((CreateIntIntArray)fun).getIntIntArray();

	// }

	/**

	 * The Class CreateIntIntArray.

	 */

	static class CreateIntIntArray implements IntIntDoubleFunction {

		/** The array. */

		private final int[][] array;

		/**

		 * Instantiates a new creates the int int array.

		 *

		 * @param rows the rows

		 * @param columns the columns

		 */

		public CreateIntIntArray(int rows, int columns) {

			array = new int[rows][columns];

			for (int i = 0; i < array.length; i++) {

				for (int j = 0; j < array[i].length; j++) {

					array[i][j] = 0;

				}

			}

		}

		/* (non-Javadoc)

		 * @see cern.colt.function.IntIntDoubleFunction#apply(int, int, double)

		 */

		@Override

		public double apply(int row, int col, double value) {

			array[row][col] = (int) value;

			return value;

		}

		/**

		 * Gets the int int array.

		 *

		 * @return the int int array

		 */

		public int[][] getIntIntArray() {

			return array;

		}

	}

	/**

	 * The Class CreateIntArray.

	 */

	static class CreateIntArray implements IntIntDoubleFunction {

		/** The array. */

		private final int[] array;

		/** The rows. */

		private final int rows;

		/**

		 * Instantiates a new creates the int array.

		 *

		 * @param rows the rows

		 * @param columns the columns

		 */

		public CreateIntArray(int rows, int columns) {

			array = new int[rows * columns];

			for (int i = 0; i < array.length; i++) {

				array[i] = 0;

			}

			this.rows = rows;

		}

		/* (non-Javadoc)

		 * @see cern.colt.function.IntIntDoubleFunction#apply(int, int, double)

		 */

		@Override

		public double apply(int row, int col, double value) {

			array[(col * rows) + row] = (int) value;

			return value;

		}

		/**

		 * Gets the int array.

		 *

		 * @return the int array

		 */

		public int[] getIntArray() {

			return array;

		}

	}

}

// 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-06-15 15:29:16 +0200 (Mon, 15 Jun 2015) $

// $LastChangedRevision: 2989 $

// $LastChangedBy: mdecorde $ 

//

package org.txm.stat.engine.r;

import java.io.File;

import org.rosuda.REngine.Rserve.RConnection;

import org.txm.Messages;

import org.txm.utils.OSDetector;

import org.txm.utils.SystemProxyDetector;

import org.txm.utils.StreamHog;

import org.txm.utils.logger.Log;

// TODO: Auto-generated Javadoc

/**

 * Helper class that consumes output of a process. In addition, it filter output

 * of the REG command on Windows to look for InstallPath registry entry which

 * specif ies the location of R.

 * 

 * @author RServe library

 */

/**

 * simple class that start Rserve locally if it's not running already - see

 * mainly <code>checkLocalRserve</code> method. It spits out quite some

 * debugging outout of the console, so feel free to modif y it for your

 * application if desired.

 * <p>

 * <i>Important:</i> All applications should shutdown every Rserve that they

 * started! Never leave Rserve running if you started it after your application

 * quits since it may pose a security risk. Inform the user if you started an

 * Rserve instance.

 */

public class StartRserve {

	/** shortcut to <code>launchRserve(cmd, "--no-save --slave", "--no-save --slave", false)</code>. */

	public static Process Rserveprocess;

	/**

	 * Launch rserve.

	 *

	 * @param cmd the cmd

	 * @param options 

	 * @return true, if successful

	 */

	protected static boolean launchRserve(String cmd, int port, boolean debug, String rArgs, String rServeArgs) {

		if (new File(cmd).exists() && !new File(cmd).isDirectory()

				&& new File(cmd).canExecute())

			return launchRserve(cmd,

					"--no-save --slave --encoding utf8 "+rArgs, "--RS-encoding utf8 --no-save --slave --encoding utf8 "+rServeArgs, port, debug); //$NON-NLS-1$ //$NON-NLS-2$

		return false;

	}

	/**

	 * attempt to start Rserve. Note: parameters are <b>not</b> quoted, so avoid

	 * using any quotes in arguments

	 *

	 * @param cmd command necessary to start R

	 * @param rargs arguments are are to be passed to R

	 * @param rsrvargs arguments to be passed to Rserve

	 * @param debug the debug

	 * @return <code>true</code> if Rserve is running or was successfully

	 * started, <code>false</code> otherwise.

	 */

	protected static boolean launchRserve(String cmd, String rargs,

			String rsrvargs, int port, boolean debug) {

		//System.out.println("LAUNCH R SERVER "+cmd+" "+port+" "+debug);

		try {

			String[] cmdline = null;

			// FIXME: don't forget to remove this Window dedicated code if we manage to use http_proxy command line argument

			boolean isWindows = false;

			// Windows OS

			if (OSDetector.isFamilyWindows()) {

				isWindows = true; /* Windows startup */

				// TODO: old tests for setting proxy in R

				//Windows : set --internet2 option to manage proxy if any

//				// set Proxy configuration using Eclipse RCP stored values

//				String proxy_conf = "";

//				ProxyConf conf = new ProxyConf(RWorkspace.getRWorkspaceInstance());

//				if (conf.mustSetProxyConfiguration()) {

//					proxy_conf = "http_proxy="+conf.getHttpProxyUrl();

//					rsrvargs += " "+proxy_conf; // add the http_proxy parameter

//					Log.info("Run Rserve with proxy configuration: "+proxy_conf);

//				}

				cmdline = new String[] {

						cmd,

						rargs, 

						"-e", //$NON-NLS-1$

						"library(Rserve);Rserve(" //$NON-NLS-1$ 

						+ (debug ? "TRUE" : "FALSE")  //$NON-NLS-1$ //$NON-NLS-2$

						+ ",port=" + port + "" //$NON-NLS-1$ //$NON-NLS-2$

						+ ",args='" //$NON-NLS-1$

						+ rsrvargs + "')\" " //$NON-NLS-1$

				};	

			}

			// Mac, Linux

			else {

				cmdline = new String[] {

						"/bin/sh", //$NON-NLS-1$

						"-c", //$NON-NLS-1$

						"echo 'library(Rserve);Rserve(" //$NON-NLS-1$

						+ (debug ? "TRUE" : "FALSE") //$NON-NLS-1$ //$NON-NLS-2$

						+ ",port="+port+"" //$NON-NLS-1$ //$NON-NLS-2$

						+ ",args=\"" + rsrvargs //$NON-NLS-1$

						+ "\")'|" + cmd //$NON-NLS-1$ 

						+ " " + rargs }; //$NON-NLS-1$

			}

//			ProcessBuilder builder = new ProcessBuilder(cmdline);

//			Rserveprocess = builder.start();

			Runtime runtime = Runtime.getRuntime();

			Rserveprocess = runtime.exec(cmdline);

			//Log.info(Messages.StartRserve_0+Arrays.toString(cmdline));

			StreamHog errStream = new StreamHog(Rserveprocess.getErrorStream(), debug);

			StreamHog inStream = new StreamHog(Rserveprocess.getInputStream(), debug);

			RWorkspace.getRWorkspaceInstance().registerLogger(errStream, inStream);

			if (!debug && !isWindows)

				Rserveprocess.waitFor();

			// System.out.println("call terminated, let us try to connect ...");

		} catch (Exception x) {

			System.err.println(Messages.StartRserve_21 + x.getMessage());

			return false;

		}

		System.err.print(Messages.StartRserve_22);

		try {

			Thread.sleep(200);

		} catch (InterruptedException ix) { }

		int attempts = 20;

		while (attempts > 0) {

			try {

				System.out.print("."); //$NON-NLS-1$

				RConnection c = new RConnection("127.0.0.1", port); //$NON-NLS-1$

				c.close();

				return true;

			} catch (Exception e2) {

				try {

					Thread.sleep(2000);

				} catch (InterruptedException ix) { }

			}

			attempts--;

		}

		System.out.println(""); //$NON-NLS-1$

		return false;

	}

	/**

	 * checks whether Rserve is running and if that's not the case it attempts

	 * to start it using the defaults for the platform where it is run on. This

	 * method is meant to be set-and-forget and cover most default setups. For

	 * special setups you may get more control over R with <

	 * <code>launchRserve</code> instead.

	 * @param rServeArgs 

	 * @param rargs 

	 *

	 * @return true, if successful

	 */

	protected static boolean checkLocalRserve(int port, boolean debug, String rargs, String rServeArgs) {

		Log.info(Messages.StartRserve_2);

		if (isRserveRunning(port)) {

			Log.info(Messages.StartRserve_3+port);

			return true;

		}

		// Windows OS

		if (OSDetector.isFamilyWindows()) {

			// System.out.println("Windows: query registry to find where R is installed ...");

			String installPath = null;

			try {

				Process rp = Runtime.getRuntime().exec(

						"reg query HKLM\\Software\\R-core\\R"); //$NON-NLS-1$

				StreamHog regHog = new StreamHog(rp.getInputStream(), true);

				rp.waitFor();

				regHog.join();

				installPath = regHog.getInstallPath();

			} catch (Exception rge) {

				System.err.println(Messages.StartRserve_28 + rge);

				return false;

			}

			if (installPath == null) {

				System.err.println(Messages.StartRserve_29);

				return false;

			}

			// System.out.println(" Found R in : "+installPath +

			// "\\bin\\R.exe");

			return launchRserve(installPath + "\\bin\\R.exe", port, debug, rargs, rServeArgs); //$NON-NLS-1$

		}

		Log.info(Messages.StartRserve_4);

		if (launchRserve("R", port, debug, rargs, rServeArgs)) return true; //$NON-NLS-1$

		// R not in the PATH env, try with R common paths

		String[] paths = {

				"/Library/Frameworks/R.framework/Resources/bin/R", //$NON-NLS-1$

				"/usr/local/lib/R/bin/R", //$NON-NLS-1$

				"/usr/lib/R/bin/R", //$NON-NLS-1$

				"/sw/bin/R", //$NON-NLS-1$

				"/usr/common/bin/R", //$NON-NLS-1$

		"/opt/bin/R" }; //$NON-NLS-1$

		for (String path : paths) {

			Log.info(Messages.StartRserve_6+path);

			if (new File(path).exists() && launchRserve(path, port, debug, rargs, rServeArgs)) return true;

		}

		return false;

		//			

		//		return (launchRserve("R", port, debug) //$NON-NLS-1$

		//				|| /* try some common unix locations of R */

		//				(( && launchRserve("/Library/Frameworks/R.framework/Resources/bin/R", port, debug)) //$NON-NLS-1$

		//				|| ((new File("/usr/local/lib/R/bin/R")).exists() && launchRserve("/usr/local/lib/R/bin/R")) //$NON-NLS-1$ //$NON-NLS-2$

		//				|| ((new File("/usr/lib/R/bin/R")).exists() && launchRserve("/usr/lib/R/bin/R")) //$NON-NLS-1$ //$NON-NLS-2$

		//				|| ((new File("/usr/local/bin/R")).exists() && launchRserve("/usr/local/bin/R")) //$NON-NLS-1$ //$NON-NLS-2$

		//				|| ((new File("/sw/bin/R")).exists() && launchRserve("/sw/bin/R")) //$NON-NLS-1$ //$NON-NLS-2$

		//				|| ((new File("/usr/common/bin/R")).exists() && launchRserve("/usr/common/bin/R")) || ((new File( //$NON-NLS-1$ //$NON-NLS-2$

		//				"/opt/bin/R")).exists() && launchRserve("/opt/bin/R"))); //$NON-NLS-1$ //$NON-NLS-2$

	}

	/**

	 * check whether Rserve is currently running (on local machine and default

	 * port).

	 * 

	 * @return <code>true</code> if local Rserve instance is running,

	 *         <code>false</code> otherwise

	 */

	protected static boolean isRserveRunning(int port) {

		try {

			new RConnection("127.0.0.1", port); //$NON-NLS-1$

			// System.out.println("Rserve is running.");

			// c.close();

			return true;

		} catch (Exception e) {

			// System.out.println("First connect try failed with: "+

			// e.getMessage());

		}

		return false;

	}

	public static void main(String[] args) {

		System.out.println("result=" + checkLocalRserve(8212, false, "", ""));

		try {

			System.out.println("Start RServe");

			RConnection c = new RConnection("localhost", 8212);

			System.out.println("Stop RServe");

			c.eval("print(1+1)");

			c.eval("2+2");

			c.shutdown();

			System.out.println("Done");

		} catch (Exception x) {

			x.printStackTrace();

		}

	}

}

// 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;

// TODO: Auto-generated Javadoc

/**

 * The Class RServeException.

 */

public class RServeException extends RException {

	/** The Constant serialVersionUID. */

	private static final long serialVersionUID = 1L;

	/**