v1.15.4 Move SMap NaN warning to verbose. Improve ComputeError NaN handling.

Author: SoftwareLiteracy

src/API.cc

@@ -458,23 +458,21 @@ SMapValues SMap( DataFrame< double > & DF,
     }
     DF.FindNan( nanColsCheck ); // If nan, set DF.nanFound, DF.nanRows
 
-    if ( DF.NanFound() ) {
+    if ( parameters.verbose and DF.NanFound() ) {
         // Issue warning
         std::stringstream msg;
         msg << "WARNING: SMap() " << DF.NanRows().size()
             << " nan rows detected in columns or target. "
             << "Original number of rows " << DF.NRows() << ".\n";
         std::cout << msg.str();
 
-        if ( parameters.verbose ) {
-            msg.str( std::string() ); // clear msg 
-            msg << "WARNING: SMap() nan rows: ";
-            std::vector< size_t >::iterator ni;
-            for ( ni = DF.NanRows().begin(); ni != DF.NanRows().end(); ++ni ) {
-                msg << *ni + 1 << " ";
-            } msg << "\n";
-            std::cout << msg.str();
-        }
+        msg.str( std::string() ); // clear msg 
+        msg << "WARNING: SMap() nan rows: ";
+        std::vector< size_t >::iterator ni;
+        for ( ni = DF.NanRows().begin(); ni != DF.NanRows().end(); ++ni ) {
+            msg << *ni + 1 << " ";
+        } msg << "\n";
+        std::cout << msg.str();
     }
 
     //-----------------------------------------------------------------

src/Common.cc

@@ -113,7 +113,7 @@ VectorError ComputeError( std::valarray< double > obsIn,
     // We need to find the appropriate slice parameters
 
     // To try and be efficient, we first scan for nans, if none: stats
-    // If there are nans, then assess the overlapping subset and slice
+    // If there are nans, copy from the overlapping values
     bool nanObs  = false;
     bool nanPred = false;
 
@@ -130,57 +130,51 @@ VectorError ComputeError( std::valarray< double > obsIn,
         pred = std::valarray< double >( predIn );
     }
     else {
-        // Handle nans...
+        // Handle nans
         // Build concurrent vector of bool pairs : isnan on obsIn, predIn
         std::vector< std::pair< bool, bool > > nanIndexPairs( Nin );
         for ( size_t i = 0; i < Nin; i++ ) {
             nanIndexPairs[ i ] = std::make_pair( std::isnan( obsIn[i]  ),
                                                  std::isnan( predIn[i] ) );
         }
-        // Find overlapping subset indices
+        // Find overlapping subset indices or use set::intersection
         // Condense pairs into one boolean value in nonNanOverlap
+        size_t Nout = 0;
         std::vector< bool > nonNanOverlap( Nin );
         for ( size_t i = 0; i < Nin; i++ ) {
             if ( not nanIndexPairs[ i ].first and
                  not nanIndexPairs[ i ].second ) {
                 nonNanOverlap[ i ] = true; // Both are not nan, valid index
+                Nout++;
             }
             else {
                 nonNanOverlap[ i ] = false;
             }
         }
-        // Get the slice parameters
-        auto firstValid = std::find( nonNanOverlap.begin(),
-                                     nonNanOverlap.end(), true );
-        auto lastValid  = std::find( nonNanOverlap.rbegin(),
-                                     nonNanOverlap.rend(), true );
-        size_t firstValidIndex = std::distance( nonNanOverlap.begin(),
-                                                firstValid );
-        size_t lastValidIndex = std::distance( nonNanOverlap.rbegin(),
-                                               lastValid );
-
-        lastValidIndex = Nin - lastValidIndex; // reverse iterator used...
-
-        int Nout = (int) lastValidIndex - (int) firstValidIndex;
-        
-        if ( Nout < 0 ) {
+
+        if ( Nout < 6 ) {
             std::stringstream msg;
-            msg << "WARNING: ComputeError(): nan predictions found"
-                << " error not computed." << std::endl;
+            msg << "WARNING: ComputeError(): nan found. Not enough data"
+                << " to compute error." << std::endl;
             std::cout << msg.str();
 
-            Nout = 0;
             obs  = std::valarray< double >( 0., 1 ); // vector [0.] N = 1
             pred = std::valarray< double >( 0., 1 ); // vector [0.] N = 1
         }
         else {
             // Allocate the output arrays and fill with slices
             obs  = std::valarray< double >( Nout );
             pred = std::valarray< double >( Nout );
-            
-            std::slice nonNan = std::slice( firstValidIndex, Nout, 1 );
-            obs [ std::slice( 0, Nout, 1 ) ] = obsIn [ nonNan ];
-            pred[ std::slice( 0, Nout, 1 ) ] = predIn[ nonNan ];
+
+            // Copy valid values into obs & pred
+            size_t n = 0;
+            for ( size_t i = 0; i < nonNanOverlap.size(); i++ ) {
+                if ( nonNanOverlap[ i ] ) {
+                    obs [ n ] = obsIn [ i ];
+                    pred[ n ] = predIn[ i ];
+                    n++;
+                }
+            }
         }
     }
 

src/Parameter.cc

@@ -102,7 +102,7 @@ Parameters::Parameters(
     validated        ( false ),
 
     // Instantiate Version
-    version( 1, 15, 3, "2023-11-31" )
+    version( 1, 15, 4, "2024-04-05" )
 {
     // Constructor code
     if ( method != Method::None ) {