def __init__(self, structure, family, param1, param2=None): self.structure = structure self.family = family self.param1 = param1 self.param2 = param2 ri.initr() self.build_vine()
def analyze_log_file_in_phases(file_id, nstates, trials, iter): print_n_flush("Starting phase by phase analysis...") # id_to_log = lambda x: "logs/%s.exp.log" % x filename_log = id_to_log(file_id) responses, tests, responses_t, tests_t, images = toCSV(filename_log) from IPython.parallel import Client # from functools import partial from rpy2.rinterface import initr rinterface.set_initoptions(("--max-ppsize=100000")) initr() client = Client(profile="default") # client[:].push(dict(initr=initr)) # client[:].apply_sync(lambda: initr()) lview = client.load_balanced_view() # default load-balanced view lview.block = True # func = lambda args: train_hmm_n_times(file_id=args[0], nstates=args[1], trials=args[2], iter=args[3]) # trials = 4 client[:].push(dict(train_hmm_once=train_hmm_once)) # args = [(file_id, nstates, trials, 1000) for nstates in range(5,10)] # results = lview.map(func, args)# hmm, d, results = train_hmm_n_times(file_id, nstates, trials=20, iter=1000) # pool.join() results = {} for i in range(3): results[i] = train_hmm_n_times(file_id, nstates=nstates, trials=trials, iter=iter, phase=i) return results
def plot(self, data_array, width, height): """ Create a plot with R """ # Start R timing startTime = time.time() rinterface.initr() r = robjects.r grdevices = importr('grDevices') # Import the bfast package bfast = importr('bfast') b = robjects.FloatVector(data_array) # arry by b to time serie vector b_ts = r.ts(b, start=robjects.IntVector([2000, 4]), frequency=23) # calculate bfast h = 23.0 / float(len(b_ts)) b_bfast = r.bfast(b_ts, h=h, season="harmonic", max_iter=2) # Get the index names of the ListVector b_bfast names = b_bfast.names log.debug(names) temp_datadir = self.config.get('main', 'temp.datadir') temp_url = self.config.get('main', 'temp.url') file = NamedTemporaryFile(suffix=".png", dir=temp_datadir, delete=False) log.debug(file.name) grdevices.png(file=file.name, width=width, height=height) # Plotting code here r.par(col="black") r.plot(b_bfast) # Close the device grdevices.dev_off() # End R timing and log it endTime = time.time() log.debug('It took ' + str(endTime - startTime) + ' seconds to initalize R and draw a plot.') file.close() result = {"file": "%s/%s" % (temp_url, file.name.split("/")[-1])} try: result['magnitude'] = str(tuple(b_bfast[names.index("Magnitude")])[0]) except ValueError: pass try: result['time'] = str(tuple(b_bfast[names.index("Time")])[0]) except ValueError: pass self.outputs['plot']['value'] = json.dumps({"file": "%s/%s" % (temp_url, file.name.split("/")[-1])}) return SERVICE_SUCCEEDED
def volnd_data_to_r(data): """ Convert a volnd data object to an R object """ rinterface.initr() dn = [] for i in data.dims: dn.append([str(x) for x in i]) return ma_to_r(data.vals, dimnames=dn)
def getRasterValues(lon, lat, layer, buffervalue): startTime = time.time() rinterface.initr() r = robjects.r r.require('raster') ras = r.raster(layer) rasvalues = r.extract(ras, r.cbind(lon,lat), buffer=buffervalue, small=True) values = npri.ri2numpy(rasvalues[0]) endTime = time.time() print(str(endTime - startTime)) return values
def run(self): sample1 = pickle.load( gzip.open(self.sampleobjfile1, "rb") ) sample2 = pickle.load( gzip.open(self.sampleobjfile2, "rb") ) print self.size, os.path.basename(self.sampleobjfile1).split('.')[0], sample1.total, os.path.basename(self.sampleobjfile2).split('.')[0], sample2.total #sampling "size" sequences from sample: subsample1 = iseqlib.samplingSample( sample1, self.size ) #sampled sample subsample2 = iseqlib.samplingSample( sample2, self.size ) #sampled sample #Get different statistics: stats = PairSamplingStats() #initialize stats for the current subsample #Find Sizes of the Union of clones between subsample1 and subsample2: counts1 = [] counts2 = [] for header, seq in subsample1.seqs.iteritems(): counts1.append( seq.count ) if header in subsample2.seqs: counts2.append( subsample2.seqs[header].count ) else: counts2.append( 0 ) for header, seq in subsample2.seqs.iteritems(): if header not in subsample1.seqs: counts1.append( 0 ) counts2.append( seq.count ) if len(counts1) != len(counts2): raise ValueError("The count vectors of two compared samples must have equal length. Found %d and %d\n" %(len(counts1), len(counts2))) ## Initialize the R interface import rpy2.rinterface as rinterface rinterface.set_initoptions(('rpy2', '--no-save')) rinterface.initr() import rpy2.robjects as robjs from rpy2.robjects.packages import importr vegan = importr('vegan') vegdist = vegan.vegdist counts = counts1 counts.extend(counts2) rcountsVec = robjs.IntVector( counts ) #convert python list into R vector rcountsMatrix = robjs.r['matrix'](rcountsVec, nrow = 2, byrow=True) #indices = ['bray', 'horn', 'mountford', 'chao'] indices = self.options.similarityIndices #"manhattan", "euclidean", "canberra", "bray", "kulczynski", "jaccard", "gower", "morisita", "horn", "mountford", "raup" , "binomial" or "chao" for index in indices: disimilarity = vegdist( rcountsMatrix, method=index ) stats[index] = disimilarity[0] #Write to temp file: picklefile = os.path.join( self.outdir, "%d.pickle" % self.id) pickle.dump( stats, gzip.open(picklefile, "wb") )
def usage (fname): R.initr () fname = R.StrSexpVector ([fname]) try: location = R.globalEnv.get ('help') (fname)[0] except IndexError: raise RuntimeError ('Function not found') file = open (location) m = search ('_\x08U_\x08s_\x08a_\x08g_\x08e:\n([^\x08]+)(?=_)', file.read ()) if m is None: raise RuntimeError ('Usage not found') else: return m.group (1)
def boxPlotData (response, data, tmpdir = '.', params = {}): R.initr () svg = R.globalEnv.get ('svg') off = R.globalEnv.get ('graphics.off') boxplot = R.globalEnv.get ('boxplot') vectors = [] for dataList in data: vectors.append (R.FloatSexpVector (dataList)) params = formatForR (params) filename = tmpdir + '/' + str(uuid4 ().int) + '.svg' svg (R.StrSexpVector([filename]), width=R.FloatSexpVector ([10.5]), height=R.FloatSexpVector ([7])) boxplot (*vectors, **params) off () cp (response, filename)
def calc_bfast(data_array): """ Calculate the BFast statistics """ # Start R timing startTime = time.time() # Initialize R rinterface.initr() r = robjects.r # Import the bfast package bfast = importr('bfast') # Create a R vector from the Python array b = robjects.FloatVector(data_array) # Create a R timeseries from R vector b_ts = r.ts(b, start=robjects.IntVector([2000, 4]), frequency=23) # Calculate BFast h = 23.0 / float(len(b_ts)) b_bfast = r.bfast(b_ts, h=h, season="harmonic", max_iter=2) # Get the "output" attribute from the BFast result output = b_bfast[b_bfast.names.index("output")] # Number of iteration nbrOfIter = len(output) # Get the break points breakpointsOutput = output.rx2(nbrOfIter).rx("bp.Vt")[0] # Get the break points as a "breakpoints" R object, see also: # http://cran.r-project.org/web/packages/strucchange/strucchange.pdf#Rfn.breakpoints breakpoints = breakpointsOutput[breakpointsOutput.names.index("breakpoints")] endTime = time.time() # Figure out how long the script took to run log.debug('It took ' + str(endTime - startTime) + ' seconds to calculate the BFast breakpoints.') if(breakpoints[0] == robjects.NA_Logical): return [] # Return the list of breakpoints as Python array return [int(breakpoints[b]) for b in range(len(breakpoints))]
def volnd_save_to_r(vars, file): """ Convert the result of a volnd read into various R objects, and save them to the given file """ rinterface.initr() tosave = [] for k, d in vars.items(): #print "s2r", k robjects.r.assign(k, volnd_data_to_r(d)) tosave.append(k) for aname, adata in d.attrs.items(): robjects.r.assign(k+"."+aname, volnd_data_to_r(adata)) tosave.append(k+"."+aname) tosave = robjects.vectors.StrVector(tosave) robjects.r.save(list=tosave, file=file) # Cleanup the names from the environment robjects.r.remove(list=tosave)
def create (self): R.initr () R.globalEnv['x'] = R.FloatSexpVector (self.xdata) R.globalEnv['y'] = R.FloatSexpVector (self.ydata) formula = RFormula ('y ~ x') rLine = R.globalEnv.get ('lm')(formula) slope = rLine[0][1] intercept = rLine[0][0] y1 = slope * self.currentView.min.x + intercept y2 = slope * self.currentView.max.x + intercept p1 = V (self.currentView.min.x, y1) p2 = V (self.currentView.max.x, y2) self.draw (Line (p1, p2, className='regression-line')) self.draw (Line (p1, p2, className='regression-shadow')) TransformableGroup.create (self)
def __init__ (self, xdata, ydata, xbounds, ybounds): from rpy2.robjects import RFormula from rpy2 import rinterface as R R.initr () R.globalEnv['x'] = R.FloatSexpVector (xdata) R.globalEnv['y'] = R.FloatSexpVector (ydata) formula = RFormula ('y ~ x') rLine = R.globalEnv.get ('lm')(formula) slope = rLine[0][1] intercept = rLine[0][0] y1 = slope * xbounds[0] + intercept y2 = slope * xbounds[1] + intercept p1 = (xbounds[0], y1) p2 = (xbounds[1], y2) Line.__init__ (self, point1 = p1, point2 = p2)
def run(self): sample = pickle.load( gzip.open(self.sampleobjfile, "rb") ) #sampling "size" sequences from sample: subsample = iseqlib.samplingSample( sample, self.size ) #sampled sample #Get different statistics: stats = SingleSamplingStats() #initialize stats for the current subsample #1/ Number of uniq clones: stats.uniqClones = len( subsample.seqs ) #2/ Diversity Indices counts = [ seq.count for seq in subsample.seqs.values() ] #list of clone sizes ## Initialize the R interface import rpy2.rinterface as rinterface rinterface.set_initoptions(('rpy2', '--no-save')) rinterface.initr() import rpy2.robjects as robjs from rpy2.robjects.packages import importr vegan = importr('vegan') rcounts = robjs.IntVector( counts ) #convert python list into R vector ##Diversity indices (Simpson, InverseSimpson, Shannon) indices = self.options.diversityIndices #['simpson', 'invsimpson', 'shannon'] for index in indices: if index == 'uniqClones' or index == 'fisherAlpha': continue rval = vegan.diversity( rcounts, index ) stats[index] = rval[0] ## Fisher Alpha: rfisher = vegan.fisher_alpha( rcounts ) stats.fisherAlpha = rfisher[0] #Write to temp file: picklefile = os.path.join( self.outdir, "%d.pickle" % self.id) pickle.dump( stats, gzip.open(picklefile, "wb") )
def multiRScatter (response, data, groups, tmpdir = '.', params = {}): R.initr () svg = R.globalEnv.get ('svg') off = R.globalEnv.get ('graphics.off') pairs = R.globalEnv.get ('pairs') for g in groups: dataList = [] for key, value in data: try: dataList.append (value[g]) except KeyError: dataList.append (None) R.globalEnv[str(g)] = R.FloatSexpVector (dataList) f = '~' + '+'.join (map (str, groups)) formula = RFormula (f) params = formatForR (params) filename = tmpdir + '/' + str(uuid4 ().int) + '.svg' svg (R.StrSexpVector([filename]), width=R.FloatSexpVector ([10.5]), height=R.FloatSexpVector ([7])) pairs (formula, **params) off () cp (response, filename)
#!/usr/bin/env python import os, sys, time, re, json, pdb, random, datetime, subprocess from sys import modules # third parties import numpy as np import pandas as pd import pandas.io.sql as psql from scipy import stats import psycopg2 # R interface import rpy2.robjects as robjects import rpy2.rinterface as RI import warnings warnings.filterwarnings('ignore') R = robjects.r RI.initr() # personal utilities import utils.pandas_psql as pdpsql # ------------------------------------------ # setting up the computation environment # ------------------------------------------- # the postgres database connection is made # global to avoid confusion when we # switch location try: # local postgresql database cnx = psycopg2.connect(host='localhost', database='popsfundamental', user='******')
def testCallErrorWhenEndedR(self): self.assertTrue(False) # worked when tested, but calling endEmbeddedR causes trouble t = rinterface.baseNameSpaceEnv['date'] rinterface.endr(1) self.assertRaises(RuntimeError, t) rinterface.initr()
import os, sys, time, re, json, pdb, random, datetime, subprocess from sys import modules # third parties import numpy as np import pandas as pd import pandas.io.sql as psql from scipy import stats import psycopg2 # R interface import rpy2.robjects as robjects import rpy2.rinterface as RI import warnings warnings.filterwarnings('ignore') R = robjects.r RI.initr() # personal utilities import utils.pandas_psql as pdpsql # ------------------------------------------ # setting up the computation environment # ------------------------------------------- # the postgres database connection is made # global to avoid confusion when we # switch location try: # local postgresql database cnx = psycopg2.connect(host='localhost', database='popsfundamental', user='******')
def analyze_log_file(file_id, nstates, trials, iter): # id_to_log = lambda x: "logs/%s.exp.log" % x filename_log = id_to_log(file_id) responses, tests, responses_t, tests_t, images = toCSV(filename_log) from IPython.parallel import Client # from functools import partial from rpy2.rinterface import initr try: rinterface.set_initoptions(("--max-ppsize=500000")) except RuntimeError, e: print_n_flush("Runtime error, probably redundant call to set_initoptions()") print_n_flush(e) initr() client = Client(profile="default") # client[:].push(dict(initr=initr)) # client[:].apply_sync(lambda: initr()) lview = client.load_balanced_view() # default load-balanced view lview.block = True # func = lambda args: train_hmm_n_times(file_id=args[0], nstates=args[1], trials=args[2], iter=args[3]) # trials = 4 client[:].push(dict(train_hmm_once=train_hmm_once)) # args = [(file_id, nstates, trials, 1000) for nstates in range(5,10)] # results = lview.map(func, args)# hmm, d, results = train_hmm_n_times(file_id, nstates, trials=20, iter=1000) # pool.join() results = train_hmm_n_times(file_id, nstates=nstates, trials=trials, iter=iter) return results
def _start (): if not R._running: R._running = True r.initr () R._execute = r.globalEnv.get R._library = R._execute ('library')
def __init__(self): if R._instance is None: rinterface.initr() R._instance = self else: pass
def init_r(): from rpy2 import rinterface rinterface.initr()
def __new__(cls): if cls._instance is None: rinterface.initr() cls._instance = object.__new__(cls) return cls._instance
def init_r(preserve_hash): from rpy2 import rinterface rinterface.initr(r_preservehash=preserve_hash)
def plot(self, data_array, width, height): """ Create a plot with R """ # Start R timing startTime = time.time() rinterface.initr() r = robjects.r grdevices = importr('grDevices') vector = robjects.FloatVector(data_array) temp_datadir = self.config.get('main', 'temp.datadir') temp_url = self.config.get('main', 'temp.url') file = NamedTemporaryFile(suffix=".png", dir=temp_datadir, delete=False) grdevices.png(file=file.name, width=width, height=height) ts = r.ts(vector, start=robjects.IntVector([2000, 4]), frequency=23) #r.layout(r.matrix(robjects.IntVector([1, 2, 3, 4]), ncol=1, nrow=4)) ## PLOT 1: Raw NDVI values #r.par(mar=robjects.FloatVector([0, 4, .2, 4])) # mar für die Abstände ausserhalb des plots in der Reihenfolge unten - links - oben - rechts. Oben Null, der Rest sind default-Werte r.plot(ts, type="l", axes=False, ylab="Raw NDVI value", xlab="", ylim=robjects.FloatVector([0.0, 1.0])) r.box() r.axis(2, labels=robjects.StrVector(['0.0', '0.2', '0.4', '0.6', '0.8', '1.0']), at=robjects.FloatVector([0.0, 0.2, 0.4, 0.6, 0.8, 1.0])) r.axis(1, labels=robjects.StrVector(['2000', '2002', '2004', '2006', '2008', '2010', '2012', '2014']), at=robjects.FloatVector([2000, 2002, 2004, 2006, 2008, 2010, 2012, 2014])) r.abline(v=[2000, 2002, 2004, 2006, 2008, 2010, 2012, 2014], col="lightgrey", lty=2) # vertikale linien bei jedem jahr, lty ist line type r.abline(h=robjects.FloatVector([0, 0.2000, 0.4000, 0.6000, 0.8000, 1.0000]), col="lightgrey", lty=2) ## PLOT 2: #r.par(mar=robjects.IntVector([0, 4, 0, 4])) #r.plot(ts, type="l", col="grey", axes=False, ylab="Asym Gaussian fitting", xlab="") #r.box() #r.axis(4, labels=robjects.StrVector(['0', '0.2', '0.4', '0.6', '0.8', '1']), at=robjects.FloatVector([0, 0.2, 0.4, 0.6, 0.8, 1])) #r.abline(v=[2000, 2014, 1], col="lightgrey", lty=2) #r.abline(h=robjects.FloatVector([0, 0.2000, 0.4000, 0.6000, 0.8000]), col="lightgrey", lty=2) ## PLOT 3: #r.par(mar=robjects.IntVector([0, 4, 0, 4])) #r.plot(ts, type="l", col="grey", axes=False, ylab="Double logistic fitting", xlab="") #r.box() #r.axis(2, labels=robjects.StrVector(['0', '0.2', '0.4', '0.6', '0.8', '1']), at=robjects.FloatVector([0, 0.2, 0.4, 0.6, 0.8, 1])) #r.abline(v=[2000, 2014, 1], col="lightgrey", lty=2) #r.abline(h=robjects.FloatVector([0, 0.2000, 0.4000, 0.6000, 0.8000]), col="lightgrey", lty=2) ## PLOT 4: #r.par(mar=robjects.IntVector([2, 4, 0, 4])) #r.plot(ts, type="l", col="grey", axes=False, ylab="Trends", xlab="") #r.box() #r.axis(4, labels=robjects.StrVector(['0', '0.2', '0.4', '0.6', '0.8', '1']), at=robjects.FloatVector([0, 0.2, 0.4, 0.6, 0.8, 1])) #r.axis(1, labels=robjects.StrVector(['2000', '2002', '2004', '2006', '2008', '2010', '2012', '2014']), at=robjects.FloatVector([2000, 2002, 2004, 2006, 2008, 2010, 2012, 2014])) #r.abline(v=[2000, 2014, 1], col="lightgrey", lty=2) #r.abline(h=robjects.FloatVector([0, 0.2000, 0.4000, 0.6000, 0.8000]), col="lightgrey", lty=2) # Close the device grdevices.dev_off() file.close() # End R timing and log it endTime = time.time() log.debug('It took ' + str(endTime - startTime) + ' seconds to initalize R and draw a plot.') self.outputs['plot']['value'] = json.dumps({"file": "%s/%s" % (temp_url, file.name.split("/")[-1])}) return SERVICE_SUCCEEDED
def setUp(self): # Initialized embedded R ri.initr()
import unittest import copy import gc import rpy2.rinterface as rinterface rinterface.initr() class SexpTestCase(unittest.TestCase): def testNew_invalid(self): x = "a" self.assertRaises(ValueError, rinterface.Sexp, x) def testNew(self): sexp = rinterface.globalEnv.get("letters") sexp_new = rinterface.Sexp(sexp) idem = rinterface.globalEnv.get("identical") self.assertTrue(idem(sexp, sexp_new)[0]) sexp_new2 = rinterface.Sexp(sexp) self.assertTrue(idem(sexp, sexp_new2)[0]) del(sexp) self.assertTrue(idem(sexp_new, sexp_new2)[0]) def testTypeof_get(self): sexp = rinterface.globalEnv.get("letters") self.assertEquals(sexp.typeof, rinterface.STRSXP)
import unittest import copy import gc from rpy2 import rinterface rinterface.initr() class SexpTestCase(unittest.TestCase): def testNew_invalid(self): x = "a" self.assertRaises(ValueError, rinterface.Sexp, x) def testNew(self): sexp = rinterface.baseenv.get("letters") sexp_new = rinterface.Sexp(sexp) idem = rinterface.baseenv.get("identical") self.assertTrue(idem(sexp, sexp_new)[0]) sexp_new2 = rinterface.Sexp(sexp) self.assertTrue(idem(sexp, sexp_new2)[0]) del (sexp) self.assertTrue(idem(sexp_new, sexp_new2)[0]) def testTypeof_get(self): sexp = rinterface.baseenv.get("letters") self.assertEqual(sexp.typeof, rinterface.STRSXP) sexp = rinterface.baseenv.get("pi")
import array import pytest import rpy2.rinterface as ri ri.initr() def test_init_from_seqr(): seq = [True, False, False] v = ri.BoolSexpVector(seq) assert len(v) == 3 for x, y in zip(seq, v): assert x == y def test_from_int_memoryview(): a = array.array('i', (True, False, True)) mv = memoryview(a) vec = ri.BoolSexpVector.from_memoryview(mv) assert (True, False, True) == tuple(vec) def test_from_bool_memoryview(): a = array.array('b', (True, False, True)) mv = memoryview(a) with pytest.raises(ValueError): ri.BoolSexpVector.from_memoryview(mv) def test_getitem(): vec = ri.BoolSexpVector([True, False, False])
#--------------------------------------------------------- # Name: matrix_seriation.py # Purpose: Implementation of amtrix seriation using rpy2 and seriation package # Author: Jacob Retallick # Created: 2015.10.06 # Last Modified: 2015.10.07 #--------------------------------------------------------- import numpy as np import rpy2.rinterface as rint import rpy2.robjects as robj from rpy2.robjects.packages import importr # initialise R rint.initr() # load packages seriation = importr("seriation") stats = importr("stats") def mat_to_R(M): '''convert a numpy matrix to R format''' d = M.reshape([1, -1]).tolist()[0] return robj.r.matrix(d, nrow=M.shape[0]) def deres_mat(M, res): '''Reduce the numerical resolution of a matrix. inputs: res -> resolution (smallest relative diffence between values)
def plot(self, data_array, width, height): """ Create a plot with R """ # Start R timing startTime = time.time() rinterface.initr() r = robjects.r grdevices = importr("grDevices") # Import the bfast package log.debug(os.environ["R_SCRIPTS_USER"]) r.source("%s/4253H_twice.R" % os.environ["R_SCRIPTS_USER"]) b = robjects.FloatVector(data_array) # Make a time series from the vector b_ts = r.ts(b, start=robjects.IntVector([2000, 4]), frequency=23) b_fitting = r.my4253Htwice(x=b_ts) temp_datadir = self.config.get("main", "temp.datadir") temp_url = self.config.get("main", "temp.url") file = NamedTemporaryFile(suffix=".png", dir=temp_datadir, delete=False) log.debug("Writing resulting diagram to file %s" % file.name) grdevices.png(file=file.name, width=width, height=height) # Plotting code here # r.par(col="black") r.plot(b_fitting, type="l", axes=False, ylab="Double logistic fitting", ylim=robjects.FloatVector([0.0, 1.0])) r.box() r.axis( 2, labels=robjects.StrVector(["0.0", "0.2", "0.4", "0.6", "0.8", "1.0"]), at=robjects.FloatVector([0.0, 0.2, 0.4, 0.6, 0.8, 1.0]), ) r.axis( 1, labels=robjects.StrVector(["2000", "2002", "2004", "2006", "2008", "2010", "2012", "2014"]), at=robjects.FloatVector([2000, 2002, 2004, 2006, 2008, 2010, 2012, 2014]), ) r.abline( v=robjects.IntVector([2000, 2002, 2004, 2006, 2008, 2010, 2012, 2014]), col="lightgrey", lty=2 ) # vertikale linien bei jedem jahr, lty ist line type r.abline(h=robjects.FloatVector([0, 0.2000, 0.4000, 0.6000, 0.8000, 1.0000]), col="lightgrey", lty=2) # Close the device grdevices.dev_off() # End R timing and log it endTime = time.time() log.debug("It took " + str(endTime - startTime) + " seconds to initalize R and draw a plot.") file.close() result = {"file": "%s/%s" % (temp_url, file.name.split("/")[-1])} self.outputs["plot"]["value"] = json.dumps({"file": "%s/%s" % (temp_url, file.name.split("/")[-1])}) return SERVICE_SUCCEEDED
def testNewWithoutInit(self): self.assertTrue(False) # worked when tested, but calling endEmbeddedR causes trouble ri.endr(1) self.assertRaises(RuntimeError, ri.SexpVector, [1,2], ri.INTSXP) #FIXME: trouble... does not initialize R when failing the test ri.initr()
import rpy2.robjects as ro from rpy2.robjects.packages import importr import rpy2.rinterface as ri ri.set_initoptions(('rpy2', '--verbose', '--no-save')) ri.initr() graphics = importr('graphics') grdevices = importr('grDevices') base = importr('base') stats = importr('stats') zoo = importr('zoo') #Need to add params to importr as xts and quantmod have conflicts xts = importr("xts", robject_translations = {".subset.xts": "_subset_xts2", "to.period": "to_period2"}) quantmod = importr('quantmod', robject_translations = {"skeleton.TA": "skeleton_TA2"}) AORD = ro.r('read.table("~/Documents/R/StrategyTester/Data/AORD.csv",header=T, sep=",")') #WIP - using quantmod, zoo, xts in Python. #Create Zoo object #indexZoo = ro.r.rownames(AORD) AORD = zoo.as_zoo(AORD) AORD = xts.as_xts(AORD) #Create MA zoo object #Creating EMA using quantmod chartData = AORD#.rx['2008-02::2008-08'] quantmod.chartSeries(chartData, theme="white") EMA1=quantmod.addEMA(n=10,col=2)
def initializer(): if rpy2.rinterface_lib.embedded.isready(): print('R is is already initialized!') ri.initr()