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