public static VariableContextExpression diff(VariableContextExpression expression, string variableName)
{
VariableContext c = expression.VariableContext;
Expression diff = new Differ(expression.Expression, variableName).Calculate(c);
TypeCheckingContext context = new MathyLanguageService().CreateTypeCheckingContext(c);
foreach (VariableInfo variable in expression.Variables)
{
c.Set(variable.Name, context.CreateAutoCreatedVariableValue(variable.Type));
}
VariableContextExpression result = new VariableContextExpression(diff, expression.Variables, 0, 0)
{
VariableContext = expression.VariableContext
};
new MathyLanguageService().CreateTypeChecker().PerformTypeChecking(result, context);
result = new VariableContextExpression(new Cherimoya.Reduction.ExpressionReductor(new MathyLanguageService()).Reduce(diff), expression.Variables, 0, 0)
{
VariableContext = expression.VariableContext
};
new MathyLanguageService().CreateTypeChecker().PerformTypeChecking(result, context);
foreach (VariableInfo variable in expression.Variables)
{
context.VariableContext.Remove(variable.Name);
}
return(result);
}
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 VariableContext CreateVariebleContext()
{
VariableContext vc = MathyLanguageService.CreateVariableContext();
foreach (SourceVariable variable in plan.Variables)
{
vc.Set(variable.Name, DataFuncs.CreateDefaultValue(variable.Type));
}
return(vc);
}
public static VariableContext CreateVariableContext(Dictionary <string, object> variables)
{
VariableContext c = MathyLanguageService.CreateVariableContext();
foreach (string variableName in variables.Keys)
{
c.Set(variableName, variables[variableName]);
}
return(c);
}
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);
}
private VariableContext CreateVariableContext()
{
VariableContext vc = MathyLanguageService.CreateVariableContext();
foreach (Step step in Steps)
{
for (int i = 0; i <= step.InSourceVariables.Length - 1; i++)
{
object value = step.InValues[i];
if (value != null)
{
if (value is double)
{
value = Math.Round((double)value, Settings.DecimalDigitCount);
}
else if (value is double[])
{
value = (value as double[]).Where(j => !double.IsNaN(j)).Select(j => Math.Round(j, Settings.DecimalDigitCount)).ToArray();
}
else if (value is int[])
{
value = (value as int[]).Select(j => Math.Round((double)j, Settings.DecimalDigitCount)).ToArray();
}
else if (value is Vector)
{
Vector v = (value as Vector).Clone();
v.SetDecimalDigitCount(Settings.DecimalDigitCount);
value = v;
}
else if (value is Matrix)
{
Matrix m = (value as Matrix).Clone();
m.SetDecimalDigitCount(Settings.DecimalDigitCount);
value = m;
}
vc.Set(step.InSourceVariables[i].Name, value);
}
}
}
vc.Set("_EvaluationContext", this);
return(vc);
}
public bool EvaluateConditions(VariableContext vc)
{
List <bool> conditions = new List <bool>();
int index = 0;
foreach (Expression expression in Conditions)
{
object result = new MathyLanguageService().CreateEvaluator().Evaluate(expression, vc);
if (!(result is bool))
{
throw new Exception(string.Format("Condition {0} does not evaluate to boolean.", index));
}
else
{
conditions.Add((bool)result);
}
index++;
}
return(conditions.All(i => i));
}
public EvaluationContext Analyze()
{
VariableContext vc = CreateVariebleContext();
MathyLanguageService service = new MathyLanguageService();
List <Step> steps = new List <Step>();
List <string> existingInVariables = new List <string>();
int index = 0;
foreach (SourceExpression expression in plan.Expressions)
{
Step step = new Step();
step.SourceExpression = expression;
try
{
step.Expressions = service.Compile(expression.Expression, vc);
}
catch (CompileException ex)
{
throw new Exception(string.Format("步骤{0}表达式编译错误：\r\n{1}", index + 1, ex.Message));
}
if (string.IsNullOrEmpty(expression.Condition))
{
step.Conditions = new Expression[] { };
}
else
{
try
{
step.Conditions = service.Compile(expression.Condition, vc);
}
catch (CompileException ex)
{
throw new Exception(string.Format("步骤{0}条件编译错误：\r\n{1}", index + 1, ex.Message));
}
}
Bitmap expressionImage = new NodeVisualizer(
step.Expressions
.Select(i => new NodeConverter().Convert(i))
.ToArray()).VisulizeAsBitmap();
Bitmap conditionImage = step.Conditions.Length == 0 ? null :
new NodeVisualizer(
step.Conditions
.Select(i => new NodeConverter().Convert(i))
.ToArray()).VisulizeAsBitmap();
step.Image = StackImages(expressionImage, conditionImage);
step.ImageData = Funcs.ImageToBytes(step.Image);
step.OutVariables = CollectOutVariables(step.Expressions).ToArray();
string[] inVariables = CollectVariables(step.Expressions)
.Where(i => !step.OutVariables.Contains(i))
.ToArray();
string[] conditionVariables = CollectVariables(step.Conditions);
step.InSourceVariables = plan.Variables.Where(i => inVariables.Contains(i.Name) && !existingInVariables.Contains(i.Name)).ToArray();
step.InValues = new object[step.InSourceVariables.Length];
step.DependentVariables = plan.Variables.Where(i => inVariables.Contains(i.Name)).ToArray();
step.DependentValues = new object[step.DependentVariables.Length];
step.InTempVariables = inVariables.Where(i => plan.Variables.All(j => j.Name != i)).ToArray();
step.ConditionVariables = conditionVariables;
existingInVariables.AddRange(step.InSourceVariables.Select(i => i.Name));
steps.Add(step);
index++;
}
foreach (Step step in steps)
{
List <Step> froms = new List <Step>();
foreach (string tempVariable in step.InTempVariables)
{
froms.AddRange(steps.Where(i => i.OutVariables.Contains(tempVariable)));
}
foreach (string tempVariable in step.ConditionVariables)
{
froms.AddRange(steps.Where(i => i.OutVariables.Contains(tempVariable)));
}
step.Froms = froms.Where(i => i != null).Distinct().ToArray();
}
EvaluationContext context = new EvaluationContext(plan, steps.ToArray());
foreach (SourceVariable variable in plan.Variables)
{
context.SetValue(variable.Name, null);
}
return(context);
}
public static VariableContextExpression ucomb(VariableContextExpression func, Matrix r, Vector u)
{
int count = func.Variables.Length;
VariableContextExpression[] diffs = func.Variables.Select(i => ExpressionFuncs.diff(func, i.Name)).ToArray();
Expression e1 = null;
for (int i = 0; i <= count - 1; i++)
{
Expression right = BinaryExpression.Create(BinaryOperator.Multiply,
ConstantExpression.create(u[i] * u[i], 0, 0),
new FunctionCallExpression("pow",
new Expression[]
{
diffs[i].Expression,
ConstantExpression.create(2, 0, 0)
},
0,
0));
e1 = e1 == null ? right : BinaryExpression.Create(BinaryOperator.Add, e1, right);
}
Expression e2 = null;
for (int i = 1; i <= count - 1; i++)
{
for (int j = i + 1; j <= count; j++)
{
Expression right = BinaryExpression.Create(BinaryOperator.Multiply,
ConstantExpression.create(u[i - 1] * u[j - 1] * r[i - 1, j - 1], 0, 0),
BinaryExpression.Create(BinaryOperator.Multiply,
diffs[i - 1].Expression,
diffs[j - 1].Expression));
e2 = e2 == null ? right : BinaryExpression.Create(BinaryOperator.Add, e2, right);
}
}
e2 = BinaryExpression.Create(BinaryOperator.Multiply,
ConstantExpression.create(2, 0, 0),
e2);
Expression e = BinaryExpression.Create(BinaryOperator.Add,
e1,
e2);
VariableContext c = func.VariableContext;
TypeCheckingContext context = new MathyLanguageService().CreateTypeCheckingContext(c);
foreach (VariableInfo variable in func.Variables)
{
c.Set(variable.Name, context.CreateAutoCreatedVariableValue(variable.Type));
}
VariableContextExpression result = new VariableContextExpression(e, func.Variables, 0, 0)
{
VariableContext = func.VariableContext
};
new MathyLanguageService().CreateTypeChecker().PerformTypeChecking(result, context);
result = new VariableContextExpression(new Cherimoya.Reduction.ExpressionReductor(new MathyLanguageService()).Reduce(e), func.Variables, 0, 0)
{
VariableContext = func.VariableContext
};
new MathyLanguageService().CreateTypeChecker().PerformTypeChecking(result, context);
foreach (VariableInfo variable in func.Variables)
{
context.VariableContext.Remove(variable.Name);
}
return(result);
}
private static RenderBranch Create(double x, double y, int angle, TreeBranch branch, VariableContext variables, Graphics g, Font font)
{
double x2 = x - branch.Position * Math.Cos(angle * Math.PI / 180);
double y2 = y + branch.Position * Math.Sin(angle * Math.PI / 180);
double x1 = x2 + branch.Length * Math.Cos((angle + branch.Angle) * Math.PI / 180);
double y1 = y2 - branch.Length * Math.Sin((angle + branch.Angle) * Math.PI / 180);
double a = Funcs.Atan(x1, y1, x2, y2);
x2 = x1 + (branch.Length - 2) * Math.Cos(a);
y2 = y1 - (branch.Length - 2) * Math.Sin(a);
RenderBranch[] branches = branch.Branches.Select(i => Create(x2, y2, angle + branch.Angle - 180, i, variables, g, font)).ToArray();
string description;
double imageX = 0;
double imageY = 0;
Bitmap expressionImage = null;
if (branch is ExpressionBranch)
{
string[] preVariables = variables.GetAllVariables();
Expression[] expressions = new MathyLanguageService().Compile((branch as ExpressionBranch).Expression, variables);
foreach (Expression expression in expressions)
{
new MathyLanguageService().CreateEvaluator().Evaluate(expression, variables);
}
StringBuilder b = new StringBuilder();
foreach (string variableName in variables.GetAllVariables().Where(i => !preVariables.Contains(i)))
{
b.AppendFormat("{0}={1}", variableName, variables.GetValue(variableName));
}
description = branch.Description + "\r\n" + b.ToString();
double xt = x2 + (branch as ExpressionBranch).ImageX * Math.Cos(a + Math.PI);
double yt = y2 - (branch as ExpressionBranch).ImageX * Math.Sin(a + Math.PI);
double d = (branch as ExpressionBranch).ImageY;
imageX = xt + d * Math.Cos(a + Math.PI / 2);
imageY = yt - d * Math.Sin(a + Math.PI / 2);
expressionImage = new NodeVisualizer(expressions.Select(i => new NodeConverter().Convert(i)).ToArray()).VisulizeAsBitmap();
}
else
{
string variableName = (branch as VariableBranch).VariableName;
object value = variables.GetValue(variableName);
description = string.Format("{0}\r\n{1}={2}", branch.Description, variableName, value);
}
double dx;
double dy;
EvaluateDescriptionPosition(branch, description, x1, y1, x2, y2, g, font, out dx, out dy);
return(new RenderBranch()
{
X1 = x1,
Y1 = y1,
X2 = x2,
Y2 = y2,
IsVariable = branch is VariableBranch,
ImageX = imageX,
ImageY = imageY,
Image = expressionImage,
Branches = branches,
DescriptionX = dx,
DescriptionY = dy,
Description = description
});
}
