/// <summary>
/// Returns the coefficient u[exponent] of x^exponent in the polynomial <see cref="signal"/>
/// </summary>
/// <returns>
/// Constant UndefinedSymbol if <see cref="signal"/> is not a single-variable polynomial.
/// Constant <see cref="IntegerValue.Zero"/> if there's no summand with the given exponent.
/// Otherwise the sum of all coefficient factors of the term with the given exponent.
/// </returns>
/// <remarks><see cref="signal"/> is assumed to be automatic simplified.</remarks>
public static Signal PolynomialCoefficient(Signal signal, Signal variable, int exponent)
{
ValueStructure vs;
Signal c = MonomialCoefficient(signal, variable, out vs);
if (!(vs is UndefinedSymbol))
{
IntegerValue iv = vs as IntegerValue;
if (iv == null || iv.Value == exponent)
{
return(c);
}
else
{
return(IntegerValue.ConstantZero(signal.Context));
}
}
if (signal.IsDrivenByPortEntity("Add", "Std"))
{
ReadOnlySignalSet inputs = signal.DrivenByPort.InputSignals;
List <Signal> coeffs = new List <Signal>(4);
for (int i = 0; i < inputs.Count; i++)
{
c = MonomialCoefficient(inputs[i], variable, out vs);
IntegerValue iv = vs as IntegerValue;
if (iv != null && iv.Value == exponent)
{
coeffs.Add(c);
}
}
return(signal.Context.Builder.AddSimplified(coeffs));
}
return(UndefinedSymbol.Constant(signal.Context));
}
internal void OnPortAdded(Port port, int index)
{
foreach (ISystemObserver observer in _observers)
{
observer.OnPortAdded(port, index);
}
ReadOnlySignalSet allSignals = System.GetAllSignals();
ReadOnlySignalSet inputs = port.InputSignals;
for (int i = 0; i < inputs.Count; i++)
{
if (allSignals.Contains(inputs[i]))
{
OnSignalDrivesPort(inputs[i], port, i);
}
}
ReadOnlySignalSet outputs = port.OutputSignals;
for (int i = 0; i < outputs.Count; i++)
{
if (allSignals.Contains(outputs[i]))
{
OnPortDrivesSignal(outputs[i], port, i);
}
}
}
public static ValueStructure PolynomialDegree(Signal signal, Signal[] generalizedVariables)
{
if (signal == null)
{
throw new ArgumentNullException("signal");
}
if (signal.IsDrivenByPortEntity("Add", "Std"))
{
IntegerValue d = IntegerValue.Zero;
ReadOnlySignalSet inputs = signal.DrivenByPort.InputSignals;
for (int i = 0; i < inputs.Count; i++)
{
ValueStructure f = MonomialDegree(inputs[i], generalizedVariables);
if (f is UndefinedSymbol)
{
return(f);
}
else if (!(f is NegativeInfinitySymbol))
{
d = d.Max((IntegerValue)f);
}
}
return(d);
}
else
{
return(MonomialDegree(signal, generalizedVariables));
}
}
/// <summary>
/// Evaluates the degree of the single-variable polynomial <see cref="signal"/>.
/// </summary>
/// <returns>
/// <see cref="UndefinedSymbol"/> if <see cref="signal"/> is not a single-variable polynomial.
/// <see cref="NegativeInfinitySymbol"/> if <see cref="signal"/> is zero.
/// Otherwise an <see cref="IntegerValue"/> representing the asked degree.
/// </returns>
/// <remarks><see cref="signal"/> is assumed to be automatic simplified.</remarks>
public static ValueStructure PolynomialDegree(Signal signal, Signal variable)
{
if (signal.IsDrivenByPortEntity("Add", "Std"))
{
IntegerValue d = IntegerValue.Zero;
ReadOnlySignalSet inputs = signal.DrivenByPort.InputSignals;
for (int i = 0; i < inputs.Count; i++)
{
ValueStructure f = MonomialDegree(inputs[i], variable);
if (f is UndefinedSymbol)
{
return(f);
}
else if (!(f is NegativeInfinitySymbol))
{
d = d.Max((IntegerValue)f);
}
}
return(d);
}
else
{
return(MonomialDegree(signal, variable));
}
}
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 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 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 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 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("CosecantTrigonometricSusbtitute", "Std", "TrigonometricSubstitute", "Std",
delegate(Port port) { return(port.Entity.EntityId.Equals("Cosecant", "Std")); },
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 LeavePort(Port port, Signal parent, bool again, bool root)
{
if (_plans[port.InstanceId] == ManipulationPlan.DontAlter)
{
return(true);
}
// ## MANIPULATE PORT
bool isManipulated;
SignalSet preManip = BuildManipulatedInputsList(port, out isManipulated);
IEnumerable <Signal> postManip;
if (_plans[port.InstanceId] == ManipulationPlan.CloneIfChildsAltered)
{
Port newPort = port.CloneWithNewInputs(preManip);
postManip = newPort.OutputSignals;
}
else
{
postManip = _visitor.ManipulatePort(port, preManip, isManipulated);
}
// ## WRITE BACK OUTPUT SIGNAL REPLACEMENTS
ReadOnlySignalSet outputs = port.OutputSignals;
int i = 0;
foreach (Signal rep in postManip)
{
_signalRep[outputs[i++].InstanceId] = rep;
}
return(base.LeavePort(port, parent, again, root));
}
/// <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 });
}
protected override void ReregisterArchitecture(Port oldPort, Port newPort)
{
this.inputSignals = newPort.InputSignals;
this.outputSignals = newPort.OutputSignals;
for(int i = 0; i < inputSignals.Count; i++)
inputSignals[i].ValueChanged += CompoundArchitecture_SignalValueChanged;
system.PushInputValueRange(inputSignals);
}
public Signal Manipulate(Signal rootSignal, 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(rootSignal, 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(rootSignal, reducer, ignoreHold);
// ## EXECUTE MANIPULATION
ManipulatorPlanExecutor executor = new ManipulatorPlanExecutor(plans, signalReplacements, sentinels, visitor);
allPathsStrat.Traverse(rootSignal, executor, ignoreHold);
// ## SELECT NEW SYSTEM
Signal ret;
if (!signalReplacements.TryGetValue(rootSignal.InstanceId, out ret))
{
ret = rootSignal;
}
// ## 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);
FixSentinel(ref ret, sentinels, signalReplacements);
// ## RETURN SELECTED NEW SYSTEM AS RESULT
return(ret);
}
protected override void ReregisterArchitecture(Port oldPort, Port newPort)
{
this.inputSignals = newPort.InputSignals;
this.outputSignals = newPort.OutputSignals;
for (int i = 0; i < inputSignals.Count; i++)
{
inputSignals[i].ValueChanged += CompoundArchitecture_SignalValueChanged;
}
system.PushInputValueRange(inputSignals);
}
public CompoundArchitecture(MathIdentifier id, MathIdentifier entityId, Port port, IMathSystem system)
: base(id, entityId, false)
{
this.inputSignals = port.InputSignals;
this.outputSignals = port.OutputSignals;
this.system = system;
this.system.OutputValueChanged += system_OutputValueChanged;
SetPort(port);
for(int i = 0; i < inputSignals.Count; i++)
inputSignals[i].ValueChanged += CompoundArchitecture_SignalValueChanged;
system.PushInputValueRange(inputSignals);
}
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();
ReadOnlySignalSet cosines = StdBuilder.Cosine(port.InputSignals);
for (int i = 0; i < manipulatedInputs.Count; i++)
{
outputs.Add(cosines[i] * manipulatedInputs[i]);
}
return(outputs);
}));
}
public CompoundArchitecture(MathIdentifier id, MathIdentifier entityId, Port port, IMathSystem system)
: base(id, entityId, false)
{
this.inputSignals = port.InputSignals;
this.outputSignals = port.OutputSignals;
this.system = system;
this.system.OutputValueChanged += system_OutputValueChanged;
SetPort(port);
for (int i = 0; i < inputSignals.Count; i++)
{
inputSignals[i].ValueChanged += CompoundArchitecture_SignalValueChanged;
}
system.PushInputValueRange(inputSignals);
}
public MathSystem BuildSystem()
{
if (!HasSystem)
{
Entity localEntity = entity;
if (entity.IsGeneric)
{
localEntity = entity.CompileGenericEntity(1, 0);
}
Signal[] inputs = new Signal[localEntity.InputSignals.Length];
ReadOnlySignalSet outputs = context.Builder.Functions(localEntity, inputs);
system = new MathSystem(context);
system.AddSignalTreeRange(outputs, true, true);
}
return(system);
}
public MathSystem BuildSystem()
{
if (!HasSystem)
{
IEntity localEntity = entity;
if (entity.IsGeneric)
{
localEntity = entity.CompileGenericEntity(1, 0, null);
}
Signal[] inputs = new Signal[localEntity.InputSignals.Length];
ReadOnlySignalSet outputs = Service <IBuilder> .Instance.Functions(localEntity, inputs);
system = new MathSystem();
system.AddSignalTreeRange(outputs, true, true);
}
return(system);
}
public static Signal Denominator(Signal signal)
{
if (signal.IsDrivenByPortEntity("Divide", "Std") && signal.DrivenByPort.InputSignalCount > 1)
{
if (signal.DrivenByPort.InputSignals.Count == 2)
{
return(signal.DrivenByPort.InputSignals[1]);
}
List <Signal> factors = new List <Signal>();
ReadOnlySignalSet inputs = signal.DrivenByPort.InputSignals;
for (int i = 1; i < inputs.Count; i++) //all but first element
{
factors.Add(inputs[i]);
}
return(signal.Context.Builder.MultiplySimplified(factors));
}
return(IntegerValue.ConstantOne(signal.Context));
}
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;
Signal[] outputs = new Signal[manipulatedInputs.Count];
ReadOnlySignalSet sines = Std.Sine(context, port.InputSignals);
for (int i = 0; i < outputs.Length; i++)
{
outputs[i] = sines[i] * manipulatedInputs[i];
}
return(b.Negate(outputs));
});
return(theorems);
}
public Match MatchFirst(Port port)
{
ReadOnlySignalSet inputs = port.InputSignals;
if (_childAxis.Count != inputs.Count)
{
return(null);
}
// Exact, Ordered Matching
List <MatchCollection> list = new List <MatchCollection>(_childAxis.Count);
for (int i = 0; i < _childAxis.Count; i++)
{
list.Add(_childAxis[i].MatchAll(inputs[i], inputs[i].DrivenByPort, 3));
}
return(MatchCollection.CombineIntersectFirst(list));
}
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 override bool Match(Signal output, Port port)
{
if (!base.Match(output, port))
{
return(false);
}
//if(_exactMatch)
//{
// if(_ordered)
// {
ReadOnlySignalSet inputs = port.InputSignals;
if (_children.Count != inputs.Count)
{
return(false);
}
for (int i = 0; i < _children.Count; i++)
{
if (!_children[i].Match(inputs[i], inputs[i].DrivenByPort))
{
return(false);
}
}
return(true);
// }
// else // permutation
// {
// throw new NotImplementedException("Ineaxct matching is not implemented yet.");
// }
//}
//else // catch all
//{
// throw new NotImplementedException("Out of order matching is not implemented yet.");
// //if(_ordered)
// //{
// //}
// //else // permutation
// //{
// //}
//}
}
private void ScanDefineArchitecture()
{
tokenizer.Match(TokenTypes.TextIdentifier, "architecture");
MathIdentifier architectureId = ScanEntityMathIdentifierOrLabel(true);
MathIdentifier entityId = ScanEntityMathIdentifierOrLabel(true);
IEntity entity = library.LookupEntity(entityId);
tokenizer.Match("{");
IMathSystem originalSystem = system;
IMathSystem tempSystem = Binder.CreateSystem();
system = tempSystem;
while (tokenizer.LookaheadFistToken.Text != "}")
{
NextStatement();
}
foreach (string input in entity.InputSignals)
{
tempSystem.PromoteAsInput(tempSystem.LookupNamedSignal(input));
}
foreach (string output in entity.OutputSignals)
{
tempSystem.AddSignalTree(tempSystem.LookupNamedSignal(output), tempSystem.GetAllInputs(), true, false);
}
ReadOnlySignalSet leafs = tempSystem.GetAllLeafSignals();
foreach (Signal s in leafs)
{
Signal so;
if (originalSystem.TryLookupNamedSignal(s.Label, out so) && so.Value != null)
{
s.PostNewValue(so.Value);
}
}
Service <ISimulationMediator> .Instance.SimulateInstant();
system = originalSystem;
tokenizer.Match("}");
tempSystem.RemoveUnusedObjects();
tempSystem.PublishToLibrary(architectureId, entity.EntityId);
}
private static IManipulationVisitor CreateSubstituteVisitor(Signal subject, Signal replacement)
{
return(new BasicManipulationVisitor(
delegate(Port p)
{ // ## ESTIMATE PLAN
if (p.InputSignals.Contains(subject))
{
return ManipulationPlan.DoAlter;
}
else
{
return ManipulationPlan.CloneIfChildsAltered;
}
},
delegate(Port port, SignalSet manipulatedInputs, bool hasManipulatedInputs)
{ // ## MANIPULATE PORT
/* NOTE: manipulatedInputs could contain sentinels, that's why
* we use the original port inputs instead. */
ReadOnlySignalSet inputs = port.InputSignals;
for (int i = 0; i < inputs.Count; i++)
{
if (subject.Equals(inputs[i]))
{
manipulatedInputs[i] = replacement;
}
}
return port.CloneWithNewInputs(manipulatedInputs).OutputSignals;
},
delegate(Signal original, Signal replaced, bool isReplaced)
{ // ## POST-MANIPULATE SIGNAL
if (subject.Equals(replaced))
{
return replacement;
}
else
{
return replaced;
}
}));
}
public MatchCollection MatchAll(Port port, int score)
{
int newScore = score + 3;
ReadOnlySignalSet inputs = port.InputSignals;
if (_childAxis.Count != inputs.Count)
{
return(new MatchCollection());
}
// Exact, Ordered Matching
List <MatchCollection> list = new List <MatchCollection>(_childAxis.Count);
for (int i = 0; i < _childAxis.Count; i++)
{
list.Add(_childAxis[i].MatchAll(inputs[i], inputs[i].DrivenByPort, newScore));
}
return(MatchCollection.CombineIntersect(list)); //CombineAnd(list);
}
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);
}));
}
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 void RegisterTheorems(ILibrary library)
{
Analysis.DerivativeTransformation.Provider.Add(
new Analysis.DerivativeTransformation(_entityId,
delegate(Port port, SignalSet manipulatedInputs, Signal variable, bool hasManipulatedInputs)
{
Signal[] outputs = new Signal[manipulatedInputs.Count];
ReadOnlySignalSet cotangents = StdBuilder.Cotangent(port.InputSignals);
for (int i = 0; i < outputs.Length; i++)
{
outputs[i] = Std.Multiply(port.OutputSignals[i], cotangents[i], manipulatedInputs[i]);
}
return(StdBuilder.Negate(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)
{
return(StdBuilder.Invert(StdBuilder.Sine(transformedInputs)));
//Signal[] ret = new Signal[transformedInputs.Count];
//for(int i = 0; i < ret.Length; i++)
// ret[i] = Std.Invert(Std.Sine(transformedInputs[i]));
//return ret;
}));
}
public Signal MultiplySimplified(ReadOnlySignalSet signals)
{
return MultiplySimplified(new SignalSet(signals));
}
public Signal AddSimplified(ReadOnlySignalSet signals)
{
return AddSimplified(new SignalSet(signals));
}
public Signal DivideSimplified(ReadOnlySignalSet signals)
{
return DivideSimplified(new SignalSet(signals));
}
public Signal SubtractSimplified(ReadOnlySignalSet signals)
{
return SubtractSimplified(new SignalSet(signals));
}
public Signal MultiplySimplified(ReadOnlySignalSet signals)
{
return(MultiplySimplified(new SignalSet(signals)));
}
public Signal DivideSimplified(ReadOnlySignalSet signals)
{
return(DivideSimplified(new SignalSet(signals)));
}
private void InitializeObserverWithCurrentSystem(ISystemObserver observer)
{
if (_system == null)
{
return;
}
observer.BeginInitialize();
ReadOnlySignalSet allSignals = _system.GetAllSignals();
for (int i = 0; i < allSignals.Count; i++)
{
observer.OnSignalAdded(allSignals[i], i);
}
ReadOnlyBusSet allBuses = _system.GetAllBuses();
for (int i = 0; i < allBuses.Count; i++)
{
observer.OnBusAdded(allBuses[i], i);
}
ReadOnlyPortSet allPorts = _system.GetAllPorts();
for (int i = 0; i < allPorts.Count; i++)
{
observer.OnPortAdded(allPorts[i], i);
}
for (int i = 0; i < allSignals.Count; i++)
{
Signal s = allSignals[i];
if (s.IsDriven && allPorts.Contains(s.DrivenByPort))
{
observer.OnPortDrivesSignal(s, s.DrivenByPort, s.DrivenByPort.OutputSignals.IndexOf(s));
}
}
for (int i = 0; i < allPorts.Count; i++)
{
Port p = allPorts[i];
for (int j = 0; j < p.InputSignalCount; j++)
{
Signal s = p.InputSignals[j];
if (allSignals.Contains(s))
{
observer.OnSignalDrivesPort(s, p, j);
}
}
}
ReadOnlySignalSet inputs = _system.GetAllInputs();
for (int i = 0; i < inputs.Count; i++)
{
observer.OnInputAdded(inputs[i], i);
}
ReadOnlySignalSet outputs = _system.GetAllOutputs();
for (int i = 0; i < outputs.Count; i++)
{
observer.OnOutputAdded(outputs[i], i);
}
observer.EndInitialize();
}
