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