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 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 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 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 override bool EnterSignal(Signal signal, Port parent, bool again, bool root) { if (again) { return(false); } if (_signalMatch(signal)) { _signals.Add(signal); } return(true); }
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 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 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> /// 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 }; }
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); })); }
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 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; 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(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; 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(_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); }
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 static bool SimplifyFactors(SignalSet signals) { if (signals == null) { throw new ArgumentNullException("signals"); } if (Std.IsConstantAdditiveIdentity(signals[0])) { signals.Clear(); signals.Add(signals[0]); return(true); } bool altered = false; for (int i = signals.Count - 1; i > 0; i--) //don't touch first item! { if (Std.IsConstantMultiplicativeIdentity(signals[i])) { altered = true; signals.RemoveAt(i); } } return(altered); }
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; }
protected void SenseSignal(Signal signal) { _sensedSignals.Add(signal); signal.ValueChanged += signal_SignalValueChanged; }
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 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 Signal AddSimplified(Signal signal, Signal[] signals) { SignalSet list = new SignalSet(); //signals.Length+1); list.Add(signal); list.AddRange(signals); return AddSimplified(list); }
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 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 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) { if(signals == null) throw new ArgumentNullException("signals"); if(Std.IsConstantAdditiveIdentity(signals[0])) { signals.Clear(); signals.Add(signals[0]); return true; } bool altered = false; for(int i = signals.Count - 1; i > 0; i--) //don't touch first item! if(Std.IsConstantMultiplicativeIdentity(signals[i])) { altered = true; signals.RemoveAt(i); } return altered; }