423 lines
7.5 KiB
C++
423 lines
7.5 KiB
C++
|
|
#include <knotkit.h>
|
|
|
|
void
|
|
test_vector ()
|
|
{
|
|
basedvector<int, 1> v;
|
|
assert (v.size () == 0);
|
|
assert (v.capacity () == 0);
|
|
|
|
v.append (69);
|
|
assert (v.size () == 1);
|
|
assert (v[1] == 69);
|
|
|
|
v.append (8);
|
|
v.append (13);
|
|
assert (v.pop () == 13);
|
|
assert (v.pop () == 8);
|
|
v.append (14);
|
|
v.append (17);
|
|
v.append (36);
|
|
v.append (101);
|
|
assert (v.size () == 5);
|
|
assert (v.pop () == 101);
|
|
assert (v.pop () == 36);
|
|
assert (v.pop () == 17);
|
|
assert (v.pop () == 14);
|
|
assert (v.pop () == 69);
|
|
assert (v.size () == 0);
|
|
|
|
v = basedvector<int, 1> ();
|
|
assert (v.size () == 0);
|
|
assert (v.capacity () == 0);
|
|
|
|
v.append (69);
|
|
v.append (14);
|
|
v.append (17);
|
|
v.append (36);
|
|
v.append (101);
|
|
assert (v.size () == 5);
|
|
|
|
v.resize (10);
|
|
assert (v.size () == 10);
|
|
assert (v.capacity () >= v.size ());
|
|
|
|
assert (v[1] == 69);
|
|
assert (v[2] == 14);
|
|
assert (v[3] == 17);
|
|
assert (v[4] == 36);
|
|
assert (v[5] == 101);
|
|
|
|
v[1] = 52;
|
|
v[2] = 666;
|
|
v[3] = 55559;
|
|
v[4] = 1721;
|
|
v[5] = -24;
|
|
v[6] = 8893;
|
|
v[7] = 42;
|
|
v[8] = 173;
|
|
v[9] = 115;
|
|
v[10] = 382;
|
|
|
|
/* shared */
|
|
basedvector<int, 1> v2 (v);
|
|
assert (v2.size () == 10);
|
|
for (int i = 1; i <= 10; i ++)
|
|
assert (v2[i] == v[i]);
|
|
|
|
assert (v2[8] == 173);
|
|
v[8] = 174;
|
|
assert (v2[8] == 174);
|
|
|
|
basedvector<int, 1> u (COPY, v);
|
|
assert (u.size () == 10);
|
|
for (int i = 1; i <= 10; i ++)
|
|
assert (u[i] == v[i]);
|
|
|
|
int x[6] = { 7, 4, 2, 3, 9, 1 };
|
|
basedvector<int, 1> w (4, x);
|
|
assert (w.size () == 4);
|
|
for (int i = 0; i < 4; i ++)
|
|
assert (w[i + 1] == x[i]);
|
|
|
|
basedvector<int, 1> y (6, v);
|
|
assert (y.size () == 6);
|
|
for (int i = 1; i <= 6; i ++)
|
|
assert (y[i] == v[i]);
|
|
|
|
y = w;
|
|
assert (y.size () == 4);
|
|
for (int i = 1; i <= 4; i ++)
|
|
assert (y[i] == w[i]);
|
|
}
|
|
|
|
void
|
|
test_bitset ()
|
|
{
|
|
bitset s;
|
|
assert (s.size () == 0);
|
|
assert (s.card () == 0);
|
|
|
|
bitset t (100);
|
|
assert (t.size () == 100);
|
|
assert (t.card () == 0);
|
|
t.push (52);
|
|
t.push (1);
|
|
t.push (31);
|
|
t.push (32);
|
|
t.push (100);
|
|
t.push (63);
|
|
t.push (7);
|
|
|
|
int c = 0;
|
|
for (bitset_const_iter i = t; i; i ++)
|
|
{
|
|
assert (t(i.val ()));
|
|
c ++;
|
|
}
|
|
assert (c == 7);
|
|
|
|
assert (t.card () == 7);
|
|
|
|
assert (t(52));
|
|
assert (t(1));
|
|
assert (t(31));
|
|
assert (t(32));
|
|
assert (t(100));
|
|
assert (t(63));
|
|
assert (t(7));
|
|
|
|
assert (!t(2));
|
|
assert (!t(15));
|
|
assert (!t(47));
|
|
assert (!t(99));
|
|
|
|
t -= 52;
|
|
t -= 63;
|
|
t -= 7;
|
|
t += 100;
|
|
t += 82;
|
|
t -= 47;
|
|
assert (t.card () == 5);
|
|
assert (!t(52));
|
|
assert (!t(63));
|
|
assert (!t(7));
|
|
assert (!t(47));
|
|
assert (t(100));
|
|
assert (t(82));
|
|
|
|
bitset u (t);
|
|
assert (u.size () == 100);
|
|
assert (u.card () == 5);
|
|
}
|
|
|
|
template<class unsignedset1> void
|
|
test_unsignedset1 ()
|
|
{
|
|
unsignedset1 s (94);
|
|
assert (s.card () == 0);
|
|
|
|
unsignedset1 t (300);
|
|
assert (t.card () == 0);
|
|
t.push (52);
|
|
t.push (1);
|
|
t.push (31);
|
|
t.push (32);
|
|
t.push (33);
|
|
t.push (63);
|
|
t.push (64);
|
|
t.push (65);
|
|
t.push (300);
|
|
t.push (299);
|
|
t.push (243);
|
|
t.push (172);
|
|
t.push (122);
|
|
t.push (70);
|
|
|
|
int c = 0;
|
|
for (typename unsignedset1::const_iter i = t; i; i ++)
|
|
{
|
|
assert (t(i.val ()));
|
|
c ++;
|
|
}
|
|
assert (c == 14);
|
|
|
|
assert (t.card () == 14);
|
|
|
|
assert (t(52));
|
|
assert (t(1));
|
|
assert (t(31));
|
|
assert (t(32));
|
|
assert (t(33));
|
|
assert (t(63));
|
|
assert (t(64));
|
|
assert (t(65));
|
|
assert (t(300));
|
|
assert (t(299));
|
|
assert (t(243));
|
|
assert (t(172));
|
|
assert (t(122));
|
|
assert (t(70));
|
|
|
|
assert (!t(2));
|
|
assert (!t(15));
|
|
assert (!t(47));
|
|
assert (!t(99));
|
|
assert (!t(127));
|
|
assert (!t(128));
|
|
assert (!t(129));
|
|
|
|
t -= 52;
|
|
t -= 63;
|
|
t -= 64;
|
|
t -= 65;
|
|
t -= 7;
|
|
t += 100;
|
|
t += 82;
|
|
t -= 47;
|
|
assert (t.card () == 12);
|
|
assert (!t(52));
|
|
assert (!t(63));
|
|
assert (!t(64));
|
|
assert (!t(65));
|
|
assert (!t(7));
|
|
assert (!t(47));
|
|
assert (t(100));
|
|
assert (t(82));
|
|
|
|
unsignedset1 u (COPY, t);
|
|
assert (u.card () == 12);
|
|
}
|
|
|
|
void
|
|
test_map ()
|
|
{
|
|
map<int, int> m;
|
|
assert (m.card () == 0);
|
|
m.push (1, 7);
|
|
m.set (2, 9);
|
|
m[3] = 14;
|
|
m[4] = 23;
|
|
assert (m.card () == 4);
|
|
|
|
assert (m % 1);
|
|
assert (m % 2);
|
|
assert (m % 3);
|
|
assert (m % 4);
|
|
assert (! (m % 5));
|
|
|
|
assert (m(1) == 7);
|
|
assert (m(2) == 9);
|
|
assert (m(3) == 14);
|
|
assert (m(4) == 23);
|
|
|
|
m[2] = 17;
|
|
assert (m(2) == 17);
|
|
|
|
int c = 0;
|
|
for (map<int, int>::iter i = m; i; i ++)
|
|
{
|
|
int k = i.key ();
|
|
assert (k >= 1);
|
|
assert (k <= 4);
|
|
switch (k)
|
|
{
|
|
case 1: assert (i.val () == 7); break;
|
|
case 2: assert (i.val () == 17); break;
|
|
case 3: assert (i.val () == 14); break;
|
|
case 4: assert (i.val () == 23); break;
|
|
default: abort ();
|
|
}
|
|
c ++;
|
|
}
|
|
assert (c == 4);
|
|
|
|
map<int, int> n (COPY, m);
|
|
assert (n.card () == 4);
|
|
m[2] = 111;
|
|
assert (n(2) == 17);
|
|
}
|
|
|
|
void
|
|
test_polynomial ()
|
|
{
|
|
vector<int> coeffs (3);
|
|
coeffs[0] = 7;
|
|
coeffs[1] = 0;
|
|
coeffs[2] = 2;
|
|
polynomial<int> p (coeffs);
|
|
p.show_self ();
|
|
printf ("\n");
|
|
|
|
polynomial<int> q (coeffs);
|
|
q += p;
|
|
show (q);
|
|
printf ("\n");
|
|
|
|
q *= p;
|
|
show (q);
|
|
printf ("\n");
|
|
}
|
|
|
|
void
|
|
test_laurentpoly ()
|
|
{
|
|
vector<int> c (3);
|
|
c[0] = 1;
|
|
c[1] = 0;
|
|
c[2] = 1;
|
|
laurentpoly<int> p (-1, c);
|
|
|
|
show (p);
|
|
printf ("\n");
|
|
|
|
p *= p;
|
|
show (p);
|
|
printf ("\n");
|
|
}
|
|
|
|
#if 0
|
|
void
|
|
test_vs ()
|
|
{
|
|
grading gr;
|
|
gr.h = -1;
|
|
gr.q = 1;
|
|
|
|
basedvector<grading, 1> g5_gr (5);
|
|
g5_gr[1] = g5_gr[2] = g5_gr[3] = g5_gr[4] = g5_gr[5] = gr;
|
|
|
|
basedvector<ptr<vsgenerator>, 1> gs5;
|
|
gs5.append (new euclideangenerator (1));
|
|
gs5.append (new euclideangenerator (2));
|
|
gs5.append (new euclideangenerator (3));
|
|
gs5.append (new euclideangenerator (4));
|
|
gs5.append (new euclideangenerator (5));
|
|
ptr<const vectorspace<F2> > e5 = new vectorspace<F2> (gs5, g5_gr);
|
|
printf ("e5: ");
|
|
e5->show_self ();
|
|
printf ("\n");
|
|
|
|
vselt<F2> x1 = e5->singleton (1);
|
|
x1 += e5->singleton (3);
|
|
|
|
vselt<F2> x2 = e5->singleton (2);
|
|
x2 += e5->singleton (3);
|
|
x2 += e5->singleton (5);
|
|
|
|
vselt<F2> x3 = e5->singleton (4);
|
|
x3 += e5->singleton (5);
|
|
|
|
vselt<F2> x4 = e5->singleton (1);
|
|
x4 += e5->singleton (2);
|
|
x4 += e5->singleton (5);
|
|
|
|
basedvector<vselt<F2>, 1> xs (4);
|
|
xs[1] = x1;
|
|
xs[2] = x2;
|
|
xs[3] = x3;
|
|
xs[4] = x4;
|
|
|
|
ptr<const vectorspace<F2> > vs3 = e5->subspace (xs);
|
|
assert (vs3->dim () == 3);
|
|
printf ("vs3: ");
|
|
vs3->show_self ();
|
|
printf ("\n");
|
|
|
|
basedvector<grading, 1> g2_gr (2);
|
|
g2_gr[1] = g2_gr[2] = gr;
|
|
|
|
basedvector<ptr<vsgenerator>, 1> gs2;
|
|
gs2.append (new euclideangenerator (1));
|
|
gs2.append (new euclideangenerator (2));
|
|
ptr<const vectorspace<F2> > e2 = new vectorspace<F2> (gs2, g2_gr);
|
|
|
|
basedvector<grading, 1> g3_gr (3);
|
|
g3_gr[1] = g3_gr[2] = g3_gr[3] = gr;
|
|
|
|
basedvector<ptr<vsgenerator>, 1> gs3;
|
|
gs3.append (new euclideangenerator (1));
|
|
gs3.append (new euclideangenerator (2));
|
|
gs3.append (new euclideangenerator (3));
|
|
ptr<const vectorspace<F2> > e3 = new vectorspace<F2> (gs3, g3_gr);
|
|
|
|
basedvector<vselt<F2>, 1> cols (3);
|
|
cols[1] = e2->singleton (1);
|
|
cols[2] = e2->singleton (2);
|
|
vselt<F2> x5 = e2->singleton (1);
|
|
x5 += e2->singleton (2);
|
|
cols[3] = x5;
|
|
vsmap<F2> m (e3, e2, cols);
|
|
|
|
ptr<const vectorspace<F2> > mker = m.kernel ();
|
|
printf ("mker: ");
|
|
mker->show_self ();
|
|
printf ("\n");
|
|
}
|
|
#endif
|
|
|
|
void
|
|
test_fields ()
|
|
{
|
|
Q a (2, 1);
|
|
Q b (-2, 1);
|
|
a /= b;
|
|
assert (a == -1);
|
|
}
|
|
|
|
int
|
|
main ()
|
|
{
|
|
test_vector ();
|
|
test_bitset ();
|
|
test_unsignedset1<unsignedset> ();
|
|
test_unsignedset1<bitset> ();
|
|
test_unsignedset1<ullmanset<1> > ();
|
|
test_map ();
|
|
test_polynomial ();
|
|
test_laurentpoly ();
|
|
// test_vs ();
|
|
test_fields ();
|
|
}
|