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])