ieee-754

What is the cardinality of the set of rational numbers, which have an exact representation in floating point format compatible with single-precision IEEE-754? There are 2139095039 finite positive floats. There are as many finite negative floats. Do you want to include +0.0 and -0.0 as two items or as one? Depending on the answer the total is 2 * 2139095039 + 2 or 2 * 2139095039 + 1, that is, respectively, 4278190080 or 4278190079. Source for the 2139095039 number: #include <float.h> #include <math.h> #include <stdlib.h> #include <stdio.h> #include <string.h> int main(void) { float f = FLT_MAX;

IEEE 754 specifies the result of 1 / 0 as ∞ (Infinity). However, IEEE 754 then specifies the result of 0 × ∞ as NaN. This feels counter-intuitive : Why is 0 × ∞ not 0? We can think of 1 / 0 = ∞ as the limit of 1 / z as z tends to zero We can think of 0 × ∞ = 0 as the limit of 0 × z as z tends to ∞. Why does the IEEE standard follow intuition 1. but not 2.? It is easier to understand the behavior of IEEE 754 floating point zeros and infinities if you do not think of them as being literally zero or infinite. The floating point zeros not only represent the real number zero. They also represent

Follow-Up available: There's a follow-up with further details, see Convert MBF to IEEE . I've got some legacy data which is still in use, reading the binary files is not the problem, the number format is. All floating point numbers are saved in MBF format (Single and Double). I've found a topic about that on the MSDN boards but that one only deals with Single values. I'd also would like to stay away from API-Calls as far as I can. Does anyone have a solution for Doubles? Edit: Just in case somebody needs it, here is the VB.NET Code (it's Option Strict compliant) I ended up with (feel free to

I've always assumed, that numpy uses a kind of pairwise-summation , which ensures high precision also for float32 - operations: import numpy as np N=17*10**6 # float32-precision no longer enough to hold the whole sum print(np.ones((N,1),dtype=np.float32).sum(axis=0)) # [17000000.], kind of expected However, it looks as if a different algorithm is used if the matrix has more than one column: print(np.ones((N,2),dtype=np.float32).sum(axis=0)) # [16777216. 16777216.] the error is just to big print(np.ones((2*N,2),dtype=np.float32).sum(axis=0)) # [16777216. 16777216.] error is bigger Probably sum

I just read this topic (especially the last comments). Then I was wondering, why we actually need this was of giving the remainder. But it seems, that not many people "on google" were interested in that before... Simon Byrne If you're looking for reasons why you would want it, one is for what is known as "range reduction" Let's say you want sind function for computing the sine of an argument in degrees. A naive way to do this would be sind(x) = sin(x*pi/180) However pi here is not the true irrational number pi , but instead the floating point number closest to pi . This leads to things like

While investigating floating-point exception status flags, I came across the curious case of a status flag FE_UNDERFLOW set when not expected. This is similar to When does underflow occur? yet goes into a corner case that may be a C specification issue or FP hardware defect. // pseudo code // s bias_expo implied "mantissa" w = smallest_normal; // 0 000...001 (1) 000...000 x = w * 2; // 0 000...010 (1) 000...000 y = next_smaller(x); // 0 000...001 (1) 111...111 round_mode(FE_TONEAREST); clear_status_flags(); z = y/2; // 0 000...001 (1) 000...000 FE_UNDERFLOW is set!? I did not expect FE

I'm using the following function to approximate the derivative of a function at a point: def prime_x(f, x, h): if not f(x+h) == f(x) and not h == 0.0: return (f(x+h) - f(x)) / h else: raise PrecisionError As a test I'm passing f as fx and x as 3.0. Where fx is: def fx(x): import math return math.exp(x)*math.sin(x) Which has exp(x)*(sin(x)+cos(x)) as derivative. Now, according to Google and to my calculator exp(3)*(sin(3)+cos(3)) = -17.050059 . So far so good. But when I decided to test the function with small values for h I got the following: print prime_x(fx, 3.0, 10**-5) -17.0502585578 print