31.1 Test SparseAdditiveArray
734a⟨test zero 734a⟩≡ (733 749) 734b ⊳
testZero1(): () == {
x: X := 0;
assertTrue(zero? x);
}
734b⟨test zero 734a⟩+
≡ (733 749) ⊲734a 734c ⊳
testZero2(): () == {
x: X := [0, 1];
assertEquals(X, 0, x);
assertTrue(zero? x);
}
734c⟨test zero 734a⟩+
≡ (733 749) ⊲734b 750a ⊳
testZero3(): () == {
x: X := [ 1, 1];
y: X := [-1, 1];
assertTrue(zero?(x + y));
assertTrue(zero?(x - x));
}
735a⟨test compare 735a⟩≡ (733 743) 735b ⊳
testCompare1(): () == {
x: X := [3, 3];
y: X := [7, 1];
z: X := [1, 1];
assertTrue(x > y); assertTrue(compare(x, y) > 0);
assertTrue(x > z); assertTrue(compare(x, z) > 0);
assertTrue(y > z); assertTrue(compare(y, z) > 0);
assertTrue(0 < x); assertTrue(compare(0, x) < 0);
assertTrue(x < x+y); assertTrue(compare(x , x+y) < 0);
assertTrue(x+z < x+y); assertTrue(compare(x+z, x+y) < 0);
assertTrue(x+z = x+z); assertTrue(zero? compare(x+z, x+z));
}
735b⟨test compare 735a⟩+
≡ (733 743) ⊲735a 736a ⊳
testCompare2(): () == {
x: X := [1, 9];
y: X := [3, 3];
z: X := [9, 1];
assertTrue(x > y); assertTrue(compare(x, y) > 0);
assertTrue(x > z); assertTrue(compare(x, z) > 0);
assertTrue(y > z); assertTrue(compare(y, z) > 0);
assertTrue(0 < x); assertTrue(compare(0, x) < 0);
assertTrue(x < x+y); assertTrue(compare(x , x+y) < 0);
assertTrue(x+z < x+y); assertTrue(compare(x+z, x+y) < 0);
assertTrue(x+z = x+z); assertTrue(zero? compare(x+z, x+z));
}
736a⟨test compare 735a⟩+
≡ (733 743) ⊲735b 746a ⊳
testCompare3(): () == {
V ==> CycleIndexVariable;
T ==> SparseAdditiveArray(Z, V);
import from V, T;
x: T := [1, 9 :: V];
y: T := [3, 3 :: V];
z: T := [9, 1 :: V];
assertTrue(x < y); assertTrue(compare(x, y) < 0);
assertTrue(x < z); assertTrue(compare(x, z) < 0);
assertTrue(y < z); assertTrue(compare(y, z) < 0);
assertTrue(0 < x); assertTrue(compare(0, x) < 0);
assertTrue(x < x+y); assertTrue(compare(x , x+y) < 0);
assertTrue(y < x+y); assertTrue(compare(x , x+y) < 0);
assertTrue(z < z+y); assertTrue(compare(x , x+y) < 0);
assertTrue(x+z > x+y); assertTrue(compare(x+z, x+y) > 0);
assertTrue(x+z = x+z); assertTrue(zero? compare(x+z, x+z));
}
Uses CycleIndexVariable 329, SparseAdditiveArray 489, and Z 47.
736b⟨test construct/decompose 736b⟩≡ (733) 737a ⊳
testLeadingMonomial1(): () == {
x: X := [1, 2];
(a, j) := leadingMonomial x;
assertEquals(Z, a, 1);
assertEquals(I, j, 2);
assertTrue(zero? reductum x);
assertEquals(Z, 1, leadingCoefficient x);
assertEquals(I, 2, maxSupport x);
assertEquals(Z, 0, x.1);
assertEquals(Z, 1, x.2);
assertEquals(Z, 0, x.3);
}
Uses I 47 and Z 47.
737a⟨test construct/decompose 736b⟩+
≡ (733) ⊲736b 737b ⊳
testLeadingMonomial2(): () == {
x: X := [1, 2];
x := x + x;
(a, j) := leadingMonomial x;
assertEquals(Z, a, 2);
assertEquals(I, j, 2);
assertTrue(zero? reductum x);
}
Uses I 47 and Z 47.
737b⟨test construct/decompose 736b⟩+
≡ (733) ⊲737a 738a ⊳
testLeadingMonomial3(): () == {
x: X := [1, 2];
y: X := [3, 1];
z := x + y;
(a, j) := leadingMonomial z;
assertEquals(Z, 1, a);
assertEquals(I, 2, j);
assertEquals(I, 2, maxSupport z);
assertEquals(Z, 1, leadingCoefficient z);
assertEquals(Z, 0, z.0);
assertEquals(Z, 3, z.1);
assertEquals(Z, 1, z.2);
assertEquals(Z, 0, z.3);
assertEquals(I, 2, #z);
z := reductum z;
assertFalse(zero? z);
(a, j) := leadingMonomial z;
assertEquals(Z, 3, a);
assertEquals(I, 1, j);
assertTrue(zero? reductum z);
}
Uses I 47 and Z 47.
738a⟨test construct/decompose 736b⟩+
≡ (733) ⊲737b 738b ⊳
testGenerator(): () == {
x: X := [3,4]+[7,5]+[1,1];
lz: List Z := [7,3,1];
li: List I := [5,4,1];
n: I := 0;
for mx in x for z in lz for i in li repeat {
n := n + 1;
(a, j) := mx;
assertEquals(Z, z, a);
assertEquals(I, i, j);
}
assertEquals(I, 3, n);
assertEquals(I, 3, #x);
assertEquals(Z, 0, x.0);
assertEquals(Z, 1, x.1);
assertEquals(Z, 0, x.2);
assertEquals(Z, 0, x.3);
assertEquals(Z, 3, x.4);
assertEquals(Z, 7, x.5);
assertEquals(Z, 0, x.6);
}
Uses I 47 and Z 47.
738b⟨test construct/decompose 736b⟩+
≡ (733) ⊲738a 739 ⊳
testPlus1(): () == {
x: X := [3, 3];
y: X := [1, 1];
z := x + y;
assertEquals(X, z, y+x);
t := z + [7, 2];
assertEquals(X, [3,3]+[7,2]+[1,1], t);
t := t + z;
assertEquals(X, [6,3]+[7,2]+[2,1], t);
t := t + [-7, 2];
assertEquals(X, [6,3]+[2,1], t);
}
In the following test Y is an additive combination of strings whose coefficients
could be seen as univariate polynomials.
739⟨test construct/decompose 736b⟩+
≡ (733) ⊲738b 740 ⊳
testPlus2(): () == {
macro Y == SparseAdditiveArray(X, String);
import from Y, String, List String, List X;
local assertY(lx: List X, ls: List String): Y == {
y: Y := 0;
assertEquals(I, #lx, #ls);
for x in lx for s in ls repeat y := y + [x, s];
n: I := 0;
for x in lx for s in ls for my in y repeat {
n := n + 1;
(a, j) := my;
assertEquals(String, s, j);
assertEquals(X, x, a);
}
assertEquals(I, #lx, n);
y;
}
x1: X := [3,3] + [7,2] + [1,1];
x2: X := [1,4] + [3,8] + [-1, 1] + [2,2];
x3 := x1 + x2;
assertEquals(X, [3,8]+[1,4]+[3,3]+[9,2], x3);
y1: Y := assertY([x1,x2],["Ralf", "Hemmecke"]);
y2: Y := assertY([x3,x2],["Ralf", "Martin"]);
y3: Y := assertY([x1+x3,x2,x2],["Ralf","Martin","Hemmecke"]);
assertEquals(Y, y3, y1+y2);
assertEquals(X, x1+x3, y3."Ralf");
assertEquals(X, x2, y3."Martin");
assertEquals(X, 0, y3."Rubey");
}
Uses I 47, SparseAdditiveArray 489, and String 65.
In the following test Y is an additive combination of univariate polynomials
whose coefficients are Integers. The domain Y can also be seen as a polynomial
domain with infinitely many variables and integer coefficients.
740⟨test construct/decompose 736b⟩+
≡ (733) ⊲739 741a ⊳
testPlus3(): () == {
macro Y == SparseAdditiveArray(Integer, X);
import from Y, String, List Z, List X;
local assertY(lz: List Z, lx: List X): Y == {
y: Y := 0;
assertEquals(I, #lz, #lx);
for z in lz for x in lx repeat y := y + [z, x];
n: I := 0;
for z in lz for x in lx for my in y repeat {
n := n + 1;
(a, j) := my;
assertEquals(Z, z, a);
assertEquals(X, x, j);
}
assertEquals(I, #lx, n);
y;
}
x1: X := [3,3] + [7,2] + [1,1];
x2: X := [1,4] + [3,8] + [-1, 1] + [2,2];
x3 := x1 + x2;
assertEquals(X, [3,8]+[1,4]+[3,3]+[9,2], x3);
assertTrue(x1 < x2);
assertTrue(x2 < x3);
y1: Y := assertY([2,1],[x2,x1]);
y2: Y := assertY([5,7],[x3,x2]);
y3: Y := assertY([5,9,1],[x3,x2,x1]);
assertEquals(Y, y3, y1+y2);
}
Uses I 47, Integer 66, SparseAdditiveArray 489, String 65, and Z 47.
741a⟨test construct/decompose 736b⟩+
≡ (733) ⊲740 741b ⊳
testPlus4(): () == {
x: X := [3, 3];
y: X := [1, 1];
z := x - y;
assertEquals(X, z, -(y-x));
t := z - [7, 2];
assertEquals(X, [3,3]-[7,2]+[-1,1], t);
t := t + z;
assertEquals(X, [6,3]+[-7,2]+[-2,1], t);
t := t - [-7, 2];
assertEquals(X, [6,3]-[2,1], t);
}
741b⟨test construct/decompose 736b⟩+
≡ (733) ⊲741a
testPlus5(): () == {
x: X := [3, 3];
y: X := [1, 1];
assertEquals(X, -[3,-2]-[4,1], [-3,-2]+[-4,1]);
assertEquals(X, y-x, y+(-x));
}