Algorithme De La Phase Lunaire / Lunaire

je pense que vous avez cherché à tromper google:

• 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

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

vous croyez qu'il doit y avoir des sources faisant autorité comme livres qui contiennent des solutions prudentes et complètes. Par exemple:

Meeus, Jean. Algorithmes Astronomiques. Richmond: Willmann-Bell, 1991. ISBN 0-943396-35-2.

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

vous faites confiance à des bibliothèques largement utilisées, bien testées et open source qui peuvent faire corriger leurs erreurs (contrairement aux pages Web statiques). Voici donc une solution Python à votre question basée sur le PyEphem bibliothèque, en utilisant le 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)

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

Également pyephem-routines d'astronomie de niveau scientifique [PyPI], qui est un paquet Python mais qui a le calcul tripes en C et

Précision < 0.05" de -1369 à +2950.

Utilise des techniques de recherche de table pour limiter les appels aux fonctions trigonométriques.

Pyephem par défaut utilise le temps universel coordonné (UTC). Je voulais un programme qui générerait une liste de lunes complètes qui seraient précises dans le fuseau horaire du Pacifique. Le code ci-dessous calculera les lunes complètes pour une année donnée, puis ajustera cela en utilisant l'éphémère.méthode localtime () pour calibrer au fuseau horaire désiré. Il semble également tenir compte de l'heure avancée. Merci à Richard, ce code est similaire à ce qu'il avait écrire.

#!/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']

je sais que vous cherchez Python mais si vous pouvez comprendre C# il y a un projet open source qui s'appelle Chronos XP qui le fait très bien.

Un rapide google a révélé .

si vous n'avez pas besoin d'une grande précision, vous pouvez toujours (ab)utiliser une classe de calendrier lunaire (ou lunisolaire) (par exemple, HijriCalendar ou ChineseLunisolarCalendar dans Microsoft .NET) pour calculer la phase de lune (approximative) de n'importe quelle date, comme la propriété de "jour du mois" du calendrier, étant un jour de calendrier lunaire (ou lunisolaire), correspond toujours à la phase de lune