private void Constructed()
{
InstructionCustomFunction icfunc = d_instruction as InstructionCustomFunction;
InstructionCustomOperator icop = d_instruction as InstructionCustomOperator;
Cdn.Function f = null;
if (icfunc != null)
{
f = icfunc.Function;
}
else if (icop != null)
{
f = icop.Operator.PrimaryFunction;
}
if (f == null)
{
return;
}
var args = f.Arguments;
int offset = 0;
for (int i = 0; i < args.Length; ++i)
{
if (args[i].Unused)
{
d_children.RemoveAt(i - offset);
++offset;
}
}
}
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));
}
private void ExtractDelayedState(State st, HashSet <DelayedState.Key> same)
{
if (st.Instructions == null)
{
return;
}
foreach (Cdn.Instruction instruction in st.Instructions)
{
InstructionCustomOperator op = instruction as InstructionCustomOperator;
if (op == null || !(op.Operator is OperatorDelayed))
{
continue;
}
if (Options.Instance.DelayTimeStep <= 0)
{
throw new Exception("The network uses the `delayed' operator but no delay time step was specified (--delay-time-step)...");
}
double delay = ComputeDelayedDelay(st.Instructions, st.Expression, op);
OperatorDelayed opdel = (OperatorDelayed)op.Operator;
DelayedState.Key key = new DelayedState.Key(opdel, delay);
if (!same.Add(key))
{
d_delays.Add(op, delay);
continue;
}
double size;
size = delay / Options.Instance.DelayTimeStep;
if (size % 1 > double.Epsilon)
{
throw new Exception(String.Format("Time delay `{0}' is not a multiple of the delay time step `{1}'",
delay, Options.Instance.DelayTimeStep));
}
d_delays.Add(op, delay);
DelayedState s = new DelayedState(op, delay, opdel.Expression, Cdn.RawC.State.Flags.None);
AddState(null, s);
// Create a new expression for the initial value of this state
AddInitialize(new DelayedState(op, delay, opdel.InitialValue, Cdn.RawC.State.Flags.Initialization));
d_delayedStates.Add(s);
// Recurse into state
ExtractDelayedState(s, same);
}
}
private int[] InstructionSparsity(InstructionCustomOperator instr, SparsityInfo[] children, Dictionary <Variable, SparsityInfo> mapping)
{
var f = instr.Operator.PrimaryFunction;
if (f != null)
{
return(FunctionSparsity(f, children, mapping));
}
return(new int[0]);
}
/*
* Support for custom operators which do not generate functions.
* Currently, the only operator supported here is the delay operator.
* All other operators which currently exist generate functions which
* are handled just like other custom functions.
*/
protected virtual string Translate(InstructionCustomOperator instruction, Context context)
{
var op = instruction.Operator;
if (op is OperatorDelayed)
{
return(TranslateDelayed(instruction, context));
}
throw new NotSupportedException(String.Format("The custom operator `{0}' is not yet supported.",
op.ToString()));
}
/*
* Delay operator instructions are translated to a simple lookup in
* the statetable where they delayed expressions are stored.
*/
protected virtual string TranslateDelayed(InstructionCustomOperator instruction, Context context)
{
OperatorDelayed delayed = (OperatorDelayed)instruction.Operator;
double delay;
if (!Knowledge.Instance.LookupDelay(instruction, out delay))
{
throw new NotSupportedException("Unable to determine delay of delayed operator");
}
DataTable.DataItem item = context.Program.StateTable[new DelayedState.Key(delayed, delay)];
return(String.Format("{0}[{1}]",
context.This(context.Program.StateTable),
item.AliasOrIndex));
}
private double ComputeDelayedDelay(Instruction[] instructions, Expression e, InstructionCustomOperator instr)
{
Cdn.Stack stack = new Cdn.Stack(e.StackSize);
foreach (Cdn.Instruction i in instructions)
{
if (i == instr)
{
return(stack.Pop());
}
i.Execute(stack);
}
return(0);
}
public DelayedState(InstructionCustomOperator delayed, double delay, Flags type) : this(delayed, delay, null, type)
{
}
public DelayedState(InstructionCustomOperator delayed, double delay) : this(delayed, delay, Flags.None)
{
}