Lune / Phase Lunaire Algorithme

J'ai porté du code Python pour cela un moment de retour. J'allais juste un lien, mais il s'avère qu'il est tombé sur le web dans l'intervalle, j'ai donc dû aller dépoussiérer et le télécharger à nouveau. Voir moon.py qui est dérivée à partir de John Walker moontool.

Je ne trouve pas de référence pour ce pour ce les travées du temps c'est exact, soit, mais il semble que les auteurs ont été assez rigoureux. Ce qui signifie oui, il fait utiliser la trigo, mais je ne peux pas imaginer ce que le diable vous utiliserez pour ce qui ferait de calcul prohibitif. Python appel de fonction, les frais généraux est probablement plus élevé que le coût des opérations trigonométriques. Les ordinateurs sont assez rapide à l'informatique.

Les algorithmes utilisés dans le code sont tirées des sources suivantes:

Meeus, Jean. Astronomical Algorithms. Richmond: Willmann-Bell, 1991. ISBN 0-943396-35-2.

Un must-have; si vous achetez seulement un livre, assurez-vous qu'il est celui-là. Les algorithmes sont présentés mathématiquement, pas comme les programmes d'ordinateur, mais le code source de la mise en œuvre de la plupart des algorithmes dans le livre peut être commandé séparément à partir de l'éditeur dans QuickBasic, Turbo Pascal ou C. Meeus fournit de nombreux exemples de calculs qui sont essentiels pour le débogage de votre code, et souvent présente plusieurs algorithmes différents compromis entre la précision, la vitesse, la complexité, et à long terme (du siècle et du millénaire) la validité.

Duffett-Smith, Peter. L'Astronomie Pratique Avec Votre Calculatrice. 3e ed. Cambridge: Cambridge University Press, 1981. ISBN 0-521-28411-2.

Malgré le mot de la Calculatrice dans le titre; c'est une référence précieuse si vous êtes intéressé dans le développement de logiciel qui calcule les positions des planètes, les orbites, les éclipses, et la comme. Plus de renseignements, étant donné que dans Meeus, qui aide ceux qui ne sont pas déjà versé dans l'astronomie apprennent souvent de la confusion terminologique. Les algorithmes donnés sont plus simples et moins précises que celles fournies par Meeus, mais sont adaptés pour la plupart des travaux pratiques.

Si vous êtes comme moi, vous essayez d'être prudent programmeur. Si cela vous rend nerveux quand vous voyez code aléatoire dispersés à travers l'internet qui vise à résoudre un complexe astronomique problème, mais n'explique pas pourquoi la solution est correcte.

Vous croyez qu'il doit y avoir des sources faisant autorité tels que livres qui contiennent de l'attention, et complète, des solutions. Par exemple:

Meeus, Jean. Astronomical Algorithms. Richmond: Willmann-Bell, 1991. ISBN 0-943396-35-2.

Duffett-Smith, Peter. L'Astronomie Pratique Avec Votre Calculatrice. 3e ed. Cambridge:
Cambridge University Press, 1981. ISBN 0-521-28411-2.

Vous placez votre confiance dans largement utilisé et bien testé, bibliothèques open source qui peuvent avoir leurs erreurs corrigées (à la différence des pages web statiques). Ici, alors, est un Python solution à votre question en se basant sur la PyEphem de la bibliothèque, à l'aide de la Les Phases de la Lune interface.

#!/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)

Cela renvoie

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')]

Pyephem utilise par défaut universel coordonné (UTC) heure. Je voulais un programme qui permettrait de générer une liste de pleines lunes qui seraient exactes dans le fuseau horaire du pacifique. Le code ci-dessous calculer les pleines lunes pour une année donnée, puis de régler cela à l'aide de la ephem.localtime() la méthode pour calibrer le fuseau horaire désiré. Il apparaît également pour prendre correctement en compte l'heure d'été ainsi. Merci à Richard, ce code est similaire à ce qu'il avait écrit.

#!/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)

Le code ci-dessus sera de retour:

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']

Un rapide google a révélé cette.