protected GenericFunctionProcess(bool[] inInput, bool[] inInternal, bool[] outOutput, bool[] outInternal)
{
if(inInput == null)
throw new ArgumentNullException("inInput");
if(inInternal == null)
throw new ArgumentNullException("inInternal");
if(outOutput == null)
throw new ArgumentNullException("outOutput");
if(outInternal == null)
throw new ArgumentNullException("outInternal");
this.inInput = inInput;
this.inInternal = inInternal;
this.outOutput = outOutput;
this.outInternal = outInternal;
//count mapped signals
for(int i = 0; i < inInput.Length; i++)
if(inInput[i]) inCount++;
for(int i = 0; i < inInternal.Length; i++)
if(inInternal[i]) inCount++;
for(int i = 0; i < outOutput.Length; i++)
if(outOutput[i]) outCount++;
for(int i = 0; i < outInternal.Length; i++)
if(outInternal[i]) outCount++;
inputs = new Signal[inCount];
outputs = new Signal[outCount];
}
private bool TraverseSignal(List<Guid> signals, List<Guid> ports, List<Guid> buses, Signal signal, Port target, bool ignoreHold, IScanVisitor visitor)
{
if(signal == null)
return true;
bool again = true;
if(!signals.Contains(signal.InstanceId))
{
again = false;
signals.Add(signal.InstanceId);
}
if(visitor.EnterSignal(signal, target, again, target == null))
{
// LEAF SIGNAL?
if(!signal.BehavesAsBeingDriven(ignoreHold))
{
if(!visitor.VisitLeaf(signal, again))
return false; // finished
}
else // HANDLE PORT
{
TraversePort(signals, ports, buses, signal.DrivenByPort, signal, ignoreHold, visitor);
}
}
return visitor.LeaveSignal(signal, target, again, target == null);
}
public static Signal Cotangent(Context context, Signal op)
{
if(context == null)
throw new ArgumentNullException("context");
return context.Builder.Function(new MathIdentifier("Cotangent", "Std"), op);
}
public override bool EnterSignal(Signal signal, Port parent, bool again, bool root)
{
if(again)
return false;
_signals.Add(signal);
return true;
}
public override bool EnterPort(Port port, Signal parent, bool again, bool root)
{
if(again)
return false;
_ports.Add(port);
return true;
}
protected override void DoTraverse(Signal rootSignal, IScanVisitor visitor, bool ignoreHold)
{
List<Guid> signals = new List<Guid>();
List<Guid> ports = new List<Guid>();
List<Guid> buses = new List<Guid>();
TraverseSignal(signals, ports, buses, rootSignal, null, ignoreHold, visitor);
}
public static ITheorem[] BuildTheorems(Context context)
{
ITheorem[] theorems = new ITheorem[2];
theorems[0] = new Analysis.DerivativeTransformation(context.Library.LookupEntity(_entityId),
delegate(Port port, SignalSet manipulatedInputs, Signal variable, bool hasManipulatedInputs)
{
Builder b = context.Builder;
Signal[] outputs = new Signal[manipulatedInputs.Count];
ReadOnlySignalSet squares = b.Square(port.OutputSignals);
Signal one = IntegerValue.ConstantOne(context);
for(int i = 0; i < outputs.Length; i++)
outputs[i] = (one + squares[i]) * manipulatedInputs[i];
return b.Negate(outputs);
});
theorems[1] = new BasicTransformation("CotangentTrigonometricSusbtitute", "Std", "TrigonometricSubstitute", "Std",
delegate(Port port) { return port.Entity.EntityId.Equals("Cotangent", "Std"); },
delegate(Port port) { return ManipulationPlan.DoAlter; },
delegate(Port port, SignalSet transformedInputs, bool hasTransformedInputs)
{
Signal[] ret = new Signal[transformedInputs.Count];
for(int i = 0; i < ret.Length; i++)
ret[i] = Std.Cosine(port.Context, transformedInputs[i]) / Std.Sine(port.Context, transformedInputs[i]);
return ret;
});
return theorems;
}
public override bool FulfillsCondition(Signal output, Port port)
{
if(port == null)
return false;
return port.HasArchitectureLink && _match(port.CurrentArchitecture);
}
public static ITheorem[] BuildTheorems(Context context)
{
ITheorem[] theorems = new ITheorem[2];
theorems[0] = new Analysis.DerivativeTransformation(_entityId,
delegate(Port port, SignalSet manipulatedInputs, Signal variable, bool hasManipulatedInputs)
{
Builder b = context.Builder;
Signal[] outputs = new Signal[manipulatedInputs.Count];
ReadOnlySignalSet cotangents = Std.Cotangent(context, port.InputSignals);
for(int i = 0; i < outputs.Length; i++)
outputs[i] = b.MultiplySimplified(port.OutputSignals[i], cotangents[i], manipulatedInputs[i]);
return b.Negate(outputs);
});
theorems[1] = new BasicTransformation(_entityId.DerivePostfix("TrigonometricSubstitute"), new MathIdentifier("TrigonometricSubstitute", "Std"),
delegate() { return new Pattern(new EntityCondition(_entityId)); },
delegate(Port port) { return ManipulationPlan.DoAlter; },
delegate(Port port, SignalSet transformedInputs, bool hasTransformedInputs)
{
return port.Context.Builder.Invert(Std.Sine(port.Context, transformedInputs));
//Signal[] ret = new Signal[transformedInputs.Count];
//for(int i = 0; i < ret.Length; i++)
// ret[i] = port.Context.Builder.Invert(Std.Sine(port.Context, transformedInputs[i]));
//return ret;
});
return theorems;
}
public override bool FulfillsCondition(Signal output, Port port)
{
foreach(Condition c in _conditions)
if(!c.FulfillsCondition(output, port))
return false;
return true;
}
public bool PropagatePropertyIfApplicable(Signal target)
{
if(target == null) throw new ArgumentNullException("target");
if(!target.HasProperty(providedPropertyId) && WouldBePropagatedTo(target))
buildProperty(target);
return target.HasProperty(providedPropertyId);
}
protected override CommandReference Action()
{
int idx = System.SignalCount;
Signal s = new Signal(System.Context);
Guid iid = s.InstanceId;
System.AddSignal(s);
return new CommandReference(iid, idx);
}
public void Traverse(Signal rootSignal, IScanVisitor visitor, bool ignoreHold)
{
//lock(??) {
ScanStrategy strat = ProvideExecutableInstance();
strat._activeScans++; //}
try { strat.DoTraverse(rootSignal, visitor, ignoreHold); }
finally { strat._activeScans--; }
}
public override bool EnterPort(Port port, Signal parent, bool again, bool root)
{
// ## DIVE DEEPER ONLY ON UNCERTAIN PORTS
if(_plans[port.InstanceId] != ManipulationPlan.AlterIfChildsAltered
&& _plans[port.InstanceId] != ManipulationPlan.CloneIfChildsAltered)
return false;
return base.EnterPort(port, parent, again, root);
}
public override ECategoryMembership IsMember(Signal signal, bool ignoreCache)
{
if(signal.Value == null)
return ECategoryMembership.Unknown;
if(signal.Value is ComplexValue || signal.Value is RealValue || signal.Value is RationalValue || signal.Value is IntegerValue)
return ECategoryMembership.Member;
return ECategoryMembership.NotMember;
}
protected override void DoTraverse(Signal rootSignal, IScanVisitor visitor, bool ignoreHold)
{
if(rootSignal.BehavesAsBeingDriven(ignoreHold))
{
List<Guid> ports = new List<Guid>();
TraversePort(ports, rootSignal.DrivenByPort, rootSignal, ignoreHold, visitor);
}
}
public override bool EnterSignal(Signal signal, Port parent, bool again, bool root)
{
if(again)
return false;
if(_match(signal))
return _action(signal);
return true;
}
public override ECategoryMembership IsMember(Signal signal, bool ignoreCache)
{
if(signal.Value == null)
return ECategoryMembership.Unknown;
if(signal.Value is LogicValue)
return ECategoryMembership.Member;
return ECategoryMembership.NotMember;
}
public SignalEventItem(Signal signal, ValueStructure newValue, SetValue setValue, SetEventFlag setEventFlag, NotifyNewValue notifyNewValue)
{
_signal = signal;
_newValue = newValue;
_setEventFlag = setEventFlag;
_setValue = setValue;
_notifyNewValue = notifyNewValue;
}
public override bool VisitCycle(Port port, Signal target, Signal source)
{
// ## ON CYCLES, TEST WHETHER THE PORT DEPENDS ON ANY ALTERED PORTS AND ADOPT
if(Scanner.ExistsPort(port, delegate(Port p) { return _plans[p.InstanceId] == ManipulationPlan.DoAlter; }, _ignoreHold))
_plans[port.InstanceId] = ManipulationPlan.DoAlter;
else
_plans[port.InstanceId] = ManipulationPlan.DontAlter;
return base.VisitCycle(port, target, source);
}
public Signal Function(Entity entity, Signal argument1, Signal argument2)
{
Port port = entity.InstantiatePort(context, argument1, argument2);
if(port.InputSignalCount != 2 || port.OutputSignalCount != 1)
throw new MathNet.Symbolics.Backend.Exceptions.EntitySignalCountUnexpectedException("2 input and 1 output", port.InputSignalCount.ToString(Context.NumberFormat) + " input and " + port.OutputSignalCount.ToString(Context.NumberFormat) + " output");
return port[0]; //.AutomaticSimplify();
}
protected override void Action(bool isInit, Signal origin)
{
if(origin != null)
{
int originIdx = Array.IndexOf<Signal>(inputSignals, origin);
system.PushInputValue(originIdx, inputSignals[originIdx].Value);
}
else
system.PushInputValueRange(inputSignals);
}
public override bool EnterPort(Port port, Signal parent, bool again, bool root)
{
_currentPath.Push(port);
if(_source.Equals(port))
{
List<Port> p = new List<Port>(_currentPath);
_paths.Add(p);
return false;
}
return base.EnterPort(port, parent, again, root);
}
public override bool EnterSignal(Signal signal, Port parent, bool again, bool root)
{
_currentPath.Push(signal);
if(_source.Equals(signal))
{
List<Signal> p = new List<Signal>(_currentPath);
_paths.Add(p);
return false;
}
return base.EnterSignal(signal, parent, again, root);
}
public Signal ManipulateSignal(Signal original, Signal replacement, bool isReplaced)
{
ITransformationTheorem trans = _transformations.Default;
if(trans != null)
{
if(_configure != null)
_configure(trans);
return trans.ManipulateSignal(original, replacement, isReplaced);
}
return replacement;
}
public override ECategoryMembership IsMember(Signal signal, bool ignoreCache)
{
if(signal == null)
throw new ArgumentNullException("signal");
if(signal.Value == null)
return ECategoryMembership.Unknown;
if(signal.Value is IntegerValue)
return ECategoryMembership.Member;
return ECategoryMembership.NotMember;
}
public override bool EnterSignal(Signal signal, Port parent, bool again, bool root)
{
if(again)
return false;
if(_match(signal))
{
_foundSignal = signal;
_foundSignalTarget = parent;
return false;
}
return true;
}
public override bool EnterPort(Port port, Signal parent, bool again, bool root)
{
if(again)
return false;
if(_match(port))
{
_foundPort = port;
_foundPortTarget = parent;
return false;
}
return true;
}
/// <summary>Port Instance Constructor</summary>
protected GenericSimpleArchitecture(MathIdentifier entityId, bool isMathematicalOperator, Port port, int internalSignalCount)
: base(entityId, entityId, isMathematicalOperator)
{
_internalSignals = new Signal[internalSignalCount];
for(int i = 0; i < _internalSignals.Length; i++)
_internalSignals[i] = new Signal(port.Context);
//System.Diagnostics.Debug.Assert(SupportsPort(port));
SetPort(port);
_sensedSignals = new SignalSet();
SenseSignals(port.InputSignals, _internalSignals, port.Buses, port.OutputSignals);
Action(port.InputSignals, port.OutputSignals, _internalSignals, port.Buses);
}
private bool TraversePort(List<Guid> ports, Port port, Signal target, bool ignoreHold, IScanVisitor visitor)
{
if(ports.Contains(port.InstanceId))
return true;
ports.Add(port.InstanceId);
if(visitor.EnterPort(port, target, false, target == null))
{
foreach(Signal input in port.InputSignals)
if(input != null && input.BehavesAsBeingDriven(ignoreHold))
if(!TraversePort(ports, input.DrivenByPort, input, ignoreHold, visitor))
return false; // finished
}
return visitor.LeavePort(port, target, false, target == null);
}
