# Predicting Eclipses Does Not Require the Saros Cycle or NASA’s Involvement Using the current computing power, predicting eclipses is usually done iteratively. We determine the position of the Sun and the Moon at a time and calculate their elongation to determine if an eclipse happens. This same procedure is then repeated many times, each for a different time.

Flat-Earthers insist that nobody can predict eclipses from the position of the Sun and the Moon. They incorrectly believe NASA used the ancient Saros cycle to predict eclipses by calculating the interval between eclipses. A tiny Python script can easily debunk it.

Calculating eclipse is done using the ephemeris. It is a mathematical model describing the motion of celestial bodies. Utilizing the ephemeris, we can figure out the position of the Sun and the Moon at a time and then calculate the angle separating them (elongation) to determine if an eclipse happens.

For the 2017 North American total solar eclipse, NASA used their supercomputers to predict it. Using their immense computing power, they even account for the elevation data of both Earth and the Moon. This is impossible to achieve from the Saros cycle.

Flat-Earthers claim that NASA is the authority for eclipses, and we can only wait for their predictions. In reality, NASA does not hold a monopoly on predicting eclipses. Anyone with sufficient knowledge can easily do that. And the result will probably be accurate enough.

For a demonstration, we created a tiny and straightforward Python script to predict the occurrences of a lunar eclipse in the 21st century. The script consists of no more than 20 lines, and anyone who knows basic programming will not have much difficulty understanding it.

## Source code

```#!/usr/bin/env python
'''
lunar-eclipse-prediction.py

Shows the occurences of a lunar eclipse in the 21st century.
Works by iterating every hour in the 21st century and calculating if the
separation between the Moon and the Sun is less than 0.9° from 180°.
The number 0.9° is hardcoded for simplicity, for more accuracy, it
should be computed from the distance of the Moon and the Sun.
'''
import ephem
from datetime import datetime, timedelta

curtime = datetime(2001, 1, 1, 0, 0, 0) # start time
endtime = datetime(2100, 12, 31, 23, 59, 59) # end time
moon = ephem.Moon()
sun = ephem.Sun()
observer = ephem.Observer()
observer.elevation = -6371000 # place observer in the center of the Earth
observer.pressure = 0 # disable refraction

while curtime <= endtime:
observer.date = curtime.strftime('%Y/%m/%d %H:%M:%S')

# computer the position of the sun and the moon with respect to the observer
moon.compute(observer)
sun.compute(observer)

# calculate separation between the moon and the sun, convert
# it from radians to degrees, substract it by 180°
sep = abs((float(ephem.separation(moon, sun))
/ 0.01745329252) - 180)

# eclipse happens if Sun-Earth-Moon alignment is less than 0.9°.
# this should detect all total and partial eclipses, but is
# hit-and-miss for penumbral eclipses.
# the number is hardcoded for simplicity. for accuracy it should
# be computed from the distance to the Sun and the Moon.
if sep < 0.9:
print(curtime.strftime('%Y/%m/%d %H:%M:%S'), sep)
# an eclipse cannot happen more than once in a day,
# so we skip 24 hours when an eclipse is found
curtime += timedelta(days = 1)
else: