def testAssignItemOutOfBound(self):
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,
ri.SexpVector([
1,
], ri.INTSXP))
def py2rpy(obj):
if isinstance(obj, int):
robj = ri.SexpVector([
obj,
], ri.INTSXP)
return robj
if isinstance(obj, float):
robj = ri.SexpVector([
obj,
], ri.REALSXP)
return robj
if isinstance(obj, str):
robj = ri.SexpVector([
obj,
], ri.STRSXP)
return robj
if isinstance(obj, complex):
robj = ri.SexpVector([
obj,
], ri.CPLSXP)
return robj
if isinstance(obj, list) or isinstance(obj, tuple):
robj = seq2vec(obj)
return robj
raise ValueError("Don't know what to do with 'obj'.")
def int2ri(obj):
# special case for NA_Logical
if obj is rinterface.NA_Logical:
res = rinterface.SexpVector([obj, ], rinterface.LGLSXP)
else:
res = rinterface.SexpVector([obj, ], rinterface.INTSXP)
return res
def testAssignItemList(self):
myVec = ri.SexpVector([
ri.StrSexpVector([
"a",
]),
ri.IntSexpVector([
1,
]),
ri.IntSexpVector([
3,
])
], ri.VECSXP)
myVec[0] = ri.SexpVector([
ri.FloatSexpVector([
100.0,
]),
], ri.VECSXP)
self.assertTrue(floatEqual(myVec[0][0][0], 100.0))
myVec[2] = ri.SexpVector([
ri.StrSexpVector([
"a",
]),
], ri.VECSXP)
self.assertTrue(myVec[2][0][0] == "a")
def testGetItem(self):
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 = ri.globalenv.get("list")
seq_R = ri.globalenv.get("seq")
mySeq = seq_R(ri.SexpVector([
0,
], ri.INTSXP), ri.SexpVector([
10,
], ri.INTSXP))
myList = Rlist(s=mySeq, l=letters_R)
idem = ri.globalenv.get("identical")
self.assertTrue(idem(mySeq, myList[0]))
self.assertTrue(idem(letters_R, myList[1]))
letters_R = ri.globalenv.get("letters")
self.assertEqual('z', letters_R[-1])
def testAssignItemDifferentType(self):
c_R = ri.globalenv.get("c")
myVec = c_R(ri.SexpVector([0, 1, 2, 3, 4, 5], ri.INTSXP))
self.assertRaises(ValueError, myVec.__setitem__, 0,
ri.SexpVector([
"a",
], ri.STRSXP))
def _(obj):
if obj.typecode in ('h', 'H', 'i', 'I'):
res = rinterface.SexpVector(obj, rinterface.INTSXP)
elif obj.typecode in ('f', 'd'):
res = rinterface.SexpVector(obj, rinterface.REALSXP)
else:
raise(ValueError("Nothing can be done for this array type at the moment."))
return res
def testAssignItemString(self):
letters_R = ri.SexpVector("abcdefghij", ri.STRSXP)
self.assertRaises(ValueError, letters_R.__setitem__, 0,
ri.SexpVector([1, ],
ri.INTSXP))
letters_R[0] = ri.SexpVector(["z", ], ri.STRSXP)
self.assertTrue(letters_R[0] == "z")
def testAssignItemReal(self):
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] = ri.SexpVector([100.0, ], ri.REALSXP)
self.assertTrue(floatEqual(myVec[3], 100.0))
def testAssignItemLogical(self):
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] = ri.SexpVector([False, ], ri.LGLSXP)
self.assertFalse(myVec[3])
def testNewInt(self):
sexp = ri.SexpVector([1, ], ri.INTSXP)
isInteger = ri.globalenv.get("is.integer")
ok = isInteger(sexp)[0]
self.assertTrue(ok)
sexp = ri.SexpVector(["a", ], ri.INTSXP)
isNA = ri.globalenv.get("is.na")
ok = isNA(sexp)[0]
self.assertTrue(ok)
def testNewReal(self):
sexp = ri.SexpVector([1.0, ], ri.REALSXP)
isNumeric = ri.globalenv.get("is.numeric")
ok = isNumeric(sexp)[0]
self.assertTrue(ok)
sexp = ri.SexpVector(["a", ], ri.REALSXP)
isNA = ri.globalenv.get("is.na")
ok = isNA(sexp)[0]
self.assertTrue(ok)
def testNewString(self):
sexp = ri.SexpVector(["abc", ], ri.STRSXP)
isCharacter = ri.globalenv.get("is.character")
ok = isCharacter(sexp)[0]
self.assertTrue(ok)
sexp = ri.SexpVector([1, ], ri.STRSXP)
isCharacter = ri.globalenv.get("is.character")
ok = isCharacter(sexp)[0]
self.assertTrue(ok)
def testMissingArg(self):
parse = rinterface.baseenv["parse"]
exp = parse(text=rinterface.SexpVector(["function(x) { missing(x) }"],
rinterface.STRSXP))
fun = rinterface.baseenv["eval"](exp)
nonmissing = rinterface.SexpVector([
0,
], rinterface.INTSXP)
missing = rinterface.MissingArg
self.assertEquals(False, fun(nonmissing)[0])
self.assertEquals(True, fun(missing)[0])
def testAssignItemInt(self):
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] = ri.SexpVector([100, ], ri.INTSXP)
self.assertTrue(myVec[3] == 100)
myVec[-1] = ri.SexpVector([200, ], ri.INTSXP)
self.assertTrue(myVec[5] == 200)
def testRpyMemory(self):
x = rinterface.SexpVector(range(10), rinterface.INTSXP)
y = rinterface.SexpVector(range(10), rinterface.INTSXP)
x_rid = x.rid
self.assertTrue(x_rid in set(z[0]
for z in rinterface.protected_rids()))
del (x)
gc.collect()
gc.collect()
self.assertFalse(x_rid in set(z[0]
for z in rinterface.protected_rids()))
def testDel(self):
env = rinterface.globalenv.get("new.env")()
env["a"] = rinterface.SexpVector([
123,
], rinterface.INTSXP)
env["b"] = rinterface.SexpVector([
456,
], rinterface.INTSXP)
self.assertEqual(2, len(env))
del (env['a'])
self.assertEqual(1, len(env))
self.assertTrue('b' in env)
def testCallS4SetClass(self):
# R's package "methods" can perform uncommon operations
r_setClass = rinterface.globalenv.get('setClass')
r_representation = rinterface.globalenv.get('representation')
attrnumeric = rinterface.SexpVector([
"numeric",
], rinterface.STRSXP)
classname = rinterface.SexpVector([
'Track',
], rinterface.STRSXP)
classrepr = r_representation(x=attrnumeric, y=attrnumeric)
r_setClass(classname, classrepr)
def testNewBool(self):
sexp = ri.SexpVector([True, ], ri.LGLSXP)
isLogical = ri.globalenv.get("is.logical")
ok = isLogical(sexp)[0]
self.assertTrue(ok)
self.assertTrue(sexp[0])
sexp = ri.SexpVector(["a", ], ri.LGLSXP)
isLogical = ri.globalenv.get("is.logical")
ok = isLogical(sexp)[0]
self.assertTrue(ok)
self.assertTrue(sexp[0])
def testAssignItemComplex(self):
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] = 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 testNewVector(self):
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)
self.assertEqual(2, len(sexp))
def testLength(self):
newEnv = rinterface.globalenv.get("new.env")
env = newEnv()
self.assertEqual(0, len(env))
env["a"] = rinterface.SexpVector([
123,
], rinterface.INTSXP)
self.assertEqual(1, len(env))
env["b"] = rinterface.SexpVector([
123,
], rinterface.INTSXP)
self.assertEqual(2, len(env))
def default_py2ri(o):
""" Convert arbitrary Python object to :class:`rpy2.rinterface.Sexp` to objects,
creating an R object with the content of the Python object in the process
(wich means data copying).
:param o: object
:rtype: :class:`rpy2.rinterface.Sexp` (and subclasses)
"""
if isinstance(o, RObject):
res = rinterface.Sexp(o)
if isinstance(o, Sexp):
res = o
elif isinstance(o, array.array):
if o.typecode in ('h', 'H', 'i', 'I'):
res = rinterface.SexpVector(o, rinterface.INTSXP)
elif o.typecode in ('f', 'd'):
res = rinterface.SexpVector(o, rinterface.REALSXP)
else:
raise (ValueError(
"Nothing can be done for this array type at the moment."))
elif isinstance(o, bool):
res = rinterface.SexpVector([
o,
], rinterface.LGLSXP)
elif isinstance(o, int) or isinstance(o, long):
# special case for NA_Logical
if o is rinterface.NA_Logical:
res = rinterface.SexpVector([
o,
], rinterface.LGLSXP)
else:
res = rinterface.SexpVector([
o,
], rinterface.INTSXP)
elif isinstance(o, float):
res = rinterface.SexpVector([
o,
], rinterface.REALSXP)
elif isinstance(o, str):
res = rinterface.SexpVector([
o,
], rinterface.STRSXP)
elif isinstance(o, unicode):
res = rinterface.SexpVector([
o,
], rinterface.STRSXP)
elif isinstance(o, list):
res = r.list(*[conversion.ri2py(conversion.py2ri(x)) for x in o])
elif isinstance(o, complex):
res = rinterface.SexpVector([
o,
], rinterface.CPLXSXP)
else:
raise (ValueError(
"Nothing can be done for the type %s at the moment." % (type(o))))
return res
def testKeys(self):
newEnv = rinterface.globalenv.get("new.env")
env = newEnv()
env["a"] = rinterface.SexpVector([
123,
], rinterface.INTSXP)
env["b"] = rinterface.SexpVector([
456,
], rinterface.INTSXP)
symbols = env.keys()
self.assertEqual(2, len(symbols))
for s in ["a", "b"]:
self.assertTrue(s in symbols)
def testClosureenv(self):
exp = rinterface.parse("function(x) { x[y] }")
fun = rinterface.baseenv["eval"](exp)
vec = rinterface.baseenv["letters"]
self.assertRaises(rinterface.RRuntimeError, fun, vec)
fun.closureenv["y"] = rinterface.SexpVector([
1,
], rinterface.INTSXP)
self.assertEqual('a', fun(vec)[0])
fun.closureenv["y"] = rinterface.SexpVector([
2,
], rinterface.INTSXP)
self.assertEqual('b', fun(vec)[0])
def testNewComplex(self):
sexp = ri.SexpVector([
1.0 + 1.0j,
], ri.CPLXSXP)
isComplex = ri.globalenv.get("is.complex")
ok = isComplex(sexp)[0]
self.assertTrue(ok)
def testArrayStructComplex(self):
px = [1 + 2j, 2 + 5j, -1 + 0j]
x = rinterface.SexpVector(px, rinterface.CPLXSXP)
nx = self.numericmodule.asarray(x)
self.assertEqual(nx.dtype.kind, 'c')
for orig, new in zip(px, nx):
self.assertEqual(orig, new)
def testArrayStructBoolean(self, numericModule):
px = [True, False, True]
x = rinterface.SexpVector(px, rinterface.LGLSXP)
nx = numericModule.asarray(x)
self.assertEquals('i', nx.dtype.kind) # not 'b', see comments in array.c
for orig, new in itertools.izip(px, nx):
self.assertEquals(orig, new)
def foo(queue):
import rpy2.rinterface as rinterface
rinterface.endr(1)
try:
tmp = ri.SexpVector([1, 2], ri.INTSXP)
res = (False, None)
except RuntimeError, re:
res = (True, re)
def testNewUnicode(self):
sexp = ri.SexpVector([
u'abc',
], ri.STRSXP)
isCharacter = ri.globalenv.get("is.character")
ok = isCharacter(sexp)[0]
self.assertTrue(ok)
self.assertEqual('abc', sexp[0])
