/// <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) { IValueStructure 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); } } if (signal.IsDrivenByPortEntity("Add", "Std")) { ISignalSet 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(Std.Add(coeffs)); } return(UndefinedSymbol.Constant); }
public static bool CollectSummands(ISignalSet signals) { bool changed = false; for(int i = 0; i < signals.Count; i++) { Signal s = signals[i]; if(!s.BehavesAsBeingDriven(false)) continue; Port p = s.DrivenByPort; if(p.Entity.EntityId.Equals(AdditionArchitectures.EntityIdentifier)) { signals.RemoveAt(i); ISignalSet inputs = p.InputSignals; for(int j = 0; j < inputs.Count; j++) signals.Insert(i + j, inputs[j]); i--; changed = true; continue; } if(p.Entity.EntityId.Equals(SubtractionArchitectures.EntityIdentifier)) { ISignalSet inputs = p.InputSignals; signals[i] = inputs[0]; i--; for(int j = 1; j < inputs.Count; j++) signals.Insert(i + j, Std.Negate(inputs[j])); changed = true; continue; } } return changed; }
public static bool CollectFactors(ISignalSet signals) { bool changed = false; for(int i = 0; i < signals.Count; i++) { Signal s = signals[i]; if(!s.BehavesAsBeingDriven(false)) continue; Port p = s.DrivenByPort; if(p.Entity.EntityId.Equals(MultiplicationArchitectures.EntityIdentifier)) { signals.RemoveAt(i); ISignalSet inputs = p.InputSignals; for(int j = 0; j < inputs.Count; j++) signals.Insert(i + j, (i == 0 && j != 0) ? Std.Invert(inputs[j]) : inputs[j]); i--; changed = true; continue; } if(p.Entity.EntityId.Equals(DivisionArchitectures.EntityIdentifier)) { ISignalSet inputs = p.InputSignals; signals[i] = inputs[0]; i--; for(int j = 1; j < inputs.Count; j++) signals.Insert(i + j, (i == 0) ? inputs[j] : Std.Invert(inputs[j])); changed = true; continue; } } return changed; }
public static bool SimplifySummands(ISignalSet signals) { bool changed = CollectSummands(signals); if (signals.Count < 2) { return(changed); } IAccumulator acc = null; for (int i = signals.Count - 1; i >= 0; i--) { Signal s = signals[i]; if (Std.IsConstantComplex(s)) { if (acc == null) { acc = Accumulator <IntegerValue, RationalValue> .Create(IntegerValue.AdditiveIdentity); } signals.RemoveAt(i); changed = true; acc = acc.Add(s.Value); } } if (acc != null && !acc.Value.Equals(IntegerValue.AdditiveIdentity)) { signals.Insert(0, Std.DefineConstant(acc.Value)); } return(changed); }
public static IValueStructure PolynomialDegree(Signal signal, Signal[] generalizedVariables) { if (signal == null) { throw new ArgumentNullException("signal"); } if (signal.IsDrivenByPortEntity("Add", "Std")) { IntegerValue d = IntegerValue.Zero; ISignalSet inputs = signal.DrivenByPort.InputSignals; for (int i = 0; i < inputs.Count; i++) { IValueStructure 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> /// 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(Signal product, Signal x) { SignalSet freePart = new SignalSet(); SignalSet dependentPart = new SignalSet(); if (product.IsDrivenByPortEntity("Multiply", "Std")) { ISignalSet 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 = Multiply(freePart); Signal dependentSignal = Multiply(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].SignalValueChanged += CompoundArchitecture_SignalValueChanged; system.PushInputValueRange(inputSignals); }
public static bool CollectOperands(ISignalSet signals) { bool changed = false; while (signals.Count > 0 && signals[0].IsDrivenByPortEntity(PowerArchitectures.EntityIdentifier)) { } return(changed); }
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].SignalValueChanged += CompoundArchitecture_SignalValueChanged; } system.PushInputValueRange(inputSignals); }
/// <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 CompoundArchitecture(MathIdentifier id, MathIdentifier entityId, Port port, MathSystem 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].SignalValueChanged += CompoundArchitecture_SignalValueChanged; system.PushInputValueRange(inputSignals); }
public CompoundArchitecture(MathIdentifier id, MathIdentifier entityId, Port port, MathSystem 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].SignalValueChanged += CompoundArchitecture_SignalValueChanged; } system.PushInputValueRange(inputSignals); }
public static bool SimplifyFactors(ISignalSet signals) { bool changed = CollectFactors(signals); if (signals.Count < 2) { return(changed); } IAccumulator acc = null; for (int i = signals.Count - 1; i > 0; i--) //don't touch first item! { Signal s = signals[i]; if (Std.IsConstantComplex(s)) { if (acc == null) { acc = Accumulator <IntegerValue, RationalValue> .Create(IntegerValue.MultiplicativeIdentity); } signals.RemoveAt(i); changed = true; if (Std.IsConstantAdditiveIdentity(s)) { signals.Clear(); signals.Add(UndefinedSymbol.Constant); return(true); } acc = acc.Multiply(s.Value); } } if (acc != null && !acc.Value.Equals(IntegerValue.MultiplicativeIdentity)) { Signal first = signals[0]; if (Std.IsConstantComplex(first)) { acc = acc.Divide(first.Value).Invert(); signals[0] = Std.DefineConstant(acc.Value); changed = true; } else { signals.Insert(1, Std.DefineConstant(acc.Value)); } } return(changed); }
/// <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)); }
/// <summary> /// Substracts a set of signals (from the first signal) 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 Subtract(ISignalSet signals) { if (signals.IsReadOnly) { signals = new SignalSet(signals); } SubtractionArchitectures.SimplifySummandsForceAddition(signals); if (signals.Count == 0) { return(IntegerValue.ConstantAdditiveIdentity); } if (signals.Count == 1) { return(signals[0]); } return(StdBuilder.Subtract(signals)); }
/// <summary> /// Divides a set of signals (from the first signal) 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 Divide(ISignalSet signals) { if (signals.IsReadOnly) { signals = new SignalSet(signals); } DivisionArchitectures.SimplifyFactorsForceMultiplication(signals); if (signals.Count == 0) { return(IntegerValue.ConstantMultiplicativeIdentity); } if (signals.Count == 1) { return(signals[0]); } return(StdBuilder.Divide(signals)); }
public static bool SimplifyFactorsForceMultiplication(ISignalSet signals) { bool changed = CollectFactors(signals); if (signals.Count < 2) { return(changed); } for (int i = 1; i < signals.Count; i++) { signals[i] = Std.Invert(signals[i]); } Signal product = Std.Multiply(signals); signals.Clear(); signals.Add(product); return(true); }
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>(); ISignalSet inputs = signal.DrivenByPort.InputSignals; for (int i = 1; i < inputs.Count; i++) //all but first element { factors.Add(inputs[i]); } return(Multiply(factors)); } return(IntegerValue.ConstantOne); }
public static bool SimplifySummandsForceAddition(ISignalSet signals) { bool changed = CollectSummands(signals); if (signals.Count < 2) { return(changed); } for (int i = 1; i < signals.Count; i++) { signals[i] = Std.Negate(signals[i]); } Signal sum = Std.Add(signals); signals.Clear(); signals.Add(sum); return(true); }
public Match MatchFirst(Port port) { ISignalSet 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 override bool Match(Signal output, Port port) { if (!base.Match(output, port)) { return(false); } //if(_exactMatch) //{ // if(_ordered) // { ISignalSet 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 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. */ ISignalSet 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 static bool CollectFactors(ISignalSet signals) { bool changed = false; for (int i = 0; i < signals.Count; i++) { Signal s = signals[i]; if (!s.BehavesAsBeingDriven(false)) { continue; } Port p = s.DrivenByPort; if (p.Entity.EntityId.Equals(MultiplicationArchitectures.EntityIdentifier)) { signals.RemoveAt(i); ISignalSet inputs = p.InputSignals; for (int j = 0; j < inputs.Count; j++) { signals.Insert(i + j, inputs[j]); } i--; changed = true; continue; } if (p.Entity.EntityId.Equals(DivisionArchitectures.EntityIdentifier)) { ISignalSet inputs = p.InputSignals; signals[i] = inputs[0]; i--; for (int j = 1; j < inputs.Count; j++) { signals.Insert(i + j, Std.Invert(inputs[j])); } changed = true; continue; } } return(changed); }
public static bool CollectSummands(ISignalSet signals) { bool changed = false; for (int i = 0; i < signals.Count; i++) { Signal s = signals[i]; if (!s.BehavesAsBeingDriven(false)) { continue; } Port p = s.DrivenByPort; if (p.Entity.EntityId.Equals(AdditionArchitectures.EntityIdentifier)) { signals.RemoveAt(i); ISignalSet inputs = p.InputSignals; for (int j = 0; j < inputs.Count; j++) { signals.Insert(i + j, (i == 0 && j != 0) ? Std.Negate(inputs[j]) : inputs[j]); } i--; changed = true; continue; } if (p.Entity.EntityId.Equals(SubtractionArchitectures.EntityIdentifier)) { ISignalSet inputs = p.InputSignals; signals[i] = inputs[0]; i--; for (int j = 1; j < inputs.Count; j++) { signals.Insert(i + j, (i == 0) ? inputs[j] : Std.Negate(inputs[j])); } changed = true; continue; } } return(changed); }
public MatchCollection MatchAll(Port port, int score) { int newScore = score + 3; ISignalSet 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 bool SimplifySummands(ISignalSet signals) { bool changed = CollectSummands(signals); if (signals.Count < 2) { return(changed); } IAccumulator acc = null; for (int i = signals.Count - 1; i > 0; i--) //don't touch first item! { Signal s = signals[i]; if (Std.IsConstantComplex(s)) { if (acc == null) { acc = Accumulator <IntegerValue, RationalValue> .Create(IntegerValue.AdditiveIdentity); } signals.RemoveAt(i); changed = true; acc = acc.Add(s.Value); } } if (acc != null && !acc.Value.Equals(IntegerValue.AdditiveIdentity)) { Signal first = signals[0]; if (Std.IsConstantComplex(first)) { acc = acc.Subtract(first.Value).Negate(); signals[0] = Std.DefineConstant(acc.Value); changed = true; } else { signals.Insert(1, Std.DefineConstant(acc.Value)); } } return(changed); }
public static bool SimplifyOperands(ISignalSet signals) { if (signals.Count < 2) { return(false); } bool changed = false; Signal radix = signals[0]; if (Std.IsConstantAdditiveIdentity(radix) && Std.IsConstant(signals[1])) { if (Std.IsAlwaysNegative(signals[1])) { signals.Clear(); signals.Add(UndefinedSymbol.Constant); return(true); } signals.Clear(); signals.Add(radix); return(true); } if (Std.IsConstantMultiplicativeIdentity(radix)) { signals.Clear(); signals.Add(radix); return(true); } // Evaluate all but the first two operands -> nonnegative integers IntegerValue value = null; for (int i = signals.Count - 1; i > 1; i--) { Signal s = signals[i]; if (!Std.IsConstantNonnegativeInteger(s)) { if (changed) { if (!value.IsMultiplicativeIdentity) { signals.Add(Std.DefineConstant(value)); } return(true); } return(false); } signals.RemoveAt(i); value = ValueConverter <IntegerValue> .ConvertFrom(s.Value).PositiveIntegerPower((int)value.Value); changed = true; } // Evaluate the second operand -> integer (can also be negative) Signal exponent = signals[1]; if (!Std.IsConstantInteger(exponent)) { if (changed) { if (!value.IsMultiplicativeIdentity) { signals.Add(Std.DefineConstant(value)); } return(true); } return(false); } IntegerValue exponentValue = ValueConverter <IntegerValue> .ConvertFrom(exponent.Value); if (changed) { exponentValue = exponentValue.PositiveIntegerPower((int)value.Value); } // Special case: first operand is a power if (radix.IsDrivenByPortEntity(PowerArchitectures.EntityIdentifier) && radix.DrivenByPort.InputSignalCount == 2 && Std.IsConstantInteger(radix.DrivenByPort.InputSignals[1])) { exponentValue = exponentValue.Multiply(ValueConverter <IntegerValue> .ConvertFrom(radix.DrivenByPort.InputSignals[1].Value)); signals[0] = radix = radix.DrivenByPort.InputSignals[0]; changed = true; } // Evaluate the first operand if (!Std.IsConstantComplex(radix)) { if (changed) { if (!exponentValue.IsMultiplicativeIdentity) { signals[1] = Std.DefineConstant(exponentValue); } else { signals.RemoveAt(1); } return(true); } return(false); } IAccumulator acc = Accumulator <IntegerValue, RationalValue> .Create(radix.Value); acc = acc.IntegerPower((int)exponentValue.Value); signals.Clear(); signals.Add(Std.DefineConstant(acc.Value)); return(true); }
public static bool SimplifyFactorsForceMultiplication(ISignalSet signals) { bool changed = CollectFactors(signals); if(signals.Count < 2) return changed; for(int i = 1; i < signals.Count; i++) signals[i] = Std.Invert(signals[i]); Signal product = Std.Multiply(signals); signals.Clear(); signals.Add(product); return true; }
public static bool SimplifySummands(ISignalSet signals) { bool changed = CollectSummands(signals); if(signals.Count < 2) return changed; IAccumulator acc = null; for(int i = signals.Count - 1; i >= 0; i--) { Signal s = signals[i]; if(Std.IsConstantComplex(s)) { if(acc == null) acc = Accumulator<IntegerValue, RationalValue>.Create(IntegerValue.AdditiveIdentity); signals.RemoveAt(i); changed = true; acc = acc.Add(s.Value); } } if(acc != null && !acc.Value.Equals(IntegerValue.AdditiveIdentity)) { signals.Insert(0, Std.DefineConstant(acc.Value)); } return changed; }
/// <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); }
/// <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 SimplifySummandsForceAddition(ISignalSet signals) { bool changed = CollectSummands(signals); if(signals.Count < 2) return changed; for(int i = 1; i < signals.Count; i++) signals[i] = Std.Negate(signals[i]); Signal sum = Std.Add(signals); signals.Clear(); signals.Add(sum); return true; }
public static bool SimplifyFactors(ISignalSet signals) { bool changed = CollectFactors(signals); if(signals.Count < 2) return changed; IAccumulator acc = null; for(int i = signals.Count - 1; i > 0; i--) //don't touch first item! { Signal s = signals[i]; if(Std.IsConstantComplex(s)) { if(acc == null) acc = Accumulator<IntegerValue, RationalValue>.Create(IntegerValue.MultiplicativeIdentity); signals.RemoveAt(i); changed = true; if(Std.IsConstantAdditiveIdentity(s)) { signals.Clear(); signals.Add(UndefinedSymbol.Constant); return true; } acc = acc.Multiply(s.Value); } } if(acc != null && !acc.Value.Equals(IntegerValue.MultiplicativeIdentity)) { Signal first = signals[0]; if(Std.IsConstantComplex(first)) { acc = acc.Divide(first.Value).Invert(); signals[0] = Std.DefineConstant(acc.Value); changed = true; } else { signals.Insert(1, Std.DefineConstant(acc.Value)); } } return changed; }
public static bool SimplifySummands(ISignalSet signals) { bool changed = CollectSummands(signals); if(signals.Count < 2) return changed; IAccumulator acc = null; for(int i = signals.Count - 1; i > 0; i--) //don't touch first item! { Signal s = signals[i]; if(Std.IsConstantComplex(s)) { if(acc == null) acc = Accumulator<IntegerValue, RationalValue>.Create(IntegerValue.AdditiveIdentity); signals.RemoveAt(i); changed = true; acc = acc.Add(s.Value); } } if(acc != null && !acc.Value.Equals(IntegerValue.AdditiveIdentity)) { Signal first = signals[0]; if(Std.IsConstantComplex(first)) { acc = acc.Subtract(first.Value).Negate(); signals[0] = Std.DefineConstant(acc.Value); changed = true; } else { signals.Insert(1, Std.DefineConstant(acc.Value)); } } return changed; }
/// <summary> /// Extracts all coefficients of the polynomial <see cref="signal"/>. /// </summary> /// <returns>A signal array [c0,c1,c2,..] where ci ist the coefficient of x^i.</returns> public static Signal[] PolynomialCoefficients(Signal signal, Signal variable) { IValueStructure vs; SortedList <long, Signal> polynom = new SortedList <long, Signal>(); Signal c = MonomialCoefficient(signal, variable, out vs); if (!(vs is UndefinedSymbol)) { IntegerValue iv = vs as IntegerValue; if (iv != null) { polynom.Add(iv.Value, c); } else { return new Signal[] { IntegerValue.ConstantZero } }; } else if (signal.IsDrivenByPortEntity("Add", "Std")) { ISignalSet inputs = signal.DrivenByPort.InputSignals; for (int i = 0; i < inputs.Count; i++) { c = MonomialCoefficient(inputs[i], variable, out vs); IntegerValue iv = vs as IntegerValue; if (iv != null) { if (!polynom.ContainsKey(iv.Value)) { polynom.Add(iv.Value, c); } else { polynom[iv.Value] = Std.Add(polynom[iv.Value], c); } } } } if (polynom.Keys.Count == 0) { return new Signal[] { } } ; long deg = polynom.Keys[polynom.Keys.Count - 1]; Signal[] ret = new Signal[deg + 1]; Signal zero = IntegerValue.ConstantZero; for (int i = 0; i < ret.Length; i++) { if (polynom.ContainsKey(i)) { ret[i] = polynom[i]; } else { ret[i] = zero; } } return(ret); }