nan

Is it a good idea to use IEEE754 floating point NaN (not-a-number) for values which are undefined for non-mathematical reasons? In our case they are not yet set because the values have not been received from some other device. The context is an embedded system using IEC1131 REAL32 values. Edit: The programming language is C, so we would most likely use NAN and isnanf(x), which are from C99. Though we may need some extra contortions to get these into our OS compatibility layer. The default in programming languages seems to be to initialize floating point variables with positive zero, whose

Is null evaluated to 0 and undefined to NaN on arithmetic expressions? According to some testing it seems so: > null + null 0 > 4 + null 4 > undefined + undefined NaN > 4 + undefined NaN Is it safe or correct to assume this? (a quote from a documentation would be A+). Is null evaluated to 0 and undefined to NaN on arithmetic expressions? Is it safe or correct to assume this? Yes, it is. An "arithmetic expression" would use the ToNumber operation : Argument Type | Result --------------+-------- Undefined | NaN Null | +0 … | It is used in the following "arithmetic" expressions: prefix / postfix

As mathematical concepts, I am well aware of what inf and nan actually are. But what I am really interested in is how they are implemented in programming languages. In python, I can use inf and nan in arithmetic and conditional expressions, like this: >>> nan = float('nan') >>> inf = float('inf') >>> 1 + inf inf >>> inf + inf inf >>> inf - inf nan This would lead me to believe that python internally has a special reserved bit sequence for these two mathematical quantities, and no other number can assume these positions. Is my assumption correct? Can you please enlighten me in this regard? If

What's the difference between NaN and Infinity ? When does NaN appear? What is it? From Wikipedia : In computing, NaN (Not a Number) is a value of the numeric data type representing an undefined or unrepresentable value, especially in floating-point calculations. Systematic use of NaNs was introduced by the IEEE 754 floating-point standard in 1985, along with the representation of other non-finite quantities like infinities. And from MSDN : Represents a value that is not a number (NaN). This field is constant. The value of this constant is the result of dividing zero by zero. This constant is

How do you write an NaN floating-point literal in C? In C99's <math.h> 7.12 Mathematics <math.h> [#5] The macro NAN is defined if and only if the implementation supports quiet NaNs for the float type. It expands to a constant expression of type float representing a quiet NaN. | 5.2.4.2.2/3: floating types may be able to contain other kinds of floating-point numbers, such as ... infinities and NaNs. A NaN is an encoding signifying Not-a-Number. A quiet NaN propagates through almost every arithmetic operation without raising a floating-point exception; a signaling NaN generally raises a floating

Here is the test program: void testFunc() { double maxValue = DBL_MAX; double slope = std::numeric_limits<double>::quiet_NaN(); std::cout << "slope is " << slope << std::endl; std::cout << "maxThreshold is " << maxValue << std::endl; std::cout << "the_min is " << std::min( slope, maxValue) << std::endl; std::cout << "the_min is " << std::min( DBL_MAX, std::numeric_limits<double>::quiet_NaN()) << std::endl; } int main( int argc, char* argv[] ) { testFunc(); return 0; } In Debug, I get: slope is nan maxThreshold is 1.79769e+308 the_min is nan the_min is 1.79769e+308 In Release, I get: slope is

Is there an idiomatic way to compare two NumPy arrays that would treat NaNs as being equal to each other (but not equal to anything other than a NaN). For example, I want the following two arrays to compare equal: np.array([1.0, np.NAN, 2.0]) np.array([1.0, np.NAN, 2.0]) and the following two arrays to compare unequal: np.array([1.0, np.NAN, 2.0]) np.array([1.0, 0.0, 2.0]) I am looking for a method that would produce a scalar Boolean outcome. The following would do it: np.all((a == b) | (np.isnan(a) & np.isnan(b))) but it's clunky and creates all those intermediate arrays. Is there a way that