readme
This commit is contained in:
Raffaele
@@ -0,0 +1,19 @@
|
||||
## Description
|
||||
Here is developed the testing unit for all the lina functions that need numerical testing.
|
||||
|
||||
## Usage
|
||||
For each function in the lina library named in the form of 'lina_something()', here is defined a folder named 'something'. In each folder there are many tests, each one identified by a ti.txt file, for i=1,...,n.
|
||||
Each test file is defined as follows: The first matrix/matrices are the inputs of the function (depending on the function, for example: lina_add() has two inputs A,B and one output C=A+B. A and B have to be the first two matrices in the test file), the last matrix/matrices are the output of the function and after there are input scalar values (ordered in the same order of the function under test) of the function represented as a 1x1 matrix.
|
||||
For example, a scale test file, that is a test for the lina_scale() function is defined as follows:
|
||||
|
||||
[1 1 1,
|
||||
1 1 1, <-- Input matrix
|
||||
1 1 1]
|
||||
|
||||
[2 2 2,
|
||||
2 2 2, <-- Output matrix
|
||||
2 2 2]
|
||||
|
||||
[2] <-- Input scalar value
|
||||
|
||||
By default, launching test will generate all the testing and provide on the stdout the results.
|
||||
+7
-293
@@ -9,306 +9,20 @@
|
||||
//Print the matrix A with size m by n
|
||||
static void pmatrix(FILE *fp, double *A, int m, int n);
|
||||
|
||||
struct {
|
||||
double A[9], // Left argument
|
||||
B[9], // Right argument
|
||||
C[9]; // Expected result
|
||||
} dot_tests[] = {
|
||||
{
|
||||
.A = {
|
||||
1, 0, 0,
|
||||
0, 1, 0,
|
||||
0, 0, 1,
|
||||
},
|
||||
.B = {
|
||||
1, 0, 0,
|
||||
0, 1, 0,
|
||||
0, 0, 1,
|
||||
},
|
||||
.C = {
|
||||
1, 0, 0,
|
||||
0, 1, 0,
|
||||
0, 0, 1,
|
||||
},
|
||||
},
|
||||
struct dot_test{
|
||||
|
||||
double *A;
|
||||
double *B;
|
||||
double *C;
|
||||
|
||||
};
|
||||
|
||||
struct {
|
||||
double A[9], // Input
|
||||
B[9], // Expected output
|
||||
factor; // Scale factor
|
||||
} scale_tests[] = {
|
||||
{
|
||||
.A = {
|
||||
1, 1, 1,
|
||||
1, 1, 1,
|
||||
1, 1, 1,
|
||||
},
|
||||
.B = {
|
||||
2, 2, 2,
|
||||
2, 2, 2,
|
||||
2, 2, 2,
|
||||
},
|
||||
.factor = 2,
|
||||
},
|
||||
};
|
||||
|
||||
struct {
|
||||
double *A, *B;
|
||||
int m, n;
|
||||
} transp_tests[] = {
|
||||
{
|
||||
.A = (double[]) {
|
||||
1, 0, 0, 0,
|
||||
0, 2, 0, 0,
|
||||
0, 0, 3, 0,
|
||||
0, 0, 0, 4,
|
||||
},
|
||||
.B = (double[]) {
|
||||
1, 0, 0, 0,
|
||||
0, 2, 0, 0,
|
||||
0, 0, 3, 0,
|
||||
0, 0, 0, 4,
|
||||
},
|
||||
.m = 4,
|
||||
.n = 4,
|
||||
},
|
||||
{
|
||||
.A = (double[]) {
|
||||
1, 2, 3, 4,
|
||||
0, 0, 0, 0,
|
||||
0, 0, 0, 0,
|
||||
0, 0, 0, 0,
|
||||
},
|
||||
.B = (double[]) {
|
||||
1, 0, 0, 0,
|
||||
2, 0, 0, 0,
|
||||
3, 0, 0, 0,
|
||||
4, 0, 0, 0,
|
||||
},
|
||||
.m = 4,
|
||||
.n = 4,
|
||||
},
|
||||
{
|
||||
.A = (double[]) {
|
||||
0, 1, 0, 0,
|
||||
0, 2, 0, 0,
|
||||
0, 3, 0, 0,
|
||||
0, 4, 0, 0,
|
||||
},
|
||||
.B = (double[]) {
|
||||
0, 0, 0, 0,
|
||||
1, 2, 3, 4,
|
||||
0, 0, 0, 0,
|
||||
0, 0, 0, 0,
|
||||
},
|
||||
.m = 4,
|
||||
.n = 4,
|
||||
},
|
||||
{
|
||||
.A = (double[]) {
|
||||
0, 0, 1, 0,
|
||||
0, 0, 2, 0,
|
||||
0, 0, 3, 0,
|
||||
0, 0, 4, 0,
|
||||
},
|
||||
.B = (double[]) {
|
||||
0, 0, 0, 0,
|
||||
0, 0, 0, 0,
|
||||
1, 2, 3, 4,
|
||||
0, 0, 0, 0,
|
||||
},
|
||||
.m = 4,
|
||||
.n = 4,
|
||||
},
|
||||
{
|
||||
.A = (double[]) {
|
||||
0, 0, 0, 1,
|
||||
0, 0, 0, 2,
|
||||
0, 0, 0, 3,
|
||||
0, 0, 0, 4,
|
||||
},
|
||||
.B = (double[]) {
|
||||
0, 0, 0, 0,
|
||||
0, 0, 0, 0,
|
||||
0, 0, 0, 0,
|
||||
1, 2, 3, 4,
|
||||
},
|
||||
.m = 4,
|
||||
.n = 4,
|
||||
},
|
||||
{
|
||||
.A = (double[]) {
|
||||
1, 0, 0,
|
||||
0, 2, 0,
|
||||
0, 0, 3,
|
||||
},
|
||||
.B = (double[]) {
|
||||
1, 0, 0,
|
||||
0, 2, 0,
|
||||
0, 0, 3,
|
||||
},
|
||||
.m = 3,
|
||||
.n = 3,
|
||||
},
|
||||
{
|
||||
.A = (double[]) {
|
||||
1, 2, 3,
|
||||
0, 0, 0,
|
||||
0, 0, 0,
|
||||
},
|
||||
.B = (double[]) {
|
||||
1, 0, 0,
|
||||
2, 0, 0,
|
||||
3, 0, 0,
|
||||
},
|
||||
.m = 3,
|
||||
.n = 3,
|
||||
},
|
||||
{
|
||||
.A = (double[]) {
|
||||
0, 1, 0,
|
||||
0, 2, 0,
|
||||
0, 3, 0,
|
||||
},
|
||||
.B = (double[]) {
|
||||
0, 0, 0,
|
||||
1, 2, 3,
|
||||
0, 0, 0,
|
||||
},
|
||||
.m = 3,
|
||||
.n = 3,
|
||||
},
|
||||
{
|
||||
.A = (double[]) {
|
||||
0, 0, 1,
|
||||
0, 0, 2,
|
||||
0, 0, 3,
|
||||
},
|
||||
.B = (double[]) {
|
||||
0, 0, 0,
|
||||
0, 0, 0,
|
||||
1, 2, 3,
|
||||
},
|
||||
.m = 3,
|
||||
.n = 3,
|
||||
},
|
||||
{
|
||||
.A = (double[]) {
|
||||
1, 2, 3,
|
||||
4, 5, 6,
|
||||
},
|
||||
.B = (double[]) {
|
||||
1, 4,
|
||||
2, 5,
|
||||
3, 6,
|
||||
},
|
||||
.m = 2,
|
||||
.n = 3,
|
||||
},
|
||||
{
|
||||
.A = (double[]) {
|
||||
1, 4,
|
||||
2, 5,
|
||||
3, 6,
|
||||
},
|
||||
.B = (double[]) {
|
||||
1, 2, 3,
|
||||
4, 5, 6,
|
||||
},
|
||||
.m = 3,
|
||||
.n = 2,
|
||||
},
|
||||
};
|
||||
|
||||
int main()
|
||||
{
|
||||
// Evaluate dot product tests.
|
||||
{
|
||||
int dot_passed = 0;
|
||||
int dot_total = sizeof(dot_tests) / sizeof(*dot_tests);
|
||||
struct dot_test a;
|
||||
|
||||
for(int i = 0; i < dot_total; i += 1)
|
||||
{
|
||||
double R[9];
|
||||
|
||||
lina_dot(dot_tests[i].A, dot_tests[i].B, R, 3, 3, 3);
|
||||
|
||||
if(!memcmp(R, dot_tests[i].C, sizeof(R)))
|
||||
{
|
||||
fprintf(stderr, "Dot product test %d passed.\n", i);
|
||||
dot_passed += 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
fprintf(stderr, "Dot product test %d failed:\n got matrix:\n\n", i);
|
||||
pmatrix(stderr, R, 3, 3);
|
||||
fprintf(stderr, " instead of:\n\n");
|
||||
pmatrix(stderr, dot_tests[i].C, 3, 3);
|
||||
}
|
||||
}
|
||||
fprintf(stderr, "\n\t%d dot products out of %d were succesful.\n\n", dot_passed, dot_total);
|
||||
}
|
||||
|
||||
|
||||
// Evaluate scaling tests.
|
||||
{
|
||||
int scale_passed = 0;
|
||||
int scale_total = sizeof(scale_tests) / sizeof(*scale_tests);
|
||||
|
||||
for(int i = 0; i < scale_total; i += 1)
|
||||
{
|
||||
double R[9];
|
||||
|
||||
lina_scale(scale_tests[i].A, R, scale_tests[i].factor, 3, 3);
|
||||
|
||||
if(!memcmp(R, scale_tests[i].B, sizeof(R)))
|
||||
{
|
||||
fprintf(stderr, "Scaling test %d passed.\n", i);
|
||||
scale_passed += 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
fprintf(stderr, "Scaling test %d failed:\n got matrix:\n\n", i);
|
||||
pmatrix(stderr, R, 3, 3);
|
||||
fprintf(stderr, " instead of:\n\n");
|
||||
pmatrix(stderr, scale_tests[i].B, 3, 3);
|
||||
}
|
||||
}
|
||||
fprintf(stderr, "\n\t%d scalings out of %d were succesful.\n\n", scale_passed, scale_total);
|
||||
}
|
||||
|
||||
// Evaluate transposition tests.
|
||||
{
|
||||
int transp_passed = 0;
|
||||
int transp_total = sizeof(transp_tests) / sizeof(*transp_tests);
|
||||
|
||||
for(int i = 0; i < transp_total; i += 1)
|
||||
{
|
||||
int m = transp_tests[i].m;
|
||||
int n = transp_tests[i].n;
|
||||
|
||||
double R[32];
|
||||
|
||||
assert(sizeof(R) >= m * n * sizeof(R[0]));
|
||||
|
||||
lina_transpose(transp_tests[i].A, R, m, n);
|
||||
|
||||
if(!memcmp(R, transp_tests[i].B, sizeof(R[0]) * m * n))
|
||||
{
|
||||
fprintf(stderr, "Transposition test %d passed.\n", i);
|
||||
transp_passed += 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
fprintf(stderr, "Transposition test %d failed:\n got matrix:\n\n", i);
|
||||
pmatrix(stderr, R, m, n);
|
||||
fprintf(stderr, " instead of:\n\n");
|
||||
pmatrix(stderr, transp_tests[i].B, m, n);
|
||||
}
|
||||
}
|
||||
fprintf(stderr, "\n\t%d transpositions out of %d were succesful.\n\n", transp_passed, transp_total);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user