MC100/Simulink/PMSM_Motor_TL3_sfcn_rtw/rt_nonfinite.c

    /*
  * rt_nonfinite.c
  *
    * Code generation for model "PMSM_Motor_TL3_sf".
  *
  * Model version              : 1.825
  * Simulink Coder version : 9.4 (R2020b) 29-Jul-2020
  * C source code generated on : Fri Apr 14 12:51:02 2023
 * 
 * Target selection: rtwsfcn.tlc
 * Note: GRT includes extra infrastructure and instrumentation for prototyping
 * Embedded hardware selection: ARM Compatible->ARM Cortex-M
 * Emulation hardware selection: 
 *    Differs from embedded hardware (MATLAB Host)
 * Code generation objectives: 
 *    1. Execution efficiency
 *    2. RAM efficiency
 * Validation result: Not run
  */



    

    /*
  * Abstract:
  *      Function to initialize non-finites,
  *      (Inf, NaN and -Inf).
  */
    #include "rt_nonfinite.h"

          #include "rtGetNaN.h"
      
        #include "rtGetInf.h"
      
    

    


  

  

  

    #define NumBitsPerChar  8U


  

  

  

  

  

  

  

  

  

  

  

  


  real_T rtInf;


  


  real_T rtMinusInf;


  


  real_T rtNaN;


  


  real32_T rtInfF;


  


  real32_T rtMinusInfF;


  


  real32_T rtNaNF;





    
  /* 
 * Initialize the rtInf, rtMinusInf, and rtNaN needed by the
 * generated code. NaN is initialized as non-signaling. Assumes IEEE.
 */

     void rt_InitInfAndNaN(size_t realSize) {

    (void) (realSize); 
    rtNaN = rtGetNaN();
    rtNaNF = rtGetNaNF();
    rtInf = rtGetInf();
    rtInfF = rtGetInfF();
    rtMinusInf = rtGetMinusInf();
    rtMinusInfF = rtGetMinusInfF();
  }
    
  /* Test if value is infinite */
     boolean_T rtIsInf(real_T value) {
    return (boolean_T)((value==rtInf || value==rtMinusInf) ? 1U : 0U);
  }
    
  /* Test if single-precision value is infinite */
     boolean_T rtIsInfF(real32_T value) {
    return (boolean_T)(((value)==rtInfF || (value)==rtMinusInfF) ? 1U : 0U);
  }
    
  /* Test if value is not a number */
     boolean_T rtIsNaN(real_T value) {
    boolean_T result = (boolean_T) 0;
    size_t bitsPerReal = sizeof(real_T) * (NumBitsPerChar);
    
    if (bitsPerReal == 32U) {
      result = rtIsNaNF((real32_T)value);
    } else {
          
  union {
    LittleEndianIEEEDouble bitVal;
    real_T fltVal;
  } tmpVal;
  tmpVal.fltVal = value;
  result = (boolean_T)((tmpVal.bitVal.words.wordH & 0x7FF00000) == 0x7FF00000 &&
                       ( (tmpVal.bitVal.words.wordH & 0x000FFFFF) != 0 ||
                         (tmpVal.bitVal.words.wordL != 0) ));


    }
    return result;
  }
    
  /* Test if single-precision value is not a number */
     boolean_T rtIsNaNF(real32_T value) {
    IEEESingle tmp;
    tmp.wordL.wordLreal = value;
    return (boolean_T)( (tmp.wordL.wordLuint & 0x7F800000) == 0x7F800000 &&
                        (tmp.wordL.wordLuint & 0x007FFFFF) != 0 );
  }