Laboratoire ICAR » Plateforme TXM

import org.txm.statsengine.core.data.Vector;

import org.txm.statsengine.core.utils.ArrayIndex;

import org.txm.statsengine.r.core.exceptions.RWorkspaceException;

/**

 * 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.

	 *

		rw.addVectorToWorkspace(symbol, data);

		length = data.length;

	}

	/**

	 * Instantiates a new vector impl.

	 *

		rw.addVectorToWorkspace(symbol, data);

		length = data.length;

	}

	/**

	 * Instantiates a new vector impl.

	 *

		rw.addVectorToWorkspace(symbol, data);

		length = data.length;

	}

	/**

	 * Instantiates a new vector impl.

	 *

		rw.addVectorToWorkspace(symbol, data);

		length = data.length;

	}

	/**

	 * Instantiates a new vector impl.

	 *

		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.

		super(symbol);

		try {

			length = rw.eval("length(" + symbol + ")").asInteger(); //$NON-NLS-1$ //$NON-NLS-2$

			throw new RWorkspaceException(e);

		}

	}

	/**

	 * Sets the r names.

	 *

	 */

	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(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.

	 * 

	public void getRNames(String[] string) throws RWorkspaceException {

		getAttribute("names"); //$NON-NLS-1$

	}

	/**

	 * Get a new vector with a copy of the value at the specified index in this

	 * vector.

		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 new int[0];

			}

			return rexp.asIntegers();

			throw new RWorkspaceException(e);

		}

	}

	 * @see org.txm.stat.data.Vector#asStringsArray()

	 */

	@Override

				return new String[0];

			}

			return rexp.asStrings();

			throw new RWorkspaceException(e);

		}

	}

	 * @see org.txm.stat.data.Vector#asDoubleArray()

	 */

	@Override

				return new double[0];

			}

			return rexp.asDoubles();

			throw new RWorkspaceException(e);

		}

	}

	 * @see org.txm.stat.data.Vector#getLength()

	 */

	@Override

	public int getLength() throws StatException {

		return length;

	}

	 * @see org.txm.stat.data.Vector#remove(int)

	 */

	@Override

				rw.eval(symbol + " <- " + symbol + "[-" + (index + 1) + "];"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$

				length--;

			}

			return false;

		}

		return true;

	}

	 * @see org.txm.stat.data.Vector#setString(int, java.lang.String)

	 */

	@Override

			if (index < this.length) {

				rw.eval(symbol + "[" + (index + 1) + "] <-\"" + value + "\";"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$

			}

		}

	}

	 * @see org.txm.stat.data.Vector#setDouble(int, double)

	 */

	@Override

			if (index < this.length) {

				rw.eval(symbol + "[" + (index + 1) + "] <-" + value + ";"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$

			}

		}

	}

	 * @see org.txm.stat.data.Vector#setInt(int, int)

	 */

	@Override

			if (index < this.length) {

				rw.eval(symbol + "[" + (index + 1) + "] <-" + value + ";"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$

			}

		}

	}

	 * @see org.txm.stat.data.Vector#sort(java.lang.Boolean)

	 */

	@Override

	public void sort(Boolean reverse) {

		try {

			REXP r = rw

					.eval(symbol

							+ "<- " + symbol + "[order(" + symbol + ", decreasing = " + reverse.toString().toUpperCase() + ")];"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$

		}

	}

	 * @see org.txm.stat.data.Vector#setOrder(java.util.List, java.lang.Boolean)

	 */

	@Override

		if (reverse) {

			for (int i = neworder.size() - 1; i >= 0; i--)

				order += "" + (neworder.get(i) + 1) + ", "; //$NON-NLS-1$ //$NON-NLS-2$

			for (Integer i : neworder)

				order += "" + (i + 1) + ", "; //$NON-NLS-1$ //$NON-NLS-2$

		}

		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$

		}

	}

	 * @see org.txm.stat.data.Vector#cut(int)

	 */

	@Override

		try {

			// cut nlines

		}

	}

}

 * @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;

		}

		return rez;

	}

	/**

	 * Instantiates a new matrix impl.

	 *

	public MatrixImpl(double[][] matrix) throws RWorkspaceException {

		super();

		rw.addMatrixToWorkspace(symbol, matrix);

	}

	/**

	public MatrixImpl(double[][] matrix, int ncol, int nrow) throws RWorkspaceException {

		super();

		rw.addMatrixToWorkspace(symbol, matrix, ncol, nrow);

	}

	/**

	 * Instantiates a new matrix impl.

	 *

	public MatrixImpl(DoubleMatrix2D matrix) throws RWorkspaceException {

		super();

		rw.addMatrixToWorkspace(symbol, matrix);

	}

	/**

	 * Create a new matrix given a {@link DoubleMatrix2D}, with row and col

	 * names.

	public MatrixImpl(DoubleMatrix2D matrix, String[] rowNames,

			String[] columnNames) throws RWorkspaceException {

		this(matrix);

		if (rowNames == null) {

			throw new IllegalArgumentException(StatsEngineCoreMessages.rowNamesOfAContingencyTableCannotBeNull);

		}

		rw.assignRowNamesToMatrix(symbol, new VectorImpl(rowNames).getSymbol());

		if (columnNames == null) {

			throw new IllegalArgumentException(StatsEngineCoreMessages.columnNamesOfAContingencyTableCannotBeNull);

		}

		rw.assignColNamesToMatrix(symbol, new VectorImpl(columnNames).getSymbol());

	}

	/**

	 * Instantiates a new matrix impl.

	 *

	public MatrixImpl(int[][] matrix, int ncol, int nrow) throws RWorkspaceException {

		super();

		rw.addMatrixToWorkspace(symbol, matrix, ncol, nrow);

	}

	/**

	public MatrixImpl(int[][] matrix) throws RWorkspaceException {

		super();

		rw.addMatrixToWorkspace(symbol, matrix);

	}

	public void exchangeColumns(int c1, int c2) {

		try {

			RWorkspace rw = RWorkspace.getRWorkspaceInstance();

			// TODO Auto-generated catch block

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

		}

	}

	/**

	 * Instantiates a new matrix impl.

	 *

	 * @throws RWorkspaceException the r workspace exception

	 */

	public MatrixImpl(int[][] matrix, String[] lineNames, String[] partNames) throws RWorkspaceException {

		if (lineNames == null) {

			throw new IllegalArgumentException(StatsEngineCoreMessages.rowNamesOfAContingencyTableCannotBeNull);

		}

			throw new IllegalArgumentException(StatsEngineCoreMessages.columnNamesOfAContingencyTableCannotBeNull);

		}

		rw.assignRowNamesToMatrix(symbol, new VectorImpl(lineNames).getSymbol());

		rw.assignColNamesToMatrix(symbol, new VectorImpl(partNames).getSymbol());

	}

	/**

	 * Create a matrix wrapping data already existing into R with the given

	 * symbol.

	protected MatrixImpl(String symbol) throws RWorkspaceException {

		super(symbol);

	}

	/**

	 * Removes the row with a negative index.

	 * @param row the row [1..N]

	 */

	public void _removeRow(int row) {

		try {

			REXP r = rw.eval(symbol

					+ " <- " + symbol + "[ " + row + ",];"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$

			// TODO Auto-generated catch block

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

		}

		// de la liste rows

	}

	/**

	 * Export data.

	 *

	public void exportData(File f, String colseparator, String txtseparator) {

		try {

			org.txm.statsengine.r.core.RWorkspace

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

			RWorkspace.printLastSafeEvalExpr();

		}

	}

	/**

	 * Filter.

	 *

	 * @param freqs the freqs

	 * @param nlines the nlines

	 * @param fmin the fmin

	 */

		RWorkspace rw = RWorkspace.getRWorkspaceInstance();

		// first sort rows

		int[] freqs = rw.eval("freqs").asIntegers(); //$NON-NLS-1$

		rw.eval("order <- sort(freqs, decreasing= TRUE, index.return= TRUE)"); //$NON-NLS-1$

		int[] order = rw.eval("order$ix").asIntegers();  //$NON-NLS-1$

		rw.eval(symbol + "<- " + symbol + "[order$ix, ];"); //$NON-NLS-1$ //$NON-NLS-2$

		// find first fmin line

		int ifmin = 999999999;

				ifmin = i; // the ith line

				break;

			}

		}

	}

	/**

	 * Cut.

	 *

	 * @param nRowToCut the nlines

	 */

			return;

		try {

			// cut nlines

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

		}

	}

	public void sortByFreqs(boolean reverse) throws RWorkspaceException, REXPMismatchException {

		String DECREASING = "FALSE"; //$NON-NLS-1$

		if (reverse) DECREASING = "TRUE"; //$NON-NLS-1$

		rw.eval(symbol + "<- " + symbol + "[order$ix, ];"); //$NON-NLS-1$ //$NON-NLS-2$

	}

	/**

	 * Fusion rows.

	 *

	 * @param row the row

	 */

	public boolean mergeRows(int[] rows) throws RWorkspaceException {

		if (rows.length < 2) return false;

		Arrays.sort(rows);

		int rowToChange = rows[0] + 1;

		rw.addVectorToWorkspace("rowsToMerge", ArrayIndex.zeroToOneBasedIndex(rows, rows.length)); //$NON-NLS-1$

		this.removeRows(Arrays.copyOfRange(rows, 1, rows.length)); // remove rows minus the first row to remove

		return true;

	}

	/**

	 * Fusion rows.

	 *

	 * @param row the row

	 */

	public boolean mergeCols(int[] cols) throws RWorkspaceException {

		if (cols.length < 2) return false;

		Arrays.sort(cols);

		int colToChange = cols[0] + 1;

		rw.addVectorToWorkspace("colsToMerge", ArrayIndex.zeroToOneBasedIndex(cols, cols.length)); //$NON-NLS-1$

		this.removeCols(Arrays.copyOfRange(cols, 1, cols.length)); // remove rows minus the first row to remove

		return true;

	}

	 * @see org.txm.stat.data.Matrix#get(int, int)

	 */

	@Override

	public double get(int row, int col) throws RException, RWorkspaceException {

		int ncol = this.getNColumns();

		if (row < 0 || row >= nrow) {

		}

		if (col < 0 || col >= ncol) {

		}

		REXP r = rw.eval(symbol

				+ "[" + ArrayIndex.zeroToOneBasedIndex(row) + ", " + ArrayIndex.zeroToOneBasedIndex(col) + " ];"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$

		if (r.isInteger()) {

			try {

				return r.asInteger();

				throw new RWorkspaceException(e);

			}

			try {

				return r.asDouble();

				throw new RWorkspaceException(e);

			}

			try {

				return r.asDouble();

				throw new RWorkspaceException(e);

			}

			throw new IllegalArgumentException(StatsEngineCoreMessages.rObjectEvaluatedToNull);

			// System.out.println("row: " + row);

			// System.out.println("col: " + col);

			// System.out.println("nrow: " + nrow);

			throw new IllegalArgumentException(StatsEngineCoreMessages.bind(StatsEngineCoreMessages.unknownTypeColon, r.getAttribute(StatsEngineCoreMessages.mode)));

		}

	}

	 * @see org.txm.stat.data.Matrix#getCol(int)

	 */

	@Override

	public Vector getCol(int index) throws RException, RWorkspaceException {

		int ncol = this.getNColumns();

		if (index < 0 || index >= ncol) {

		}

		String colName = createSymbole(Vector.class);

		rw.voidEval(colName + "<- " + symbol + "[ ," + (index + 1) + "];"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$

		return new VectorImpl(colName);

	}

	 * @see org.txm.stat.data.Matrix#getCol(java.lang.String)

	 */

	@Override

		rw.voidEval(colName + "<- " + symbol + "[ ,\"" + column + "\"];"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$

		return new VectorImpl(colName);

	}

	 * @see org.txm.stat.data.Matrix#getColNames()

	 */

	@Override

	public Vector getColNames() {

		try {

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

			return null;

		}

	}

	public int[][] getIntData() {

		try {

			REXP rexp = RWorkspace.getRWorkspaceInstance().eval(this.symbol);

			return asIntMatrix(rexp);

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

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

		}

		return null;

	}

	 * @see org.txm.stat.data.Matrix#getNColumns()

	 */

	@Override

	public int getNColumns() {

		try {

			return RWorkspace.getRWorkspaceInstance().eval("dim(" + symbol + ")[2]").asInteger(); //$NON-NLS-1$ //$NON-NLS-2$

			Log.severe(StatsEngineCoreMessages.bind("Matrix: failed to get nrow: {0}.", e));

		}

		return 0;

	}

	 * @see org.txm.stat.data.Matrix#getNRows()

	 */

	@Override

	public int getNRows() {

		try {

			return RWorkspace.getRWorkspaceInstance().eval("dim(" + symbol + ")[1]").asInteger(); //$NON-NLS-1$ //$NON-NLS-2$

			Log.severe(StatsEngineCoreMessages.bind(StatsEngineCoreMessages.matrixColonFailedToGetNrowColon, e));

		}

		return 0;

	}

	 * @see org.txm.stat.data.Matrix#getRow(int)

	 */

	@Override

	public Vector getRow(int index) throws RException, RWorkspaceException {

		int nrow = getNRows();

		if (index < 0 || index >= nrow) {

		}

		String rowName = createSymbole(Vector.class);

		rw.voidEval(rowName + "<- " + symbol + "[" + (index + 1) + ", ];"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$

		return new VectorImpl(rowName);

	}

	 * @see org.txm.stat.data.Matrix#getRow(java.lang.String)

	 */

	@Override

		rw.voidEval(rowName + "<- " + symbol + "[ \"" + row + "\" , ];"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$

		return new VectorImpl(rowName);

	}

	 * @see org.txm.stat.data.Matrix#getRowNames()

	 */

	@Override

	public Vector getRowNames() {

		try {

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

			return null;

		}

	}

	 * @see org.txm.stat.data.ContingencyTable#getRowMargin()

	 */

	public int[] getRowMargins() throws StatException {

		try {

			return rw.eval("rowSums(" + this.symbol + ");").asIntegers(); //$NON-NLS-1$ //$NON-NLS-2$

			throw new StatException(e);

	}

	 * @see org.txm.stat.data.ContingencyTable#getRowMargin()

	 */

	public int[] getColMargins() throws StatException {

		try {

			return rw.eval("colSums(" + this.symbol + ");").asIntegers(); //$NON-NLS-1$ //$NON-NLS-2$

			throw new StatException(e);

		}

	}

	/**

	 * Import data.

	 *

	 * @param f the f

	 */

	public boolean importData(File f, String encoding, String colseparator, String txtseparator) throws RWorkspaceException, REXPMismatchException {

		String path = f.getAbsolutePath();

		if (OSDetector.isFamilyWindows()) {

			path = path.replace("\\", "\\\\"); //$NON-NLS-1$ //$NON-NLS-2$

		}

		rw.voidEval("tmpheader <- tmpheader[2:length(tmpheader)];"); //$NON-NLS-1$

		rw.voidEval("tmpmat <- tmpmat[1:nrow(tmpmat),];"); //$NON-NLS-1$

		rw.voidEval("colnames(tmpmat) <- tmpheader"); //$NON-NLS-1$

		return true;

	}

	public void print() {

		try {

			String[] rowNames = this.getRowNames().asStringsArray();

			String[] colNames = this.getColNames().asStringsArray();

			int[][] data = getIntData();

			// col names

			for (String col : colNames)

				System.out.print(rowNames[i]);

				}

				System.out.println();

			}

			// TODO Auto-generated catch block

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

		}

	}

	/**

	 * Removes the col.

	 *

	 * @param checkEmptyLines the check empty lines

	 */

	public void removeCol(int col) {

		try {

			REXP r = rw.eval(symbol + " <- " + symbol + "[,-" + ArrayIndex.zeroToOneBasedIndex(col) + "];"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$

			// TODO Auto-generated catch block

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

		}

	}

	/**

	 * Removes the col and delete empty rows.

	 *

	 * @param checkEmptyLines the check empty lines

	 */

	public void removeCol(int col, boolean checkEmptyLines) {

		try {

			removeCol(col);

			if (checkEmptyLines) {

				removeEmptyRows();

			}

			// TODO Auto-generated catch block

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

		}

	}

	/**

	 * Removes the cols.

	 *

			removeCol(index, false);

		}

	}

	public void removeCols(int[] cols, boolean removeEmptyLines) throws RWorkspaceException {

		removeCols(cols);

		if (removeEmptyLines) removeEmptyRows();

	}

	/**

	 * Removes the cols.

	 *

			removeCol(index, false);

		}

	}

	public void removeCols(List<Integer> cols, boolean removeEmptyLines) throws RWorkspaceException {

		removeCols(cols);

		if (removeEmptyLines) {

			removeEmptyRows();

		}

	}

	private void removeEmptyCols() throws RWorkspaceException {

		try {

			// get the empty line index

				if (colsums[i] == 0)

					removecols.add(i);

			}

			if (removecols.size() > 0) {

				removeCols(removecols);

			}

			// TODO Auto-generated catch block

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

		}

	}

	/**

	 * Removes the empty lines.

	 *

	 * @throws RWorkspaceException the r workspace exception

	 */

		try {

			// get the empty line index

				if (rowsums[i] == 0)

					rowIndexes.add(i);

			}

			if (rowIndexes.size() > 0) {

				removeRows(rowIndexes);

			}

			// TODO Auto-generated catch block

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

		}

	}

	/**

	 * Removes the row.

	 *

		try {

			REXP r = rw.eval(symbol

					+ " <- " + symbol + "[ -" + ArrayIndex.zeroToOneBasedIndex(row) + ",];"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$

			// TODO Auto-generated catch block

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

		}

		// de la liste rows

	}

	/**

	 * Removes the rows.

	 *

			}

		}

	}

	/**

	 * Removes the rows indexes.

	 *

		int nrow = this.getNRows();

		try {

			Arrays.sort(rows);

			}

			int idx = rows[0];

			if (rows.length > 1) {

				System.arraycopy(rows, 1, subrows, 0, rows.length - 1);

				rw.addVectorToWorkspace("linesToDelete", subrows); //$NON-NLS-1$

				REXP r = rw.eval(symbol + " <- " + symbol + "[ linesToDelete,];"); //$NON-NLS-1$ //$NON-NLS-2$

				nrow -= rows.length - 1;

			}

			if (nrow == 2) {

				// 2 lines left

				int last = 1;

				String[] rowNames;

				try {

					rowNames = getRowNames().asStringsArray();

					System.out.println(StatsEngineCoreMessages.failedToGetRowNames);

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

					return;

				}

				nrow = 1;

				_removeRow(idx);

			}

			// TODO Auto-generated catch block

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

		}

	}

	public void removeRows(int[] rows, boolean removeEmptyCols) throws RWorkspaceException {

		removeRows(rows);

		if (removeEmptyCols) removeEmptyCols();

	}

	/**

	 * Removes the rows.

	 *

	 * @param rows the row

	 */

	public void removeRows(List<Integer> rows) {

		Collections.sort(rows);

		int index = 0;

		int nrow = this.getNRows();

		int diff = Math.abs(rows.size() - nrow);

				index = rows.get(i);

				removeRow(index);

			}

			for (int i = rows.size() - 2; i >= 0; i--) {

				index = rows.get(i);

				removeRow(index);

			String[] rowNames;

			try {

				rowNames = getRowNames().asStringsArray();

				System.out.println(StatsEngineCoreMessages.failedToGetRowNames);

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

				return;

			}

			String lastRowName = rowNames[last];

			System.out.println(StatsEngineCoreMessages.cannotDeleteAllLines);

		}

	}

	public void removeRows(List<Integer> rows, boolean removeEmptyCols) throws RWorkspaceException {

		this.removeRows(rows);

		if (removeEmptyCols) {

			removeEmptyCols();

		}

	}

	/**

	 * Sets the.

	 *

		int nrow = this.getNRows();

		int ncol = this.getNColumns();

		if (row < 0 || row >= nrow) {

		}

		if (col < 0 || col >= ncol) {

		}

		// appel à R

		try {

			REXP r = rw.eval(symbol

					+ "[" + ArrayIndex.zeroToOneBasedIndex(row) + ", " + ArrayIndex.zeroToOneBasedIndex(col) + " ] <- " + value + ";"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$

			// TODO Auto-generated catch block

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

		}

	}

	/**

	 * Sets the order.

	 *

	 */

	public void setOrder(List<Integer> neworder, Boolean reverse) {

		int nrow = this.getNRows();

			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$

			for (Integer i : neworder)

				order += "" + (i + 1) + ", "; //$NON-NLS-1$ //$NON-NLS-2$

		}

		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$