/// <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 (signal == null) { throw new ArgumentNullException("signal"); } 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)); }
public static Signal PolynomialLeadingCoefficient(Signal signal, Signal variable) { if (signal == null) { throw new ArgumentNullException("signal"); } ValueStructure degree = PolynomialDegree(signal, variable); IntegerValue iv = degree as IntegerValue; if (iv != null) { return(PolynomialCoefficient(signal, variable, (int)iv.Value)); } if (degree is NegativeInfinitySymbol) { return(IntegerValue.ConstantZero(signal.Context)); } return(UndefinedSymbol.Constant(signal.Context)); }
public ValueStructure[] Evaluate(params ValueStructure[] inputs) { if (inputs.Length != _inputs.Count) { throw new System.ArgumentException("The count of inputs doesn't match the systems count of input signals.", "inputs"); } for (int i = 0; i < inputs.Length; i++) { _inputs[i].PostNewValue(inputs[i]); } _context.Scheduler.SimulateInstant(); ValueStructure[] outputs = new ValueStructure[_outputs.Count]; for (int i = 0; i < outputs.Length; i++) { outputs[i] = _outputs[i].Value; } return(outputs); }
private static ValueStructure LocalConvertFrom(ValueStructure value) { IntegerValue inv = value as IntegerValue; if (inv != null) { return(new ComplexValue(inv)); } RationalValue rav = value as RationalValue; if (rav != null) { return(new ComplexValue(rav)); } RealValue rev = value as RealValue; if (rev != null) { return(new ComplexValue(rev)); } return((ComplexValue)value); }
public static LogicValue ConvertFrom(ValueStructure value) { return((LogicValue)_router.ConvertFrom(value)); }
private int Compare(ref ValueStructure left, ref ValueStructure right) { return _comparer.Compare(left.GetBytes(), right.GetBytes()); }
private static ValueStructure LocalConvertFrom(ValueStructure value) { //RealValue inv = value as RealValue; //if(inv != null) return new LiteralValue(inv.Value.ToString(Context.NumberFormat)); return((LiteralValue)value); }
private static ValueStructure LocalConvertToStdInteger(ValueStructure value) { RationalValue rv = (RationalValue)value; return(new IntegerValue(rv._numeratorValue / rv._denominatorValue)); }
public static ComplexValue ConvertFrom(ValueStructure value) { return((ComplexValue)_router.ConvertFrom(value)); }
public override bool Equals(ValueStructure other) { return(other is UndefinedSymbol); }
public ConversionRouter LookupRouter(ValueStructure value) { return(_table.GetValue(value.StructureId).Router); }
protected StructureNotSupportedException(SerializationInfo info, StreamingContext context) : base(info, context) { structure = (ValueStructure)info.GetValue("structure", typeof(ValueStructure)); }
public StructureNotSupportedException(ValueStructure structure) { this.structure = structure; }
private int IsDuplicate(ref ValueStructure left, ref ValueStructure right) { return(_duplicatesComparer.Compare(left.GetBytes(), right.GetBytes())); }
public void PushInputValue(int inputIndex, ValueStructure value, TimeSpan delay) { _inputs[inputIndex].PostNewValue(value, delay); }
private int Compare(ref ValueStructure left, ref ValueStructure right) { return(_comparer.Compare(left.GetBytes(), right.GetBytes())); }
public CurveSegment(Curve segment, TimeSpan begin, ValueStructure offset) { this.Segment = segment; this.Begin = begin; this.Offset = offset; }
public static UndefinedSymbol ConvertFrom(ValueStructure value) { return(_instance); }
private bool Get(CursorOperation operation, byte[] key) { _currentValueStructure = default(ValueStructure); return(Lmdb.mdb_cursor_get(_handle, key, out _currentKeyStructure, out _currentValueStructure, operation) == 0); }
private static ValueStructure LocalConvertToStdReal(ValueStructure value) { return(new RealValue(((ComplexValue)value).RealValue)); }
public override bool Equals(ValueStructure other) { return(other is PositiveInfinitySymbol); }
public static ToggleValue ConvertFrom(ValueStructure value) { return((ToggleValue)_router.ConvertFrom(value)); }
public static PositiveInfinitySymbol ConvertFrom(ValueStructure value) { return(_instance); }
public static RationalValue ConvertFrom(ValueStructure value) { return((RationalValue)_router.ConvertFrom(value)); }
private static ValueStructure LocalConvertToStdInteger(ValueStructure value) { return(new IntegerValue((long)Math.Round(((RealValue)value).Value, 0))); }
public static IntegerValue ConvertFrom(ValueStructure value) { return((IntegerValue)_router.ConvertFrom(value)); }
private KeyValuePair<byte[], byte[]>? Get(CursorOperation operation, ValueStructure? key = null, ValueStructure? value = null) { var keyStruct = key.GetValueOrDefault(); var valueStruct = value.GetValueOrDefault(); var res = NativeMethods.Read(lib => lib.mdb_cursor_get(_handle, ref keyStruct, ref valueStruct, operation)); return res == NativeMethods.MDB_NOTFOUND ? (KeyValuePair<byte[], byte[]>?) null : new KeyValuePair<byte[], byte[]>(keyStruct.ToByteArray(res), valueStruct.ToByteArray(res)); }
private int IsDuplicate(ref ValueStructure left, ref ValueStructure right) { return _duplicatesComparer.Compare(left.GetBytes(), right.GetBytes()); }
public override bool Equals(ValueStructure other) { return(other is ComplexInfinitySymbol); }
public void PushInputValue(int inputIndex, ValueStructure value) { _inputs[inputIndex].PostNewValue(value); }
private static ValueStructure LocalConvertFrom(ValueStructure value) { return(_instance); }
public static ComplexInfinitySymbol ConvertFrom(ValueStructure value) { return(_instance); }
public ComboBoxItem(string text, ValueStructure value) { this.Text = text; this.Value = value; }