public void AutoSimplify_RationalNumberExpression()
{
// A
Signal a =
StdBuilder.Add(
StdBuilder.Divide(IntegerValue.Constant(2), IntegerValue.Constant(3)),
RationalValue.Constant(3, 4));
Assert.AreEqual("2/3+3/4", _f.Format(a, FormattingOptions.Compact), "A1");
Signal aS = Std.AutoSimplify(a);
Assert.AreEqual("17/12", _f.Format(aS, FormattingOptions.Compact), "A2");
// B
Signal b =
StdBuilder.Power(
StdBuilder.Divide(IntegerValue.Constant(4), IntegerValue.Constant(2)),
IntegerValue.Constant(3));
Assert.AreEqual("(4/2)^3", _f.Format(b, FormattingOptions.Compact), "B1");
Signal bS = Std.AutoSimplify(b);
Assert.AreEqual("8", _f.Format(bS, FormattingOptions.Compact), "B2");
// C
Signal c =
StdBuilder.Divide(
IntegerValue.ConstantOne,
StdBuilder.Subtract(
RationalValue.Constant(2, 4),
RationalValue.ConstantHalf));
Assert.AreEqual("1/(1/2-1/2)", _f.Format(c, FormattingOptions.Compact), "C1");
Signal cS = Std.AutoSimplify(c);
Assert.AreEqual("Std.Undefined", _f.Format(cS, FormattingOptions.Compact), "C2");
// D
Signal d =
StdBuilder.Power(
StdBuilder.Power(
IntegerValue.Constant(5),
IntegerValue.Constant(2)),
StdBuilder.Power(
IntegerValue.Constant(3),
IntegerValue.Constant(1)));
Assert.AreEqual("(5^2)^(3^1)", _f.Format(d, FormattingOptions.Compact), "D1");
Signal dS = Std.AutoSimplify(d);
Assert.AreEqual("15625", _f.Format(dS, FormattingOptions.Compact), "D2");
}
public override bool StillValidAfterEvent(Signal signal)
{
if (signal == null)
{
throw new ArgumentNullException("signal");
}
if (signal.Value == null)
{
return(false);
}
return(RationalValue.CanConvertLosslessFrom(signal.Value));
}
public void DirectLosslessConversionsTest()
{
IntegerValue int1 = new IntegerValue(35);
RationalValue rat1 = ValueConverter <RationalValue> .ConvertFrom(int1);
Assert.AreEqual(35, rat1.NumeratorValue, "01");
Assert.AreEqual(1, rat1.DenominatorValue, "02");
RealValue real1 = ValueConverter <RealValue> .ConvertFrom(rat1);
Assert.AreEqual(35d, real1.Value, 0.0001d, "03");
}
public IAccumulator IntegerPower(IValueStructure operand)
{
object other;
if (ValueConverter <IntegerValue> .TryConvertLosslessFrom(operand, out other))
{
return(IntegerPower((int)((IntegerValue)other).Value));
}
if (ValueConverter <RationalValue> .TryConvertLosslessFrom(operand, out other))
{
RationalValue rv = (RationalValue)other;
if (rv.IsInteger)
{
return(IntegerPower((int)rv.NumeratorValue));
}
}
throw new NotSupportedException();
}
/// <summary>
/// The height of a polynomial is the maxium of the absolute values of its coefficients.
/// </summary>
public static IValueStructure PolynomialHeight(Signal signal, Signal variable)
{
Signal[] coefficients = PolynomialCoefficients(signal, variable);
if (coefficients.Length == 0)
{
return(UndefinedSymbol.Instance);
}
RationalValue max = RationalValue.ConvertFrom(coefficients[0].Value).Absolute();
for (int i = 1; i < coefficients.Length; i++)
{
RationalValue next = RationalValue.ConvertFrom(coefficients[i].Value).Absolute();
if (next > max)
{
max = next;
}
}
return(max);
}
public PowerArchitectures()
: base(_entityId)
{
AddArchitecture(EntityId.DerivePrefix("Integer"),
IntegerValueCategory.IsIntegerValueMember,
delegate(Port port) { return(new ProcessBase[] { new GenericStdFunctionProcess <IntegerValue>(delegate() { return IntegerValue.One; }, IntegerValue.ConvertFrom, delegate(IntegerValue acc, IntegerValue item) { return acc.Power(item); }, port.InputSignalCount) }); });
AddArchitecture(new MathIdentifier("RationalPowerIntegerRadix", "Std"),
delegate(Port port) { return(RationalValue.CanConvertLosslessFrom(port.InputSignals[0].Value) && IntegerValue.CanConvertLosslessFrom(port.InputSignals[1].Value)); },
delegate(Port port) { return(new ProcessBase[] { new GenericStdFunctionProcess <RationalValue>(delegate() { return IntegerValue.One; }, RationalValue.ConvertFrom, delegate(RationalValue acc, RationalValue item) { return acc.Power(item.Numerator); }, port.InputSignalCount) }); });
AddArchitecture(EntityId.DerivePrefix("Real"),
RealValueCategory.IsRealValueMember,
delegate(Port port) { return(new ProcessBase[] { new GenericStdFunctionProcess <RealValue>(delegate() { return IntegerValue.One; }, RealValue.ConvertFrom, delegate(RealValue acc, RealValue item) { return acc.Power(item); }, port.InputSignalCount) }); });
AddArchitecture(EntityId.DerivePrefix("Complex"),
ComplexValueCategory.IsComplexValueMember,
delegate(Port port) { return(new ProcessBase[] { new GenericStdFunctionProcess <ComplexValue>(delegate() { return ComplexValue.One; }, ComplexValue.ConvertFrom, ComplexValue.Power, port.InputSignalCount) }); });
}
public void IndirectLosslessConversionsTest()
{
ToggleValue toggle1 = ToggleValue.InitialToggle;
Assert.AreEqual("Std.Toggle(A)", toggle1.ToString(), "01");
RationalValue rat1 = ValueConverter <RationalValue> .ConvertFrom(toggle1);
Assert.AreEqual(1, rat1.NumeratorValue, "02");
Assert.AreEqual(1, rat1.DenominatorValue, "03");
RationalValue rat2 = ValueConverter <RationalValue> .ConvertFrom(toggle1.Toggle());
Assert.AreEqual(0, rat2.NumeratorValue, "04");
Assert.AreEqual(1, rat2.DenominatorValue, "05");
RealValue real1 = ValueConverter <RealValue> .ConvertFrom(toggle1);
Assert.AreEqual(1d, real1.Value, 0.0001d, "06");
}
public static bool IsConstantRational(Signal signal)
{
return(IsConstant(signal) && RationalValue.CanConvertLosslessFrom(signal.Value));
}
