Revision 216

tmp/org.txm.statsengine.r.core/.classpath (revision 216)
1
<?xml version="1.0" encoding="UTF-8"?>
2
<classpath>
3
	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.6"/>
4
	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
5
	<classpathentry kind="src" path="src"/>
6
	<classpathentry exported="true" kind="lib" path="REngine.jar"/>
7
	<classpathentry exported="true" kind="lib" path="RserveEngine.jar"/>
8
	<classpathentry exported="true" kind="lib" path="colt-1.2.0.jar"/>
9
	<classpathentry kind="output" path="bin"/>
10
</classpath>
0 11

  
tmp/org.txm.statsengine.r.core/META-INF/MANIFEST.MF (revision 216)
1
Manifest-Version: 1.0
2
Bundle-ManifestVersion: 2
3
Bundle-Name: R Core
4
Bundle-SymbolicName: org.txm.statsengine.r.core
5
Bundle-Version: 1.0.0.qualifier
6
Require-Bundle: org.eclipse.ui,
7
 org.eclipse.core.runtime,
8
 org.txm.utils;bundle-version="1.0.0"
9
Bundle-RequiredExecutionEnvironment: JavaSE-1.6
10
Bundle-ActivationPolicy: lazy
11
Export-Package: cern.clhep,
12
 cern.colt,
13
 cern.colt.bitvector,
14
 cern.colt.buffer,
15
 cern.colt.function,
16
 cern.colt.list,
17
 cern.colt.list.adapter,
18
 cern.colt.map,
19
 cern.colt.matrix,
20
 cern.colt.matrix.bench,
21
 cern.colt.matrix.doublealgo,
22
 cern.colt.matrix.impl,
23
 cern.colt.matrix.linalg,
24
 cern.colt.matrix.objectalgo,
25
 cern.jet.math,
26
 cern.jet.random,
27
 cern.jet.random.engine,
28
 cern.jet.random.sampling,
29
 cern.jet.stat,
30
 cern.jet.stat.quantile,
31
 corejava,
32
 hep.aida,
33
 hep.aida.bin,
34
 hep.aida.ref,
35
 org.rosuda.REngine,
36
 org.rosuda.REngine.Rserve,
37
 org.rosuda.REngine.Rserve.protocol,
38
 org.txm.stat,
39
 org.txm.stat.data,
40
 org.txm.stat.engine.r,
41
 org.txm.stat.engine.r.data,
42
 org.txm.stat.engine.r.rcolt,
43
 org.txm.stat.utils
44
Bundle-ClassPath: REngine.jar,
45
 RserveEngine.jar,
46
 .,
47
 colt-1.2.0.jar
0 48

  
tmp/org.txm.statsengine.r.core/.project (revision 216)
1
<?xml version="1.0" encoding="UTF-8"?>
2
<projectDescription>
3
	<name>org.txm.statsengine.r.core</name>
4
	<comment></comment>
5
	<projects>
6
	</projects>
7
	<buildSpec>
8
		<buildCommand>
9
			<name>org.eclipse.jdt.core.javabuilder</name>
10
			<arguments>
11
			</arguments>
12
		</buildCommand>
13
		<buildCommand>
14
			<name>org.eclipse.pde.ManifestBuilder</name>
15
			<arguments>
16
			</arguments>
17
		</buildCommand>
18
		<buildCommand>
19
			<name>org.eclipse.pde.SchemaBuilder</name>
20
			<arguments>
21
			</arguments>
22
		</buildCommand>
23
	</buildSpec>
24
	<natures>
25
		<nature>org.eclipse.pde.PluginNature</nature>
26
		<nature>org.eclipse.jdt.core.javanature</nature>
27
	</natures>
28
</projectDescription>
0 29

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

  
tmp/org.txm.statsengine.r.core/src/org/txm/stat/utils/PrintArray.java (revision 216)
1
// Copyright © 2010-2013 ENS de Lyon.
2
// Copyright © 2007-2010 ENS de Lyon, CNRS, INRP, University of
3
// Lyon 2, University of Franche-Comté, University of Nice
4
// Sophia Antipolis, University of Paris 3.
5
// 
6
// The TXM platform is free software: you can redistribute it
7
// and/or modify it under the terms of the GNU General Public
8
// License as published by the Free Software Foundation,
9
// either version 2 of the License, or (at your option) any
10
// later version.
11
// 
12
// The TXM platform is distributed in the hope that it will be
13
// useful, but WITHOUT ANY WARRANTY; without even the implied
14
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
15
// PURPOSE. See the GNU General Public License for more
16
// details.
17
// 
18
// You should have received a copy of the GNU General
19
// Public License along with the TXM platform. If not, see
20
// http://www.gnu.org/licenses.
21
// 
22
// 
23
// 
24
// $LastChangedDate: 2013-05-06 17:38:43 +0200 (lun., 06 mai 2013) $
25
// $LastChangedRevision: 2386 $
26
// $LastChangedBy: mdecorde $ 
27
//
28
package org.txm.stat.utils;
29

  
30
import java.util.Arrays;
31

  
32
// TODO: Auto-generated Javadoc
33
/**
34
 * Various utilities method for printing arrays.
35
 * 
36
 * @author sloiseau
37
 * 
38
 */
39
public final class PrintArray {
40

  
41
	/**
42
	 * Double array.
43
	 *
44
	 * @param matrix the matrix
45
	 * @return the string
46
	 */
47
	public final static String doubleArray(double[][] matrix) {
48
		// DoubleMatrix2D m = new SparseDoubleMatrix2D(matrix);
49
		// return m.toString();
50
		StringBuffer sb = new StringBuffer();
51
		for (int i = 0; i < matrix.length; i++) {
52
			sb.append(Arrays.toString(matrix[i]));
53
		}
54
		return sb.toString();
55
	}
56

  
57
	/**
58
	 * Int array.
59
	 *
60
	 * @param matrix the matrix
61
	 * @return the string
62
	 */
63
	public final static String intArray(int[][] matrix) {
64
		double[][] doublematrix = new double[matrix.length][matrix[0].length];
65
		for (int i = 0; i < matrix.length; i++) {
66
			for (int j = 0; j < doublematrix[i].length; j++) {
67
				doublematrix[i][j] = matrix[i][j];
68
			}
69
		}
70
		return doubleArray(doublematrix);
71
	}
72

  
73
}
0 74

  
tmp/org.txm.statsengine.r.core/src/org/txm/stat/utils/CheckArray.java (revision 216)
1
// Copyright © 2010-2013 ENS de Lyon.
2
// Copyright © 2007-2010 ENS de Lyon, CNRS, INRP, University of
3
// Lyon 2, University of Franche-Comté, University of Nice
4
// Sophia Antipolis, University of Paris 3.
5
// 
6
// The TXM platform is free software: you can redistribute it
7
// and/or modify it under the terms of the GNU General Public
8
// License as published by the Free Software Foundation,
9
// either version 2 of the License, or (at your option) any
10
// later version.
11
// 
12
// The TXM platform is distributed in the hope that it will be
13
// useful, but WITHOUT ANY WARRANTY; without even the implied
14
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
15
// PURPOSE. See the GNU General Public License for more
16
// details.
17
// 
18
// You should have received a copy of the GNU General
19
// Public License along with the TXM platform. If not, see
20
// http://www.gnu.org/licenses.
21
// 
22
// 
23
// 
24
// $LastChangedDate: 2013-05-06 17:38:43 +0200 (lun., 06 mai 2013) $
25
// $LastChangedRevision: 2386 $
26
// $LastChangedBy: mdecorde $ 
27
//
28
package org.txm.stat.utils;
29

  
30
// TODO: Auto-generated Javadoc
31
/**
32
 * Various utility methods for checking consistency of matrix as java array of
33
 * arrays.
34
 * 
35
 * @author sloiseau
36
 * 
37
 */
38
public final class CheckArray {
39

  
40
	/**
41
	 * Check if an array is not null (or 0-length), does not include null inner
42
	 * array (or 0 length), and if all inner arrays have the same length.
43
	 *
44
	 * @param array the array
45
	 * @return <code>true</code> if the condition are satisfied,
46
	 * <code>false</code> otherwise.
47
	 */
48
	public final static boolean checkMatrixRepresentation(int[][] array) {
49
		// same code as in #checkMatrixRepresentation(double[][])
50
		if (array == null)
51
			return false;
52
		int length = array.length;
53
		if (length < 1)
54
			return false;
55
		if (array[0] == null)
56
			return false;
57
		int firstElementLength = array[0].length;
58
		if (firstElementLength == 0)
59
			return false;
60
		for (int i = 0; i < array.length; i++) {
61
			if (array[i] == null)
62
				return false;
63
			if (array[i].length != firstElementLength)
64
				return false;
65
		}
66
		return true;
67
	}
68

  
69
	/**
70
	 * Check if an array is not null (or 0-length), does not include null inner
71
	 * array (or 0 length), and if all inner arrays have the same length.
72
	 *
73
	 * @param array the array
74
	 * @return <code>true</code> if the condition are satisfied,
75
	 * <code>false</code> otherwise.
76
	 */
77
	public final static boolean checkMatrixRepresentation(double[][] array) {
78
		// same code as in #checkMatrixRepresentation(int[][])
79
		if (array == null)
80
			return false;
81
		int length = array.length;
82
		if (length < 1)
83
			return false;
84
		if (array[0] == null)
85
			return false;
86
		int firstElementLength = array[0].length;
87
		if (firstElementLength == 0)
88
			return false;
89
		for (int i = 0; i < array.length; i++) {
90
			if (array[i] == null)
91
				return false;
92
			if (array[i].length != firstElementLength)
93
				return false;
94
		}
95
		return true;
96
	}
97

  
98
}
0 99

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

  
tmp/org.txm.statsengine.r.core/src/org/txm/stat/utils/ArrayIndex.java (revision 216)
1
// Copyright © 2010-2013 ENS de Lyon.
2
// Copyright © 2007-2010 ENS de Lyon, CNRS, INRP, University of
3
// Lyon 2, University of Franche-Comté, University of Nice
4
// Sophia Antipolis, University of Paris 3.
5
// 
6
// The TXM platform is free software: you can redistribute it
7
// and/or modify it under the terms of the GNU General Public
8
// License as published by the Free Software Foundation,
9
// either version 2 of the License, or (at your option) any
10
// later version.
11
// 
12
// The TXM platform is distributed in the hope that it will be
13
// useful, but WITHOUT ANY WARRANTY; without even the implied
14
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
15
// PURPOSE. See the GNU General Public License for more
16
// details.
17
// 
18
// You should have received a copy of the GNU General
19
// Public License along with the TXM platform. If not, see
20
// http://www.gnu.org/licenses.
21
// 
22
// 
23
// 
24
// $LastChangedDate: 2013-05-06 17:38:43 +0200 (lun., 06 mai 2013) $
25
// $LastChangedRevision: 2386 $
26
// $LastChangedBy: mdecorde $ 
27
//
28
package org.txm.stat.utils;
29

  
30
import java.util.HashMap;
31
import java.util.Map;
32

  
33
import org.txm.Messages;
34

  
35
// TODO: Auto-generated Javadoc
36
/**
37
 * Utilities for managing index of vector.
38
 * 
39
 * @author sloiseau
40
 * 
41
 */
42
public final class ArrayIndex {
43

  
44
	/**
45
	 * Convert an array of zero-based index to an array of one-base index, that
46
	 * is, add <code>1</code> to all elements.
47
	 * 
48
	 * This method check every index (see exception thrown).
49
	 *
50
	 * @param zero_based the zero based index.
51
	 * @param length the number of elements that can be indexed.
52
	 * @return the one base index.
53
	 */
54
	public static final int[] zeroToOneBasedIndex(int[] zero_based, int length) {
55
		if (zero_based == null || zero_based.length == 0) {
56
			throw new IllegalArgumentException(Messages.ArrayIndex_0);
57
		}
58
		int[] one_based = new int[zero_based.length];
59
		for (int i = 0; i < zero_based.length; i++) {
60
			if (zero_based[i] < 0 || zero_based[i] >= length) {
61
				throw new IllegalArgumentException(Messages.ArrayIndex_1);
62
			}
63
			one_based[i] = zero_based[i] + 1;
64
		}
65
		return one_based;
66
	}
67

  
68
	/**
69
	 * Zero to one based index.
70
	 *
71
	 * @param zero_based the zero_based
72
	 * @return the int
73
	 */
74
	public static final int zeroToOneBasedIndex(int zero_based) {
75
		return zero_based + 1;
76
	}
77

  
78
	/**
79
	 * Get the index (0-based) of the element of subvector into vector. Return
80
	 * <code>-1</code> when no element in vector correspond to the element in
81
	 * subvector.
82
	 *
83
	 * @param vector the vector
84
	 * @param subvector the subvector
85
	 * @return the index
86
	 */
87
	public static int[] getIndex(String[] vector, String[] subvector) {
88
		int[] result = new int[subvector.length];
89
		Map<String, Integer> index = new HashMap<String, Integer>();
90
		for (int i = 0; i < subvector.length; i++) {
91
			index.put(subvector[i], i);
92
			result[i] = -1;
93
		}
94
		for (int i = 0; i < vector.length; i++) {
95
			if (index.containsKey(vector[i])) {
96
				result[index.get(vector[i])] = i;
97
			}
98
		}
99
		return result;
100
	}
101
}
0 102

  
tmp/org.txm.statsengine.r.core/src/org/txm/stat/utils/ArrayEquals.java (revision 216)
1
// Copyright © 2010-2013 ENS de Lyon.
2
// Copyright © 2007-2010 ENS de Lyon, CNRS, INRP, University of
3
// Lyon 2, University of Franche-Comté, University of Nice
4
// Sophia Antipolis, University of Paris 3.
5
// 
6
// The TXM platform is free software: you can redistribute it
7
// and/or modify it under the terms of the GNU General Public
8
// License as published by the Free Software Foundation,
9
// either version 2 of the License, or (at your option) any
10
// later version.
11
// 
12
// The TXM platform is distributed in the hope that it will be
13
// useful, but WITHOUT ANY WARRANTY; without even the implied
14
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
15
// PURPOSE. See the GNU General Public License for more
16
// details.
17
// 
18
// You should have received a copy of the GNU General
19
// Public License along with the TXM platform. If not, see
20
// http://www.gnu.org/licenses.
21
// 
22
// 
23
// 
24
// $LastChangedDate: 2013-05-06 17:38:43 +0200 (lun., 06 mai 2013) $
25
// $LastChangedRevision: 2386 $
26
// $LastChangedBy: mdecorde $ 
27
//
28
package org.txm.stat.utils;
29

  
30
import java.util.Arrays;
31

  
32
// TODO: Auto-generated Javadoc
33
/**
34
 * Utility methods for testing for equality of arrays.
35
 * 
36
 * @author sloiseau
37
 * 
38
 */
39
public final class ArrayEquals {
40

  
41
	/**
42
	 * Test for equality of both array. For consistency with Arrays.equals
43
	 * contract, the two arrays are equals if both are <code>null</code>.
44
	 *
45
	 * @param array1 the array1
46
	 * @param array2 the array2
47
	 * @return <code>true</code> if (1) both arrays are <code>null</code> or if
48
	 * (2) both arrays have the same length and contain pair of arrays
49
	 * equals to each other according to
50
	 * {@link Arrays#equals(int[], int[])}.
51
	 */
52
	public static final boolean deepEquals(int[][] array1, int[][] array2) {
53
		if (array1 == null && array2 == null)
54
			return true;
55
		if (array1 == null || array2 == null)
56
			return false;
57
		if (array1.length != array2.length)
58
			return false;
59
		for (int i = 0; i < array2.length; i++) {
60
			if (!Arrays.equals(array1[i], array2[i]))
61
				return false;
62
		}
63
		return true;
64
	}
65

  
66
}
0 67

  
tmp/org.txm.statsengine.r.core/src/org/txm/stat/utils/VectorizeArray.java (revision 216)
1
// Copyright © 2010-2013 ENS de Lyon.
2
// Copyright © 2007-2010 ENS de Lyon, CNRS, INRP, University of
3
// Lyon 2, University of Franche-Comté, University of Nice
4
// Sophia Antipolis, University of Paris 3.
5
// 
6
// The TXM platform is free software: you can redistribute it
7
// and/or modify it under the terms of the GNU General Public
8
// License as published by the Free Software Foundation,
9
// either version 2 of the License, or (at your option) any
10
// later version.
11
// 
12
// The TXM platform is distributed in the hope that it will be
13
// useful, but WITHOUT ANY WARRANTY; without even the implied
14
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
15
// PURPOSE. See the GNU General Public License for more
16
// details.
17
// 
18
// You should have received a copy of the GNU General
19
// Public License along with the TXM platform. If not, see
20
// http://www.gnu.org/licenses.
21
// 
22
// 
23
// 
24
// $LastChangedDate: 2013-05-06 17:38:43 +0200 (lun., 06 mai 2013) $
25
// $LastChangedRevision: 2386 $
26
// $LastChangedBy: mdecorde $ 
27
//
28
package org.txm.stat.utils;
29

  
30
import org.txm.Messages;
31

  
32
// TODO: Auto-generated Javadoc
33
/**
34
 * Static methods for dealing vectorization of Arrays.
35
 * 
36
 * @author sloiseau
37
 * 
38
 */
39
public final class VectorizeArray {
40

  
41
	/**
42
	 * Convert a <code>double * double</code> array in a <code>double</code>
43
	 * array. Each inner array of the argument is added one after the other into
44
	 * the result array.
45
	 * 
46
	 * <pre>
47
	 * [
48
	 * [1, 2, 3],
49
	 * [4, 5, 6]
50
	 * ]
51
	 * </pre>
52
	 * 
53
	 * result in :
54
	 * 
55
	 * <pre>
56
	 * [1, 2, 3, 4, 5, 6]
57
	 * </pre>
58
	 * 
59
	 * that is, "row first".
60
	 *
61
	 * @param matrix a <code>double * double</code> array where all inner arrays
62
	 * have the same length.
63
	 * @return an array of <code>double</code> produced by vectorization of the
64
	 * matrix.
65
	 */
66
	public final static double[] vectorizeByInner(double[][] matrix) {
67
		if (matrix == null || matrix.length == 0) {
68
			throw new IllegalArgumentException(Messages.VectorizeArray_0);
69
		}
70
		int inner_length = matrix[0].length;
71
		if (inner_length < 1) {
72
			throw new IllegalArgumentException(Messages.VectorizeArray_1);
73
		}
74
		double[] vector = new double[matrix.length * matrix[0].length];
75
		for (int i = 0; i < matrix.length; i++) {
76
			if (matrix[i] == null) {
77
				throw new IllegalArgumentException(Messages.VectorizeArray_10);
78
			}
79
			if (inner_length != matrix[i].length) {
80
				throw new IllegalArgumentException(Messages.VectorizeArray_3);
81
			}
82
			System.arraycopy(matrix[i], 0, vector, i * inner_length,
83
					inner_length);
84
		}
85
		return vector;
86
	}
87

  
88
	/**
89
	 * Convert a <code>int * int</code> array in a <code>double</code> array.
90
	 * Each inner array of the argument is added one after the other into the
91
	 * result array.
92
	 * 
93
	 * <pre>
94
	 * [
95
	 * [1, 2, 3],
96
	 * [4, 5, 6]
97
	 * ]
98
	 * </pre>
99
	 * 
100
	 * result in :
101
	 * 
102
	 * <pre>
103
	 * [1, 2, 3, 4, 5, 6]
104
	 * </pre>
105
	 * 
106
	 * that is, "row first".
107
	 *
108
	 * @param matrix a <code>int * int</code> array where all inner arrays have the
109
	 * same length.
110
	 * @return an array of <code>int</code> produced by vectorization of the
111
	 * matrix.
112
	 */
113
	public final static int[] vectorizeByInner(int[][] matrix) {
114
		if (matrix == null || matrix.length == 0) {
115
			throw new IllegalArgumentException(Messages.VectorizeArray_4);
116
		}
117
		int inner_length = matrix[0].length;
118
		if (inner_length < 1) {
119
			throw new IllegalArgumentException(Messages.VectorizeArray_5);
120
		}
121
		int[] vector = new int[matrix.length * matrix[0].length];
122
		for (int i = 0; i < matrix.length; i++) {
123
			if (matrix[i] == null) {
124
				throw new IllegalArgumentException(Messages.VectorizeArray_10);
125
			}
126
			if (inner_length != matrix[i].length) {
127
				throw new IllegalArgumentException(Messages.VectorizeArray_7);
128
			}
129
			System.arraycopy(matrix[i], 0, vector, i * inner_length,
130
					inner_length);
131
		}
132
		return vector;
133
	}
134

  
135
	/**
136
	 * Convert a <code>double * double</code> array in a <code>double</code>
137
	 * array. The elements of the input array are assembled in the output array
138
	 * so that elements of same index in the outer array are consecutive. So :
139
	 * 
140
	 * <pre>
141
	 * [
142
	 * [1, 2, 3],
143
	 * [4, 5, 6]
144
	 * ]
145
	 * </pre>
146
	 * 
147
	 * result in :
148
	 * 
149
	 * <pre>
150
	 * [1, 4, 2, 5, 3, 6]
151
	 * </pre>
152
	 * 
153
	 * that is, "column first".
154
	 *
155
	 * @param matrix a <code>double * double</code> array where all inner arrays
156
	 * have the same length.
157
	 * @return an array of <code>double</code> produced by vectorization of the
158
	 * matrix.
159
	 */
160
	public final static double[] vectorizeByOuter(double[][] matrix) {
161
		if (matrix == null || matrix.length == 0) {
162
			throw new IllegalArgumentException(Messages.VectorizeArray_8);
163
		}
164
		int inner_length = matrix[0].length;
165
		int outer_length = matrix.length;
166
		if (inner_length < 1) {
167
			throw new IllegalArgumentException(Messages.VectorizeArray_9);
168
		}
169
		double[] vector = new double[matrix.length * matrix[0].length];
170
		for (int i = 0; i < matrix.length; i++) {
171
			if (matrix[i] == null) {
172
				throw new IllegalArgumentException(Messages.VectorizeArray_10);
173
			}
174
			if (inner_length != matrix[i].length) {
175
				throw new IllegalArgumentException(Messages.VectorizeArray_11);
176
			}
177
			for (int j = 0; j < matrix[i].length; j++) {
178
				vector[(j * outer_length) + i] = matrix[i][j];
179
			}
180

  
181
		}
182
		return vector;
183
	}
184

  
185
}
0 186

  
tmp/org.txm.statsengine.r.core/src/org/txm/stat/ConnectToRserve.java (revision 216)
1
// Copyright © 2010-2013 ENS de Lyon.
2
// Copyright © 2007-2010 ENS de Lyon, CNRS, INRP, University of
3
// Lyon 2, University of Franche-Comté, University of Nice
4
// Sophia Antipolis, University of Paris 3.
5
// 
6
// The TXM platform is free software: you can redistribute it
7
// and/or modify it under the terms of the GNU General Public
8
// License as published by the Free Software Foundation,
9
// either version 2 of the License, or (at your option) any
10
// later version.
11
// 
12
// The TXM platform is distributed in the hope that it will be
13
// useful, but WITHOUT ANY WARRANTY; without even the implied
14
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
15
// PURPOSE. See the GNU General Public License for more
16
// details.
17
// 
18
// You should have received a copy of the GNU General
19
// Public License along with the TXM platform. If not, see
20
// http://www.gnu.org/licenses.
21
// 
22
// 
23
// 
24
// $LastChangedDate:$
25
// $LastChangedRevision:$
26
// $LastChangedBy:$ 
27
//
28
package org.txm.stat;
29
import org.rosuda.REngine.REXP;
30
import org.rosuda.REngine.RList;
31
import org.rosuda.REngine.Rserve.RConnection;
32

  
33
// TODO: Auto-generated Javadoc
34
/**
35
 * The Class ConnectToRserve.
36
 */
37
class ConnectToRserve {
38
	
39
	/**
40
	 * The main method.
41
	 *
42
	 * @param args the arguments
43
	 */
44
	public static void main(String args[]) {
45
		try {
46
			RConnection c = new RConnection();
47
			String userhome = System.getProperty("user.home"); //$NON-NLS-1$
48
			RList ret = c.eval("source('"+userhome+"/Bureau/R/Rdata')").asList(); //$NON-NLS-1$ //$NON-NLS-2$
49
			
50
			System.out.println("source ret : "+ret.get(1)); //$NON-NLS-1$
51
			System.out.println(ret);
52
			
53
			REXP ret2 = c.eval("print(lexicaltable)"); //$NON-NLS-1$
54
			System.out.println("lexicaltable :"+ret2); //$NON-NLS-1$
55
		}
56
		catch(Exception e) {
57
			org.txm.utils.logger.Log.printStackTrace(e);
58
		}
59
	}
60
}
0 61

  
tmp/org.txm.statsengine.r.core/src/org/txm/stat/engine/r/StartRserve.java (revision 216)
1
// Copyright © 2010-2013 ENS de Lyon.
2
// Copyright © 2007-2010 ENS de Lyon, CNRS, INRP, University of
3
// Lyon 2, University of Franche-Comté, University of Nice
4
// Sophia Antipolis, University of Paris 3.
5
// 
6
// The TXM platform is free software: you can redistribute it
7
// and/or modify it under the terms of the GNU General Public
8
// License as published by the Free Software Foundation,
9
// either version 2 of the License, or (at your option) any
10
// later version.
11
// 
12
// The TXM platform is distributed in the hope that it will be
13
// useful, but WITHOUT ANY WARRANTY; without even the implied
14
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
15
// PURPOSE. See the GNU General Public License for more
16
// details.
17
// 
18
// You should have received a copy of the GNU General
19
// Public License along with the TXM platform. If not, see
20
// http://www.gnu.org/licenses.
21
// 
22
// 
23
// 
24
// $LastChangedDate: 2015-06-15 15:29:16 +0200 (Mon, 15 Jun 2015) $
25
// $LastChangedRevision: 2989 $
26
// $LastChangedBy: mdecorde $ 
27
//
28
package org.txm.stat.engine.r;
29

  
30
import java.io.File;
31

  
32
import org.rosuda.REngine.Rserve.RConnection;
33
import org.txm.Messages;
34
import org.txm.utils.OSDetector;
35
import org.txm.utils.SystemProxyDetector;
36
import org.txm.utils.StreamHog;
37
import org.txm.utils.logger.Log;
38

  
39
// TODO: Auto-generated Javadoc
40
/**
41
 * Helper class that consumes output of a process. In addition, it filter output
42
 * of the REG command on Windows to look for InstallPath registry entry which
43
 * specif ies the location of R.
44
 * 
45
 * @author RServe library
46
 */
47

  
48
/**
49
 * simple class that start Rserve locally if it's not running already - see
50
 * mainly <code>checkLocalRserve</code> method. It spits out quite some
51
 * debugging outout of the console, so feel free to modif y it for your
52
 * application if desired.
53
 * <p>
54
 * <i>Important:</i> All applications should shutdown every Rserve that they
55
 * started! Never leave Rserve running if you started it after your application
56
 * quits since it may pose a security risk. Inform the user if you started an
57
 * Rserve instance.
58
 */
59
public class StartRserve {
60

  
61
	/** shortcut to <code>launchRserve(cmd, "--no-save --slave", "--no-save --slave", false)</code>. */
62
	public static Process Rserveprocess;
63

  
64
	/**
65
	 * Launch rserve.
66
	 *
67
	 * @param cmd the cmd
68
	 * @param options 
69
	 * @return true, if successful
70
	 */
71
	protected static boolean launchRserve(String cmd, int port, boolean debug, String rArgs, String rServeArgs) {
72
		if (new File(cmd).exists() && !new File(cmd).isDirectory()
73
				&& new File(cmd).canExecute())
74
			return launchRserve(cmd,
75
					"--no-save --slave --encoding utf8 "+rArgs, "--RS-encoding utf8 --no-save --slave --encoding utf8 "+rServeArgs, port, debug); //$NON-NLS-1$ //$NON-NLS-2$
76
		return false;
77
	}
78

  
79
	/**
80
	 * attempt to start Rserve. Note: parameters are <b>not</b> quoted, so avoid
81
	 * using any quotes in arguments
82
	 *
83
	 * @param cmd command necessary to start R
84
	 * @param rargs arguments are are to be passed to R
85
	 * @param rsrvargs arguments to be passed to Rserve
86
	 * @param debug the debug
87
	 * @return <code>true</code> if Rserve is running or was successfully
88
	 * started, <code>false</code> otherwise.
89
	 */
90
	protected static boolean launchRserve(String cmd, String rargs,
91
			String rsrvargs, int port, boolean debug) {
92
		//System.out.println("LAUNCH R SERVER "+cmd+" "+port+" "+debug);
93
		try {
94
			String[] cmdline = null;
95
			// FIXME: don't forget to remove this Window dedicated code if we manage to use http_proxy command line argument
96
			boolean isWindows = false;
97
			
98
			// Windows OS
99
			if (OSDetector.isFamilyWindows()) {
100
				isWindows = true; /* Windows startup */
101
				
102
				
103
				// TODO: old tests for setting proxy in R
104
				//Windows : set --internet2 option to manage proxy if any
105
				
106
//				// set Proxy configuration using Eclipse RCP stored values
107
//				String proxy_conf = "";
108
//				ProxyConf conf = new ProxyConf(RWorkspace.getRWorkspaceInstance());
109
//				if (conf.mustSetProxyConfiguration()) {
110
//					proxy_conf = "http_proxy="+conf.getHttpProxyUrl();
111
//					rsrvargs += " "+proxy_conf; // add the http_proxy parameter
112
//					Log.info("Run Rserve with proxy configuration: "+proxy_conf);
113
//				}
114
				
115
				cmdline = new String[] {
116
						cmd,
117
						rargs, 
118
						"-e", //$NON-NLS-1$
119
						"library(Rserve);Rserve(" //$NON-NLS-1$ 
120
						+ (debug ? "TRUE" : "FALSE")  //$NON-NLS-1$ //$NON-NLS-2$
121
						+ ",port=" + port + "" //$NON-NLS-1$ //$NON-NLS-2$
122
						+ ",args='" //$NON-NLS-1$
123
						+ rsrvargs + "')\" " //$NON-NLS-1$
124
				};	
125
			}
126
			// Mac, Linux
127
			else {
128
				cmdline = new String[] {
129
						"/bin/sh", //$NON-NLS-1$
130
						"-c", //$NON-NLS-1$
131
						"echo 'library(Rserve);Rserve(" //$NON-NLS-1$
132
						+ (debug ? "TRUE" : "FALSE") //$NON-NLS-1$ //$NON-NLS-2$
133
						+ ",port="+port+"" //$NON-NLS-1$ //$NON-NLS-2$
134
						+ ",args=\"" + rsrvargs //$NON-NLS-1$
135
						+ "\")'|" + cmd //$NON-NLS-1$ 
136
						+ " " + rargs }; //$NON-NLS-1$
137
			}
138

  
139
//			ProcessBuilder builder = new ProcessBuilder(cmdline);
140
//			Rserveprocess = builder.start();
141

  
142
			Runtime runtime = Runtime.getRuntime();
143
			Rserveprocess = runtime.exec(cmdline);
144
			
145
			//Log.info(Messages.StartRserve_0+Arrays.toString(cmdline));
146
			StreamHog errStream = new StreamHog(Rserveprocess.getErrorStream(), debug);
147
			StreamHog inStream = new StreamHog(Rserveprocess.getInputStream(), debug);
148
			RWorkspace.getRWorkspaceInstance().registerLogger(errStream, inStream);
149

  
150
			if (!debug && !isWindows)
151
				Rserveprocess.waitFor();
152
			// System.out.println("call terminated, let us try to connect ...");
153
		} catch (Exception x) {
154
			System.err.println(Messages.StartRserve_21 + x.getMessage());
155
			return false;
156
		}
157

  
158
		System.err.print(Messages.StartRserve_22);
159

  
160
		try {
161
			Thread.sleep(200);
162
		} catch (InterruptedException ix) { }
163

  
164
		int attempts = 20;
165
		while (attempts > 0) {
166
			try {
167
				System.out.print("."); //$NON-NLS-1$
168
				RConnection c = new RConnection("127.0.0.1", port); //$NON-NLS-1$
169
				c.close();
170
				return true;
171
			} catch (Exception e2) {
172
				try {
173
					Thread.sleep(2000);
174
				} catch (InterruptedException ix) { }
175
			}
176

  
177
			attempts--;
178
		}
179
		System.out.println(""); //$NON-NLS-1$
180
		return false;
181
	}
182

  
183
	/**
184
	 * checks whether Rserve is running and if that's not the case it attempts
185
	 * to start it using the defaults for the platform where it is run on. This
186
	 * method is meant to be set-and-forget and cover most default setups. For
187
	 * special setups you may get more control over R with <
188
	 * <code>launchRserve</code> instead.
189
	 * @param rServeArgs 
190
	 * @param rargs 
191
	 *
192
	 * @return true, if successful
193
	 */
194
	protected static boolean checkLocalRserve(int port, boolean debug, String rargs, String rServeArgs) {
195
		Log.info(Messages.StartRserve_2);
196
		if (isRserveRunning(port)) {
197
			Log.info(Messages.StartRserve_3+port);
198
			return true;
199
		}
200
		// Windows OS
201
		if (OSDetector.isFamilyWindows()) {
202
			// System.out.println("Windows: query registry to find where R is installed ...");
203
			String installPath = null;
204
			try {
205
				Process rp = Runtime.getRuntime().exec(
206
						"reg query HKLM\\Software\\R-core\\R"); //$NON-NLS-1$
207
				StreamHog regHog = new StreamHog(rp.getInputStream(), true);
208
				rp.waitFor();
209
				regHog.join();
210
				installPath = regHog.getInstallPath();
211
			} catch (Exception rge) {
212
				System.err.println(Messages.StartRserve_28 + rge);
213
				return false;
214
			}
215
			if (installPath == null) {
216
				System.err.println(Messages.StartRserve_29);
217
				return false;
218
			}
219
			// System.out.println(" Found R in : "+installPath +
220
			// "\\bin\\R.exe");
221
			return launchRserve(installPath + "\\bin\\R.exe", port, debug, rargs, rServeArgs); //$NON-NLS-1$
222
		}
223

  
224
		Log.info(Messages.StartRserve_4);
225
		if (launchRserve("R", port, debug, rargs, rServeArgs)) return true; //$NON-NLS-1$
226

  
227
		// R not in the PATH env, try with R common paths
228
		String[] paths = {
229
				"/Library/Frameworks/R.framework/Resources/bin/R", //$NON-NLS-1$
230
				"/usr/local/lib/R/bin/R", //$NON-NLS-1$
231
				"/usr/lib/R/bin/R", //$NON-NLS-1$
232
				"/sw/bin/R", //$NON-NLS-1$
233
				"/usr/common/bin/R", //$NON-NLS-1$
234
		"/opt/bin/R" }; //$NON-NLS-1$
235
		for (String path : paths) {
236
			Log.info(Messages.StartRserve_6+path);
237
			if (new File(path).exists() && launchRserve(path, port, debug, rargs, rServeArgs)) return true;
238
		}
239

  
240
		return false;
241
		//			
242
		//		return (launchRserve("R", port, debug) //$NON-NLS-1$
243
		//				|| /* try some common unix locations of R */
244
		//				(( && launchRserve("/Library/Frameworks/R.framework/Resources/bin/R", port, debug)) //$NON-NLS-1$
245
		//				|| ((new File("/usr/local/lib/R/bin/R")).exists() && launchRserve("/usr/local/lib/R/bin/R")) //$NON-NLS-1$ //$NON-NLS-2$
246
		//				|| ((new File("/usr/lib/R/bin/R")).exists() && launchRserve("/usr/lib/R/bin/R")) //$NON-NLS-1$ //$NON-NLS-2$
247
		//				|| ((new File("/usr/local/bin/R")).exists() && launchRserve("/usr/local/bin/R")) //$NON-NLS-1$ //$NON-NLS-2$
248
		//				|| ((new File("/sw/bin/R")).exists() && launchRserve("/sw/bin/R")) //$NON-NLS-1$ //$NON-NLS-2$
249
		//				|| ((new File("/usr/common/bin/R")).exists() && launchRserve("/usr/common/bin/R")) || ((new File( //$NON-NLS-1$ //$NON-NLS-2$
250
		//				"/opt/bin/R")).exists() && launchRserve("/opt/bin/R"))); //$NON-NLS-1$ //$NON-NLS-2$
251
	}
252

  
253
	/**
254
	 * check whether Rserve is currently running (on local machine and default
255
	 * port).
256
	 * 
257
	 * @return <code>true</code> if local Rserve instance is running,
258
	 *         <code>false</code> otherwise
259
	 */
260
	protected static boolean isRserveRunning(int port) {
261
		try {
262
			new RConnection("127.0.0.1", port); //$NON-NLS-1$
263
			// System.out.println("Rserve is running.");
264
			// c.close();
265
			return true;
266
		} catch (Exception e) {
267
			// System.out.println("First connect try failed with: "+
268
			// e.getMessage());
269
		}
270
		return false;
271
	}
272

  
273

  
274
	public static void main(String[] args) {
275
		System.out.println("result=" + checkLocalRserve(8212, false, "", ""));
276
		try {
277
			System.out.println("Start RServe");
278
			RConnection c = new RConnection("localhost", 8212);
279
			System.out.println("Stop RServe");
280
			c.eval("print(1+1)");
281
			c.eval("2+2");
282
			c.shutdown();
283
			System.out.println("Done");
284
		} catch (Exception x) {
285
			x.printStackTrace();
286
		}
287
	}
288
}
0 289

  
tmp/org.txm.statsengine.r.core/src/org/txm/stat/engine/r/RServeException.java (revision 216)
1
// Copyright © 2010-2013 ENS de Lyon.
2
// Copyright © 2007-2010 ENS de Lyon, CNRS, INRP, University of
3
// Lyon 2, University of Franche-Comté, University of Nice
4
// Sophia Antipolis, University of Paris 3.
5
// 
6
// The TXM platform is free software: you can redistribute it
7
// and/or modify it under the terms of the GNU General Public
8
// License as published by the Free Software Foundation,
9
// either version 2 of the License, or (at your option) any
10
// later version.
11
// 
12
// The TXM platform is distributed in the hope that it will be
13
// useful, but WITHOUT ANY WARRANTY; without even the implied
14
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
15
// PURPOSE. See the GNU General Public License for more
16
// details.
17
// 
18
// You should have received a copy of the GNU General
19
// Public License along with the TXM platform. If not, see
20
// http://www.gnu.org/licenses.
21
// 
22
// 
23
// 
24
// $LastChangedDate: 2013-05-06 17:38:43 +0200 (Mon, 06 May 2013) $
25
// $LastChangedRevision: 2386 $
26
// $LastChangedBy: mdecorde $ 
27
//
28
package org.txm.stat.engine.r;
29

  
30
// TODO: Auto-generated Javadoc
31
/**
32
 * The Class RServeException.
33
 */
34
public class RServeException extends RException {
35

  
36
	/** The Constant serialVersionUID. */
37
	private static final long serialVersionUID = 1L;
38

  
39
	/**
40
	 * Instantiates a new r serve exception.
41
	 */
42
	public RServeException() {
43
		super();
44
		// TODO Auto-generated constructor stub
45
	}
46

  
47
	/**
48
	 * Instantiates a new r serve exception.
49
	 *
50
	 * @param arg0 the arg0
51
	 * @param arg1 the arg1
52
	 */
53
	public RServeException(String arg0, Throwable arg1) {
54
		super(arg0, arg1);
55
		// TODO Auto-generated constructor stub
56
	}
57

  
58
	/**
59
	 * Instantiates a new r serve exception.
60
	 *
61
	 * @param arg0 the arg0
62
	 */
63
	public RServeException(String arg0) {
64
		super(arg0);
65
		// TODO Auto-generated constructor stub
66
	}
67

  
68
	/**
69
	 * Instantiates a new r serve exception.
70
	 *
71
	 * @param arg0 the arg0
72
	 */
73
	public RServeException(Throwable arg0) {
74
		super(arg0);
75
		// TODO Auto-generated constructor stub
76
	}
77

  
78
}
0 79

  
tmp/org.txm.statsengine.r.core/src/org/txm/stat/engine/r/RFileCommunication.java (revision 216)
1
// Copyright © 2010-2013 ENS de Lyon.
2
// Copyright © 2007-2010 ENS de Lyon, CNRS, INRP, University of
3
// Lyon 2, University of Franche-Comté, University of Nice
4
// Sophia Antipolis, University of Paris 3.
5
// 
6
// The TXM platform is free software: you can redistribute it
7
// and/or modify it under the terms of the GNU General Public
8
// License as published by the Free Software Foundation,
9
// either version 2 of the License, or (at your option) any
10
// later version.
11
// 
12
// The TXM platform is distributed in the hope that it will be
13
// useful, but WITHOUT ANY WARRANTY; without even the implied
14
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
15
// PURPOSE. See the GNU General Public License for more
16
// details.
17
// 
18
// You should have received a copy of the GNU General
19
// Public License along with the TXM platform. If not, see
20
// http://www.gnu.org/licenses.
21
// 
22
// 
23
// 
24
// $LastChangedDate: 2015-05-22 09:06:15 +0200 (Fri, 22 May 2015) $
25
// $LastChangedRevision: 2973 $
26
// $LastChangedBy: mdecorde $ 
27
//
28
package org.txm.stat.engine.r;
29

  
30
import java.io.BufferedWriter;
31
import java.io.File;
32
import java.io.FileWriter;
33
import java.io.IOException;
34

  
35
import org.eclipse.core.runtime.Platform;
36
import org.txm.utils.OSDetector;
37

  
38

  
39
// TODO: Auto-generated Javadoc
40
/**
41
 * The Class RFileCommunication.
42
 */
43
public class RFileCommunication {
44
	
45
	/** The transfertfile. */
46
	File transfertfile;
47
	
48
	/** The transfertfilepath. */
49
	String transfertfilepath;
50

  
51
	/**
52
	 * Instantiates a new r file communication.
53
	 *
54
	 * @throws IOException Signals that an I/O exception has occurred.
55
	 */
56
	public RFileCommunication() throws IOException
57
	{
58
		createTempFile();
59

  
60
	}
61

  
62
	/**
63
	 * Creates the temp file.
64
	 *
65
	 * @throws IOException Signals that an I/O exception has occurred.
66
	 */
67
	public void createTempFile() throws IOException
68
	{
69
		transfertfile = File.createTempFile("Rtransfert","file"); //$NON-NLS-1$ //$NON-NLS-2$
70
		//transfertfile = new File("~/Bureau/RTRANSFERT.txt");
71
		transfertfilepath = transfertfile.getAbsolutePath();
72
		if (OSDetector.isFamilyWindows()) //$NON-NLS-1$ //$NON-NLS-2$
73
		{
74
			//System.out.println("patch path");
75
			transfertfilepath = transfertfilepath.replace("\\", "\\\\"); //$NON-NLS-1$ //$NON-NLS-2$
76
		}
77
		//System.out.println("Transfert file: "+transfertfilepath);
78
	}
79

  
80
	/**
81
	 * Assign.
82
	 *
83
	 * @param variablename the variablename
84
	 * @param matrix the matrix
85
	 * @param nrow the nrow
86
	 * @param ncol the ncol
87
	 * @throws RWorkspaceException the r workspace exception
88
	 */
89
	public void assign(String variablename, int[] matrix, int nrow, int ncol) throws RWorkspaceException
90
	{
91
		writeVector(matrix);
92
		RWorkspace.getRWorkspaceInstance().eval("source(\""+transfertfilepath+"\");"); //$NON-NLS-1$ //$NON-NLS-2$
93
		RWorkspace.getRWorkspaceInstance().eval(variablename+" <- matrix(vectorint, nrow="+nrow+", ncol="+ncol+", byrow=T);"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
94
	}
95

  
96
	/**
97
	 * Assign.
98
	 *
99
	 * @param variablename the variablename
100
	 * @param matrix the matrix
101
	 * @param nrow the nrow
102
	 * @param ncol the ncol
103
	 * @throws RWorkspaceException the r workspace exception
104
	 */
105
	public void assign(String variablename, double[] matrix, int nrow, int ncol) throws RWorkspaceException
106
	{
107
		writeVector(matrix);
108
		RWorkspace.getRWorkspaceInstance().eval("source(\""+transfertfilepath+"\");"); //$NON-NLS-1$ //$NON-NLS-2$
109
		RWorkspace.getRWorkspaceInstance().eval(variablename+" <- matrix(vectordouble, nrow="+nrow+", ncol="+ncol+", byrow=T);"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
110
	}
111

  
112
	/**
113
	 * Assign.
114
	 *
115
	 * @param variablename the variablename
116
	 * @param vector the vector
117
	 * @throws RWorkspaceException the r workspace exception
118
	 */
119
	public void assign(String variablename, int[] vector) throws RWorkspaceException
120
	{
121
		//System.out.println("assign vector "+variablename+" size "+vector.length);
122
		writeVector(vector);
123
		RWorkspace.getRWorkspaceInstance().eval("source(\""+transfertfilepath+"\");"); //$NON-NLS-1$ //$NON-NLS-2$
124
		RWorkspace.getRWorkspaceInstance().eval(variablename+" <- vectorint;"); //$NON-NLS-1$
125
	}
126

  
127
	/**
128
	 * Assign.
129
	 *
130
	 * @param variablename the variablename
131
	 * @param vector the vector
132
	 * @throws RWorkspaceException the r workspace exception
133
	 */
134
	public void assign(String variablename, double[] vector) throws RWorkspaceException
135
	{
136
		//System.out.println("assign vector "+variablename+" size "+vector.length);
137
		writeVector(vector);
138
		RWorkspace.getRWorkspaceInstance().eval("source(\""+transfertfilepath+"\");"); //$NON-NLS-1$ //$NON-NLS-2$
139
		RWorkspace.getRWorkspaceInstance().eval(variablename+" <- vectordouble;"); //$NON-NLS-1$
140
		
141
	}
142

  
143
	/**
144
	 * Assign.
145
	 *
146
	 * @param variablename the variablename
147
	 * @param vector the vector
148
	 * @throws RWorkspaceException the r workspace exception
149
	 */
150
	public void assign(String variablename, String[] vector) throws RWorkspaceException
151
	{
152
		//System.out.println("assign vector "+variablename+" size "+vector.length);
153
		writeVector(vector);
154
		RWorkspace.getRWorkspaceInstance().eval("source(\""+transfertfilepath+"\");"); //$NON-NLS-1$ //$NON-NLS-2$
155
		RWorkspace.getRWorkspaceInstance().eval(variablename+" <- vectorstr;"); //$NON-NLS-1$
156
	}
157

  
158
	/*
159
	public boolean writeMatrix(int[][] matrix)
160
	{
161
		//System.out.println("WRITE MATRIX");
162
		try {
163
			BufferedWriter writer = new BufferedWriter(new FileWriter(transfertfilepath));
164
			for(int i = 0 ; i < matrix.length ; i++)
165
			{
166
				StringBuffer str = new StringBuffer();
167
				for(int j = 0 ; j < matrix[i].length ; j++)
168
					if (j == matrix[i].length -1)
169
						str.append(matrix[i][j]);
170
					else
171
						str.append(""+matrix[i][j]+"\t");
172
				writer.write(str.toString()+"\n");
173
			}
174
			writer.close();
175
		} catch (IOException e) {
176
			org.txm.utils.logger.Log.printStackTrace(e);
177
			return false;
178
		}
179
		return true;
180
	}
181

  
182
	public boolean writeMatrix(double[][] matrix)
183
	{
184
		//System.out.println("WRITE MATRIX");
185
		try {
186
			BufferedWriter writer = new BufferedWriter(new FileWriter(transfertfilepath));
187
			for(int i = 0 ; i < matrix.length ; i++)
188
			{
189
				StringBuffer str = new StringBuffer();
190
				for(int j = 0 ; j < matrix[i].length ; j++)
191
					if (j == matrix[i].length -1)
192
						str.append(matrix[i][j]);
193
					else
194
						str.append(""+matrix[i][j]+"\t");
195
				writer.write(str.toString()+"\n");
196
			}
197
			writer.close();
198
		} catch (IOException e) {
199
			org.txm.utils.logger.Log.printStackTrace(e);
200
			return false;
201
		}
202
		return true;
203
	}
204

  
205
*/
206
	/**
207
	 * Write vector.
208
	 *
209
	 * @param vector the vector
210
	 * @return true, if successful
211
	 */
212
	private boolean writeVector(String[] vector) {
213
		//System.out.println("WRITE VECTOR");
214
		try {
215
			BufferedWriter writer = new BufferedWriter(new FileWriter(transfertfilepath));
216

  
217
			StringBuffer str = new StringBuffer();
218
			str.append("vectorstr <- c("); //$NON-NLS-1$
219
			for(int j = 0 ; j < vector.length ; j++)
220
				if (j == vector.length -1)
221
					str.append("\""+vector[j]+"\""); //$NON-NLS-1$ //$NON-NLS-2$
222
				else
223
					str.append("\""+vector[j]+"\", "); //$NON-NLS-1$ //$NON-NLS-2$
224
			str.append(");"); //$NON-NLS-1$
225
			writer.write(str.toString());
226

  
227
			writer.close();
228
		} catch (IOException e) {
229
			org.txm.utils.logger.Log.printStackTrace(e);
230
			return false;
231
		}
232
		return true;
233
	}
234

  
235
	/**
236
	 * Write vector.
237
	 *
238
	 * @param vector the vector
239
	 * @return true, if successful
240
	 */
241
	public boolean writeVector(int[] vector)
242
	{
243
		//System.out.println("WRITE VECTOR");
244
		try {
245
			BufferedWriter writer = new BufferedWriter(new FileWriter(transfertfilepath));
246

  
247
			StringBuffer str = new StringBuffer();
248
			str.append("vectorint <- as.integer(c("); //$NON-NLS-1$
249
			for(int j = 0 ; j < vector.length ; j++)
250
				if (j == vector.length -1)
251
					str.append(vector[j]);
252
				else
253
					str.append(""+vector[j]+", "); //$NON-NLS-1$ //$NON-NLS-2$
254
			str.append("));"); //$NON-NLS-1$
255
			writer.write(str.toString());
256
			writer.close();
257
		} catch (IOException e) {
258
			org.txm.utils.logger.Log.printStackTrace(e);
259
			return false;
260
		}
261
		return true;
262
	}
263

  
264
	/**
265
	 * Write vector.
266
	 *
267
	 * @param vector the vector
268
	 * @return true, if successful
269
	 */
270
	public boolean writeVector(double[] vector)
271
	{
272
		//System.out.println("WRITE VECTOR");
273
		try {
274
			BufferedWriter writer = new BufferedWriter(new FileWriter(transfertfilepath));
275

  
276
			StringBuffer str = new StringBuffer();
277
			str.append("vectordouble <- c("); //$NON-NLS-1$
278
			for(int j = 0 ; j < vector.length ; j++)
279
			{
280
				if (j == vector.length -1)
281
					str.append(vector[j]);
282
				else
283
					str.append(""+vector[j]+", "); //$NON-NLS-1$ //$NON-NLS-2$
284
			}
285
			str.append(");"); //$NON-NLS-1$
286
			writer.write(str.toString());
... This diff was truncated because it exceeds the maximum size that can be displayed.

Also available in: Unified diff