def batch_adjust(expr_df, batch):
# sample call: ir.batch_adjust(exprset, batch=[batch1.columns.to_list(), [1,1,1]])
"""
TODO: some 0 or na somewhere causing regection
Error in `contrasts<-`(`*tmp*`, value = contr.funs[1 + isOF[nn]]) :
contrasts can be applied only to factors with 2 or more levels
Args:
expr_df:
batch:
Returns:
"""
ro.pandas2ri.activate()
sva = importr('sva')
base = importr('base')
batch_vec = ro.Vector(batch)
# batch can be a pd dataframe. has to have multiple levels
rbatch = ro.FactorVector(obj=ro.Vector(batch),
labels=ro.Vector(batch[0]),
levels=ro.Vector(batch[1:]))
print(rbatch.slots['levels'].r_repr())
# print(expr_df.slots['assayData'].r_repr())
# NAs in corrected matrix caused by genes = 0?
# remove na: batch1 = batch1[(batch1.T != 0).any()]
# batch needs to have multiple list dimensions (multi-level)
# df =base.as_matrix(rpd.py2ri_pandasdataframe(expr_df))
batch_corrected = sva.ComBat(
dat=expr_df, batch=rbatch) #, mod=ro.NULL)#, mean_only=True)
ro.pandas2ri.deactivate()
return batch_corrected
def testNew(self):
identical = ri.baseenv["identical"]
py_a = array.array('i', [1, 2, 3])
ro_v = robjects.Vector(py_a)
self.assertEqual(ro_v.typeof, ri.INTSXP)
ri_v = ri.SexpVector(py_a, ri.INTSXP)
ro_v = robjects.Vector(ri_v)
self.assertTrue(identical(ro_v, ri_v)[0])
del (ri_v)
self.assertEqual(ri.INTSXP, ro_v.typeof)
def do_bicor(this_trait_vals, target_trait_vals):
r_library = ro.r["library"] # Map the library function
r_options = ro.r["options"] # Map the options function
r_library("WGCNA")
r_bicor = ro.r["bicorAndPvalue"] # Map the bicorAndPvalue function
r_options(stringsAsFactors = False)
this_vals = ro.Vector(this_trait_vals)
target_vals = ro.Vector(target_trait_vals)
the_r, the_p, _fisher_transform, _the_t, _n_obs = [numpy.asarray(x) for x in r_bicor(x = this_vals, y = target_vals)]
return the_r, the_p
def testCall(self):
ri_f = rinterface.baseenv.get('sum')
ro_f = robjects.Function(ri_f)
ro_v = robjects.Vector(array.array('i', [1, 2, 3]))
s = ro_f(ro_v)
def two_var_intr_effects(self, target, vars, nval=100, plot=True):
""" Loads first level interactions.
Args:
target - Variable identifier (column name or number) specifying the
target variable
vars - List of variable identifiers (column names or numbers) specifying
other selected variables. Must not contain target
nval - Number of evaluation points used for calculation.
plot - Determines whether or not to plot results.
Returns: Pandas dataframe of interaction effects
"""
# Check if null.models have already been generated
check_str = """
function(){
if(exists("null.models")){
return(T)
} else {
return(F)
}
}
"""
if not robjects.r(check_str)()[0]:
self.logger.info(
'Null models not generated, generating null models '
'(n=10)')
self._generate_interaction_null_models(10, quiet=False)
int_str = """
function(target, vars, nval){
interactions <- twovarint(tvar=target, vars=vars, null.models,
nval=nval, plot=F)
}
"""
# Check the input type. If int, add one, if string do nothing.
target = target if type(target) is str else target + 1
vars = [var if type(var) is str else var + 1 for var in vars]
r_interact = robjects.r(int_str)(target,
robjects.Vector(np.array(vars)), nval)
interact = pd.DataFrame(
{
'interact_str': list(r_interact[0]),
'exp_null_int': list(r_interact[1]),
'std_null_int': list(r_interact[2])
},
index=vars)
if plot:
int_effects = interact.reset_index().rename(
columns={'index': 'vars'})
int_effects_m = pd.melt(
int_effects,
id_vars='vars',
value_vars=['interact_str', 'exp_null_int'])
p = gg.ggplot(gg.aes(x='vars', fill='variable', weight='value'),
data=int_effects_m) \
+ gg.geom_bar() \
+ gg.labs(
title='Two-var interaction effects - {}'.format(target))
print(p)
return interact
def test_call_with_sexp():
ri_f = rinterface.baseenv.get('sum')
ro_f = Function(ri_f)
ro_v = robjects.Vector(array.array('i', [1, 2, 3]))
s = ro_f(ro_v)
assert s[0] == 6
def vecterize(value_list):
'''
Vecterize a python list into a R vector
input:
value_list: a python list
output:
An R vector
'''
return robjects.Vector(value_list)
def ML_survivorship(times= np.arange(0,np.max(data['mortality']),0.1) ):
ptime = np.array(times)
rtime = ro.Vector(ptime)
return np.array(pgammagompertz(rtime,
model_para['est']['beta'],
model_para['est']['s'],
model_para['est']['rate'],lower_tail=False))
def ML_hazard(times= np.arange(0,np.max(data['mortality']),0.1) ):
ptime = np.array(times)
rtime = ro.Vector(ptime)
return np.array(hgammagompertz(rtime,
model_para['est']['beta'],
model_para['est']['s'],
model_para['est']['rate']))
def testExtractByIndex(self):
seq_R = robjects.baseenv["seq"]
mySeq = seq_R(0, 10)
# R indexing starts at one
myIndex = robjects.Vector(array.array('i', range(1, 11, 2)))
mySubset = mySeq.rx(myIndex)
for i, si in enumerate(myIndex):
self.assertEqual(mySeq[si - 1], mySubset[i])
def testGetNames(self):
vec = robjects.Vector(array.array('i', [1, 2, 3]))
v_names = [robjects.baseenv["letters"][x] for x in (0, 1, 2)]
#FIXME: simplify this
r_names = robjects.baseenv["c"](*v_names)
vec = robjects.baseenv["names<-"](vec, r_names)
for i in range(len(vec)):
self.assertEqual(v_names[i], vec.names[i])
vec.names[0] = 'x'
def ML_cumulative_hazard(times= np.arange(0,np.max(data['mortality']),0.1) ):
ptime = np.array(times)
rtime = ro.Vector(ptime)
return np.array(Hgammagompertzmakeham(rtime,
model_para['est']['rate'],
model_para['est']['beta'],
model_para['est']['s'],
model_para['est']['lambda']))
def testExtractIndexError(self):
seq_R = robjects.baseenv["seq"]
mySeq = seq_R(0, 10)
# R indexing starts at one
myIndex = robjects.Vector(['a', 'b', 'c'])
def noconsole(x):
pass
robjects.rinterface.set_writeconsole(noconsole)
self.assertRaises(ri.RRuntimeError, mySeq.rx, myIndex)
def testExtractByName(self):
seq_R = robjects.baseenv["seq"]
mySeq = seq_R(0, 25)
letters = robjects.baseenv["letters"]
mySeq = robjects.baseenv["names<-"](mySeq, letters)
# R indexing starts at one
myIndex = robjects.Vector(letters[2])
mySubset = mySeq.rx(myIndex)
for i, si in enumerate(myIndex):
self.assertEqual(2, mySubset[i])
def single_partial_dependency(self, vars, nav=500):
""" Display single variable partial dependancy plots
Args:
vars - A list of variable indecies or column names indicated which plots
to print.
nav - Maximum number of observations used for average calculations.
Higher values give more accurate calculations with diminishing
returns.
"""
dep_str = """
function(vars, nval, nav){
singleplot(vars)
}
"""
if any([type(var) == int for var in vars]):
vars = [var + 1 for var in vars]
robjects.r(dep_str)(robjects.Vector(np.array(vars)), nav)
def r_main():
#f*****g can't make it work with cbind f**k this
from rpy2.robjects.lib.dplyr import DataFrame
print("Loading file...")
robj.r['load'](sys.argv[1])
lang = []
for i, chunk in enumerate(misc.chunks_from_r(sys.argv[2])):
print("Chunk ", i + 1)
lang += lang_det(chunk.text)
robj.globalenv['tmp'] = robj.Vector(
map(lambda x: x if x != None else rpy2.rinterface.NULL, lang))
robj.globalenv[sys.argv[2]] = DataFrame(
robj.globalenv[sys.argv[2]]).mutate(lang2='tmp')
print("Saving...")
robj.r.save(sys.argv[2], file=sys.argv[1])
def run_mccoil(barcode_file_lines, maf_file_lines=None, verbose=False):
## init barcode set
barcode_set = Barcode.SetOfBarcodes()
barcode_set.readBarcodeFileLines(barcode_file_lines)
# validate
is_valid_barcode_set, err_msg = barcode_set.validate()
if not is_valid_barcode_set:
print err_msg
return ([])
## init mafs
if not maf_file_lines:
mafs = barcode_set.computeMAFFromBarcodes(1)
else:
mafs = MAF.MAF()
mafs.readMAFFileLines(maf_file_lines)
mafs_R_vector = robjects.Vector(mafs.minor_allele_freqs())
# validate
is_valid_mafs, err_msg = mafs.validate()
if not is_valid_mafs:
print err_msg
return ({})
## compute zygosity matrix, then convert to R DataFrame
zygosity_matrix = barcode_set.to_zygosity_matrix(mafs,
header=True,
index=True)
if verbose: print(zygosity_matrix)
data = to_R_zygosity_df(zygosity_matrix)
if verbose: print(data)
## import MCCOIL
mccoil_R_code = open(mccoil_R, 'r').read()
mccoil = SignatureTranslatedAnonymousPackage(mccoil_R_code, 'mccoil')
## compute result
result = mccoil.McCOIL_categorical(data, P=mafs_R_vector)
#print result
## get sites/samples
sites, samples = list(result[-2]), list(result[-1])
## get maf/coi predictions, which map 1-to-1 sites/samples
# (i.e. maf_prediction[i] is prediction for site[i])
maf_predictions, coi_predictions = list(result[6]), list(result[5])
return ({
'mafs': zip(sites, maf_predictions),
'cois': zip(samples, coi_predictions)
})
def cut_genes(cluster_data, diss_tom_path, min_module_size):
tree = robjects.Vector([
np.array(cluster_data['merge']),
robjects.FloatVector(cluster_data['height']),
robjects.IntVector(cluster_data['order'])
])
tree.names = ['merge', 'height', 'order']
diss_tom = np.loadtxt(diss_tom_path)
modules = robjects.r.cutreeHybrid(dendro=tree,
distM=diss_tom,
deepSplit=2,
pamRespectsDendro=False,
minClusterSize=min_module_size)
labels = pandas2ri.ri2py(modules.rx2('labels'))[tree.rx2('order')]
colors = WGCNA.labels2colors(labels)
rgb = robjects.r.col2rgb(colors)
hex = robjects.r.rgb(rgb.rx(1, True),
rgb.rx(2, True),
rgb.rx(3, True),
maxColorValue=255)
return {'modules': list(colors), 'hex': list(hex)}
def DGSA(A, B, name_A, num_cluster):
'''
Distance based Generalized Sensitivity Analysis method
Args:
A: (np.array) A in SA(A|B), # features * # realizations
B: (np.array) B in SA(A|B), # features * # realizations
name_A: (np.vector) Row names of A
num_cluster: (int) number of cluster
Output:
SA_dataframe: (pd.DataFrame) StandardizedSensitivity data frame
'''
## Load DGSA R script
ro.r('source(\'./source_code/dgsa/dgsa_rightcolor.R\')')
rpy2.robjects.numpy2ri.activate()
## Clustering
score = B.T
kmeans = KMeans(n_clusters=num_cluster, random_state=0).fit(score)
clustering = kmeans.labels_
clustering = ro.Vector(clustering + 1)
## DGSA
pandas2ri.activate()
A = pd.DataFrame(A.T, columns=name_A)
r_A = pandas2ri.py2ri(A)
r_dgsa = ro.r['dgsa']
myDGSA = r_dgsa(clustering, r_A)
SensitivityMatrix = np.asarray(myDGSA.rx2(1))
SA_stats = np.diag(np.nan_to_num(SensitivityMatrix).max(axis=0))
names = np.asarray(myDGSA.rx2(2))
SA_dataframe = pd.DataFrame(SA_stats, index=names)
return SA_dataframe
def testSetNames(self):
vec = robjects.Vector(array.array('i', [1, 2, 3]))
names = ['x', 'y', 'z']
vec.names = names
for i in range(len(vec)):
self.assertEqual(names[i], vec.names[i])
def run_analysis(self, requestform):
print("Starting WGCNA analysis on dataset")
self.r_enableWGCNAThreads() # Enable multi threading
self.trait_db_list = [
trait.strip() for trait in requestform['trait_list'].split(',')
]
print("Retrieved phenotype data from database",
requestform['trait_list'])
helper_functions.get_trait_db_obs(self, self.trait_db_list)
self.input = {
} # self.input contains the phenotype values we need to send to R
strains = [] # All the strains we have data for (contains duplicates)
traits = [
] # All the traits we have data for (should not contain duplicates)
for trait in self.trait_list:
traits.append(trait[0].name)
self.input[trait[0].name] = {}
for strain in trait[0].data:
strains.append(strain)
self.input[trait[0].name][strain] = trait[0].data[strain].value
# Transfer the load data from python to R
uStrainsR = r_unique(ro.Vector(strains)) # Unique strains in R vector
uTraitsR = r_unique(ro.Vector(traits)) # Unique traits in R vector
r_cat("The number of unique strains:", r_length(uStrainsR), "\n")
r_cat("The number of unique traits:", r_length(uTraitsR), "\n")
# rM is the datamatrix holding all the data in R /rows = strains columns = traits
rM = ro.r.matrix(ri.NA_Real,
nrow=r_length(uStrainsR),
ncol=r_length(uTraitsR),
dimnames=r_list(uStrainsR, uTraitsR))
for t in uTraitsR:
trait = t[0] # R uses vectors every single element is a vector
for s in uStrainsR:
strain = s[
0] # R uses vectors every single element is a vector
#DEBUG: print(trait, strain, " in python: ", self.input[trait].get(strain), "in R:", rM.rx(strain,trait)[0])
rM.rx[strain, trait] = self.input[trait].get(
strain) # Update the matrix location
sys.stdout.flush()
self.results = {}
self.results['nphe'] = r_length(uTraitsR)[
0] # Number of phenotypes/traits
self.results['nstr'] = r_length(uStrainsR)[0] # Number of strains
self.results['phenotypes'] = uTraitsR # Traits used
self.results['strains'] = uStrainsR # Strains used in the analysis
self.results[
'requestform'] = requestform # Store the user specified parameters for the output page
# Calculate soft threshold if the user specified the SoftThreshold variable
if requestform.get('SoftThresholds') is not None:
powers = [
int(threshold.strip()) for threshold in
requestform['SoftThresholds'].rstrip().split(",")
]
rpow = r_unlist(r_c(powers))
print "SoftThresholds: {} == {}".format(powers, rpow)
self.sft = self.r_pickSoftThreshold(rM,
powerVector=rpow,
verbose=5)
print "PowerEstimate: {}".format(self.sft[0])
self.results['PowerEstimate'] = self.sft[0]
if self.sft[0][0] is ri.NA_Integer:
print "No power is suitable for the analysis, just use 1"
self.results['Power'] = 1 # No power could be estimated
else:
self.results['Power'] = self.sft[0][
0] # Use the estimated power
else:
# The user clicked a button, so no soft threshold selection
self.results['Power'] = requestform.get(
'Power') # Use the power value the user gives
# Create the block wise modules using WGCNA
network = self.r_blockwiseModules(
rM,
power=self.results['Power'],
TOMType=requestform['TOMtype'],
minModuleSize=requestform['MinModuleSize'],
verbose=3)
# Save the network for the GUI
self.results['network'] = network
# How many modules and how many gene per module ?
print "WGCNA found {} modules".format(r_table(network[1]))
self.results['nmod'] = r_length(r_table(network[1]))[0]
# The iconic WCGNA plot of the modules in the hanging tree
self.results['imgurl'] = webqtlUtil.genRandStr("WGCNAoutput_") + ".png"
self.results['imgloc'] = webqtlConfig.TMPDIR + self.results['imgurl']
r_png(self.results['imgloc'], width=1000, height=600)
mergedColors = self.r_labels2colors(network[1])
self.r_plotDendroAndColors(network[5][0],
mergedColors,
"Module colors",
dendroLabels=False,
hang=0.03,
addGuide=True,
guideHang=0.05)
r_dev_off()
sys.stdout.flush()
def construct_rule_list(self,
train_df,
label_col,
tree_constructors,
nr_bootstraps=3):
y_train = train_df[label_col]
X_train = train_df.copy()
X_train = X_train.drop(label_col, axis=1)
importr('randomForest')
importr('inTrees')
ro.globalenv["X"] = com.convert_to_r_dataframe(X_train)
ro.globalenv["target"] = ro.FactorVector(y_train.values.tolist())
feature_mapping = {}
feature_mapping_reverse = {}
for i, feature in enumerate(X_train.columns):
feature_mapping[feature] = i + 1
feature_mapping_reverse[i + 1] = feature
treeList = []
for tree in bootstrap(train_df,
label_col,
tree_constructors,
nr_classifiers=nr_bootstraps):
if tree.count_nodes() > 1:
treeList.append(self.tree_to_R_object(tree, feature_mapping))
ro.globalenv["treeList"] = ro.Vector(
[len(treeList), ro.Vector(treeList)])
ro.r('names(treeList) <- c("ntree", "list")')
rules = ro.r(
'buildLearner(getRuleMetric(extractRules(treeList, X), X, target), X, target)'
)
rules = list(rules)
conditions = rules[int(0.6 * len(rules)):int(0.8 * len(rules))]
predictions = rules[int(0.8 * len(rules)):]
# Create a OrderedRuleList
rulesets = []
for idx, (condition,
prediction) in enumerate(zip(conditions, predictions)):
# Split each condition in Rules to form a RuleSet
rulelist = []
condition_split = [
x.lstrip().rstrip() for x in condition.split('&')
]
for rule in condition_split:
feature = feature_mapping_reverse[int(
re.findall(r',[0-9]+]', rule)[0][1:-1])]
lte = re.findall(r'<=', rule)
gt = re.findall(r'>', rule)
eq = re.findall(r'==', rule)
cond = lte[0] if len(lte) else (gt[0] if len(gt) else eq[0])
extract_value = re.findall(r'[=>]-?[0-9\.]+', rule)
if len(extract_value):
value = float(re.findall(r'[=>]-?[0-9\.]+', rule)[0][1:])
else:
feature = 'True'
value = None
rulelist.append(Rule(feature, cond, value))
rulesets.append(RuleSet(idx, rulelist, prediction))
return OrderedRuleList(rulesets)
import rpy2.robjects as robjects
r = robjects.r
F = open("table.txt")
lines = F.readlines()
l1 = []
l2 = []
l3 = []
l4 = []
for line in lines:
col = line.split(',')
l1.append(float(col[0]))
l2.append(float(col[1]))
l3.append(col[2])
l4.append(float(col[3]))
#l.append(float(line.split()[0]))
R_vector1 = robjects.FloatVector(l1)
R_vector2 = robjects.FloatVector(l2)
R_vector3 = robjects.Vector(l3)
print("mean", (r.mean(R_vector1)), (r.mean(R_vector2)))
print(R_vector3)
print("2", "3")
chrmreq + '.snpid.updates.txt', 'w')
#import time
#t0 = time.time()
for item in range(snpbim.shape[0]):
#for item in range(20):
snp = snpbim[item, ]
chrm = snp[0]
if str(chrm) != str(chrmreq):
continue
oldid = snp[1]
if item % 1000 == 0:
print str(item) + ' snps updated...'
sys.stdout.flush()
chrm = snp[0]
snpregion = snp[0] + ':' + snp[3] + ':' + snp[3]
filters = robjects.Vector([snpregion, True, chrm, "dbSNP"])
filters.names = [
"chromosomal_region", "with_validated", "chr_name", "variation_source"
]
snprecords = biomart.getBM(attributes, filters=filters, mart=snpmart)
#snprecords = snpper(snp[0] + ':' + snp[3] + ':' + snp[3],snp[0])
if len(snprecords[0]) == 0:
print >> nameupdates, oldid + '\tncgi' + snp[1]
continue
counter = range(len(snprecords[0]))
counterupdate = []
for x, y in enumerate(counter):
if snprecords[5][y] == 1:
counterupdate.append(x)
if len(counterupdate) == 0:
print >> nameupdates, oldid + '\tmcgi' + snp[1]
def construct_rule_list(self,
train_df,
label_col,
tree_constructors,
nr_bootstraps=3):
""" Construct an `constructors.inTrees.OrderedRuleList` from an ensemble of decision trees
**Params**
----------
- `train_df` (pandas DataFrame) - the training data
- `label_col` (string) - the column identifier for the class labels
- `tree_constructors` (`constructors.treeconstructor.TreeConstructor`) - the decision tree induction algorithms used to create an ensemble with
- `nr_bootstraps` (pandas DataFrame) - how many times do we apply bootstrapping for each TreeConstructor? The size of the ensemble will be equal to
|tree_constructors|*nr_bootstraps
**Returns**
-----------
an OrderedRuleList
"""
y_train = train_df[label_col]
X_train = train_df.copy()
X_train = X_train.drop(label_col, axis=1)
importr('randomForest')
importr('inTrees')
ro.globalenv["X"] = com.convert_to_r_dataframe(X_train)
ro.globalenv["target"] = ro.FactorVector(y_train.values.tolist())
feature_mapping = {}
feature_mapping_reverse = {}
for i, feature in enumerate(X_train.columns):
feature_mapping[feature] = i + 1
feature_mapping_reverse[i + 1] = feature
treeList = []
for tree in ensemble.bootstrap(train_df,
label_col,
tree_constructors,
nr_classifiers=nr_bootstraps):
if tree.count_nodes() > 1:
treeList.append(self._tree_to_R_object(tree, feature_mapping))
ro.globalenv["treeList"] = ro.Vector(
[len(treeList), ro.Vector(treeList)])
ro.r('names(treeList) <- c("ntree", "list")')
rules = ro.r(
'buildLearner(getRuleMetric(extractRules(treeList, X), X, target), X, target)'
)
rules = list(rules)
conditions = rules[int(0.6 * len(rules)):int(0.8 * len(rules))]
predictions = rules[int(0.8 * len(rules)):]
# Create a OrderedRuleList
rulesets = []
for idx, (condition,
prediction) in enumerate(zip(conditions, predictions)):
# Split each condition in Rules to form a RuleSet
rulelist = []
condition_split = [
x.lstrip().rstrip() for x in condition.split('&')
]
for rule in condition_split:
feature = feature_mapping_reverse[int(
re.findall(r',[0-9]+]', rule)[0][1:-1])]
lte = re.findall(r'<=', rule)
gt = re.findall(r'>', rule)
eq = re.findall(r'==', rule)
cond = lte[0] if len(lte) else (gt[0] if len(gt) else eq[0])
extract_value = re.findall(r'[=>]-?[0-9\.]+', rule)
if len(extract_value):
value = float(re.findall(r'[=>]-?[0-9\.]+', rule)[0][1:])
else:
feature = 'True'
value = None
rulelist.append(Condition(feature, cond, value))
rulesets.append(Rule(idx, rulelist, prediction))
return OrderedRuleList(rulesets)
elif is_str and (desired_type is None or desired_type == str):
res = [str(elt) for elt in v_list]
return robjects.StrVector(res)
if desired_type is not None:
raise TypeException("Cannot coerce vector to type '%s'" % desired_type)
return robjects.RVector(v_list)
def vector_conv(v, desired_type=None):
v_list = literal_eval(v)
return create_vector(v_list, desired_type)
RVector = new_constant('RVector', staticmethod(vector_conv),
robjects.Vector([]),
staticmethod(lambda x: isinstance(x, robjects.Vector)))
def bool_vector_conv(v):
return vector_conv(v, bool)
RBoolVector = new_constant(
'RBoolVector',
staticmethod(bool_vector_conv),
robjects.BoolVector([]),
staticmethod(lambda x: isinstance(x, robjects.Vector)),
base_class=RVector)
def granger_causality(data,
cols,
y_var,
lags,
our_type,
list_subcausalities=False):
y_subset = data[y_var]
pandas2ri.activate()
data = pandas2ri.py2ri(data)
### We define the functions;
robjects.r('''
is.installed <- function(mypkg){
is.element(mypkg, installed.packages()[,1])
}
# check if package "gtools" is installed
if (!is.installed("gtools")){
install.packages("gtools", INSTALL_opts = '--no-lock', repos='https://cloud.r-project.org')
}
if (!is.installed("vars")){
install.packages("vars", INSTALL_opts = '--no-lock', repos='https://cloud.r-project.org')
}
library("gtools")
library("vars")
for (k in .libPaths()){
k <- paste0(k,"/00LOCK")
unlink(k, recursive = TRUE)
}
get_p_value <- function(data,lags,y_values,causes,our_type){
data <- as.data.frame(data)
mycols <- c(as.character(unlist(causes)))
mydata <- data[c(as.character(unlist(causes)))]
mydata <- as.data.frame(mydata)
mydata <- cbind(Temperatures = y_values,mydata)
var.2c <- VAR(mydata, p = lags, type = our_type) ### In this case, we are using trended Granger causality
my_vcov <- vcovHC(var.2c)
mycause <- causality(var.2c, cause = mycols)
return(c(mycause$Granger$p.value))
}
permuts <- function(data,order,y,columns,our_type){
list_perms <- do.call("c", lapply(seq_along(columns), function(i) combn(columns, i, FUN = list)))
d <- data.frame(x = NA, y = 1:length(list_perms))
i <- 1
columns <- unlist(columns)
while (i<=length(list_perms)){
myp <- get_p_value(data,order,y,list_perms[i][[1]],our_type = our_type)
d[i,] <- c(toString(unlist(list_perms[i][[1]])),as.numeric(myp))
i <- i + 1
}
colnames(d) <- c("Sets of variables","p-value")
d$`p-value` <- as.numeric(d$`p-value`)
return(d)
#return(.libPaths())
#return(unlist(list_perms[i-1][[1]]))
}
''')
r_f = robjects.globalenv['get_p_value']
permuts = robjects.globalenv['permuts']
robjects.r.library("vars")
our_causes = robjects.r('as.data.frame')(cols)
if list_subcausalities == True:
mydf = permuts(data, lags, robjects.Vector(y_subset), our_causes,
our_type)
return (mydf)
return (r_f(data, lags, robjects.Vector(y_subset), our_causes, our_type))
def testExtractRecyclingRule(self):
# recycling rule
v = robjects.Vector(array.array('i', range(1, 23)))
m = robjects.r.matrix(v, ncol=2)
col = m.rx(True, 1)
self.assertEqual(11, len(col))
def testCallClosureWithRObject(self):
ri_f = rinterface.baseenv["sum"]
ro_vec = robjects.Vector(array.array('i', [1, 2, 3]))
res = ri_f(ro_vec)
self.assertEquals(6, res[0])
