change precision for tests : put it to 3e-16 for double and 3e-6 for float

8 files changed, 153 insertions, 153 deletions

diff --git a/scilab2c/src/statisticsFunctions/mean/testDoubleMean.c b/scilab2c/src/statisticsFunctions/mean/testDoubleMean.c
index b48ad7d4..e430c7eb 100644
--- a/scilab2c/src/statisticsFunctions/mean/testDoubleMean.c
+++ b/scilab2c/src/statisticsFunctions/mean/testDoubleMean.c
@@ -24,8 +24,8 @@ static int dmeansTest(void) {
   double value2 = 1.123456789;
 
   printf("\n>>>> Mean Double Scalar Test\n");
-  assert( ( fabs(dmeans(value1) ) - (  3.0 ) ) / fabs ( dmeans(value1)  ) <  1e-15 );
-  assert( ( fabs(dmeans(value2) ) - (  1.123456789 ) ) / fabs ( dmeans(value2)  ) <  1e-15 );
+  assert( ( fabs(dmeans(value1) ) - (  3.0 ) ) / fabs ( dmeans(value1)  ) <  3e-16 );
+  assert( ( fabs(dmeans(value2) ) - (  1.123456789 ) ) / fabs ( dmeans(value2)  ) <  3e-16 );
 
   return 0;
 }
@@ -39,8 +39,8 @@ static int dmeanaTest(void) {
 		     9.186784563};
 
   printf("\n>>>> Mean Double Array Test\n");
-  assert( ( fabs(dmeana(table1, 3) ) - (  9.0 / 3.0 ) ) / fabs ( dmeana(table1, 3)  ) <  1e-15 );
-  assert(( ( fabs(dmeana(table2, 5) ) - (  (9.186784563 + 9.186784563 + 9.186784563 + 9.186784563 + 9.186784563) / 5.0) ) ) / fabs ( dmeana(table2, 5)  ) <  1e-15 );
+  assert( ( fabs(dmeana(table1, 3) ) - (  9.0 / 3.0 ) ) / fabs ( dmeana(table1, 3)  ) <  3e-16 );
+  assert(( ( fabs(dmeana(table2, 5) ) - (  (9.186784563 + 9.186784563 + 9.186784563 + 9.186784563 + 9.186784563) / 5.0) ) ) / fabs ( dmeana(table2, 5)  ) <  3e-16 );
   return 0;
 }
 
@@ -61,15 +61,15 @@ static int dcolumnmeanaTest(void) {
     [ 7 8 9 ]
   */
   dcolumnmeana(table1, 3, 3,columnMeanmedTable1_3_3);
-  assert( ( fabs(columnMeanmedTable1_3_3[0] ) - (  6.0 / 3.0 ) ) / fabs ( columnMeanmedTable1_3_3[0]  ) <  1e-15 );
-  assert( ( fabs(columnMeanmedTable1_3_3[1] ) - (  15.0 / 3.0 ) ) / fabs ( columnMeanmedTable1_3_3[1]  ) <  1e-15 );
-  assert( ( fabs(columnMeanmedTable1_3_3[2] ) - (  24.0 / 3.0 ) ) / fabs ( columnMeanmedTable1_3_3[2]  ) <  1e-15 );
+  assert( ( fabs(columnMeanmedTable1_3_3[0] ) - (  6.0 / 3.0 ) ) / fabs ( columnMeanmedTable1_3_3[0]  ) <  3e-16 );
+  assert( ( fabs(columnMeanmedTable1_3_3[1] ) - (  15.0 / 3.0 ) ) / fabs ( columnMeanmedTable1_3_3[1]  ) <  3e-16 );
+  assert( ( fabs(columnMeanmedTable1_3_3[2] ) - (  24.0 / 3.0 ) ) / fabs ( columnMeanmedTable1_3_3[2]  ) <  3e-16 );
 
   /*
     [ 1 2 3 4 5 6 7 8 9 ] => [ 45 ]
   */
   dcolumnmeana(table1, 1, 9,columnMeanmedTable1_1_9);
-  assert( ( fabs(columnMeanmedTable1_1_9[0] ) - (  45.0 / 9.0 ) ) / fabs ( columnMeanmedTable1_1_9[0]  ) <  1e-15 );
+  assert( ( fabs(columnMeanmedTable1_1_9[0] ) - (  45.0 / 9.0 ) ) / fabs ( columnMeanmedTable1_1_9[0]  ) <  3e-16 );
 
   /*
     [ 1 ]
@@ -93,8 +93,8 @@ static int dcolumnmeanaTest(void) {
     [ 2 4 6 8 10 ] => [ 25 30 ]
   */
   dcolumnmeana(table2, 2, 5,columnMeanmedTable2_2_5);
-  assert( ( fabs(columnMeanmedTable2_2_5[0] ) - (  25.0 / 5.0 ) ) / fabs ( columnMeanmedTable2_2_5[0]  ) <  1e-15 );
-  assert( ( fabs(columnMeanmedTable2_2_5[1] ) - (  30.0 / 5.0 ) ) / fabs ( columnMeanmedTable2_2_5[1]  ) <  1e-15 );
+  assert( ( fabs(columnMeanmedTable2_2_5[0] ) - (  25.0 / 5.0 ) ) / fabs ( columnMeanmedTable2_2_5[0]  ) <  3e-16 );
+  assert( ( fabs(columnMeanmedTable2_2_5[1] ) - (  30.0 / 5.0 ) ) / fabs ( columnMeanmedTable2_2_5[1]  ) <  3e-16 );
   for ( i = 0 ; i < 2 ; ++i) {
     printf("columnMeanmedTable2_2_5[%d] = %e\n", i, columnMeanmedTable2_2_5[i]);
   }
@@ -107,11 +107,11 @@ static int dcolumnmeanaTest(void) {
     [ 5 10 ]
   */
   dcolumnmeana(table2, 5, 2,columnMeanmedTable2_5_2);
-  assert( ( fabs(columnMeanmedTable2_5_2[0] ) - (  7.0 / 2.0 ) ) / fabs ( columnMeanmedTable2_5_2[0]  ) <  1e-15 );
-  assert( ( fabs(columnMeanmedTable2_5_2[1] ) - (  9.0 / 2.0 ) ) / fabs ( columnMeanmedTable2_5_2[1]  ) <  1e-15 );
-  assert( ( fabs(columnMeanmedTable2_5_2[2] ) - (  11.0 / 2.0 ) ) / fabs ( columnMeanmedTable2_5_2[2]  ) <  1e-15 );
-  assert( ( fabs(columnMeanmedTable2_5_2[3] ) - (  13.0 / 2.0 ) ) / fabs ( columnMeanmedTable2_5_2[3]  ) <  1e-15 );
-  assert( ( fabs(columnMeanmedTable2_5_2[4] ) - (  15.0 / 2.0 ) ) / fabs ( columnMeanmedTable2_5_2[4]  ) <  1e-15 );
+  assert( ( fabs(columnMeanmedTable2_5_2[0] ) - (  7.0 / 2.0 ) ) / fabs ( columnMeanmedTable2_5_2[0]  ) <  3e-16 );
+  assert( ( fabs(columnMeanmedTable2_5_2[1] ) - (  9.0 / 2.0 ) ) / fabs ( columnMeanmedTable2_5_2[1]  ) <  3e-16 );
+  assert( ( fabs(columnMeanmedTable2_5_2[2] ) - (  11.0 / 2.0 ) ) / fabs ( columnMeanmedTable2_5_2[2]  ) <  3e-16 );
+  assert( ( fabs(columnMeanmedTable2_5_2[3] ) - (  13.0 / 2.0 ) ) / fabs ( columnMeanmedTable2_5_2[3]  ) <  3e-16 );
+  assert( ( fabs(columnMeanmedTable2_5_2[4] ) - (  15.0 / 2.0 ) ) / fabs ( columnMeanmedTable2_5_2[4]  ) <  3e-16 );
   for ( i = 0 ; i < 5 ; ++i) {
     printf("columnMeanmedTable2_5_2[%d] = %e\n", i, columnMeanmedTable2_5_2[i]);
   }
@@ -139,9 +139,9 @@ static int drowmeanaTest(void) {
   for ( i = 0 ; i < 3 ; ++i) {
     printf("rowMeanmedTable1_3_3[%d] = %e\n", i, rowMeanmedTable1_3_3[i]);
   }
-  assert( ( fabs(rowMeanmedTable1_3_3[0] ) - (  12.0 / 3.0 ) ) / fabs ( rowMeanmedTable1_3_3[0]  ) <  1e-15 );
-  assert( ( fabs(rowMeanmedTable1_3_3[1] ) - (  15.0 / 3.0 ) ) / fabs ( rowMeanmedTable1_3_3[1]  ) <  1e-15 );
-  assert( ( fabs(rowMeanmedTable1_3_3[2] ) - (  18.0 / 3.0 ) ) / fabs ( rowMeanmedTable1_3_3[2]  ) <  1e-15 );
+  assert( ( fabs(rowMeanmedTable1_3_3[0] ) - (  12.0 / 3.0 ) ) / fabs ( rowMeanmedTable1_3_3[0]  ) <  3e-16 );
+  assert( ( fabs(rowMeanmedTable1_3_3[1] ) - (  15.0 / 3.0 ) ) / fabs ( rowMeanmedTable1_3_3[1]  ) <  3e-16 );
+  assert( ( fabs(rowMeanmedTable1_3_3[2] ) - (  18.0 / 3.0 ) ) / fabs ( rowMeanmedTable1_3_3[2]  ) <  3e-16 );
 
   /*
     [ 1 ]
@@ -164,7 +164,7 @@ static int drowmeanaTest(void) {
     [ 1 2 3 4 5 6 7 8 9 ] => [ 45 ]
   */
   drowmeana(table1, 9, 1,rowMeanmedTable1_9_1);
-  assert( ( fabs(rowMeanmedTable1_9_1[0] ) - (  45.0 / 9.0 ) ) / fabs ( rowMeanmedTable1_9_1[0]  ) <  1e-15 );
+  assert( ( fabs(rowMeanmedTable1_9_1[0] ) - (  45.0 / 9.0 ) ) / fabs ( rowMeanmedTable1_9_1[0]  ) <  3e-16 );
 
   /*
     [ 1 3 5 7  9 ]
@@ -174,11 +174,11 @@ static int drowmeanaTest(void) {
   for ( i = 0 ; i < 5 ; ++i) {
     printf("rowMeanmedTable2_2_5[%d] = %e\n", i, rowMeanmedTable2_2_5[i]);
   }
-  assert( ( fabs(rowMeanmedTable2_2_5[0] ) - (  3.0 / 2.0 ) ) / fabs ( rowMeanmedTable2_2_5[0]  ) <  1e-15 );
-  assert( ( fabs(rowMeanmedTable2_2_5[1] ) - (  7.0 / 2.0 ) ) / fabs ( rowMeanmedTable2_2_5[1]  ) <  1e-15 );
-  assert( ( fabs(rowMeanmedTable2_2_5[2] ) - (  11.0 / 2.0 ) ) / fabs ( rowMeanmedTable2_2_5[2]  ) <  1e-15 );
-  assert( ( fabs(rowMeanmedTable2_2_5[3] ) - (  15.0 / 2.0 ) ) / fabs ( rowMeanmedTable2_2_5[3]  ) <  1e-15 );
-  assert( ( fabs(rowMeanmedTable2_2_5[4] ) - (  19.0 / 2.0 ) ) / fabs ( rowMeanmedTable2_2_5[4]  ) <  1e-15 );
+  assert( ( fabs(rowMeanmedTable2_2_5[0] ) - (  3.0 / 2.0 ) ) / fabs ( rowMeanmedTable2_2_5[0]  ) <  3e-16 );
+  assert( ( fabs(rowMeanmedTable2_2_5[1] ) - (  7.0 / 2.0 ) ) / fabs ( rowMeanmedTable2_2_5[1]  ) <  3e-16 );
+  assert( ( fabs(rowMeanmedTable2_2_5[2] ) - (  11.0 / 2.0 ) ) / fabs ( rowMeanmedTable2_2_5[2]  ) <  3e-16 );
+  assert( ( fabs(rowMeanmedTable2_2_5[3] ) - (  15.0 / 2.0 ) ) / fabs ( rowMeanmedTable2_2_5[3]  ) <  3e-16 );
+  assert( ( fabs(rowMeanmedTable2_2_5[4] ) - (  19.0 / 2.0 ) ) / fabs ( rowMeanmedTable2_2_5[4]  ) <  3e-16 );
 
   /*
     [ 1  6 ]
@@ -188,8 +188,8 @@ static int drowmeanaTest(void) {
     [ 5 10 ]
   */
   drowmeana(table2, 5, 2,rowMeanmedTable2_5_2);
-  assert( ( fabs(rowMeanmedTable2_5_2[0] ) - (  15.0 / 5.0 ) ) / fabs ( rowMeanmedTable2_5_2[0]  ) <  1e-15 );
-  assert( ( fabs(rowMeanmedTable2_5_2[1] ) - (  40.0 / 5.0 ) ) / fabs ( rowMeanmedTable2_5_2[1]  ) <  1e-15 );
+  assert( ( fabs(rowMeanmedTable2_5_2[0] ) - (  15.0 / 5.0 ) ) / fabs ( rowMeanmedTable2_5_2[0]  ) <  3e-16 );
+  assert( ( fabs(rowMeanmedTable2_5_2[1] ) - (  40.0 / 5.0 ) ) / fabs ( rowMeanmedTable2_5_2[1]  ) <  3e-16 );
   for ( i = 0 ; i < 2 ; ++i) {
     printf("rowMeanmedTable2_5_2[%d] = %e\n", i, rowMeanmedTable2_5_2[i]);
   }
@@ -202,10 +202,10 @@ static int zmeansTest(void) {
   doubleComplex value2 = DoubleComplex(1.123456789, 1.123456789);
 
   printf("\n>>>> Mean Double Complex Scalar Test\n");
-  assert( ( fabs(zreals(zmeans(value1)) ) - (  3.0 ) ) / fabs ( zreals(zmeans(value1))  ) <  1e-15 );
-  assert( ( fabs(zimags(zmeans(value1)) ) - (  3.0 ) ) / fabs ( zimags(zmeans(value1))  ) <  1e-15 );
-  assert( ( fabs(zreals(zmeans(value2)) ) - (  1.123456789 ) ) / fabs ( zreals(zmeans(value2))  ) <  1e-15 );
-  assert( ( fabs(zimags(zmeans(value2)) ) - (  1.123456789 ) ) / fabs ( zimags(zmeans(value2))  ) <  1e-15 );
+  assert( ( fabs(zreals(zmeans(value1)) ) - (  3.0 ) ) / fabs ( zreals(zmeans(value1))  ) <  3e-16 );
+  assert( ( fabs(zimags(zmeans(value1)) ) - (  3.0 ) ) / fabs ( zimags(zmeans(value1))  ) <  3e-16 );
+  assert( ( fabs(zreals(zmeans(value2)) ) - (  1.123456789 ) ) / fabs ( zreals(zmeans(value2))  ) <  3e-16 );
+  assert( ( fabs(zimags(zmeans(value2)) ) - (  1.123456789 ) ) / fabs ( zimags(zmeans(value2))  ) <  3e-16 );
   return 0;
 }
 
@@ -235,10 +235,10 @@ static int zmeanaTest(void) {
   printf("%e\n", zimags(zmeana(table2, 5)));
   printf("--------\n");
 #endif
-  assert( ( fabs(zreals(zmeana(table1, 3)) ) - (  9.0 / 3.0 ) ) / fabs ( zreals(zmeana(table1, 3))  ) <  1e-15 );
-  assert( ( fabs(zimags(zmeana(table1, 3)) ) - (  9.0 / 3.0 ) ) / fabs ( zimags(zmeana(table1, 3))  ) <  1e-15 );
-  assert( ( fabs(zreals(zmeana(table2, 5)) ) - (  (9.186784563 + 9.186784563 + 9.186784563 + 9.186784563 + 9.186784563) / 5.0 ) ) / fabs ( zreals(zmeana(table2, 5))  ) <  1e-15 );
-  assert( ( fabs(zimags(zmeana(table2, 5)) ) - (  (9.186784563 + 9.186784563 + 9.186784563 + 9.186784563 + 9.186784563) / 5.0 ) ) / fabs ( zimags(zmeana(table2, 5))  ) <  1e-15 );
+  assert( ( fabs(zreals(zmeana(table1, 3)) ) - (  9.0 / 3.0 ) ) / fabs ( zreals(zmeana(table1, 3))  ) <  3e-16 );
+  assert( ( fabs(zimags(zmeana(table1, 3)) ) - (  9.0 / 3.0 ) ) / fabs ( zimags(zmeana(table1, 3))  ) <  3e-16 );
+  assert( ( fabs(zreals(zmeana(table2, 5)) ) - (  (9.186784563 + 9.186784563 + 9.186784563 + 9.186784563 + 9.186784563) / 5.0 ) ) / fabs ( zreals(zmeana(table2, 5))  ) <  3e-16 );
+  assert( ( fabs(zimags(zmeana(table2, 5)) ) - (  (9.186784563 + 9.186784563 + 9.186784563 + 9.186784563 + 9.186784563) / 5.0 ) ) / fabs ( zimags(zmeana(table2, 5))  ) <  3e-16 );
 
   return 0;
 }
@@ -271,11 +271,11 @@ static int zrowmeanaTest(void) {
     printf("rowMeanmedIn_4_3[%d] = %e + %ei\n", i, zreals(rowMeanmedIn_4_3[i]), zimags(rowMeanmedIn_4_3[i]));
   }
   assert(fabs(zreals(rowMeanmedIn_4_3[0]) - 0.6 / 4.0) < 1e-16);
-  assert( ( fabs(zimags(rowMeanmedIn_4_3[0]) ) - (  3.8 / 4.0 ) ) / fabs ( zimags(rowMeanmedIn_4_3[0])  ) <  1e-15 );
-  assert( ( fabs(zreals(rowMeanmedIn_4_3[1]) ) - (  2.2 / 4.0 ) ) / fabs ( zreals(rowMeanmedIn_4_3[1])  ) <  1e-15 );
-  assert(fabs(zimags(rowMeanmedIn_4_3[1]) - 2.2 / 4.0) < 1e-15);
-  assert(fabs(zreals(rowMeanmedIn_4_3[2]) - 3.8 / 4.0) < 1e-15);
-  assert( ( fabs(zimags(rowMeanmedIn_4_3[2]) ) - (  0.6 / 4.0 ) ) / fabs ( zimags(rowMeanmedIn_4_3[2])  ) <  1e-15 );
+  assert( ( fabs(zimags(rowMeanmedIn_4_3[0]) ) - (  3.8 / 4.0 ) ) / fabs ( zimags(rowMeanmedIn_4_3[0])  ) <  3e-16 );
+  assert( ( fabs(zreals(rowMeanmedIn_4_3[1]) ) - (  2.2 / 4.0 ) ) / fabs ( zreals(rowMeanmedIn_4_3[1])  ) <  3e-16 );
+  assert(fabs(zimags(rowMeanmedIn_4_3[1]) - 2.2 / 4.0) < 3e-16);
+  assert(fabs(zreals(rowMeanmedIn_4_3[2]) - 3.8 / 4.0) < 3e-16);
+  assert( ( fabs(zimags(rowMeanmedIn_4_3[2]) ) - (  0.6 / 4.0 ) ) / fabs ( zimags(rowMeanmedIn_4_3[2])  ) <  3e-16 );
 
   /*
     [ 1.1i     0.3+0.8i  0.6+0.5i 0.9+0.2i ]
@@ -287,11 +287,11 @@ static int zrowmeanaTest(void) {
     printf("rowMeanmedIn_3_4[%d] = %e + %ei\n", i, zreals(rowMeanmedIn_3_4[i]), zimags(rowMeanmedIn_3_4[i]));
   }
   assert(fabs(zreals(rowMeanmedIn_3_4[0]) - 0.3 / 3.0) < 1e-16);
-  assert( ( fabs(zimags(rowMeanmedIn_3_4[0]) ) - (  3.0 / 3.0 ) ) / fabs ( zimags(rowMeanmedIn_3_4[0])  ) <  1e-15 );
+  assert( ( fabs(zimags(rowMeanmedIn_3_4[0]) ) - (  3.0 / 3.0 ) ) / fabs ( zimags(rowMeanmedIn_3_4[0])  ) <  3e-16 );
   assert(zreals(rowMeanmedIn_3_4[1]) == 1.2 / 3.0 && zimags(rowMeanmedIn_3_4[1]) == 2.1 / 3.0);
-  assert(fabs(zreals(rowMeanmedIn_3_4[2]) - 2.1 / 3.0) < 1e-15);
-  assert( ( fabs(zimags(rowMeanmedIn_3_4[2]) ) - (  1.2 / 3.0 ) ) / fabs ( zimags(rowMeanmedIn_3_4[2])  ) <  1e-15 );
-  assert( ( fabs(zreals(rowMeanmedIn_3_4[3]) ) - (  3.0 / 3.0 ) ) / fabs ( zreals(rowMeanmedIn_3_4[3])  ) <  1e-15 );
+  assert(fabs(zreals(rowMeanmedIn_3_4[2]) - 2.1 / 3.0) < 3e-16);
+  assert( ( fabs(zimags(rowMeanmedIn_3_4[2]) ) - (  1.2 / 3.0 ) ) / fabs ( zimags(rowMeanmedIn_3_4[2])  ) <  3e-16 );
+  assert( ( fabs(zreals(rowMeanmedIn_3_4[3]) ) - (  3.0 / 3.0 ) ) / fabs ( zreals(rowMeanmedIn_3_4[3])  ) <  3e-16 );
   assert(fabs(zimags(rowMeanmedIn_3_4[3]) - 0.3 / 3.0) < 1e-16);
 
   /*
@@ -318,14 +318,14 @@ static int zrowmeanaTest(void) {
     printf("rowMeanmedIn_2_6[%d] = %e + %ei\n", i, zreals(rowMeanmedIn_2_6[i]), zimags(rowMeanmedIn_2_6[i]));
   }
   assert(zreals(rowMeanmedIn_2_6[0]) == 0.1 / 2.0 && zimags(rowMeanmedIn_2_6[0]) == 2.1 / 2.0);
-  assert( ( fabs(zreals(rowMeanmedIn_2_6[1]) ) - (  0.5 / 2.0 ) ) / fabs ( zreals(rowMeanmedIn_2_6[1])  ) <  1e-15 );
+  assert( ( fabs(zreals(rowMeanmedIn_2_6[1]) ) - (  0.5 / 2.0 ) ) / fabs ( zreals(rowMeanmedIn_2_6[1])  ) <  3e-16 );
   assert(fabs(zimags(rowMeanmedIn_2_6[1]) == 1.7 / 2.0) < 1e-16);
-  assert( ( fabs(zreals(rowMeanmedIn_2_6[2]) ) - (  0.9 / 2.0 ) ) / fabs ( zreals(rowMeanmedIn_2_6[2])  ) <  1e-15 );
+  assert( ( fabs(zreals(rowMeanmedIn_2_6[2]) ) - (  0.9 / 2.0 ) ) / fabs ( zreals(rowMeanmedIn_2_6[2])  ) <  3e-16 );
   assert(fabs(zimags(rowMeanmedIn_2_6[2]) == 1.3 / 2.0) < 1e-16);
   assert(fabs(zreals(rowMeanmedIn_2_6[3]) == 1.3 / 2.0) < 1e-16);
-  assert( ( fabs(zimags(rowMeanmedIn_2_6[3]) ) - (  0.9 / 2.0 ) ) / fabs ( zimags(rowMeanmedIn_2_6[3])  ) <  1e-15 );
+  assert( ( fabs(zimags(rowMeanmedIn_2_6[3]) ) - (  0.9 / 2.0 ) ) / fabs ( zimags(rowMeanmedIn_2_6[3])  ) <  3e-16 );
   assert(fabs(zreals(rowMeanmedIn_2_6[4]) == 1.7 / 2.0) < 1e-16);
-  assert( ( fabs(zimags(rowMeanmedIn_2_6[4]) ) - (  0.5 / 2.0 ) ) / fabs ( zimags(rowMeanmedIn_2_6[4])  ) <  1e-15 );
+  assert( ( fabs(zimags(rowMeanmedIn_2_6[4]) ) - (  0.5 / 2.0 ) ) / fabs ( zimags(rowMeanmedIn_2_6[4])  ) <  3e-16 );
   assert(zreals(rowMeanmedIn_2_6[5]) == 2.1 / 2.0 && zimags(rowMeanmedIn_2_6[5]) == 0.1 / 2.0);
 
   /*
@@ -387,12 +387,12 @@ static int zcolumnmeanaTest(void) {
   for (i = 0 ; i < 4 ; ++i) {
     printf("columnMeanmedIn_4_3[%d] = %e + %ei\n", i, zreals(columnMeanmedIn_4_3[i]), zimags(columnMeanmedIn_4_3[i]));
   }
-  assert(fabs(zreals(columnMeanmedIn_4_3[0]) - 1.2 / 3.0) < 1e-15);
+  assert(fabs(zreals(columnMeanmedIn_4_3[0]) - 1.2 / 3.0) < 3e-16);
   assert(zimags(columnMeanmedIn_4_3[0]) == 2.1 / 3.0);
   assert(zreals(columnMeanmedIn_4_3[1]) == 1.5 / 3.0 && zimags(columnMeanmedIn_4_3[1]) == 1.8 / 3.0);
   assert(zreals(columnMeanmedIn_4_3[2]) == 1.8  / 3.0&& zimags(columnMeanmedIn_4_3[2]) == 1.5 / 3.0);
   assert(zreals(columnMeanmedIn_4_3[3]) == 2.1 / 3.0);
-  assert(fabs(zimags(columnMeanmedIn_4_3[3]) - 1.2 / 3.0) < 1e-15);
+  assert(fabs(zimags(columnMeanmedIn_4_3[3]) - 1.2 / 3.0) < 3e-16);
 
   /*
     [ 1.1i     0.3+0.8i  0.6+0.5i 0.9+0.2i ]
@@ -403,8 +403,8 @@ static int zcolumnmeanaTest(void) {
   for (i = 0 ; i < 3 ; ++i) {
     printf("columnMeanmedIn_3_4[%d] = %e + %ei\n", i, zreals(columnMeanmedIn_3_4[i]), zimags(columnMeanmedIn_3_4[i]));
   }
-  assert(fabs(zreals(columnMeanmedIn_3_4[0]) - 1.8 / 4.0) < 1e-15);
-  assert(fabs(zimags(columnMeanmedIn_3_4[0]) - 2.6 / 4.0) < 1e-15);
+  assert(fabs(zreals(columnMeanmedIn_3_4[0]) - 1.8 / 4.0) < 3e-16);
+  assert(fabs(zimags(columnMeanmedIn_3_4[0]) - 2.6 / 4.0) < 3e-16);
   assert(zreals(columnMeanmedIn_3_4[1]) == 2.2 / 4.0 && zimags(columnMeanmedIn_3_4[1]) == 2.2 / 4.0);
   assert(zreals(columnMeanmedIn_3_4[2]) == 2.6 / 4.0 && zimags(columnMeanmedIn_3_4[2]) == 1.8 / 4.0);
 
@@ -421,12 +421,12 @@ static int zcolumnmeanaTest(void) {
     printf("columnMeanmedIn_6_2[%d] = %e + %ei\n", i, zreals(columnMeanmedIn_6_2[i]), zimags(columnMeanmedIn_6_2[i]));
   }
   assert(zreals(columnMeanmedIn_6_2[0]) == 0.6 / 2.0 && zimags(columnMeanmedIn_6_2[0]) == 1.6 / 2.0);
-  assert(fabs(zreals(columnMeanmedIn_6_2[1]) - 0.8 / 2.0) < 1e-15);
+  assert(fabs(zreals(columnMeanmedIn_6_2[1]) - 0.8 / 2.0) < 3e-16);
   assert(zimags(columnMeanmedIn_6_2[1]) == 1.4 / 2.0);
   assert(zreals(columnMeanmedIn_6_2[2]) == 1.0  / 2.0 && zimags(columnMeanmedIn_6_2[2]) == 1.2 / 2.0);
   assert(zreals(columnMeanmedIn_6_2[3]) == 1.2  / 2.0 && zimags(columnMeanmedIn_6_2[3]) == 1.0 / 2.0);
   assert(zreals(columnMeanmedIn_6_2[4]) == 1.4 / 2.0);
-  assert(fabs(zimags(columnMeanmedIn_6_2[4]) - 0.8 / 2.0) < 1e-15);
+  assert(fabs(zimags(columnMeanmedIn_6_2[4]) - 0.8 / 2.0) < 3e-16);
   assert(zreals(columnMeanmedIn_6_2[5]) == 1.6 / 2.0 && zimags(columnMeanmedIn_6_2[5]) == 0.6 / 2.0);
 
   /*
diff --git a/scilab2c/src/statisticsFunctions/prod/testDoubleProd.c b/scilab2c/src/statisticsFunctions/prod/testDoubleProd.c
index 9ec1559c..b18ca148 100644
--- a/scilab2c/src/statisticsFunctions/prod/testDoubleProd.c
+++ b/scilab2c/src/statisticsFunctions/prod/testDoubleProd.c
@@ -41,7 +41,7 @@ static int dprodaTest(void) {
   printf("\n>>>> prod Double Array Test\n");
   printf("%f\n", dproda(table1, 3));
   assert(dproda(table1, 3) == 27.0);
-  assert((dproda(table2, 5) - (9.186784 * 9.186784 * 9.186784 * 9.186784 * 9.186784)) / dproda(table2, 5) < 1e-6);
+  assert((dproda(table2, 5) - (9.186784 * 9.186784 * 9.186784 * 9.186784 * 9.186784)) / dproda(table2, 5) < 3e-16);
   return 0;
 }
 
@@ -238,8 +238,8 @@ static int zprodaTest(void) {
 #endif
   assert(zreals(zproda(table1, 3)) == -54.0);
   assert(zimags(zproda(table1, 3)) == 54.0);
-  assert(fabs(zreals(zproda(table2, 5)) + 261744.55211053110542707) < 1e-06);
-  assert(fabs(zimags(zproda(table2, 5)) + 261744.55211053110542707) < 1e-06);
+  assert(fabs(zreals(zproda(table2, 5)) + 261744.55211053110542707) < 3e-16);
+  assert(fabs(zimags(zproda(table2, 5)) + 261744.55211053110542707) < 3e-16);
 
   return 0;
 }
@@ -271,12 +271,12 @@ static int zrowprodaTest(void) {
   for (i = 0 ; i < 3 ; ++i) {
     printf("rowProductedIn_4_3[%d] = %e + %ei\n", i, zreals(rowProductedIn_4_3[i]), zimags(rowProductedIn_4_3[i]));
   }
-  assert(fabs(zreals(rowProductedIn_4_3[0]) - 0.6787000000000000810019) < 1e-06);
-  assert(fabs(zimags(rowProductedIn_4_3[0]) + 0.5456) < 1e-06);
-  assert(fabs(zreals(rowProductedIn_4_3[1]) + 0.3964999999999999635847) < 1e-06);
-  assert(fabs(zimags(rowProductedIn_4_3[1]) - 0.0) < 1e-06);
-  assert(fabs(zreals(rowProductedIn_4_3[2]) - 0.6787000000000000810019) < 1e-06);
-  assert(fabs(zimags(rowProductedIn_4_3[2]) - 0.5456) < 1e-06);
+  assert(fabs(zreals(rowProductedIn_4_3[0]) - 0.6787000000000000810019) < 3e-16);
+  assert(fabs(zimags(rowProductedIn_4_3[0]) + 0.5456) < 3e-16);
+  assert(fabs(zreals(rowProductedIn_4_3[1]) + 0.3964999999999999635847) < 3e-16);
+  assert(fabs(zimags(rowProductedIn_4_3[1]) - 0.0) < 3e-16);
+  assert(fabs(zreals(rowProductedIn_4_3[2]) - 0.6787000000000000810019) < 3e-16);
+  assert(fabs(zimags(rowProductedIn_4_3[2]) - 0.5456) < 3e-16);
 
   /*
     [ 1.1i     0.3+0.8i  0.6+0.5i 0.9+0.2i ]
@@ -289,14 +289,14 @@ static int zrowprodaTest(void) {
   for (i = 0 ; i < 4 ; ++i) {
     printf("rowProductedIn_3_4[%d] = %e + %ei\n", i, zreals(rowProductedIn_3_4[i]), zimags(rowProductedIn_3_4[i]));
   }
-  assert(fabs(zreals(rowProductedIn_3_4[0]) + 0.3190000000000000612843) < 1e-06);
-  assert(fabs(zimags(rowProductedIn_3_4[0]) + 0.9680000000000000826006) < 1e-06);
-  assert(fabs(zreals(rowProductedIn_3_4[1]) + 0.5380000000000000337508) < 1e-06);
-  assert(fabs(zimags(rowProductedIn_3_4[1]) - 0.0010000000000000563993 ) < 1e-06);
-  assert(fabs(zreals(rowProductedIn_3_4[2]) + 0.0010000000000000008882) < 1e-06);
-  assert(fabs(zimags(rowProductedIn_3_4[2]) - 0.5379999999999999227285) < 1e-06);
-  assert(fabs(zreals(rowProductedIn_3_4[3]) - 0.9680000000000000826006) < 1e-06);
-  assert(fabs(zimags(rowProductedIn_3_4[3]) - 0.3190000000000000612843) < 1e-06);
+  assert(fabs(zreals(rowProductedIn_3_4[0]) + 0.3190000000000000612843) < 3e-16);
+  assert(fabs(zimags(rowProductedIn_3_4[0]) + 0.9680000000000000826006) < 3e-16);
+  assert(fabs(zreals(rowProductedIn_3_4[1]) + 0.5380000000000000337508) < 3e-16);
+  assert(fabs(zimags(rowProductedIn_3_4[1]) - 0.0010000000000000563993 ) < 3e-16);
+  assert(fabs(zreals(rowProductedIn_3_4[2]) + 0.0010000000000000008882) < 3e-16);
+  assert(fabs(zimags(rowProductedIn_3_4[2]) - 0.5379999999999999227285) < 3e-16);
+  assert(fabs(zreals(rowProductedIn_3_4[3]) - 0.9680000000000000826006) < 3e-16);
+  assert(fabs(zimags(rowProductedIn_3_4[3]) - 0.3190000000000000612843) < 3e-16);
 
   /*
     [ 1.1i     0.6+0.5i ]
@@ -310,10 +310,10 @@ static int zrowprodaTest(void) {
   for (i = 0 ; i < 2 ; ++i) {
     printf("rowProductedIn_6_2[%d] = %e + %ei\n", i, zreals(rowProductedIn_6_2[i]), zimags(rowProductedIn_6_2[i]));
   }
-  assert(fabs(zreals(rowProductedIn_6_2[0]) - 0.1725900000000000766853) < 1e-06);
-  assert(fabs(zimags(rowProductedIn_6_2[0]) - 0.5204650000000000664713) < 1e-06);
-  assert(fabs(zreals(rowProductedIn_6_2[1]) + 0.1725899999999999934186) < 1e-06);
-  assert(fabs(zimags(rowProductedIn_6_2[1]) - 0.5204649999999999554490 ) < 1e-06);
+  assert(fabs(zreals(rowProductedIn_6_2[0]) - 0.1725900000000000766853) < 3e-16);
+  assert(fabs(zimags(rowProductedIn_6_2[0]) - 0.5204650000000000664713) < 3e-16);
+  assert(fabs(zreals(rowProductedIn_6_2[1]) + 0.1725899999999999934186) < 3e-16);
+  assert(fabs(zimags(rowProductedIn_6_2[1]) - 0.5204649999999999554490 ) < 3e-16);
 
   /*
     [ 1.1i  0.2+0.9i 0.4+0.7i 0.6+0.5i 0.8+0.3i 1+0.1i ]
@@ -328,18 +328,18 @@ static int zrowprodaTest(void) {
   for (i = 0 ; i < 6 ; ++i) {
     printf("rowProductedIn_2_6[%d] = %e + %ei\n", i, zreals(rowProductedIn_2_6[i]), zimags(rowProductedIn_2_6[i]));
   }
-  assert(fabs(zreals(rowProductedIn_2_6[0]) + 1.1000000000000000888178) < 1e-06);
-  assert(fabs(zimags(rowProductedIn_2_6[0]) - 0.11) < 1e-06);
-  assert(fabs(zreals(rowProductedIn_2_6[1]) + 0.6600000000000001421086) < 1e-06);
-  assert(fabs(zimags(rowProductedIn_2_6[1]) - 0.4300000000000000488498 ) < 1e-06);
-  assert(fabs(zreals(rowProductedIn_2_6[2]) + 0.2199999999999999733547) < 1e-06);
-  assert(fabs(zimags(rowProductedIn_2_6[2]) - 0.5899999999999999689138) < 1e-06);
-  assert(fabs(zreals(rowProductedIn_2_6[3]) - 0.2199999999999999733547) < 1e-06);
-  assert(fabs(zimags(rowProductedIn_2_6[3]) - 0.5899999999999999689138 ) < 1e-06);
-  assert(fabs(zreals(rowProductedIn_2_6[4]) - 0.6600000000000001421086) < 1e-06);
-  assert(fabs(zimags(rowProductedIn_2_6[4]) - 0.4300000000000000488498) < 1e-06);
-  assert(fabs(zreals(rowProductedIn_2_6[5]) - 1.1000000000000000888178) < 1e-06);
-  assert(fabs(zimags(rowProductedIn_2_6[5]) - 0.11 ) < 1e-06);
+  assert(fabs(zreals(rowProductedIn_2_6[0]) + 1.1000000000000000888178) < 3e-16);
+  assert(fabs(zimags(rowProductedIn_2_6[0]) - 0.11) < 3e-16);
+  assert(fabs(zreals(rowProductedIn_2_6[1]) + 0.6600000000000001421086) < 3e-16);
+  assert(fabs(zimags(rowProductedIn_2_6[1]) - 0.4300000000000000488498 ) < 3e-16);
+  assert(fabs(zreals(rowProductedIn_2_6[2]) + 0.2199999999999999733547) < 3e-16);
+  assert(fabs(zimags(rowProductedIn_2_6[2]) - 0.5899999999999999689138) < 3e-16);
+  assert(fabs(zreals(rowProductedIn_2_6[3]) - 0.2199999999999999733547) < 3e-16);
+  assert(fabs(zimags(rowProductedIn_2_6[3]) - 0.5899999999999999689138 ) < 3e-16);
+  assert(fabs(zreals(rowProductedIn_2_6[4]) - 0.6600000000000001421086) < 3e-16);
+  assert(fabs(zimags(rowProductedIn_2_6[4]) - 0.4300000000000000488498) < 3e-16);
+  assert(fabs(zreals(rowProductedIn_2_6[5]) - 1.1000000000000000888178) < 3e-16);
+  assert(fabs(zimags(rowProductedIn_2_6[5]) - 0.11 ) < 3e-16);
 
   /*
     [ 1.1i 0.1+i 0.2+0.9i  0.3+0.8i 0.4+0.7i 0.5+0.6i 0.6+0.5i 0.7+0.4i 0.8+0.3i 0.9+0.2i 1+0.1i 1.1 ]
@@ -369,8 +369,8 @@ static int zrowprodaTest(void) {
   */
   zrowproda(in, 12, 1, rowProductedIn_12_1);
   printf("rowProductedIn_12_1[%d] = %e + %ei\n", 0, zreals(rowProductedIn_12_1[0]), zimags(rowProductedIn_12_1[0]));
-  assert(fabs(zreals(rowProductedIn_12_1[0]) + 0.3006711243250001497351) < 1e-06);
-  assert(fabs(zimags(rowProductedIn_12_1[0]) - 0.0000000000000000038164) < 1e-06);
+  assert(fabs(zreals(rowProductedIn_12_1[0]) + 0.3006711243250001497351) < 3e-16);
+  assert(fabs(zimags(rowProductedIn_12_1[0]) - 0.0000000000000000038164) < 3e-16);
 
   return 0;
 }
@@ -402,14 +402,14 @@ static int zcolumnprodaTest(void) {
   for (i = 0 ; i < 4 ; ++i) {
     printf("columnProductedIn_4_3[%d] = %e + %ei\n", i, zreals(columnProductedIn_4_3[i]), zimags(columnProductedIn_4_3[i]));
   }
-  assert(fabs(zreals(columnProductedIn_4_3[0]) + 0.7480000000000001092460) < 1e-06);
-  assert(fabs(zimags(columnProductedIn_4_3[0]) - 0.1210000000000001074696) < 1e-06);
-  assert(fabs(zreals(columnProductedIn_4_3[1]) + 0.6069999999999999840128) < 1e-06);
-  assert(fabs(zimags(columnProductedIn_4_3[1]) - 0.394000000000000127897) < 1e-06);
-  assert(fabs(zreals(columnProductedIn_4_3[2]) + 0.3940000000000000168754) < 1e-06);
-  assert(fabs(zimags(columnProductedIn_4_3[2]) - 0.606999999999999984012) < 1e-06);
-  assert(fabs(zreals(columnProductedIn_4_3[3]) + 0.1210000000000000935918) < 1e-06);
-  assert(fabs(zimags(columnProductedIn_4_3[3]) - 0.7479999999999999982236) < 1e-06);
+  assert(fabs(zreals(columnProductedIn_4_3[0]) + 0.7480000000000001092460) < 3e-16);
+  assert(fabs(zimags(columnProductedIn_4_3[0]) - 0.1210000000000001074696) < 3e-16);
+  assert(fabs(zreals(columnProductedIn_4_3[1]) + 0.6069999999999999840128) < 3e-16);
+  assert(fabs(zimags(columnProductedIn_4_3[1]) - 0.394000000000000127897) < 3e-16);
+  assert(fabs(zreals(columnProductedIn_4_3[2]) + 0.3940000000000000168754) < 3e-16);
+  assert(fabs(zimags(columnProductedIn_4_3[2]) - 0.606999999999999984012) < 3e-16);
+  assert(fabs(zreals(columnProductedIn_4_3[3]) + 0.1210000000000000935918) < 3e-16);
+  assert(fabs(zimags(columnProductedIn_4_3[3]) - 0.7479999999999999982236) < 3e-16);
 
   /*
     [ 1.1i     0.3+0.8i  0.6+0.5i 0.9+0.2i ]    [ - 0.5753000000000000335731 - 0.3564000000000000500933i ]  
@@ -420,12 +420,12 @@ static int zcolumnprodaTest(void) {
   for (i = 0 ; i < 3 ; ++i) {
     printf("columnProductedIn_3_4[%d] = %e + %ei\n", i, zreals(columnProductedIn_3_4[i]), zimags(columnProductedIn_3_4[i]));
   }
-  assert(fabs(zreals(columnProductedIn_3_4[0]) + 0.5753000000000000335731) < 1e-06);
-  assert(fabs(zimags(columnProductedIn_3_4[0]) + 0.3564000000000000500933) < 1e-06);
-  assert(fabs(zreals(columnProductedIn_3_4[1]) + 0.6564999999999998614442) < 1e-06);
-  assert(fabs(zimags(columnProductedIn_3_4[1]) - 0.0000000000000000693889) < 1e-06);
-  assert(fabs(zreals(columnProductedIn_3_4[2]) + 0.5753000000000001445955) < 1e-06);
-  assert(fabs(zimags(columnProductedIn_3_4[2]) - 0.3564000000000001056044) < 1e-06);
+  assert(fabs(zreals(columnProductedIn_3_4[0]) + 0.5753000000000000335731) < 3e-16);
+  assert(fabs(zimags(columnProductedIn_3_4[0]) + 0.3564000000000000500933) < 3e-16);
+  assert(fabs(zreals(columnProductedIn_3_4[1]) + 0.6564999999999998614442) < 3e-16);
+  assert(fabs(zimags(columnProductedIn_3_4[1]) - 0.0000000000000000693889) < 3e-16);
+  assert(fabs(zreals(columnProductedIn_3_4[2]) + 0.5753000000000001445955) < 3e-16);
+  assert(fabs(zimags(columnProductedIn_3_4[2]) - 0.3564000000000001056044) < 3e-16);
 
   /*
     [ 1.1i     0.6+0.5i ]    [ - 0.5500000000000000444089 + 0.6600000000000000310862i ]
@@ -439,18 +439,18 @@ static int zcolumnprodaTest(void) {
   for (i = 0 ; i < 6 ; ++i) {
     printf("columnProductedIn_6_2[%d] = %e + %ei\n", i, zreals(columnProductedIn_6_2[i]), zimags(columnProductedIn_6_2[i]));
   }
-  assert(fabs(zreals(columnProductedIn_6_2[0]) + 0.5500000000000000444089) < 1e-06);
-  assert(fabs(zimags(columnProductedIn_6_2[0]) - 0.6600000000000000310862) < 1e-06);
-  assert(fabs(zreals(columnProductedIn_6_2[1]) + 0.3300000000000000155431) < 1e-06);
-  assert(fabs(zimags(columnProductedIn_6_2[1]) - 0.7399999999999999911182) < 1e-06);
-  assert(fabs(zreals(columnProductedIn_6_2[2]) + 0.1099999999999999866773) < 1e-06);
-  assert(fabs(zimags(columnProductedIn_6_2[2]) - 0.7800000000000000266454) < 1e-06);
-  assert(fabs(zreals(columnProductedIn_6_2[3]) - 0.1099999999999999866773) < 1e-06);
-  assert(fabs(zimags(columnProductedIn_6_2[3]) - 0.7800000000000000266454) < 1e-06);
-  assert(fabs(zreals(columnProductedIn_6_2[4]) - 0.3300000000000000155431) < 1e-06);
-  assert(fabs(zimags(columnProductedIn_6_2[4]) - 0.7399999999999999911182) < 1e-06);
-  assert(fabs(zreals(columnProductedIn_6_2[5]) - 0.5500000000000000444089) < 1e-06);
-  assert(fabs(zimags(columnProductedIn_6_2[5]) - 0.6600000000000000310862) < 1e-06);
+  assert(fabs(zreals(columnProductedIn_6_2[0]) + 0.5500000000000000444089) < 3e-16);
+  assert(fabs(zimags(columnProductedIn_6_2[0]) - 0.6600000000000000310862) < 3e-16);
+  assert(fabs(zreals(columnProductedIn_6_2[1]) + 0.3300000000000000155431) < 3e-16);
+  assert(fabs(zimags(columnProductedIn_6_2[1]) - 0.7399999999999999911182) < 3e-16);
+  assert(fabs(zreals(columnProductedIn_6_2[2]) + 0.1099999999999999866773) < 3e-16);
+  assert(fabs(zimags(columnProductedIn_6_2[2]) - 0.7800000000000000266454) < 3e-16);
+  assert(fabs(zreals(columnProductedIn_6_2[3]) - 0.1099999999999999866773) < 3e-16);
+  assert(fabs(zimags(columnProductedIn_6_2[3]) - 0.7800000000000000266454) < 3e-16);
+  assert(fabs(zreals(columnProductedIn_6_2[4]) - 0.3300000000000000155431) < 3e-16);
+  assert(fabs(zimags(columnProductedIn_6_2[4]) - 0.7399999999999999911182) < 3e-16);
+  assert(fabs(zreals(columnProductedIn_6_2[5]) - 0.5500000000000000444089) < 3e-16);
+  assert(fabs(zimags(columnProductedIn_6_2[5]) - 0.6600000000000000310862) < 3e-16);
 
   /*
     [ 1.1i  0.2+0.9i 0.4+0.7i 0.6+0.5i 0.8+0.3i 1+0.1i ]    [   0.2212649999999999894662 - 0.5017100000000001003286i ]
@@ -460,10 +460,10 @@ static int zcolumnprodaTest(void) {
   for (i = 0 ; i < 2 ; ++i) {
     printf("columnProductedIn_2_6[%d] = %e + %ei\n", i, zreals(columnProductedIn_2_6[i]), zimags(columnProductedIn_2_6[i]));
   }
-  assert(fabs(zreals(columnProductedIn_2_6[0]) - 0.2212649999999999894662) < 1e-06);
-  assert(fabs(zimags(columnProductedIn_2_6[0]) + 0.5017100000000001003286) < 1e-06);
-  assert(fabs(zreals(columnProductedIn_2_6[1]) + 0.2212649999999999894662) < 1e-06);
-  assert(fabs(zimags(columnProductedIn_2_6[1]) + 0.5017100000000001003286) < 1e-06);
+  assert(fabs(zreals(columnProductedIn_2_6[0]) - 0.2212649999999999894662) < 3e-16);
+  assert(fabs(zimags(columnProductedIn_2_6[0]) + 0.5017100000000001003286) < 3e-16);
+  assert(fabs(zreals(columnProductedIn_2_6[1]) + 0.2212649999999999894662) < 3e-16);
+  assert(fabs(zimags(columnProductedIn_2_6[1]) + 0.5017100000000001003286) < 3e-16);
 
   /*
   [ 1.1i 0.1+i 0.2+0.9i  0.3+0.8i 0.4+0.7i 0.5+0.6i 0.6+0.5i 0.7+0.4i 0.8+0.3i 0.9+0.2i 1+0.1i 1.1 ]
@@ -472,8 +472,8 @@ static int zcolumnprodaTest(void) {
   */
   zcolumnproda(in, 1, 12, columnProductedIn_1_12);
   printf("columnProductedIn_1_12[%d] = %e + %ei\n", 0, zreals(columnProductedIn_1_12[0]), zimags(columnProductedIn_1_12[0]));
-  assert(fabs(zreals(columnProductedIn_1_12[0]) + 0.3006711243250001497351) < 1e-06);
-  assert(fabs(zimags(columnProductedIn_1_12[0]) - 0.0000000000000000038164) < 1e-06);
+  assert(fabs(zreals(columnProductedIn_1_12[0]) + 0.3006711243250001497351) < 3e-16);
+  assert(fabs(zimags(columnProductedIn_1_12[0]) - 0.0000000000000000038164) < 3e-16);
 
 
   /*
diff --git a/scilab2c/src/statisticsFunctions/prod/testFloatProd.c b/scilab2c/src/statisticsFunctions/prod/testFloatProd.c
index 324f2ea4..b5fe20c4 100644
--- a/scilab2c/src/statisticsFunctions/prod/testFloatProd.c
+++ b/scilab2c/src/statisticsFunctions/prod/testFloatProd.c
@@ -208,7 +208,7 @@ static int cprodsTest(void) {
   return 0;
 }
 
-static int cprodaTest(void) {/*
+static int cprodaTest(void) {
   floatComplex value1 = FloatComplex(3.0f, 3.0f);
   floatComplex table1[3];
   floatComplex value2 = FloatComplex(9.186784563f,9.186784563f);
@@ -237,9 +237,9 @@ static int cprodaTest(void) {/*
 
   assert(creals(cproda(table1, 3)) == -54.0f);
   assert(cimags(cproda(table1, 3)) == 54.0f);
-  assert(fabs(creals(cproda(table2, 5)) + 261744.55211053110542707f) < 1e-06);
-  assert(fabs(cimags(cproda(table2, 5)) + 261744.55211053110542707f) < 1e-06);
-*/
+  assert(fabs(creals(cproda(table2, 5)) + 261744.55211053110542707f)/creals(cproda(table2, 5)) < 1e-06);
+  assert(fabs(cimags(cproda(table2, 5)) + 261744.55211053110542707f)/cimags(cproda(table2, 5)) < 1e-06);
+
   return 0;
 }
 
diff --git a/scilab2c/src/statisticsFunctions/sum/testDoubleSum.c b/scilab2c/src/statisticsFunctions/sum/testDoubleSum.c
index d8a57fe6..e00ec0ec 100644
--- a/scilab2c/src/statisticsFunctions/sum/testDoubleSum.c
+++ b/scilab2c/src/statisticsFunctions/sum/testDoubleSum.c
@@ -40,7 +40,7 @@ static int dsumaTest(void) {
 
   printf("\n>>>> Sum Double Array Test\n");
   assert(dsuma(table1, 3) == 9.0);
-  assert((dsuma(table2, 5) - (9.186784 + 9.186784 + 9.186784 + 9.186784 + 9.186784)) / dsuma(table2, 5) < 1e-6);
+  assert((dsuma(table2, 5) - (9.186784 + 9.186784 + 9.186784 + 9.186784 + 9.186784)) / dsuma(table2, 5) < 3e-16);
   return 0;
 }
 
diff --git a/scilab2c/src/statisticsFunctions/variance/testDoubleVariance.c b/scilab2c/src/statisticsFunctions/variance/testDoubleVariance.c
index 16320479..b85a1571 100644
--- a/scilab2c/src/statisticsFunctions/variance/testDoubleVariance.c
+++ b/scilab2c/src/statisticsFunctions/variance/testDoubleVariance.c
@@ -170,7 +170,7 @@ static void  dvarianceaTest ( void){
     
 
     
-    assert ( fabs ( out - result ) / fabs( out ) < 1e-15 ) ;
+    assert ( fabs ( out - result ) / fabs( out ) < 3e-16 ) ;
     
 }
 
@@ -188,7 +188,7 @@ static void drowvarianceaTest ( void )
     for ( i = 0 ; i < LINES ; i++)
     {
             printf ( "ROWout : %1.20f\t result : %1.20f\t\n" , out[i] , result [i] ) ; 
-           assert ( fabs ( out[i] - result[i] ) / fabs( out[i] ) < 1e-15 ) ;
+           assert ( fabs ( out[i] - result[i] ) / fabs( out[i] ) < 3e-16 ) ;
     }
     
 }
@@ -210,7 +210,7 @@ static void dcolumnvarianceaTest ( void )
             printf ( "%dCOLout : %1.20f\t result : %1.20f\t\n" ,i, out[i] , result [i] ) ;  } 
      for ( i = 0 ; i <  COLUMNS; i++)
     {
-          assert ( fabs ( out[i] - result[i] ) / fabs( out[i] ) < 1e-15 ) ;
+          assert ( fabs ( out[i] - result[i] ) / fabs( out[i] ) < 3e-16 ) ;
     }
     
 }
@@ -227,8 +227,8 @@ static void  zvarianceaTest ( void){
     doubleComplex* mtoTest = DoubleComplexMatrix ( rmtoTest , imtoTest , LINES*COLUMNS ) ;
     doubleComplex out = zvariancea ( mtoTest ,  LINES*COLUMNS );  ;
     
-            assert ( fabs(  zreals(out) -  zreals (Result) ) / fabs (zreals (out)) < 1e-11 );
-            assert(  fabs(  zimags(out) -  zimags (Result )) / fabs (zimags (out)) < 1e-11 );
+            assert ( fabs(  zreals(out) -  zreals (Result) ) / fabs (zreals (out)) < 3e-16 );
+            assert(  fabs(  zimags(out) -  zimags (Result )) / fabs (zimags (out)) < 3e-16 );
 
     
 }
@@ -252,8 +252,8 @@ static void zrowvarianceaTest (void ) {
     for ( i = 0 ; i < COLUMNS ; i++)
     {
         printf ( "%d out : %e  %e \t result %e %e \n" , i , zreals(out[i])  , zimags(out[i]), zreals(Result[i]) ,zimags( Result[i]));
-        assert ( fabs(  zreals(out[i]) -  zreals (Result[i]) ) / fabs (zreals (out[i])) < 1e-04 );
-        assert(  fabs(  zimags(out[i]) -  zimags (Result[i])) / fabs (zimags (out[i])) < 1e-04);
+        assert ( fabs(  zreals(out[i]) -  zreals (Result[i]) ) / fabs (zreals (out[i])) < 3e-16 );
+        assert(  fabs(  zimags(out[i]) -  zimags (Result[i])) / fabs (zimags (out[i])) < 3e-16);
       
     }
 }
@@ -278,8 +278,8 @@ static void zcolumnvarianceaTest ( void) {
     for ( i = 0 ; i < LINES ; i++)
     {
         printf ( "%d out : %e  %e \t result %e %e \n" , i , zreals(out[i])  , zimags(out[i]), zreals(Result[i]) ,zimags( Result[i]));
-        assert ( fabs(  zreals(out[i]) -  zreals (Result[i]) ) / fabs (zreals (out[i])) < 1e-11 );
-        assert(  fabs(  zimags(out[i]) -  zimags (Result[i])) / fabs (zimags (out[i])) < 1e-11);
+        assert ( fabs(  zreals(out[i]) -  zreals (Result[i]) ) / fabs (zreals (out[i])) < 3e-16 );
+        assert(  fabs(  zimags(out[i]) -  zimags (Result[i])) / fabs (zimags (out[i])) < 3e-16);
       
     }
     
diff --git a/scilab2c/src/statisticsFunctions/variance/testDoubleVarianceNono.c b/scilab2c/src/statisticsFunctions/variance/testDoubleVarianceNono.c
index 92f76b81..fd82a5a2 100644
--- a/scilab2c/src/statisticsFunctions/variance/testDoubleVarianceNono.c
+++ b/scilab2c/src/statisticsFunctions/variance/testDoubleVarianceNono.c
@@ -163,8 +163,8 @@ static int doubleComplexVariance(void){
 		printf("Variance \n");
 		printf("%f + %f *i\n",zreals(out),zimags(out));
 		
-		assert(fabs(zreals(out)-varianceR)/fabs(zreals(out)) <1e-15);
-		assert(fabs(zimags(out)-varianceI)/fabs(zimags(out)) <1e-15);
+		assert(fabs(zreals(out)-varianceR)/fabs(zreals(out)) <3e-16);
+		assert(fabs(zimags(out)-varianceI)/fabs(zimags(out)) <3e-16);
 		
 		
 		
@@ -176,8 +176,8 @@ static int doubleComplexVariance(void){
 			
 			
 		for (i=0;i<3;i++){
-			assert(fabs(zreals(outRow[i])-rowVarianceR[i])/fabs(zreals(outRow[i])) <1e-15);
-			assert(fabs(zimags(outRow[i])-rowVarianceI[i])/fabs(zimags(outRow[i])) <1e-14);
+			assert(fabs(zreals(outRow[i])-rowVarianceR[i])/fabs(zreals(outRow[i])) <3e-16);
+			assert(fabs(zimags(outRow[i])-rowVarianceI[i])/fabs(zimags(outRow[i])) <3e-16);
 		}
 		
 		
@@ -188,8 +188,8 @@ static int doubleComplexVariance(void){
 				
 		
 		for (i=0;i<2;i++){
-			assert(fabs(zreals(outCol[i])-colVarianceR[i])/fabs(zreals(outCol[i])) <1e-15);			
-			assert(fabs(zimags(outCol[i])-colVarianceI[i])/fabs(zimags(outCol[i])) <1e-15);			
+			assert(fabs(zreals(outCol[i])-colVarianceR[i])/fabs(zreals(outCol[i])) <3e-16);			
+			assert(fabs(zimags(outCol[i])-colVarianceI[i])/fabs(zimags(outCol[i])) <3e-16);			
 		}
 		
 		free(in);
@@ -304,8 +304,8 @@ static int doubleComplexVariance(void){
 		printf("Variance 2 \n");
 		printf("%f + %f *i\n",zreals(out),zimags(out));
 		
-		assert(fabs(zreals(out)-varianceR)/fabs(zreals(out)) <1e-15);
-		assert(fabs(zimags(out)-varianceI)/fabs(zimags(out)) <1e-15);
+		assert(fabs(zreals(out)-varianceR)/fabs(zreals(out)) <3e-16);
+		assert(fabs(zimags(out)-varianceI)/fabs(zimags(out)) <3e-16);
 		
 		
 		
@@ -317,8 +317,8 @@ static int doubleComplexVariance(void){
 			
 			
 		for (i=0;i<7;i++){
-			assert(fabs(zreals(outRow[i])-rowVarianceR[i])/fabs(zreals(outRow[i])) <1e-15);
-			assert(fabs(zimags(outRow[i])-rowVarianceI[i])/fabs(zimags(outRow[i])) <1e-13);
+			assert(fabs(zreals(outRow[i])-rowVarianceR[i])/fabs(zreals(outRow[i])) <3e-16);
+			assert(fabs(zimags(outRow[i])-rowVarianceI[i])/fabs(zimags(outRow[i])) <3e-16);
 		}
 		
 		
@@ -329,8 +329,8 @@ static int doubleComplexVariance(void){
 				
 		
 		for (i=0;i<10;i++){
-			assert(fabs(zreals(outCol[i])-colVarianceR[i])/fabs(zreals(outCol[i])) <1e-15);			
-			assert(fabs(zimags(outCol[i])-colVarianceI[i])/fabs(zimags(outCol[i])) <1e-14);			
+			assert(fabs(zreals(outCol[i])-colVarianceR[i])/fabs(zreals(outCol[i])) <3e-16);			
+			assert(fabs(zimags(outCol[i])-colVarianceI[i])/fabs(zimags(outCol[i])) <3e-16);			
 		}
 		free(in);
 		free(outCol);
diff --git a/scilab2c/src/statisticsFunctions/variance/testFloatVariance.c b/scilab2c/src/statisticsFunctions/variance/testFloatVariance.c
index ec98387b..97b56d4d 100644
--- a/scilab2c/src/statisticsFunctions/variance/testFloatVariance.c
+++ b/scilab2c/src/statisticsFunctions/variance/testFloatVariance.c
@@ -247,8 +247,8 @@ static void crowvarianceaTest (void ) {
     for ( i = 0 ; i < COLUMNS ; i++)
     {
         printf ( "%d out : %e  %e \t result %e %e \n" , i , creals(out[i])  , cimags(out[i]), creals(Result[i]) ,cimags( Result[i]));
-        assert ( fabs(  creals(out[i]) -  creals (Result[i]) ) / fabs (creals (out[i])) < 1e-04 );
-        assert(  fabs(  cimags(out[i]) -  cimags (Result[i])) / fabs (cimags (out[i])) < 1e-04);
+        assert ( fabs(  creals(out[i]) -  creals (Result[i]) ) / fabs (creals (out[i])) < 3e-6 );
+        assert(  fabs(  cimags(out[i]) -  cimags (Result[i])) / fabs (cimags (out[i])) < 3e-6);
       
     }
 }
diff --git a/scilab2c/src/statisticsFunctions/variance/testFloatVarianceNono.c b/scilab2c/src/statisticsFunctions/variance/testFloatVarianceNono.c
index 71c9b859..9880f923 100644
--- a/scilab2c/src/statisticsFunctions/variance/testFloatVarianceNono.c
+++ b/scilab2c/src/statisticsFunctions/variance/testFloatVarianceNono.c
@@ -177,7 +177,7 @@ static int floatComplexVariance(void){
 			
 		for (i=0;i<3;i++){
 			assert(fabs(creals(outRow[i])-rowVarianceR[i])/fabs(creals(outRow[i])) <1e-6);
-			assert(fabs(cimags(outRow[i])-rowVarianceI[i])/fabs(cimags(outRow[i])) <1e-5);
+			assert(fabs(cimags(outRow[i])-rowVarianceI[i])/fabs(cimags(outRow[i])) <3e-6);
 		}
 		
 		
@@ -189,7 +189,7 @@ static int floatComplexVariance(void){
 		
 		for (i=0;i<2;i++){
 			assert(fabs(creals(outCol[i])-colVarianceR[i])/fabs(creals(outCol[i])) <1e-6);			
-			assert(fabs(cimags(outCol[i])-colVarianceI[i])/fabs(cimags(outCol[i])) <1e-5);			
+			assert(fabs(cimags(outCol[i])-colVarianceI[i])/fabs(cimags(outCol[i])) <3e-6);			
 		}
 		
 		free(in);
@@ -306,7 +306,7 @@ static int floatComplexVariance(void){
 		printf("%f + %f *i\n",creals(out),cimags(out));
 		
 		assert(fabs(creals(out)-varianceR)/fabs(creals(out)) <1e-6);
-		assert(fabs(cimags(out)-varianceI)/fabs(cimags(out)) <1e-5);
+		assert(fabs(cimags(out)-varianceI)/fabs(cimags(out)) <3e-6);
 		
 		
 		
@@ -319,7 +319,7 @@ static int floatComplexVariance(void){
 			
 		for (i=0;i<7;i++){
 			assert(fabs(creals(outRow[i])-rowVarianceR[i])/fabs(creals(outRow[i])) <1e-6);
-			assert(fabs(cimags(outRow[i])-rowVarianceI[i])/fabs(cimags(outRow[i])) <1e-4);
+			assert(fabs(cimags(outRow[i])-rowVarianceI[i])/fabs(cimags(outRow[i])) <3e-6);
 		}
 		
 		
@@ -331,7 +331,7 @@ static int floatComplexVariance(void){
 		
 		for (i=0;i<10;i++){
 			assert(fabs(creals(outCol[i])-colVarianceR[i])/fabs(creals(outCol[i])) <1e-6);			
-			assert(fabs(cimags(outCol[i])-colVarianceI[i])/fabs(cimags(outCol[i])) <1e-5);			
+			assert(fabs(cimags(outCol[i])-colVarianceI[i])/fabs(cimags(outCol[i])) <3e-6);			
 		}
 		
 		free(in);