EMNR: make internal calculations in double precision

wdsp/calculus.cpp

@@ -29,7 +29,7 @@ warren@wpratt.com
 
 namespace WDSP {
 
-const float Calculus::GG[241 * 241] = {
+const double Calculus::GG[241 * 241] = {
 7.25654181154076983e-01,    7.05038822098223439e-01,    6.85008217584843870e-01,    6.65545775927326222e-01,
 6.46635376294157682e-01,    6.28261355371665386e-01,    6.10408494407843394e-01,    5.93062006626410732e-01,
 5.76207525000389742e-01,    5.59831090374464435e-01,    5.43919139925240769e-01,    5.28458495948192608e-01,
@@ -14552,7 +14552,7 @@ const float Calculus::GG[241 * 241] = {
 1.00000000000000000e+00,    1.00000000000000000e+00,    1.00000000000000000e+00,    1.00000000000000000e+00,
 1.00000000000000000e+00 };
 
-const float Calculus::GGS[241 * 241] = {
+const double Calculus::GGS[241 * 241] = {
 8.00014908335353492e-01,    8.00020707540703313e-01,    8.00026700706648830e-01,    8.00032894400760863e-01,
 8.00039295417528384e-01,    8.00045910786425396e-01,    8.00052747780268358e-01,    8.00059813923879481e-01,
 8.00067117003061101e-01,    8.00074665073896907e-01,    8.00082466472385456e-01,    8.00090529824419749e-01,

wdsp/calculus.hpp

@@ -36,8 +36,8 @@ namespace WDSP {
 class WDSP_API Calculus
 {
 public:
-    static const float GG[];
+    static const double GG[];
-    static const float GGS[];
+    static const double GGS[];
 };
 
 } // namespace WDSP

wdsp/emnr.cpp

@@ -48,9 +48,9 @@ namespace WDSP {
 // Shanjie Zhang and Jianming Jin, "Computation of Special Functions."  New York, NY, John Wiley and Sons,
 //      Inc., 1996.  [Sample code given in FORTRAN]
 
-float EMNR::bessI0 (float x)
+double EMNR::bessI0 (double x)
 {
-    float res, p;
+    double res, p;
     if (x == 0.0)
         res = 1.0;
     else
@@ -86,10 +86,10 @@ float EMNR::bessI0 (float x)
     return res;
 }
 
-float EMNR::bessI1 (float x)
+double EMNR::bessI1 (double x)
 {
 
-    float res, p;
+    double res, p;
     if (x == 0.0)
         res = 0.0;
     else
@@ -132,9 +132,9 @@ float EMNR::bessI1 (float x)
 // Shanjie Zhang and Jianming Jin, "Computation of Special Functions."  New York, NY, John Wiley and Sons,
 //      Inc., 1996.  [Sample code given in FORTRAN]
 
-float EMNR::e1xb (float x)
+double EMNR::e1xb (double x)
 {
-    float e1, ga, r, t, t0;
+    double e1, ga, r, t, t0;
     int k, m;
     if (x == 0.0)
         e1 = 1.0e300;
@@ -193,7 +193,7 @@ void EMNR::calc_window (EMNR *a)
     }
 }
 
-void EMNR::interpM (float* res, float x, int nvals, float* xvals, float* yvals)
+void EMNR::interpM (double* res, double x, int nvals, double* xvals, double* yvals)
 {
     if (x <= xvals[0])
         *res = yvals[0];
@@ -202,7 +202,7 @@ void EMNR::interpM (float* res, float x, int nvals, float* xvals, float* yvals)
     else
     {
         int idx = 0;
-        float xllow, xlhigh, frac;
+        double xllow, xlhigh, frac;
         while (x >= xvals[idx])  idx++;
         xllow = log10 (xvals[idx - 1]);
         xlhigh = log10(xvals[idx]);
@@ -214,9 +214,9 @@ void EMNR::interpM (float* res, float x, int nvals, float* xvals, float* yvals)
 void EMNR::calc_emnr(EMNR *a)
 {
     int i;
-    float Dvals[18] = { 1.0, 2.0, 5.0, 8.0, 10.0, 15.0, 20.0, 30.0, 40.0,
+    double Dvals[18] = { 1.0, 2.0, 5.0, 8.0, 10.0, 15.0, 20.0, 30.0, 40.0,
         60.0, 80.0, 120.0, 140.0, 160.0, 180.0, 220.0, 260.0, 300.0 };
-    float Mvals[18] = { 0.000, 0.260, 0.480, 0.580, 0.610, 0.668, 0.705, 0.762, 0.800,
+    double Mvals[18] = { 0.000, 0.260, 0.480, 0.580, 0.610, 0.668, 0.705, 0.762, 0.800,
         0.841, 0.865, 0.890, 0.900, 0.910, 0.920, 0.930, 0.935, 0.940 };
     // float Hvals[18] = { 0.000, 0.150, 0.480, 0.780, 0.980, 1.550, 2.000, 2.300, 2.520,
     //     3.100, 3.380, 4.150, 4.350, 4.250, 3.900, 4.100, 4.700, 5.000 };
@@ -246,7 +246,8 @@ void EMNR::calc_emnr(EMNR *a)
     a->inaccum = new float[a->iasize]; // (float *)malloc0(a->iasize * sizeof(float));
     a->forfftin = new float[a->fsize]; // (float *)malloc0(a->fsize * sizeof(float));
     a->forfftout = new float[a->msize * 2]; // (float *)malloc0(a->msize * sizeof(complex));
-    a->mask = new float[a->msize]; // (float *)malloc0(a->msize * sizeof(float));
+    a->mask = new double[a->msize]; // (float *)malloc0(a->msize * sizeof(float));
+    std::fill(a->mask, a->mask + a->msize, 1.0);
     a->revfftin = new float[a->msize * 2]; // (float *)malloc0(a->msize * sizeof(complex));
     a->revfftout = new float[a->fsize]; // (float *)malloc0(a->fsize * sizeof(float));
     a->save = new float*[a->ovrlp]; // (float **)malloc0(a->ovrlp * sizeof(float *));
@@ -262,10 +263,10 @@ void EMNR::calc_emnr(EMNR *a)
     a->g.msize = a->msize;
     a->g.mask = a->mask;
     a->g.y = a->forfftout;
-    a->g.lambda_y = new float[a->msize]; // (float *)malloc0(a->msize * sizeof(float));
+    a->g.lambda_y = new double[a->msize]; // (float *)malloc0(a->msize * sizeof(float));
-    a->g.lambda_d = new float[a->msize]; // (float *)malloc0(a->msize * sizeof(float));
+    a->g.lambda_d = new double[a->msize]; // (float *)malloc0(a->msize * sizeof(float));
-    a->g.prev_gamma = new float[a->msize]; // (float *)malloc0(a->msize * sizeof(float));
+    a->g.prev_gamma = new double[a->msize]; // (float *)malloc0(a->msize * sizeof(float));
-    a->g.prev_mask = new float[a->msize]; // (float *)malloc0(a->msize * sizeof(float));
+    a->g.prev_mask = new double[a->msize]; // (float *)malloc0(a->msize * sizeof(float));
 
     a->g.gf1p5 = sqrt(PI) / 2.0;
     {
@@ -282,8 +283,8 @@ void EMNR::calc_emnr(EMNR *a)
     }
     a->g.gmax = 10000.0;
     //
-    a->g.GG = new float[241 * 241]; // (float *)malloc0(241 * 241 * sizeof(float));
+    a->g.GG = new double[241 * 241]; // (float *)malloc0(241 * 241 * sizeof(float));
-    a->g.GGS = new float[241 * 241]; // (float *)malloc0(241 * 241 * sizeof(float));
+    a->g.GGS = new double[241 * 241]; // (float *)malloc0(241 * 241 * sizeof(float));
     if ((a->g.fileb = fopen("calculus", "rb")))
     {
         std::size_t lgg = fread(a->g.GG, sizeof(float), 241 * 241, a->g.fileb);
@@ -356,23 +357,23 @@ void EMNR::calc_emnr(EMNR *a)
         a->np.nsmax[3] = pow(10.0, db / 10.0 * a->np.V * a->np.incr / a->np.rate);
     }
 
-    a->np.p = new float[a->np.msize]; // (float *)malloc0(a->np.msize * sizeof(float));
+    a->np.p = new double[a->np.msize]; // (float *)malloc0(a->np.msize * sizeof(float));
-    a->np.alphaOptHat = new float[a->np.msize]; // (float *)malloc0(a->np.msize * sizeof(float));
+    a->np.alphaOptHat = new double[a->np.msize]; // (float *)malloc0(a->np.msize * sizeof(float));
-    a->np.alphaHat = new float[a->np.msize]; // (float *)malloc0(a->np.msize * sizeof(float));
+    a->np.alphaHat = new double[a->np.msize]; // (float *)malloc0(a->np.msize * sizeof(float));
-    a->np.sigma2N = new float[a->np.msize]; // (float *)malloc0(a->np.msize * sizeof(float));
+    a->np.sigma2N = new double[a->np.msize]; // (float *)malloc0(a->np.msize * sizeof(float));
-    a->np.pbar = new float[a->np.msize]; // (float *)malloc0(a->np.msize * sizeof(float));
+    a->np.pbar = new double[a->np.msize]; // (float *)malloc0(a->np.msize * sizeof(float));
-    a->np.p2bar = new float[a->np.msize]; // (float *)malloc0(a->np.msize * sizeof(float));
+    a->np.p2bar = new double[a->np.msize]; // (float *)malloc0(a->np.msize * sizeof(float));
-    a->np.Qeq = new float[a->np.msize]; // (float *)malloc0(a->np.msize * sizeof(float));
+    a->np.Qeq = new double[a->np.msize]; // (float *)malloc0(a->np.msize * sizeof(float));
-    a->np.bmin = new float[a->np.msize]; // (float *)malloc0(a->np.msize * sizeof(float));
+    a->np.bmin = new double[a->np.msize]; // (float *)malloc0(a->np.msize * sizeof(float));
-    a->np.bmin_sub = new float[a->np.msize]; // (float *)malloc0(a->np.msize * sizeof(float));
+    a->np.bmin_sub = new double[a->np.msize]; // (float *)malloc0(a->np.msize * sizeof(float));
     a->np.k_mod = new int[a->np.msize]; // (int *)malloc0(a->np.msize * sizeof(int));
-    a->np.actmin = new float[a->np.msize]; // (float *)malloc0(a->np.msize * sizeof(float));
+    a->np.actmin = new double[a->np.msize]; // (float *)malloc0(a->np.msize * sizeof(float));
-    a->np.actmin_sub =  new float[a->np.msize]; // (float *)malloc0(a->np.msize * sizeof(float));
+    a->np.actmin_sub =  new double[a->np.msize]; // (float *)malloc0(a->np.msize * sizeof(float));
     a->np.lmin_flag = new int[a->np.msize]; // (int *)malloc0(a->np.msize * sizeof(int));
-    a->np.pmin_u = new float[a->np.msize]; // (float *)malloc0(a->np.msize * sizeof(float));
+    a->np.pmin_u = new double[a->np.msize]; // (float *)malloc0(a->np.msize * sizeof(float));
-    a->np.actminbuff = new float*[a->np.U]; // (float**)malloc0(a->np.U     * sizeof(float*));
+    a->np.actminbuff = new double*[a->np.U]; // (float**)malloc0(a->np.U     * sizeof(float*));
     for (i = 0; i < a->np.U; i++)
-        a->np.actminbuff[i] = new float[a->np.msize]; // (float *)malloc0(a->np.msize * sizeof(float));
+        a->np.actminbuff[i] = new double[a->np.msize]; // (float *)malloc0(a->np.msize * sizeof(float));
 
     {
         int k, ku;
@@ -412,10 +413,10 @@ void EMNR::calc_emnr(EMNR *a)
     a->nps.epsH1 = pow(10.0, 15.0 / 10.0);
     a->nps.epsH1r = a->nps.epsH1 / (1.0 + a->nps.epsH1);
 
-    a->nps.sigma2N = new float[a->nps.msize]; // (float *)malloc0(a->nps.msize * sizeof(float));
+    a->nps.sigma2N = new double[a->nps.msize]; // (float *)malloc0(a->nps.msize * sizeof(float));
-    a->nps.PH1y = new float[a->nps.msize]; // (float *)malloc0(a->nps.msize * sizeof(float));
+    a->nps.PH1y = new double[a->nps.msize]; // (float *)malloc0(a->nps.msize * sizeof(float));
-    a->nps.Pbar = new float[a->nps.msize]; // (float *)malloc0(a->nps.msize * sizeof(float));
+    a->nps.Pbar = new double[a->nps.msize]; // (float *)malloc0(a->nps.msize * sizeof(float));
-    a->nps.EN2y = new float[a->nps.msize]; // (float *)malloc0(a->nps.msize * sizeof(float));
+    a->nps.EN2y = new double[a->nps.msize]; // (float *)malloc0(a->nps.msize * sizeof(float));
 
     for (i = 0; i < a->nps.msize; i++)
     {
@@ -429,7 +430,7 @@ void EMNR::calc_emnr(EMNR *a)
     a->ae.zetaThresh = 0.75;
     a->ae.psi = 10.0;
 
-    a->ae.nmask = new float[a->ae.msize]; // (float *)malloc0(a->ae.msize * sizeof(float));
+    a->ae.nmask = new double[a->ae.msize]; // (float *)malloc0(a->ae.msize * sizeof(float));
 }
 
 void EMNR::decalc_emnr(EMNR *a)
@@ -482,8 +483,21 @@ void EMNR::decalc_emnr(EMNR *a)
     delete[] (a->window);
 }
 
-EMNR* EMNR::create_emnr (int run, int position, int size, float* in, float* out, int fsize, int ovrlp,
+EMNR* EMNR::create_emnr (
-    int rate, int wintype, float gain, int gain_method, int npe_method, int ae_run)
+    int run,
+    int position,
+    int size,
+    float* in,
+    float* out,
+    int fsize,
+    int ovrlp,
+    int rate,
+    int wintype,
+    float gain,
+    int gain_method,
+    int npe_method,
+    int ae_run
+)
 {
     EMNR *a = new EMNR;
 
@@ -528,17 +542,17 @@ void EMNR::destroy_emnr (EMNR *a)
 void EMNR::LambdaD(EMNR *a)
 {
     int k;
-    float f0, f1, f2, f3;
+    double f0, f1, f2, f3;
-    float sum_prev_p;
+    double sum_prev_p;
-    float sum_lambda_y;
+    double sum_lambda_y;
-    float alphaCtilda;
+    double alphaCtilda;
-    float sum_prev_sigma2N;
+    double sum_prev_sigma2N;
-    float alphaMin, SNR;
+    double alphaMin, SNR;
-    float beta, varHat, invQeq;
+    double beta, varHat, invQeq;
-    float invQbar;
+    double invQbar;
-    float bc;
+    double bc;
-    float QeqTilda, QeqTildaSub;
+    double QeqTilda, QeqTildaSub;
-    float noise_slope_max;
+    double noise_slope_max;
 
     sum_prev_p = 0.0;
     sum_lambda_y = 0.0;
@@ -658,7 +672,7 @@ void EMNR::LambdaDs (EMNR *a)
         a->nps.PH1y[k] = 1.0 / (1.0 + (1.0 + a->nps.epsH1) * exp (- a->nps.epsH1r * a->nps.lambda_y[k] / a->nps.sigma2N[k]));
         a->nps.Pbar[k] = a->nps.alpha_Pbar * a->nps.Pbar[k] + (1.0 - a->nps.alpha_Pbar) * a->nps.PH1y[k];
         if (a->nps.Pbar[k] > 0.99)
-            a->nps.PH1y[k] = std::min (a->nps.PH1y[k], 0.99f);
+            a->nps.PH1y[k] = std::min (a->nps.PH1y[k], 0.99);
         a->nps.EN2y[k] = (1.0 - a->nps.PH1y[k]) * a->nps.lambda_y[k] + a->nps.PH1y[k] * a->nps.sigma2N[k];
         a->nps.sigma2N[k] = a->nps.alpha_pow * a->nps.sigma2N[k] + (1.0 - a->nps.alpha_pow) * a->nps.EN2y[k];
     }
@@ -697,12 +711,12 @@ void EMNR::aepf(EMNR *a)
     std::copy(a->ae.nmask, a->ae.nmask + (a->ae.msize - 2 * n), a->mask + n);
 }
 
-float EMNR::getKey(float* type, float gamma, float xi)
+double EMNR::getKey(double* type, double gamma, double xi)
 {
-    int ngamma1, ngamma2, nxi1, nxi2;
+    int ngamma1, ngamma2, nxi1 = 0, nxi2 = 0;
-    float tg, tx, dg, dx;
+    double tg, tx, dg, dx;
-    const float dmin = 0.001;
+    const double dmin = 0.001;
-    const float dmax = 1000.0;
+    const double dmax = 1000.0;
     if (gamma <= dmin)
     {
         ngamma1 = ngamma2 = 0;
@@ -748,7 +762,9 @@ void EMNR::calc_gain (EMNR *a)
     int k;
     for (k = 0; k < a->g.msize; k++)
     {
-        a->g.lambda_y[k] = a->g.y[2 * k + 0] * a->g.y[2 * k + 0] + a->g.y[2 * k + 1] * a->g.y[2 * k + 1];
+        double y0 = a->g.y[2 * k + 0];
+        double y1 = a->g.y[2 * k + 1];
+        a->g.lambda_y[k] = y0 * y0 + y1 * y1;
     }
     switch (a->g.npe_method)
     {
@@ -763,7 +779,7 @@ void EMNR::calc_gain (EMNR *a)
     {
     case 0:
         {
-            float gamma, eps_hat, v;
+            double gamma, eps_hat, v;
             for (k = 0; k < a->msize; k++)
             {
                 gamma = std::min (a->g.lambda_y[k] / a->g.lambda_d[k], a->g.gamma_max);
@@ -773,10 +789,10 @@ void EMNR::calc_gain (EMNR *a)
                 a->g.mask[k] = a->g.gf1p5 * sqrt (v) / gamma * exp (- 0.5 * v)
                     * ((1.0 + v) * bessI0 (0.5 * v) + v * bessI1 (0.5 * v));
                 {
-                    float v2 = std::min (v, 700.0f);
+                    double v2 = std::min (v, 700.0);
-                    float eta = a->g.mask[k] * a->g.mask[k] * a->g.lambda_y[k] / a->g.lambda_d[k];
+                    double eta = a->g.mask[k] * a->g.mask[k] * a->g.lambda_y[k] / a->g.lambda_d[k];
-                    float eps = eta / (1.0 - a->g.q);
+                    double eps = eta / (1.0 - a->g.q);
-                    float witchHat = (1.0 - a->g.q) / a->g.q * exp (v2) / (1.0 + eps);
+                    double witchHat = (1.0 - a->g.q) / a->g.q * exp (v2) / (1.0 + eps);
                     a->g.mask[k] *= witchHat / (1.0 + witchHat);
                 }
                 if (a->g.mask[k] > a->g.gmax) a->g.mask[k] = a->g.gmax;
@@ -788,7 +804,7 @@ void EMNR::calc_gain (EMNR *a)
         }
     case 1:
         {
-            float gamma, eps_hat, v, ehr;
+            double gamma, eps_hat, v, ehr;
             for (k = 0; k < a->g.msize; k++)
             {
                 gamma = std::min (a->g.lambda_y[k] / a->g.lambda_d[k], a->g.gamma_max);
@@ -805,7 +821,7 @@ void EMNR::calc_gain (EMNR *a)
         }
     case 2:
         {
-            float gamma, eps_hat, eps_p;
+            double gamma, eps_hat, eps_p;
             for (k = 0; k < a->msize; k++)
             {
                 gamma = std::min(a->g.lambda_y[k] / a->g.lambda_d[k], a->g.gamma_max);
@@ -952,14 +968,14 @@ void EMNR::SetEMNRPosition (RXA& rxa, int position)
     rxa.csDSP.unlock();
 }
 
-void EMNR::SetEMNRaeZetaThresh (RXA& rxa, float zetathresh)
+void EMNR::SetEMNRaeZetaThresh (RXA& rxa, double zetathresh)
 {
     rxa.csDSP.lock();
     rxa.emnr.p->ae.zetaThresh = zetathresh;
     rxa.csDSP.unlock();
 }
 
-void EMNR::SetEMNRaePsi (RXA& rxa, float psi)
+void EMNR::SetEMNRaePsi (RXA& rxa, double psi)
 {
     rxa.csDSP.lock();
     rxa.emnr.p->ae.psi = psi;

wdsp/emnr.hpp

@@ -52,7 +52,7 @@ public:
     float* forfftin;
     float* forfftout;
     int msize;
-    float* mask;
+    double* mask;
     float* revfftin;
     float* revfftout;
     float** save;
@@ -76,95 +76,108 @@ public:
         int gain_method;
         int npe_method;
         int ae_run;
-        float msize;
+        double msize;
-        float* mask;
+        double* mask;
         float* y;
-        float* lambda_y;
+        double* lambda_y;
-        float* lambda_d;
+        double* lambda_d;
-        float* prev_mask;
+        double* prev_mask;
-        float* prev_gamma;
+        double* prev_gamma;
-        float gf1p5;
+        double gf1p5;
-        float alpha;
+        double alpha;
-        float eps_floor;
+        double eps_floor;
-        float gamma_max;
+        double gamma_max;
-        float q;
+        double q;
-        float gmax;
+        double gmax;
         //
-        float* GG;
+        double* GG;
-        float* GGS;
+        double* GGS;
         FILE* fileb;
     } g;
     struct _npest
     {
         int incr;
-        float rate;
+        double rate;
         int msize;
-        float* lambda_y;
+        double* lambda_y;
-        float* lambda_d;
+        double* lambda_d;
-        float* p;
+        double* p;
-        float* alphaOptHat;
+        double* alphaOptHat;
-        float alphaC;
+        double alphaC;
-        float alphaCsmooth;
+        double alphaCsmooth;
-        float alphaCmin;
+        double alphaCmin;
-        float* alphaHat;
+        double* alphaHat;
-        float alphaMax;
+        double alphaMax;
-        float* sigma2N;
+        double* sigma2N;
-        float alphaMin_max_value;
+        double alphaMin_max_value;
-        float snrq;
+        double snrq;
-        float betamax;
+        double betamax;
-        float* pbar;
+        double* pbar;
-        float* p2bar;
+        double* p2bar;
-        float invQeqMax;
+        double invQeqMax;
-        float av;
+        double av;
-        float* Qeq;
+        double* Qeq;
         int U;
-        float Dtime;
+        double Dtime;
         int V;
         int D;
-        float MofD;
+        double MofD;
-        float MofV;
+        double MofV;
-        float* bmin;
+        double* bmin;
-        float* bmin_sub;
+        double* bmin_sub;
         int* k_mod;
-        float* actmin;
+        double* actmin;
-        float* actmin_sub;
+        double* actmin_sub;
         int subwc;
         int* lmin_flag;
-        float* pmin_u;
+        double* pmin_u;
-        float invQbar_points[4];
+        double invQbar_points[4];
-        float nsmax[4];
+        double nsmax[4];
-        float** actminbuff;
+        double** actminbuff;
         int amb_idx;
     } np;
     struct _npests
     {
         int incr;
-        float rate;
+        double rate;
         int msize;
-        float* lambda_y;
+        double* lambda_y;
-        float* lambda_d;
+        double* lambda_d;
 
-        float alpha_pow;
+        double alpha_pow;
-        float alpha_Pbar;
+        double alpha_Pbar;
-        float epsH1;
+        double epsH1;
-        float epsH1r;
+        double epsH1r;
 
-        float* sigma2N;
+        double* sigma2N;
-        float* PH1y;
+        double* PH1y;
-        float* Pbar;
+        double* Pbar;
-        float* EN2y;
+        double* EN2y;
     } nps;
     struct _ae
     {
         int msize;
-        float* lambda_y;
+        double* lambda_y;
-        float zetaThresh;
+        double zetaThresh;
-        float psi;
+        double psi;
-        float* nmask;
+        double* nmask;
     } ae;
 
-    static EMNR* create_emnr (int run, int position, int size, float* in, float* out, int fsize, int ovrlp,
+    static EMNR* create_emnr (
-        int rate, int wintype, float gain, int gain_method, int npe_method, int ae_run);
+        int run,
+        int position,
+        int size,
+        float* in,
+        float* out,
+        int fsize,
+        int ovrlp,
+        int rate,
+        int wintype,
+        float gain,
+        int gain_method,
+        int npe_method,
+        int ae_run
+    );
     static void destroy_emnr (EMNR *a);
     static void flush_emnr (EMNR *a);
     static void xemnr (EMNR *a, int pos);
@@ -177,21 +190,21 @@ public:
     static void SetEMNRnpeMethod (RXA& rxa, int method);
     static void SetEMNRaeRun (RXA& rxa, int run);
     static void SetEMNRPosition (RXA& rxa, int position);
-    static void SetEMNRaeZetaThresh (RXA& rxa, float zetathresh);
+    static void SetEMNRaeZetaThresh (RXA& rxa, double zetathresh);
-    static void SetEMNRaePsi (RXA& rxa, float psi);
+    static void SetEMNRaePsi (RXA& rxa, double psi);
 
 private:
-    static float bessI0 (float x);
+    static double bessI0 (double x);
-    static float bessI1 (float x);
+    static double bessI1 (double x);
-    static float e1xb (float x);
+    static double e1xb (double x);
     static void calc_window (EMNR *a);
-    static void interpM (float* res, float x, int nvals, float* xvals, float* yvals);
+    static void interpM (double* res, double x, int nvals, double* xvals, double* yvals);
     static void calc_emnr(EMNR *a);
     static void decalc_emnr(EMNR *a);
     static void LambdaD(EMNR *a);
     static void LambdaDs (EMNR *a);
     static void aepf(EMNR *a);
-    static float getKey(float* type, float gamma, float xi);
+    static double getKey(double* type, double gamma, double xi);
     static void calc_gain (EMNR *a);
 };