/*
 * File: rt_nonfinite.c
 *
 * Real-Time Workshop code generated for Simulink model c2000scitest_2812tgt.
 *
 * Model version                        : 1.104
 * Real-Time Workshop file version      : 6.3  (R14SP3)  26-Jul-2005
 * Real-Time Workshop file generated on : Sat Dec 13 20:37:34 2008
 * TLC version                          : 6.3 (Aug  5 2005)
 * C source code generated on           : Sat Dec 13 20:37:35 2008
 */

/*
 * Abstract:
 *      Real-Time Workshop function to intialize non-finites,
 *      (Inf, NaN and -Inf).
 */
#include "rt_nonfinite.h"

real_T rtInf;
real_T rtMinusInf;
real_T rtNaN;

real32_T rtInfF;
real32_T rtMinusInfF;
real32_T rtNaNF;

/* Function: rt_InitInfAndNaN ==================================================
 * Abstract:
 *	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) {
  typedef struct {
    uint32_T fraction : 23;
    uint32_T exponent : 8;
    uint32_T sign : 1;
  } LittleEndianIEEESingle;

  typedef struct {
    struct {
      uint32_T fraction2;
    } wordH;
    struct {
      uint32_T fraction1 : 20;
      uint32_T exponent : 11;
      uint32_T sign : 1;
    } wordL;
  } LittleEndianIEEEDouble;

  (*(LittleEndianIEEESingle*)&rtInfF).sign = 0;
  (*(LittleEndianIEEESingle*)&rtInfF).exponent = 0xFF;
  (*(LittleEndianIEEESingle*)&rtInfF).fraction = 0;
  rtMinusInfF = rtInfF;
  rtNaNF = rtInfF;
  (*(LittleEndianIEEESingle*)&rtMinusInfF).sign = 1;
  (*(LittleEndianIEEESingle*)&rtNaNF).fraction = 0x7FFFFF;

  if (realSize == 4) {
    (*(LittleEndianIEEESingle*)&rtInf).sign = 0;
    (*(LittleEndianIEEESingle*)&rtInf).exponent = 0xFF;
    (*(LittleEndianIEEESingle*)&rtInf).fraction = 0;
    rtMinusInf = rtInf;
    rtNaN = rtInf;
    (*(LittleEndianIEEESingle*)&rtMinusInf).sign = 1;
    (*(LittleEndianIEEESingle*)&rtNaN).fraction = 0x7FFFFF;
  } else {
    (*(LittleEndianIEEEDouble*)&rtInf).wordL.sign = 0;
    (*(LittleEndianIEEEDouble*)&rtInf).wordL.exponent = 0x7FF;
    (*(LittleEndianIEEEDouble*)&rtInf).wordL.fraction1 = 0;
    (*(LittleEndianIEEEDouble*)&rtInf).wordH.fraction2 = 0;

    rtMinusInf = rtInf;
    (*(LittleEndianIEEEDouble*)&rtMinusInf).wordL.sign = 1;
    (*(LittleEndianIEEEDouble*)&rtNaN).wordL.sign = 0;
    (*(LittleEndianIEEEDouble*)&rtNaN).wordL.exponent = 0x7FF;
    (*(LittleEndianIEEEDouble*)&rtNaN).wordL.fraction1 = 0xFFFFF;
    (*(LittleEndianIEEEDouble*)&rtNaN).wordH.fraction2 = 0xFFFFFFFF;
  }
}

/* Function: rtIsInf ==================================================
 * Abstract:
 *	Test if value is infinite
 */
boolean_T rtIsInf(real_T value) {
  return(value==rtInf || value==rtMinusInf);
}

/* Function: rtIsInfF =================================================
 * Abstract:
 *	Test if single-precision value is infinite
 */
boolean_T rtIsInfF(real32_T value) {
  return((value)==rtInfF || (value)==rtMinusInfF);
}

/* Function: rtIsNaN ==================================================
 * Abstract:
 *	Test if value is not a number
 */
boolean_T rtIsNaN(real_T value) {
  return(value!=value);
}

/* Function: rtIsNaNF =================================================
 * Abstract:
 *	Test if single-precision value is not a number
 */
boolean_T rtIsNaNF(real32_T value) {
  return(value!=value);
}

/* end rt_nonfinite.c */

/* File trailer for Real-Time Workshop generated code.
 *
 * [EOF]
 */