var DToR = Math.PI/180.0;
var pi2  = 2.0*Math.PI;

/* Eclipses */

var TOTAL = 1;
var ANNULAR = 2;
var ANNULARTOTAL = 3;
var TOTAL_NOT_CENTRAL = 4;
var ANNULAR_NOT_CENTRAL = 5;
var PARTIAL = 6;
var OLDSYSTEM = 1;
var PENUMBRAL = 7;
var PARTPENUMBRAL = 8;


//Winkel auf das Intervall 0 - 360 Grad reduzieren
function reduzieren(a)
{
  return (a - Math.floor (a / 360) * 360);
}


//Berechnug des Julianischen Datums
function JDay(yy, mm, d)  
{
    var y, m;  //Jahr, Monat
    var a,b;   //Hilfsgroessen   
    var jd;
    
    y=yy;
    m=mm;
   
    if (m<=2)
    {
      y=y-1;
      m=m+12;         
    }
   
    a = (Math.floor(y/100));
    b = ( 2 - a + (Math.floor(a/4)) );
 
    jd=(Math.floor(365.25*(y+4716))) + (Math.floor(30.6001*(m+1)))+d+b-1524.5;
   
    return jd;   
}  


function JDToCal(JD)
{
  TDate = new Array(6); 
  var A, B, F, alpha, C, E, D, Z;
  var yy, mm, dd, h, m, s;

  Z = Math.floor(JD + 0.5);
  F = (JD + 0.5) - Z;

  if (Z < 2299161)
    A = Z;
  else
  {
    alpha = Math.floor((Z - 1867216.25) / 36524.25);
    A = Z + 1 + alpha - Math.floor (alpha / 4);
  }

  B = A + 1524;
  C = Math.floor ((B - 122.1) / 365.25);
  D = Math.floor (365.25 * C);
  E = Math.floor((B - D) / 30.6001);

  dd = B - D - Math.floor (30.6001 * E) + F;

  if (E < 14)
    mm = E - 1;
  else
    mm = E - 13;
  if (mm > 2)
    yy = C - 4716;
  else
   yy = C - 4715;

  F = (F * 24);
  h = Math.floor(F);
  F = (F - Math.floor(F)) * 60;
  m = Math.floor(F);
  s = (F - Math.floor(F)) * 60;


  TDate[0] = yy;
  TDate[1] = mm;
  TDate[2] = Math.floor(dd);
  TDate[3] = h;
  TDate[4] = m;
  TDate[5] = s;

  return TDate;
}


//Vorzeichen ermitteln
function sgn(a)            
{                             
    if (a==0)                                           
      return 0;               
                                
    return (a>0) ? 1 : -1;      
}   

  
//Wochentag aus JD berechnen: 0=Sonntag, 1=Montag, ... , 6=Samatag
function WTag(JD)
{ 
    return Math.floor((JD+1.5)%7);
}                          

//--

// funktioniert :-)

/*****************************************************************************/
/* Name:    modpi2                                                           */
/* Type:    function                                                         */
/* Purpose: reduce an angle to the interval (0, 2pi).                        */
/*****************************************************************************/

function modpi2(x)
{
  return (x - Math.floor (x / pi2) * pi2);
}     


/*****************************************************************************/
/* Name:    JDToT                                                            */
/* Typ:     Function                                                         */
/* Zweck:   verwandelt Julianischen Tag in Jahrhunderte seit 2000.0          */
/* Argumente:                                                                */
/*   JD : umzuwandelnder Julianischer Tag                                    */
/* Ausgabe:                                                                  */
/*   das dem Julianischen Tag entsprechende T                                */
/*****************************************************************************/

function JDToT (JD)
{
  return (JD - 2451545.0) / 36525.0;
}


/*****************************************************************************/
/* Name:    EvalPoly                                                         */
/* Type:    function                                                         */
/* Purpose: evaluate a polynomial.                                           */
/* Arguments:                                                                */
/*   P : the coefficients of the polynomial : P[0] is constant term, etc.    */
/*   n : the degree of the polynomial                                        */
/*   x : the point at which to evaluate the polynomial                       */
/*****************************************************************************/

function EvalPoly(P, n, x)
{
  var tmp = P[n];

  while (n--)
  {
    tmp = tmp * x + P[n];
  }
  return tmp;
}


/*****************************************************************************/
/* Name:    EvalMoonAngles                                                   */
/* Typ:     Procedure                                                        */
/* Zweck:   Berechnet die Winkel Om, D, M, Md und F sowie E.                 */
/* Argumente:                                                                */
/*   T : Zahl der Julianischen Jahrhunderte seit J2000                       */
/* Rueckgabe: Vektor mit folgenden Werten:                                   */
/*   Om, D, M, Md, F, E : die Ergebnisse                                     */
/*                                                                           */
/* Anmerkung: Diese Prozedur wird auch durch MoonPhysEphemeris und Eclipse   */
/*        verwendet.                                                         */
/*****************************************************************************/

function CalcMoonAngles(T) 
{
var Om, D, M, Md, F, E;

var POm = [125.0445550, -1934.1361849, 0.0020762, 2.139449e-6, 1.64973e-8];
var PD  = [297.8502042, 445267.1115168, -0.0016300, 1.831945e-6, 8.84447e-6];
var PM  = [357.5291092, 35999.0502909, -0.0001536, 4.083299e-8];
var PMd = [134.9634114, 477198.8676313, 0.0089970, 1.434741e-5, 6.79717e-8];
var PF  = [ 93.2720993, 483202.0175273, -0.0034029, 2.836075e-7, 1.15833e-9];

  Om = modpi2 (EvalPoly (POm, 4, T) * DToR);
  D  = modpi2 (EvalPoly (PD , 4, T) * DToR);
  M  = modpi2 (EvalPoly (PM , 3, T) * DToR);
  Md = modpi2 (EvalPoly (PMd, 4, T) * DToR);
  F  = modpi2 (EvalPoly (PF , 4, T) * DToR);
  E = 1 - T * (0.002516 + T * 0.0000074);

return [Om, D, M, Md, F, E];  
}


/*****************************************************************************/
/* Name:    GeneralEclipseData                                               */
/* Typ:     Support procedure                                                */
/* Zweck:   Berechnet die allgemeinen Daten einer Finsternis.                */
/* Argumente:                                                                */
/*   k : Nummer der Lunation                                                 */
/* Rueckgabewert: Vektor mit folgenden Argumenten:                           */
/*   JD : Julianischer Tag der maximalen Finsternis                          */
/*   u, Gamma : siehe Text. Wenn sicher keine Finsternis, Gamma = 2          */
/*   Md : mittlere Anomalie des Mondes, nur noetig bei Mondfinsternissen     */
/*****************************************************************************/

function GeneralEclipseData(k)
{
  var T, v, Om, D, M, F, E, F1, A1, sum, P, Q, W, u, Md;

  T = k / 1236.85;
  JD = 2451550.09765 + 29.530588853 * k;
  JD += T * T * (0.0001337 + T * (0.000000150 + T * 0.00000000073));
  T = JDToT (JD);
  v=CalcMoonAngles (T);
  Om = v[0];
  D  = v[1];
  M  = v[2];
  Md = v[3];
  F  = v[4];
  E  = v[5];

  if (Math.abs (Math.sin (F)) < 0.36) 
  {
    /* Finsterniss moeglich */
    F1 = F - 0.02665 * DToR * Math.sin (Om);
    A1 = (299.77 + 0.107408 * k - 0.009173 * T * T) * DToR;
    sum =
      - 0.4075 * Math.sin (Md)
      + 0.1721 * E * Math.sin (M)
      + 0.0161 * Math.sin (2 * Md)
      - 0.0097 * Math.sin (2 * F1)
      + 0.0073 * E * Math.sin (Md - M)
      - 0.0050 * E * Math.sin (Md + M);
    sum +=
      - 0.0023 * Math.sin (Md - 2 * F1)
      + 0.0021 * E * Math.sin (2 * M)
      + 0.0012 * Math.sin (Md + 2 * F1)
      + 0.0006 * E * Math.sin (2 * Md + M)
      - 0.0004 * Math.sin (3 * Md)
      - 0.0003 * E * Math.sin (M + 2 * F1);
    sum +=
      + 0.0003 * Math.sin (A1)
      - 0.0002 * E * Math.sin (M - 2 * F1)
      - 0.0002 * E * Math.sin (2 * Md - M)
      - 0.0002 * Math.sin (Om);
        JD += sum;
    P =
      + 0.2070 * E * Math.sin (M)
      + 0.0024 * E * Math.sin (2 * M)
      - 0.0392 * Math.sin (Md)
      + 0.0116 * Math.sin (2 * Md)
      - 0.0073 * E * Math.sin (Md + M)
      + 0.0067 * E * Math.sin (Md - M)
      + 0.0118 * Math.sin (2 * F1);
    Q =
      + 5.2207 - 0.0048 * E * Math.cos (M)
      + 0.0020 * E * Math.cos (2 * M)
      - 0.3299 * Math.cos (Md)
      - 0.0060 * E * Math.cos (Md + M)
      + 0.0041 * E * Math.cos (Md - M);
    W = Math.abs (Math.cos (F1));

    /* Wir wollen hier nicht wissen, ob die Finsternis */
    /* auf der noerdlichen oder der suedlichen Halbkugel */
    /* eintritt, deshalb nehmen wir den absoluten Wert. */
    Gamma = Math.abs((P * Math.cos (F1) + Q * Math.sin (F1)) * 
                     (1 - 0.0048 * W));
    u =
      + 0.0059
      + 0.0046 * E * Math.cos (M)
      - 0.0182 * Math.cos (Md)
      + 0.0004 * Math.cos (2 * Md)
      - 0.0005 * Math.cos (Md + M);
    }
  else     /* keine Finsterniss moeglich */
    {
    u = 0;
    Gamma = 2;
    }

return [JD, u, Gamma, Md];
}

/*****************************************************************************/
/* Name:    NextSolarEclipse                                                 */
/* Typ:     Function                                                         */
/* Zweck:   Findet die naechste Sonnenfinsternis nach einem Julianischen Tag.*/
/* Argumente:                                                                */
/*   JD : untere Grenze fuer Julianischen Tag                                */
/* Rueckgabewert: Vektor mit folgenden Werten:                               */
/*   JD : Julianischer Tag der Finsternis                                    */
/*   Max : maximale Groesse bei einer partiellen Finsternis                  */
/*   EclipseType : entweder TOTAL, ANNULAR, ANNULARTOTAL, NOT-CENTRAL oder   */
/*                 PARTIAL                                                   */
/*****************************************************************************/

function NextSolarEclipse(JD)
{
  var k, u, Gamma, Dummy, v, Max, EclipseType;

  k = Math.floor ((JD - 2451550.09765) / 29.530588853 + 1.03);

  do 
  {
    v = GeneralEclipseData (k);
    JD = v[0];
    u  = v[1];
    Gamma = v[2];
    k++;
  } 
  while (Gamma > 1.5433 + u);	

  //document.write("NextSolarEclipse: u="+u+"  Gamma="+Gamma+"<BR>");
  if (Gamma < 0.9972)
  {
    if (u < 0.0)
    {
      EclipseType = TOTAL;
      //Max=1; //???????
    }
    else
      if (u > 0.0047)
        EclipseType = ANNULAR;
      else
        if (u < (0.00464 * Math.sqrt (1 - Gamma * Gamma)))
          EclipseType = ANNULARTOTAL;
        else
          EclipseType = ANNULAR;
  }
  else
  {
      if ((Gamma < 0.9972 + Math.abs(u)))
          if (u > 0.0047)
	       EclipseType = ANNULAR_NOT_CENTRAL;
           else
	       EclipseType = TOTAL_NOT_CENTRAL;
      else	
      {
           EclipseType = PARTIAL;
           Max = (1.5433 + u - Gamma) / (0.5461 + 2.0 * u);
      }  
  }
  //document.write("Max="+Max+"<BR>");

  return [JD, Max, EclipseType];
}

/*****************************************************************************/
/* Name:    ip                                                               */
/* Type:    function                                                         */
/* Purpose: return the integral part of a double value.                      */
/*****************************************************************************/

function ip(x)
{
  if (x >= 0)
    return Math.floor(x);
  else
    return Math.ceil(x);
}


/*****************************************************************************/
/* Name:    NextLunarEclipse                                                 */
/* Typ:     Function                                                         */
/* Zweck: Findet die naechste Mondfinsternis nach einem gegebenen            */
/*        Julianischen Tag.                                                  */
/* Argumente:                                                                */
/*   JD : untere Grenze fuer Julianischen Tag                                */
/*   System : normalerweise 0, TRADITIONAL wenn das 'traditionelle'          */
/*                 System der Konstanten benutzt werden soll                 */
/* Rueckgabewerte: Vektor mit folgenden Werten:                              */
/*   JD : Julianischer Tag der Finsternis                                    */
/*   Max : maximale Groesse (im Halbschatten wenn Halbschattenfinsternis))   */
/*   PartialSemiDuration : halbe Dauer der partiellen Phase in Bruchteilen   */
/*                         eines Tages                                       */
/*   TotalSemiDuration : falls zutreffend, die halbe Dauer der totalen       */
/*                       Phase der Finsternis in Tagesbruchteilen            */
/*   EclipseType : entweder TOTAL, PARTIAL oder PENUMBRAL                    */
/*****************************************************************************/

function NextLunarEclipse(JD, System)
{
  var k, u, Gamma, Md, P, T, n;
  var Max, PartialSemiDuration, TotalSemiDuration, EclipseType;

  var LunarEclipseParams = [[1.2848, 0.7403, 1.5573, 1.0128, 0.4678],
                            [1.2985, 0.7432, 1.5710, 1.0157, 0.4707]];

  k = Math.floor ((JD - 2451550.09765) / 29.530588853 + 1.03) + 0.5;

  do 
  {
    v=GeneralEclipseData (k);
    JD = v[0];
    u  = v[1];
    Gamma = v[2];
    Md = v[3];

    k = k + 1;
    EclipseType = TOTAL;
    Max = (LunarEclipseParams[System][3] - u - Gamma) / 0.5450;
    if ((Max < 0))
      {
      EclipseType = PENUMBRAL;
      Max = (LunarEclipseParams[System][2] + u - Gamma) / 0.5450;
      }
  }
  while (!(Max > 0));

  n = 24 * (0.5458 + 0.0400 * Math.cos (Md));

  if (EclipseType == TOTAL)
    {
    P = LunarEclipseParams[System][3] - u;
    T = LunarEclipseParams[System][4] - u;
    if (Gamma < T)
      TotalSemiDuration = Math.sqrt (T * T - Gamma * Gamma) / n;
    else
      EclipseType = PARTIAL;
    if ((Gamma < P))
      PartialSemiDuration = Math.sqrt (P * P - Gamma * Gamma) / n;
    else
      PartialSemiDuration = 0;
    }
  else
    {
    P = 1.5573 + u;
    if ((Gamma < P))
      PartialSemiDuration = Math.sqrt (P * P - Gamma * Gamma) / n;
    else
      PartialSemiDuration = 0;
    }
  return [JD, Max, PartialSemiDuration, TotalSemiDuration, EclipseType];
}


//--
//Elongation des Mondes berechnen
function Mondphase(JDE)
{   	
    var DtoR = Math.PI/180.;
    //Mond
    var T,L1,D,M,M1,F,E,E2,EL;
    var l,b,r,i;
    var A1,A2,A3; 
    var Summe_l=0,Summe_r=0,Summe_b=0;

    //Sonne
    var Lo,Mo,ex,C,wLo;
   
    T = (JDE-2451545.0) / 36525;
    
    L1= 218.3164591 + 481267.88134236*T - 0.0013268*T*T + T*T*T/538841.0 - T*T*T*T/65194000.0;

    //Mittlere Elongation des Mondes
    D = 297.8502042 + 445267.1115168*T - 0.0016300*T*T + T*T*T/545868.0 - T*T*T*T/113065000.0;
    
    //Mittlere Anomalie der Sonne
    M = 357.5291092 + 35999.0502909*T - 0.0001536*T*T + T*T*T/24490000.0;
    
    //Mittlere Anomalie des Mondes
    M1= 134.9634114 + 477198.8676313*T + 0.0089970*T*T + T*T*T/69699.0 - T*T*T*T/14712000.0;
    
    //Mittlerer Abstand des Mondes von seinem absteigenden Knoten
    F = 93.2720993 + 483202.0175273*T - 0.0034029*T*T - T*T*T/3526000.0 + T*T*T*T/863310000.0;
    
    //Exzentrizitaet der Erdbahn
    E = 1.0 - 0.002516*T - 0.0000074*T*T;
    E2=E*E;
    
    L1=reduzieren(L1)*DtoR;
    D =reduzieren(D) *DtoR;
    M =reduzieren(M) *DtoR;
    M1=reduzieren(M1)*DtoR;
    F =reduzieren(F) *DtoR;
    
    //Argumente
    A1=reduzieren(119.75+   131.849*T)*DtoR;
    A2=reduzieren( 53.09+479264.290*T)*DtoR;
    A3=reduzieren(313.45+481266.484*T)*DtoR;
    
    //Summe l
    Summe_l = Summe_l + Math.sin(              1*M1       ) * 6288774 ;    
    Summe_l = Summe_l + Math.sin(2*D +        -  M1       ) * 1274027 ;    
    Summe_l = Summe_l + Math.sin(2*D                      ) *  658314 ;    
    Summe_l = Summe_l + Math.sin(              2*M1       ) *  213618 ;    
    Summe_l = Summe_l + Math.sin(         M               ) * -185116 *E;    
    Summe_l = Summe_l + Math.sin(                     2*F ) * -114332 ;    
    Summe_l = Summe_l + Math.sin(2*D +        -2*M1       ) *   58793 ;    
    Summe_l = Summe_l + Math.sin(2*D   -  M   -  M1       ) *   57066 *E;    
    Summe_l = Summe_l + Math.sin(2*D +           M1       ) *   53322 ;    
    Summe_l = Summe_l + Math.sin(2*D   -  M               ) *   45758 *E;    
    Summe_l = Summe_l + Math.sin(         M   -  M1       ) *  -40923 *E;    
    Summe_l = Summe_l + Math.sin(  D                      ) *  -34720 ;    
    Summe_l = Summe_l + Math.sin(         M +    M1       ) *  -30383 *E;    
    Summe_l = Summe_l + Math.sin(2*D +               -2*F ) *   15327 ;    
    Summe_l = Summe_l + Math.sin(                M1 + 2*F ) *  -12528 ;    
    Summe_l = Summe_l + Math.sin(                M1 +-2*F ) *   10980 ;    
    Summe_l = Summe_l + Math.sin(4*D +        -  M1       ) *   10675 ;    
    Summe_l = Summe_l + Math.sin(              3*M1       ) *   10034 ;    
    Summe_l = Summe_l + Math.sin(4*D +        -2*M1       ) *    8548 ;    
    Summe_l = Summe_l + Math.sin(2*D +    M   -  M1       ) *   -7888 *E;    
    Summe_l = Summe_l + Math.sin(2*D +    M               ) *   -6766 *E;    
    Summe_l = Summe_l + Math.sin(  D +        -  M1       ) *   -5163 ;    
    Summe_l = Summe_l + Math.sin(  D +    M               ) *    4987 *E;    
    Summe_l = Summe_l + Math.sin(2*D   -  M +    M1       ) *    4036 *E;    
    Summe_l = Summe_l + Math.sin(2*D +         2*M1       ) *    3994 ;    
    Summe_l = Summe_l + Math.sin(4*D                      ) *    3861 ;    
    Summe_l = Summe_l + Math.sin(2*D +        -3*M1       ) *    3665 ;    
    Summe_l = Summe_l + Math.sin(         M   -2*M1       ) *   -2689 *E;    
    Summe_l = Summe_l + Math.sin(2*D +        -  M1 + 2*F ) *   -2602 ;    
    Summe_l = Summe_l + Math.sin(2*D   -  M   -2*M1       ) *    2390 *E;    
    Summe_l = Summe_l + Math.sin(  D +           M1       ) *   -2348 ;    
    Summe_l = Summe_l + Math.sin(2*D   -2*M               ) *    2236 *E2;    
    Summe_l = Summe_l + Math.sin(         M +  2*M1       ) *   -2120 *E;    
    Summe_l = Summe_l + Math.sin(       2*M               ) *   -2069 *E2;    
    Summe_l = Summe_l + Math.sin(2*D   -2*M   -  M1       ) *    2048 *E2;    
    Summe_l = Summe_l + Math.sin(2*D +           M1 +-2*F ) *   -1773 ;    
    Summe_l = Summe_l + Math.sin(2*D +                2*F ) *   -1595 ;    
    Summe_l = Summe_l + Math.sin(4*D   -  M   -  M1       ) *    1215 *E;    
    Summe_l = Summe_l + Math.sin(              2*M1 + 2*F ) *   -1110 ;    
    Summe_l = Summe_l + Math.sin(3*D +        -  M1       ) *    -892 ;    
    Summe_l = Summe_l + Math.sin(2*D +    M +    M1       ) *    -810 *E;    
    Summe_l = Summe_l + Math.sin(4*D   -  M   -2*M1       ) *     759 *E;          
    Summe_l = Summe_l + Math.sin(       2*M   -  M1       ) *    -713 *E2;    
    Summe_l = Summe_l + Math.sin(2*D +  2*M   -  M1       ) *    -700 *E2;    
    Summe_l = Summe_l + Math.sin(2*D +    M   -2*M1       ) *     691 *E;    
    Summe_l = Summe_l + Math.sin(2*D   -  M +        -2*F ) *     596 *E;    
    Summe_l = Summe_l + Math.sin(4*D +           M1       ) *     549 ;    
    Summe_l = Summe_l + Math.sin(              4*M1       ) *     537 ;    
    Summe_l = Summe_l + Math.sin(4*D   -  M               ) *     520 *E;    
    Summe_l = Summe_l + Math.sin(  D +        -2*M1       ) *    -487 ;    
    Summe_l = Summe_l + Math.sin(2*D +    M +        -2*F ) *    -399 *E;    
    Summe_l = Summe_l + Math.sin(              2*M1 +-2*F ) *    -381 ;    
    Summe_l = Summe_l + Math.sin(  D +    M +    M1       ) *     351 *E;    
    Summe_l = Summe_l + Math.sin(3*D +        -2*M1       ) *    -340 ;    
    Summe_l = Summe_l + Math.sin(4*D +        -3*M1       ) *     330 ;    
    Summe_l = Summe_l + Math.sin(2*D   -  M +  2*M1       ) *     327 *E;    
    Summe_l = Summe_l + Math.sin(       2*M +    M1       ) *    -323 *E2;    
    Summe_l = Summe_l + Math.sin(  D +    M   -  M1       ) *     299 *E;    
    Summe_l = Summe_l + Math.sin(2*D +         3*M1       ) *     294 ;           

    Summe_l = Summe_l + 3958.0*Math.sin(A1)+1962.0*Math.sin(L1-F)+318.0*Math.sin(A2);
        
    //Summe r
    Summe_r = Summe_r + Math.cos(                M1       ) * -20905355 ;
    Summe_r = Summe_r + Math.cos(2*D +        -  M1       ) *  -3699111 ;
    Summe_r = Summe_r + Math.cos(2*D                      ) *  -2955968 ;
    Summe_r = Summe_r + Math.cos(              2*M1       ) *   -569925 ;
    Summe_r = Summe_r + Math.cos(         M               ) *     48888 *E;
    Summe_r = Summe_r + Math.cos(                     2*F ) *     -3149 ;
    Summe_r = Summe_r + Math.cos(2*D +        -2*M1       ) *    246158 ;
    Summe_r = Summe_r + Math.cos(2*D   -  M   -  M1       ) *   -152138 *E;
    Summe_r = Summe_r + Math.cos(2*D +           M1       ) *   -170733 ;
    Summe_r = Summe_r + Math.cos(2*D   -  M               ) *   -204586 *E;
    Summe_r = Summe_r + Math.cos(         M   -  M1       ) *   -129620 *E;
    Summe_r = Summe_r + Math.cos(  D                      ) *    108743 ;
    Summe_r = Summe_r + Math.cos(         M +    M1       ) *    104755 *E;
    Summe_r = Summe_r + Math.cos(2*D +               -2*F ) *     10321 ;
    
    Summe_r = Summe_r + Math.cos(                M1 +-2*F ) *     79661 ;
    Summe_r = Summe_r + Math.cos(4*D +        -  M1       ) *    -34782 ;
    Summe_r = Summe_r + Math.cos(              3*M1       ) *    -23210 ;
    Summe_r = Summe_r + Math.cos(4*D +        -2*M1       ) *    -21636 ;
    Summe_r = Summe_r + Math.cos(2*D +    M   -  M1       ) *     24208 *E;
    Summe_r = Summe_r + Math.cos(2*D +    M               ) *     30824 *E;
    Summe_r = Summe_r + Math.cos(  D +        -  M1       ) *     -8379 ;
    Summe_r = Summe_r + Math.cos(  D +    M               ) *    -16675 *E;
    Summe_r = Summe_r + Math.cos(2*D   -  M +    M1       ) *    -12831 *E;
    Summe_r = Summe_r + Math.cos(2*D +         2*M1       ) *    -10445 ;
    Summe_r = Summe_r + Math.cos(4*D                      ) *    -11650 ;
    Summe_r = Summe_r + Math.cos(2*D +        -3*M1       ) *     14403 ;
    Summe_r = Summe_r + Math.cos(         M   -2*M1       ) *     -7003 *E;
    
    Summe_r = Summe_r + Math.cos(2*D   -  M   -2*M1       ) *     10056 *E;
    Summe_r = Summe_r + Math.cos(  D +           M1       ) *      6322 ;
    Summe_r = Summe_r + Math.cos(2*D   -2*M               ) *     -9884 *E2;
    Summe_r = Summe_r + Math.cos(         M +  2*M1       ) *      5751 *E;

    Summe_r = Summe_r + Math.cos(2*D   -2*M   -  M1       ) *     -4950 *E2;
    Summe_r = Summe_r + Math.cos(2*D +           M1 +-2*F ) *      4130 ;

    Summe_r = Summe_r + Math.cos(4*D   -  M   -  M1       ) *     -3958 *E;
  
    Summe_r = Summe_r + Math.cos(3*D +        -  M1       ) *      3258 ;
    Summe_r = Summe_r + Math.cos(2*D +    M +    M1       ) *      2616 *E;
    Summe_r = Summe_r + Math.cos(4*D   -  M   -2*M1       ) *     -1897 *E;
    
    Summe_r = Summe_r + Math.cos(       2*M   -  M1       ) *     -2117 *E2;
    Summe_r = Summe_r + Math.cos(2*D +  2*M   -  M1       ) *      2354 *E2;
    
    Summe_r = Summe_r + Math.cos(4*D +           M1       ) *     -1423 ;
    Summe_r = Summe_r + Math.cos(              4*M1       ) *     -1117 ;
    Summe_r = Summe_r + Math.cos(4*D   -  M               ) *     -1571 *E;
    Summe_r = Summe_r + Math.cos(  D +        -2*M1       ) *     -1739 ;
    
    Summe_r = Summe_r + Math.cos(              2*M1 +-2*F ) *     -4421 ;
    
    Summe_r = Summe_r + Math.cos(       2*M +    M1       ) *      1165 *E2;

    Summe_r = Summe_r + Math.cos(2*D +        -  M1 +-2*F ) *      8752 ;
    
    //Summe b
    Summe_b = Summe_b + Math.sin(                          F ) * 5128122 ;      
    Summe_b = Summe_b + Math.sin(                 M1 +     F ) *  280602 ;      
    Summe_b = Summe_b + Math.sin(                 M1    -  F ) *  277693 ;      
    Summe_b = Summe_b + Math.sin( 2*D +                 -  F ) *  173237 ;      
    Summe_b = Summe_b + Math.sin( 2*D +        -  M1 +     F ) *   55413 ;      
    Summe_b = Summe_b + Math.sin( 2*D +        -  M1    -  F ) *   46271 ;      
    Summe_b = Summe_b + Math.sin( 2*D +                    F ) *   32573 ;      
    Summe_b = Summe_b + Math.sin(               2*M1 +     F ) *   17198 ;      
    Summe_b = Summe_b + Math.sin( 2*D +           M1    -  F ) *    9266 ;      
    Summe_b = Summe_b + Math.sin(               2*M1    -  F ) *    8822 ;      
    Summe_b = Summe_b + Math.sin( 2*D   -  M            -  F ) *    8216 *E;      
    Summe_b = Summe_b + Math.sin( 2*D +        -2*M1    -  F ) *    4324 ;      
    Summe_b = Summe_b + Math.sin( 2*D +           M1 +     F ) *    4200 ;      
    Summe_b = Summe_b + Math.sin( 2*D +    M            -  F ) *   -3359 *E;      
    Summe_b = Summe_b + Math.sin( 2*D   -  M   -  M1 +     F ) *    2463 *E;      
    Summe_b = Summe_b + Math.sin( 2*D   -  M +             F ) *    2211 *E;      
    Summe_b = Summe_b + Math.sin( 2*D   -  M   -  M1    -  F ) *    2065 *E;      
    Summe_b = Summe_b + Math.sin(          M   -  M1    -  F ) *   -1870 *E;      
    Summe_b = Summe_b + Math.sin( 4*D +        -  M1    -  F ) *    1828 ;      
    Summe_b = Summe_b + Math.sin(          M +             F ) *   -1794 *E;      
    Summe_b = Summe_b + Math.sin(                        3*F ) *   -1749 ;      
    Summe_b = Summe_b + Math.sin(          M   -  M1 +     F ) *   -1565 *E;      
    Summe_b = Summe_b + Math.sin(   D +                    F ) *   -1491 ;      
    Summe_b = Summe_b + Math.sin(          M +    M1 +     F ) *   -1475 *E;      
    Summe_b = Summe_b + Math.sin(          M +    M1    -  F ) *   -1410 *E;      
    Summe_b = Summe_b + Math.sin(          M            -  F ) *   -1344 *E;      
    Summe_b = Summe_b + Math.sin(   D +                 -  F ) *   -1335 ;      
    Summe_b = Summe_b + Math.sin(               3*M1 +     F ) *    1107 ;      
    Summe_b = Summe_b + Math.sin( 4*D +                 -  F ) *    1021 ;      
    Summe_b = Summe_b + Math.sin( 4*D +        -  M1 +     F ) *     833 ;      
    Summe_b = Summe_b + Math.sin(                 M1    -3*F ) *     777 ; 
    Summe_b = Summe_b + Math.sin( 4*D +        -2*M1 +     F ) *     671 ; 
    Summe_b = Summe_b + Math.sin( 2*D +                 -3*F ) *     607 ; 
    Summe_b = Summe_b + Math.sin( 2*D +         2*M1    -  F ) *     596 ; 
    Summe_b = Summe_b + Math.sin( 2*D   -  M +    M1    -  F ) *     491 *E; 
    Summe_b = Summe_b + Math.sin( 2*D +        -2*M1 +     F ) *    -451 ; 
    Summe_b = Summe_b + Math.sin(               3*M1    -  F ) *     439 ; 
    Summe_b = Summe_b + Math.sin( 2*D +         2*M1 +     F ) *     422 ; 
    Summe_b = Summe_b + Math.sin( 2*D +        -3*M1    -  F ) *     421 ; 
    Summe_b = Summe_b + Math.sin( 2*D +    M   -  M1 +     F ) *    -366 *E; 
    Summe_b = Summe_b + Math.sin( 2*D +    M +             F ) *    -351 *E; 
    Summe_b = Summe_b + Math.sin( 4*D +                    F ) *     331 ; 
    Summe_b = Summe_b + Math.sin( 2*D   -  M +    M1 +     F ) *     315 *E; 
    Summe_b = Summe_b + Math.sin( 2*D   -2*M            -  F ) *     302 *E2; 
    Summe_b = Summe_b + Math.sin(                 M1 +   3*F ) *    -283 ; 
    Summe_b = Summe_b + Math.sin( 2*D +    M +    M1    -  F ) *    -229 *E; 
    Summe_b = Summe_b + Math.sin(   D +    M            -  F ) *     223 *E; 
    Summe_b = Summe_b + Math.sin(   D +    M +             F ) *     223 *E; 
    Summe_b = Summe_b + Math.sin(          M   -2*M1    -  F ) *    -220 *E; 
    Summe_b = Summe_b + Math.sin( 2*D +    M   -  M1    -  F ) *    -220 *E; 
    Summe_b = Summe_b + Math.sin(   D +           M1 +     F ) *    -185 ; 
    Summe_b = Summe_b + Math.sin( 2*D   -  M   -2*M1    -  F ) *     181 *E; 
    Summe_b = Summe_b + Math.sin(          M +  2*M1 +     F ) *    -177 *E; 
    Summe_b = Summe_b + Math.sin( 4*D +        -2*M1    -  F ) *     176 ; 
    Summe_b = Summe_b + Math.sin( 4*D   -  M   -  M1    -  F ) *     166 *E; 
    Summe_b = Summe_b + Math.sin(   D +           M1    -  F ) *    -164 ; 
    Summe_b = Summe_b + Math.sin( 4*D +           M1    -  F ) *     132 ; 
    Summe_b = Summe_b + Math.sin(   D +        -  M1    -  F ) *    -119 ; 
    Summe_b = Summe_b + Math.sin( 4*D   -  M            -  F ) *     115 *E; 
    Summe_b = Summe_b + Math.sin( 2*D   -2*M +             F ) *     107 *E2; 

    Summe_b = Summe_b - 2235.0*Math.sin(L1)+382.0*Math.sin(A3)+175.0*Math.sin(A1-F)+175.0*Math.sin(A1+F)+127.0*Math.sin(L1-M1)-115.0*Math.sin(L1+M1);

    Summe_l = Summe_l/1000000.0;
    Summe_b = Summe_b/1000000.0;
    Summe_r = Summe_r/1000.0;
    
    //Koordinaten des Mondes
    l = L1/DtoR + Summe_l;       //Laenge
    b = Summe_b;                 //Breite
    r = 385000.56 + Summe_r;     //Entfernung in km
    
    //Phasenwinkel
    //i = 180-D/DtoR-6.289*Math.sin(M1)+2.100*Math.sin(M)-1.274*Math.sin(2*D-M1)-0.658*Math.sin(2*D)-0.214*Math.sin(2*M1)-0.110*Math.sin(D);

   
    //Länge der Sonne
   
    //geometrische mittlere Laenge der Sonne
    Lo = 280.46645 + 36000.76983*T - 0.0003032*T*T;
    Lo = reduzieren(Lo);
    
    //mittlere Anomalie der Sonne
    Mo =357.52910 + 35999.05030*T + 0.0001559*T*T - 0.00000048*T*T*T; 
    Mo=reduzieren(Mo)*DtoR;
        
    //Exzentrizitaet der Erdbahn - wird hier nicht gebraucht!
    //ex=0.016708617 - 0.000042037*T - 0.0000001236*T*T;
    
    //Mittelpunktsgleichung der Sonne
    C  = (1.914600-0.004817*T+0.000014*T*T)*Math.sin(Mo);
    C += (0.019993-0.000101*T)*Math.sin(2*Mo);
    C += 0.000290*Math.sin(3*Mo);
    
    C  = reduzieren(C);
    wLo= Lo + C;
    wLo= reduzieren(wLo);
    
    //Mondphase
    EL = l - wLo;          //Mondphase=Laenge d.Mondes - Lenge d.Sonne
    
    return reduzieren(EL); //Mondphase
}


function Mondkal(yy,mm)
{

     Dat=new Array(6);  
     var JDE,EL;	
     var m_alt,dd=1,nr,idx;
     var i=0, k=0;
     
     Tag = ["Sonntag","Montag","Dienstag","Mittwoch","Donnerstag","Freitag",
            "Samstag"]; 
    
     Monate = ["","Januar","Februar","M&auml;rz","April","Mai","Juni","Juli",
                  "August","September","Oktober","November","Dezember"];

     m_alt=mm;
     JDE=JDay(yy,mm,1); 

     /* Finsternisse Suchen */

     //naechste Sonnenfinsternis suchen
     var SofiData=NextSolarEclipse(JDE-1);
     var SEDate=JDToCal(SofiData[0]); 
     //document.write("Sofi: "+SEDate[2]+"."+SEDate[1]+". ");
     //document.write(SofiData[1]+"<BR>");

     //naechste Mondfinsternis suchen
     var MofiData=NextLunarEclipse(JDE-15,0); 
     var LEDate=JDToCal(MofiData[0]); 
     //document.write("Mondfi: "+LEDate[2]+"."+LEDate[1]+".<BR>");


     document.writeln("<H2 align=center>im "+Monate[mm]+" "+yy+"</H2>")
     
     document.writeln("<CENTER>");
     document.writeln("<TABLE border=5 bgcolor=black>");
     document.writeln("<TR>");
     
     for (i=0; i<7; i++) // 7 Spalten mit Namen der Wochentage als Ueberschrift
     {
        document.write("<TH>");
        
     	idx=WTag(JDE+i);  
        
     	if (idx==0)                    // Sonntag in rot setzen
	    document.write("<font color=red>"+Tag[idx]+"</font>");
     	else
	    document.write(Tag[idx]);  
	
        document.write("</TH>");
     }
    
     document.writeln("</TR>");
     
     i=0;
     
     while (m_alt==mm)  //Schleife ueber den Monat
     {       
	 EL=Mondphase(JDE);

	 nr=Math.round(EL); 
 
	 if (nr<10)
	     Bild="../img/Mond00"+nr+".gif";
	 if ((nr>=10) && (nr<100))
	     Bild="../img/Mond0"+nr+".gif"; 
	 if (nr>=100)
	     Bild="../img/Mond"+nr+".gif";  	

         if (dd == SEDate[2] && mm == SEDate[1]) //Sonnenfinsternis
         { 
             if(SofiData[2]==TOTAL)
               Bild="../img/Sofi.gif";
             if(SofiData[2]==ANNULAR)
               Bild="../img/AnnularSofi.gif";               
             if(SofiData[2]==ANNULAR_NOT_CENTRAL)
               Bild="../img/AnnularSofi.gif";                 
             if(SofiData[2]==PARTIAL)
               Bild="../img/PartSofi.gif";

            //naechste Sonnenfinsternis suchen
            SofiData=NextSolarEclipse(JDE+1);
            SEDate=JDToCal(SofiData[0]); 
            //document.write("Sofi: "+SEDate[2]+"."+SEDate[1]+".<BR>");

         }
         if (dd == LEDate[2] && mm == LEDate[1]) //Mondfinsternis
         {         	
             if(MofiData[4]==1)
               Bild="../img/Mofi.gif";
             else
               Bild="../img/PartMofi.gif"; 

            //naechste Mondfinsternis suchen
            MofiData=NextLunarEclipse(JDE+1,0); 
            LEDate=JDToCal(MofiData[0]); 
            //document.write("Mondfi: "+LEDate[2]+"."+LEDate[1]+".<BR>");

         }

	 idx=WTag(JDE);  
   	 
	 if (idx==0)
	 {    // Sonntag in rot setzen
	     document.write("<TD><IMG SRC="+Bild+" width=100 height=100><BR>");
	     document.write("<font color=red>"+dd+"</font></TD>");
	 }
	 else
         {
	     document.write("<TD><IMG SRC="+Bild+" width=100 height=100>");
             document.write("<BR>"+dd+"</TD>");
	 } 
	 if (i<6)  
	     i++;
	 else    
	     {   //neue Zeile anfangen
		 i=0;  		 
		 document.writeln("</TR>");
	     }
	 
	 JDE++;  
	 dd++;   //Kalenderdatum um eins weiterzaehlen
	 TDate=JDToCal(JDE);        
	 mm=TDate[1];

     }   //Ende der Schleife ueber den Monat


     if(i!=0)  //ev.Rest der Zeile mit Leerstellen auffuellen
     {
        for(k=i; k<7; k++)
	      document.write("<TD>&nbsp;</TD>");
     }

     document.writeln("</TR>");
     document.writeln("</TABLE>"); //Tabelle beenden     
     document.writeln("Alle Angaben f&uuml;r 1Uhr MEZ!");
     document.writeln("</CENTER>");
     
}