Standardization of Inf and NaN. 08/21008/3
Clément DAVID [Wed, 12 Jun 2019 11:24:03 +0000 (13:24 +0200)]
Provided by NumericConstants class.

Change-Id: I2e616bb2ed275910bd0f0387aff01bcab879eaeb

scilab/modules/ast/includes/system_env/numericconstants.hxx
scilab/modules/ast/includes/system_env/numericconstants_interface.h
scilab/modules/ast/src/cpp/system_env/numericconstants.cpp
scilab/modules/ast/src/cpp/system_env/numericconstants_interface.cpp
scilab/modules/core/src/cpp/InitScilab.cpp
scilab/modules/fileio/src/c/fscanfMat.c
scilab/modules/linear_algebra/sci_gateway/c/sci_norm.c
scilab/modules/string/src/c/stringToComplex.c
scilab/modules/string/src/c/stringToDouble.c

index 79b4d2a..0346f86 100644 (file)
@@ -34,7 +34,9 @@ public:
     EXTERN_AST static double double_min;                   //underflow threshold - base**(emin-1)
     EXTERN_AST static double exp_max;               //largest exponent before overflow
     EXTERN_AST static double double_max;                   //overflow threshold  - (base**emax)*(1-eps)
-
+    EXTERN_AST static double infinity;
+    EXTERN_AST static double neginfinity;
+    EXTERN_AST static double nan;
     EXTERN_AST static void Initialize();
 
 };
index a118fc4..628e257 100644 (file)
@@ -26,6 +26,9 @@ EXTERN_AST double nc_exp_min();
 EXTERN_AST double nc_double_min();
 EXTERN_AST double nc_exp_max();
 EXTERN_AST double nc_double_max();
+EXTERN_AST double nc_inf();
+EXTERN_AST double nc_neginf();
+EXTERN_AST double nc_nan();
 
 //Fortran
 EXTERN_AST double C2F(nc_eps)();
@@ -38,3 +41,6 @@ EXTERN_AST double C2F(nc_exp_min)();
 EXTERN_AST double C2F(nc_double_min)();
 EXTERN_AST double C2F(nc_exp_max)();
 EXTERN_AST double C2F(nc_double_max)();
+EXTERN_AST double C2F(nc_inf)();
+EXTERN_AST double C2F(nc_neginf)();
+EXTERN_AST double C2F(nc_nan)();
index 9c6b752..baaae69 100644 (file)
@@ -13,6 +13,7 @@
 *
 */
 
+#include <limits>
 #include "numericconstants.hxx"
 
 double NumericConstants::eps;
@@ -25,6 +26,9 @@ double NumericConstants::exp_min;
 double NumericConstants::double_min;
 double NumericConstants::exp_max;
 double NumericConstants::double_max;
+double NumericConstants::infinity;
+double NumericConstants::neginfinity;
+double NumericConstants::nan;
 
 void NumericConstants::Initialize()
 {
@@ -38,4 +42,8 @@ void NumericConstants::Initialize()
     double_min = C2F(dlamch)("U", 1L);
     exp_max = C2F(dlamch)("L", 1L);
     double_max = C2F(dlamch)("O", 1L);
+    infinity = std::numeric_limits<double>::infinity();
+    neginfinity = -std::numeric_limits<double>::infinity();
+    nan = std::numeric_limits<double>::quiet_NaN();
+
 }
index 3c22d0f..0c267f2 100644 (file)
@@ -70,6 +70,20 @@ double nc_double_max()
     return NumericConstants::double_max;
 }
 
+double nc_inf()
+{
+    return NumericConstants::infinity;
+}
+
+double nc_neginf()
+{
+    return NumericConstants::neginfinity;
+}
+
+double nc_nan()
+{
+    return NumericConstants::nan;
+}
 
 //Fortran
 double C2F(nc_eps)()
@@ -121,3 +135,18 @@ double C2F(nc_double_max)()
 {
     return NumericConstants::double_max;
 }
+
+double C2F(nc_inf)()
+{
+    return NumericConstants::infinity;
+}
+
+double C2F(nc_neginf)()
+{
+    return NumericConstants::neginfinity;
+}
+
+double C2F(nc_nan)()
+{
+    return NumericConstants::nan;
+}
index 9e63733..7bec998 100644 (file)
@@ -503,7 +503,7 @@ void StopScilabEngine(ScilabEngineInfo* _pSEI)
 
     //close dynamic linked libraries
     std::vector<ConfigVariable::DynamicLibraryStr*>* pDLLIst = ConfigVariable::getDynamicLibraryList();
-    int size = pDLLIst->size();
+    int size = static_cast<int>(pDLLIst->size());
     for (int i = 0; i < size; i++)
     {
         ConfigVariable::DynamicLibraryStr* pStr = ConfigVariable::getDynamicLibrary(i);
@@ -781,7 +781,7 @@ void* scilabReadAndStore(void* param)
             {
                 bool disableDebug = false;
                 char* tmpCommand = NULL;
-                int commandsize = strlen(command);
+                int commandsize = static_cast<int>(strlen(command));
 
                 //all commands must be prefixed by debug except e(xec) (r)un or p(rint) "something" that become "something" or disp("something")
                 if (strncmp(command, "e ", 2) == 0 || strncmp(command, "r ", 2) == 0)
@@ -1127,18 +1127,12 @@ static void Add_All_Variables(void)
 
 static void Add_Nan(void)
 {
-    double dbl1 = -1.0;
-    double dbl0 = fabs(dbl1 - dbl1);
-
-    Add_Double_Constant(L"%nan", dbl0 / dbl0, 0, false);
+    Add_Double_Constant(L"%nan", NumericConstants::nan, 0, false);
 }
 
 static void Add_Inf(void)
 {
-    double dbl1 = 1.0;
-    double dbl0 = dbl1 - dbl1;
-
-    Add_Double_Constant(L"%inf", dbl1 / dbl0, 0, false);
+    Add_Double_Constant(L"%inf", NumericConstants::infinity, 0, false);
 }
 
 static void Add_gui(void)
index 3b75473..f239473 100644 (file)
@@ -32,6 +32,7 @@
 #include "mgetl.h"
 #include "mopen.h"
 #include "mclose.h"
+#include "numericconstants_interface.h"
 /*--------------------------------------------------------------------------*/
 #define EOL "\n"
 #define NanString "Nan"
@@ -63,8 +64,6 @@ static double *getDoubleValuesFromLines(char **lines, int sizelines,
 static double *getDoubleValuesInLine(char *line,
                                      char *format, char *separator,
                                      int nbColumnsMax);
-static double returnINF(BOOL bPositive);
-static double returnNAN(void);
 static BOOL checkFscanfMatFormat(char *format);
 static char *getCleanedFormat(char *format);
 static BOOL isOnlyBlankLine(const char *line);
@@ -585,7 +584,7 @@ static double *getDoubleValuesInLine(char *line,
                 int ierr = 0;
                 double dValue = 0.;
                 char *cleanedFormat = getCleanedFormat(format);
-                int iLen = strlen(cleanedFormat);
+                int iLen = (int)strlen(cleanedFormat);
                 switch (cleanedFormat[iLen - 1])
                 {
                     case 'e' :
@@ -635,17 +634,17 @@ static double *getDoubleValuesInLine(char *line,
                         {
                             if (strcmp(str, NanString) == 0)
                             {
-                                dValues[i] = returnNAN();
+                                dValues[i] = nc_nan();
                             }
 
                             if (strcmp(str, NegInfString) == 0)
                             {
-                                dValues[i] = returnINF(FALSE);
+                                dValues[i] = nc_neginf();
                             }
 
                             if (strcmp(str, InfString) == 0)
                             {
-                                dValues[i] = returnINF(TRUE);
+                                dValues[i] = nc_inf();
                             }
                         }
                         else
@@ -678,30 +677,6 @@ static double *getDoubleValuesInLine(char *line,
     return dValues;
 }
 /*--------------------------------------------------------------------------*/
-static double returnINF(BOOL bPositive)
-{
-    double v = 0;
-    double p = 10;
-    if (!bPositive)
-    {
-        p = -10;
-    }
-    return (double) p / (double)v;
-}
-/*--------------------------------------------------------------------------*/
-static double returnNAN(void)
-{
-    static int first = 1;
-    static double nan = 1.0;
-
-    if ( first )
-    {
-        nan = (nan - (double) first) / (nan - (double) first);
-        first = 0;
-    }
-    return (nan);
-}
-/*--------------------------------------------------------------------------*/
 static BOOL checkFscanfMatFormat(char *format)
 {
     if (format)
index a9a867e..f766a99 100644 (file)
@@ -12,7 +12,6 @@
  * along with this program.
  *
  */
-#include <math.h>
 
 #include "doublecomplex.h"
 #include "api_scilab.h"
@@ -21,6 +20,7 @@
 #include "localization.h"
 #include "sci_malloc.h"
 #include "norm.h"
+#include "numericconstants_interface.h"
 
 /*--------------------------------------------------------------------------*/
 int sci_norm(char *fname, void* pvApiCtx)
@@ -107,7 +107,7 @@ int sci_norm(char *fname, void* pvApiCtx)
 
     if (_isnan)
     {
-        createScalarDouble(pvApiCtx, Rhs + 1, NAN);
+        createScalarDouble(pvApiCtx, Rhs + 1, nc_nan());
         AssignOutputVariable(pvApiCtx, 1) = Rhs + 1;
         return 0;
     }
@@ -138,7 +138,7 @@ int sci_norm(char *fname, void* pvApiCtx)
         // Call normP() or normPC().
         if (_isinf)
         {
-            ret = INFINITY;
+            ret = nc_inf();
         }
         else if (isComplex)
         {
@@ -195,7 +195,7 @@ int sci_norm(char *fname, void* pvApiCtx)
 
         if (_isinf)
         {
-            ret = INFINITY;
+            ret = nc_inf();
         }
         else if (isComplex)
         {
@@ -251,7 +251,7 @@ int sci_norm(char *fname, void* pvApiCtx)
 
             if (_isinf && la_isinf(flagVal) == 0) // Infs in A and flag != -%inf
             {
-                ret = INFINITY;
+                ret = nc_inf();
             }
             else if (isComplex)
             {
index 86585fe..c6b7077 100644 (file)
@@ -24,7 +24,8 @@
 #include "os_string.h"
 #include "BOOL.h"
 #include "strsubst.h"
-/* ========================================================================== */
+#include "numericconstants_interface.h"
+ /* ========================================================================== */
 #define PlusChar '+'
 #define PlusCharW L'+'
 #define LessChar '-'
@@ -60,7 +61,6 @@ static char *leftstring(const char *tx, size_t pos);
 static wchar_t* leftstringW(const wchar_t* tx, size_t pos);
 static BOOL is_unit_imaginary (const char *src, double *im);
 static BOOL is_unit_imaginaryW (const wchar_t* src, double *im);
-static double returnNAN(void);
 /* ========================================================================== */
 complexArray *stringsToComplexArray(const char **pSTRs, int nbElements,
                                     const char *decimal,
@@ -408,7 +408,7 @@ static stringToComplexError ParseComplexValue(const char *tx, BOOL bConvertByNAN
             if (bConvertByNAN)
             {
                 ierrDouble = STRINGTODOUBLE_NOT_A_NUMBER;
-                *real = returnNAN();
+                *real = nc_nan();
                 *imag = 0;
             }
             else
@@ -477,7 +477,7 @@ static stringToComplexError ParseComplexValue(const char *tx, BOOL bConvertByNAN
         }
         else if (inum_string[1] == 'i' || inum_string[1] == 'j') // The imaginary part looks like "%i*a". For instance if string() has been used
         {
-            int len_inum_string = strlen(inum_string);
+            int len_inum_string = (int)strlen(inum_string);
             for (i = 1; i < len_inum_string; ++i)
             {
                 inum_string[i] = inum_string[i + 1];    // Removing the "i"
@@ -493,13 +493,13 @@ static stringToComplexError ParseComplexValue(const char *tx, BOOL bConvertByNAN
             if (strcmp(inum_string, "+") == 0)
             {
                 FREE(inum_string);
-                inum_string = strdup("+1");
+                inum_string = os_strdup("+1");
             }
 
             if (strcmp(inum_string, "-") == 0)
             {
                 FREE(inum_string);
-                inum_string = strdup("-1");
+                inum_string = os_strdup("-1");
             }
             haveImagI = TRUE;
         }
@@ -532,7 +532,7 @@ static stringToComplexError ParseComplexValue(const char *tx, BOOL bConvertByNAN
                     if (bConvertByNAN)
                     {
                         ierr = STRINGTOCOMPLEX_NO_ERROR;
-                        *real = returnNAN();
+                        *real = nc_nan();
                         *imag = 0.;
                     }
                     else
@@ -552,7 +552,7 @@ static stringToComplexError ParseComplexValue(const char *tx, BOOL bConvertByNAN
                 if (bConvertByNAN)
                 {
                     ierr = STRINGTOCOMPLEX_NO_ERROR;
-                    *real = returnNAN();
+                    *real = nc_nan();
                     *imag = 0.;
                 }
                 else
@@ -594,7 +594,7 @@ static stringToComplexError ParseComplexValueW(const wchar_t *tx, BOOL bConvertB
             if (bConvertByNAN)
             {
                 ierrDouble = STRINGTODOUBLE_NOT_A_NUMBER;
-                *real = returnNAN();
+                *real = nc_nan();
                 *imag = 0;
             }
             else
@@ -753,7 +753,7 @@ static stringToComplexError ParseComplexValueW(const wchar_t *tx, BOOL bConvertB
                     if (bConvertByNAN)
                     {
                         ierr = STRINGTOCOMPLEX_NO_ERROR;
-                        *real = returnNAN();
+                        *real = nc_nan();
                         *imag = 0.;
                     }
                     else
@@ -773,7 +773,7 @@ static stringToComplexError ParseComplexValueW(const wchar_t *tx, BOOL bConvertB
                 if (bConvertByNAN)
                 {
                     ierr = STRINGTOCOMPLEX_NO_ERROR;
-                    *real = returnNAN();
+                    *real = nc_nan();
                     *imag = 0.;
                 }
                 else
@@ -980,16 +980,3 @@ static BOOL is_unit_imaginaryW(const wchar_t *src, double *im)
     return isUnitImag;
 }
 /* ========================================================================== */
-static double returnNAN(void)
-{
-    static int first = 1;
-    static double nan = 1.0;
-
-    if ( first )
-    {
-        nan = (nan - (double) first) / (nan - (double) first);
-        first = 0;
-    }
-    return (nan);
-}
-// =============================================================================
index 09c4842..5433f74 100644 (file)
@@ -25,6 +25,7 @@
 #include "core_math.h"
 #include "sci_malloc.h"
 #include "os_string.h"
+#include "numericconstants_interface.h"
 #ifndef _MSC_VER
 #ifndef stricmp
 #define stricmp strcasecmp
 /* ========================================================================== */
 #define DEFAULT_DOUBLE_MAX_DIGIT_FORMAT "%lg"
 /* ========================================================================== */
-static double returnINF(BOOL bPositive);
-static double returnNAN(void);
-/* ========================================================================== */
-
 static char* replace_D_By_E(const char* _pst)
 {
     //find and replace d and D by E for compatibility with strtod Linux/Mac
@@ -107,16 +104,16 @@ double stringToDouble(const char *pSTR, BOOL bConvertByNAN, stringToDoubleError
                 (stricmp(pSTR, PosNanString) == 0) || (stricmp(pSTR, ScilabPosNanString) == 0) ||
                 (stricmp(pSTR, ScilabNanString) == 0) || (stricmp(pSTR, ScilabNegNanString) == 0))
         {
-            dValue = returnNAN();
+            dValue = nc_nan();
         }
         else if ((stricmp(pSTR, InfString) == 0) || (stricmp(pSTR, PosInfString) == 0) ||
                  (stricmp(pSTR, ScilabInfString) == 0) || (stricmp(pSTR, ScilabPosInfString) == 0))
         {
-            dValue = returnINF(TRUE);
+            dValue = nc_inf();
         }
         else if ((stricmp(pSTR, NegInfString) == 0) || (stricmp(pSTR, ScilabNegInfString) == 0))
         {
-            dValue = returnINF(FALSE);
+            dValue = nc_neginf();
         }
         else if ((stricmp(pSTR, ScilabPiString) == 0) || (stricmp(pSTR, ScilabPosPiString) == 0))
         {
@@ -151,7 +148,7 @@ double stringToDouble(const char *pSTR, BOOL bConvertByNAN, stringToDoubleError
             {
                 if (bConvertByNAN)
                 {
-                    dValue = returnNAN();
+                    dValue = nc_nan();
                 }
                 else
                 {
@@ -170,7 +167,7 @@ double stringToDouble(const char *pSTR, BOOL bConvertByNAN, stringToDoubleError
                 {
                     if (bConvertByNAN)
                     {
-                        dValue = returnNAN();
+                        dValue = nc_nan();
                     }
                     else
                     {
@@ -202,16 +199,16 @@ double stringToDoubleW(const wchar_t *pSTR, BOOL bConvertByNAN, stringToDoubleEr
                 (wcsicmp(pSTR, PosNanStringW) == 0) || (wcsicmp(pSTR, ScilabPosNanStringW) == 0) ||
                 (wcsicmp(pSTR, ScilabNanStringW) == 0) || (wcsicmp(pSTR, ScilabNegNanStringW) == 0))
         {
-            dValue = returnNAN();
+            dValue = nc_nan();
         }
         else if ((wcsicmp(pSTR, InfStringW) == 0) || (wcsicmp(pSTR, PosInfStringW) == 0) ||
                  (wcsicmp(pSTR, ScilabInfStringW) == 0) || (wcsicmp(pSTR, ScilabPosInfStringW) == 0))
         {
-            dValue = returnINF(TRUE);
+            dValue = nc_inf();
         }
         else if ((wcsicmp(pSTR, NegInfStringW) == 0) || (wcsicmp(pSTR, ScilabNegInfStringW) == 0))
         {
-            dValue = returnINF(FALSE);
+            dValue = nc_neginf();
         }
         else if ((wcsicmp(pSTR, ScilabPiStringW) == 0) || (wcsicmp(pSTR, ScilabPosPiStringW) == 0))
         {
@@ -246,7 +243,7 @@ double stringToDoubleW(const wchar_t *pSTR, BOOL bConvertByNAN, stringToDoubleEr
             {
                 if (bConvertByNAN)
                 {
-                    dValue = returnNAN();
+                    dValue = nc_nan();
                 }
                 else
                 {
@@ -265,7 +262,7 @@ double stringToDoubleW(const wchar_t *pSTR, BOOL bConvertByNAN, stringToDoubleEr
                 {
                     if (bConvertByNAN)
                     {
-                        dValue = returnNAN();
+                        dValue = nc_nan();
                     }
                     else
                     {
@@ -287,25 +284,3 @@ double stringToDoubleW(const wchar_t *pSTR, BOOL bConvertByNAN, stringToDoubleEr
     return dValue;
 }
 // =============================================================================
-static double returnINF(BOOL bPositive)
-{
-    double dbl1 = 1.0;
-    double dbl0 = dbl1 - dbl1;
-    int iSign = bPositive == 1 ? 1 : -1;
-
-    return iSign * dbl1 / dbl0;
-}
-// =============================================================================
-static double returnNAN(void)
-{
-    static int first = 1;
-    static double nan = 1.0;
-
-    if ( first )
-    {
-        nan = (nan - (double) first) / (nan - (double) first);
-        first = 0;
-    }
-    return (nan);
-}
-// =============================================================================