private static GenericVector asList(SymbolicExpression expression)
{
if (!object.ReferenceEquals(engine, expression.Engine) || engine == null)
{
engine = expression.Engine;
asListFunction = null;
}
if (asListFunction == null)
asListFunction = engine.Evaluate("invisible(as.list)").AsFunction();
var newExpression = asListFunction.Invoke(expression);
return new GenericVector(newExpression.Engine, newExpression.DangerousGetHandle());
}
/// <summary>
/// Executes the function. Match the function arguments by name.
/// </summary>
/// <param name="argNames">The names of the arguments. These can be empty strings for unnamed function arguments</param>
/// <param name="args">The arguments passed to the function</param>
/// <returns></returns>
protected SymbolicExpression InvokeViaPairlist(string[] argNames, SymbolicExpression[] args)
{
var names = new CharacterVector(Engine, argNames);
var arguments = new GenericVector(Engine, args);
arguments.SetNames(names);
var argPairList = arguments.ToPairlist();
//IntPtr newEnvironment = Engine.GetFunction<Rf_allocSExp>()(SymbolicExpressionType.Environment);
//IntPtr result = Engine.GetFunction<Rf_applyClosure>()(Body.DangerousGetHandle(), handle,
// argPairList.DangerousGetHandle(),
// Environment.DangerousGetHandle(), newEnvironment);
return createCallAndEvaluate(argPairList.DangerousGetHandle());
}
public RInternalResult Map(SymbolicExpression sexp)
{
//Comments return null instead of a SEXP.
if (sexp == null) return new RInternalResult();
var mapper = _mappers[sexp.Type];
var mapped = mapper(sexp);
var result = new RInternalResult
{
Type = sexp.Type.ToString(),
Values = mapped.ToList()
};
return result;
}
/// <summary>
/// Evaluates the expression in the specified environment.
/// </summary>
/// <param name="environment">The environment.</param>
/// <param name="result">The evaluation result, or <c>null</c> if the evaluation failed</param>
/// <returns><c>True</c> if the evaluation succeeded.</returns>
public bool TryEvaluate(REnvironment environment, out SymbolicExpression result)
{
if (environment == null)
{
throw new ArgumentNullException("environment");
}
if (Engine != environment.Engine)
{
throw new ArgumentException(null, "environment");
}
bool errorOccurred;
IntPtr pointer = this.GetFunction<R_tryEval>()(handle, environment.DangerousGetHandle(), out errorOccurred);
result = errorOccurred ? null : new SymbolicExpression(Engine, pointer);
return !errorOccurred;
}
static void Main(string[] args)
{
var e = REngine.GetInstance();
e.Initialize();
int n = 200000;
var memBefore = GC.GetTotalMemory(true);
var sexpressions = new SymbolicExpression[n];
for (int i = 0; i < n; i++)
{
sexpressions[i] = e.Evaluate("'abc'");
}
var mem2 = GC.GetTotalMemory(true);
sexpressions = null;
GC.Collect();
GC.Collect();
var mem3 = GC.GetTotalMemory(true);
}
/// <summary>
/// Defines a symbol in this environment.
/// </summary>
/// <param name="name">The name.</param>
/// <param name="expression">The symbol.</param>
public void SetSymbol(string name, SymbolicExpression expression)
{
if (name == null)
{
throw new ArgumentNullException("name", "'name' cannot be null");
}
if (name == string.Empty)
{
throw new ArgumentException("'name' cannot be an empty string");
}
if (expression == null)
{
expression = Engine.NilValue;
}
if (expression.Engine != this.Engine)
{
throw new ArgumentException();
}
IntPtr installedName = this.GetFunction<Rf_install>()(name);
this.GetFunction<Rf_defineVar>()(installedName, expression.DangerousGetHandle(), handle);
}
static void Main(string[] args)
{
//double a = 43.52;
//double b = 40000566.78234234;
//double max;
//Stopwatch sw = Stopwatch.StartNew();
//sw.Restart();
//max = SergeysBitwiseMax(a, b);
//sw.Stop();
//Console.WriteLine("SergeysBitwiseMax(" + a + ", " + b + ") = " + max + " took " + ElapsedNanoSeconds(sw) + " ns!");
//sw.Restart();
//max = Math.Max(a, b);
//sw.Stop();
//Console.WriteLine("Math.Max(" + a + ", " + b + ") = " + max + " took " + ElapsedNanoSeconds(sw) + " ns!");
SymbolicExpression ident = new SymbolicExpression("symbolic");
Console.WriteLine(ident);
SimpleExpression <SymbolicValue> SymbolicSE = new SymbolicExpression("symbolic_exspression");
Console.WriteLine(SymbolicSE.GetValue());
SymbolicValue sv = new SymbolicValue("sv");
IValue <AValue> sive = sv;
dynamic dsv = new SymbolicValue("sv");
object osv = new SymbolicValue("sv");
Console.WriteLine(sv.Equals(dsv));
Console.WriteLine(dsv.Equals(sv));
Console.WriteLine(dsv.Equals(sive));
Console.WriteLine(osv.Equals(dsv));
Console.WriteLine(sv.Equals(osv));
Console.WriteLine(osv.Equals(sv));
Console.WriteLine(osv.Equals(sive));
Console.WriteLine(sive.Equals(osv));
IExpression <IValue <AValue> > sSV = SymbolicSE;
List <IExpression <IValue <AValue> > > aivL = new List <IExpression <IValue <AValue> > >();
aivL.Add(sSV);
aivL.Add(SymbolicSE);
NumericExpression n = new NumericExpression(6.7);
Console.WriteLine(n.GetValue());
SimpleExpression <NumericValue> NumericSE = new NumericExpression(3.4);
Console.WriteLine(NumericSE.GetValue());
FunctionInvocation <int> f = new FunctionInvocation <int>(
delegate(object[] parameters)
{
int sum = 0;
foreach (object parameter in parameters)
{
sum += (int)parameter;
}
return(new NumericValue(sum));
},
5, 7, 8);
Console.WriteLine("!! FunctionInvocation !! " + f.GetValue());
// money
Money <SymbolicValue> moneyFromSymbolicValue = new Money <SymbolicValue>(ident, Currency.GBP);
Console.WriteLine(moneyFromSymbolicValue.GetValue());
Money <SymbolicValue> moneyFromSymbolicExpression = new Money <SymbolicValue>(SymbolicSE, Currency.GBP);
Console.WriteLine(moneyFromSymbolicExpression.GetValue());
Money <NumericValue> moneyFromNumericValue = new Money <NumericValue>(n, Currency.GBP);
Console.WriteLine(moneyFromNumericValue.GetValue());
Money <NumericValue> moneyFromNumericExpression = new Money <NumericValue>(NumericSE, Currency.GBP);
Console.WriteLine(moneyFromNumericExpression.GetValue());
// percentage
Percentage <SymbolicValue> symSEPerc = new Percentage <SymbolicValue>(SymbolicSE);
Console.WriteLine(symSEPerc);
Percentage <NumericValue> numPerc = new Percentage <NumericValue>(n);
Console.WriteLine(numPerc);
// Ratio
Ratio <SymbolicValue> symbolicRatio = new Ratio <SymbolicValue>(ident);
Console.WriteLine(symbolicRatio);
Ratio <Value> funcInvRatio = new Ratio <Value>(f);
Console.WriteLine(funcInvRatio);
Ratio <NumericValue> percNumRatio = new Ratio <NumericValue>(numPerc);
Console.WriteLine(percNumRatio);
// participation
Participation <SymbolicValue> symbolicRatioParticipation = new Participation <SymbolicValue>(symbolicRatio);
Console.WriteLine(symbolicRatioParticipation);
Participation <Value> funcInvRatioParticipation = new Participation <Value>(funcInvRatio);
Console.WriteLine(funcInvRatioParticipation);
Participation <NumericValue> percNumRatioParticipation = new Participation <NumericValue>(percNumRatio);
Console.WriteLine(percNumRatioParticipation);
// _Limit specification
LimitSpecification <MoneyValue <SymbolicValue> > moneyFromSymbolicExpressionPayoutSpec =
new LimitSpecification <MoneyValue <SymbolicValue> >(moneyFromSymbolicExpression);
Console.WriteLine(moneyFromSymbolicExpressionPayoutSpec);
LimitSpecification <MoneyValue <NumericValue> > moneyFromNumericValuePayoutSpec =
new LimitSpecification <MoneyValue <NumericValue> >(moneyFromNumericValue, true);
Console.WriteLine(moneyFromNumericValuePayoutSpec);
LimitSpecification <NumericValue> numPercPayoutSpec =
new LimitSpecification <NumericValue>(numPerc, true);
Console.WriteLine(numPercPayoutSpec);
// _Limit
Limit <MoneyValue <SymbolicValue> > moneyFromSymbolicExpressionPayout
= new Limit <MoneyValue <SymbolicValue> >(moneyFromSymbolicExpressionPayoutSpec, 1);
// _Attachment
Attachment <NumericValue> NumericSEAttachment = new Attachment <NumericValue>(NumericSE);
// cover
Cover <NumericValue, MoneyValue <SymbolicValue>, NumericValue> coverNumSymbNum
= new Cover <NumericValue, MoneyValue <SymbolicValue>, NumericValue>(percNumRatioParticipation, moneyFromSymbolicExpressionPayout, NumericSEAttachment);
Console.WriteLine(coverNumSymbNum);
ICover <Value, Value, Value> cNSN
= (ICover <Value, Value, Value>)coverNumSymbNum;
Cover <SymbolicValue> coverNumShareNumPayout
= new Cover <SymbolicValue>(symbolicRatioParticipation, "\"MyCoverLabel\"");
Console.WriteLine(coverNumShareNumPayout);
Console.ReadKey();
}
/// <summary>
///
/// </summary>
/// <param name="data"></param>
/// <param name="spec"></param>
/// <param name="constraint"></param>
/// <returns></returns>
public static fPortfolio efficientPortfolio(SymbolicExpression data, SymbolicExpression spec, SymbolicExpression constraint)
{
Initialize();
var expr = efficientPortfolio().Invoke(new SymbolicExpression[] { data, spec, constraint });
return(new fPortfolio(expr));
}
public static void AddDiffTimeAttributes(SymbolicExpression result)
{
SetClassAttribute(result, "difftime"); // class(as.difftime(3.5, units='secs'))
SetUnitsAttribute(result, "secs"); // unclass(as.difftime(3.5, units='secs'))
}
public SymbolicExpression SaveHistory(Language call, SymbolicExpression operation, Pairlist args, REnvironment environment)
{
throw new NotImplementedException();
}
public static void SetAttribute(SymbolicExpression sexp, string[] attribValues, string attributeName = "names")
{
var names = new CharacterVector(engine, attribValues);
sexp.SetAttribute(attributeName, names);
}
public static void AddPosixctAttributes(SymbolicExpression result)
{
SetClassAttribute(result, "POSIXct", "POSIXt");
SetTzoneAttribute(result, "UTC");
}
public SymbolicExpression AddHistory(Language call, SymbolicExpression operation, Pairlist args, REnvironment environment)
{
return(null);
}
public static void SetUnitsAttribute(SymbolicExpression sexp, string units)
{
SetAttribute(sexp, new[] { units }, attributeName: "units");
}
public static SymbolicExpression AddDiffTimeAttributes(this SymbolicExpression sexp, string units = SECS)
{
sexp.SetAttribute("class", sexp.Engine.CreateCharacterVector(new[] { "difftime" }));
sexp.SetAttribute("units", sexp.Engine.CreateCharacterVector(new[] { units }));
return(sexp);
}
public static bool IsPosixlt(this SymbolicExpression sexp)
{
return(sexp.GetAttributeNames().Any(p => string.Equals("class", p)) &&
sexp.GetAttribute("class").AsCharacter().ToArray().Any(p => string.Equals("POSIXlt", p)));
}
public static bool IsDiffTime(this SymbolicExpression sexp)
{
return(sexp.GetAttributeNames().Any(p => string.Equals("class", p)) &&
sexp.GetAttribute("class").AsCharacter().ToArray().Any(p => string.Equals("difftime", p)));
}
public static SymbolicExpression AddPosixctAttributes(this SymbolicExpression sexp, IEnumerable <string> tzone)
{
sexp.SetAttribute("class", sexp.Engine.CreateCharacterVector(new[] { "POSIXct", "POSIXt" }));
sexp.SetAttribute("tzone", sexp.Engine.CreateCharacterVector(tzone));
return(sexp);
}
/// <summary>
/// Return the NULL SEXP; no other effect
/// </summary>
/// <param name="call"></param>
/// <param name="operation"></param>
/// <param name="args"></param>
/// <param name="environment"></param>
/// <returns></returns>
public SymbolicExpression AddHistory(Language call, SymbolicExpression operation, Pairlist args, REnvironment environment)
{
return(environment.Engine.NilValue);
}
private static void AddSexpHandle(SymbolicExpression sexp)
{
handles.Add(sexp);
}
private void runPrint(SymbolicExpression obj)
{
var func = Engine.Evaluate("print").AsFunction();
func.Invoke(new SymbolicExpression[] { obj });
}
public static void SetTzoneAttribute(SymbolicExpression sexp, string tzoneId)
{
SetAttribute(sexp, new[] { tzoneId }, attributeName: "tzone");
}
public SymbolicExpressionWrapper(SymbolicExpression sexp)
{
this.Sexp = sexp;
counter++;
}
public static void SetClassAttribute(SymbolicExpression sexp, params string[] classes)
{
SetAttribute(sexp, classes, attributeName: "class");
}
public static string GetTzoneAttrib(SymbolicExpression sexp)
{
var v = GetAttrib(sexp, "tzone");
if (v == null) return null; else return v[0];
}
private static Tuple<string, SymbolicExpression>[] CreateNamedArgs(SymbolicExpression[] colVectors, string[] columnNames)
{
if (columnNames != null && colVectors.Length != columnNames.Length)
throw new ArgumentException("columnNames", "when not null, the number of column names must match the number of SEXP");
var args = new List<Tuple<string, SymbolicExpression>>();
for (int i = 0; i < colVectors.Length; i++)
args.Add(Tuple.Create(columnNames != null ? columnNames[i] : "", colVectors[i]));
return args.ToArray();
}
public static string[] GetClassAttrib(SymbolicExpression sexp)
{
return GetAttrib(sexp, "class");
}
/// <summary>
/// Invoke this function with unnamed arguments.
/// </summary>
/// <param name="args">The arguments passed to function call.</param>
/// <returns>The result of the function evaluation.</returns>
protected SymbolicExpression InvokeOrderedArguments(SymbolicExpression[] args)
{
IntPtr argument = Engine.NilValue.DangerousGetHandle();
foreach (SymbolicExpression arg in args.Reverse())
{
argument = this.GetFunction<Rf_cons>()(arg.DangerousGetHandle(), argument);
}
return createCallAndEvaluate(argument);
}
private static IEnumerable<string> MapAsEmpty(SymbolicExpression sexp)
{
//TODO: Report missing mappers.
return Enumerable.Empty<string>();
}
private void checkInvoke(SymbolicExpression result, string expected)
{
Assert.AreEqual(expected, result.AsCharacter().ToArray()[0]);
}
/// <summary>
/// Assign a value to a name in the global environment.
/// </summary>
/// <param name="name">The name.</param>
/// <param name="expression">The symbol.</param>
public void SetSymbol(string name, SymbolicExpression expression)
{
CheckEngineIsRunning();
GlobalEnvironment.SetSymbol(name, expression);
}
public SymbolicExpression SaveHistory(Language call, SymbolicExpression operation, Pairlist args, REnvironment environment)
{
throw new NotImplementedException();
}
public static bool IsOfClass(SymbolicExpression sexp, string className)
{
var classNames = GetClassAttrib(sexp);
if (classNames == null) return false;
return classNames.Contains(className);
}
internal void Execute(string callStr)
{
ret = engine.Evaluate(callStr);
}
public static bool TryConvertBack(REngine engine, RDotNetConverter dataConverter, object data, out SymbolicExpression result)
{
var type = data.GetType();
if (type.IsGenericType)
{
var genericTypeDefinition = type.GetGenericTypeDefinition();
if (dictionaryTypeDefinitions.Contains(genericTypeDefinition))
{
var genericArguments = type.GetGenericArguments();
if (genericArguments[0] == typeof(string))
{
if (dicoToSexpMethod.MakeGenericMethod(new[] { genericArguments[1] })
.Invoke(null, new[] { engine, dataConverter, data }) is SymbolicExpression sexp)
{
result = sexp;
return(true);
}
}
}
if (listTypeDefinitions.Contains(genericTypeDefinition))
{
if (data is IEnumerable enumerable)
{
result = new GenericVector(engine, ListToSexp(engine, dataConverter, enumerable));
return(true);
}
}
}
if (type.IsArray)
{
if (data is IEnumerable array)
{
result = new GenericVector(engine, ListToSexp(engine, dataConverter, array));
return(true);
}
}
result = engine.NilValue;
return(false);
}
private static IEnumerable<string> MapComplexVector(SymbolicExpression sexp)
{
var mapped = sexp.AsComplex().Select(s => s.ToString());
return mapped;
}
public static SymbolicExpression GetTaylor(int k, SymbolicExpression symbol, SymbolicExpression a, SymbolicExpression x)
{
int factorial = 1;
SymbolicExpression accumulator = SymbolicExpression.Zero;
SymbolicExpression derivative = x;
for (int i = 0; i < k; i++)
{
var subs = derivative.Substitute(symbol, a);
derivative = derivative.Differentiate(symbol);
accumulator = accumulator.Add(subs / factorial * (symbol.Subtract(a)).Pow(i));
factorial *= (i + 1);
}
return accumulator.Expand();
}
/// <summary>
/// Return the NULL SEXP; no other effect
/// </summary>
/// <param name="call"></param>
/// <param name="operation"></param>
/// <param name="args"></param>
/// <param name="environment"></param>
/// <returns></returns>
public SymbolicExpression AddHistory(Language call, SymbolicExpression operation, Pairlist args, REnvironment environment)
{
return environment.Engine.NilValue;
}
private static object ReturnHandle(SymbolicExpression sexp)
{
AddSexpHandle(sexp);
return(sexp.DangerousGetHandle());
}
/// <summary>
/// Assign a value to a name in a specific environment.
/// </summary>
/// <param name="name">The name.</param>
/// <param name="expression">The symbol.</param>
/// <param name="environment">The environment. If <c>null</c> is passed, <see cref="GlobalEnvironment"/> is used.</param>
public void SetSymbol(string name, SymbolicExpression expression, REnvironment environment)
{
CheckEngineIsRunning();
if (environment == null)
{
environment = GlobalEnvironment;
}
environment.SetSymbol(name, expression);
}
private fPortfolio(SymbolicExpression expression)
: base(expression)
{
}
