
How do you compute the midpoint of an interval? (2014) [pdf] - tzhenghao
https://hal.archives-ouvertes.fr/file/index/docid/576641/filename/computing-midpoint.pdf
======
jacobolus
Summary: to compute (a + b) / 2 and get the best answer for arbitrary inputs,
you want:

0 if a == –b

±realmax if a or b is ±∞

otherwise compute (a - a/2) + b/2 at higher precision, then round to the
nearest float

~~~
Someone
_”±realmax if a or b is ±∞”_

That, IMO, is debatable. NaN is an option, too (as it is for the case a=+∞,
b=-∞, so one can argue _”0 if a == –b”_ needs tuning, too)

Both choices break the property _m(I) ∈ I_ , but that may be fine, as NaN
doesn’t mean the midpoint isn’t in the interval, but just that one cannot tell
where in the interval it lies.

~~~
thaumasiotes
Is a == -b true when a and b are +inf and -inf? That's not what I would have
expected.

~~~
jacobolus
You are asking if ∞ == ∞? Yes.

~~~
wutbrodo
It's been years since I got my math degree, but IIRC this isn't true. At
least, it's not true in enough framings that you can assert it this plainly.
Infinity isn't just another number, and just because the symbols are identical
in either side of the equals signs doesn't mean the entities described are.

~~~
jacobolus
We are talking about the floating point number format and the behavior of
computer programming languages.

In “mathematics”, the meaning of the symbol ∞ depends on what number system we
are talking about. In some contexts ∞ is not a “number”, but rather a
shorthand for a statement about limits. In other contexts it is a number.

If you want to learn about the “affinely extended real numbers”, which is what
floating point numbers more or less approximate, you can read
[https://en.wikipedia.org/wiki/Extended_real_number_line](https://en.wikipedia.org/wiki/Extended_real_number_line)

------
fhars
Similar things are relevant for calculations with integers (like array
indexes), if you haven‘t yet, read this classic post about it:
[https://ai.googleblog.com/2006/06/extra-extra-read-all-
about...](https://ai.googleblog.com/2006/06/extra-extra-read-all-about-it-
nearly.html?m=1) (reader mode makes it accessible on iPhones, why don‘t people
test their layouts with common browsers?).

~~~
Sean1708

      In C and C++ (where you don't have the >>> operator), you can do this:
    
        6:             mid = ((unsigned int)low + (unsigned int)high)) >> 1;
    

Since you're casting to unsigned int anyway, can't you just use / 2?

~~~
kevinventullo
Yeah, I believe those compile to the same thing for unsigned ints. You can
confirm using godbolt.

------
abhinai
This post is a great reminder of just how much we need to respect the people
who write or have written system libraries. Even simple things can be so
complicated when you have to factor for all eventualities. A rocket could blow
up because the library function you wrote didn't account for floating point
arithmetic correctly.

~~~
adwn
> _A rocket could blow up because the library function you wrote didn 't
> account for floating point arithmetic correctly._

I would go so far as to say that using floating point in any software that
might cause the rocket to blow up is probably Doing It Wrong (TM). That does
not include the video encoder sending a livestream to the ground station, but
it does include the µC that controls the engine turbopumps.

~~~
lhjuhafjbh
A microcontroller for a pump probably doesn't need floating point numbers, but
flight control software uses it.

This went wrong before and an Ariane 5 was blown up (automatically as a safety
measure), see
[https://en.wikipedia.org/wiki/Cluster_(spacecraft)#Launch_fa...](https://en.wikipedia.org/wiki/Cluster_\(spacecraft\)#Launch_failure)
Strictly speaking the problem was converting floats to 16-bit integers which
ended in an overflow... So avoiding floats doesn't even help as it won't
protect you from overflows.

------
sova
Take an average in a range! Neat. Floating point uses exponential indexing and
gets blurry. Taking a chunk of an exponential range and averaging that seems
to solve the inaccuracy (!)

