def createDataFrame(list_vec, colnames=None, name=None):
"""
Create the DataFrame.
list_vec : The list of RDotNet.Vector.
colnames : The list of IronPython.
name : The name.
return : The expression.
"""
if list_vec is None or len(list_vec) == 0:
return None
if colnames is None or len(list_vec) != len(colnames):
colnames = []
for i in xrange(len(list_vec)):
colnames.append("V{0}".format(i + 1))
_r_dataframe = SymbolicExpressionExtension.AsFunction(
Engine.Evaluate("data.frame"))
_r_colnames = SymbolicExpressionExtension.AsFunction(
Engine.Evaluate("colnames"))
dst = runFunction(_r_dataframe, list_vec, "dataframe")
cln = runFunction(_r_colnames, [dst], "character")
for i in xrange(len(list_vec)):
cln[i] = colnames[i]
if name != None:
setSymbol(name, dst)
return dst
def asDataFrame(var):
"""
Converts the specified expression to a DataFrame.
var : The expression of DataFrame or Matrix.
return : The DataFrame.
"""
if isDataFrame(var):
return SymbolicExpressionExtension.AsDataFrame(var)
elif isMatrix(var):
asdf = evaluate("as.data.frame", "function")
dst = runFunction(asdf, [var], "dataframe")
asdf.Dispose()
return dst
else:
return var
def asRaw(var):
return SymbolicExpressionExtension.AsRaw(var)
def asCharacter(var):
return SymbolicExpressionExtension.AsCharacter(var)
def isVector(var):
return SymbolicExpressionExtension.IsVector(var)
def isMatrix(var):
return SymbolicExpressionExtension.IsMatrix(var)
def isLanguage(var):
return SymbolicExpressionExtension.IsLanguage(var)
def isEnvironment(var):
return SymbolicExpressionExtension.IsEnvironment(var)
def asVector(var):
if isVector(var):
return SymbolicExpressionExtension.AsVector(var)
else:
return var
def asInteger(var):
return SymbolicExpressionExtension.AsInteger(var)
def asFunction(var):
if isFunction(var):
return SymbolicExpressionExtension.AsFunction(var)
else:
return var
def asEnvironment(var):
if isEnvironment(var):
return SymbolicExpressionExtension.AsEnvironment(var)
else:
return var
def asComplexMatrix(var):
if isMatrix(var):
return SymbolicExpressionExtension.AsComplexMatrix(var)
else:
return var
def asComplex(var):
return SymbolicExpressionExtension.AsComplex(var)
def asCharacterMatrix(var):
if isMatrix(var):
return SymbolicExpressionExtension.AsCharacterMatrix(var)
else:
return var
def asRawMatrix(var):
if isMatrix(var):
return SymbolicExpressionExtension.AsRawMatrix(var)
else:
return var
def asSymbol(var):
if isSymbol(var):
return SymbolicExpressionExtension.AsSymbol(var)
else:
return var
def asIntegerMatrix(var):
if isMatrix(var):
return SymbolicExpressionExtension.AsIntegerMatrix(var)
else:
return var
def isDataFrame(var):
return SymbolicExpressionExtension.IsDataFrame(var)
def asList(var):
if isList(var):
return SymbolicExpressionExtension.AsList(var)
else:
return var
def isFunction(var):
return SymbolicExpressionExtension.IsFunction(var)
def asLogical(var):
return SymbolicExpressionExtension.AsLogical(var)
def isList(var):
return SymbolicExpressionExtension.IsList(var)
def asLogicalMatrix(var):
if isMatrix(var):
return SymbolicExpressionExtension.AsLogicalMatrix(var)
else:
return var
def isSymbol(var):
return SymbolicExpressionExtension.IsSymbol(var)
def asNumeric(var):
return SymbolicExpressionExtension.AsNumeric(var)
def asNumericMatrix(var):
if isMatrix(var):
return SymbolicExpressionExtension.AsNumericMatrix(var)
else:
return var
#
# Add reference.
#
import clr
clr.AddReferenceToFile("RDotNet.dll")
import RDotNet
from RDotNet import REngineExtension
from RDotNet import SymbolicExpressionExtension
#
# Initialize.
#
RDotNet.REngine.SetEnvironmentVariables(path.join(R_HOME, "bin\\x64"), R_HOME)
Engine = RDotNet.REngine.GetInstance()
_r_print = SymbolicExpressionExtension.AsFunction(Engine.Evaluate("print"))
print("REngine is initialized.")
#
# Functions.
#
def Initialize():
"""
Initialize REngine.
"""
global Engine
if Engine is None:
RDotNet.REngine.SetEnvironmentVariables(path.join(R_HOME, "bin\\x64"),
R_HOME)
Engine = RDotNet.REngine.GetInstance()