Revision: 509
http://rpy.svn.sourceforge.net/rpy/?rev=509&view=rev
Author: lgautier
Date: 2008-05-04 20:26:35 -0700 (Sun, 04 May 2008)
Log Message:
-----------
rinterface:
- modified the signature to initEmbeddedR
- alias rinterface to ri for some tests
- added comments in the C code
robjects:
- handling of named vectors (unstable)
Modified Paths:
--------------
branches/rpy_nextgen/doc/rpy.texi
branches/rpy_nextgen/rpy/rinterface/rinterface.c
branches/rpy_nextgen/rpy/rinterface/tests/test_Sexp.py
branches/rpy_nextgen/rpy/rinterface/tests/test_SexpClosure.py
branches/rpy_nextgen/rpy/rinterface/tests/test_SexpEnvironment.py
branches/rpy_nextgen/rpy/rinterface/tests/test_SexpVector.py
branches/rpy_nextgen/rpy/rinterface/tests/test_SexpVectorNumeric.py
branches/rpy_nextgen/rpy/robjects/__init__.py
branches/rpy_nextgen/rpy/robjects/tests/testRVector.py
Modified: branches/rpy_nextgen/doc/rpy.texi
===================================================================
--- branches/rpy_nextgen/doc/rpy.texi 2008-04-29 09:03:05 UTC (rev 508)
+++ branches/rpy_nextgen/doc/rpy.texi 2008-05-05 03:26:35 UTC (rev 509)
@@ -9,9 +9,7 @@
* RPy v2: (rpy2). RPy2, Python extension module for R.
@end direntry
[EMAIL PROTECTED] version
-2.0.0-dev
[EMAIL PROTECTED] macro
[EMAIL PROTECTED] VERSIONno 2.0.0-dev
@macro Python
Python
@@ -33,9 +31,10 @@
@end macro
@ifinfo
-This file documents @RPy2{} @version{}
+This file documents @RPy2{} @value{VERSIONno}
-Copyright -
+Copyright @copyright{} 2008 L.@: Gautier@
+
Permission is granted to make and distribute verbatim
copies of this manual provided the copyright notice and
this permission notice are preserved on all copies.
@@ -110,8 +109,8 @@
@contents
@end iftex
[EMAIL PROTECTED] Preface, Overview, , Top
[EMAIL PROTECTED] Preface
[EMAIL PROTECTED] Preface, Overview, Top, Top
[EMAIL PROTECTED] Preface
This presentation describes @RPy2{}, a close-to-complete rewrite of
the @RPy{} package.
@@ -392,17 +391,18 @@
One has to initialize R before much can be done.
The function @code{initEmbeddedR} lets one initialize
-the embedded R, and take the same parameters as one
-would give when starting an R terminal from the command
-line:
+the embedded R:
@example
->>> rinterface.initEmbeddedR("--no-save", "--quiet")
+>>> rinterface.initEmbeddedR()
@end example
Initialization should only be performed once and in the case
of a second call to initEmbeddedR, to avoid unpredictable results
when using the embedded R, an exception is be fired.
+Parameters for the initialization are in the module varible
[EMAIL PROTECTED]
+
@node Rspace
@subsection @R{} space and @Python{} space
Modified: branches/rpy_nextgen/rpy/rinterface/rinterface.c
===================================================================
--- branches/rpy_nextgen/rpy/rinterface/rinterface.c 2008-04-29 09:03:05 UTC
(rev 508)
+++ branches/rpy_nextgen/rpy/rinterface/rinterface.c 2008-05-05 03:26:35 UTC
(rev 509)
@@ -79,6 +79,16 @@
typedef intobjargproc ssizeobjargproc;
#endif
+/* A sequence that holds options to initialize R */
+static PyObject *initOptions;
+
+/* Helper variables to quickly resolve SEXP types.
+ * The first variable gives the highest possible
+ * SEXP type.
+ * The second in an array of strings giving either
+ * the SEXP name (INTSXP, REALSXP, etc...), or a NULL
+ * if there is no such valid SEXP.
+ */
static const int maxValidSexpType = 99;
static char **validSexpType;
@@ -96,6 +106,9 @@
error("Interrupted");
}
+/* Helper variable to store whether the embedded R is initialized
+ * or not.
+ */
static PyObject *embeddedR_isInitialized;
/* The Python original SIGINT handler */
@@ -123,7 +136,7 @@
/* Should having multiple threads of R become possible,
* useful routines could appear here...
*/
-static PyObject* EmbeddedR_init(PyObject *self, PyObject *args)
+static PyObject* EmbeddedR_init(PyObject *self)
{
if (PyObject_IsTrue(embeddedR_isInitialized)) {
@@ -131,18 +144,14 @@
return NULL;
}
- const Py_ssize_t n_args = PyTuple_Size(args);
- //char *defaultargv[] = {"rpython", "--verbose"};
+ const Py_ssize_t n_args = PySequence_Size(initOptions);
char *options[n_args];
+
PyObject *opt_string;
Py_ssize_t ii;
for (ii = 0; ii < n_args; ii++) {
- opt_string = PyTuple_GetItem(args, ii);
- if (! PyString_Check(opt_string)) {
- PyErr_SetString(PyExc_TypeError, "All options must be strings.");
- return NULL;
- }
- options[ii] = PyString_AS_STRING(opt_string);
+ opt_string = PyList_GetItem(initOptions, ii);
+ options[ii] = PyString_AsString(opt_string);
}
int status = Rf_initEmbeddedR(n_args, options);
@@ -155,12 +164,16 @@
PyObject *res = PyInt_FromLong(status);
+#ifdef RPY_VERBOSE
+ printf("R initialized - status: %i\n", status);
+#endif
+
return res;
}
PyDoc_STRVAR(EmbeddedR_init_doc,
"initEmbeddedR()\n\
-\n\
-Initialize an embedded R.");
+ \n\
+ Initialize an embedded R.");
static PyObject* EmbeddedR_end(PyObject *self, Py_ssize_t fatal)
@@ -192,8 +205,8 @@
}
PyDoc_STRVAR(EmbeddedR_end_doc,
"endEmbeddedR()\n\
-\n\
-Terminate an embedded R.");
+ \n\
+ Terminate an embedded R.");
/* --- set output from the R console ---*/
@@ -225,8 +238,8 @@
}
PyDoc_STRVAR(EmbeddedR_setWriteConsole_doc,
"setWriteConsoleEmbeddedR()\n\
-\n\
-Set the R console output to the Python console.");
+ \n\
+ Set the R console output to the Python console.");
static PyObject*
@@ -256,7 +269,7 @@
if ((RPY_COUNT(self) == 0) && RPY_SEXP(self)) {
#ifdef RPY_VERBOSE
- printf("freeing SEXP resources...");
+ printf("freeing SEXP resources...\n");
#endif
if (RPY_SEXP(self) != R_NilValue) {
@@ -277,10 +290,10 @@
{
//FIXME: make sure this is making any sense
SEXP sexp = RPY_SEXP((PySexpObject *)self);
- if (! sexp) {
- PyErr_Format(PyExc_ValueError, "NULL SEXP.");
- return NULL;
- }
+ //if (! sexp) {
+ // PyErr_Format(PyExc_ValueError, "NULL SEXP.");
+ // return NULL;
+ //}
return PyString_FromFormat("<%s - Python:\%p / R:\%p>",
self->ob_type->tp_name,
self,
@@ -299,8 +312,8 @@
return PyInt_FromLong(TYPEOF(sexp));
}
PyDoc_STRVAR(Sexp_typeof_doc,
-"\n\
-Returns the R internal SEXPREC type.");
+ "\n\
+ Returns the R internal SEXPREC type.");
static PyObject*
@@ -421,11 +434,15 @@
PySexpObject *self;
#ifdef RPY_VERBOSE
- printf("new object @ %p...", self);
+ printf("new object @...\n");
#endif
//self = (PySexpObject *)_PyObject_New(&type);
self = (PySexpObject *)type->tp_alloc(type, 0);
+ #ifdef RPY_VERBOSE
+ printf(" %p...\n", self);
+ #endif
+
if (! self)
PyErr_NoMemory();
@@ -449,7 +466,7 @@
Sexp_init(PySexpObject *self, PyObject *args, PyObject *kwds)
{
#ifdef RPY_VERBOSE
- printf("%p: Sexp initializing...", self);
+ printf("%p: Sexp initializing...\n", self);
#endif
PyObject *sourceObject;
@@ -662,6 +679,12 @@
/* return NULL; */
/* } */
UNPROTECT(2);
+
+ if (! res_R) {
+ PyErr_Format(PyExc_RuntimeError, "Error while running R code");
+ return NULL;
+ }
+
//FIXME: standardize R outputs
extern void Rf_PrintWarnings(void);
Rf_PrintWarnings(); /* show any warning messages */
@@ -670,7 +693,6 @@
return res;
fail:
- printf("failed.\n");
UNPROTECT(1);
return NULL;
@@ -972,14 +994,13 @@
//FIXME: write more doc
PyDoc_STRVAR(VectorSexp_Type_doc,
-"R object that is a vector.\
- R vectors start their indexing at one,\
- while Python lists or arrays start indexing\
- at zero.\
-\n\
-In the hope to avoid confusion, the indexing\
- from the Python subset operator (__getitem__)\
- is done at zero.");
+ "R object that is a vector."
+ " R vectors start their indexing at one,"
+ " while Python lists or arrays start indexing"
+ " at zero.\n"
+ "In the hope to avoid confusion, the indexing"
+ " from the Python subset operator (__getitem__)"
+ " is done at zero.");
/* ", while an other method to perform\ */
/* it at one is provided (_not yet implemented_).\ */
/* That other method is also performing indexing."); */
@@ -1040,7 +1061,7 @@
VectorSexp_init(PySexpObject *self, PyObject *args, PyObject *kwds)
{
#ifdef RPY_VERBOSE
- printf("%p: VectorSexp initializing...", self);
+ printf("%p: VectorSexp initializing...\n", self);
#endif
PyObject *object;
@@ -1156,9 +1177,9 @@
return NULL;
}
PyDoc_STRVAR(EnvironmentSexp_subscript_doc,
- "Find an R object in the environment.\n\
- Not all R environment are hash tables, and this may\
- influence performances when doing repeated lookups.");
+ "Find an R object in the environment.\n"
+ "Not all R environment are hash tables, and this may"
+ " influence performances when doing repeated lookups.");
static int
EnvironmentSexp_ass_subscript(PyObject *self, PyObject *key, PyObject *value)
@@ -1624,7 +1645,7 @@
/* --- List of functions defined in the module --- */
static PyMethodDef EmbeddedR_methods[] = {
- {"initEmbeddedR", (PyCFunction)EmbeddedR_init, METH_VARARGS,
+ {"initEmbeddedR", (PyCFunction)EmbeddedR_init, METH_NOARGS,
EmbeddedR_init_doc},
{"endEmbeddedR", (PyCFunction)EmbeddedR_end, METH_O,
EmbeddedR_end_doc},
@@ -1746,8 +1767,9 @@
PyModule_AddIntConstant(module, #name, name)
#define ADD_VALID_SEXP(name) \
validSexpType[name] = #name
+#define PYASSERT_ZERO(code) \
+ if ((code) != 0) {return ; }
-
PyMODINIT_FUNC
initrinterface(void)
{
@@ -1772,6 +1794,25 @@
return;
d = PyModule_GetDict(m);
+ initOptions = PyList_New(4);
+ PYASSERT_ZERO(
+ PyList_SetItem(initOptions, 0,
+ PyString_FromString("rpy2"))
+ );
+ PYASSERT_ZERO(
+ PyList_SetItem(initOptions, 1,
+ PyString_FromString("--quiet"))
+ );
+ PYASSERT_ZERO(
+ PyList_SetItem(initOptions, 2,
+ PyString_FromString("--vanilla"))
+ );
+ PYASSERT_ZERO(
+ PyList_SetItem(initOptions, 3,
+ PyString_FromString("--no-save"))
+ );
+ PyModule_AddObject(m, "initOptions", initOptions);
+
PyModule_AddObject(m, "Sexp", (PyObject *)&Sexp_Type);
PyModule_AddObject(m, "SexpClosure", (PyObject *)&ClosureSexp_Type);
PyModule_AddObject(m, "SexpVector", (PyObject *)&VectorSexp_Type);
Modified: branches/rpy_nextgen/rpy/rinterface/tests/test_Sexp.py
===================================================================
--- branches/rpy_nextgen/rpy/rinterface/tests/test_Sexp.py 2008-04-29
09:03:05 UTC (rev 508)
+++ branches/rpy_nextgen/rpy/rinterface/tests/test_Sexp.py 2008-05-05
03:26:35 UTC (rev 509)
@@ -3,7 +3,7 @@
try:
#FIXME: can starting and stopping an embedded R be done several times ?
- rinterface.initEmbeddedR("foo", "--vanilla", "--no-save", "--quiet")
+ rinterface.initEmbeddedR()
except:
pass
Modified: branches/rpy_nextgen/rpy/rinterface/tests/test_SexpClosure.py
===================================================================
--- branches/rpy_nextgen/rpy/rinterface/tests/test_SexpClosure.py
2008-04-29 09:03:05 UTC (rev 508)
+++ branches/rpy_nextgen/rpy/rinterface/tests/test_SexpClosure.py
2008-05-05 03:26:35 UTC (rev 509)
@@ -3,7 +3,7 @@
try:
#FIXME: can starting and stopping an embedded R be done several times ?
- rinterface.initEmbeddedR("foo", "--vanilla", "--no-save", "--quiet")
+ rinterface.initEmbeddedR()
except:
pass
Modified: branches/rpy_nextgen/rpy/rinterface/tests/test_SexpEnvironment.py
===================================================================
--- branches/rpy_nextgen/rpy/rinterface/tests/test_SexpEnvironment.py
2008-04-29 09:03:05 UTC (rev 508)
+++ branches/rpy_nextgen/rpy/rinterface/tests/test_SexpEnvironment.py
2008-05-05 03:26:35 UTC (rev 509)
@@ -3,7 +3,7 @@
try:
#FIXME: can starting and stopping an embedded R be done several times ?
- rinterface.initEmbeddedR("foo", "--vanilla", "--no-save", "--quiet")
+ rinterface.initEmbeddedR()
except:
pass
Modified: branches/rpy_nextgen/rpy/rinterface/tests/test_SexpVector.py
===================================================================
--- branches/rpy_nextgen/rpy/rinterface/tests/test_SexpVector.py
2008-04-29 09:03:05 UTC (rev 508)
+++ branches/rpy_nextgen/rpy/rinterface/tests/test_SexpVector.py
2008-05-05 03:26:35 UTC (rev 509)
@@ -1,10 +1,10 @@
import unittest
import sys
-import rpy2.rinterface as rinterface
+import rpy2.rinterface as ri
try:
#FIXME: can starting and stopping an embedded R be done several times ?
- rinterface.initEmbeddedR("foo", "--vanilla", "--no-save", "--quiet")
+ ri.initEmbeddedR()
except:
pass
@@ -13,74 +13,74 @@
class SexpVectorTestCase(unittest.TestCase):
#def setUpt(self):
- # rinterface.initEmbeddedR("foo", "--no-save")
+ # ri.initEmbeddedR("foo", "--no-save")
#def tearDown(self):
- # rinterface.endEmbeddedR(1);
+ # ri.endEmbeddedR(1);
def testMissinfType(self):
- self.assertRaises(ValueError, rinterface.SexpVector, [2, ])
+ self.assertRaises(ValueError, ri.SexpVector, [2, ])
def testNewBool(self):
- sexp = rinterface.SexpVector([True, ], rinterface.LGLSXP)
- isLogical = rinterface.globalEnv.get("is.logical")
+ sexp = ri.SexpVector([True, ], ri.LGLSXP)
+ isLogical = ri.globalEnv.get("is.logical")
ok = isLogical(sexp)[0]
self.assertTrue(ok)
self.assertTrue(sexp[0])
- sexp = rinterface.SexpVector(["a", ], rinterface.LGLSXP)
- isLogical = rinterface.globalEnv.get("is.logical")
+ sexp = ri.SexpVector(["a", ], ri.LGLSXP)
+ isLogical = ri.globalEnv.get("is.logical")
ok = isLogical(sexp)[0]
self.assertTrue(ok)
self.assertTrue(sexp[0])
def testNewInt(self):
- sexp = rinterface.SexpVector([1, ], rinterface.INTSXP)
- isInteger = rinterface.globalEnv.get("is.integer")
+ sexp = ri.SexpVector([1, ], ri.INTSXP)
+ isInteger = ri.globalEnv.get("is.integer")
ok = isInteger(sexp)[0]
self.assertTrue(ok)
- sexp = rinterface.SexpVector(["a", ], rinterface.INTSXP)
- isNA = rinterface.globalEnv.get("is.na")
+ sexp = ri.SexpVector(["a", ], ri.INTSXP)
+ isNA = ri.globalEnv.get("is.na")
ok = isNA(sexp)[0]
self.assertTrue(ok)
def testNewReal(self):
- sexp = rinterface.SexpVector([1.0, ], rinterface.REALSXP)
- isNumeric = rinterface.globalEnv.get("is.numeric")
+ sexp = ri.SexpVector([1.0, ], ri.REALSXP)
+ isNumeric = ri.globalEnv.get("is.numeric")
ok = isNumeric(sexp)[0]
self.assertTrue(ok)
- sexp = rinterface.SexpVector(["a", ], rinterface.REALSXP)
- isNA = rinterface.globalEnv.get("is.na")
+ sexp = ri.SexpVector(["a", ], ri.REALSXP)
+ isNA = ri.globalEnv.get("is.na")
ok = isNA(sexp)[0]
self.assertTrue(ok)
def testNewComplex(self):
- sexp = rinterface.SexpVector([1.0 + 1.0j, ], rinterface.CPLXSXP)
- isComplex = rinterface.globalEnv.get("is.complex")
+ sexp = ri.SexpVector([1.0 + 1.0j, ], ri.CPLXSXP)
+ isComplex = ri.globalEnv.get("is.complex")
ok = isComplex(sexp)[0]
self.assertTrue(ok)
def testNewString(self):
- sexp = rinterface.SexpVector(["abc", ], rinterface.STRSXP)
- isCharacter = rinterface.globalEnv.get("is.character")
+ sexp = ri.SexpVector(["abc", ], ri.STRSXP)
+ isCharacter = ri.globalEnv.get("is.character")
ok = isCharacter(sexp)[0]
self.assertTrue(ok)
- sexp = rinterface.SexpVector([1, ], rinterface.STRSXP)
- isCharacter = rinterface.globalEnv.get("is.character")
+ sexp = ri.SexpVector([1, ], ri.STRSXP)
+ isCharacter = ri.globalEnv.get("is.character")
ok = isCharacter(sexp)[0]
self.assertTrue(ok)
def testNewVector(self):
- sexp_char = rinterface.SexpVector(["abc", ],
- rinterface.STRSXP)
- sexp_int = rinterface.SexpVector([1, ],
- rinterface.INTSXP)
- sexp = rinterface.SexpVector([sexp_char, sexp_int],
- rinterface.VECSXP)
- isList = rinterface.globalEnv.get("is.list")
+ sexp_char = ri.SexpVector(["abc", ],
+ ri.STRSXP)
+ sexp_int = ri.SexpVector([1, ],
+ ri.INTSXP)
+ sexp = ri.SexpVector([sexp_char, sexp_int],
+ ri.VECSXP)
+ isList = ri.globalEnv.get("is.list")
ok = isList(sexp)[0]
self.assertTrue(ok)
@@ -88,109 +88,110 @@
def testNew_InvalidType(self):
- self.assertRaises(ValueError, rinterface.SexpVector, [1, ], -1)
- self.assertRaises(ValueError, rinterface.SexpVector, [1, ], 250)
+ self.assertRaises(ValueError, ri.SexpVector, [1, ], -1)
+ self.assertRaises(ValueError, ri.SexpVector, [1, ], 250)
def testGetItem(self):
- letters_R = rinterface.globalEnv.get("letters")
- self.assertTrue(isinstance(letters_R, rinterface.SexpVector))
+ letters_R = ri.globalEnv.get("letters")
+ self.assertTrue(isinstance(letters_R, ri.SexpVector))
letters = (('a', 0), ('b', 1), ('c', 2), ('x', 23), ('y', 24), ('z',
25))
for l, i in letters:
self.assertTrue(letters_R[i] == l)
- Rlist = rinterface.globalEnv.get("list")
- seq_R = rinterface.globalEnv.get("seq")
+ Rlist = ri.globalEnv.get("list")
+ seq_R = ri.globalEnv.get("seq")
- mySeq = seq_R(rinterface.SexpVector([0, ], rinterface.INTSXP),
- rinterface.SexpVector([10, ], rinterface.INTSXP))
+ mySeq = seq_R(ri.SexpVector([0, ], ri.INTSXP),
+ ri.SexpVector([10, ], ri.INTSXP))
myList = Rlist(s=mySeq, l=letters_R)
- idem = rinterface.globalEnv.get("identical")
+ idem = ri.globalEnv.get("identical")
self.assertTrue(idem(mySeq, myList[0]))
self.assertTrue(idem(letters_R, myList[1]))
def testGetItemOutOfBound(self):
- myVec = rinterface.SexpVector([0, 1, 2, 3, 4, 5], rinterface.INTSXP)
+ myVec = ri.SexpVector([0, 1, 2, 3, 4, 5], ri.INTSXP)
self.assertRaises(IndexError, myVec.__getitem__, 10)
- if (sys.maxint > rinterface.R_LEN_T_MAX):
+ if (sys.maxint > ri.R_LEN_T_MAX):
self.assertRaises(IndexError, myVec.__getitem__,
- rinterface.R_LEN_T_MAX+1)
+ ri.R_LEN_T_MAX+1)
def testAssignItemDifferentType(self):
- c_R = rinterface.globalEnv.get("c")
- myVec = c_R(rinterface.SexpVector([0, 1, 2, 3, 4, 5],
rinterface.INTSXP))
+ c_R = ri.globalEnv.get("c")
+ myVec = c_R(ri.SexpVector([0, 1, 2, 3, 4, 5], ri.INTSXP))
#import pdb; pdb.set_trace()
self.assertRaises(ValueError, myVec.__setitem__, 0,
- rinterface.SexpVector(["a", ], rinterface.STRSXP))
+ ri.SexpVector(["a", ], ri.STRSXP))
def testAssignItemOutOfBound(self):
- c_R = rinterface.globalEnv.get("c")
- myVec = c_R(rinterface.SexpVector([0, 1, 2, 3, 4, 5],
rinterface.INTSXP))
+ c_R = ri.globalEnv.get("c")
+ myVec = c_R(ri.SexpVector([0, 1, 2, 3, 4, 5], ri.INTSXP))
self.assertRaises(IndexError, myVec.__setitem__, 10,
- rinterface.SexpVector([1, ], rinterface.INTSXP))
+ ri.SexpVector([1, ], ri.INTSXP))
def testAssignItemInt(self):
- c_R = rinterface.globalEnv.get("c")
- myVec = c_R(rinterface.SexpVector([0, 1, 2, 3, 4, 5],
rinterface.INTSXP))
- myVec[0] = rinterface.SexpVector([100, ], rinterface.INTSXP)
+ c_R = ri.globalEnv.get("c")
+ myVec = c_R(ri.SexpVector([0, 1, 2, 3, 4, 5], ri.INTSXP))
+ myVec[0] = ri.SexpVector([100, ], ri.INTSXP)
self.assertTrue(myVec[0] == 100)
- myVec[3] = rinterface.SexpVector([100, ], rinterface.INTSXP)
+ myVec[3] = ri.SexpVector([100, ], ri.INTSXP)
self.assertTrue(myVec[3] == 100)
def testAssignItemReal(self):
- c_R = rinterface.globalEnv.get("c")
- myVec = c_R(rinterface.SexpVector([0.0, 1.0, 2.0, 3.0, 4.0, 5.0],
- rinterface.REALSXP))
- myVec[0] = rinterface.SexpVector([100.0, ], rinterface.REALSXP)
+ c_R = ri.globalEnv.get("c")
+ myVec = c_R(ri.SexpVector([0.0, 1.0, 2.0, 3.0, 4.0, 5.0],
+ ri.REALSXP))
+ myVec[0] = ri.SexpVector([100.0, ], ri.REALSXP)
self.assertTrue(floatEqual(myVec[0], 100.0))
- myVec[3] = rinterface.SexpVector([100.0, ], rinterface.REALSXP)
+ myVec[3] = ri.SexpVector([100.0, ], ri.REALSXP)
self.assertTrue(floatEqual(myVec[3], 100.0))
def testAssignItemLogical(self):
- c_R = rinterface.globalEnv.get("c")
- myVec = c_R(rinterface.SexpVector([True, False, True, True, False],
- rinterface.LGLSXP))
- myVec[0] = rinterface.SexpVector([False, ], rinterface.LGLSXP)
+ c_R = ri.globalEnv.get("c")
+ myVec = c_R(ri.SexpVector([True, False, True, True, False],
+ ri.LGLSXP))
+ myVec[0] = ri.SexpVector([False, ], ri.LGLSXP)
self.assertFalse(myVec[0])
- myVec[3] = rinterface.SexpVector([False, ], rinterface.LGLSXP)
+ myVec[3] = ri.SexpVector([False, ], ri.LGLSXP)
self.assertFalse(myVec[3])
def testAssignItemComplex(self):
- c_R = rinterface.globalEnv.get("c")
- myVec = c_R(rinterface.SexpVector([1.0+2.0j, 2.0+2.0j, 3.0+2.0j,
4.0+2.0j, 5.0+2.0j],
- rinterface.CPLXSXP))
- myVec[0] = rinterface.SexpVector([100.0+200.0j, ], rinterface.CPLXSXP)
+ c_R = ri.globalEnv.get("c")
+ myVec = c_R(ri.SexpVector([1.0+2.0j, 2.0+2.0j, 3.0+2.0j, 4.0+2.0j,
5.0+2.0j],
+ ri.CPLXSXP))
+ myVec[0] = ri.SexpVector([100.0+200.0j, ], ri.CPLXSXP)
self.assertTrue(floatEqual(myVec[0].real, 100.0))
self.assertTrue(floatEqual(myVec[0].imag, 200.0))
- myVec[3] = rinterface.SexpVector([100.0+200.0j, ], rinterface.CPLXSXP)
+ myVec[3] = ri.SexpVector([100.0+200.0j, ], ri.CPLXSXP)
self.assertTrue(floatEqual(myVec[3].real, 100.0))
self.assertTrue(floatEqual(myVec[3].imag, 200.0))
def testAssignItemList(self):
- myVec = rinterface.SexpVector([rinterface.SexpVector(["a", ],
rinterface.STRSXP),
- rinterface.SexpVector([1, ],
rinterface.INTSXP),
- rinterface.SexpVector([3, ],
rinterface.INTSXP)],
- rinterface.VECSXP)
+ myVec = ri.SexpVector([ri.SexpVector(["a", ], ri.STRSXP),
+ ri.SexpVector([1, ], ri.INTSXP),
+ ri.SexpVector([3, ], ri.INTSXP)],
+ ri.VECSXP)
- myVec[0] = rinterface.SexpVector([rinterface.SexpVector([100.0, ],
rinterface.REALSXP), ],
- rinterface.VECSXP)
+ myVec[0] = ri.SexpVector([ri.SexpVector([100.0, ],
+ri.REALSXP), ],
+ ri.VECSXP)
self.assertTrue(floatEqual(myVec[0][0][0], 100.0))
- myVec[2] = rinterface.SexpVector([rinterface.SexpVector(["a", ],
rinterface.STRSXP), ],
- rinterface.VECSXP)
+ myVec[2] = ri.SexpVector([ri.SexpVector(["a", ], ri.STRSXP), ],
+ ri.VECSXP)
self.assertTrue(myVec[2][0][0] == "a")
def testAssignItemString(self):
- letters_R = rinterface.SexpVector("abcdefghij", rinterface.STRSXP)
- self.assertRaises(ValueError, letters_R.__setitem__, 0,
rinterface.SexpVector([1, ],
-
rinterface.INTSXP))
+ letters_R = ri.SexpVector("abcdefghij", ri.STRSXP)
+ self.assertRaises(ValueError, letters_R.__setitem__, 0,
ri.SexpVector([1, ],
+
ri.INTSXP))
- letters_R[0] = rinterface.SexpVector(["z", ], rinterface.STRSXP)
+ letters_R[0] = ri.SexpVector(["z", ], ri.STRSXP)
self.assertTrue(letters_R[0] == "z")
def suite():
Modified: branches/rpy_nextgen/rpy/rinterface/tests/test_SexpVectorNumeric.py
===================================================================
--- branches/rpy_nextgen/rpy/rinterface/tests/test_SexpVectorNumeric.py
2008-04-29 09:03:05 UTC (rev 508)
+++ branches/rpy_nextgen/rpy/rinterface/tests/test_SexpVectorNumeric.py
2008-05-05 03:26:35 UTC (rev 509)
@@ -6,7 +6,7 @@
try:
#FIXME: can starting and stopping an embedded R be done several times ?
- rinterface.initEmbeddedR("foo", "--vanilla", "--no-save", "--quiet")
+ rinterface.initEmbeddedR()
except:
pass
Modified: branches/rpy_nextgen/rpy/robjects/__init__.py
===================================================================
--- branches/rpy_nextgen/rpy/robjects/__init__.py 2008-04-29 09:03:05 UTC
(rev 508)
+++ branches/rpy_nextgen/rpy/robjects/__init__.py 2008-05-05 03:26:35 UTC
(rev 509)
@@ -77,13 +77,13 @@
self._sexp = rinterface.Sexp(sexp, copy=copy)
def __str__(self):
- tmp = r.fifo("")
- r.sink(tmp)
+ tmp = baseNameSpaceEnv["fifo"]("")
+ baseNameSpaceEnv["sink"](tmp)
r.show(self)
- r.sink()
- s = r.readLines(tmp)
+ baseNameSpaceEnv["sink"]()
+ s = baseNameSpaceEnv["readLines"](tmp)
r.close(tmp)
- s = str.join(os.linesep, self)
+ s = str.join(os.linesep, s)
return s
def __repr__(self):
@@ -181,8 +181,13 @@
def __len__(self):
return len(self.getSexp())
+ def getNames(self):
+ res = r.names(self.getSexp())
+ import pdb; pdb.set_trace()
+ return res
+
class RArray(Rvector):
-
+ """ An R array """
def __init__(self, o):
super(RArray, self).__init__(o)
if not r["is.array"](self.getSexp())[0]:
@@ -199,20 +204,25 @@
value = mapperPy2R
res = r["dim<-"](value)
+
class RMatrix(RArray):
-
+ """ An R matrix """
+
def nrow(self):
""" Number of rows """
- return r.nrow(self.getSexp())
+ return self.dim[0]
def ncol(self):
""" Number of columns """
- return r.nrow(self.getSexp())
+ return self.dim[1]
class DataFrame(Rvector):
#FIXME: not implemented
def __init__(self, o):
- raise(RuntimeError("Not implemented."))
+ if not isinstance(o, rinterface.SexpVector):
+ o = mapperPy2R(o)
+ o = o.getSexp()
+ self._sexp = o
@@ -276,10 +286,9 @@
class R(object):
_instance = None
- def __init__(self, options):
+ def __init__(self):
if R._instance is None:
- args = ["robjects", ] + options
- rinterface.initEmbeddedR(*args)
+ rinterface.initEmbeddedR()
R._instance = self
else:
raise(ValueError("Only one instance of R can be created"))
@@ -307,7 +316,7 @@
res = self.eval(p)
return res
-r = R(["--no-save", "--quiet"])
+r = R()
globalEnv = mapperR2Py(rinterface.globalEnv)
baseNameSpaceEnv = mapperR2Py(rinterface.baseNameSpaceEnv)
Modified: branches/rpy_nextgen/rpy/robjects/tests/testRVector.py
===================================================================
--- branches/rpy_nextgen/rpy/robjects/tests/testRVector.py 2008-04-29
09:03:05 UTC (rev 508)
+++ branches/rpy_nextgen/rpy/robjects/tests/testRVector.py 2008-05-05
03:26:35 UTC (rev 509)
@@ -1,25 +1,25 @@
import unittest
import rpy2.robjects as robjects
-rinterface = robjects.rinterface
+ri = robjects.rinterface
import array
rlist = robjects.baseNameSpaceEnv["list"]
class RvectorTestCase(unittest.TestCase):
def testNew(self):
- identical = rinterface.baseNameSpaceEnv["identical"]
+ identical = ri.baseNameSpaceEnv["identical"]
py_a = array.array('i', [1,2,3])
ro_v = robjects.Rvector(py_a)
- self.assertEquals(ro_v.typeof(), rinterface.INTSXP)
+ self.assertEquals(ro_v.typeof(), ri.INTSXP)
- ri_v = rinterface.SexpVector(py_a, rinterface.INTSXP)
+ ri_v = ri.SexpVector(py_a, ri.INTSXP)
ro_v = robjects.Rvector(ri_v)
self.assertTrue(identical(ro_v._sexp, ri_v)[0])
#FIXME: why isn't this working ?
#del(ri_v)
- self.assertEquals(rinterface.INTSXP, ro_v.typeof())
+ self.assertEquals(ri.INTSXP, ro_v.typeof())
def testOperators(self):
seq_R = robjects.r["seq"]
@@ -67,6 +67,16 @@
self.assertTrue(idem(letters, mylist[0]))
self.assertTrue(idem("foo", mylist[1]))
+ def testGetNames(self):
+ vec = robjects.Rvector(array.array('i', [1,2,3]))
+ v_names = [robjects.baseNameSpaceEnv["letters"][x] for x in (0,1,2)]
+ #FIXME: simplify this
+ r_names = robjects.baseNameSpaceEnv["c"](*v_names)
+ robjects.r["names<-"](vec, r_names)
+
+ for i in xrange(len(vec)):
+ self.assertEquals(v_names[i], vec.getNames()[i])
+
def suite():
suite = unittest.TestLoader().loadTestsFromTestCase(RvectorTestCase)
return suite
This was sent by the SourceForge.net collaborative development platform, the
world's largest Open Source development site.
-------------------------------------------------------------------------
This SF.net email is sponsored by the 2008 JavaOne(SM) Conference
Don't miss this year's exciting event. There's still time to save $100.
Use priority code J8TL2D2.
http://ad.doubleclick.net/clk;198757673;13503038;p?http://java.sun.com/javaone
_______________________________________________
rpy-list mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/rpy-list
