public static Signal ConstructPolynomial <TCoeff>(Signal variable, params TCoeff[] coefficients)
where TCoeff : IAlgebraicRingWithUnity <TCoeff>, IValueStructure
{
Signal zero = null;
Signal[] summands = new Signal[coefficients.Length];
for (int i = 0; i < summands.Length; i++)
{
TCoeff c = coefficients[i];
if (c.IsAdditiveIdentity)
{
if (zero == null)
{
zero = Std.DefineConstant(c);
}
summands[i] = zero;
continue;
}
Signal coeff = Std.DefineConstant(c);
if (i == 0)
{
summands[0] = coeff;
}
else if (i == 1)
{
if (c.IsMultiplicativeIdentity)
{
summands[1] = variable;
}
else
{
summands[1] = StdBuilder.Multiply(coeff, variable);
}
}
else
{
if (c.IsMultiplicativeIdentity)
{
summands[i] = StdBuilder.Power(variable, IntegerValue.Constant(i));
}
else
{
summands[i] = StdBuilder.Multiply(coeff, StdBuilder.Power(variable, IntegerValue.Constant(i)));
}
}
}
return(Std.Add(summands));
}
/// <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>
/// 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));
}
/// <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));
}
public static Signal ConstructPolynomial(Signal variable, params Signal[] coefficients)
{
Signal[] summands = new Signal[coefficients.Length];
for (int i = 0; i < summands.Length; i++)
{
Signal coeff = coefficients[i];
if (Std.IsConstantAdditiveIdentity(coeff))
{
summands[i] = coeff;
continue;
}
if (i == 0)
{
summands[0] = coeff;
}
else if (i == 1)
{
if (Std.IsConstantMultiplicativeIdentity(coeff))
{
summands[1] = variable;
}
else
{
summands[1] = StdBuilder.Multiply(coeff, variable);
}
}
else
{
if (Std.IsConstantMultiplicativeIdentity(coeff))
{
summands[i] = StdBuilder.Power(variable, IntegerValue.Constant(i));
}
else
{
summands[i] = StdBuilder.Multiply(coeff, StdBuilder.Power(variable, IntegerValue.Constant(i)));
}
}
}
return(Std.Add(summands));
}
