# Can math.atan2 return INF?

```On Monday, June 27, 2016 at 12:10:21 PM UTC+5:30, Marko Rauhamaa wrote:
> Steven D'Aprano :
>
> > Naive empirical falsification can, at best, be considered as a
> > best-practice rule: if you have no way of falsifying something even in
> > principle, then it's not scientific. But it doesn't really give you
> > much in the way of practical guidance. What counts as falsification?
>
> We cannot get any information on black holes proper because black holes
> cannot come into existence according to the very theory that predicts
> black holes. It will take infinitely long for an event horizon to form.
> Speculating on what happens to an astronaut falling in is not much
> different from speculating what happens after the end of the world.
>
> > We have no way of seeing what goes on past the black hole's event
> > horizon, since light cannot escape. But we can still see *some*
> > properties of black holes, even through their event horizon: their
> > mass, any electric charge they may hold, their angular momentum.
>
> If an event horizon cannot come into existence, you can only see
> properties of almost-black-holes. Even though there probably is
> virtually no difference between the two astronomically, it relieves
> physicists from answering some awkward questions on the goings-on inside
> an event horizon.
>
> > We can test the proposition that a black hole that forms from hydrogen
> > is no different from one which forms from uranium. We can look for
> > variations in randomness in the Hawking radiation emitted, we can test
> > that the event horizon is where we expect, etc. An electrically
> > neutral black hole with a magnetic field would likely falsify a lot of
> > theories about what goes on inside the event horizon.
>
> If an event horizon cannot ever form, you can't really test any of that
> stuff.

I am reminded of an argument I once had with a colleague about
infinite, lazy data-structures

I said that for the Haskell list [0..]

[0..] ++ [-1] == [0..]

++ is like python's list append +

This could equally apply to a Python generator like:

def nats():
i=0
while True:
yield i
i += 1

He said (in effect) yes that -1 would not be detectable but its still there!

```