[InlineData(-2)] // -2* public void NodWithWithSignH(int h) { FiniteDifference goodDifference = FiniteDifference.GetFiniteDifferenceByOrderAndMinH(0, h); string s = $"u(x{h:+0;-0}*h)"; Assert.True(FiniteDifference.Parse(s) == goodDifference); }
// check equality operator public void CheckEquality() { // create two equal FiniteDifference FiniteDifference l = FiniteDifference.GetFiniteDifferenceByOrder(2); FiniteDifference r = FiniteDifference.GetFiniteDifferenceByOrder(2); Assert.True(l == r); // REMOVED AS FiniteDifference indexer changed to read-only // ***************************************************************************************************** ////////// change coefficient ////////l[0] = 2; ////////Assert.False(l == r); ////////// revert coefficient ////////l[0] = 1; ////////Assert.True(l == r); ////////// create FiniteDifference with different order ////////r = FiniteDifference.GetFiniteDifferenceByOrder(3); ////////Assert.False(l == r); ////////// change right's coefficients to match left's ////////r[0] = 1; ////////r[1] = -2; ////////r[2] = 1; ////////Assert.False(l == r); // ***************************************************************************************************** // create FiniteDifference with the same order but another minimumH r = FiniteDifference.GetFiniteDifferenceByOrderAndMinH(2, 1); Assert.False(l == r); // create same FiniteDifference l = FiniteDifference.GetFiniteDifferenceByOrderAndMinH(2, 1); Assert.True(l == r); }
// order = 0 public void CheckCoefsOrder0() { int minh = new Random().Next(-10, 10); FiniteDifference dif = FiniteDifference.GetFiniteDifferenceByOrderAndMinH(0, minh); Assert.Equal(1, dif[minh]); }
// check order changing on summation public void CheckOrderChange() { // cut one order from right var sum = FiniteDifference.GetFiniteDifferenceByOrderAndMinH(3, 1) + FiniteDifference.GetFiniteDifferenceByOrderAndMinH(0, 1); Assert.Equal(2, sum.Order); // cut one order from left sum = FiniteDifference.GetFiniteDifferenceByOrderAndMinH(3, 1) - FiniteDifference.GetFiniteDifferenceByOrderAndMinH(0, 4); Assert.Equal(2, sum.Order); // cut two orders from right sum = FiniteDifference.GetFiniteDifferenceByOrderAndMinH(3, 1) - FiniteDifference.GetFiniteDifferenceByOrderAndMinH(2, 2) + FiniteDifference.GetFiniteDifferenceByOrderAndMinH(0, 3); Assert.Equal(1, sum.Order); // cut one from right and one from left sum = FiniteDifference.GetFiniteDifferenceByOrderAndMinH(3, 1) - FiniteDifference.GetFiniteDifferenceByOrderAndMinH(2, 2) + FiniteDifference.GetFiniteDifferenceByOrderAndMinH(0, 1); Assert.Equal(1, sum.Order); }
// check simple summation public void CheckSimpleSummation() { string s = "d3u(x-2*h) - du(x-h)"; Assert.True(FiniteDifference.GetFiniteDifferenceByOrderAndMinH(3, -2) - FiniteDifference.GetFiniteDifferenceByOrderAndMinH(1, -1) == DifferenceExpressionEvaluator.Evaluate(s)); }
// check multiplication public void CheckSingleDifferenceMultiplication() { string s = " -20.2 * d3u (x-2*h) "; Assert.True(-20.2 * FiniteDifference.GetFiniteDifferenceByOrderAndMinH(3, -2) == DifferenceExpressionEvaluator.Evaluate(s)); s = " 20,2d3u(x-2*h)"; Assert.True(20.2 * FiniteDifference.GetFiniteDifferenceByOrderAndMinH(3, -2) == DifferenceExpressionEvaluator.Evaluate(s)); }
// check returning null on creating bad order public void CheckBadOrderCreating() { Assert.Null(FiniteDifference.GetFiniteDifferenceByOrder(-1)); Assert.Null(0 * FiniteDifference.GetFiniteDifferenceByOrder(1)); // check summations Assert.Null(FiniteDifference.GetFiniteDifferenceByOrder(3) - FiniteDifference.GetFiniteDifferenceByOrder(3)); Assert.Null(FiniteDifference.GetFiniteDifferenceByOrderAndMinH(3, 2) - FiniteDifference.GetFiniteDifferenceByOrderAndMinH(2, 3) + FiniteDifference.GetFiniteDifferenceByOrderAndMinH(2, 2)); }
// create FiniteDifference with custom minimumH and random order public void SetMinH(int minH) { Random rnd = new Random(); int order = rnd.Next(10); FiniteDifference dif = FiniteDifference.GetFiniteDifferenceByOrderAndMinH(order, minH); Assert.Equal(minH, dif.MinimumH); Assert.Equal(order, dif.Order); Assert.Equal(minH + order, dif.MaximumH); }
// order = 5 public void CheckCoefsOrder5() { int minh = new Random().Next(-10, 10); FiniteDifference dif = FiniteDifference.GetFiniteDifferenceByOrderAndMinH(5, minh); Assert.Equal(-1, dif[minh]); Assert.Equal(5, dif[minh + 1]); Assert.Equal(-10, dif[minh + 2]); Assert.Equal(10, dif[minh + 3]); Assert.Equal(-5, dif[minh + 4]); Assert.Equal(1, dif[minh + 5]); }
// check format of FiniteDifference.ToString() public void CheckToString() { // check zero in the middle and signs and (x+h) FiniteDifference difference = FiniteDifference.GetFiniteDifferenceByOrderAndMinH(3, -2) - 3 * FiniteDifference.GetFiniteDifferenceByOrderAndMinH(0, -1); string goodString = "u(x+h)-3*u(x)-u(x-2*h)"; Assert.Equal(goodString, difference.ToString()); // check leading -, (x-h), (x+2*h) difference = -2 * FiniteDifference.GetFiniteDifferenceByOrderAndMinH(3, -1); goodString = "-2*u(x+2*h)+6*u(x+h)-6*u(x)+2*u(x-h)"; Assert.Equal(goodString, difference.ToString()); }
// check multiplication public void CheckMultiply(int order, int h) { // get first FiniteDifference var dif = FiniteDifference.GetFiniteDifferenceByOrderAndMinH(order, h); double k = 1.0 / new Random().Next(2, 5000); // et multiplied FiniteDifference var multiplied = k * dif; Assert.Equal(dif.MinimumH, multiplied.MinimumH); for (int i = 0; i <= order; i++) { Assert.Equal(k * dif[h + i], multiplied[h + i]); } }
// integration test of parsing to check correctness of all parts of parsing public void OrderAndArgChecks() { // check different orders with not null arg Assert.Equal(FiniteDifference.Parse(" d ^ 21 u ( x - 3h)"), FiniteDifference.GetFiniteDifferenceByOrderAndMinH(21, -3)); Assert.Equal(FiniteDifference.Parse(" d 21 u ( x - 3h)"), FiniteDifference.GetFiniteDifferenceByOrderAndMinH(21, -3)); Assert.Equal(FiniteDifference.Parse(" d u ( x - 3h)"), FiniteDifference.GetFiniteDifferenceByOrderAndMinH(1, -3)); Assert.Equal(FiniteDifference.Parse(" u ( x - 3h)"), FiniteDifference.GetFiniteDifferenceByOrderAndMinH(0, -3)); Assert.Equal(FiniteDifference.Parse(" d ^ -21 u ( x - 3h)"), null); Assert.Equal(FiniteDifference.Parse(" d -21 u ( x - 3h)"), null); // check different args with not null orders Assert.Equal(FiniteDifference.Parse(" d ^ 21 u ( x - h)"), FiniteDifference.GetFiniteDifferenceByOrderAndMinH(21, -1)); Assert.Equal(FiniteDifference.Parse(" d u ( x + h ) "), FiniteDifference.GetFiniteDifferenceByOrderAndMinH(1, 1)); Assert.Equal(FiniteDifference.Parse(" d ^ 21 u ( x + 24 h)"), FiniteDifference.GetFiniteDifferenceByOrderAndMinH(21, 24)); // check u absence error Assert.Throws <FormatException>(() => FiniteDifference.Parse("d2(x+2h)")); Assert.Throws <FormatException>(() => FiniteDifference.Parse("d(x+2h)")); Assert.Throws <FormatException>(() => FiniteDifference.Parse("(x+2h)")); Assert.Throws <FormatException>(() => FiniteDifference.Parse("(x)")); // check args errors with good nont null orders Assert.Throws <OverflowException>(() => FiniteDifference.Parse(" d^ 5u(x + 24243243242432 h)")); Assert.Throws <FormatException>(() => FiniteDifference.Parse("d2u(x 2h)")); Assert.Throws <FormatException>(() => FiniteDifference.Parse(" d 2u(x + 2 2h)")); Assert.Throws <FormatException>(() => FiniteDifference.Parse("d^ 11 u(x - - 2h)")); Assert.Throws <FormatException>(() => FiniteDifference.Parse("d 2u(xh)")); // check order errors with good nont null args Assert.Throws <OverflowException>(() => FiniteDifference.Parse(" d 513244u(x+23h)")); Assert.Throws <FormatException>(() => FiniteDifference.Parse("ddu(x -21h)")); Assert.Throws <FormatException>(() => FiniteDifference.Parse("2u(x+h)")); Assert.Throws <FormatException>(() => FiniteDifference.Parse("^1u(x-h)")); }
// check operator - (unary) public void CheckNegatiation() { // get random order and h int order = new Random().Next(10); int h = new Random().Next(-10, 10); // create FiniteDifference and its negatioaton FiniteDifference difference = FiniteDifference.GetFiniteDifferenceByOrderAndMinH(order, h); FiniteDifference negatioation = -difference; // check MinimumH and coefficients Assert.Equal(difference.MinimumH, negatioation.MinimumH); for (int i = 0; i <= order; i++) { Assert.Equal(difference[h + i], -(negatioation[h + i])); } }
// check summmation with crossing operands public void CrossingSummands() { // get two crossing FiniteDifferences FiniteDifference l = FiniteDifference.GetFiniteDifferenceByOrderAndMinH(3, -1); FiniteDifference r = FiniteDifference.GetFiniteDifferenceByOrderAndMinH(2, 1); // sum var sum = l + r; // check sum Assert.Equal(4, sum.Order); Assert.Equal(-1, sum[-1]); Assert.Equal(3, sum[0]); Assert.Equal(-3 + 1, sum[1]); Assert.Equal(1 - 2, sum[2]); Assert.Equal(1, sum[3]); }
// check summation of multiple summands with coefficients public void CheckSummation() { string s = " d3 u(x-2*h) - 2 * du(x-h) + u(x+2*h) - 1 * d^2 u(x) "; Assert.True(FiniteDifference.GetFiniteDifferenceByOrderAndMinH(3, -2) - 2 * FiniteDifference.GetFiniteDifferenceByOrderAndMinH(1, -1) + FiniteDifference.GetFiniteDifferenceByOrderAndMinH(0, 2) - FiniteDifference.GetFiniteDifferenceByOrder(2) == DifferenceExpressionEvaluator.Evaluate(s)); s = " - d^3u(x-2*h) - 2 * du(x-h) + u(x+2*h) - 1 * d^2 u(x) "; Assert.True(-FiniteDifference.GetFiniteDifferenceByOrderAndMinH(3, -2) - 2 * FiniteDifference.GetFiniteDifferenceByOrderAndMinH(1, -1) + FiniteDifference.GetFiniteDifferenceByOrderAndMinH(0, 2) - FiniteDifference.GetFiniteDifferenceByOrder(2) == DifferenceExpressionEvaluator.Evaluate(s)); }
// check for u(x-h), u(x+h), u(x-0*h) public void NodWithHNoNumber() { // -0 FiniteDifference goodDifference = FiniteDifference.GetFiniteDifferenceByOrderAndMinH(0, 0); string s = "u(x-0*h)"; Assert.True(FiniteDifference.Parse(s) == goodDifference); // -h goodDifference = FiniteDifference.GetFiniteDifferenceByOrderAndMinH(0, -1); s = "u(x-h)"; Assert.True(FiniteDifference.Parse(s) == goodDifference); // +h goodDifference = FiniteDifference.GetFiniteDifferenceByOrderAndMinH(0, 1); s = "u(x+h)"; Assert.True(FiniteDifference.Parse(s) == goodDifference); }
// check summmation without crossing operands public void NoCrossingNoSpaceSummand() { // get two non crossing FiniteDifferences without space FiniteDifference l = FiniteDifference.GetFiniteDifferenceByOrderAndMinH(1, -1); FiniteDifference r = FiniteDifference.GetFiniteDifferenceByOrderAndMinH(2, 1); // sum var sum = l + r; var sum2 = r + l; // check sum Assert.True(sum == sum2); Assert.Equal(4, sum.Order); Assert.Equal(-1, sum[-1]); Assert.Equal(1, sum[0]); Assert.Equal(1, sum[1]); Assert.Equal(-2, sum[2]); Assert.Equal(1, sum[3]); }
// check summmation with crossing operands public void WithSpacingSummands() { // get two FiniteDifferences with space between them FiniteDifference l = FiniteDifference.GetFiniteDifferenceByOrderAndMinH(3, -4); FiniteDifference r = FiniteDifference.GetFiniteDifferenceByOrderAndMinH(2, 1); // sum var sum = l + r; // check sum Assert.Equal(7, sum.Order); Assert.Equal(-1, sum[-4]); Assert.Equal(3, sum[-3]); Assert.Equal(-3, sum[-2]); Assert.Equal(1, sum[-1]); Assert.Equal(0, sum[0]); Assert.Equal(1, sum[1]); Assert.Equal(-2, sum[2]); Assert.Equal(1, sum[3]); }
// test simple FiniteDifference parsing public void CheckSingleDifference() { string s = "d3u(x-h)"; Assert.True(FiniteDifference.GetFiniteDifferenceByOrderAndMinH(3, -1) == DifferenceExpressionEvaluator.Evaluate(s)); }