liboctave-dev 4.2.2-1ubuntu1 / usr / include / octave-4.2.2 / octave / lo-ieee.h

This file is indexed.

/usr/include/octave-4.2.2/octave/lo-ieee.h is in liboctave-dev 4.2.2-1ubuntu1.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below. 

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
/*

Copyright (C) 1996-2017 John W. Eaton

This file is part of Octave.

Octave is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by the
Free Software Foundation; either version 3 of the License, or (at your
option) any later version.

Octave is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
for more details.

You should have received a copy of the GNU General Public License
along with Octave; see the file COPYING.  If not, see
<http://www.gnu.org/licenses/>.

*/

#if ! defined (octave_lo_ieee_h)
#define octave_lo_ieee_h 1

#include "octave-config.h"

#if defined (__cplusplus)
extern "C" {
#endif

/*  Octave's idea of infinity.  */
#define octave_Inf (lo_ieee_inf_value ())

/* Octave's idea of a missing value.  */
#define octave_NA (lo_ieee_na_value ())

/* Octave's idea of not a number.  */
#define octave_NaN (lo_ieee_nan_value ())

/*  Octave's idea of infinity.  */
#define octave_Float_Inf (lo_ieee_float_inf_value ())

/* Octave's idea of a missing value.  */
#define octave_Float_NA (lo_ieee_float_na_value ())

/* Octave's idea of not a number.  */
#define octave_Float_NaN (lo_ieee_float_nan_value ())

/* FIXME: This code assumes that a double has twice the
          number of bits as an int */

typedef union
{
  double value;
  unsigned int word[2];
} lo_ieee_double;

typedef union
{
  float value;
  unsigned int word;
} lo_ieee_float;

#define LO_IEEE_NA_HW_OLD 0x7ff00000
#define LO_IEEE_NA_LW_OLD 1954
#define LO_IEEE_NA_HW 0x7FF840F4
#define LO_IEEE_NA_LW 0x40000000
#define LO_IEEE_NA_FLOAT   0x7FC207A2

extern OCTAVE_API void octave_ieee_init (void);

extern OCTAVE_API int __lo_ieee_isnan (double x);
extern OCTAVE_API int __lo_ieee_finite (double x);
extern OCTAVE_API int __lo_ieee_isinf (double x);

extern OCTAVE_API int __lo_ieee_is_NA (double);
extern OCTAVE_API int __lo_ieee_is_old_NA (double);
extern OCTAVE_API double __lo_ieee_replace_old_NA (double);

extern OCTAVE_API double lo_ieee_inf_value (void);
extern OCTAVE_API double lo_ieee_na_value (void);
extern OCTAVE_API double lo_ieee_nan_value (void);

extern OCTAVE_API int __lo_ieee_signbit (double);

extern OCTAVE_API int __lo_ieee_float_isnan (float x);
extern OCTAVE_API int __lo_ieee_float_finite (float x);
extern OCTAVE_API int __lo_ieee_float_isinf (float x);

extern OCTAVE_API int __lo_ieee_float_is_NA (float);

extern OCTAVE_API float lo_ieee_float_inf_value (void);
extern OCTAVE_API float lo_ieee_float_na_value (void);
extern OCTAVE_API float lo_ieee_float_nan_value (void);

extern OCTAVE_API int __lo_ieee_float_signbit (float);

#if defined (__cplusplus)
}
#endif

#define lo_ieee_isnan(x)                                \
  (sizeof (x) == sizeof (float)                         \
   ? __lo_ieee_float_isnan (x) : __lo_ieee_isnan (x))

#define lo_ieee_finite(x)                               \
  (sizeof (x) == sizeof (float)                         \
   ? __lo_ieee_float_finite (x) : __lo_ieee_finite (x))

#define lo_ieee_isinf(x)                                \
  (sizeof (x) == sizeof (float)                         \
   ? __lo_ieee_float_isinf (x) : __lo_ieee_isinf (x))

#define lo_ieee_is_NA(x)                                \
  (sizeof (x) == sizeof (float)                         \
   ? __lo_ieee_float_is_NA (x) : __lo_ieee_is_NA (x))

#define lo_ieee_is_NaN_or_NA(x)                                         \
  (sizeof (x) == sizeof (float)                                         \
   ? __lo_ieee_float_is_NaN_or_NA (x) : __lo_ieee_is_NaN_or_NA (x))

#define lo_ieee_signbit(x)                                      \
  (sizeof (x) == sizeof (float)                                 \
   ? __lo_ieee_float_signbit (x) : __lo_ieee_signbit (x))

#if defined (__cplusplus)

namespace octave
{
  template <typename T>
  struct numeric_limits
  {
    static T NA (void) { return static_cast<T> (0); }
    static T NaN (void) { return static_cast<T> (0); }
    static T Inf (void) { return static_cast<T> (0); }
  };

  template <>
  struct numeric_limits<double>
  {
    static double NA (void) { return octave_NA; }
    static double NaN (void) { return octave_NaN; }
    static double Inf (void) { return octave_Inf; }
  };

  template <>
  struct numeric_limits<float>
  {
    static float NA (void) { return octave_Float_NA; }
    static float NaN (void) { return octave_Float_NaN; }
    static float Inf (void) { return octave_Float_Inf; }
  };
}

#endif

#endif

APT Browse - Built by Thomas Orozco.