public bool Equal(Cdn.Expression other, bool asstring)
{
bool raw_ret = cdn_expression_equal(Handle, other == null ? IntPtr.Zero : other.Handle, asstring);
bool ret = raw_ret;
return(ret);
}
public Cdn.Expression[][] AllIndices()
{
int num = cdn_operator_num_indices(Handle);
if (num == 0)
{
return(new Cdn.Expression[0][]);
}
IntPtr rawret = cdn_operator_all_indices(Handle);
Cdn.Expression[][] ret;
IntPtr[] data = new IntPtr[num];
Marshal.Copy(rawret, data, 0, (int)num);
ret = new Cdn.Expression[num][];
for (int i = 0; i < num; ++i)
{
ret[i] = (Cdn.Expression[])GLib.Marshaller.ListPtrToArray(data[i],
typeof(GLib.SList),
false,
false,
typeof(Cdn.Expression));
}
return(ret);
}
public DelayedState(InstructionCustomOperator delayed, double delay, Cdn.Expression expr, Flags type) : base(delayed, expr, type)
{
d_delayed = delayed;
d_delay = delay;
d_size = new Size((uint)System.Math.Round(d_delay / Options.Instance.DelayTimeStep));
}
public EdgeAction(string target, Cdn.Expression equation) : base(IntPtr.Zero)
{
if (GetType() != typeof(EdgeAction))
{
ArrayList vals = new ArrayList();
ArrayList names = new ArrayList();
names.Add("target");
vals.Add(new GLib.Value(target));
if (equation != null)
{
names.Add("equation");
vals.Add(new GLib.Value(equation));
}
CreateNativeObject((string[])names.ToArray(typeof(string)), (GLib.Value[])vals.ToArray(typeof(GLib.Value)));
}
else
{
IntPtr native_target = GLib.Marshaller.StringToPtrGStrdup(target);
Raw = cdn_edge_action_new(native_target, equation == null ? IntPtr.Zero : equation.Handle);
GLib.Marshaller.Free(native_target);
}
if (Raw != IntPtr.Zero)
{
g_object_ref_sink(Raw);
}
}
public Cdn.Expression ToExpression()
{
IntPtr raw_ret = cdn_expression_tree_iter_to_expression(Handle);
Cdn.Expression ret = GLib.Object.GetObject(raw_ret) as Cdn.Expression;
return(ret);
}
public Variable(string name, Cdn.Expression expression, Cdn.VariableFlags flags) : base(IntPtr.Zero)
{
if (GetType() != typeof(Variable))
{
ArrayList vals = new ArrayList();
ArrayList names = new ArrayList();
names.Add("name");
vals.Add(new GLib.Value(name));
if (expression != null)
{
names.Add("expression");
vals.Add(new GLib.Value(expression));
}
names.Add("flags");
vals.Add(new GLib.Value(flags));
CreateNativeObject((string[])names.ToArray(typeof(string)), (GLib.Value[])vals.ToArray(typeof(GLib.Value)));
return;
}
IntPtr native_name = GLib.Marshaller.StringToPtrGStrdup(name);
Raw = cdn_variable_new(native_name, expression == null ? IntPtr.Zero : expression.Handle, (int)flags);
GLib.Marshaller.Free(native_name);
if (Raw != IntPtr.Zero)
{
g_object_ref_sink(Raw);
}
}
public bool DependsOn(Cdn.Expression depends_on)
{
bool raw_ret = cdn_expression_depends_on(Handle, depends_on == null ? IntPtr.Zero : depends_on.Handle);
bool ret = raw_ret;
return(ret);
}
public Cdn.EdgeAction GetActionWithIndexAndPhases(string target, Cdn.Expression index, GLib.SList phases)
{
IntPtr native_target = GLib.Marshaller.StringToPtrGStrdup(target);
IntPtr raw_ret = cdn_edge_get_action_with_index_and_phases(Handle, native_target, index == null ? IntPtr.Zero : index.Handle, phases == null ? IntPtr.Zero : phases.Handle);
Cdn.EdgeAction ret = GLib.Object.GetObject(raw_ret) as Cdn.EdgeAction;
GLib.Marshaller.Free(native_target);
return(ret);
}
public static Cdn.Expression Sum(Cdn.Expression[] expressions)
{
GLib.SList list = new GLib.SList(expressions, typeof(Cdn.Expression), true, false);
IntPtr raw_ret = cdn_expression_sum(list == null ? IntPtr.Zero : list.Handle);
Cdn.Expression ret = GLib.Object.GetObject(raw_ret) as Cdn.Expression;
return(ret);
}
private void Expand()
{
if (d_expression != null)
{
return;
}
if (d_expressionUnexpanded != null)
{
d_expression = Knowledge.Instance.ExpandExpression(d_expressionUnexpanded);
return;
}
List <Cdn.Expression> exprs = new List <Cdn.Expression>();
Variable v = d_object as Variable;
if (d_actions.Length != 0)
{
foreach (EdgeAction action in d_actions)
{
Cdn.Variable subvar;
if (Knowledge.Instance.EventActionProperties.TryGetValue(action, out subvar))
{
Cdn.Expression e = new Cdn.Expression(subvar.Name);
e.Instructions = new Cdn.Instruction[] { new Cdn.InstructionVariable(subvar) };
exprs.Add(e);
}
else
{
exprs.Add(action.Equation);
}
}
}
else
{
if (v != null)
{
exprs.Add(v.Expression);
}
else
{
Expression e = d_object as Expression;
if (e != null)
{
exprs.Add(e);
}
}
}
Dictionary <Instruction, Instruction> instmap = new Dictionary <Instruction, Instruction>();
d_expression = Knowledge.Instance.ExpandExpression(instmap, exprs.ToArray());
Knowledge.Instance.UpdateInstructionMap(instmap);
}
private void Resolve(Node node, Cdn.Expression expression, HashSet <Cdn.Expression> seen, Dictionary <object, State> mapping)
{
if (seen.Contains(expression))
{
return;
}
Resolve(node, expression.Instructions, seen, mapping);
}
private Cdn.Expression Inline(Dictionary <Instruction, Instruction> instmap, Cdn.Expression expr)
{
List <Cdn.Instruction> instructions = new List <Instruction>();
foreach (Instruction inst in expr.Instructions)
{
InstructionVariable variable = inst as InstructionVariable;
if (variable != null)
{
// See if we need to expand it
Variable v = variable.Variable;
if (State(v) == null)
{
if (variable.HasSlice)
{
// Need to promote it here. Inlining a slice is
// complicated
var s = ExpandedState(v);
AddState(null, s);
AddAux(s, null);
}
else
{
var sub = Inline(instmap, v.Expression);
// Expand the instruction
foreach (var i in sub.Instructions)
{
instructions.Add(i);
}
continue;
}
}
}
var cp = inst.Copy() as Instruction;
if (instmap != null)
{
instmap.Add(inst, cp);
}
instructions.Add(cp);
}
var e = new Cdn.Expression("");
e.SetInstructionsTake(instructions.ToArray());
return(e);
}
public Function(string name, Cdn.Expression expression) : base(IntPtr.Zero)
{
if (GetType() != typeof(Function))
{
throw new InvalidOperationException("Can't override this constructor.");
}
IntPtr native_name = GLib.Marshaller.StringToPtrGStrdup(name);
Raw = cdn_function_new(native_name, expression == null ? IntPtr.Zero : expression.Handle);
GLib.Marshaller.Free(native_name);
}
public Cdn.Expression Copy()
{
IntPtr raw_ret = cdn_expression_copy(Handle);
if (raw_ret != IntPtr.Zero)
{
g_object_ref_sink(Raw);
}
Cdn.Expression ret = GLib.Object.GetObject(raw_ret, true) as Cdn.Expression;
return(ret);
}
public Cdn.EdgeAction AddAction(string target, Cdn.Expression expression)
{
Cdn.EdgeAction action = new Cdn.EdgeAction(target, expression);
if (AddAction(action))
{
return(action);
}
else
{
return(null);
}
}
protected virtual void OnExpressionChanged(Cdn.Expression expression)
{
GLib.Value ret = GLib.Value.Empty;
GLib.ValueArray inst_and_params = new GLib.ValueArray(2);
GLib.Value[] vals = new GLib.Value [2];
vals [0] = new GLib.Value(this);
inst_and_params.Append(vals [0]);
vals [1] = new GLib.Value(expression);
inst_and_params.Append(vals [1]);
g_signal_chain_from_overridden(inst_and_params.ArrayPtr, ref ret);
foreach (GLib.Value v in vals)
{
v.Dispose();
}
}
public FunctionArgument(string name, Cdn.Expression defaultValue, bool isexplicit) : base(IntPtr.Zero)
{
if (GetType() != typeof(FunctionArgument))
{
throw new InvalidOperationException("Can't override this constructor.");
}
IntPtr native_name = GLib.Marshaller.StringToPtrGStrdup(name);
Raw = cdn_function_argument_new(native_name, defaultValue != null ? defaultValue.Handle : IntPtr.Zero, isexplicit);
GLib.Marshaller.Free(native_name);
if (Raw != IntPtr.Zero)
{
g_object_ref_sink(Raw);
}
}
public Cdn.Expression ExpandExpression(Dictionary <Instruction, Instruction> instmap, params Cdn.Expression[] expressions)
{
if (expressions.Length == 0)
{
var ret = new Cdn.Expression("0");
ret.Compile(null, null);
return(ret);
}
List <Cdn.Expression> inlined = new List <Expression>();
for (int i = 0; i < expressions.Length; ++i)
{
inlined.Add(Inline(instmap, expressions[i]));
}
return(Cdn.Expression.Sum(inlined.ToArray()));
}
private IEnumerable <VariableDependency> VariableExpressionDependencies(Cdn.Expression expr)
{
if (expr == null)
{
return(new VariableDependency[] {});
}
if (s_variableDependencies == null)
{
s_variableDependencies = new Dictionary <Cdn.Expression, List <VariableDependency> >();
}
List <VariableDependency> lst;
if (s_variableDependencies.TryGetValue(expr, out lst))
{
return(lst);
}
lst = new List <VariableDependency>();
s_variableDependencies[expr] = lst;
foreach (var instr in expr.Instructions)
{
InstructionVariable v = instr as InstructionVariable;
if (v != null)
{
lst.Add(new VariableDependency {
Variable = v.Variable, Instruction = v
});
}
}
foreach (var ex in expr.Dependencies)
{
lst.AddRange(VariableExpressionDependencies(ex));
}
return(lst);
}
public Event(string id, Cdn.Expression condition, double approximation) : base(IntPtr.Zero)
{
if (GetType() != typeof(Event))
{
ArrayList vals = new ArrayList();
ArrayList names = new ArrayList();
names.Add("id");
vals.Add(new GLib.Value(id));
if (condition != null)
{
names.Add("condition");
vals.Add(new GLib.Value(condition));
}
names.Add("approximation");
vals.Add(new GLib.Value(approximation));
CreateNativeObject((string[])names.ToArray(typeof(string)), (GLib.Value[])vals.ToArray(typeof(GLib.Value)));
return;
}
IntPtr native_id = GLib.Marshaller.StringToPtrGStrdup(id);
Raw = cdn_event_new(native_id, condition == null ? IntPtr.Zero : condition.Handle, approximation);
GLib.Marshaller.Free(native_id);
}
public State(object obj, Cdn.Expression expr, Flags type, params EdgeAction[] actions)
{
d_object = obj;
d_actions = actions;
if (d_actions == null)
{
d_actions = new EdgeAction[0];
}
Variable variable = obj as Variable;
if (variable != null && variable.HasFlag(VariableFlags.Integrated))
{
d_type = Flags.Integrated;
}
if (expr != null)
{
d_expressionUnexpanded = expr;
}
d_type |= type;
}
public void AddSetVariable(Cdn.Variable variable, Cdn.Expression value)
{
cdn_event_add_set_variable(Handle, variable == null ? IntPtr.Zero : variable.Handle, value == null ? IntPtr.Zero : value.Handle);
}
public void Generate()
{
Profile.Do("load network", () => {
LoadNetwork();
});
if (Options.Instance.Validate)
{
d_validator = new Validator(d_network);
}
if (Options.Instance.DelayTimeStep > 0)
{
Cdn.Expression expr = new Cdn.Expression(Options.Instance.DelayTimeStep.ToString("R"));
Cdn.Instruction[] instr = new Cdn.Instruction[1];
instr[0] = new Cdn.InstructionNumber(Options.Instance.DelayTimeStep);
expr.Instructions = instr;
d_network.Integrator.AddVariable(new Cdn.Variable("delay_dt", expr, Cdn.VariableFlags.Out));
}
Profile.Do("initialize knowledge", () => {
// Initialize the knowledge
Knowledge.Initialize(d_network);
});
if (!Options.Instance.NoSparsity)
{
Profile.Do("sparsity", () => {
var sparsity = new Sparsity();
sparsity.Optimize();
});
}
var t = Profile.Begin("collect");
// Collect all the equations
Tree.Collectors.Result collection = Collect();
t.End();
t = Profile.Begin("filter");
// Filter conflicts and resolve final embeddings
Tree.Embedding[] embeddings = Filter(collection);
t.End();
t = Profile.Begin("resolve equations");
// Resolve final equations
Dictionary <State, Tree.Node> equations = ResolveEquations(embeddings);
t.End();
// Create program
t = Profile.Begin("create program");
Programmer.Program program = new Programmer.Program(ProgrammerOptions(), embeddings, equations);
t.End();
bool outistemp = false;
// Write program
if (Options.Instance.Validate || Options.Instance.Compile)
{
// Create a new temporary directory for the output files
string path = Path.GetTempFileName();
File.Delete(path);
Directory.CreateDirectory(path);
program.Options.Output = path;
outistemp = true;
}
else
{
Directory.CreateDirectory(program.Options.Output);
}
t = Profile.Begin("write program");
d_writtenFiles = Options.Instance.Formatter.Write(program);
t.End();
if (Options.Instance.PrintCompileSource)
{
foreach (string filename in d_writtenFiles)
{
Console.WriteLine("File: {0}", filename);
Console.WriteLine(File.ReadAllText(filename));
}
}
if (Options.Instance.Validate && !Options.Instance.PrintCompileSource)
{
try
{
d_validator.Validate(program, d_writtenFiles);
}
catch (Exception e)
{
Console.Error.WriteLine(e.Message);
Directory.Delete(program.Options.Output, true);
Environment.Exit(1);
}
}
else if (Options.Instance.Compile)
{
var files = Options.Instance.Formatter.Compile(Options.Instance.Verbose);
if (Options.Instance.Verbose)
{
Log.WriteLine("Compiled {0}...", String.Join(", ", Array.ConvertAll <string, string>(files, a => Path.GetFileName(a))));
}
if (!String.IsNullOrEmpty(Options.Instance.Output))
{
try
{
Directory.CreateDirectory(Options.Instance.Output);
}
catch
{
}
}
foreach (var f in files)
{
var dest = Path.GetFileName(f);
if (!String.IsNullOrEmpty(Options.Instance.Output))
{
dest = Path.Combine(Options.Instance.Output, dest);
}
try
{
File.Delete(dest);
} catch {}
File.Move(f, dest);
}
}
if (outistemp)
{
try
{
Directory.Delete(program.Options.Output, true);
} catch {};
}
}
public ExpressionTreeIter(Cdn.Expression expression)
{
Raw = cdn_expression_tree_iter_new(expression == null ? IntPtr.Zero : expression.Handle);
}
private void PromoteEdgeSlices()
{
// This function splits all the edge actions on variables based
// on the slice on which the operate on the target variable.
var cp = d_actionedVariables;
d_actionedVariables = new Dictionary <Variable, EdgeAction[]>();
foreach (var pair in cp)
{
var variable = pair.Key;
var actions = pair.Value;
var split = SplitActionsPerSlice(actions);
if (split.Count == 1)
{
// That's ok, no diversity means we can just use the
// normal code path
d_actionedVariables[pair.Key] = pair.Value;
continue;
}
// Contains a set of instructions for each value in the matrix
// representing the final, new equation. Each value in the matrix
// is a set of instructions because it can be a sum
List <Cdn.Instruction>[] instructions = new List <Instruction> [variable.Dimension.Size()];
// Ai! Cool stuff needs to happen here. Split out new
// variables for these equations and setup a new edge action
// representing the fully combined set. Complex you say? Indeed!
foreach (var elem in split)
{
// Combine elements with the same indices by simply doing a sum
var eqs = Array.ConvertAll <Cdn.EdgeAction, Cdn.Expression>(elem.ToArray(), a => a.Equation);
Cdn.Expression sum = Cdn.Expression.Sum(eqs);
// Now make a variable for it
var nv = new Cdn.Variable(UniqueVariableName(variable.Object, String.Format("__d{0}", variable.Name)), sum, VariableFlags.None);
variable.Object.AddVariable(nv);
// Add relevant instructions as per slice
var slice = elem[0].Indices;
if (slice == null || slice.Length == 0)
{
// Empty slice is just the full range
slice = new int[variable.Dimension.Size()];
for (int i = 0; i < slice.Length; ++i)
{
slice[i] = i;
}
}
for (int i = 0; i < slice.Length; ++i)
{
if (instructions[slice[i]] == null)
{
instructions[slice[i]] = new List <Instruction>();
}
var vinstr = new Cdn.InstructionVariable(nv);
vinstr.SetSlice(new int[] { i }, new Cdn.Dimension {
Rows = 1, Columns = 1
});
instructions[slice[i]].Add(vinstr);
}
}
List <Cdn.Instruction> ret = new List <Instruction>();
// Create substitute edge action
foreach (var i in instructions)
{
if (i == null)
{
ret.Add(new Cdn.InstructionNumber("0"));
}
else
{
// Add indexing instructions
ret.AddRange(i);
// Then add simple plus operators
for (int j = 0; j < i.Count - 1; ++j)
{
ret.Add(new Cdn.InstructionFunction((uint)Cdn.MathFunctionType.Plus, null, 2));
}
}
}
var minstr = new Cdn.InstructionMatrix(new Cdn.StackArgs(instructions.Length), variable.Dimension);
ret.Add(minstr);
var retex = new Cdn.Expression("");
retex.SetInstructionsTake(ret.ToArray());
var action = new Cdn.EdgeAction(variable.Name, retex);
((Cdn.Node)variable.Object).SelfEdge.AddAction(action);
d_actionedVariables[variable] = new EdgeAction[] { action };
}
}
public void Set(IntPtr gerror, Cdn.Object objekt, Cdn.Variable property, Cdn.EdgeAction action, Cdn.Expression expression) {
cdn_compile_error_set(Handle, gerror, objekt == null ? IntPtr.Zero : objekt.Handle, property == null ? IntPtr.Zero : property.Handle, action == null ? IntPtr.Zero : action.Handle, expression == null ? IntPtr.Zero : expression.Handle);
}
public static Node Create(State state, Cdn.Expression expression)
{
return(Create(state, expression.Instructions));
}
void InvokeNative(Cdn.Expression expression)
{
native_cb(expression == null ? IntPtr.Zero : expression.Handle, __data);
}
public ModifyExpression(Cdn.Expression expr, string expression)
{
d_expr = expr;
d_expression = expression;
d_prevExpression = expr.AsString;
}
