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;
ReadOnlySignalSet squares = b.Square(port.OutputSignals);
Signal one = IntegerValue.ConstantOne(context);
SignalSet outputs = new SignalSet();
for(int i = 0; i < manipulatedInputs.Count; i++)
outputs.Add((one + squares[i]) * manipulatedInputs[i]);
return 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)
{
Signal[] ret = new Signal[transformedInputs.Count];
for(int i = 0; i < ret.Length; i++)
ret[i] = Std.Sine(port.Context, transformedInputs[i]) / Std.Cosine(port.Context, transformedInputs[i]);
return ret;
});
return theorems;
}
public static IValueStructure MonomialDegree(Signal signal, Signal[] generalizedVariables)
{
if(Std.IsConstantAdditiveIdentity(signal))
return NegativeInfinitySymbol.Instance;
if(Array.Exists<Signal>(generalizedVariables, signal.Equals))
return IntegerValue.One;
if(!Array.Exists<Signal>(generalizedVariables, signal.DependsOn))
return IntegerValue.Zero;
ISignalSet factors;
long deg = 0;
if(signal.IsDrivenByPortEntity("Multiply", "Std"))
factors = signal.DrivenByPort.InputSignals;
else
factors = new SignalSet(signal);
for(int i = 0; i < factors.Count; i++)
{
if(Array.Exists<Signal>(generalizedVariables, factors[i].Equals))
deg++;
else if(factors[i].IsDrivenByPortEntity("Power", "Std"))
{
Signal b = signal.DrivenByPort.InputSignals[0];
Signal e = signal.DrivenByPort.InputSignals[1];
IntegerValue v;
if(Array.Exists<Signal>(generalizedVariables, b.Equals) && (v = e.Value as IntegerValue) != null && v.Value > 0)
deg += v.Value;
}
}
return new IntegerValue(deg);
}
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;
ReadOnlySignalSet tangents = Std.Tangent(context, port.InputSignals);
SignalSet outputs = new SignalSet();
for(int i = 0; i < manipulatedInputs.Count; i++)
outputs.Add(b.MultiplySimplified(port.OutputSignals[i], tangents[i], manipulatedInputs[i]));
return 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.Cosine(port.Context, transformedInputs));
//Signal[] ret = new Signal[transformedInputs.Length];
//for(int i = 0; i < ret.Length; i++)
// ret[i] = port.Context.Builder.Invert(Std.Cosine(port.Context, transformedInputs[i]));
//return ret;
});
return theorems;
}
public static void RegisterTheorems(ILibrary library)
{
Analysis.DerivativeTransformation.Provider.Add(
new Analysis.DerivativeTransformation(_entityId,
delegate(Port port, SignalSet manipulatedInputs, Signal variable, bool hasManipulatedInputs)
{
ReadOnlySignalSet squares = StdBuilder.Square(port.OutputSignals);
Signal one = IntegerValue.ConstantOne;
SignalSet outputs = new SignalSet();
for(int i = 0; i < manipulatedInputs.Count; i++)
outputs.Add((one + squares[i]) * manipulatedInputs[i]);
return outputs;
}));
MathIdentifier typeId = new MathIdentifier("TrigonometricSubstitute", "Std");
ITheoremProvider basicProvider;
if(!library.TryLookupTheoremType(typeId, out basicProvider))
{
basicProvider = Binder.GetInstance<ITransformationTheoremProvider, MathIdentifier>(typeId);
library.AddTheoremType(basicProvider);
}
((ITransformationTheoremProvider)basicProvider).Add(
new BasicTransformation(_entityId.DerivePostfix("TrigonometricSubstitute"), typeId,
delegate() { return new Pattern(new EntityCondition(_entityId)); },
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] = StdBuilder.Sine(transformedInputs[i]) / StdBuilder.Cosine(transformedInputs[i]);
return ret;
}));
}
public override ISignalSet ExecuteMathematicalOperator()
{
int cnt = Port.OutputSignalCount;
SignalSet ret = new SignalSet();
Signal variable = Port.InputSignals[cnt];
for(int i = 0; i < cnt; i++)
ret.Add(Std.Derive(Port.InputSignals[i], variable));
return ret;
}
public ConditionalCollectVisitor(Predicate<Signal> signalMatch, Predicate<Port> portMatch, Predicate<Bus> busMatch)
{
_signals = new SignalSet();
_ports = new PortSet();
_buses = new BusSet();
_signalMatch = signalMatch;
_portMatch = portMatch;
_busMatch = busMatch;
}
public ConditionalCollectVisitor()
{
_signals = new SignalSet();
_ports = new PortSet();
_buses = new BusSet();
_signalMatch = DummySignalPredicate;
_portMatch = DummyPortPredicate;
_busMatch = DummyBusPredicate;
}
public MathSystem()
{
_iid = Config.GenerateInstanceId();
_inputs = new SignalSet();
_outputs = new SignalSet();
_allSignals = new SignalSet();
_allBuses = new BusSet();
_allPorts = new PortSet();
}
/// <summary>
/// Adds a set of signals and tries to automatically simplify the term.
/// WARNING: This method may change the contents of the <c>signals</c> paramerer.
/// Pass <c>signals.AsReadOnly</c> instead of <c>signals</c> if you pass
/// a writeable signal set that must not be changed.
/// </summary>
public static Signal Add(ISignalSet signals)
{
if(signals.IsReadOnly)
signals = new SignalSet(signals);
AdditionArchitectures.SimplifySummands(signals);
if(signals.Count == 0)
return IntegerValue.ConstantAdditiveIdentity;
if(signals.Count == 1)
return signals[0];
return StdBuilder.Add(signals);
}
public static bool SimplifySummands(SignalSet signals)
{
if(signals == null) throw new ArgumentNullException("signals");
bool altered = false;
for(int i = signals.Count - 1; i > 0; i--) //don't touch first item!
if(Std.IsConstantAdditiveIdentity(signals[i]))
{
altered = true;
signals.RemoveAt(i);
}
return altered;
}
public IEnumerable<Signal> ManipulatePort(Port port, SignalSet manipulatedInputs, bool hasManipulatedInputs)
{
ITransformationTheorem trans;
if(_transformations.TryLookupTheorem(port, out trans))
{
if(_configure != null)
_configure(trans);
return trans.ManipulatePort(port, manipulatedInputs, hasManipulatedInputs);
}
else
throw new MathNet.Symbolics.Backend.Exceptions.TheoremMismatchException();
}
public static void RegisterTheorems(ILibrary library)
{
Analysis.DerivativeTransformation.Provider.Add(
new Analysis.DerivativeTransformation(_entityId,
delegate(Port port, SignalSet manipulatedInputs, Signal variable, bool hasManipulatedInputs)
{
SignalSet outputs = new SignalSet();
for(int i = 0; i < manipulatedInputs.Count; i++)
outputs.Add(manipulatedInputs[i] / port.InputSignals[i]);
return outputs;
}));
}
/// <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] = Binder.CreateSignal();
//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);
}
public static ITheorem[] BuildTheorems(Context context)
{
ITheorem[] theorems = new ITheorem[1];
theorems[0] = new Analysis.DerivativeTransformation(_entityId,
delegate(Port port, SignalSet manipulatedInputs, Signal variable, bool hasManipulatedInputs)
{
Builder b = context.Builder;
SignalSet outputs = new SignalSet();
for(int i = 0; i < manipulatedInputs.Count; i++)
outputs.Add(b.Negate(b.DivideSimplified(manipulatedInputs[i], b.Square(port.InputSignals[i]))));
return outputs;
});
return theorems;
}
public static ITheorem[] BuildTheorems(Context context)
{
ITheorem[] theorems = new ITheorem[1];
theorems[0] = new Analysis.DerivativeTransformation(context.Library.LookupEntity(_entityId),
delegate(Port port, SignalSet manipulatedInputs, Signal variable, bool hasManipulatedInputs)
{
Builder b = context.Builder;
SignalSet outputs = new SignalSet();
for(int i = 0; i < manipulatedInputs.Count; i++)
outputs.Add(manipulatedInputs[i] / port.InputSignals[i]);
return outputs;
});
return theorems;
}
public static ITheorem[] BuildTheorems(Context context)
{
ITheorem[] theorems = new ITheorem[1];
theorems[0] = new Analysis.DerivativeTransformation(_entityId,
delegate(Port port, SignalSet manipulatedInputs, Signal variable, bool hasManipulatedInputs)
{
Builder b = context.Builder;
Signal two = IntegerValue.ConstantTwo(context);
SignalSet outputs = new SignalSet();
for(int i = 0; i < manipulatedInputs.Count; i++)
outputs.Add(b.MultiplySimplified(two, port.InputSignals[i], manipulatedInputs[i]));
return outputs;
});
return theorems;
}
public static ITheorem[] BuildTheorems(Context context)
{
ITheorem[] theorems = new ITheorem[1];
theorems[0] = new Analysis.DerivativeTransformation(_entityId,
delegate(Port port, SignalSet manipulatedInputs, Signal variable, bool hasManipulatedInputs)
{
Builder b = context.Builder;
SignalSet outputs = new SignalSet();
ReadOnlySignalSet cosines = Std.Cosine(context, port.InputSignals);
for(int i = 0; i < manipulatedInputs.Count; i++)
outputs.Add(cosines[i] * manipulatedInputs[i]);
return outputs;
});
return theorems;
}
internal Port(IEntity entity)
{
_entity = entity;
_inputSignalSet = new SignalSet(entity.InputSignals.Length);
_outputSignalSet = new SignalSet(entity.OutputSignals.Length);
_busSet = new BusSet(entity.Buses.Length);
_completelyConnected = _inputSignalSet.Count == 0 && _busSet.Count == 0;
Service<IMediator>.Instance.NotifyNewPortCreated(this);
for(int i = 0; i < _outputSignalSet.Count; i++)
{
_outputSignalSet[i] = new Signal();
((ISignal_Drive)_outputSignalSet[i]).DriveSignal(this, i);
}
}
public static ITheorem[] BuildTheorems(Context context)
{
ITheorem[] theorems = new ITheorem[1];
theorems[0] = new Analysis.DerivativeTransformation(context.Library.LookupEntity(_entityId),
delegate(Port port, SignalSet manipulatedInputs, Signal variable, bool hasManipulatedInputs)
{
Builder b = context.Builder;
SignalSet outputs = new SignalSet();
for (int i = 0; i < manipulatedInputs.Count; i++)
{
outputs.Add(b.Negate(b.DivideSimplified(manipulatedInputs[i], b.Square(port.InputSignals[i]))));
}
return(outputs);
});
return(theorems);
}
public IEnumerable <Signal> ManipulatePort(Port port, SignalSet manipulatedInputs, bool hasManipulatedInputs)
{
ITransformationTheorem trans;
GroupCollection groups;
if (_transformations.TryLookupBest(null, port, out trans, out groups))
{
if (_configure != null)
{
_configure(trans);
}
return(trans.ManipulatePort(port, manipulatedInputs, hasManipulatedInputs, groups));
}
else
{
throw new MathNet.Symbolics.Exceptions.TheoremMismatchException();
}
}
public static bool SimplifySummands(SignalSet signals)
{
if (signals == null)
{
throw new ArgumentNullException("signals");
}
bool altered = false;
for (int i = signals.Count - 1; i > 0; i--) //don't touch first item!
{
if (Std.IsConstantAdditiveIdentity(signals[i]))
{
altered = true;
signals.RemoveAt(i);
}
}
return(altered);
}
public static ITheorem[] BuildTheorems(Context context)
{
ITheorem[] theorems = new ITheorem[1];
theorems[0] = new Analysis.DerivativeTransformation(_entityId,
delegate(Port port, SignalSet manipulatedInputs, Signal variable, bool hasManipulatedInputs)
{
Builder b = context.Builder;
SignalSet outputs = new SignalSet();
for (int i = 0; i < manipulatedInputs.Count; i++)
{
outputs.Add(manipulatedInputs[i] / port.InputSignals[i]);
}
return(outputs);
});
return(theorems);
}
public static IValueStructure MonomialDegree(Signal signal, Signal[] generalizedVariables)
{
if (Std.IsConstantAdditiveIdentity(signal))
{
return(NegativeInfinitySymbol.Instance);
}
if (Array.Exists <Signal>(generalizedVariables, signal.Equals))
{
return(IntegerValue.One);
}
if (!Array.Exists <Signal>(generalizedVariables, signal.DependsOn))
{
return(IntegerValue.Zero);
}
ISignalSet factors;
long deg = 0;
if (signal.IsDrivenByPortEntity("Multiply", "Std"))
{
factors = signal.DrivenByPort.InputSignals;
}
else
{
factors = new SignalSet(signal);
}
for (int i = 0; i < factors.Count; i++)
{
if (Array.Exists <Signal>(generalizedVariables, factors[i].Equals))
{
deg++;
}
else if (factors[i].IsDrivenByPortEntity("Power", "Std"))
{
Signal b = signal.DrivenByPort.InputSignals[0];
Signal e = signal.DrivenByPort.InputSignals[1];
IntegerValue v;
if (Array.Exists <Signal>(generalizedVariables, b.Equals) && (v = e.Value as IntegerValue) != null && v.Value > 0)
{
deg += v.Value;
}
}
}
return(new IntegerValue(deg));
}
public static ITheorem[] BuildTheorems(Context context)
{
ITheorem[] theorems = new ITheorem[1];
theorems[0] = new Analysis.DerivativeTransformation(context.Library.LookupEntity(_entityId),
delegate(Port port, SignalSet manipulatedInputs, Signal variable, bool hasManipulatedInputs)
{
Builder b = context.Builder;
SignalSet outputs = new SignalSet();
ReadOnlySignalSet cosines = Std.Cosine(context, port.InputSignals);
for (int i = 0; i < manipulatedInputs.Count; i++)
{
outputs.Add(cosines[i] * manipulatedInputs[i]);
}
return(outputs);
});
return(theorems);
}
public static ITheorem[] BuildTheorems(Context context)
{
ITheorem[] theorems = new ITheorem[1];
theorems[0] = new Analysis.DerivativeTransformation(_entityId,
delegate(Port port, SignalSet manipulatedInputs, Signal variable, bool hasManipulatedInputs)
{
Builder b = context.Builder;
Signal two = IntegerValue.ConstantTwo(context);
SignalSet outputs = new SignalSet();
for (int i = 0; i < manipulatedInputs.Count; i++)
{
outputs.Add(b.MultiplySimplified(two, port.InputSignals[i], manipulatedInputs[i]));
}
return(outputs);
});
return(theorems);
}
internal Port(Context context, Entity entity)
{
_context = context;
_iid = _context.GenerateInstanceId();
_entity = entity;
_inputSignalSet = new SignalSet(entity.InputSignals.Length);
_outputSignalSet = new SignalSet(entity.OutputSignals.Length);
_busSet = new BusSet(entity.Buses.Length);
_completelyConnected = _inputSignalSet.Count == 0 && _busSet.Count == 0;
context.NotifyNewPortConstructed(this);
for (int i = 0; i < _outputSignalSet.Count; i++)
{
_outputSignalSet[i] = new Signal(context);
_outputSignalSet[i].DriveSignal(this, i);
}
}
public override async Task StartAsync(ExamContext context)
{
//清除历史的信号记录；
SignalSet.Clear();
//设置考试里程
context.ExamDistance = (context.ExamTimeMode == ExamTimeMode.Day)
? Settings.ExamDistance
: Settings.NightDistance;
await ExamManager.StartExamAsync(context);
if (context.ExamMode == ExamMode.Training)
{
await StartTrainingAsync(context);
}
else
{
await StartExamAsync(context);
}
}
public static void RegisterTheorems(ILibrary library)
{
Analysis.DerivativeTransformation.Provider.Add(
new Analysis.DerivativeTransformation(_entityId,
delegate(Port port, SignalSet manipulatedInputs, Signal variable, bool hasManipulatedInputs)
{
ReadOnlySignalSet squares = StdBuilder.Square(port.OutputSignals);
Signal one = IntegerValue.ConstantOne;
SignalSet outputs = new SignalSet();
for (int i = 0; i < manipulatedInputs.Count; i++)
{
outputs.Add((one + squares[i]) * manipulatedInputs[i]);
}
return(outputs);
}));
MathIdentifier typeId = new MathIdentifier("TrigonometricSubstitute", "Std");
ITheoremProvider basicProvider;
if (!library.TryLookupTheoremType(typeId, out basicProvider))
{
basicProvider = Binder.GetInstance <ITransformationTheoremProvider, MathIdentifier>(typeId);
library.AddTheoremType(basicProvider);
}
((ITransformationTheoremProvider)basicProvider).Add(
new BasicTransformation(_entityId.DerivePostfix("TrigonometricSubstitute"), typeId,
delegate() { return(new Pattern(new EntityCondition(_entityId))); },
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] = StdBuilder.Sine(transformedInputs[i]) / StdBuilder.Cosine(transformedInputs[i]);
}
return(ret);
}));
}
public override async Task ReadyStartExamAsync(ExamContext context)
{
//清除历史的信号记录；
SignalSet.Clear();
//设置考试里程
context.ExamDistance = (context.ExamTimeMode == ExamTimeMode.Day)
? Settings.ExamDistance
: Settings.NightDistance;
await ExamManager.StartExamAsync(context);
await Task.Run(() =>
{
while (!(SignalSet.Current != null && SignalSet.Current.Sensor.Brake))
{
Thread.Sleep(100);
}
});
await StartExamItemAutoAsync(context, ExamItemCodes.CommonExamItem);
await StartExamItemAutoAsync(context, ExamItemCodes.Start);
}
/// <summary>
/// Separates factors in a product that depend on x from those that do not.
/// </summary>
/// <returns>
/// A signal array [a,b], where a is the product of the factors not
/// depending on x, and b the product of those depending on x.
/// </returns>
/// <remarks><see cref="product"/> is assumed to be automatic simplified</remarks>
public static Signal[] SeparateFactors(Context context, Signal product, Signal x)
{
SignalSet freePart = new SignalSet();
SignalSet dependentPart = new SignalSet();
if(product.IsDrivenByPortEntity("Multiply", "Std"))
{
ReadOnlySignalSet factors = product.DrivenByPort.InputSignals;
foreach(Signal s in factors)
{
if(s.DependsOn(x))
dependentPart.Add(s);
else
freePart.Add(s);
}
}
else if(product.DependsOn(x))
dependentPart.Add(product);
else
freePart.Add(product);
Signal freeSignal = context.Builder.MultiplySimplified(freePart);
Signal dependentSignal = context.Builder.MultiplySimplified(dependentPart);
return new Signal[] { freeSignal, dependentSignal };
}
private SignalSet BuildManipulatedInputsList(Port port, out bool isManipulated)
{
ReadOnlySignalSet inputs = port.InputSignals;
SignalSet manip = new SignalSet();
isManipulated = false;
foreach (Signal s in inputs)
{
Signal rep;
if (_signalRep.TryGetValue(s.InstanceId, out rep))
{
if (!s.Equals(rep))
{
isManipulated = true;
}
manip.Add(rep);
}
else
{
manip.Add(s);
}
}
return(manip);
}
internal Port(IEntity entity, IEnumerable<MathNet.Symbolics.Signal> outputSignals)
{
_entity = entity;
_inputSignalSet = new SignalSet(entity.InputSignals.Length);
_outputSignalSet = new SignalSet(outputSignals);
_busSet = new BusSet(entity.Buses.Length);
System.Diagnostics.Debug.Assert(_outputSignalSet.Count == entity.OutputSignals.Length);
Service<IMediator>.Instance.NotifyNewPortCreated(this);
_completelyConnected = true;
for(int i = 0; i < _outputSignalSet.Count; i++)
if(_outputSignalSet[i] != null)
((ISignal_Drive)_outputSignalSet[i]).DriveSignal(this, i);
else
_completelyConnected = false;
_completelyConnected &= _inputSignalSet.Count == 0 && _busSet.Count == 0;
for(int i = 0; i < _outputSignalSet.Count && _completelyConnected; i++)
_completelyConnected &= _outputSignalSet[i] != null;
}
private InstanceIdSet BuilderMapSignals(SignalSet signals, Dictionary <Guid, Guid> signalMappings)
{
return(signals.ConvertAllToInstanceIds(delegate(MathNet.Symbolics.Signal s) { return signalMappings[s.InstanceId]; }));
}
public IEnumerable<Signal> ManipulatePort(Port port, SignalSet manipulatedInputs, bool hasManipulatedInputs, GroupCollection groups)
{
return _derive(port, manipulatedInputs, _variable, hasManipulatedInputs);
}
public IEnumerable<Signal> ManipulatePort(Port port, SignalSet manipulatedInputs, bool hasManipulatedInputs)
{
return _transform(port, manipulatedInputs, hasManipulatedInputs);
}
public CollectVisitor()
{
_signals = new SignalSet();
_ports = new PortSet();
_buses = new BusSet();
}
/// <summary>
/// Multiplies a set of signals and tries to automatically simplify the term.
/// WARNING: This method may change the contents of the <c>signals</c> paramerer.
/// Pass <c>signals.AsReadOnly</c> instead of <c>signals</c> if you pass
/// a writeable signal set that must not be changed.
/// </summary>
public static Signal Multiply(ISignalSet signals)
{
if(signals.IsReadOnly)
signals = new SignalSet(signals);
MultiplicationArchitectures.SimplifyFactors(signals);
if(signals.Count == 0)
return IntegerValue.ConstantMultiplicativeIdentity;
if(signals.Count == 1)
return signals[0];
return StdBuilder.Multiply(signals);
}
public static Signal Add(Signal signal, IEnumerable<Signal> signals)
{
SignalSet set = new SignalSet(signal);
set.AddRange(signals);
return Add(set);
}
public IEnumerable <Signal> ManipulatePort(Port port, SignalSet manipulatedInputs, bool hasManipulatedInputs)
{
return(_simplify(port, manipulatedInputs, hasManipulatedInputs));
}
/// <summary>
/// Default ctor
/// </summary>
internal SignalSetImpl(SignalSet impl)
: base(impl)
{
}
public Signal AddSimplified(Signal signal, Signal[] signals)
{
SignalSet list = new SignalSet(); //signals.Length+1);
list.Add(signal);
list.AddRange(signals);
return AddSimplified(list);
}
public static SignalSet Manipulate(IEnumerable<Signal> rootSignals, IManipulationVisitor visitor, bool ignoreHold)
{
Dictionary<Guid, ManipulationPlan> plans = new Dictionary<Guid, ManipulationPlan>();
Dictionary<Guid, Signal> signalReplacements = new Dictionary<Guid, Signal>();
Dictionary<Guid, Signal> sentinels = new Dictionary<Guid, Signal>();
// ## ESTIMATE MANIPULATION PLAN
Scanner.ForEachPort(rootSignals, delegate(Port p)
{
if(!plans.ContainsKey(p.InstanceId))
plans.Add(p.InstanceId, visitor.EstimatePlan(p));
return true;
}, ignoreHold);
// ## OPTIMIZE MANIPULATION PLAN (cycle analysis)
ManipulatorPlanReducer reducer = new ManipulatorPlanReducer(plans, ignoreHold);
AllPathsStrategy.Instance.Traverse(rootSignals, reducer, ignoreHold);
// ## EXECUTE MANIPULATION
ManipulatorPlanExecutor executor = new ManipulatorPlanExecutor(plans, signalReplacements, sentinels, visitor);
AllPathsStrategy.Instance.Traverse(rootSignals, executor, ignoreHold);
// ## SELECT NEW SYSTEM
SignalSet ret = new SignalSet();
foreach(Signal root in rootSignals)
{
Signal r;
if(!signalReplacements.TryGetValue(root.InstanceId, out r))
r = root;
ret.Add(r);
}
// ## FIX SENTINELS ON SELECTED NEW SYSTEM
Scanner.ForEachPort(ret, delegate(Port p)
{
// look for sentinels on all input signals
ReadOnlySignalSet inputs = p.InputSignals;
for(int i = 0; i < inputs.Count; i++)
{
Signal input = inputs[i];
if(FixSentinel(ref input, sentinels, signalReplacements))
p.ReplaceInputSignalBinding(i, input);
}
return true;
}, ignoreHold);
for(int i = 0; i < ret.Count; i++)
{
Signal r = ret[i];
if(FixSentinel(ref r, sentinels, signalReplacements))
ret[i] = r;
}
// ## RETURN SELECTED NEW SYSTEM AS RESULT
return ret;
}
private SignalSet BuildManipulatedInputsList(Port port, out bool isManipulated)
{
ReadOnlySignalSet inputs = port.InputSignals;
SignalSet manip = new SignalSet();
isManipulated = false;
foreach(Signal s in inputs)
{
Signal rep;
if(_signalRep.TryGetValue(s.InstanceId, out rep))
{
if(!s.Equals(rep))
isManipulated = true;
manip.Add(rep);
}
else
manip.Add(s);
}
return manip;
}
public static bool SimplifyFactors(SignalSet signals)
{
Signal zero;
if(signals.Exists(Std.IsConstantAdditiveIdentity, out zero))
{
signals.Clear();
signals.Add(zero);
return true;
}
return 0 < signals.RemoveAll(Std.IsConstantMultiplicativeIdentity);
}
public SignalSet Manipulate(IEnumerable <Signal> rootSignals, IManipulationVisitor visitor, bool ignoreHold)
{
IScanStrategy allPathsStrat = Binder.GetSpecificInstance <IScanStrategy>(new MathIdentifier("AllPathsStrategy", "Traversing"));
Dictionary <Guid, ManipulationPlan> plans = new Dictionary <Guid, ManipulationPlan>();
Dictionary <Guid, Signal> signalReplacements = new Dictionary <Guid, Signal>();
Dictionary <Guid, Signal> sentinels = new Dictionary <Guid, Signal>();
// ## ESTIMATE MANIPULATION PLAN
_scanner.ForEachPort(rootSignals, delegate(Port p)
{
if (!plans.ContainsKey(p.InstanceId))
{
plans.Add(p.InstanceId, visitor.EstimatePlan(p));
}
return(true);
}, ignoreHold);
// ## OPTIMIZE MANIPULATION PLAN (cycle analysis)
ManipulatorPlanReducer reducer = new ManipulatorPlanReducer(plans, ignoreHold);
allPathsStrat.Traverse(rootSignals, reducer, ignoreHold);
// ## EXECUTE MANIPULATION
ManipulatorPlanExecutor executor = new ManipulatorPlanExecutor(plans, signalReplacements, sentinels, visitor);
allPathsStrat.Traverse(rootSignals, executor, ignoreHold);
// ## SELECT NEW SYSTEM
SignalSet ret = new SignalSet();
foreach (Signal root in rootSignals)
{
Signal r;
if (!signalReplacements.TryGetValue(root.InstanceId, out r))
{
r = root;
}
ret.Add(r);
}
// ## FIX SENTINELS ON SELECTED NEW SYSTEM
_scanner.ForEachPort(ret, delegate(Port p)
{
// look for sentinels on all input signals
ReadOnlySignalSet inputs = p.InputSignals;
for (int i = 0; i < inputs.Count; i++)
{
Signal input = inputs[i];
if (FixSentinel(ref input, sentinels, signalReplacements))
{
p.ReplaceInputSignalBinding(i, input);
}
}
return(true);
}, ignoreHold);
for (int i = 0; i < ret.Count; i++)
{
Signal r = ret[i];
if (FixSentinel(ref r, sentinels, signalReplacements))
{
ret[i] = r;
}
}
// ## RETURN SELECTED NEW SYSTEM AS RESULT
return(ret);
}
public IEnumerable <Signal> ManipulatePort(Port port, SignalSet manipulatedInputs, bool hasManipulatedInputs, GroupCollection groups)
{
return(_derive(port, manipulatedInputs, _variable, hasManipulatedInputs));
}
public override ISignalSet ExecuteMathematicalOperator()
{
int cnt = Port.OutputSignalCount;
SignalSet ret = new SignalSet();
for(int i = 0; i < cnt; i++)
ret.Add(Std.AutoSimplify(Port.InputSignals[i]));
return ret;
}
public IEnumerable<Signal> ManipulatePort(Port port, SignalSet manipulatedInputs, bool hasManipulatedInputs, GroupCollection groups)
{
return _simplify(port, manipulatedInputs, hasManipulatedInputs);
}
public static void FindAll(IEnumerable <Signal> rootSignals, bool ignoreHold, out SignalSet signals, out PortSet ports)
{
CollectVisitor visitor = new CollectVisitor();
AllSpanningTreeStrategy.Instance.Traverse(rootSignals, visitor, ignoreHold);
signals = visitor.Signals;
ports = visitor.Ports;
}
private SignalSet MapSignals(InstanceIdSet signals)
{
return(SignalSet.ConvertAllFromInstanceIds(signals, delegate(Guid id) { return _signalMappings[id]; }));
}
private InstanceIdSet MapSignals(SignalSet signals, Dictionary <Guid, Guid> signalMappings)
{
return(signals.ConvertAllToInstanceIds(delegate(Signal s) { return signalMappings[s.InstanceId]; }));
}
public IEnumerable <Signal> ManipulatePort(Port port, SignalSet manipulatedInputs, bool hasManipulatedInputs, GroupCollection groups)
{
return(_transform(port, manipulatedInputs, hasManipulatedInputs));
}
/// <summary>
/// Raises a signals (the first signal) to powers and tries to automatically simplify the term.
/// WARNING: This method may change the contents of the <c>signals</c> paramerer.
/// Pass <c>signals.AsReadOnly</c> instead of <c>signals</c> if you pass
/// a writeable signal set that must not be changed.
/// </summary>
public static Signal Power(ISignalSet signals)
{
if(signals.IsReadOnly)
signals = new SignalSet(signals);
PowerArchitectures.SimplifyOperands(signals);
if(signals.Count == 0)
return IntegerValue.ConstantMultiplicativeIdentity;
if(signals.Count == 1)
return signals[0];
return StdBuilder.Power(signals);
}
public static bool SimplifySummands(SignalSet signals)
{
return(0 < signals.RemoveAll(Std.IsConstantAdditiveIdentity));
}
