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