// 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 parsing simple du
public void Order1CheckWithoutH()
{
FiniteDifference goodDifference = FiniteDifference.GetFiniteDifferenceByOrder(1);
string s = "du(x)";
Assert.True(FiniteDifference.Parse(s) == goodDifference);
}
[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 simple u(x)
public void NodNoH()
{
FiniteDifference goodDifference = FiniteDifference.GetFiniteDifferenceByOrder(0);
string s = "u(x)";
Assert.True(FiniteDifference.Parse(s) == goodDifference);
}
// 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));
}
// just create FiniteDifference with minimumH=0 and check order, minimumH and maximumH
public void CheckOrderAfterCreating(int order)
{
FiniteDifference dif = FiniteDifference.GetFiniteDifferenceByOrder(order);
Assert.Equal(order, dif.Order);
Assert.Equal(0, dif.MinimumH);
Assert.Equal(order, dif.MaximumH);
}
// 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);
}
// check parsing d^nu and dnu
public void OrderCheckWithoutH(int order)
{
FiniteDifference goodDifference = FiniteDifference.GetFiniteDifferenceByOrder(order);
// check d^nu
string s = $"d^{order}u(x)";
Assert.True(FiniteDifference.Parse(s) == goodDifference);
// check dnu
s = $"d{order}u(x)";
Assert.True(FiniteDifference.Parse(s) == goodDifference);
}
// 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 error in argument
public void ArgsErrors()
{
Assert.Throws <OverflowException>(() => FiniteDifference.Parse("u(x+242342342343*h)"));
Assert.Throws <FormatException>(() => FiniteDifference.Parse("u"));
Assert.Throws <FormatException>(() => FiniteDifference.Parse("u(x+h"));
Assert.Throws <FormatException>(() => FiniteDifference.Parse("ux( h)"));
Assert.Throws <FormatException>(() => FiniteDifference.Parse("u( h)"));
Assert.Throws <FormatException>(() => FiniteDifference.Parse("u(x h)"));
Assert.Throws <FormatException>(() => FiniteDifference.Parse("u(x+*h"));
Assert.Throws <FormatException>(() => FiniteDifference.Parse("u(x -432fe3 h)"));
Assert.Throws <FormatException>(() => FiniteDifference.Parse("u(x -43 3 h)"));
Assert.NotNull(FiniteDifference.Parse("u ( x -4323 * h ) "));
}
// 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]);
}
}
// check if order parsing throws exceptions on errors
public void OrderErrors()
{
Assert.Throws <OverflowException>(() => FiniteDifference.Parse("d^43245u(x)"));
Assert.Throws <FormatException>(() => FiniteDifference.Parse("du"));
Assert.Throws <FormatException>(() => FiniteDifference.Parse("ddu(x)"));
Assert.Throws <FormatException>(() => FiniteDifference.Parse(" d^u(x)"));
Assert.Throws <FormatException>(() => FiniteDifference.Parse("d^^2u(x)"));
Assert.Throws <FormatException>(() => FiniteDifference.Parse(" d^ 2 2u(x)"));
Assert.Throws <FormatException>(() => FiniteDifference.Parse(" d^ - 2u(x)"));
Assert.Throws <FormatException>(() => FiniteDifference.Parse("ud(x"));
Assert.Throws <FormatException>(() => FiniteDifference.Parse("^d2u(x)"));
Assert.Null(FiniteDifference.Parse(" d ^ -2 u ( x -4323 * h ) "));
Assert.NotNull(FiniteDifference.Parse(" d 32 u ( x -4323 * h ) "));
}
// 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]));
}
}
public void CheckOperationsWithNotFiniteDifference()
{
// create normal FiniteDifference and two non-FiniteDifferences
FiniteDifference order11 = FiniteDifference.GetFiniteDifferenceByOrder(1);
FiniteDifference not1 = FiniteDifference.GetFiniteDifferenceByOrder(-1);
FiniteDifference not2 = FiniteDifference.GetFiniteDifferenceByOrder(-1);
// check equality
Assert.True(order11 != not1);
Assert.True(not1 == not2);
// check multiplication
Assert.Null(not1 * 2);
// check summation
Assert.True(order11 == order11 + not1);
Assert.Null(not1 + not2);
}
// 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));
}
