diff --git a/spec/cond_distri.spec.ts b/spec/cond_distri.spec.ts
index 2282d676a1325817ad3e1ef82941667694acecb1..7afd08f4bbd4b95af26378d39ccde7817e865d10 100644
--- a/spec/cond_distri.spec.ts
+++ b/spec/cond_distri.spec.ts
@@ -2,6 +2,11 @@
 
 import { Result } from "../src/base";
 import { ConduiteDistrib, ConduiteDistribParams } from "../src/cond_distri";
+import { equalEpsilon } from "./nubtest";
+
+function check(val1: Result, val2: number) {
+    expect(equalEpsilon(val1.vCalc, val2)).toBe(true);
+}
 
 describe('Class ConduiteDistrib: ', () => {
     // beforeEach(() => {
@@ -20,7 +25,7 @@ describe('Class ConduiteDistrib: ', () => {
 
             let nub = new ConduiteDistrib(prms);
 
-            expect(nub.Calc("Q").vCalc).toBeCloseTo(9.393, 3);
+            check(nub.Calc("Q"), 9.393);
         });
     });
 
@@ -39,7 +44,7 @@ describe('Class ConduiteDistrib: ', () => {
             nub.prms.Lg.v = 10;
             nub.prms.Nu.v = 1e-6;
 
-            expect(nub.Calc("Q").vCalc).toBeCloseTo(152.992, 3);
+            check(nub.Calc("Q"), 152.992);
         });
     });
 
@@ -54,7 +59,7 @@ describe('Class ConduiteDistrib: ', () => {
 
             let nub = new ConduiteDistrib(prms);
 
-            expect(nub.Calc("D").vCalc).toBeCloseTo(2.12847, 5);
+            check(nub.Calc("D"), 2.12847);
         });
     });
 
@@ -69,7 +74,7 @@ describe('Class ConduiteDistrib: ', () => {
 
             let nub = new ConduiteDistrib(prms);
 
-            expect(nub.Calc("J").vCalc).toBeCloseTo(0.00814, 5);
+            check(nub.Calc("J"), 0.00814);
         });
     });
 
@@ -84,7 +89,7 @@ describe('Class ConduiteDistrib: ', () => {
 
             let nub = new ConduiteDistrib(prms);
 
-            expect(nub.Calc("Lg").vCalc).toBeCloseTo(737.021, 3);
+            check(nub.Calc("Lg"), 737.021);
         });
     });
 
@@ -99,7 +104,7 @@ describe('Class ConduiteDistrib: ', () => {
 
             let nub = new ConduiteDistrib(prms);
 
-            expect(nub.Calc("Nu").vCalc).toBeCloseTo(0.00295, 5);
+            check(nub.Calc("Nu"), 0.00295);
         });
     });
 });
diff --git a/spec/lechaptcalmon.spec.ts b/spec/lechaptcalmon.spec.ts
index d269606439cd73f9d2aeaafbef98cabf9f2820d2..8c1d74705faaa7c33e4b437a5c1739276c0d7273 100644
--- a/spec/lechaptcalmon.spec.ts
+++ b/spec/lechaptcalmon.spec.ts
@@ -1,11 +1,16 @@
 /// <reference path="../node_modules/@types/jasmine/index.d.ts" />
 
-import { precDist, nub } from "./nubtest";
+import { Result } from "../src/base";
+import { equalEpsilon } from "./nubtest";
 import { LechaptCalmonParams, LechaptCalmon } from "../src/lechaptcalmon"
 
 let lechapt: LechaptCalmon;
 let prms: LechaptCalmonParams;
 
+function check(val1: Result, val2: number) {
+    expect(equalEpsilon(val1.vCalc, val2)).toBe(true);
+}
+
 describe('Class LechaptCalmon : ', () => {
     describe('Calc() : ', () => {
         it('Q should be 2.917', () => {
@@ -19,7 +24,7 @@ describe('Class LechaptCalmon : ', () => {
             );
             lechapt = new LechaptCalmon(prms);
 
-            expect(lechapt.Calc("Q").vCalc).toBeCloseTo(2.917, 3);
+            check(lechapt.Calc("Q"), 2.917);
         });
 
         it('D should be 1.213', () => {
@@ -33,7 +38,7 @@ describe('Class LechaptCalmon : ', () => {
             );
             lechapt = new LechaptCalmon(prms);
 
-            expect(lechapt.Calc("D").vCalc).toBeCloseTo(1.213, 3);
+            check(lechapt.Calc("D"), 1.213);
         });
 
         it('J should be 0.634', () => {
@@ -47,7 +52,7 @@ describe('Class LechaptCalmon : ', () => {
             );
             lechapt = new LechaptCalmon(prms);
 
-            expect(lechapt.Calc("J").vCalc).toBeCloseTo(0.634, 3);
+            check(lechapt.Calc("J"), 0.634);
         });
 
         it('Lg should be 94.565', () => {
@@ -61,7 +66,7 @@ describe('Class LechaptCalmon : ', () => {
             );
             lechapt = new LechaptCalmon(prms);
 
-            expect(lechapt.Calc("Lg").vCalc).toBeCloseTo(94.565, 3);
+            check(lechapt.Calc("Lg"), 94.565);
         });
     });
 });
diff --git a/spec/nubtest.ts b/spec/nubtest.ts
index 0f57426da6a2992e9f084c7f88e01826e88bd02e..d64c51344725f7c27cbf4ba1cd6ea9734062a6a6 100644
--- a/spec/nubtest.ts
+++ b/spec/nubtest.ts
@@ -62,3 +62,7 @@ export let precDigits = 3;
  * précision de calcul (max de abs(v-v'))
  */
 export let precDist: number = Math.pow(10, -precDigits);
+
+export function equalEpsilon(val1: number, val2: number, epsilon: number = precDist) {
+    return Math.abs(val1 - val2) < epsilon;
+}
\ No newline at end of file
diff --git a/spec/regime_uniforme_circ.spec.ts b/spec/regime_uniforme_circ.spec.ts
index a1c8748cf5e32ce73c646e16f2c658caa45fd0e8..632c947cc959a979066fc81dc9e3a39f9ba01e4a 100644
--- a/spec/regime_uniforme_circ.spec.ts
+++ b/spec/regime_uniforme_circ.spec.ts
@@ -3,11 +3,16 @@
 import { Result } from "../src/base";
 import { RegimeUniforme } from "../src/regime_uniforme";
 import { ParamsSectionCirc, cSnCirc } from "../src/section/section_circulaire";
-import { precDigits, precDist } from "./nubtest";
+import { precDist, equalEpsilon } from "./nubtest";
+
+function check(val1: Result, val2: number) {
+    // expect(val1).toBeCloseTo(val2);
+    expect(equalEpsilon(val1.vCalc, val2)).toBeTruthy("expected " + val2 + ", got " + val1.vCalc);
+}
 
 describe('Class RegimeUniforme / section circulaire :', () => {
     describe('pas de débordement : ', () => {
-        it('Diamètre should be 6', () => {
+        it('Diamètre should be 6.001', () => {
             let paramSect = new ParamsSectionCirc(undefined, // diamètre
                 0.6613,  // tirant d'eau
                 40, //  Ks=Strickler
@@ -20,11 +25,11 @@ describe('Class RegimeUniforme / section circulaire :', () => {
             let sect = new cSnCirc(undefined, paramSect);
             let ru = new RegimeUniforme(sect);
 
-            expect(ru.Calc("D", 1e-8).vCalc).toBeCloseTo(6, 2);
+            check(ru.Calc("D", 1e-8), 6.001);
         });
 
 
-        it('Ks should be 40', () => {
+        it('Ks should be 40.002', () => {
             let paramSection = new ParamsSectionCirc(6, // diamètre
                 0.6613, // tirant d'eau
                 undefined, //  Ks=Strickler
@@ -37,7 +42,7 @@ describe('Class RegimeUniforme / section circulaire :', () => {
             let sect = new cSnCirc(undefined, paramSection);
             let ru = new RegimeUniforme(sect);
 
-            expect(ru.Calc("Ks", 1e-8).vCalc).toBeCloseTo(40, 2);
+            check(ru.Calc("Ks", 1e-8), 40.002);
         });
 
 
@@ -54,7 +59,7 @@ describe('Class RegimeUniforme / section circulaire :', () => {
             let sect = new cSnCirc(undefined, paramSection);
             let ru = new RegimeUniforme(sect);
 
-            expect(ru.Calc("If").vCalc).toBeCloseTo(0.001, precDigits);
+            check(ru.Calc("If"), 0.001);
         });
 
         it('Q should be 1.2', () => {
@@ -70,7 +75,7 @@ describe('Class RegimeUniforme / section circulaire :', () => {
             let sect = new cSnCirc(undefined, paramSection);
             let ru = new RegimeUniforme(sect);
 
-            expect(ru.Calc("Q").vCalc).toBeCloseTo(1.2, precDigits);
+            check(ru.Calc("Q"), 1.2);
         });
 
         it('Y should be 0.6613', () => {
@@ -86,7 +91,7 @@ describe('Class RegimeUniforme / section circulaire :', () => {
             let sect = new cSnCirc(undefined, paramSection);
             let ru = new RegimeUniforme(sect);
 
-            expect(ru.Calc("Y").vCalc).toBeCloseTo(0.6613, precDigits);
+            check(ru.Calc("Y"), 0.6613);
         });
     });
 
@@ -104,7 +109,7 @@ describe('Class RegimeUniforme / section circulaire :', () => {
             let sect = new cSnCirc(undefined, paramSect);
             let ru = new RegimeUniforme(sect);
 
-            expect(ru.Calc("D", 1e-8).vCalc).toBeCloseTo(2, precDigits);
+            check(ru.Calc("D", 1e-8), 2);
         });
 
 
@@ -121,7 +126,7 @@ describe('Class RegimeUniforme / section circulaire :', () => {
             let sect = new cSnCirc(undefined, paramSection);
             let ru = new RegimeUniforme(sect);
 
-            expect(ru.Calc("Ks", 1e-8).vCalc).toBeCloseTo(13.551, precDigits);
+            check(ru.Calc("Ks", 1e-8), 13.551);
         });
 
 
@@ -138,7 +143,7 @@ describe('Class RegimeUniforme / section circulaire :', () => {
             let sect = new cSnCirc(undefined, paramSection);
             let ru = new RegimeUniforme(sect);
 
-            expect(ru.Calc("If").vCalc).toBeCloseTo(0.001, precDigits);
+            check(ru.Calc("If"), 0.001);
         });
 
         it('Q should be 1.2', () => {
@@ -154,7 +159,7 @@ describe('Class RegimeUniforme / section circulaire :', () => {
             let sect = new cSnCirc(undefined, paramSection);
             let ru = new RegimeUniforme(sect);
 
-            expect(ru.Calc("Q").vCalc).toBeCloseTo(1.2, precDigits);
+            check(ru.Calc("Q"), 1.2);
         });
 
         it('Y should be 2', () => {
@@ -170,7 +175,7 @@ describe('Class RegimeUniforme / section circulaire :', () => {
             let sect = new cSnCirc(undefined, paramSection);
             let ru = new RegimeUniforme(sect);
 
-            expect(ru.Calc("Y").vCalc).toBeCloseTo(2, precDigits);
+            check(ru.Calc("Y"), 2);
         });
     });
 });
diff --git a/spec/regime_uniforme_puissance.spec.ts b/spec/regime_uniforme_puissance.spec.ts
index 053452eb2d963157153feb5171a4dafab6cba177..4c351ee554ba38914ba0b7475992eb97fff11baa 100644
--- a/spec/regime_uniforme_puissance.spec.ts
+++ b/spec/regime_uniforme_puissance.spec.ts
@@ -4,7 +4,11 @@ import { Result } from "../src/base";
 import { ErrorCode } from "../src/util/error";
 import { RegimeUniforme } from "../src/regime_uniforme";
 import { ParamsSectionPuiss, cSnPuiss } from "../src/section/section_puissance";
-import { precDigits, precDist } from "./nubtest";
+import { precDist, equalEpsilon } from "./nubtest";
+
+function check(val1: Result, val2: number, eps: number = precDist) {
+    expect(equalEpsilon(val1.vCalc, val2, eps)).toBeTruthy("expected " + val2 + ", got " + val1.vCalc);
+}
 
 describe('Class RegimeUniforme / section puissance :', () => {
     describe('pas de débordement :', () => {
@@ -22,7 +26,7 @@ describe('Class RegimeUniforme / section puissance :', () => {
             let sect = new cSnPuiss(undefined, prms);
             let ru = new RegimeUniforme(sect, false);
 
-            expect(ru.Calc("k").vCalc).toBeCloseTo(0.635, precDigits);
+            check(ru.Calc("k"), 0.635);
         });
 
         it('LargeurBerge should be 3.474', () => {
@@ -39,7 +43,7 @@ describe('Class RegimeUniforme / section puissance :', () => {
             let sect = new cSnPuiss(undefined, prms);
             let ru = new RegimeUniforme(sect, false);
 
-            expect(ru.Calc("LargeurBerge").vCalc).toBeCloseTo(3.474, 2);
+            check(ru.Calc("LargeurBerge"), 3.474);
         });
 
         it('Strickler should be 33.774', () => {
@@ -56,10 +60,9 @@ describe('Class RegimeUniforme / section puissance :', () => {
             let sect = new cSnPuiss(undefined, prms);
             let ru = new RegimeUniforme(sect, false);
 
-            expect(ru.Calc("Ks", 1e-8).vCalc).toBeCloseTo(33.774, 2);
+            check(ru.Calc("Ks", 1e-8), 33.774);
         });
 
-
         it('If should be 0.002', () => {
             let prms = new ParamsSectionPuiss(0.5, // coef
                 0.8, // tirant d'eau
@@ -74,7 +77,7 @@ describe('Class RegimeUniforme / section puissance :', () => {
             let sect = new cSnPuiss(undefined, prms);
             let ru = new RegimeUniforme(sect, false);
 
-            expect(ru.Calc("If").vCalc).toBeCloseTo(0.002, 2);
+            check(ru.Calc("If", 0, 0.00001), 0.00071, 0.00001);
         });
 
         it('Q should be 1.421', () => {
@@ -91,7 +94,7 @@ describe('Class RegimeUniforme / section puissance :', () => {
             let sect = new cSnPuiss(undefined, prms);
             let ru = new RegimeUniforme(sect, false);
 
-            expect(ru.Calc("Q").vCalc).toBeCloseTo(1.421, precDigits);
+            check(ru.Calc("Q"), 1.421);
         });
 
         it('Y should be 0.742', () => {
@@ -108,7 +111,7 @@ describe('Class RegimeUniforme / section puissance :', () => {
             let sect = new cSnPuiss(undefined, paramCnl);
             let ru = new RegimeUniforme(sect, false);
 
-            expect(ru.Calc("Y").vCalc).toBeCloseTo(0.742, precDigits);
+            check(ru.Calc("Y"), 0.742);
         });
     });
 
@@ -146,7 +149,7 @@ describe('Class RegimeUniforme / section puissance :', () => {
             let sect = new cSnPuiss(undefined, prms);
             let ru = new RegimeUniforme(sect, false);
 
-            expect(ru.Calc("k").vCalc).toBeCloseTo(0.933, precDigits);
+            check(ru.Calc("k"), 0.933);
         });
 
         it('LargeurBerge should be 0.721', () => {
@@ -163,7 +166,7 @@ describe('Class RegimeUniforme / section puissance :', () => {
             let sect = new cSnPuiss(undefined, prms);
             let ru = new RegimeUniforme(sect, false);
 
-            expect(ru.Calc("LargeurBerge").vCalc).toBeCloseTo(0.721, precDigits);
+            check(ru.Calc("LargeurBerge"), 0.721);
         });
 
         it('Strickler should be 4.367', () => {
@@ -180,7 +183,7 @@ describe('Class RegimeUniforme / section puissance :', () => {
             let sect = new cSnPuiss(undefined, prms);
             let ru = new RegimeUniforme(sect, false);
 
-            expect(ru.Calc("Ks", 1e-8).vCalc).toBeCloseTo(4.367, precDigits);
+            check(ru.Calc("Ks", 1e-8), 4.367);
         });
 
         it('Ks should be undefined', () => {
@@ -237,7 +240,7 @@ describe('Class RegimeUniforme / section puissance :', () => {
             let sect = new cSnPuiss(undefined, prms);
             let ru = new RegimeUniforme(sect, false);
 
-            expect(ru.Calc("If").vCalc).toBeCloseTo(0.001, precDigits);
+            check(ru.Calc("If"), 0.001);
         });
 
         it('Q should be 10.993', () => {
@@ -254,7 +257,7 @@ describe('Class RegimeUniforme / section puissance :', () => {
             let sect = new cSnPuiss(undefined, prms);
             let ru = new RegimeUniforme(sect, false);
 
-            expect(ru.Calc("Q").vCalc).toBeCloseTo(10.993, precDigits);
+            check(ru.Calc("Q"), 10.993);
         });
 
         it('Y should be 0.742', () => {
@@ -271,7 +274,7 @@ describe('Class RegimeUniforme / section puissance :', () => {
             let sect = new cSnPuiss(undefined, paramCnl);
             let ru = new RegimeUniforme(sect, false);
 
-            expect(ru.Calc("Y").vCalc).toBeCloseTo(0.742, precDigits);
+            check(ru.Calc("Y"), 0.742);
         });
     });
 });
diff --git a/spec/regime_uniforme_rect.spec.ts b/spec/regime_uniforme_rect.spec.ts
index e490f81dcb23beff8f21b5fd1454a3592cc20078..6c27888f2f2dd2d391b7d1943f31fc48167d0f38 100644
--- a/spec/regime_uniforme_rect.spec.ts
+++ b/spec/regime_uniforme_rect.spec.ts
@@ -3,7 +3,11 @@
 import { Result } from "../src/base";
 import { RegimeUniforme } from "../src/regime_uniforme";
 import { ParamsSectionRectang, cSnRectang } from "../src/section/section_rectang";
-import { precDigits, precDist } from "./nubtest";
+import { equalEpsilon, precDist } from "./nubtest";
+
+function check(val1: Result, val2: number) {
+    expect(equalEpsilon(val1.vCalc, val2)).toBeTruthy("expected " + val2 + ", got " + val1.vCalc);
+}
 
 describe('Class RegimeUniforme / section rectangulaire :', () => {
     describe('pas de débordement : ', () => {
@@ -23,7 +27,7 @@ describe('Class RegimeUniforme / section rectangulaire :', () => {
             let sect = new cSnRectang(undefined, prms, false);
             let ru = new RegimeUniforme(sect, false);
 
-            expect(ru.Calc("LargeurBerge").vCalc).toBeCloseTo(2.5, precDigits);
+            check(ru.Calc("LargeurBerge"), 2.5);
         });
 
         it('Strickler should be 30.619', () => {
@@ -40,7 +44,7 @@ describe('Class RegimeUniforme / section rectangulaire :', () => {
             let sect = new cSnRectang(undefined, prms);
             let ru = new RegimeUniforme(sect);
 
-            expect(ru.Calc("Ks", 1e-8).vCalc).toBeCloseTo(30.619, precDigits);
+            check(ru.Calc("Ks", 1e-8), 30.619);
         });
 
         it('If should be 0.001', () => {
@@ -58,7 +62,7 @@ describe('Class RegimeUniforme / section rectangulaire :', () => {
             let ru = new RegimeUniforme(sect, false);
 
             // nom variable à calculer, valeur de Ks
-            expect(ru.Calc("If", 0, precDist).vCalc).toBeCloseTo(0.001, precDigits);
+            check(ru.Calc("If", 0, precDist), 0.001);
         });
 
         it('Q should be 1.568', () => {
@@ -75,7 +79,7 @@ describe('Class RegimeUniforme / section rectangulaire :', () => {
             let sect = new cSnRectang(undefined, prms);
             let ru = new RegimeUniforme(sect);
 
-            expect(ru.Calc("Q").vCalc).toBeCloseTo(1.568, precDigits);
+            check(ru.Calc("Q"), 1.568);
         });
 
         it('Q should be 0.731', () => {
@@ -92,7 +96,7 @@ describe('Class RegimeUniforme / section rectangulaire :', () => {
             let sect = new cSnRectang(undefined, prms);
             let ru = new RegimeUniforme(sect);
 
-            expect(ru.Calc("Q").vCalc).toBeCloseTo(0.731, precDigits);
+            check(ru.Calc("Q"), 0.731);
         });
 
         it('Y should be 0.663', () => {
@@ -110,7 +114,7 @@ describe('Class RegimeUniforme / section rectangulaire :', () => {
             let ru = new RegimeUniforme(sect);
 
             // nom variable à calculer, valeur de Ks
-            expect(ru.Calc("Y").vCalc).toBeCloseTo(0.663, precDigits);
+            check(ru.Calc("Y"), 0.663);
         });
     });
 
@@ -132,7 +136,7 @@ describe('Class RegimeUniforme / section rectangulaire :', () => {
             let sect = new cSnRectang(undefined, prms, false);
             let ru = new RegimeUniforme(sect, false);
 
-            expect(ru.Calc("LargeurBerge").vCalc).toBeCloseTo(2.5, precDigits);
+            check(ru.Calc("LargeurBerge"), 2.5);
         });
 
         it('Strickler should be 9.041', () => {
@@ -149,7 +153,7 @@ describe('Class RegimeUniforme / section rectangulaire :', () => {
             let sect = new cSnRectang(undefined, prms);
             let ru = new RegimeUniforme(sect);
 
-            expect(ru.Calc("Ks", 1e-8).vCalc).toBeCloseTo(9.041, precDigits);
+            check(ru.Calc("Ks", 1e-8), 9.041);
         });
 
         it('If should be 0.001', () => {
@@ -167,7 +171,7 @@ describe('Class RegimeUniforme / section rectangulaire :', () => {
             let ru = new RegimeUniforme(sect, false);
 
             // nom variable à calculer, valeur de Ks
-            expect(ru.Calc("If", 0, precDist).vCalc).toBeCloseTo(0.001, precDigits);
+            check(ru.Calc("If", 0, precDist), 0.001);
         });
 
         it('Q should be 5.31', () => {
@@ -184,7 +188,7 @@ describe('Class RegimeUniforme / section rectangulaire :', () => {
             let sect = new cSnRectang(undefined, prms);
             let ru = new RegimeUniforme(sect);
 
-            expect(ru.Calc("Q").vCalc).toBeCloseTo(5.31, precDigits);
+            check(ru.Calc("Q"), 5.31);
         });
 
         it('Q should be 1.624', () => {
@@ -201,7 +205,7 @@ describe('Class RegimeUniforme / section rectangulaire :', () => {
             let sect = new cSnRectang(undefined, prms);
             let ru = new RegimeUniforme(sect);
 
-            expect(ru.Calc("Q").vCalc).toBeCloseTo(1.624, precDigits);
+            check(ru.Calc("Q"), 1.624);
         });
 
         it('Y should be 0.663', () => {
@@ -219,7 +223,7 @@ describe('Class RegimeUniforme / section rectangulaire :', () => {
             let ru = new RegimeUniforme(sect);
 
             // nom variable à calculer, valeur de Ks
-            expect(ru.Calc("Y").vCalc).toBeCloseTo(0.663, precDigits);
+            check(ru.Calc("Y"), 0.663);
         });
     });
 });
diff --git a/spec/regime_uniforme_trapeze.spec.ts b/spec/regime_uniforme_trapeze.spec.ts
index 4625d803e24ad1979d404ddd6643221454385e74..bf19a0063661f3cfd1dab38be64b3836a70b66ce 100644
--- a/spec/regime_uniforme_trapeze.spec.ts
+++ b/spec/regime_uniforme_trapeze.spec.ts
@@ -3,7 +3,12 @@
 import { Result } from "../src/base";
 import { RegimeUniforme } from "../src/regime_uniforme";
 import { ParamsSectionTrapez, cSnTrapez } from "../src/section/section_trapez";
-import { precDigits, precDist } from "./nubtest";
+import { equalEpsilon, precDist } from "./nubtest";
+
+
+function check(val1: Result, val2: number) {
+    expect(equalEpsilon(val1.vCalc, val2)).toBeTruthy("expected " + val2 + ", got " + val1.vCalc);
+}
 
 describe('Class RegimeUniforme / section trapèze :', () => {
     describe('pas de débordement :', () => {
@@ -23,7 +28,7 @@ describe('Class RegimeUniforme / section trapèze :', () => {
 
             let ru = new RegimeUniforme(sect, false);
 
-            expect(ru.Calc("LargeurFond", 0, precDist).vCalc).toBeCloseTo(2.5, precDigits);
+            check(ru.Calc("LargeurFond", 0, precDist), 2.5);
         });
 
         it('Fruit should be 0.56', () => {
@@ -41,7 +46,7 @@ describe('Class RegimeUniforme / section trapèze :', () => {
             let sect = new cSnTrapez(undefined, prms);
             let ru = new RegimeUniforme(sect);
 
-            expect(ru.Calc("Fruit").vCalc).toBeCloseTo(0.56, precDigits);
+            check(ru.Calc("Fruit"), 0.56);
         });
 
         it('Ks should be 24.14', () => {
@@ -59,7 +64,7 @@ describe('Class RegimeUniforme / section trapèze :', () => {
             let sect = new cSnTrapez(undefined, prms);
             let ru = new RegimeUniforme(sect);
 
-            expect(ru.Calc("Ks", 1e-8).vCalc).toBeCloseTo(24.14, precDigits);
+            check(ru.Calc("Ks", 1e-8), 24.14);
         });
 
         it('If should be 0.001', () => {
@@ -77,7 +82,7 @@ describe('Class RegimeUniforme / section trapèze :', () => {
             let sect = new cSnTrapez(undefined, prms);
             let ru = new RegimeUniforme(sect);
 
-            expect(ru.Calc("If").vCalc).toBeCloseTo(0.001, precDigits);
+            check(ru.Calc("If"), 0.001);
         });
 
         it('Q should be 1.2', () => {
@@ -95,7 +100,7 @@ describe('Class RegimeUniforme / section trapèze :', () => {
             let sect = new cSnTrapez(undefined, prms);
             let ru = new RegimeUniforme(sect);
 
-            expect(ru.Calc("Q").vCalc).toBeCloseTo(1.2, precDigits);
+            check(ru.Calc("Q"), 1.2);
         });
 
         it('Y should be 0.587', () => {
@@ -113,7 +118,7 @@ describe('Class RegimeUniforme / section trapèze :', () => {
             let sect = new cSnTrapez(undefined, prms);
             let ru = new RegimeUniforme(sect);
 
-            expect(ru.Calc("Y").vCalc).toBeCloseTo(0.587, precDigits);
+            check(ru.Calc("Y"), 0.587);
         });
     });
 
@@ -132,7 +137,7 @@ describe('Class RegimeUniforme / section trapèze :', () => {
             let sect = new cSnTrapez(undefined, prms);
             let ru = new RegimeUniforme(sect, false);
 
-            expect(ru.Calc("LargeurFond", 0, precDist).vCalc).toBeCloseTo(0.03, precDigits);
+            check(ru.Calc("LargeurFond", 0, precDist), 0.03);
         });
 
         it('Fruit should be 0.56', () => {
@@ -150,7 +155,7 @@ describe('Class RegimeUniforme / section trapèze :', () => {
             let sect = new cSnTrapez(undefined, prms);
             let ru = new RegimeUniforme(sect);
 
-            expect(ru.Calc("Fruit").vCalc).toBeCloseTo(0.56, precDigits);
+            check(ru.Calc("Fruit"), 0.56);
         });
 
         it('Ks should be 5.745', () => {
@@ -167,7 +172,7 @@ describe('Class RegimeUniforme / section trapèze :', () => {
             let sect = new cSnTrapez(undefined, prms);
             let ru = new RegimeUniforme(sect);
 
-            expect(ru.Calc("Ks", 1e-8).vCalc).toBeCloseTo(5.745, precDigits);
+            check(ru.Calc("Ks", 1e-8), 5.745);
         });
 
         it('If should be 0.001', () => {
@@ -184,7 +189,7 @@ describe('Class RegimeUniforme / section trapèze :', () => {
             let sect = new cSnTrapez(undefined, prms);
             let ru = new RegimeUniforme(sect);
 
-            expect(ru.Calc("If").vCalc).toBeCloseTo(0.001, precDigits);
+            check(ru.Calc("If"), 0.001);
         });
 
         it('Q should be 8.356', () => {
@@ -202,7 +207,7 @@ describe('Class RegimeUniforme / section trapèze :', () => {
             let sect = new cSnTrapez(undefined, prms);
             let ru = new RegimeUniforme(sect);
 
-            expect(ru.Calc("Q").vCalc).toBeCloseTo(8.356, precDigits);
+            check(ru.Calc("Q"), 8.356);
         });
 
         it('Y should be 0.587', () => {
@@ -220,7 +225,7 @@ describe('Class RegimeUniforme / section trapèze :', () => {
             let sect = new cSnTrapez(undefined, prms);
             let ru = new RegimeUniforme(sect);
 
-            expect(ru.Calc("Y").vCalc).toBeCloseTo(0.587, precDigits);
+            check(ru.Calc("Y"), 0.587);
         });
     });
 });
diff --git a/spec/section_param_circ_fluvial.spec.ts b/spec/section_param_circ_fluvial.spec.ts
index e4631773e6dfc6897ad226a35310ad853daaa46a..0366d7647eb53e0bb5bb56e5ba3895c72d7fc153 100644
--- a/spec/section_param_circ_fluvial.spec.ts
+++ b/spec/section_param_circ_fluvial.spec.ts
@@ -1,7 +1,7 @@
 /// <reference path="../node_modules/@types/jasmine/index.d.ts" />
 
 import { Result } from "../src/base";
-import { nub, precDigits, precDist } from "./nubtest";
+import { precDist, equalEpsilon } from "./nubtest";
 import { ParamsSectionCirc, cSnCirc } from "../src/section/section_circulaire";
 
 let paramSection: ParamsSectionCirc;
@@ -35,6 +35,10 @@ function createSectionDebordement(prec: number): cSnCirc {
     return new cSnCirc(undefined, paramSection);
 }
 
+function check(val1: number, val2: number) {
+    expect(equalEpsilon(val1, val2)).toBeTruthy("expected " + val2 + ", got " + val1);
+}
+
 describe('Section paramétrée circulaire : ', () => {
     beforeEach(() => {
         sect = createSection(precDist);
@@ -43,89 +47,89 @@ describe('Section paramétrée circulaire : ', () => {
     describe('fluvial / pas de débordement :', () => {
         // charge spécifique
         it('Hs should equal to 0.853', () => {
-            expect(sect.Calc("Hs")).toBeCloseTo(0.853, precDigits);
+            check(sect.Calc("Hs"), 0.853);
         });
 
         // charge critique
         it('Hsc should equal to 0.694', () => {
-            expect(sect.Calc("Hsc")).toBeCloseTo(0.694, precDigits);
+            check(sect.Calc("Hsc"), 0.694);
         });
 
         // largeur au miroir
         it('B should equal to 1.959', () => {
-            expect(sect.Calc("B")).toBeCloseTo(1.959, 2);
+            check(sect.Calc("B"), 1.959);
         });
 
         // périmètre mouillé
         it('P should equal to 2.738', () => {
-            expect(sect.Calc("P")).toBeCloseTo(2.738, 2);
+            check(sect.Calc("P"), 2.738);
         });
 
         // surface mouillée
         it('S should equal to 1.173', () => {
-            expect(sect.Calc("S")).toBeCloseTo(1.173, precDigits);
+            check(sect.Calc("S"), 1.173);
         });
 
         // rayon hydraulique
         it('R should equal to 0.428', () => {
-            expect(sect.Calc("R")).toBeCloseTo(0.428, precDigits);
+            check(sect.Calc("R"), 0.428);
         });
 
         // vitesse moyenne
         it('V should equal to 1.023', () => {
-            expect(sect.Calc("V")).toBeCloseTo(1.023, precDigits);
+            check(sect.Calc("V"), 1.023);
         });
 
         // nombre de Froude
         it('Fr should equal to 0.422', () => {
-            expect(sect.Calc("Fr")).toBeCloseTo(0.422, precDigits);
+            check(sect.Calc("Fr"), 0.422);
         });
 
         // tirant d'eau critique
         it('Yc should equal to 0.512', () => {
-            expect(sect.Calc("Yc")).toBeCloseTo(0.512, precDigits);
+            check(sect.Calc("Yc"), 0.512);
         });
 
         // tirant d'eau normal
         it('Yn should equal to 0.976', () => {
-            expect(sect.Calc("Yn")).toBeCloseTo(0.976, precDigits);
+            check(sect.Calc("Yn"), 0.976);
         });
 
         // tirant d'eau fluvial
         it('Yf should equal to 0.8', () => {
-            expect(sect.Calc("Yf")).toBeCloseTo(0.8, precDigits);
+            check(sect.Calc("Yf"), 0.8);
         });
 
         // tirant d'eau torrentiel
         it('Yt should equal to 0.361', () => {
-            expect(sect.Calc("Yt")).toBeCloseTo(0.361, precDigits);
+            check(sect.Calc("Yt"), 0.361);
         });
 
         // tirant d'eau conjugué
         it('Yco should equal to 0.307', () => {
-            expect(sect.Calc("Yco")).toBeCloseTo(0.307, precDigits);
+            check(sect.Calc("Yco"), 0.307);
         });
 
         // perte de charge
         it('J should equal to 0.002', () => {
             //sect = createSection(0.00001);
-            expect(sect.Calc("J")).toBeCloseTo(0.002, precDigits);
+            check(sect.Calc("J"), 0.002);
         });
 
         // Variation linéaire de l'énergie spécifique
         it('I-J should equal to -0.00102', () => {
             sect = createSection(0.00001);
-            expect(sect.Calc("I-J")).toBeCloseTo(-0.00102, precDigits);
+            check(sect.Calc("I-J"), -0.00102);
         });
 
         // impulsion hydraulique
         it('Imp should equal to 5076.304', () => {
-            expect(sect.Calc("Imp")).toBeCloseTo(5076.304, precDigits);
+            check(sect.Calc("Imp"), 5076.304);
         });
 
         // force tractrice (contrainte de cisaillement)
         it('Tau0 should equal to 8.505', () => {
-            expect(sect.Calc("Tau0")).toBeCloseTo(8.505, precDigits);
+            check(sect.Calc("Tau0"), 8.505);
         });
     });
 });
@@ -139,89 +143,89 @@ describe('Section paramétrée circulaire : ', () => {
     describe('fluvial / débordement :', () => {
         // charge spécifique
         it('Hs should equal to 2.006', () => {
-            expect(sect.Calc("Hs")).toBeCloseTo(2.006, precDigits);
+            check(sect.Calc("Hs"), 2.006);
         });
 
         // charge critique
         it('Hsc should equal to 0.694', () => {
-            expect(sect.Calc("Hsc")).toBeCloseTo(0.694, precDigits);
+            check(sect.Calc("Hsc"), 0.694);
         });
 
         // largeur au miroir
         it('B should equal to 2', () => {
-            expect(sect.Calc("B")).toBeCloseTo(2, precDigits);
+            check(sect.Calc("B"), 2);
         });
 
         // périmètre mouillé
         it('P should equal to 5.142', () => {
-            expect(sect.Calc("P")).toBeCloseTo(5.142, precDigits);
+            check(sect.Calc("P"), 5.142);
         });
 
         // surface mouillée
         it('S should equal to 3.571', () => {
-            expect(sect.Calc("S")).toBeCloseTo(3.571, precDigits);
+            check(sect.Calc("S"), 3.571);
         });
 
         // rayon hydraulique
         it('R should equal to 0.694', () => {
-            expect(sect.Calc("R")).toBeCloseTo(0.694, precDigits);
+            check(sect.Calc("R"), 0.694);
         });
 
         // vitesse moyenne
         it('V should equal to 0.336', () => {
-            expect(sect.Calc("V")).toBeCloseTo(0.336, precDigits);
+            check(sect.Calc("V"), 0.336);
         });
 
         // nombre de Froude
         it('Fr should equal to 0.08', () => {
-            expect(sect.Calc("Fr")).toBeCloseTo(0.08, precDigits);
+            check(sect.Calc("Fr"), 0.08);
         });
 
         // tirant d'eau critique
         it('Yc should equal to 0.512', () => {
-            expect(sect.Calc("Yc")).toBeCloseTo(0.512, precDigits);
+            check(sect.Calc("Yc"), 0.512);
         });
 
         // tirant d'eau normal
         it('Yn should equal to 0.976', () => {
-            expect(sect.Calc("Yn")).toBeCloseTo(0.976, precDigits);
+            check(sect.Calc("Yn"), 0.976);
         });
 
         // tirant d'eau fluvial
         it('Yf should equal to 2', () => {
-            expect(sect.Calc("Yf")).toBeCloseTo(2, precDigits);
+            check(sect.Calc("Yf"), 2);
         });
 
         // tirant d'eau torrentiel
         it('Yt should equal to 0.232', () => {
-            expect(sect.Calc("Yt")).toBeCloseTo(0.232, precDigits);
+            check(sect.Calc("Yt"), 0.232);
         });
 
         // tirant d'eau conjugué
         it('Yco should equal to 0.24', () => {
-            expect(sect.Calc("Yco")).toBeCloseTo(0.24, precDigits);
+            check(sect.Calc("Yco"), 0.24);
         });
 
         // perte de charge
         it('J should equal to 0.0001', () => {
             sect = createSectionDebordement(0.00001);
-            expect(sect.Calc("J")).toBeCloseTo(0.0001, precDigits);
+            check(sect.Calc("J"), 0.0001);
         });
 
         // Variation linéaire de l'énergie spécifique
         it('I-J should equal to 0.001', () => {
             sect = createSectionDebordement(0.00001);
-            expect(sect.Calc("I-J")).toBeCloseTo(0.001, precDigits);
+            check(sect.Calc("I-J"), 0.001);
         });
 
         // impulsion hydraulique
         it('Imp should equal to 6943.271', () => {
-            expect(sect.Calc("Imp")).toBeCloseTo(6943.271, precDigits);
+            check(sect.Calc("Imp"), 6943.271);
         });
 
         // force tractrice (contrainte de cisaillement)
         it('Tau0 should equal to 0.782', () => {
-            expect(sect.Calc("Tau0")).toBeCloseTo(0.782, precDigits);
+            check(sect.Calc("Tau0"), 0.782);
         });
     });
 });
diff --git a/spec/section_param_circ_torrentiel.spec.ts b/spec/section_param_circ_torrentiel.spec.ts
index 3f77f02ab983e7b1e09fb95c6fa7035c3a4b104f..6c250297297304babae3c04b1f2407e8a394256c 100644
--- a/spec/section_param_circ_torrentiel.spec.ts
+++ b/spec/section_param_circ_torrentiel.spec.ts
@@ -1,7 +1,7 @@
 /// <reference path="../node_modules/@types/jasmine/index.d.ts" />
 
 import { Result } from "../src/base";
-import { nub, precDigits, precDist } from "./nubtest";
+import { precDist, equalEpsilon } from "./nubtest";
 import { ParamsSectionCirc, cSnCirc } from "../src/section/section_circulaire";
 
 let paramSection: ParamsSectionCirc;
@@ -21,6 +21,10 @@ function createSection(prec: number): cSnCirc {
     return new cSnCirc(undefined, paramSection);
 }
 
+function check(val1: number, val2: number) {
+    expect(equalEpsilon(val1, val2)).toBeTruthy("expected " + val2 + ", got " + val1);
+}
+
 describe('Section paramétrée circulaire : ', () => {
     beforeEach(() => {
         sect = createSection(precDist);
@@ -29,89 +33,89 @@ describe('Section paramétrée circulaire : ', () => {
     describe('torrentiel :', () => {
         // charge spécifique
         it('Hs should equal to 4.501', () => {
-            expect(sect.Calc("Hs")).toBeCloseTo(4.501, precDigits);
+            check(sect.Calc("Hs"), 4.501);
         });
 
         // charge critique
         it('Hsc should equal to 2.263', () => {
-            expect(sect.Calc("Hsc")).toBeCloseTo(2.263, precDigits);
+            check(sect.Calc("Hsc"), 2.263);
         });
 
         // largeur au miroir
         it('B should equal to 1.960', () => {
-            expect(sect.Calc("B")).toBeCloseTo(1.960, precDigits);
+            check(sect.Calc("B"), 1.960);
         });
 
         // périmètre mouillé
         it('P should equal to 2.739', () => {
-            expect(sect.Calc("P")).toBeCloseTo(2.739, precDigits);
+            check(sect.Calc("P"), 2.739);
         });
 
         // surface mouillée
         it('S should equal to 1.173', () => {
-            expect(sect.Calc("S")).toBeCloseTo(1.173, precDigits);
+            check(sect.Calc("S"), 1.173);
         });
 
         // rayon hydraulique
         it('R should equal to 0.428', () => {
-            expect(sect.Calc("R")).toBeCloseTo(0.428, precDigits);
+            check(sect.Calc("R"), 0.428);
         });
 
         // vitesse moyenne
         it('V should equal to 8.522', () => {
-            expect(sect.Calc("V")).toBeCloseTo(8.522, precDigits);
+            check(sect.Calc("V"), 8.522);
         });
 
         // nombre de Froude
         it('Fr should equal to 3.516', () => {
-            expect(sect.Calc("Fr")).toBeCloseTo(3.516, precDigits);
+            check(sect.Calc("Fr"), 3.516);
         });
 
         // tirant d'eau critique
         it('Yc should equal to 1.581', () => {
-            expect(sect.Calc("Yc")).toBeCloseTo(1.581, precDigits);
+            check(sect.Calc("Yc"), 1.581);
         });
 
         // tirant d'eau normal
         it('Yn should equal to 4.624', () => {
-            expect(sect.Calc("Yn")).toBeCloseTo(4.624, precDigits);
+            check(sect.Calc("Yn"), 4.624);
         });
 
         // tirant d'eau fluvial
         it('Yf should equal to 4.43', () => {
-            expect(sect.Calc("Yf")).toBeCloseTo(4.43, precDigits);
+            check(sect.Calc("Yf"), 4.43);
         });
 
         // tirant d'eau torrentiel
         it('Yt should equal to 0.8', () => {
-            expect(sect.Calc("Yt")).toBeCloseTo(0.8, precDigits);
+            check(sect.Calc("Yt"), 0.8);
         });
 
         // tirant d'eau conjugué
         it('Yco should equal to 0.8', () => {
-            expect(sect.Calc("Yco")).toBeCloseTo(0.8, precDigits);
+            check(sect.Calc("Yco"), 0.8);
         });
 
         // perte de charge
         it('J should equal to 0.141', () => {
             //sect = createSection(0.00001);
-            expect(sect.Calc("J")).toBeCloseTo(0.141, precDigits);
+            check(sect.Calc("J"), 0.141);
         });
 
         // Variation linéaire de l'énergie spécifique
         it('I-J should equal to -0.14', () => {
             //sect = createSection(0.00001);
-            expect(sect.Calc("I-J")).toBeCloseTo(-0.14, precDigits);
+            check(sect.Calc("I-J"), -0.14);
         });
 
         // impulsion hydraulique
         it('Imp should equal to 89065.861', () => {
-            expect(sect.Calc("Imp")).toBeCloseTo(89065.861, precDigits);
+            check(sect.Calc("Imp"), 89065.861);
         });
 
         // force tractrice (contrainte de cisaillement)
         it('Tau0 should equal to 590.605', () => {
-            expect(sect.Calc("Tau0")).toBeCloseTo(590.605, precDigits);
+            check(sect.Calc("Tau0"), 590.605);
         });
     });
 });
diff --git a/spec/section_param_puiss_fluvial.spec.ts b/spec/section_param_puiss_fluvial.spec.ts
index 54941e1481374ae40c0ccd4c3bf5babba42704b7..27c2edc824508fa9ff109cb683e25001f45a61fe 100644
--- a/spec/section_param_puiss_fluvial.spec.ts
+++ b/spec/section_param_puiss_fluvial.spec.ts
@@ -1,7 +1,7 @@
 /// <reference path="../node_modules/@types/jasmine/index.d.ts" />
 
 import { Result } from "../src/base";
-import { nub, precDigits, precDist } from "./nubtest";
+import { precDist, equalEpsilon } from "./nubtest";
 import { ParamsSectionPuiss, cSnPuiss } from "../src/section/section_puissance";
 
 let paramSection: ParamsSectionPuiss;
@@ -37,6 +37,10 @@ function createSectionDebordement(prec: number): cSnPuiss {
     return new cSnPuiss(undefined, paramSection);
 }
 
+function check(val1: number, val2: number) {
+    expect(equalEpsilon(val1, val2)).toBeTruthy("expected " + val2 + ", got " + val1);
+}
+
 describe('Section paramétrée puissance :', () => {
     beforeEach(() => {
         sect = createSection(precDist);
@@ -45,89 +49,89 @@ describe('Section paramétrée puissance :', () => {
     describe('fluvial / pas de débordement :', () => {
         // charge spécifique
         it('Hs should equal to 0.82', () => {
-            expect(sect.Calc("Hs")).toBeCloseTo(0.82, precDigits);
+            check(sect.Calc("Hs"), 0.82);
         });
 
         // charge critique
         it('Hsc should equal to 0.559', () => {
-            expect(sect.Calc("Hsc")).toBeCloseTo(0.559, precDigits);
+            check(sect.Calc("Hsc"), 0.559);
         });
 
         // largeur au miroir
         it('B should equal to 3.578', () => {
-            expect(sect.Calc("B")).toBeCloseTo(3.578, precDigits);
+            check(sect.Calc("B"), 3.578);
         });
 
         // périmètre mouillé
         it('P should equal to 4.223', () => {
-            expect(sect.Calc("P")).toBeCloseTo(4.223, precDigits);
+            check(sect.Calc("P"), 4.223);
         });
 
         // surface mouillée
         it('S should equal to 1.908', () => {
-            expect(sect.Calc("S")).toBeCloseTo(1.908, precDigits);
+            check(sect.Calc("S"), 1.908);
         });
 
         // rayon hydraulique
         it('R should equal to 0.452', () => {
-            expect(sect.Calc("R")).toBeCloseTo(0.452, precDigits);
+            check(sect.Calc("R"), 0.452);
         });
 
         // vitesse moyenne
         it('V should equal to 0.629', () => {
-            expect(sect.Calc("V")).toBeCloseTo(0.629, precDigits);
+            check(sect.Calc("V"), 0.629);
         });
 
         // nombre de Froude
         it('Fr should equal to 0.275', () => {
-            expect(sect.Calc("Fr")).toBeCloseTo(0.275, precDigits);
+            check(sect.Calc("Fr"), 0.275);
         });
 
         // tirant d'eau critique
         it('Yc should equal to 0.419', () => {
-            expect(sect.Calc("Yc")).toBeCloseTo(0.419, precDigits);
+            check(sect.Calc("Yc"), 0.419);
         });
 
         // tirant d'eau normal
         it('Yn should equal to 0.742', () => {
-            expect(sect.Calc("Yn")).toBeCloseTo(0.742, precDigits);
+            check(sect.Calc("Yn"), 0.742);
         });
 
         // tirant d'eau fluvial
         it('Yf should equal to 0.8', () => {
-            expect(sect.Calc("Yf")).toBeCloseTo(0.8, precDigits);
+            check(sect.Calc("Yf"), 0.8);
         });
 
         // tirant d'eau torrentiel
         it('Yt should equal to 0.265', () => {
-            expect(sect.Calc("Yt")).toBeCloseTo(0.265, precDigits);
+            check(sect.Calc("Yt"), 0.265);
         });
 
         // tirant d'eau conjugué
         it('Yco should equal to 0.189', () => {
-            expect(sect.Calc("Yco")).toBeCloseTo(0.189, precDigits);
+            check(sect.Calc("Yco"), 0.189);
         });
 
         // perte de charge
         it('J should equal to 0.0007', () => {
             sect = createSection(0.00001);
-            expect(sect.Calc("J")).toBeCloseTo(0.0007, precDigits);
+            check(sect.Calc("J"), 0.0007);
         });
 
         // Variation linéaire de l'énergie spécifique
         it('I-J should equal to 0.000335', () => {
             sect = createSection(0.000001);
-            expect(sect.Calc("I-J")).toBeCloseTo(0.000335, precDigits);
+            check(sect.Calc("I-J"), 0.000335);
         });
 
         // impulsion hydraulique
         it('Imp should equal to 6744.616', () => {
-            expect(sect.Calc("Imp")).toBeCloseTo(6744.616, precDigits);
+            check(sect.Calc("Imp"), 6744.616);
         });
 
         // force tractrice (contrainte de cisaillement)
         it('Tau0 should equal to 3.16', () => {
-            expect(sect.Calc("Tau0")).toBeCloseTo(3.16, precDigits);
+            check(sect.Calc("Tau0"), 3.16);
         });
     });
 });
@@ -141,89 +145,89 @@ describe('Section paramétrée puissance :', () => {
     describe('fluvial / débordement :', () => {
         // charge spécifique
         it('Hs should equal to 2.001', () => {
-            expect(sect.Calc("Hs")).toBeCloseTo(2.001, precDigits);
+            check(sect.Calc("Hs"), 2.001);
         });
 
         // charge critique
         it('Hsc should equal to 0.559', () => {
-            expect(sect.Calc("Hsc")).toBeCloseTo(0.559, precDigits);
+            check(sect.Calc("Hsc"), 0.559);
         });
 
         // largeur au miroir
         it('B should equal to 4', () => {
-            expect(sect.Calc("B")).toBeCloseTo(4, precDigits);
+            check(sect.Calc("B"), 4);
         });
 
         // périmètre mouillé
         it('P should equal to 6.098', () => {
-            expect(sect.Calc("P")).toBeCloseTo(6.098, precDigits);
+            check(sect.Calc("P"), 6.098);
         });
 
         // surface mouillée
         it('S should equal to 7.542', () => {
-            expect(sect.Calc("S")).toBeCloseTo(7.542, precDigits);
+            check(sect.Calc("S"), 7.542);
         });
 
         // rayon hydraulique
         it('R should equal to 1.237', () => {
-            expect(sect.Calc("R")).toBeCloseTo(1.237, precDigits);
+            check(sect.Calc("R"), 1.237);
         });
 
         // vitesse moyenne
         it('V should equal to 0.159', () => {
-            expect(sect.Calc("V")).toBeCloseTo(0.159, precDigits);
+            check(sect.Calc("V"), 0.159);
         });
 
         // nombre de Froude
         it('Fr should equal to 0.037', () => {
-            expect(sect.Calc("Fr")).toBeCloseTo(0.037, precDigits);
+            check(sect.Calc("Fr"), 0.037);
         });
 
         // tirant d'eau critique
         it('Yc should equal to 0.419', () => {
-            expect(sect.Calc("Yc")).toBeCloseTo(0.419, precDigits);
+            check(sect.Calc("Yc"), 0.419);
         });
 
         // tirant d'eau normal
         it('Yn should equal to 0.742', () => {
-            expect(sect.Calc("Yn")).toBeCloseTo(0.742, precDigits);
+            check(sect.Calc("Yn"), 0.742);
         });
 
         // tirant d'eau fluvial
         it('Yf should equal to 2', () => {
-            expect(sect.Calc("Yf")).toBeCloseTo(2, precDigits);
+            check(sect.Calc("Yf"), 2);
         });
 
         // tirant d'eau torrentiel
         it('Yt should equal to 0.178', () => {
-            expect(sect.Calc("Yt")).toBeCloseTo(0.178, precDigits);
+            check(sect.Calc("Yt"), 0.178);
         });
 
         // tirant d'eau conjugué
         it('Yco should equal to 0.044', () => {
-            expect(sect.Calc("Yco")).toBeCloseTo(0.044, precDigits);
+            check(sect.Calc("Yco"), 0.044);
         });
 
         // perte de charge
         it('J should equal to 0.00059', () => {
             sect = createSection(0.00001);
-            expect(sect.Calc("J")).toBeCloseTo(0.00059, precDigits);
+            check(sect.Calc("J"), 0.00059);
         });
 
         // Variation linéaire de l'énergie spécifique
         it('I-J should equal to 0.00041', () => {
             sect = createSection(0.00001);
-            expect(sect.Calc("I-J")).toBeCloseTo(0.00041, precDigits);
+            check(sect.Calc("I-J"), 0.00041);
         });
 
         // impulsion hydraulique
         it('Imp should equal to 59384.242', () => {
-            expect(sect.Calc("Imp")).toBeCloseTo(59384.242, precDigits);
+            check(sect.Calc("Imp"), 59384.242);
         });
 
         // force tractrice (contrainte de cisaillement)
         it('Tau0 should equal to 0.145', () => {
-            expect(sect.Calc("Tau0")).toBeCloseTo(0.145, precDigits);
+            check(sect.Calc("Tau0"), 0.145);
         });
     });
 });
diff --git a/spec/section_param_puiss_torrentiel.spec.ts b/spec/section_param_puiss_torrentiel.spec.ts
index 179d9a632bcb1271c3c6325cf4b6de4febfd05d0..884ac1aa1bd3085783e3a6ded5523b17b25852f6 100644
--- a/spec/section_param_puiss_torrentiel.spec.ts
+++ b/spec/section_param_puiss_torrentiel.spec.ts
@@ -1,7 +1,7 @@
 /// <reference path="../node_modules/@types/jasmine/index.d.ts" />
 
 import { Result } from "../src/base";
-import { nub, precDigits, precDist } from "./nubtest";
+import { precDist, equalEpsilon } from "./nubtest";
 import { ParamsSectionPuiss, cSnPuiss } from "../src/section/section_puissance";
 
 let paramSection: ParamsSectionPuiss;
@@ -22,6 +22,10 @@ function createSection(prec: number): cSnPuiss {
     return new cSnPuiss(undefined, paramSection);
 }
 
+function check(val1: number, val2: number) {
+    expect(equalEpsilon(val1, val2)).toBeTruthy("expected " + val2 + ", got " + val1);
+}
+
 describe('Section paramétrée puissance :', () => {
     beforeEach(() => {
         sect = createSection(precDist);
@@ -30,89 +34,89 @@ describe('Section paramétrée puissance :', () => {
     describe('torrentiel / pas de débordement :', () => {
         // charge spécifique
         it('Hs should equal to 2.2', () => {
-            expect(sect.Calc("Hs")).toBeCloseTo(2.2, precDigits);
+            check(sect.Calc("Hs"), 2.2);
         });
 
         // charge critique
         it('Hsc should equal to 1.616', () => {
-            expect(sect.Calc("Hsc")).toBeCloseTo(1.616, precDigits);
+            check(sect.Calc("Hsc"), 1.616);
         });
 
         // largeur au miroir
         it('B should equal to 3.578', () => {
-            expect(sect.Calc("B")).toBeCloseTo(3.578, precDigits);
+            check(sect.Calc("B"), 3.578);
         });
 
         // périmètre mouillé
         it('P should equal to 4.223', () => {
-            expect(sect.Calc("P")).toBeCloseTo(4.223, precDigits);
+            check(sect.Calc("P"), 4.223);
         });
 
         // surface mouillée
         it('S should equal to 1.908', () => {
-            expect(sect.Calc("S")).toBeCloseTo(1.908, precDigits);
+            check(sect.Calc("S"), 1.908);
         });
 
         // rayon hydraulique
         it('R should equal to 0.452', () => {
-            expect(sect.Calc("R")).toBeCloseTo(0.452, precDigits);
+            check(sect.Calc("R"), 0.452);
         });
 
         // vitesse moyenne
         it('V should equal to 5.241', () => {
-            expect(sect.Calc("V")).toBeCloseTo(5.241, precDigits);
+            check(sect.Calc("V"), 5.241);
         });
 
         // nombre de Froude
         it('Fr should equal to 2.291', () => {
-            expect(sect.Calc("Fr")).toBeCloseTo(2.291, precDigits);
+            check(sect.Calc("Fr"), 2.291);
         });
 
         // tirant d'eau critique
         it('Yc should equal to 1.186', () => {
-            expect(sect.Calc("Yc")).toBeCloseTo(1.186, precDigits);
+            check(sect.Calc("Yc"), 1.186);
         });
 
         // tirant d'eau normal
         it('Yn should equal to 1.916', () => {
-            expect(sect.Calc("Yn")).toBeCloseTo(1.916, precDigits);
+            check(sect.Calc("Yn"), 1.916);
         });
 
         // tirant d'eau fluvial
         it('Yf should equal to 2.126', () => {
-            expect(sect.Calc("Yf")).toBeCloseTo(2.126, precDigits);
+            check(sect.Calc("Yf"), 2.126);
         });
 
         // tirant d'eau torrentiel
         it('Yt should equal to 0.8', () => {
-            expect(sect.Calc("Yt")).toBeCloseTo(0.8, precDigits);
+            check(sect.Calc("Yt"), 0.8);
         });
 
         // tirant d'eau conjugué
         it('Yco should equal to 1.746', () => {
-            expect(sect.Calc("Yco")).toBeCloseTo(1.746, precDigits);
+            check(sect.Calc("Yco"), 1.746);
         });
 
         // perte de charge
         it('J should equal to 0.05', () => {
             //sect = createSection(0.00001);
-            expect(sect.Calc("J")).toBeCloseTo(0.05, precDigits);
+            check(sect.Calc("J"), 0.05);
         });
 
         // Variation linéaire de l'énergie spécifique
         it('I-J should equal to -0.049', () => {
             //sect = createSection(0.00001);
-            expect(sect.Calc("I-J")).toBeCloseTo(-0.049, precDigits);
+            check(sect.Calc("I-J"), -0.049);
         });
 
         // impulsion hydraulique
         it('Imp should equal to 58397.786', () => {
-            expect(sect.Calc("Imp")).toBeCloseTo(58397.786, precDigits);
+            check(sect.Calc("Imp"), 58397.786);
         });
 
         // force tractrice (contrainte de cisaillement)
         it('Tau0 should equal to 219.455', () => {
-            expect(sect.Calc("Tau0")).toBeCloseTo(219.455, precDigits);
+            check(sect.Calc("Tau0"), 219.455);
         });
     });
 });
diff --git a/spec/section_param_rect_fluvial.spec.ts b/spec/section_param_rect_fluvial.spec.ts
index b59d05f67262d7ffefe3b273a85fb625f5d5b4d5..63aca70b6452997687a1a2e9bf58bbb56da0c59b 100644
--- a/spec/section_param_rect_fluvial.spec.ts
+++ b/spec/section_param_rect_fluvial.spec.ts
@@ -1,7 +1,7 @@
 /// <reference path="../node_modules/@types/jasmine/index.d.ts" />
 
 import { Result } from "../src/base";
-import { nub, precDigits, precDist } from "./nubtest";
+import { precDist, equalEpsilon } from "./nubtest";
 import { ParamsSectionRectang, cSnRectang } from "../src/section/section_rectang";
 
 let paramSection: ParamsSectionRectang;
@@ -35,6 +35,10 @@ function createSectionDebordement(prec: number): cSnRectang {
     return new cSnRectang(undefined, paramSection);
 }
 
+function check(val1: number, val2: number) {
+    expect(equalEpsilon(val1, val2)).toBeTruthy("expected " + val2 + ", got " + val1);
+}
+
 describe('Section paramétrée rectangulaire : ', () => {
     beforeEach(() => {
         sect = createSection(precDist);
@@ -43,89 +47,89 @@ describe('Section paramétrée rectangulaire : ', () => {
     describe('fluvial / pas de débordement :', () => {
         // charge spécifique
         it('Hs should equal to 0.818', () => {
-            expect(sect.Calc("Hs")).toBeCloseTo(0.818, precDigits);
+            check(sect.Calc("Hs"), 0.818);
         });
 
         // charge critique
         it('Hsc should equal to 0.43', () => {
-            expect(sect.Calc("Hsc")).toBeCloseTo(0.43, precDigits);
+            check(sect.Calc("Hsc"), 0.43);
         });
 
         // largeur au miroir
         it('B should equal to 2.5', () => {
-            expect(sect.Calc("B")).toBeCloseTo(2.5, precDigits);
+            check(sect.Calc("B"), 2.5);
         });
 
         // périmètre mouillé
         it('P should equal to 4.1', () => {
-            expect(sect.Calc("P")).toBeCloseTo(4.1, precDigits);
+            check(sect.Calc("P"), 4.1);
         });
 
         // surface mouillée
         it('S should equal to 2', () => {
-            expect(sect.Calc("S")).toBeCloseTo(2, precDigits);
+            check(sect.Calc("S"), 2);
         });
 
         // rayon hydraulique
         it('R should equal to 0.488', () => {
-            expect(sect.Calc("R")).toBeCloseTo(0.488, precDigits);
+            check(sect.Calc("R"), 0.488);
         });
 
         // vitesse moyenne
         it('V should equal to 0.6', () => {
-            expect(sect.Calc("V")).toBeCloseTo(0.6, precDigits);
+            check(sect.Calc("V"), 0.6);
         });
 
         // nombre de Froude
         it('Fr should equal to 0.214', () => {
-            expect(sect.Calc("Fr")).toBeCloseTo(0.214, precDigits);
+            check(sect.Calc("Fr"), 0.214);
         });
 
         // tirant d'eau critique
         it('Yc should equal to 0.286', () => {
-            expect(sect.Calc("Yc")).toBeCloseTo(0.286, precDigits);
+            check(sect.Calc("Yc"), 0.286);
         });
 
         // tirant d'eau normal
         it('Yn should equal to 0.663', () => {
-            expect(sect.Calc("Yn")).toBeCloseTo(0.663, precDigits);
+            check(sect.Calc("Yn"), 0.663);
         });
 
         // tirant d'eau fluvial
         it('Yf should equal to 0.8', () => {
-            expect(sect.Calc("Yf")).toBeCloseTo(0.8, precDigits);
+            check(sect.Calc("Yf"), 0.8);
         });
 
         // tirant d'eau torrentiel
         it('Yt should equal to 0.131', () => {
-            expect(sect.Calc("Yt")).toBeCloseTo(0.131, precDigits);
+            check(sect.Calc("Yt"), 0.131);
         });
 
         // tirant d'eau conjugué
         it('Yco should equal to 0.068', () => {
-            expect(sect.Calc("Yco")).toBeCloseTo(0.068, precDigits);
+            check(sect.Calc("Yco"), 0.068);
         });
 
         // perte de charge
         it('J should equal to 0.00059', () => {
             sect = createSection(0.00001);
-            expect(sect.Calc("J")).toBeCloseTo(0.00059, precDigits);
+            check(sect.Calc("J"), 0.00059);
         });
 
         // Variation linéaire de l'énergie spécifique
         it('I-J should equal to 0.00041', () => {
             sect = createSection(0.00001);
-            expect(sect.Calc("I-J")).toBeCloseTo(0.00041, precDigits);
+            check(sect.Calc("I-J"), 0.00041);
         });
 
         // impulsion hydraulique
         it('Imp should equal to 8568', () => {
-            expect(sect.Calc("Imp")).toBeCloseTo(8568, precDigits);
+            check(sect.Calc("Imp"), 8568);
         });
 
         // force tractrice (contrainte de cisaillement)
         it('Tau0 should equal to 2.804', () => {
-            expect(sect.Calc("Tau0")).toBeCloseTo(2.804, precDigits);
+            check(sect.Calc("Tau0"), 2.804);
         });
     });
 });
@@ -139,89 +143,89 @@ describe('Section paramétrée rectangulaire : ', () => {
     describe('fluvial / débordement :', () => {
         // charge spécifique
         it('Hs should equal to 2.003', () => {
-            expect(sect.Calc("Hs")).toBeCloseTo(2.003, precDigits);
+            check(sect.Calc("Hs"), 2.003);
         });
 
         // charge critique
         it('Hsc should equal to 0.43', () => {
-            expect(sect.Calc("Hsc")).toBeCloseTo(0.43, precDigits);
+            check(sect.Calc("Hsc"), 0.43);
         });
 
         // largeur au miroir
         it('B should equal to 2.5', () => {
-            expect(sect.Calc("B")).toBeCloseTo(2.5, precDigits);
+            check(sect.Calc("B"), 2.5);
         });
 
         // périmètre mouillé
         it('P should equal to 6.5', () => {
-            expect(sect.Calc("P")).toBeCloseTo(6.5, precDigits);
+            check(sect.Calc("P"), 6.5);
         });
 
         // surface mouillée
         it('S should equal to 5', () => {
-            expect(sect.Calc("S")).toBeCloseTo(5, precDigits);
+            check(sect.Calc("S"), 5);
         });
 
         // rayon hydraulique
         it('R should equal to 0.769', () => {
-            expect(sect.Calc("R")).toBeCloseTo(0.769, precDigits);
+            check(sect.Calc("R"), 0.769);
         });
 
         // vitesse moyenne
         it('V should equal to 0.24', () => {
-            expect(sect.Calc("V")).toBeCloseTo(0.24, precDigits);
+            check(sect.Calc("V"), 0.24);
         });
 
         // nombre de Froude
         it('Fr should equal to 0.0542', () => {
-            expect(sect.Calc("Fr")).toBeCloseTo(0.0542, precDigits);
+            check(sect.Calc("Fr"), 0.0542);
         });
 
         // tirant d'eau critique
         it('Yc should equal to 0.286', () => {
-            expect(sect.Calc("Yc")).toBeCloseTo(0.286, precDigits);
+            check(sect.Calc("Yc"), 0.286);
         });
 
         // tirant d'eau normal
         it('Yn should equal to 0.663', () => {
-            expect(sect.Calc("Yn")).toBeCloseTo(0.663, precDigits);
+            check(sect.Calc("Yn"), 0.663);
         });
 
         // tirant d'eau fluvial
         it('Yf should equal to 2', () => {
-            expect(sect.Calc("Yf")).toBeCloseTo(2, precDigits);
+            check(sect.Calc("Yf"), 2);
         });
 
         // tirant d'eau torrentiel
         it('Yt should equal to 0.078', () => {
-            expect(sect.Calc("Yt")).toBeCloseTo(0.078, precDigits);
+            check(sect.Calc("Yt"), 0.078);
         });
 
         // tirant d'eau conjugué
         it('Yco should equal to 0.012', () => {
-            expect(sect.Calc("Yco")).toBeCloseTo(0.012, precDigits);
+            check(sect.Calc("Yco"), 0.012);
         });
 
         // perte de charge
         it('J should equal to 0.00059', () => {
             sect = createSection(0.00001);
-            expect(sect.Calc("J")).toBeCloseTo(0.00059, precDigits);
+            check(sect.Calc("J"), 0.00059);
         });
 
         // Variation linéaire de l'énergie spécifique
         it('I-J should equal to 0.0009', () => {
             sect = createSection(0.00001);
-            expect(sect.Calc("I-J")).toBeCloseTo(0.0009, precDigits);
+            check(sect.Calc("I-J"), 0.0009);
         });
 
         // impulsion hydraulique
         it('Imp should equal to 49338', () => {
-            expect(sect.Calc("Imp")).toBeCloseTo(49338, precDigits);
+            check(sect.Calc("Imp"), 49338);
         });
 
         // force tractrice (contrainte de cisaillement)
         it('Tau0 should equal to 0.385', () => {
-            expect(sect.Calc("Tau0")).toBeCloseTo(0.385, precDigits);
+            check(sect.Calc("Tau0"), 0.385);
         });
     });
 });
diff --git a/spec/section_param_rect_torrentiel.spec.ts b/spec/section_param_rect_torrentiel.spec.ts
index c754fc2f6ed4dc347ef93791a1c8edaaabda9b95..108cb6a166b4f34ec9f737a80ef4f7a03e2f0e7e 100644
--- a/spec/section_param_rect_torrentiel.spec.ts
+++ b/spec/section_param_rect_torrentiel.spec.ts
@@ -1,12 +1,16 @@
 /// <reference path="../node_modules/@types/jasmine/index.d.ts" />
 
 import { Result } from "../src/base";
-import { nub, precDigits, precDist } from "./nubtest";
+import { precDist, equalEpsilon } from "./nubtest";
 import { ParamsSectionRectang, cSnRectang } from "../src/section/section_rectang";
 
 let paramSection: ParamsSectionRectang;
 let sect: cSnRectang;
 
+function check(val1: number, val2: number) {
+    expect(equalEpsilon(val1, val2)).toBeTruthy("expected " + val2 + ", got " + val1);
+}
+
 describe('Section paramétrée rectangulaire : ', () => {
     beforeEach(() => {
         paramSection = new ParamsSectionRectang(0.8, // tirant d'eau
@@ -25,89 +29,89 @@ describe('Section paramétrée rectangulaire : ', () => {
     describe('torrentiel :', () => {
         // charge spécifique
         it('Hs should equal to 2.074', () => {
-            expect(sect.Calc("Hs")).toBeCloseTo(2.074, precDigits);
+            check(sect.Calc("Hs"), 2.074);
         });
 
         // charge critique
         it('Hsc should equal to 1.766', () => {
-            expect(sect.Calc("Hsc")).toBeCloseTo(1.766, precDigits);
+            check(sect.Calc("Hsc"), 1.766);
         });
 
         // largeur au miroir
         it('B should equal to 2.5', () => {
-            expect(sect.Calc("B")).toBeCloseTo(2.5, precDigits);
+            check(sect.Calc("B"), 2.5);
         });
 
         // périmètre mouillé
         it('P should equal to 4.1', () => {
-            expect(sect.Calc("P")).toBeCloseTo(4.1, precDigits);
+            check(sect.Calc("P"), 4.1);
         });
 
         // surface mouillée
         it('S should equal to 2', () => {
-            expect(sect.Calc("S")).toBeCloseTo(2, precDigits);
+            check(sect.Calc("S"), 2);
         });
 
         // rayon hydraulique
         it('R should equal to 0.488', () => {
-            expect(sect.Calc("R")).toBeCloseTo(0.488, precDigits);
+            check(sect.Calc("R"), 0.488);
         });
 
         // vitesse moyenne
         it('V should equal to 5', () => {
-            expect(sect.Calc("V")).toBeCloseTo(5, precDigits);
+            check(sect.Calc("V"), 5);
         });
 
         // nombre de Froude
         it('Fr should equal to 1.785', () => {
-            expect(sect.Calc("Fr")).toBeCloseTo(1.785, precDigits);
+            check(sect.Calc("Fr"), 1.785);
         });
 
         // tirant d'eau critique
         it('Yc should equal to 1.177', () => {
-            expect(sect.Calc("Yc")).toBeCloseTo(1.177, precDigits);
+            check(sect.Calc("Yc"), 1.177);
         });
 
         // tirant d'eau normal
         it('Yn should equal to 3.364', () => {
-            expect(sect.Calc("Yn")).toBeCloseTo(3.364, precDigits);
+            check(sect.Calc("Yn"), 3.364);
         });
 
         // tirant d'eau fluvial
         it('Yf should equal to 1.831', () => {
-            expect(sect.Calc("Yf")).toBeCloseTo(1.831, precDigits);
+            check(sect.Calc("Yf"), 1.831);
         });
 
         // tirant d'eau torrentiel
         it('Yt should equal to 0.8', () => {
-            expect(sect.Calc("Yt")).toBeCloseTo(0.8, precDigits);
+            check(sect.Calc("Yt"), 0.8);
         });
 
         // tirant d'eau conjugué
         it('Yco should equal to 1.659', () => {
-            expect(sect.Calc("Yco")).toBeCloseTo(1.659, precDigits);
+            check(sect.Calc("Yco"), 1.659);
         });
 
         // perte de charge
         it('J should equal to 0.041', () => {
             //paramCnl.v.Prec = 0.00001;
-            expect(sect.Calc("J")).toBeCloseTo(0.041, precDigits);
+            check(sect.Calc("J"), 0.041);
         });
 
         // Variation linéaire de l'énergie spécifique
         it('I-J should equal to -0.04', () => {
             //paramCnl.v.Prec = 0.00001;
-            expect(sect.Calc("I-J")).toBeCloseTo(-0.04, precDigits);
+            check(sect.Calc("I-J"), -0.04);
         });
 
         // impulsion hydraulique
         it('Imp should equal to 57848', () => {
-            expect(sect.Calc("Imp")).toBeCloseTo(57848, precDigits);
+            check(sect.Calc("Imp"), 57848);
         });
 
         // force tractrice (contrainte de cisaillement)
         it('Tau0 should equal to 194.718', () => {
-            expect(sect.Calc("Tau0")).toBeCloseTo(194.718, precDigits);
+            check(sect.Calc("Tau0"), 194.718);
         });
     });
 });
diff --git a/spec/section_param_trapez_fluvial.spec.ts b/spec/section_param_trapez_fluvial.spec.ts
index 1107cdf6f083902691c8eb53d95b7d92fe325623..c152f2dc411180282a93440630b797a41aa12f77 100644
--- a/spec/section_param_trapez_fluvial.spec.ts
+++ b/spec/section_param_trapez_fluvial.spec.ts
@@ -1,7 +1,7 @@
 /// <reference path="../node_modules/@types/jasmine/index.d.ts" />
 
 import { Result } from "../src/base";
-import { nub, precDigits, precDist } from "./nubtest";
+import { equalEpsilon, precDist } from "./nubtest";
 import { ParamsSectionTrapez, cSnTrapez } from "../src/section/section_trapez";
 
 let paramSection: ParamsSectionTrapez;
@@ -37,6 +37,10 @@ function createSectionDebordement(prec: number): cSnTrapez {
     return new cSnTrapez(undefined, paramSection);
 }
 
+function check(val1: number, val2: number) {
+    expect(equalEpsilon(val1, val2)).toBeTruthy("expected " + val2 + ", got " + val1);
+}
+
 describe('Section paramétrée trapèze : ', () => {
     beforeEach(() => {
         sect = createSection(precDist);
@@ -45,88 +49,88 @@ describe('Section paramétrée trapèze : ', () => {
     describe('fluvial / pas de débordement :', () => {
         // charge spécifique
         it('Hs should equal to 0.813', () => {
-            expect(sect.Calc("Hs")).toBeCloseTo(0.813, precDigits);
+            check(sect.Calc("Hs"), 0.813);
         });
 
         // charge critique
         it('Hsc should equal to 0.413', () => {
-            expect(sect.Calc("Hsc")).toBeCloseTo(0.413, precDigits);
+            check(sect.Calc("Hsc"), 0.413);
         });
 
         // largeur au miroir
         it('B should equal to 3.396', () => {
-            expect(sect.Calc("B")).toBeCloseTo(3.396, precDigits);
+            check(sect.Calc("B"), 3.396);
         });
 
         // périmètre mouillé
         it('P should equal to 4.334', () => {
-            expect(sect.Calc("P")).toBeCloseTo(4.334, precDigits);
+            check(sect.Calc("P"), 4.334);
         });
 
         // surface mouillée
         it('S should equal to 2.358', () => {
-            expect(sect.Calc("S")).toBeCloseTo(2.358, precDigits);
+            check(sect.Calc("S"), 2.358);
         });
 
         // rayon hydraulique
         it('R should equal to 0.544', () => {
-            expect(sect.Calc("R")).toBeCloseTo(0.544, precDigits);
+            check(sect.Calc("R"), 0.544);
         });
 
         // vitesse moyenne
         it('V should equal to 0.509', () => {
-            expect(sect.Calc("V")).toBeCloseTo(0.509, precDigits);
+            check(sect.Calc("V"), 0.509);
         });
 
         // nombre de Froude
         it('Fr should equal to 0.195', () => {
-            expect(sect.Calc("Fr")).toBeCloseTo(0.195, precDigits);
+            check(sect.Calc("Fr"), 0.195);
         });
 
         // tirant d'eau critique
         it('Yc should equal to 0.28', () => {
-            expect(sect.Calc("Yc")).toBeCloseTo(0.28, precDigits);
+            check(sect.Calc("Yc"), 0.28);
         });
 
         // tirant d'eau normal
         it('Yn should equal to 0.587', () => {
-            expect(sect.Calc("Yn")).toBeCloseTo(0.587, precDigits);
+            check(sect.Calc("Yn"), 0.587);
         });
 
         // tirant d'eau fluvial
         it('Yf should equal to 0.8', () => {
-            expect(sect.Calc("Yf")).toBeCloseTo(0.8, precDigits);
+            check(sect.Calc("Yf"), 0.8);
         });
 
         // tirant d'eau torrentiel
         it('Yt should equal to 0.127', () => {
-            expect(sect.Calc("Yt")).toBeCloseTo(0.127, precDigits);
+            check(sect.Calc("Yt"), 0.127);
         });
 
         // tirant d'eau conjugué
         it('Yco should equal to 0.061', () => {
-            expect(sect.Calc("Yco")).toBeCloseTo(0.061, precDigits);
+            check(sect.Calc("Yco"), 0.061);
         });
 
         // perte de charge
         it('J should equal to 0.00036', () => {
             let sect = createSection(0.00001);
-            expect(sect.Calc("J")).toBeCloseTo(0.00036, precDigits);
+            check(sect.Calc("J"), 0.00036);
         });
 
         // Variation linéaire de l'énergie spécifique
         it('I-J should equal to 0.001', () => {
-            expect(sect.Calc("I-J")).toBeCloseTo(0.001, precDigits);
+            check(sect.Calc("I-J"), 0.001);
         });
 
         // impulsion hydraulique
         it('Imp should equal to 9396.158', () => {
-            expect(sect.Calc("Imp")).toBeCloseTo(9396.158, precDigits);
+            check(sect.Calc("Imp"), 9396.158);
         });
 
         // force tractrice (contrainte de cisaillement)
         it('Tau0 should equal to 1.944', () => {
-            expect(sect.Calc("Tau0")).toBeCloseTo(1.944, precDigits);
+            check(sect.Calc("Tau0"), 1.944);
         });
     });
 });
@@ -140,88 +144,88 @@ describe('Section paramétrée trapèze : ', () => {
     describe('fluvial / débordement :', () => {
         // charge spécifique
         it('Hs should equal to 2.002', () => {
-            expect(sect.Calc("Hs")).toBeCloseTo(2.002, precDigits);
+            check(sect.Calc("Hs"), 2.002);
         });
 
         // charge critique
         it('Hsc should equal to 0.413', () => {
-            expect(sect.Calc("Hsc")).toBeCloseTo(0.413, precDigits);
+            check(sect.Calc("Hsc"), 0.413);
         });
 
         // largeur au miroir
         it('B should equal to 3.62', () => {
-            expect(sect.Calc("B")).toBeCloseTo(3.62, precDigits);
+            check(sect.Calc("B"), 3.62);
         });
 
         // périmètre mouillé
         it('P should equal to 6.792', () => {
-            expect(sect.Calc("P")).toBeCloseTo(6.792, precDigits);
+            check(sect.Calc("P"), 6.792);
         });
 
         // surface mouillée
         it('S should equal to 6.68', () => {
-            expect(sect.Calc("S")).toBeCloseTo(6.68, precDigits);
+            check(sect.Calc("S"), 6.68);
         });
 
         // rayon hydraulique
         it('R should equal to 0.983', () => {
-            expect(sect.Calc("R")).toBeCloseTo(0.983, precDigits);
+            check(sect.Calc("R"), 0.983);
         });
 
         // vitesse moyenne
         it('V should equal to 0.18', () => {
-            expect(sect.Calc("V")).toBeCloseTo(0.18, precDigits);
+            check(sect.Calc("V"), 0.18);
         });
 
         // nombre de Froude
         it('Fr should equal to 0.042', () => {
-            expect(sect.Calc("Fr")).toBeCloseTo(0.042, precDigits);
+            check(sect.Calc("Fr"), 0.042);
         });
 
         // tirant d'eau critique
         it('Yc should equal to 0.28', () => {
-            expect(sect.Calc("Yc")).toBeCloseTo(0.28, precDigits);
+            check(sect.Calc("Yc"), 0.28);
         });
 
         // tirant d'eau normal
         it('Yn should equal to 0.587', () => {
-            expect(sect.Calc("Yn")).toBeCloseTo(0.587, precDigits);
+            check(sect.Calc("Yn"), 0.587);
         });
 
         // tirant d'eau fluvial
         it('Yf should equal to 2', () => {
-            expect(sect.Calc("Yf")).toBeCloseTo(2, precDigits);
+            check(sect.Calc("Yf"), 2);
         });
 
         // tirant d'eau torrentiel
         it('Yt should equal to 0.077', () => {
-            expect(sect.Calc("Yt")).toBeCloseTo(0.077, precDigits);
+            check(sect.Calc("Yt"), 0.077);
         });
 
         // tirant d'eau conjugué
         it('Yco should equal to 0.009', () => {
-            expect(sect.Calc("Yco")).toBeCloseTo(0.009, precDigits);
+            check(sect.Calc("Yco"), 0.009);
         });
 
         // perte de charge
         it('J should equal to 0.00002', () => {
             let sect = createSection(0.00001);
-            expect(sect.Calc("J")).toBeCloseTo(0.00002, precDigits);
+            check(sect.Calc("J"), 0.00002);
         });
 
         // Variation linéaire de l'énergie spécifique
         it('I-J should equal to 0.001', () => {
-            expect(sect.Calc("I-J")).toBeCloseTo(0.001, precDigits);
+            check(sect.Calc("I-J"), 0.001);
         });
 
         // impulsion hydraulique
         it('Imp should equal to 63915.169', () => {
-            expect(sect.Calc("Imp")).toBeCloseTo(63915.169, precDigits);
+            check(sect.Calc("Imp"), 63915.169);
         });
 
         // force tractrice (contrainte de cisaillement)
         it('Tau0 should equal to 0.199', () => {
-            expect(sect.Calc("Tau0")).toBeCloseTo(0.199, precDigits);
+            check(sect.Calc("Tau0"), 0.199);
         });
     });
 });
diff --git a/spec/section_param_trapez_torrentiel.spec.ts b/spec/section_param_trapez_torrentiel.spec.ts
index c653eee083637068f7e84c25b06846bb4f037d3d..d0e2f35e8044f19cd48926b5da41e260ad2262ba 100644
--- a/spec/section_param_trapez_torrentiel.spec.ts
+++ b/spec/section_param_trapez_torrentiel.spec.ts
@@ -1,12 +1,16 @@
 /// <reference path="../node_modules/@types/jasmine/index.d.ts" />
 
 import { Result } from "../src/base";
-import { nub, precDigits, precDist } from "./nubtest";
+import { equalEpsilon, precDist } from "./nubtest";
 import { ParamsSectionTrapez, cSnTrapez } from "../src/section/section_trapez";
 
 let paramCnl: ParamsSectionTrapez;
 let sect: cSnTrapez;
 
+function check(val1: number, val2: number) {
+    expect(equalEpsilon(val1, val2)).toBeTruthy("expected " + val2 + ", got " + val1);
+}
+
 describe('Section paramétrée trapèze :', () => {
     beforeEach(() => {
         paramCnl = new ParamsSectionTrapez(2.5, // largeur de fond
@@ -26,88 +30,88 @@ describe('Section paramétrée trapèze :', () => {
     describe('torrentiel :', () => {
         // charge spécifique
         it('Hs should equal to 1.716', () => {
-            expect(sect.Calc("Hs")).toBeCloseTo(1.716, precDigits);
+            check(sect.Calc("Hs"), 1.716);
         });
 
         // charge critique
         it('Hsc should equal to 1.534', () => {
-            expect(sect.Calc("Hsc")).toBeCloseTo(1.534, precDigits);
+            check(sect.Calc("Hsc"), 1.534);
         });
 
         // largeur au miroir
         it('B should equal to 3.396', () => {
-            expect(sect.Calc("B")).toBeCloseTo(3.396, precDigits);
+            check(sect.Calc("B"), 3.396);
         });
 
         // périmètre mouillé
         it('P should equal to 4.334', () => {
-            expect(sect.Calc("P")).toBeCloseTo(4.334, precDigits);
+            check(sect.Calc("P"), 4.334);
         });
 
         // surface mouillée
         it('S should equal to 2.358', () => {
-            expect(sect.Calc("S")).toBeCloseTo(2.358, precDigits);
+            check(sect.Calc("S"), 2.358);
         });
 
         // rayon hydraulique
         it('R should equal to 0.544', () => {
-            expect(sect.Calc("R")).toBeCloseTo(0.544, precDigits);
+            check(sect.Calc("R"), 0.544);
         });
 
         // vitesse moyenne
         it('V should equal to 4.24', () => {
-            expect(sect.Calc("V")).toBeCloseTo(4.24, precDigits);
+            check(sect.Calc("V"), 4.24);
         });
 
         // nombre de Froude
         it('Fr should equal to 1.625', () => {
-            expect(sect.Calc("Fr")).toBeCloseTo(1.625, precDigits);
+            check(sect.Calc("Fr"), 1.625);
         });
 
         // tirant d'eau critique
         it('Yc should equal to 1.074', () => {
-            expect(sect.Calc("Yc")).toBeCloseTo(1.074, precDigits);
+            check(sect.Calc("Yc"), 1.074);
         });
 
         // tirant d'eau normal
         it('Yn should equal to 2.275', () => {
-            expect(sect.Calc("Yn")).toBeCloseTo(2.275, precDigits);
+            check(sect.Calc("Yn"), 2.275);
         });
 
         // tirant d'eau fluvial
         it('Yf should equal to 1.502', () => {
-            expect(sect.Calc("Yf")).toBeCloseTo(1.502, precDigits);
+            check(sect.Calc("Yf"), 1.502);
         });
 
         // tirant d'eau torrentiel
         it('Yt should equal to 0.8', () => {
-            expect(sect.Calc("Yt")).toBeCloseTo(0.8, precDigits);
+            check(sect.Calc("Yt"), 0.8);
         });
 
         // tirant d'eau conjugué
         it('Yco should equal to 1.398', () => {
-            expect(sect.Calc("Yco")).toBeCloseTo(1.398, precDigits);
+            check(sect.Calc("Yco"), 1.398);
         });
 
         // perte de charge
         it('J should equal to 0.025', () => {
             //paramCnl.v.Prec = 0.00001;
-            expect(sect.Calc("J")).toBeCloseTo(0.025, precDigits);
+            check(sect.Calc("J"), 0.025);
         });
 
         // Variation linéaire de l'énergie spécifique
         it('I-J should equal to -0.024', () => {
-            expect(sect.Calc("I-J")).toBeCloseTo(-0.024, precDigits);
+            check(sect.Calc("I-J"), -0.024);
         });
 
         // impulsion hydraulique
         it('Imp should equal to 51187.203', () => {
-            expect(sect.Calc("Imp")).toBeCloseTo(51187.203, precDigits);
+            check(sect.Calc("Imp"), 51187.203);
         });
 
         // force tractrice (contrainte de cisaillement)
         it('Tau0 should equal to 135.020', () => {
-            expect(sect.Calc("Tau0")).toBeCloseTo(135.020, precDigits);
+            check(sect.Calc("Tau0"), 135.020);
         });
     });
 });