public void CreateDecimalTest()
{
var d = Dec.Create(0.5m);
Assert.AreEqual(d, Literal.Create(1) / Literal.Create(2));
Assert.AreEqual(d.ToString(), "0.5");
}
public void CreateDecimalTest2()
{
var d = Dec.Create(0.33333333333333m);
Assert.AreEqual(d, Literal.Create(1) / Literal.Create(3));
Assert.AreEqual(d.ToString(), "0.33333333333333");
}
public void ExprTest()
{
const string input = "12 * 3 + foo(-3, x)() * (2 + 1)";
var actual = AddOp.Create(
MultiplyOp.Create(
Literal.Create(12),
Literal.Create(3)
),
MultiplyOp.Create(
Call.Create(
Call.Create(
new Identifier("foo"),
NegativeOp.Create(Literal.Create(3)),
new Identifier("x")
)
),
AddOp.Create(
new Two(),
new One()
)
)
).Simplify();
var expected = ExprParser.ParseOrThrow(input);
Assert.AreEqual(expected.Simplify(), actual);
}
public void Pi()
{
var actual = ExprParser.ParseOrThrow("2×π");
var expected = Literal.Create(2) * new Identifier("π");
Assert.AreEqual(expected, actual);
}
public void TrailingZerosOnDecimal()
{
var f = ExprParser.ParseOrThrow("1.2340000");
Assert.AreEqual(f, new One() + (Literal.Create(234) / Literal.Create(1000)));
Assert.AreEqual(f, (Literal.Create(234) / Literal.Create(1000)) + new One());
}
/// <summary>
/// This is the command handler that will add the code to multiple the output of the random number primitive by 10
/// This is called when the user presses the Multiply By 10 button
/// </summary>
/// <param name="parameter">The command parameter associated with instance of the command</param>
/// <param name="selection">The current selection</param>
/// <param name="host">The Composition host for the session</param>
/// <param name="site">The document edit site which is managing the edit session</param>
public static void OnMultipleBy10(ICommandParameter parameter, IEnumerable <IViewModel> selection, ICompositionHost host, DocumentEditSite site)
{
// The selected item will be the random number node since we only add this command for random numbers
var node = selection.First().Model as Node;
if (node == null)
{
return;
}
// Start a transaction and add content to multiply the output by 10
using (var transaction = node.TransactionManager.BeginTransaction("Multiple By 10", TransactionPurpose.User))
{
// Create a multiple node, position it nicely to the right ot the random number, and add it to the same diagram
var multiply = Multiply.Create(ElementCreateInfo.ForNew);
multiply.TopLeft = new SMPoint(node.Bounds.Right + StockDiagramGeometries.StandardNodeWidth, node.Top + (2 * StockDiagramGeometries.GridSize));
node.Diagram.AddNode(multiply);
// Wire the random number output to the first input on the multiple node
node.Diagram.WireWithin((NodeTerminal)node.OutputTerminals.First(), (NodeTerminal)multiply.InputTerminals.First());
// Create a Double Numeric Constant with an initial value of 10.0
var literal = Literal.Create(NITypes.Double, 10.0);
// Position the constant nicely and add it to the diagram
literal.TopLeft = new SMPoint(node.Left + StockDiagramGeometries.TinyNodeWidth, node.Bounds.Bottom + (2 * StockDiagramGeometries.GridSize));
node.Diagram.AddNode(literal);
// Wire the constant to the multiply node
node.Diagram.WireWithin(literal.OutputTerminal, (NodeTerminal)multiply.InputTerminals.ElementAt(1));
// Commit the transaction to finish the operation
transaction.Commit();
}
}
public void ParseSciNotWithParenTest()
{
var f = ExprParser.ParseOrThrow("1.2340000E(4)");
Assert.AreEqual(f, (new One() * Literal.Create(10000)) + Literal.Create(2340));
Assert.AreEqual(f, Literal.Create(2340) + (Literal.Create(10000) * new One()));
}
public void Test6()
{
const string input = "(1-a*(3-4)*x/21)^3-(1/2)^5+11-(16.31^3-a)*r*f(x)";
var ex2 = ExprParser.ParseOrThrow("16.31^3");
ex2 = ex2.Simplify();
Assert.AreEqual(ex2, DivideOp.Create(4338722591, 1000000));
var a = new Identifier("a");
var one = new One();
var three = Literal.Create(3);
var four = Literal.Create(4);
var x = new Identifier("x");
var twentyone = Literal.Create(21);
var two = new Two();
var five = Literal.Create(5);
var eleven = Literal.Create(11);
var sixteenPthirtyone = ExprParser.ParseOrThrow("16.31");
var r = new Identifier("r");
var fOfx = Call.Create(new Identifier("f"), x);
var expected = ExprParser.ParseOrThrow(input);
var actual = (one - (a * (three - four) * x / twentyone)).Raise(three) - (one / two).Raise(five) + eleven - ((sixteenPthirtyone.Raise(three) - a) * r * fOfx).Simplify();
Assert.AreEqual(expected.Simplify(), actual);
Assert.AreEqual((a * r * fOfx) - (Literal.Create(4338722591) * r * fOfx / Literal.Create(1000000)) + (a.Raise(three) * x.Raise(three) / Literal.Create(9261)) + (a.Raise(two) * x.Raise(two) / Literal.Create(147)) + (a * x / Literal.Create(7)) + (Literal.Create(383) / Literal.Create(32)), actual);
}
public void TrailingZerosOnSciNo()
{
var f = ExprParser.ParseOrThrow("1.2340000E4");
Assert.AreEqual(f, (new One() * Literal.Create(10000)) + Literal.Create(2340));
Assert.AreEqual(f, Literal.Create(2340) + (Literal.Create(10000) * new One()));
}
public static Expr ToExpr(this BigInteger i)
{
if (i < 0)
{
return(NegativeOp.Create(Literal.Create(BigInteger.Abs(i))));
}
return(Literal.Create(i));
}
public void SqrtOf8()
{
var sqrtOf8 = SqrtOp.Create(Literal.Create(8)).Simplify();
var two = new Two();
var three = Literal.Create(3);
var actual = two.Raise(three / two);
Assert.AreEqual(sqrtOf8, actual);
}
public void NegateDivideTest()
{
const string input = "- (1/3)";
var actual = NegativeOp.Create(
DivideOp.Create(new One(), Literal.Create(3))
).Simplify();
var expected = ExprParser.ParseOrThrow(input);
Assert.AreEqual(expected, actual);
}
public void SqrtN16()
{
var NegSixteen = NegativeOp.Create(Literal.Create(16));
var sqrt = NegSixteen.Sqrt();
var four = Literal.Create(4);
var sqrtOfNegOne = SqrtOp.Create(-1).Simplify();
var expected = four * sqrtOfNegOne;
Assert.AreEqual(sqrt, expected);
}
public void FractionRaiseToFraction()
{
var twentyFive = Literal.Create(25);
var thirtyTwo = Literal.Create(32);
var oneTenth = DivideOp.Create(1, 10);
var result = (thirtyTwo / twentyFive).Raise(oneTenth);
var actual = SqrtOp.Create(2) / PowerOp.Create(5, DivideOp.Create(1, 5));
Assert.AreEqual(result, actual);
}
public void EqualityTest()
{
const string input = "12 * 3";
var actual = MultiplyOp.Create(
Literal.Create(12),
Literal.Create(3)
).Simplify();
var expected = ExprParser.ParseOrThrow(input);
Assert.AreEqual(expected.Simplify(), actual);
}
public void SubtractBeforeMultTest()
{
const string input = "d-12 * 3";
var actual = SubtractOp.Create(
new Identifier("d"),
MultiplyOp.Create(Literal.Create(12), Literal.Create(3))
).Simplify();
var expected = ExprParser.ParseOrThrow(input).Simplify();
Assert.AreEqual(expected, actual);
}
public void Test3()
{
const string input = "-a/b^1+3-a/b^1";
var term1 = DivideOp.Create(NegativeOp.Create(new Identifier("a")), PowerOp.Create(new Identifier("b"), new One()));
var term2 = Literal.Create(3);
var term3 = DivideOp.Create(new Identifier("a"), PowerOp.Create(new Identifier("b"), new One()));
var actual = SubtractOp.Create(AddOp.Create(term1, term2), term3).Simplify();
var expected = ExprParser.ParseOrThrow(input);
Assert.AreEqual(expected.Simplify(), actual);
}
public void SubtractionTest()
{
const string input = "12 - 3";
var actual = SubtractOp.Create(
Literal.Create(12),
Literal.Create(3)
).Simplify();
var expected = ExprParser.ParseOrThrow(input);
Assert.AreEqual(expected.Simplify(), actual);
}
public void NegativeBeforeSubtractTest()
{
const string input = "-12 - 3";
var actual = SubtractOp.Create(
NegativeOp.Create(Literal.Create(12)),
Literal.Create(3)
).Simplify();
var expected = ExprParser.ParseOrThrow(input).Simplify();
Assert.AreEqual(expected, actual);
}
public static Expr Create(Expr left, Expr right) => (left, right) switch
{
(null, _) => new Zero(),
(_, null) => new Zero(),
(_, Zero z) => z,
(Zero z, _) => z,
(One _, _) => right,
(_, One _) => left,
(Literal l, Literal r) => Literal.Create(l.Value * r.Value),
(FractOp d1, FractOp d2) => DivideOp.Create(d1.Left * d2.Left, d1.Right * d2.Right),
_ => new MultiplyOp(left, right)
};
public void Test4()
{
const string input = "1-2/3+1-3+3*2";
var a = new One();
var b = DivideOp.Create(new Two(), Literal.Create(3));
var c = new One();
var d = Literal.Create(3);
var e = MultiplyOp.Create(Literal.Create(3), new Two());
var actual = AddOp.Create(SubtractOp.Create(AddOp.Create(SubtractOp.Create(a, b), c), d), e).Simplify();
var expected = ExprParser.ParseOrThrow(input);
Assert.AreEqual(expected.Simplify(), actual);
}
public void FunctionMethodNegateParamTest()
{
const string input = "foo(-3, x)()";
var actual =
Call.Create(
Call.Create(
new Identifier("foo"),
NegativeOp.Create(Literal.Create(3)),
new Identifier("x")
)).Simplify();
var expected = ExprParser.ParseOrThrow(input);
Assert.AreEqual(expected, actual);
}
public IEnumerable <object[]> GetData(MethodInfo methodInfo)
{
for (int j = 0; j < 100; j++)
{
var d = randomizer.Next(10, 50);
var tempArr = new Expr[d];
BigInteger total = 1;
for (int i = 0; i < d; i++)
{
var val = data[randomizer.Next(4)];
total = total * val;
tempArr[i] = Literal.Create(val);
}
var actual = tempArr.GroupBy((e) => e).Select((g) => g.Count() == 1 ? g.Key : PowerOp.Create(g.Key, g.Count()));
var expected = Literal.Create(total).Factor();
yield return(new object[] { total.ToString(), actual, expected });
}
}
public void Beta1Formula()
{
var actual = ExprParser.ParseOrThrow("0.85-(0.05/7)*(fᐠ_c-28)");
var expected = Dec.Create(0.85m) - (Dec.Create(0.05m) / Literal.Create(7)) * (new Identifier("fᐠ_c") - Literal.Create(28));
Assert.AreEqual(expected, actual);
Assert.AreEqual("0.85-((0.05/7)×(fᐠ_c-28))", actual.ToString());
var substiResult = actual.Substitute(new Identifier("fᐠ_c"), 32).Simplify();
Assert.AreEqual(substiResult, DivideOp.Create(23, 28));
if (substiResult.TryToDouble(out var val))
{
Assert.AreEqual(0.8214, val, 0.0001);
}
else
{
Assert.Fail($"{substiResult} is not a double");
}
}
public void SubtractThenMultTest()
{
var input = "(d-12) * 3";
var actual = MultiplyOp.Create(
SubtractOp.Create(new Identifier("d"), Literal.Create(12)),
Literal.Create(3)
).Simplify();
var expected = ExprParser.ParseOrThrow(input);
Assert.AreEqual(expected.ToString(), "3×(d-12)");
Assert.AreEqual(expected.Simplify(), actual);
input = "(d+12) * 3";
actual = MultiplyOp.Create(
AddOp.Create(new Identifier("d"), Literal.Create(12)),
Literal.Create(3)
).Simplify();
expected = ExprParser.ParseOrThrow(input).Simplify();
Assert.AreEqual(expected, actual);
}
public static Expr ToDecimal(string h, string d) => Literal.Create(h.ToBigInt()) + d.ToFraction();
public void SqrtOf4()
{
var sqrt4 = Literal.Create(4).Raise(DivideOp.Create(1, 2)).Simplify();
Assert.AreEqual(sqrt4, new Two());
}
public void QuantityTwoMinus_a_raisedToQuantity1Plus3Test()
{
const string input = "(2-a)^(1+3)";
var actual = PowerOp.Create(SubtractOp.Create(new Two(), new Identifier("a")), AddOp.Create(new One(), Literal.Create(3))).Simplify();
var expected = ExprParser.ParseOrThrow(input).Simplify();
Assert.AreEqual(expected, actual);
}
public void ParseSciNotWithParenTest2()
{
var f = ExprParser.ParseOrThrow("-(1.2340000)E(-14)");
Assert.AreEqual(f, (new NegativeOne() - (Literal.Create(234) / Literal.Create(1000))) * PowerOp.Create(10, -14));
}
public void SciNotSmallE()
{
var f = ExprParser.ParseOrThrow("-(1.2340000)e(-14)");
Assert.AreEqual(f, (new NegativeOne() - (Literal.Create(234) / Literal.Create(1000))) * PowerOp.Create(10, -14));
}
