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)); }