/**
* Global Sensor Networks (GSN) Source Code
* Copyright (c) 2006-2016, Ecole Polytechnique Federale de Lausanne (EPFL)
*
* This file is part of GSN.
*
* GSN 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 3 of the License, or
* (at your option) any later version.
*
* GSN 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 GSN. If not, see <http://www.gnu.org/licenses/>.
*
* File: src/ch/epfl/gsn/utils/models/jgarch/util/JRIExample.java
*
* @author Saket Sathe
* @author Sofiane Sarni
*
*/
package ch.epfl.gsn.utils.models.jgarch.util;
import java.util.Enumeration;
import org.rosuda.JRI.REXP;
import org.rosuda.JRI.RList;
import org.rosuda.JRI.RVector;
import org.rosuda.JRI.Rengine;
import ch.epfl.gsn.utils.models.jgarch.wrappers.REngineManager;
public class JRIExample {
public static void main(String[] args) {
// just making sure we have the right version of everything
if (!Rengine.versionCheck()) {
System.err.println("** Version mismatch - Java files don't match library version.");
System.exit(1);
}
System.out.println("Creating Rengine (with arguments)");
// 1) we pass the arguments from the command line
// 2) we won't use the main loop at first, we'll start it later
// (that's the "false" as second argument)
// 3) the callbacks are implemented by the TextConsole class above
//Rengine re=new Rengine(args, false, new TextConsole());
Rengine re = REngineManager.getInstance().getREngine();
System.out.println("Rengine created, waiting for R");
// the engine creates R is a new thread, so we should wait until it's ready
if (!re.waitForR()) {
System.out.println("Cannot load R");
return;
}
/* High-level API - do not use RNI methods unless there is no other way
to accomplish what you want */
try {
REXP x;
re.eval("data(iris)",false);
System.out.println(x=re.eval("iris"));
// generic vectors are RVector to accomodate names
RVector v = x.asVector();
if (v.getNames()!=null) {
System.out.println("has names:");
for (Enumeration e = v.getNames().elements() ; e.hasMoreElements() ;) {
System.out.println(e.nextElement());
}
}
// for compatibility with Rserve we allow casting of vectors to lists
RList vl = x.asList();
String[] k = vl.keys();
if (k!=null) {
System.out.println("and once again from the list:");
int i=0; while (i<k.length) System.out.println(k[i++]);
}
// get boolean array
System.out.println(x=re.eval("iris[[1]]>mean(iris[[1]])"));
// R knows about TRUE/FALSE/NA, so we cannot use boolean[] this way
// instead, we use int[] which is more convenient (and what R uses internally anyway)
int[] bi = x.asIntArray();
{
int i = 0; while (i<bi.length) { System.out.print(bi[i]==0?"F ":(bi[i]==1?"T ":"NA ")); i++; }
System.out.println("");
}
// push a boolean array
boolean by[] = { true, false, false };
re.assign("bool", by);
System.out.println(x=re.eval("bool"));
// asBool returns the first element of the array as RBool
// (mostly useful for boolean arrays of the length 1). is should return true
System.out.println("isTRUE? "+x.asBool().isTRUE());
// now for a real dotted-pair list:
System.out.println(x=re.eval("pairlist(a=1,b='foo',c=1:5)"));
RList l = x.asList();
if (l!=null) {
int i=0;
String [] a = l.keys();
System.out.println("Keys:");
while (i<a.length) System.out.println(a[i++]);
System.out.println("Contents:");
i=0;
while (i<a.length) System.out.println(l.at(i++));
}
System.out.println(re.eval("sqrt(36)"));
} catch (Exception e) {
System.out.println("EX:"+e);
e.printStackTrace();
}
// Part 2 - low-level API - for illustration purposes only!
//System.exit(0);
// simple assignment like a<-"hello" (env=0 means use R_GlobalEnv)
long xp1 = re.rniPutString("hello");
re.rniAssign("a", xp1, 0);
// Example: how to create a named list or data.frame
double da[] = {1.2, 2.3, 4.5};
double db[] = {1.4, 2.6, 4.2};
long xp3 = re.rniPutDoubleArray(da);
long xp4 = re.rniPutDoubleArray(db);
// now build a list (generic vector is how that's called in R)
long la[] = {xp3, xp4};
long xp5 = re.rniPutVector(la);
// now let's add names
String sa[] = {"a","b"};
long xp2 = re.rniPutStringArray(sa);
re.rniSetAttr(xp5, "names", xp2);
// ok, we have a proper list now
// we could use assign and then eval "b<-data.frame(b)", but for now let's build it by hand:
String rn[] = {"1", "2", "3"};
long xp7 = re.rniPutStringArray(rn);
re.rniSetAttr(xp5, "row.names", xp7);
long xp6 = re.rniPutString("data.frame");
re.rniSetAttr(xp5, "class", xp6);
// assign the whole thing to the "b" variable
re.rniAssign("b", xp5, 0);
{
System.out.println("Parsing");
long e=re.rniParse("data(iris)", 1);
System.out.println("Result = "+e+", running eval");
long r=re.rniEval(e, 0);
System.out.println("Result = "+r+", building REXP");
REXP x=new REXP(re, r);
System.out.println("REXP result = "+x);
}
{
System.out.println("Parsing");
long e=re.rniParse("iris", 1);
System.out.println("Result = "+e+", running eval");
long r=re.rniEval(e, 0);
System.out.println("Result = "+r+", building REXP");
REXP x=new REXP(re, r);
System.out.println("REXP result = "+x);
}
{
System.out.println("Parsing");
long e=re.rniParse("names(iris)", 1);
System.out.println("Result = "+e+", running eval");
long r=re.rniEval(e, 0);
System.out.println("Result = "+r+", building REXP");
REXP x=new REXP(re, r);
System.out.println("REXP result = "+x);
String s[]=x.asStringArray();
if (s!=null) {
int i=0; while (i<s.length) { System.out.println("["+i+"] \""+s[i]+"\""); i++; }
}
}
{
System.out.println("Parsing");
long e=re.rniParse("rnorm(10)", 1);
System.out.println("Result = "+e+", running eval");
long r=re.rniEval(e, 0);
System.out.println("Result = "+r+", building REXP");
REXP x=new REXP(re, r);
System.out.println("REXP result = "+x);
double d[]=x.asDoubleArray();
if (d!=null) {
int i=0; while (i<d.length) { System.out.print(((i==0)?"":", ")+d[i]); i++; }
System.out.println("");
}
System.out.println("");
}
{
REXP x=re.eval("1:10");
System.out.println("REXP result = "+x);
int d[]=x.asIntArray();
if (d!=null) {
int i=0; while (i<d.length) { System.out.print(((i==0)?"":", ")+d[i]); i++; }
System.out.println("");
}
}
re.eval("print(1:10/3)");
if (true) {
// so far we used R as a computational slave without REPL
// now we start the loop, so the user can use the console
System.out.println("Now the console is yours ... have fun");
re.startMainLoop();
} else {
re.end();
System.out.println("end");
}
}
}