Mond-/Mondphasenalgorithmus

Kennt jemand einen Algorithmus, um entweder die Mondphase oder das Alter an einem bestimmten Datum zu berechnen oder die Daten für Neu-/Vollmonde in einem bestimmten Jahr zu finden?

Googeln sagt mir, dass die Antwort in einem Astronomiebuch steht, aber ich möchte nicht wirklich ein ganzes Buch kaufen, wenn ich nur eine einzige Seite brauche.

Aktualisieren:

Ich hätte meine Aussage zum Googeln etwas besser relativieren sollen. Ich habe Lösungen gefunden, die nur über einen Teil der Zeit funktionierten (wie in den 1900er Jahren); und die trigonometrischen Lösungen, die rechenintensiver wären, als ich möchte.

S Lott hat in seinem Python-Buch mehrere Algorithmen zur Berechnung von Ostern in einem bestimmten Jahr, die meisten sind weniger als zehn Codezeilen und einige funktionieren für alle Tage im gregorianischen Kalender. Den Vollmond im März zu finden ist ein Schlüsselelement, um Ostern zu finden, also dachte ich mir, es sollte einen Algorithmus geben, der keinen Trigger benötigt und für alle Daten im gregorianischen Kalender funktioniert.

Ich habe dafür vor einiger Zeit Code nach Python portiert. Ich wollte gerade darauf verlinken, aber es stellte sich heraus, dass es in der Zwischenzeit aus dem Netz gefallen war, also musste ich es entstauben und erneut hochladen. Sehen Mond.py der abgeleitet ist John Walkers Mondwerkzeug.

Ich kann auch keine Referenz dafür finden, für welche Zeitspannen es genau ist, aber es scheint, als ob die Autoren ziemlich streng waren. Was bedeutet, ja, es verwendet Trig, aber ich kann mir nicht vorstellen, wofür zum Teufel Sie das verwenden würden, das es rechnerisch unerschwinglich machen würde. Der Aufwand für Python-Funktionsaufrufe ist wahrscheinlich höher als die Kosten der Trigger-Operationen. Computer sind ziemlich schnell im Rechnen.

Die im Code verwendeten Algorithmen stammen aus folgenden Quellen:

Meius, Jean. Astronomische Algorithmen. Richmond: Willmann-Bell, 1991. ISBN 0-943396-35-2.

Ein Must-have; Wenn Sie nur ein Buch kaufen, stellen Sie sicher, dass es dieses ist. Algorithmen werden mathematisch dargestellt, nicht als Computerprogramme, aber der Quellcode, der viele der Algorithmen im Buch implementiert, kann separat beim Herausgeber entweder in QuickBasic, Turbo Pascal oder C bestellt werden. Meeus stellt viele ausgearbeitete Beispiele für Berechnungen zur Verfügung, die für das Debugging wesentlich sind Ihren Code und präsentiert häufig mehrere Algorithmen mit unterschiedlichen Kompromissen zwischen Genauigkeit, Geschwindigkeit, Komplexität und langfristiger Gültigkeit (Jahrhunderte und Jahrtausende).

Duffett-Smith, Peter. Praktische Astronomie mit Ihrem Taschenrechner. 3. Aufl. Cambridge: Cambridge University Press, 1981. ISBN 0-521-28411-2.

Trotz des Wortes Rechner im Titel; Dies ist eine wertvolle Referenz, wenn Sie daran interessiert sind, Software zu entwickeln, die Planetenpositionen, Umlaufbahnen, Finsternisse und dergleichen berechnet. Es werden mehr Hintergrundinformationen gegeben als in Meeus, was denen hilft, die sich nicht bereits mit Astronomie auskennen, die oft verwirrende Terminologie zu lernen. Die angegebenen Algorithmen sind einfacher und weniger genau als die von Meeus bereitgestellten, aber für die meisten praktischen Arbeiten geeignet.

Wenn Sie wie ich sind, versuchen Sie, ein sorgfältiger Programmierer zu sein. Es macht Sie also nervös, wenn Sie zufälligen Code im Internet verstreut sehen, der vorgibt, ein komplexes astronomisches Problem zu lösen, aber nicht erklärt, warum die Lösung richtig ist.

Sie glauben, dass es maßgebliche Quellen wie z Bücher die sorgfältige und vollständige Lösungen enthalten. Zum Beispiel:

Meius, Jean. Astronomische Algorithmen. Richmond: Willmann-Bell, 1991. ISBN 0-943396-35-2.

Duffett-Smith, Peter. Praktische Astronomie mit Ihrem Taschenrechner. 3. Aufl. Cambridge: Cambridge University Press, 1981. ISBN 0-521-28411-2.

Sie vertrauen auf weit verbreitete, gut getestete Open-Source-Bibliotheken, deren Fehler behoben werden können (im Gegensatz zu statischen Webseiten). Hier ist dann eine Python-Lösung für Ihre Frage, die auf der basiert PyEphem Bibliothek, mit der Phasen des Mondes Schnittstelle.

#!/usr/bin/python
import datetime
import ephem

def get_phase_on_day(year,month,day):
  """Returns a floating-point number from 0-1. where 0=new, 0.5=full, 1=new"""
  #Ephem stores its date numbers as floating points, which the following uses
  #to conveniently extract the percent time between one new moon and the next
  #This corresponds (somewhat roughly) to the phase of the moon.

  #Use Year, Month, Day as arguments
  date=ephem.Date(datetime.date(year,month,day))

  nnm = ephem.next_new_moon    (date)
  pnm = ephem.previous_new_moon(date)

  lunation=(date-pnm)/(nnm-pnm)

  #Note that there is a ephem.Moon().phase() command, but this returns the
  #percentage of the moon which is illuminated. This is not really what we want.

  return lunation

def get_moons_in_year(year):
  """Returns a list of the full and new moons in a year. The list contains tuples
of either the form (DATE,'full') or the form (DATE,'new')"""
  moons=[]

  date=ephem.Date(datetime.date(year,01,01))
  while date.datetime().year==year:
    date=ephem.next_full_moon(date)
    moons.append( (date,'full') )

  date=ephem.Date(datetime.date(year,01,01))
  while date.datetime().year==year:
    date=ephem.next_new_moon(date)
    moons.append( (date,'new') )

  #Note that previous_first_quarter_moon() and previous_last_quarter_moon()
  #are also methods

  moons.sort(key=lambda x: x[0])

  return moons

print get_phase_on_day(2013,1,1)

print get_moons_in_year(2013)

Dies kehrt zurück

0.632652265318

[(2013/1/11 19:43:37, 'new'), (2013/1/27 04:38:22, 'full'), (2013/2/10 07:20:06, 'new'), (2013/2/25 20:26:03, 'full'), (2013/3/11 19:51:00, 'new'), (2013/3/27 09:27:18, 'full'), (2013/4/10 09:35:17, 'new'), (2013/4/25 19:57:06, 'full'), (2013/5/10 00:28:22, 'new'), (2013/5/25 04:24:55, 'full'), (2013/6/8 15:56:19, 'new'), (2013/6/23 11:32:15, 'full'), (2013/7/8 07:14:16, 'new'), (2013/7/22 18:15:31, 'full'), (2013/8/6 21:50:40, 'new'), (2013/8/21 01:44:35, 'full'), (2013/9/5 11:36:07, 'new'), (2013/9/19 11:12:49, 'full'), (2013/10/5 00:34:31, 'new'), (2013/10/18 23:37:39, 'full'), (2013/11/3 12:49:57, 'new'), (2013/11/17 15:15:44, 'full'), (2013/12/3 00:22:22, 'new'), (2013/12/17 09:28:05, 'full'), (2014/1/1 11:14:10, 'new'), (2014/1/16 04:52:10, 'full')]

Ich glaube du hast bei Google falsch gesucht:

• http://home.att.net/~srschmitt/zenosamples/zs_lunarphasecalc.html
• http://www.voidware.com/moon_phase.htm
• http://www.ben-daglish.net/moon.shtml
• http://www.faqs.org/faqs/astronomy/faq/part3/section-15.html

Ebenfalls, pyephem – wissenschaftliche Astronomie-Routinen [PyPI]das ein Python-Paket ist, aber die Rechenleistung in Cund das tut sagen

Genauigkeit < 0,05" von -1369 bis +2950.
Verwendet Tabellensuchtechniken, um Aufrufe auf trigonometrische Funktionen zu begrenzen.

Pyephem verwendet standardmäßig die koordinierte Weltzeit (UTC). Ich wollte ein Programm, das eine Liste der Vollmonde generiert, die in der pazifischen Zeitzone genau ist. Der folgende Code berechnet die Vollmonde für ein bestimmtes Jahr und passt diese dann mit der Methode ephem.localtime() an, um sie auf die gewünschte Zeitzone zu kalibrieren. Es scheint auch die Sommerzeit richtig zu berücksichtigen. Vielen Dank an Richard, dieser Code ähnelt dem, was er geschrieben hat.

#!/usr/bin/python
import datetime
import ephem
import os
import time

# Set time zone to pacific
os.environ['TZ'] = 'US/Pacific'
time.tzset()

print("Time zone calibrated to", os.environ['TZ'])

def get_full_moons_in_year(year):
    """
    Generate a list of full moons for a given year calibrated to the local time zone
    :param year: year to determine the list of full moons
    :return: list of dates as strings in the format YYYY-mm-dd
    """
    moons = []

    date = ephem.Date(datetime.date(year - 1, 12, 31))
    end_date = ephem.Date(datetime.date(year + 1, 1, 1))

    while date <= end_date:
        date = ephem.next_full_moon(date)

        # Convert the moon dates to the local time zone, add to list if moon date still falls in desired year
        local_date = ephem.localtime(date)
        if local_date.year == year:
            # Append the date as a string to the list for easier comparison later
            moons.append(local_date.strftime("%Y-%m-%d"))

    return moons

moons = get_full_moons_in_year(2015)
print(moons)

Der obige Code gibt zurück:

Time zone calibrated to US/Pacific
['2015-01-04', '2015-02-03', '2015-03-05', '2015-04-04', '2015-05-03', '2015-06-02', '2015-07-01', '2015-07-31', '2015-08-29', '2015-09-27', '2015-10-27', '2015-11-25', '2015-12-25']

Ich weiß, dass Sie nach Python suchen, aber wenn Sie C# verstehen, gibt es da draußen ein Open-Source-Projekt namens Chronos XP was das sehr gut macht.

Wenn Sie keine hohe Genauigkeit benötigen, können Sie immer eine Mond- (oder Lunisolar-) Kalenderklasse (ab)verwenden (z. B. HijriCalendar oder ChineseLunisolarCalendar in Microsoft .NET), um die (ungefähre) Mondphase eines beliebigen Datums als “Monatstag”-Eigenschaft des Kalenders zu berechnen, da es sich um einen Mond- (oder Lunisolar-) Kalendertag handelt, entspricht immer der Mondphase (z. B. Tag 1 ist Neumond, Tag 15 ist Vollmond usw.)