public static Matrix map(Matrix m, LambdaExpression mapper, VariableContext vc)
{
ExpressionEvaluator evaluator = new MathyLanguageService().CreateEvaluator();
List <List <double> > result = new List <List <double> >();
double[] row = new double[m.ColumnCount];
for (int i = 0; i <= m.RowCount - 1; i++)
{
for (int j = 0; j <= m.ColumnCount - 1; j++)
{
row[j] = m[i, j];
}
vc.Set(mapper.VariableNames[0], row.Where(c => !double.IsNaN(c)).ToArray());
if (mapper.VariableNames.Length > 1)
{
vc.Set(mapper.VariableNames[1], i);
}
double[] mappedRow;
var obj = evaluator.Evaluate(mapper.Body, vc);
try
{
mappedRow = (double[])obj;
}
catch (Exception ex)
{
var a = (object[])obj;
mappedRow = (double[])a[0];
}
result.Add(new List <double>());
for (int j = 0; j <= mappedRow.Length - 1; j++)
{
result[i].Add(mappedRow[j]);
}
}
vc.Remove(mapper.VariableNames[0]);
List <double> cells = new List <double>();
foreach (List <double> resultRow in result)
{
foreach (double cell in resultRow)
{
cells.Add(cell);
}
}
return(new Matrix(m.RowCount, result[0].Count, cells.ToArray()));
}
private static object[] map(object[] items, LambdaExpression mapper, VariableContext vc)
{
ExpressionEvaluator evaluator = new MathyLanguageService().CreateEvaluator();
object[] result = new object[items.Length];
for (int i = 0; i <= items.Length - 1; i++)
{
vc.Set(mapper.VariableNames[0], items[i]);
result[i] = evaluator.Evaluate(mapper.Body, vc);
}
vc.Remove(mapper.VariableNames[0]);
return(result);
}
public static object eval(Expression expression, Dictionary <string, object> variables, VariableContext vc)
{
foreach (string variableName in variables.Keys)
{
vc.Set(variableName, variables[variableName]);
}
object result = new MathyLanguageService().CreateEvaluator().Evaluate(expression is VariableContextExpression ? (expression as VariableContextExpression).Expression : expression, vc);
foreach (string variableName in variables.Keys)
{
vc.Remove(variableName);
}
return(result);
}
public static Expression Diff(Expression e, string x, Dictionary <string, object> variables)
{
VariableContext c = Funcs.CreateVariableContext(variables);
Expression diff = new Differ(e, x).Calculate(c);
foreach (string variableName in variables.Keys)
{
c.Set(variableName, variables[variableName]);
}
new MathyLanguageService().CreateTypeChecker().PerformTypeChecking(diff, new MathyLanguageService().CreateTypeCheckingContext(c));
diff = new Cherimoya.Reduction.ExpressionReductor(new MathyLanguageService()).Reduce(diff);
foreach (string variableName in variables.Keys)
{
c.Remove(variableName);
}
return(diff);
}
private object EvaluateIterationSumExpression(IterationSumExpression e, VariableContext context)
{
int[] values = new int[e.Variables.Length];
int[] fromValues = new int[e.Variables.Length];
int[] toValues = new int[e.Variables.Length];
int index = 0;
foreach (IterationSumVariable variable in e.Variables)
{
if (context.HasVariable(variable.Name))
{
throw new Exception(string.Format("Iteration variable {0} is already in use.", variable.Name));
}
fromValues[index] = Types.ConvertValue <int>(Evaluate(variable.From, context));
toValues[index] = Types.ConvertValue <int>(Evaluate(variable.To, context));
context.Set(variable.Name, fromValues[index]);
values[index] = fromValues[index];
index++;
}
double sum = 0;
while (true)
{
double value = Types.ConvertValue <double>(Evaluate(e.Body, context));;
if (!double.IsNaN(value))
{
sum += value;
}
if (!IncreaseIterationValues(values, fromValues, toValues))
{
break;
}
else
{
for (int i = 0; i <= e.Variables.Length - 1; i++)
{
context.Set(e.Variables[i].Name, values[i]);
}
}
}
foreach (IterationSumVariable variable in e.Variables)
{
context.Remove(variable.Name);
}
return(sum);
}