Feature #2887 categorical weights PR 1 of 2

internal/scripts/docker/Dockerfile.sonarqube

@@ -9,7 +9,7 @@ MAINTAINER John Halley Gotway <johnhg@ucar.edu>
 # SonarQube static code analysis on the specified branch or tag.
 # https://docs.sonarqube.org/latest/analysis/scan/sonarscanner/
 #
-ARG SONAR_SCANNER_VERSION=5.0.1.3006
+ARG SONAR_SCANNER_VERSION=6.1.0.4477
 ARG SONAR_HOST_URL
 ARG SONAR_TOKEN
 ARG SOURCE_BRANCH

internal/scripts/docker/build_met_sonarqube.sh

@@ -100,6 +100,7 @@ time_command ./configure \
   BUFRLIB_NAME=${BUFRLIB_NAME} \
   GRIB2CLIB_NAME=${GRIB2CLIB_NAME} \
   --enable-all \
+  MET_CXX_STANDARD=11 \
   CPPFLAGS="-I/usr/local/include -I/usr/local/include/freetype2 -I/usr/local/include/cairo" \
   LIBS="-ltirpc"
 

internal/scripts/sonarqube/run_sonarqube.sh

@@ -109,8 +109,9 @@ run_command "git checkout ${1}"
 # Otherwise, the SonarQube logic does not work.
 export MET_DEVELOPMENT=true
 
-# Run the configure script
-run_command "./configure --prefix=`pwd` --enable-all"
+# Run the configure script.
+# Specify the C++ standard to limit the scope of the findings.
+run_command "./configure --prefix=`pwd` --enable-all MET_CXX_STANDARD=11"
 
 # Define the version string
 SONAR_PROJECT_VERSION=$(grep "^version" docs/conf.py | cut -d'=' -f2 | tr -d "\'\" ")

src/basic/vx_util/num_array.h

@@ -57,7 +57,7 @@ class NumArray {
 
       double operator[](int) const;
 
-      const double * vals() const;
+      const std::vector<double> & vals() const;
       double * buf();
 
       int has(int, bool forward=true)    const;
@@ -127,12 +127,13 @@ class NumArray {
 ////////////////////////////////////////////////////////////////////////
 
 
-inline int            NumArray::n_elements()         const { return ( e.size() ); }
-inline int            NumArray::n         ()         const { return ( e.size() ); }
-inline const double * NumArray::vals()               const { return ( e.data() ); }
-inline       double * NumArray::buf()                      { return ( e.data() ); }
-inline void           NumArray::inc(int i, int v)          { e[i] += v; return;   }
-inline void           NumArray::inc(int i, double v)       { e[i] += v; return;   }
+inline int            NumArray::n_elements()         const { return e.size();   }
+inline int            NumArray::n()                  const { return e.size();   }
+inline const std::vector<double> &
+                      NumArray::vals()               const { return e;          }
+inline       double * NumArray::buf()                      { return e.data();   }
+inline void           NumArray::inc(int i, int v)          { e[i] += v; return; }
+inline void           NumArray::inc(int i, double v)       { e[i] += v; return; }
 
 
 ////////////////////////////////////////////////////////////////////////

src/basic/vx_util/thresh_array.cc

@@ -617,6 +617,12 @@ ThreshArray define_prob_bins(double beg, double end, double inc, int prec) {
       v += inc;
    }
 
+   // Add final 1.0 threshold, if needed
+   if(!is_eq(ta[(ta.n() - 1)].get_value(), 1.0)) {
+      cs << cs_erase << ">=1.0";
+      ta.add(cs.c_str());
+   }
+
    return ta;
 }
 

src/libcode/vx_statistics/compute_ci.cc

@@ -171,9 +171,8 @@ void compute_wilson_ci(double p, int n_int, double alpha, double vif,
 ////////////////////////////////////////////////////////////////////////
 
 void compute_woolf_ci(double odds, double alpha,
-                      int fy_oy, int fy_on, int fn_oy, int fn_on,
+                      double fy_oy, double fy_on, double fn_oy, double fn_on,
                       double &odds_cl, double &odds_cu) {
-   double cv_normal_l, cv_normal_u, a, b;
 
    if(is_bad_data(odds) ||
       fy_oy == 0 || fy_on == 0 || fn_oy == 0 || fn_on == 0) {
@@ -185,14 +184,14 @@ void compute_woolf_ci(double odds, double alpha,
    // Compute the upper and lower critical values from the
    // normal distribution.
    //
-   cv_normal_l = normal_cdf_inv(alpha/2.0, 0.0, 1.0);
-   cv_normal_u = normal_cdf_inv(1.0 - (alpha/2.0), 0.0, 1.0);
+   double cv_normal_l = normal_cdf_inv(alpha/2.0, 0.0, 1.0);
+   double cv_normal_u = normal_cdf_inv(1.0 - (alpha/2.0), 0.0, 1.0);
 
    //
    // Compute the upper and lower bounds of the confidence interval
    //
-   a = exp(cv_normal_l*sqrt(1.0/fy_oy + 1.0/fy_on + 1.0/fn_oy + 1.0/fn_on));
-   b = exp(cv_normal_u*sqrt(1.0/fy_oy + 1.0/fy_on + 1.0/fn_oy + 1.0/fn_on));
+   double a = exp(cv_normal_l*sqrt(1.0/fy_oy + 1.0/fy_on + 1.0/fn_oy + 1.0/fn_on));
+   double b = exp(cv_normal_u*sqrt(1.0/fy_oy + 1.0/fy_on + 1.0/fn_oy + 1.0/fn_on));
 
    odds_cl = odds * a;
    odds_cu = odds * b;
@@ -210,19 +209,16 @@ void compute_woolf_ci(double odds, double alpha,
 ////////////////////////////////////////////////////////////////////////
 
 void compute_hk_ci(double hk, double alpha, double vif,
-                   int fy_oy, int fy_on, int fn_oy, int fn_on,
+                   double fy_oy, double fy_on, double fn_oy, double fn_on,
                    double &hk_cl, double &hk_cu) {
-   double cv_normal, stdev;
-   double h, h_var, f_var;
-   int h_n, f_n;
 
    //
    // Get the counts
    //
-   h_n = fy_oy + fn_oy;
-   f_n = fn_on + fy_on;
+   double h_n = fy_oy + fn_oy;
+   double f_n = fn_on + fy_on;
 
-   if(is_bad_data(hk) || h_n == 0 || f_n == 0) {
+   if(is_bad_data(hk) || is_eq(h_n, 0.0) || is_eq(f_n, 0.0)) {
       hk_cl = hk_cu = bad_data_double;
       return;
    }
@@ -231,26 +227,26 @@ void compute_hk_ci(double hk, double alpha, double vif,
    // Compute the critical value for the normal distribution based
    // on the sample size
    //
-   cv_normal = normal_cdf_inv(alpha/2.0, 0.0, 1.0);
+   double cv_normal = normal_cdf_inv(alpha/2.0, 0.0, 1.0);
 
    //
    // Compute the hit rate and false alarm rate
    //
-   h = (double) fy_oy/h_n;
+   double h = fy_oy/h_n;
 
    //
    // Compute a variance for H and F
    //
-   h_var = sqrt(h*(1.0-h)/h_n + cv_normal*cv_normal/(4.0*h_n*h_n))
-         / (1.0 + cv_normal*cv_normal/h_n);
+   double h_var = sqrt(h*(1.0-h)/h_n + cv_normal*cv_normal/(4.0*h_n*h_n))
+                  / (1.0 + cv_normal*cv_normal/h_n);
 
-   f_var = sqrt(h*(1.0-h)/f_n + cv_normal*cv_normal/(4.0*f_n*f_n))
-         / (1.0 + cv_normal*cv_normal/f_n);
+   double f_var = sqrt(h*(1.0-h)/f_n + cv_normal*cv_normal/(4.0*f_n*f_n))
+                  / (1.0 + cv_normal*cv_normal/f_n);
 
    //
    // Compute the standard deviation for HK
    //
-   stdev = sqrt(vif*(h_var*h_var + f_var*f_var));
+   double stdev = sqrt(vif*(h_var*h_var + f_var*f_var));
 
    //
    // Compute the upper and lower bounds of the confidence interval

src/libcode/vx_statistics/compute_ci.h

@@ -38,11 +38,11 @@ extern void compute_wilson_ci(double p, int n, double alpha,
    double vif, double &p_cl, double &p_cu);
 
 extern void compute_woolf_ci(double odds, double alpha,
-   int fy_oy, int fy_on, int fn_oy, int fn_on,
+   double fy_oy, double fy_on, double fn_oy, double fn_on,
    double &odds_cl, double &odds_cu);
 
 extern void compute_hk_ci(double hk, double alpha, double vif,
-   int fy_oy, int fy_on, int fn_oy, int fn_on,
+   double fy_oy, double fy_on, double fn_oy, double fn_on,
    double &hk_cl, double &hk_cu);
 
 extern void compute_cts_stats_ci_bca(const gsl_rng *,