C# Signal.IsDrivenByPortEntity方法代码示例

 /// <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 ValueStructure MonomialDegree(Signal signal, Signal[] generalizedVariables)
 {
     if(IsConstantAdditiveIdentity(signal))
         return NegativeInfinitySymbol.Instance;
     if(Array.Exists<Signal>(generalizedVariables, signal.Equals))
         return IntegerValue.One;
     if(!Array.Exists<Signal>(generalizedVariables, signal.DependsOn))
         return IntegerValue.Zero;
     ISignalSet factors;
     long deg = 0;
     if(signal.IsDrivenByPortEntity("Multiply", "Std"))
         factors = signal.DrivenByPort.InputSignals;
     else
         factors = new SignalSet(signal);
     for(int i = 0; i < factors.Count; i++)
     {
         if(Array.Exists<Signal>(generalizedVariables, factors[i].Equals))
             deg++;
         else if(factors[i].IsDrivenByPortEntity("Power", "Std"))
         {
             Signal b = signal.DrivenByPort.InputSignals[0];
             Signal e = signal.DrivenByPort.InputSignals[1];
             IntegerValue v;
             if(Array.Exists<Signal>(generalizedVariables, b.Equals) && (v = e.Value as IntegerValue) != null && v.Value > 0)
                 deg += v.Value;
         }
     }
     return new IntegerValue(deg);
 }

 public static Signal[] PolynomialVariables(Signal signal)
 {
     List<Signal> variables = new List<Signal>();
     ISignalSet monomials;
     if(signal.IsDrivenByPortEntity("Add", "Std"))
         monomials = signal.DrivenByPort.InputSignals;
     else
         monomials = new SignalSet(signal);
     for(int i = 0; i < monomials.Count; i++)
     {
         ISignalSet factors;
         if(monomials[i].IsDrivenByPortEntity("Multiply", "Std"))
             factors = monomials[i].DrivenByPort.InputSignals;
         else
             factors = new SignalSet(monomials[i]);
         for(int j = 0; j < factors.Count; j++)
         {
             if(IsAlwaysRational(factors[j]))
                 continue;
             if(factors[j].IsDrivenByPortEntity("Power", "Std"))
             {
                 Signal b = factors[j].DrivenByPort.InputSignals[0];
                 if(IsAlwaysPositiveInteger(factors[j].DrivenByPort.InputSignals[1]))
                 {
                     if(!variables.Contains(b))
                         variables.Add(b);
                 }
                 else
                 {
                     if(!variables.Contains(signal))
                         variables.Add(signal);
                 }
             }
             else
                 if(!variables.Contains(factors[j]))
                     variables.Add(factors[j]);
         }
     }
     return variables.ToArray();
 }

 public static bool IsPolynomial(Signal signal, Signal[] generalizedVariables)
 {
     if(!signal.IsDrivenByPortEntity("Add", "Std"))
         return IsMonomial(signal, generalizedVariables);
     if(Array.Exists<Signal>(generalizedVariables, signal.Equals))
         return true;
     return signal.DrivenByPort.InputSignals.TrueForAll(delegate(Signal s) { return IsMonomial(s, generalizedVariables); });
 }

 public static bool IsMonomial(Signal signal, Signal[] generalizedVariables)
 {
     if(signal.IsDrivenByPortEntity("Multiply", "Std"))
         return signal.DrivenByPort.InputSignals.TrueForAll(delegate(Signal s) {return IsMonomialFactor(s, generalizedVariables);});
     else
         return IsMonomialFactor(signal, generalizedVariables);
 }

 private static bool IsMonomialFactor(Signal signal, Signal[] generalizedVariables)
 {
     if(Array.Exists<Signal>(generalizedVariables, signal.Equals))
         return true;
     if(!Array.Exists<Signal>(generalizedVariables, signal.DependsOn))
         return true;
     if(signal.IsDrivenByPortEntity("Power", "Std"))
     {
         Signal b = signal.DrivenByPort.InputSignals[0];
         Signal e = signal.DrivenByPort.InputSignals[1];
         if(Array.Exists<Signal>(generalizedVariables, b.Equals) && Std.IsAlwaysPositiveInteger(e))
             return true;
     }
     return false;
 }

        public static Signal Numerator(Signal signal)
        {
            if(signal == null)
                throw new ArgumentNullException("signal");

            if(signal.IsDrivenByPortEntity("Divide", "Std"))
                return signal.DrivenByPort.InputSignals[0];
            return signal;
        }

 public static Signal Numerator(Signal signal)
 {
     if(signal.IsDrivenByPortEntity("Divide", "Std"))
         return signal.DrivenByPort.InputSignals[0];
     return signal;
 }

 /// <summary>
 /// Returns the coefficient factor in the monomial <see cref="signal"/>
 /// </summary>
 /// <returns>
 /// Constant UndefinedSymbol if <see cref="signal"/> is not a single-variable monomial.
 /// Otherwise the coefficient factor of the term.
 /// </returns>
 /// </returns>
 /// <remarks><see cref="signal"/> is assumed to be automatic simplified.</remarks>
 public static Signal MonomialCoefficient(Signal signal, Signal variable, out ValueStructure degree)
 {
     if(IsConstantAdditiveIdentity(signal))
     {
         degree = NegativeInfinitySymbol.Instance;
         return signal;
     }
     if(IsAlwaysRational(signal))
     {
         degree = IntegerValue.Zero;
         return signal;
     }
     Signal coeff = IntegerValue.ConstantOne(signal.Context);
     if(signal.IsDrivenByPortEntity("Multiply", "Std") && signal.DrivenByPort.InputSignalCount == 2 && IsAlwaysRational(signal.DrivenByPort.InputSignals[0]))
     {
         coeff = signal.DrivenByPort.InputSignals[0];
         signal = signal.DrivenByPort.InputSignals[1];
     }
     if(signal.Equals(variable))
     {
         degree = IntegerValue.One;
         return coeff;
     }
     if(signal.IsDrivenByPortEntity("Power", "Std"))
     {
         Signal b = signal.DrivenByPort.InputSignals[0];
         Signal e = signal.DrivenByPort.InputSignals[1];
         if(b.Equals(variable) && Std.IsAlwaysPositiveInteger(e))
         {
             degree = e.Value;
             return coeff;
         }
     }
     degree = UndefinedSymbol.Instance;
     return UndefinedSymbol.Constant(signal.Context);
 }

 /// <summary>
 /// Checks whether a signal is a signle variable rational, a fraction of polynomials.
 /// </summary>
 /// <remarks><see cref="signal"/> is assumed to be automatic simplified.</remarks>
 public static bool IsRational(Signal signal, Signal variable)
 {
     if(signal.IsDrivenByPortEntity("Divide", "Std"))
         return IsPolynomial(Numerator(signal), variable) && IsPolynomial(Denominator(signal), variable);
     else
         return IsPolynomial(signal, variable);
 }

        /// <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 == 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],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 ValueStructure PolynomialDegree(Signal signal, Signal[] generalizedVariables)
 {
     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>
 /// 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);
 }

        /// <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)
        {
            ValueStructure 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(signal.Context) };
            }
            else if(signal.IsDrivenByPortEntity("Add", "Std"))
            {
                ReadOnlySignalSet 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] = signal.Context.Builder.AddSimplified(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];
            Signal zero = IntegerValue.ConstantZero(signal.Context);
            for(int i = 0; i < ret.Length; i++)
                if(polynom.ContainsKey(i))
                    ret[i] = polynom[i];
                else
                    ret[i] = zero;
            return ret;
        }

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