[R] unable to call R t-test from Java

Wed Jul 20 17:41:35 CEST 2005

This does not address the question of how to do this the way you're trying
to do it, using Omegahat.  But I've had good results using Simon Urbanek's
program Rserve:  http://stats.math.uni-augsburg.de/Rserve/

Hope this helps,

Matthew Wiener
Applied Computer Science & Mathematics
Merck Research Laboratories
Rahway, NJ 07065
732-594-5303 

-----Original Message-----
From: r-help-bounces at stat.math.ethz.ch
[mailto:r-help-bounces at stat.math.ethz.ch] On Behalf Of O'Brien, Laura
Sent: Wednesday, July 20, 2005 10:42 AM
To: r-help at stat.math.ethz.ch
Subject: [R] unable to call R t-test from Java

Hello,

My colleague and I would like to write Java code that invokes R to do a
simple TTest.  I've included my sample java code below.  I tried various
alternatives and am unable to pass a vector to the TTest method.  In my
investigation, I tried to call other R methods that take vectors and also
ran into various degrees of failure.   Any insight you can provide or other
Web references you can point me to would be appreciated.

Thank you,
Laura O'Brien
Application Architect

---------------------------  code   ------------------------------

package org.omegahat.R.Java.Examples;

import org.omegahat.R.Java.ROmegahatInterpreter;
import org.omegahat.R.Java.REvaluator;

public class JavaRCall2
{

    /**
     * want to see if I can eval a t.test command like what I would run in
the
     * R command line
     */

    static public void runTTestByEval_cores(REvaluator e,
ROmegahatInterpreter interp)
    {
        /* produces a core */
        System.err.println("eval a t.test");
        Object value = e.eval("t.test (c(1,2,3), c(4,5,6))");
        if (value != null)
            interp.show(value);
    }

    /**
     * want to see if I can eval anything that takes a vector, e.g. mean, 
     * like what I would run in the R command line
     */

    static public void runMeanByEval_works(REvaluator e,
ROmegahatInterpreter interp)
    {
        System.err.println("\r\n  evaluation string mean command");
        Object value = e.eval("mean(c(1,2,3))");
        if(value != null) 
        {
            interp.show(value ); 
            System.err.println("\r\n");
        }    
    }

/**
 *  if I pass mean a org.omegahat.Environment.DataStructures.numeric what do
I get?  NaN
 */

    static public void runMeanByNumericList_nan(REvaluator e,
ROmegahatInterpreter interp)
    {    
         Object[] funArgs = new Object[1];
         // given argument is not numeric or logical

         org.omegahat.Environment.DataStructures.numeric rList1 = new
org.omegahat.Environment.DataStructures.numeric(3);       

         double[] dList = new double[3];
         dList[0] = (double) 1.1;
         dList[1] = (double) 2.2; 
         dList[2] = (double) 3.3;
         rList1.setData(dList, true);
         System.err.println(rList1.toString());

         funArgs[0] = rList1 ;

         System.err.println("\r\n Calling mean and passing an omegahat
vector");

         Object value =  e.call("mean", funArgs); 
         if(value != null) 
         {
         interp.show(value ); 
         System.err.println("\r\n");
         }

    }

    /**
     * let's run some tests on the vector passed in and see what R thinks
I'm handing it
     * 
     * it returns 
     * isnumeric:     false
     * mode:          list
     * length:        2
     */

    public static void runTestsOnOmegahatNumeric(REvaluator e,
ROmegahatInterpreter interp)
    {
        Object[] funArgs = new Object[1];
        // given argument is not numeric or logical

        org.omegahat.Environment.DataStructures.numeric rList1 = new
org.omegahat.Environment.DataStructures.numeric(3);       

        double[] dList = new double[3];
        dList[0] = (double) 1.1;
        dList[1] = (double) 2.2; 
        dList[2] = (double) 3.3;
        rList1.setData(dList, true);
        System.err.println(rList1.toString());

        funArgs[0] = rList1 ;

        System.err.println("\r\n Calling isnumeric and passing an omegahat
vector");

        Object value =  e.call("is.numeric", funArgs); 
        if(value != null) 
        {
            interp.show(value ); 
            System.err.println("\r\n");
        }

        // mode is list

        System.err.println("\r\n Calling mode and passing an omegahat
vector");

        value =  e.call("mode", funArgs); 
        if(value != null) 
        {
            interp.show(value ); 
            System.err.println("\r\n");
        }

        System.err.println("\r\n Calling length and passing an omegahat
vector");
        System.err.println("\r\n");
        System.err.println("INTERESTING:  thinks the length is 2!");

        value =  e.call("length", funArgs); 
        if(value != null) 
        {
            interp.show(value ); 
            System.err.println("\r\n");
        }

    }

    /**
     * run the mean on a java array.  Does it also return NAN?  
     * It returns a different value than the mean -- 2.19999... instead of
2.2
     */

    static public void runMeanOnJavaArray(REvaluator e, ROmegahatInterpreter
interp)
    {
        Object[] funArgs = new Object[1];
        double[] d = { 1.1, 2.2, 3.3};
        funArgs[0] = d;
        System.err.println("\r\n Calling mean of (1.1, 2.2, 3.3) and passing
a java array\r\n");
        System.err.println("INTERSTING:  thinks the mean is 2.19999... it
should be 2.2 \r\n");

        Object value =  e.call("mean", funArgs); 
        if(value != null) 
        {
            interp.show(value ); 
            System.err.println("\r\n");
        }
    }

    /**
     *    This is what I really want! 
     */

    static public void runTTestOnJavaArray_cores(REvaluator e,
ROmegahatInterpreter interp)
    {
        Object[] funArgs = new Object[2];
        double[] d0 = { 1.1, 2.2, 3.3};
        double[] d1 = { 9.9, 8.8, 7.7};

        funArgs[0] = d0;
        funArgs[1] = d1;

         System.err.println("\r\n Calling t.test and passing a java array");

         Object value =  e.call("t.test", funArgs); 
         if(value != null) 
         {
         interp.show(value ); 
         System.err.println("\r\n");
         }

    }

    /**
     * 
     */
    static public void main(String[] args) 
    {
        ROmegahatInterpreter interp = new
ROmegahatInterpreter(ROmegahatInterpreter.fixArgs(args), false);
        REvaluator e = new REvaluator();

        Object[] funArgs;
        String[] objects;
        Object value;
        int i;

        /** GOAL:  pass a vector of numbers into a t-test
        */

            // unfortunately it core dumps
            runTTestOnJavaArray_cores(e, interp);   

        /*         since I've been unable to get that work, 
        *         I try various evaluation commands to see if I 
        *         can get any sort of R commands that take vectors to work
        *         in any sort of fashion
        */

        //
        //   SAMPLE eval based calls
        //

        //  can I successfully invoke a t.test command similar to what I can
        //  do via the command line, e.g. t.test (c(1,2,3), c(4,5,6))
        //  NO -- this core dumps
        // runTTestByEval_cores(e, interp);

        // can I eval anything that takes a vector -- let's try the mean
method
        // yes this works!
            //runMeanByEval_works(e, interp);

        //
        //    SAMPLE org.omegahat.Environment.DataStructures.numeric 
        //

        // this returns Nan

        // runMeanByNumericList_nan(e, interp);

        // given that the above returns NaN, what does R think I'm passing
it for a vector?
        // let's run some tests
        runTestsOnOmegahatNumeric(e, interp);

        // now let's try some tests on a java array instead of an omegahat
numeric
        runMeanOnJavaArray(e, interp);
    }
}

______________________________________________
R-help at stat.math.ethz.ch mailing list
https://stat.ethz.ch/mailman/listinfo/r-help
PLEASE do read the posting guide!
http://www.R-project.org/posting-guide.html