Laboratoire ICAR » Plateforme TXM

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

package org.txm.r;

import org.eclipse.ui.plugin.AbstractUIPlugin;

import org.osgi.framework.BundleContext;

/**

 * The activator class controls the plug-in life cycle

 */

public class Activator extends AbstractUIPlugin {

	// The plug-in ID

	public static final String PLUGIN_ID = "org.txm.r"; //$NON-NLS-1$

	// The shared instance

	private static Activator plugin;

	/**

	 * The constructor

	 */

	public Activator() {

	}

	/*

	 * (non-Javadoc)

	 * @see org.eclipse.ui.plugin.AbstractUIPlugin#start(org.osgi.framework.BundleContext)

	 */

	public void start(BundleContext context) throws Exception {

		super.start(context);

		plugin = this;

	}

	/*

	 * (non-Javadoc)

	 * @see org.eclipse.ui.plugin.AbstractUIPlugin#stop(org.osgi.framework.BundleContext)

	 */

	public void stop(BundleContext context) throws Exception {

		plugin = null;

		super.stop(context);

	}

	/**

	 * Returns the shared instance

	 *

	 * @return the shared instance

	 */

	public static Activator getDefault() {

		return plugin;

	}

}

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

import org.txm.stat.StatException;

// TODO: Auto-generated Javadoc

/**

 * Super-class of all exception related to the R engine.

 * 

 * @author sloiseau

 */

public class RWorkspaceException extends StatException {

	/** The Constant serialVersionUID. */

	private static final long serialVersionUID = 1630828823146927953L;

	/**

	 * Instantiates a new r workspace exception.

	 */

	public RWorkspaceException() {

		super();

		// TODO Auto-generated constructor stub

	}

	/**

	 * Instantiates a new r workspace exception.

	 *

	 * @param arg0 the arg0

	 * @param arg1 the arg1

	 */

	public RWorkspaceException(String arg0, Throwable arg1) {

		super(arg0, arg1);

		// TODO Auto-generated constructor stub

	}

	/**

	 * Instantiates a new r workspace exception.

	 *

	 * @param arg0 the arg0

	 */

	public RWorkspaceException(String arg0) {

		super(arg0);

		// TODO Auto-generated constructor stub

	}

	/**

	 * Instantiates a new r workspace exception.

	 *

	 * @param arg0 the arg0

	 */

	public RWorkspaceException(Throwable arg0) {

		super(arg0);

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

import org.txm.Messages;

// TODO: Auto-generated Javadoc

/**

 * An exception indicating an error during the evaluation of an expression by

 * the R engine.

 * 

 * @author sloiseau

 */

public class RException extends RWorkspaceException {

	/** The Constant serialVersionUID. */

	private static final long serialVersionUID = -3459835604570896478L;

	/**

	 * Instantiates a new r exception.

	 */

	public RException() {

		super();

	}

	/**

	 * Instantiates a new r exception.

	 *

	 * @param msg the msg

	 */

	public RException(String msg) {

		super(msg);

	}

	/**

	 * Instantiates a new r exception.

	 *

	 * @param expr the expr

	 * @param msg the msg

	 */

	public RException(String expr, String msg) {

		super(Messages.RException_0 + msg + Messages.RException_1 + Messages.RException_2 + expr); 

	}

	/**

	 * Instantiates a new r exception.

	 *

	 * @param arg0 the arg0

	 * @param arg1 the arg1

	 */

	public RException(String arg0, Throwable arg1) {

		super(arg0, arg1);

	}

	/**

	 * Instantiates a new r exception.

	 *

	 * @param arg0 the arg0

	 */

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

// $LastChangedRevision: 2989 $

// $LastChangedBy: mdecorde $ 

//

package org.txm.stat.engine.r;

import java.io.BufferedReader;

import java.io.File;

import java.io.FileReader;

import java.io.FileWriter;

import java.io.IOException;

import java.sql.Connection;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.UUID;

import org.apache.commons.lang.StringEscapeUtils;

import org.apache.commons.lang.StringUtils;

import org.eclipse.core.runtime.Platform;

import org.eclipse.osgi.util.NLS;

import org.eclipse.ui.internal.util.BundleUtility;

import org.osgi.framework.Bundle;

import org.rosuda.REngine.REXP;

import org.rosuda.REngine.REXPLogical;

import org.rosuda.REngine.REXPMismatchException;

import org.rosuda.REngine.REngineException;

import org.rosuda.REngine.Rserve.RConnection;

import org.rosuda.REngine.Rserve.RserveException;

import org.txm.Messages;

import org.txm.stat.StatException;

import org.txm.stat.data.QuantitativeDataStructure;

import org.txm.stat.engine.r.data.RObjectAlreadyExist;

import org.txm.stat.engine.r.rcolt.RColt;

import org.txm.stat.utils.VectorizeArray;

import org.txm.utils.OSDetector;

import org.txm.utils.StreamHog;

import org.txm.utils.SystemProxyDetector;

import org.txm.utils.logger.Log;

import cern.colt.list.DoubleArrayList;

import cern.colt.list.IntArrayList;

import cern.colt.matrix.DoubleMatrix2D;

// TODO: Auto-generated Javadoc

/**

 * RWorkspace is the wrapper on top of the R Engine. All data sent to and

 * retreive from R are using this class. One instance of this class must be

 * created in a program.

 * 

 * This class throw exception RWorkspace exception, encapsulating lower level

 * exception such as <code>RserveException</code>,

 * <code>REXPMismatchException</code> or <code>REngineException</code>.

 * 

 * This class offers many methods avoiding other classes in the toolbox to

 * contain R code. The goal is to concentrate R code, as much as possible, here.

 * See {@link #extractItemFromListByName(String, String)} for instance, and

 * other "extract..." methods.

 * 

 * methods in this class may be organized in the following group:

 * <ul>

 * <li>1/ initialization, connection to R, shutdown, etc.</li>

 * <li>2/ adding object to the R workspace (methods prefixed with "add").</li>

 * <li>3/ methods encapsulating R code for common fonctions: methods prefixed

 * with "assign...", "extract..." for instance.</li>

 * <li>4/ methods for evaluating R expression ({@link #safeEval(String)},

 * {@link #eval(String)}, {@link #evalToDouble(String)}, etc.)</li>

 * <li>5/ Static methods for converting result of evaluation in type (

 * {@link #toDouble(REXP)}, etc.)</li>

 * <li>6/ methods for checking existence of R object in the R workspace,

 * removing object from the R workspace, etc.

 * {@link #checkForDuplicateVariable(String)}, {@link #clearWorkspace()},

 * {@link #containsVariable(String)},

 * {@link #removeVariableFromWorkspace(String)}, etc.)</li>

 * <li>7/ methods for plotting.</li>

 * </ul>

 * 

 * TODO : assign/remove... in a textometrie environment, when Rengine.assign()

 * will be able to deal with R environment.

 * 

 * TODO : remove unused variables from workspace.

 * 

 * @author Sylvain Loiseau <sloiseau@ens-lsh.fr>

 */

public final class RWorkspace {

	/** The comm. */

	private static RFileCommunication comm;

	/** The connection. */

	private static RConnection connection = null;

	/** The eval logs. */

	static ArrayList<String> evalLogs = new ArrayList<String>();

	/** The filecommunication. */

	private static boolean filecommunication = false;

	// --------------------------------------

	/** The last safeeval expr. */

	static String lastSafeevalExpr = ""; //$NON-NLS-1$

	/** The Rserve process. */

	private static Process RserveProcess = null;

	/** The workspace. */

	private static RWorkspace workspace = null;

	/** The error logger. */

	private StreamHog errorLogger;

	/** The input logger. */

	private StreamHog inputLogger;

	/** The loggin. */

	private boolean logging;

	/** The DEFAUL t_ symbol. */

	//private String DEFAULT_SYMBOL = "txmresult"; //$NON-NLS-1$

	/**

	 * Folder where to create the R working directory

	 */

	protected File userdir = null;

	/**

	 * Appendto eval log.

	 *

	 * @param cmd the cmd

	 */

	public static void appendtoEvalLog(String cmd)

	{

		evalLogs.add(cmd);

	}

	/**

	 * Close the connection.

	 *

	 * @throws RWorkspaceException the r workspace exception

	 */

	public static final void closeConnection() throws RWorkspaceException {

		// If no R object have been created during the lif ecycle of the

		// application,

		// the connection has never been initialized.

		if (connection != null)

			connection.close();

	}

	/**

	 * Connect to Rserve.

	 *

	 * @param host the host

	 * @param port the port

	 * @return true if success

	 * @throws RWorkspaceException the r workspace exception

	 */

	public static boolean connect(String host, int port)

			throws RWorkspaceException {

		try {

			Log.info(Messages.RWorkspace_2+host+":"+port); //$NON-NLS-1$

			connection = new RConnection(host, port);

			//connection.setStringEncoding("UTF-8");

			return isConnected();

		} catch (RserveException x) {

			throw new RWorkspaceException(x);

		}

	}

	/**

	 * Connect to Rserve.

	 *

	 * @param host the host

	 * @param port the port

	 * @param user the user

	 * @param password the password

	 * @return true, if successful

	 */

	public static boolean connect(String host, int port, String user,

			String password) {

		try {

			Log.info(Messages.RWorkspace_2+host+":"+port+" user :"+user); //$NON-NLS-2$ //$NON-NLS-1$

			connection = new RConnection(host, port);

			connection.login(user, password);

			return isConnected();

		} catch (RserveException x) {

			System.out.println(Messages.RWorkspace_0 + host+ ", " + port + ", " + user); //$NON-NLS-1$//$NON-NLS-2$ 

			Log.severe(Messages.RWorkspace_0 + host+ ", " + port + ", " + user); //$NON-NLS-1$//$NON-NLS-2$ 

		}

		return false;

	}

	/**

	 * Gets the last safe eval expr.

	 *

	 * @return the last safe eval expr

	 */

	public static String getLastSafeEvalExpr()

	{

		return lastSafeevalExpr;

	}

	public static String getRandomSymbol() {

		String symbol = "Random"+UUID.randomUUID(); //$NON-NLS-1$

		return symbol;

	}

	/**

	 * Entering the R workspace.

	 *

	 * @param 

	 * @return the r workspace instance

	 * @throws RWorkspaceException the r workspace exception

	 */

	public static final RWorkspace getRWorkspaceInstance()

			throws RWorkspaceException {

		Bundle bundle = Platform.getBundle("org.txm.r");

		File userdir = new File(bundle.getLocation());

		System.out.println("BUNDLE LOCATION OF 'org.txm.r': "+userdir);

		if (workspace == null) {

			workspace = new RWorkspace(userdir);

		}

		return workspace;

	}

	/**

	 * Post initialisation of Rserve : loads libraries.

	 * @deprecated The extensions will load themself the packages they need 

	 * @throws RWorkspaceException the r workspace exception

	 */

	private static void init() throws RWorkspaceException {

		String[] packagesToLoad = { }; //$NON-NLS-1$

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

			String name = packagesToLoad[i];

			try {

				// System.out.println("load R lib : " + name);

				connection.eval(("library(" + name + ")")); //$NON-NLS-1$ //$NON-NLS-2$

				// System.out.println("Done : load R lib : " + name);

			} catch (RserveException e) {

				throw new RWorkspaceException(NLS.bind(Messages.LIBBRARY_NOT_LOADED, name, e));

			} catch (Exception e) {

				org.txm.utils.logger.Log.printStackTrace(e);

			}

		}

	}

	/**

	 * Default initialisation of RWorkspace with defautl parameters :

	 * address = 127.0.0.1

	 * port = 6311

	 * debug = false.

	 *

	 * @param pathToRExecutalbe the path to r executalbe

	 * @throws RWorkspaceException the r workspace exception

	 */

	public static final void initializeRWorkspace(String pathToRExecutalbe)

			throws RWorkspaceException {

		workspace = new RWorkspace(pathToRExecutalbe, "127.0.0.1", 6311, false); //$NON-NLS-1$

	}

	/**

	 * Initialize r workspace.

	 * debug = false

	 *

	 * @param pathToRExecutalbe the path to r executalbe

	 * @param host the host

	 * @param port the port

	 * @throws RWorkspaceException the r workspace exception

	 */

	public static final void initializeRWorkspace(String pathToRExecutalbe,

			String host, int port) throws RWorkspaceException {

		workspace = new RWorkspace(pathToRExecutalbe, host, port, false);

	}

	// --------------------------------------

	/**

	 * check R path

	 * check if Rserve has already been launched

	 * if not try to launch it.

	 *

	 * @param pathToRExecutable the path to r executable

	 * @param options 

	 * @param rServeArgs 

	 * @return true if Rserve is launched

	 * @throws RWorkspaceException the r workspace exception

	 */

	private static boolean initRserve(String pathToRExecutable, int port, boolean debug, String rargs, String rServeArgs)

			throws RWorkspaceException {

		boolean isRServerOk;

		if (pathToRExecutable == null || pathToRExecutable.length() == 0) {

			isRServerOk = StartRserve.checkLocalRserve(port, debug, rargs, rServeArgs);

			if (!isRServerOk) {

				throw new RWorkspaceException(

						Messages.RSERVE_PATH_NOT_SET_ERROR); 

			}

		} else {

			Log.info(Messages.RWorkspace_10+pathToRExecutable);

			isRServerOk = StartRserve.launchRserve(pathToRExecutable, port, debug, rargs, rServeArgs);

			// System.out.println("ap launchRserve");

			if (!isRServerOk) {

				throw new RWorkspaceException(Messages.RSERVE_PATH_SET_ERROR+ " : "+pathToRExecutable); //$NON-NLS-1$

			}

		}

		if (isRServerOk) {

			Log.finest("RSERVE_ACTIVATED"); //$NON-NLS-1$

			System.out.println(Messages.CONNECTED_TO_STATS_MODULE); 

			RserveProcess = StartRserve.Rserveprocess;

		}

		return isRServerOk;

	}

	/**

	 * Checks if is connected.

	 *

	 * @return true if the RWorkspace is connected to RServe

	 */

	private static boolean isConnected() {

		if (!connection.isConnected()) {

			return false;

		} else {

			return true;

		}

	}

	/**

	 * Checks if is file tranfert.

	 *

	 * @return true, if is file tranfert

	 */

	public static boolean isFileTranfert() {

		return filecommunication;

	}

	/**

	 * Load eval log.

	 *

	 * @param file the file

	 * @throws IOException Signals that an I/O exception has occurred.

	 */

	public static void loadEvalLog(File file) throws IOException

	{

		BufferedReader reader = new BufferedReader(new FileReader(file));

		String cmd = reader.readLine();

		while(cmd != null)

		{

			evalLogs.add(cmd);

			cmd = reader.readLine();

		}

		reader.close();

	}

	/**

	 * Prints the last safe eval expr.

	 */

	public static void printLastSafeEvalExpr() {

		System.out.println(Messages.RWorkspace_11+lastSafeevalExpr);

	}

	/**

	 * Save eval log.

	 *

	 * @param file the file

	 * @throws IOException Signals that an I/O exception has occurred.

	 */

	public static void saveEvalLog(File file) throws IOException {

		FileWriter writer = new FileWriter(file);

		for (String cmd : evalLogs)

			writer.write(cmd+"\n"); //$NON-NLS-1$

		writer.flush();

		writer.close();

	}

	/**

	 * if state is true, the matrix will be send to R with a File.

	 *

	 * @param state the state

	 * @return true if success

	 */

	public static boolean setUseFileCommunication(boolean state) {

		filecommunication = state;

		if (filecommunication) {

			try {

				comm = new RFileCommunication();

			} catch (IOException e) {

				filecommunication = false;

				Log.severe(Messages.RWorkspace_6+Log.toString(e));

				return false;

			}

		}

		return true;

	}

	/**

	 * Close the connection and destroy the Rserve process.

	 *

	 * @throws RWorkspaceException the r workspace exception

	 */

	public static final void shutdown() throws RWorkspaceException {

		try {

			// If no R object have been created during the lif ecycle of the

			// application,

			// the connection has never been initialized.

			if (connection != null) {

				if (connection.isConnected()) {

					// connection.close(); // No: invoquing "close()" make

					// "shutdown()" to throw a "not connected" exception.

					connection.shutdown();

					connection = null; // warning, after shuting down the

					// server, the connection appears still

					// ok but using it yield to a

					// "Broken pipe" exception.

				}

			}

			if (RserveProcess != null) RserveProcess.destroy();

		} catch (RserveException e) {

			throw new RWorkspaceException(e);

		}

	}

	/**

	 * Start exec.

	 *

	 * @param pathToRExecutable the path to r executable

	 * @param string 

	 * @param string 

	 * @return true, if successful

	 */

	public static boolean startExec(String pathToRExecutable, int port, boolean debug, String rArgs, String rServeArgs) {

		// System.out.println("Start Exec");

		try {

			initRserve(pathToRExecutable, port, debug, rArgs, rServeArgs);

			return true;

		} catch (RWorkspaceException e) {

			System.out.println(Messages.RWorkspace_8+e);

			org.txm.utils.logger.Log.printStackTrace(e);

		}

		return false;

	}

	/**

	 * To double.

	 *

	 * @param rexp the rexp

	 * @return the double[]

	 * @throws RWorkspaceException the r workspace exception

	 */

	public static final double[] toDouble(REXP rexp) throws RWorkspaceException {

		try {

			return rexp.asDoubles();

		} catch (REXPMismatchException e) {

			throw new RWorkspaceException(e);

		}

	}

	/**

	 * protected on purpose. See {@link #getRWorkspaceInstance()}.

	 *

	 * @throws RWorkspaceException the r workspace exception

	 */

	public RWorkspace(File userdir) throws RWorkspaceException {

		this.userdir = userdir;

	}

	// --------------------------------------

//	/**

//	 * protected on purpose. See {@link #getRWorkspaceInstance()}.

//	 *

//	 * @param pathToRExecutable the path to r executable

//	 * @throws RWorkspaceException the r workspace exception

//	 */

//	protected RWorkspace(String pathToRExecutable, int port, boolean debug) throws RWorkspaceException {

//		if (initRserve(pathToRExecutable, port, debug, "","")) {

//			connect();

//			init();

//		}

//	}

	/**

	 * protected on purpose. See {@link #getRWorkspaceInstance()}.

	 *

	 * @param pathToRExecutable the path to r executable

	 * @param host the host

	 * @param port the port

	 * @throws RWorkspaceException the r workspace exception

	 */

	protected RWorkspace(String pathToRExecutable, String host, int port, boolean debug)

			throws RWorkspaceException {

		if (initRserve(pathToRExecutable, port, debug, "", "")) {

			connect(host, port);

			init();

		}

	}

	/**

	 * Add a matrix into the workspace and link it to a name. The inner arrays

	 * of the <code>matrix</code> parameters are the <strong>row</strong> of the

	 * resulting R matrix.

	 *

	 * @param variableName the name to be used in the R workspace.

	 * @param matrix the data to be bound to the name. In the form

	 * <code>matrix[row][column]</code>, with exactly the same number

	 * of column in every row.

	 * @throws RWorkspaceException the r workspace exception

	 */

	public void addMatrixToWorkspace(String variableName, double[][] matrix)

			throws RWorkspaceException {

		//System.out.println("matrix len: "+matrix.length+" test="+(matrix.length == 0));

		if (matrix.length == 0) {

			new RWorkspaceException(Messages.RWorkspace_7);

		}

		int ncol = matrix[0].length;

		int nrow = matrix.length;

		double[] vector = VectorizeArray.vectorizeByInner(matrix);

		if (!filecommunication) {

			try {

				connection.assign(variableName, vector);

			} catch (REngineException e) {

				throw new RWorkspaceException(e);

			}

			try {

				connection .voidEval(variableName

						+ "<- matrix(" + variableName + ", nrow=" + nrow + ", ncol=" + ncol + ", byrow=T)"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$

			} catch (RserveException e) {

				throw new RWorkspaceException(e);

			}

		} else {

			comm.assign(variableName, vector, nrow, ncol);

		}

		Log.finest("MATRIX_ADDED_TO_WORKSPACE" + new Object[] { nrow, ncol, variableName }); //$NON-NLS-1$

	}

	/**

	 * Add a matrix into the workspace and link it to a name. Intended to be

	 * efficient for sparse matrix.

	 *

	 * @param variableName the name to be used in the R workspace.

	 * @param matrix the data to be bound to the name.

	 * @throws RWorkspaceException the r workspace exception

	 */

	public void addMatrixToWorkspace(String variableName, DoubleMatrix2D matrix)

			throws RWorkspaceException {

		double[][] data = RColt.doubleMatrix2D2DoubleDoubleArray(matrix);

		addMatrixToWorkspace(variableName, data);

		// // IntArrayList x = new IntArrayList();

		// // IntArrayList y = new IntArrayList();

		// // DoubleArrayList val = new DoubleArrayList();

		// //

		// // matrix.trimToSize();

		// // matrix.getNonZeros(x, y, val);

		// // x.trimToSize();

		// // y.trimToSize();

		// // val.trimToSize();

		// //

		// // for (int i = 0; i < x.size(); i++) {

		// // x.setQuick(i, x.getQuick(i) + 1);

		// // }

		// //

		// // for (int i = 0; i < y.size(); i++) {

		// // y.setQuick(i, y.getQuick(i) + 1);

		// // }

		// //

		// // System.out.println("colt");

		// // System.out.println(x);

		// // System.out.println(y);

		// // System.out.println(val);

		//		

		// int nrow = matrix.rows();

		// int ncol = matrix.columns();

		// // System.out.println(matrix);

		// // System.out.println(Arrays.toString(vald));

		// try {

		// // connection.eval(variableName + "<- matrix(0, nrow=" + nrow +

		// ", ncol=" + ncol + " );");

		// connection.assign(variableName, m);

		// } catch (RserveException e) {

		// throw new RWorkspaceException(e);

		// }

		// try {

		// connection.assign(variableName + ".nonzero", val.elements());

		// connection.assign(variableName + ".x", x.elements());

		// connection.assign(variableName + ".y", y.elements());

		// } catch (REngineException e) {

		// throw new RWorkspaceException(e);

		// }

		// try {

		// // connection.voidEval("dim(" + variableName + ") <- c(" + nrow +

		// ", " + ncol + ")");

		// // connection.voidEval(variableName + "[" + variableName + ".x, " +

		// variableName + ".y" + " ] <- " + variableName + ".nonzero");

		// // for (int i = 0; i < x.size(); i++) {

		// // for (int j = 0; j < y.size(); j++) {

		// // connection.voidEval(variableName + "[" + x.getQuick(i) + ", " +

		// y.getQuick(j) + "] <- " + val.getQuick(i * 5 + * j));

		// // }

		// // }

		//			

		// } catch (RserveException e) {

		// throw new RWorkspaceException(e);

		// }

		//		

		// removeVariableFromWorkspace(variableName + ".nonzero");

		// removeVariableFromWorkspace(variableName + ".x");

		// removeVariableFromWorkspace(variableName + ".y");

		//		

		//		

		// System.out.println("--------------matrice d'origine----------");

		// System.out.println(matrix);

		//		

		// // DoubleFactory2D.dense.make(arg0)

		// System.out.println("--------------matrice issue de R----------");

		// DenseDoubleMatrix2D m = null;

		// try {

		// m = new

		// DenseDoubleMatrix2D(connection.eval(variableName).asDoubleMatrix());

		// } catch (REXPMismatchException e) {

		// // TODO Auto-generated catch block

		// org.txm.utils.logger.Log.printStackTrace(e);

		// } catch (RserveException e) {

		// // TODO Auto-generated catch block

		// org.txm.utils.logger.Log.printStackTrace(e);

		// }

		// System.out.println(m);

	}

//TODO: is addLexiconToWorkspace used ?

//	/**

//	 * Adds the lexicon to workspace.

//	 *

//	 * @param variableName the variable name

//	 * @param lexicon the lexicon

//	 * @throws RWorkspaceException the r workspace exception

//	 */

//	public void addLexiconToWorkspace(String variableName, Lexicon lexicon)

//			throws RWorkspaceException {

//		int[] freqs = lexicon.getFreq();

//		String[] forms = lexicon.getForms();

//		try {

//			addVectorToWorkspace(variableName, freqs);

//			addVectorToWorkspace(variableName + "_names", forms); //$NON-NLS-1$

//			connection

//			.voidEval("names(" + variableName + ") <- " + variableName + "_names"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$

//			connection.voidEval("rm(" + variableName + "_names" + ")"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$

//		} catch (RserveException e) {

//			throw new RWorkspaceException(e);

//		}

//		Log.finest("LEXICON_ADDED" + new Object[] { lexicon.nbrOfType() + variableName }); //$NON-NLS-1$

//	}

	/**

	 * Add a matrix into the workspace and link it to a name. The inner arrays

	 * of the <code>matrix</code> parameters are the <strong>row</strong> of the

	 * resulting R matrix.

	 *

	 * @param variableName the name to be used in the R workspace.

	 * @param matrix the data to be bound to the name. In the form

	 * <code>matrix[row][column]</code>, with exactly the same number

	 * of column in every row.

	 * @throws RWorkspaceException the r workspace exception

	 */

	public void addMatrixToWorkspace(String variableName, int[][] matrix)

			throws RWorkspaceException {

		int ncol = 0;

		if (matrix.length == 0) {

			ncol = 0;

		} else {

			ncol = matrix[0].length;

		}

		int nrow = matrix.length;

		int[] vector = VectorizeArray.vectorizeByInner(matrix);

		if (!filecommunication) {

			try {

				connection.assign(variableName, vector);

			} catch (REngineException e) {

				throw new RWorkspaceException(e);

			}

			try {

				connection .voidEval(variableName

						+ "<- matrix(" + variableName + ", nrow=" + nrow + ", ncol=" + ncol + ", byrow=T)"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$

			} catch (RserveException e) {

				throw new RWorkspaceException(e);

			}

		} else {

			comm.assign(variableName, vector, nrow, ncol);

		}

		Log.finest("MATRIX_ADDED_TO_WORKSPACE" + new Object[] { nrow, ncol, variableName }); //$NON-NLS-1$

	}

	/**

	 * Adds the vector to workspace.

	 *

	 * @param variableName the variable name

	 * @param vector the vector

	 * @throws RWorkspaceException the r workspace exception

	 */

	public void addVectorToWorkspace(String variableName, double[] vector)

			throws RWorkspaceException {

		if (filecommunication) {

			comm.assign(variableName, vector);

		} else {

			try {

				connection.assign(variableName, vector);

			} catch (REngineException e) {

				throw new RWorkspaceException(e);

			}

		}

		Log.finest("DOUBLE_VECTOR_ADDED_TO_WORKSPACE" + new Object[] { vector.length, variableName }); //$NON-NLS-1$

	}

	/**

	 * Add a vector into the workspace and link it to a name.

	 *

	 * @param variableName the variable name

	 * @param vector the vector

	 * @throws RWorkspaceException the r workspace exception

	 */

	public void addVectorToWorkspace(String variableName, DoubleArrayList vector)

			throws RWorkspaceException {

		vector.trimToSize();

		double[] vald = vector.elements();

		if (filecommunication) {

			comm.assign(variableName, vald);

		} else {

			try {

				connection.assign(variableName, vald);

			} catch (REngineException e) {

				throw new RWorkspaceException(e);

			}

		}

		Log.finest("DOUBLE_VECTOR_ADDED_TO_WORKSPACE" + new Object[] { vald.length, variableName }); //$NON-NLS-1$

	}

	/**

	 * Adds the vector to workspace.

	 *

	 * @param variableName the variable name

	 * @param vector the vector

	 * @throws RWorkspaceException the r workspace exception

	 */

	public void addVectorToWorkspace(String variableName, int[] vector)

			throws RWorkspaceException {

		//checkForDuplicateVariable(variableName);

		if (filecommunication) {

			comm.assign(variableName, vector);

		} else {

			try {

				connection.assign(variableName, vector);

			} catch (REngineException e) {

				throw new RWorkspaceException(e);

			}

		}

		Log.finest("INT_VECTOR_ADDED_TO_WORKSPACE" + new Object[] { vector.length, variableName }); //$NON-NLS-1$

	}

	/**

	 * Adds the vector to workspace.

	 *

	 * @param variableName the variable name

	 * @param vector the vector

	 * @throws RWorkspaceException the r workspace exception

	 */

	public void addVectorToWorkspace(String variableName, IntArrayList vector)

			throws RWorkspaceException {

		vector.trimToSize();

		int[] vald = vector.elements();

		if (filecommunication) {

			comm.assign(variableName, vald);

		} else {

			try {

				connection.assign(variableName, vald);

			} catch (REngineException e) {

				throw new RWorkspaceException(e);

			}

		}

		Log.finest("INT_VECTOR_ADDED_TO_WORKSPACE" + new Object[] { vald.length, variableName }); //$NON-NLS-1$

	}

	// --------------------------------------

	/**

	 * Adds the vector to workspace.

	 *

	 * @param variableName the variable name

	 * @param vector the vector

	 * @throws RWorkspaceException the r workspace exception

	 */

	public void addVectorToWorkspace(String variableName, String[] vector)

			throws RWorkspaceException {

		try {

			connection.assign(variableName, vector);

		} catch (REngineException e) {

			throw new RWorkspaceException(e);

		}

		Log.finest("CHAR_VECTOR_ADDED_TO_WORKSPACE" + new Object[] { vector.length, variableName }); //$NON-NLS-1$

	}

	/**

	 * Assign col names to matrix.

	 *

	 * @param matrix the matrix

	 * @param colNames the col names

	 * @throws RWorkspaceException the r workspace exception

	 */

	public void assignColNamesToMatrix(String matrix, String colNames)

			throws RWorkspaceException {

		voidEval("colnames(" + matrix + ") <- " + colNames); //$NON-NLS-1$ //$NON-NLS-2$

	}

	/**

	 * Assign row names to matrix.

	 *

	 * @param matrix the matrix

	 * @param rowNames the row names

	 * @throws RWorkspaceException the r workspace exception

	 */

	public void assignRowNamesToMatrix(String matrix, String rowNames)

			throws RWorkspaceException {

		voidEval("rownames(" + matrix + ") <- " + rowNames); //$NON-NLS-1$ //$NON-NLS-2$

	}

	/**

	 * Builds the string args.

	 *

	 * @param arguments the arguments

	 * @return the string[]

	 * @throws RWorkspaceException the r workspace exception

	 */

	private String[] buildStringArgs(QuantitativeDataStructure[] arguments) throws RWorkspaceException {

		String[] arguments_as_string = new String[arguments.length];

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

			if (arguments[i] == null) { // null may be used for specif ying

				// "NULL" R object.

				arguments_as_string[i] = "NULL"; //$NON-NLS-1$

			} else {

				if (!containsVariable(arguments[i].getSymbol())) {

					throw new RWorkspaceException(Messages.REQUESTED_OBJECT

							+ arguments[i].getSymbol()

							+ Messages.NOT_FOUND_IN_R); 

				}

				arguments_as_string[i] = arguments[i].getSymbol();

			}

		}

		return arguments_as_string;

	}

	/**

	 * Call a function, with an array of {@link QuantitativeDataStructure}.

	 * 

	 * The <code>QuantitativeDataStructure</code> array is turned into a list of

	 * non-named parameters, and {@link #callFunction(String, String[])} is

	 * called.

	 * 

	 * If one of the <code>QuantitativeDataStructure</code> is <code>null</code>

	 * , then the string "NULL" is used (= R null).

	 *

	 * @param functionName the function name

	 * @param arguments of the function, as non-named parameters.

	 * @return a REXP object

	 * @throws RWorkspaceException the r workspace exception

	 */

	public REXP callFunction(String functionName, QuantitativeDataStructure[] arguments) throws RWorkspaceException {

		String[] arguments_as_string = buildStringArgs(arguments);

		return callFunction(functionName, arguments_as_string);

	}

	/**

	 * Call a function, with an array of {@link QuantitativeDataStructure}.

	 * 

	 * The <code>QuantitativeDataStructure</code> array is turned into a list of

	 * non-named parameters, and {@link #callFunction(String, String[])} is

	 * called.

	 * 

	 * If one of the <code>QuantitativeDataStructure</code> is <code>null</code>

	 * , then the string "NULL" is used (= R null).

	 *

	 * @param functionName the function name

	 * @param arguments of the function, as non-named parameters.

	 * @param symbol the symbol

	 * @return a REXP object

	 * @throws RWorkspaceException the r workspace exception

	 */

	public REXP callFunction(String functionName, QuantitativeDataStructure[] arguments, String symbol) throws RWorkspaceException {

		String[] arguments_as_string = buildStringArgs(arguments);

		return callFunctionAndAffect(functionName, arguments_as_string, symbol);

	}

	/**

	 * See {@link #callFunction(String, String[])}.

	 *

	 * @param functionName the function name

	 * @param argument the argument

	 * @return the rEXP

	 * @throws RWorkspaceException the r workspace exception

	 */

	public REXP callFunction(String functionName, String argument)

			throws RWorkspaceException {

		return callFunction(functionName, new String[] { argument });

	}

	/**

	 * Call a function, with a list of non-named parameters, and return the

	 * result as a <code>REXP</code> object.

	 *

	 * @param functionName the function name

	 * @param arguments of the function, as non-named parameters.

	 * @return a REXP object

	 * @throws RWorkspaceException the r workspace exception

	 */

	public REXP callFunction(String functionName, String[] arguments)

			throws RWorkspaceException {

		//return eval(makeFunctionCall(functionName, arguments));

		return callFunctionAndAffect(functionName, arguments, "txmresult"); //$NON-NLS-1$

	}

	/**

	 * Same as {@link #callFunction(String, String[])}, but affect the result to

	 * a R name in the R workspace.

	 *

	 * @param functionName the function name

	 * @param arguments the arguments

	 * @param symbol the name to which the result of the function will be affected.

	 * @return the rEXP

	 * @throws RWorkspaceException the r workspace exception

	 */

	public REXP callFunctionAndAffect(String functionName, String[] arguments, String symbol) throws RWorkspaceException {

		if (symbol.length() == 0)//symbol must be well formed

			symbol = "txmresult"; //$NON-NLS-1$

		StringBuffer sb = new StringBuffer();

		sb.append(symbol);

		sb.append(RConstant.AFFECTATION);

		sb.append(makeFunctionCall(functionName, arguments));

		return eval(sb.toString());

	}

	/**

	 * Check for duplicate variable.

	 *

	 * @param variableName the variable name

	 * @throws RWorkspaceException the r workspace exception

	 */

	public void checkForDuplicateVariable(String variableName)

			throws RWorkspaceException {

		if (containsVariable(variableName)) {

			throw new RObjectAlreadyExist(

					"Duplicate variable name: " + variableName + ". Existing variables: " + Arrays.toString(getExistingVariableName())); //$NON-NLS-1$ //$NON-NLS-2$

		}

	}

	/**

	 * Remove all variables from workspace.

	 *

	 * @throws RWorkspaceException the r workspace exception

	 */

	public void clearWorkspace() throws RWorkspaceException {

		try {

			connection.voidEval("rm(list=ls(), inherits=FALSE)"); //$NON-NLS-1$

		} catch (RserveException e) {

			throw new RWorkspaceException(e);

		}

		Log.finest("WORKSPACE_PURGED"); //$NON-NLS-1$

	}

	/**

	 * connect to Rserve using the defaults address and port 127.0.0.1:6311

	 *

	 * @return true if success

	 * @throws RWorkspaceException the r workspace exception

	 */

	private boolean connect() throws RWorkspaceException {

		return connect("127.0.0.1", 6311); //$NON-NLS-1$

	}

	/**

	 * Test if a variable exists in the R workspace. A variable exists in the R

	 * workspace if the R function <code>exists</code> return true on that

	 * variable name.

	 *

	 * @param variableName the variable supposed to exists in the R workspace.

	 * @return <code>true</code> if the variable exist, <code>false</code>

	 * otherwise.

	 * @throws RWorkspaceException the r workspace exception

	 */

	public boolean containsVariable(String variableName)

			throws RWorkspaceException {

		REXP res = null;

		try {

			res = connection.eval("exists(\"" + variableName + "\")"); //$NON-NLS-1$ //$NON-NLS-2$

		} catch (RserveException e) {

			throw new RWorkspaceException(e);

		}

		if (res.isLogical() && ((REXPLogical) res).isTRUE()[0]) {

			return true;

		}

		return false;

	}

	/**

	 * Bar delegate call to {@link Rengine#eval(String)}.

	 * 

	 * It is up to the caller to check if everything goes well (testing if the

	 * return value is not of type XT_NULL).

	 *

	 * @param exp the exp

	 * @return the rEXP

	 * @throws RWorkspaceException the r workspace exception

	 */

	public synchronized REXP eval(String exp) throws RWorkspaceException {

		REXP res = null;

		try {

			res = safeEval(exp);

		} catch (RserveException e) {

			RWorkspace.printLastSafeEvalExpr();

			throw new RWorkspaceException(e);

		} catch (REXPMismatchException e) {

			throw new RException(exp + "; " + e.getMessage(), e); //$NON-NLS-1$

		}

		//Log.finest("EVALUATED_EXPRESSION" + exp ); //$NON-NLS-1$

		return res;

	}

	/**

	 * Eval to double.

	 *

	 * @param exp the exp

	 * @return the double[]

	 * @throws RWorkspaceException the r workspace exception

	 */

	public double[] evalToDouble(String exp) throws RWorkspaceException {

		double[] res = null;

		try {

			res = eval(exp).asDoubles();

		} catch (REXPMismatchException e) {

			throw new RWorkspaceException(e);

		}

		return res;

	}

	// public REXP safeVoidEval(String s) throws RserveException, RException,

	// REXPMismatchException {

	// REXP r = connection.voidEval("try({" + s + "}, silent=TRUE)");

	// if (r.inherits("try-error")) throw new RException(r.asString());

	// return r;

	// }

	/**

	 * Eval to double2 d.

	 *

	 * @param exp the exp

	 * @return the double[][]

	 * @throws RWorkspaceException the r workspace exception

	 */

	public double[][] evalToDouble2D(String exp) throws RWorkspaceException {

		double[][] res = null;

		try {

			res = eval(exp).asDoubleMatrix();

		} catch (REXPMismatchException e) {

			throw new RWorkspaceException(e);

		}

		return res;

	}

	/*

	 * Eval to int 2d.

	 *

	 * @param exp the exp

	 * @return the double[][]

	 * @throws RWorkspaceException the r workspace exception

	 */

	public int[][] evalToInt2D(String exp) throws RWorkspaceException {

		int[][] res = null;

		try {

			int[] dims = eval(Messages.MatrixImpl_2+exp+")").asIntegers(); //$NON-NLS-2$

			int ncol = dims[1];

			int nrow = dims[0];

			int[] tmp = eval("c("+exp+")").asIntegers(); //$NON-NLS-1$ //$NON-NLS-2$

			int c = 0;

			res = new int[nrow][ncol];