Vorschlag für Module

von Rolf Wirz  -  Version 15.2.2001  -  Copyright by Rolf Wirz

Alle Daten löschen, Neubeginn:

\(\(\( (*Old\ \(Form : 
          Remove["Global`@*"]\)*) \)\(\ \ \ \)\(
\)\(\(putz = 
          Remove["Global`*"];\) (*\ "Putzmaschine"\ *) \ ;\)\)\)

Die Modulsammlung, alle Funktionen in einer Zelle definiert, in einem Schritt aktivierbar.
Die Sammlung MUSS AKTIVIERT SEIN, damit die Initialisierungen laufen können!

\( (*\(\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\)\(=\)*) 
 (*\ 
      Standartwerte\ φ\ von\ Biel\ in\ Altgrad\ , \ 
      g\  = \ 1\ *) 
 (*\(\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\)\(=\)*) 
\(dataEntryFixData = 
        Module[{}, 
m0 = \((356.5399 - 
                  360)\)\ Degree; \ 
e = 
            0.0167092; 
L0 = \((282.9399 - 
                  360)\)\ Degree; \ 
Eps\  = \ 
            23.4393\ Degree; 
L01 = 
            0.0000470684\ Degree; 
m01 = 
            0.9856002664\ Degree; 
Print["OUT-Variabeln: m0, e, L0, Eps, L01, m01"];];\)
 (*\(\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\)\(=\)*) \)
\(\(dataEntry[TAKEφ_, TAKEg_, jahr_] := 
        Module[{\ φ0 = 47.09, \ g0 = \ 1, 
            intYeahr}, 
dataEntryFixData; 
 (*\ 
            MP\ berechnen, \(\(Formel\)\(:\)\)*) 
φ = φ0 \((1 - \ Sign[TAKEφ])\) \((1 + \ 
                    Sign[TAKEφ])\) + 
              TAKEφ; 
Print["φ = ", φ]; 
φVert = \(-Sign[φ]\)*\((90 - Abs[φ])\); 
g = 
            g0 \((1 - \ Sign[TAKEg])\) \((1 + \ Sign[TAKEg])\) + 
              TAKEg; 
Print["g = ", 
            g]; 
 (*\ 
            Stunden\  === \(\(>\)\(\ \)\(Rad - 
                  Umrechnungsfaktor\)\)\ *) 
hour = \ 
            2\ Pi/24\ \ ; \ 
 (*\ 
            Jahrestage\ rechnen\ *) 
jahresTage[
              intYeahr_] := \ 
            365\ \ Mod[intYeahr, 2000] + 
              Floor[
                Mod[\ Mod[intYeahr, 2000], 2000]/
                  4]; 
jahresTage[
            jahr]; 
jahrOut = 
            jahr; 
Print["OUT-Variabeln: φ, φVert, g, hour, jahresTage, jahrOut"];\ ];\)
 (*\(\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\)\(=\)*) 
 (*\ \(\(===\)\(\(>\)\(\ \)\(INPUT\)\)\), \ hMin = \ 1. \ Stunde, \ 
      hMax = Letzte\ Stunde\ \((h)\)\ *) 
 (*\ 
      Beispiel : \ Werte\ hMin = \ \(-5\) h, \(-4\) h,  ... , 0  h,  ... , \ 
      hMax = 5  
          h\ *) 
 (*\(\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\)\(=\)*) \)
\(\(ombrixGzentr[hMin_, hMax_] := 
        Module[{tVar, φVar}, 
Print["Der Modul dataEntry wird hier vorausgesetzt!"]; 
 (*\ 
            Ost - West - \(\(Koordinate\)\(:\)\)*) 
MP[
              tVar_, φVar_] := 
            g\ Tan[tVar\ \ hour]/\ 
                Sin[\((90 - φVar)\)\ Degree]; 
 (*\ Ursprung\ versetzt, \ 
            Nord - Süd - 
              Koordinate\ *) 
ursprung[φVar_] := {\ 0, \(-g\)/Tan[φVar\ Degree]}; 
 (*\ 
            Tabelle\ der\ Plotpunkte\ rechnen\ *) 
tabPlotPunkte[φVar_] := 
            Table[{MP[tVar, φVar], 
                g/Tan[\((90 - φVar)\)\ Degree]}, {tVar, hMin, hMax, 
                1}]; \ 
Print["tabPlotPunkte = ", 
            tabPlotPunkte[φ] // N]; 
 (*\ 
            OmbrixPlot\ machen\  === \(\(>\)\(\ \)\(Ombrix - 
                  Zifferblatt\)\)\ *) 
ombixPlot = 
            Show[Graphics[
                Table[Line[{ursprung[φ], \(tabPlotPunkte[φ]\)[\([n]\)]}], {n, 1, 
                    Length[tabPlotPunkte[φ]]}]], 
              AspectRatio -> 
                Automatic]; \ 
Print["OUT-Funktionen: MP, ursprung, tabPlotPunkte, ombixPlot"];];\)
 (*\(\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\)\(=\)*) 
 (*\ \(\(===\)\(\(>\)\(\ \)\(INPUT\)\)\), \ hMin = \ 1. \ Stunde, \ 
      hMax = Letzte\ Stunde\ \((h)\)\ *) 
 (*\ 
      Beispiel : \ Werte\ hMin = \ \(-5\) h, \(-4\) h,  ... , 0  h,  ... , \ 
      hMax = 5  
          h\ *) 
 (*\(\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\)\(=\)*) \)
\(\(ombrixGzentrDeltaStd[hMin_, hMax_, deltaStd_] := 
        Module[{tVar, φVar, 
            diff}, 
Print["Der Modul dataEntry wird hier vorausgesetzt!"]; 
 (*\ 
            Ost - West - \(\(Koordinate\)\(:\)\)*) 
MP[
              tVar_, φVar_, diff_] := 
            g\ Tan[\((tVar - diff)\)\ hour]/\ 
                Sin[\((90 - φVar)\)\ Degree]; 
 (*\ Ursprung\ versetzt, \ 
            Nord - Süd - 
              Koordinate\ *) 
ursprung[φVar_] := {\ 0, \(-g\)/Tan[φVar\ Degree]}; 
 (*\ 
            Tabelle\ der\ Plotpunkte\ rechnen\ *) 
tabPlotPunkte[φVar_] := 
            Table[{MP[tVar, φVar, deltaStd], 
                g/Tan[\((90 - φVar)\)\ Degree]}, {tVar, hMin, hMax, 
                1}]; \ 
Print["tabPlotPunkte = ", 
            tabPlotPunkte[φ] // N]; 
 (*\ 
            OmbrixPlot\ machen\  === \(\(>\)\(\ \)\(Ombrix - 
                  Zifferblatt\)\)\ *) 
ombixPlot = 
            Show[Graphics[
                Table[Line[{ursprung[φ], \(tabPlotPunkte[φ]\)[\([n]\)]}], {n, 1, 
                    Length[tabPlotPunkte[φ]]}]], 
              AspectRatio -> 
                Automatic]; \ \ 
Print["OUT-Funktionen: MP, ursprung, tabPlotPunkte, ombixPlot"];];\)
 (*\(\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\)\(=\)*) 
 (*\ tage\  === \(\(>\)\(\ \)\(Berechnung\ der\ Anzahl\ Tage\ seit\ 31.12 . \ 
              letzten\ Jahres\)\)\ *) 
 (*\ 
      fpTage\  === \(\(>\)\(\ \)\(Berechnung\ der\ Anzahl\ Tage\ seit\ letztem\ Frühlingsbeginn\)\), \ \(\(Jan\)\(.\)\)\  = \ 
        13. \ \(\(Mt\)\(.\)\), \ \(\(Feb\)\(.\)\)\  = \ 
        14. \ \(\(Mt\)\(.\)\)\ *) 
 (*\ tageS, \ 
      fpTageS\  === \(\(>\)\(\ \)\(für\ Schaltjahre\)\), \ 
      ein\ Tag\ mehr\ \((ein\ Tag\ mehr)\)\ *) 
 (*\(\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\)\(=\)*) \)
kalender[jour_, mois_] := 
        Module[{m, n},  
m[n_] := 31; m[2] = 28; 
          m[4] = 30; m[6] = 30;  m[9] = 30; m[11] = 30; m[14] = 28; 
          m[0] = 0; 
tage[day_, mon_] = 
            Sum[m[n], {n, 1, mon}] - m[mon] + day; 
tageSJ[
              day_, mon_] = 
            If[mon < 3, tage[day, mon], 
              tage[day, mon] + 1]; 
fpTage[day_, mon_] = 
            tage[day, mon] - tage[21, 3]; 
fpTageSJ[day_, 
              mon_] = tage[day, mon] - tage[21, 3] + 
              1; 
Print["   tage[jour,mois] = ",  
            tage[jour, 
              mois], 
"   tageSJ[jour,mois] = ", 
            tageSJ[jour, 
              mois], 
"   fpTage[jour,mois] = ", 
            fpTage[jour, 
              mois], 
"   fpTageSJ[jour,mois] = ", 
            fpTageSJ[jour, 
              mois] ];   
Print["OUT-Funktionen: tage \
,tageSJ, fpTage, fpTageSJ"];  
          Print["Funktioniert für positiv eingegebene \
Werte"];];
  
\(\(zeitGleichung[plotYes1_, jahr_] := 
        Module[{disp}, 
 (*\ \(putz;\)\ *) 
 (*\ 
            Jahr\ auf\ 2\ Stellen\ angeben . \ Z . B . \ 
                00\ statt\ 2000\ *) 
dataEntry[0, 0, 
            jahr]; 
 (*\ 
            Keplerfunktion\ *) 
f[eE_, d_] := \ 
            eE - e\ Sin[eE]\  - m0 - m01\ jahresTage[jahr] - 
              m01\ \ \ d; 
eE[d_] := 
            eNS\  /. FindRoot[
                f[eNS, d] == 0, {eNS, 3}]; 
zG[d_] := 
            L0 + m0 + \((L01 + m01)\) d\ \  + \ 
              Mod[\((L01 + m01)\) jahresTage[jahr], 
360] - 
              ArcTan[Tan[
                    2\ ArcTan[
                          Sqrt[\((1 + e)\)/\((1 - e)\)]\ Tan[eE[d]/2\ ]] + 
                      L0 + L01\ d + \ L01\ jahresTage[jahr]]\ \ Cos[Eps]] - \ 
              jahrOut\ 2\ Pi; 
 (*\ 
            Die\ Sprünge\ des\ Arcustangens\ durch\ Stetigmachen\ resp . \ Zusammensetzen\ \(\(überwinden\)\(:\)\)*) 
updown[
              d_] := \((1 - Sign[\((zG[d] - 1)\)])\)/2\ \ zG[
                d]; 
upup[
              d_] := \((1 + Sign[\((zG[d] - 1)\)])\)/
                2\ \((zG[d] - Pi)\); 
up[d_] := 
            updown[d] + upup[d]; 
downall[
              d_] := \((1 - Sign[\((zG[d] + 1)\)])\)\ /
                2\ \ \((zG[d] + Pi)\); 
upall[
              d_] := \((1 + Sign[\((zG[d] + 1)\)])\)/2\ up[
                d]; 
glattZG[
              d_] := \((upall[d] + downall[d])\); 
zgStd[
              d_] := glattZG[
                  d]/\((2  Pi)\)\ 24\ ; 
zgMinuten[d_] := 
            glattZG[d]/\((2  Pi)\)\ 24\ 60; 
If[
            plotYes1 == 1, Goto[erstens], 
            Goto[zweitens]]; 
Label[erstens]; 
          Plot[zgMinuten[day]\ , {day, \(-191\), 356}]; 
          Goto[drittens]; 
Label[zweitens]; 
          Print["Kein Plot, nur Initialisierung"]; 
Label[
            drittens]; \ \ 
Print["OUT-Funktionen: f, eE, zG, updown, upup, up, downall, upall, glattZG, zgStd, zgMinuten"]; \ 
          Print["Jahr auf 2 Stellen angeben. Z.B. 00 statt 2000"];];\)
 (*\(\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\)\(=\)*) \)
deklin[myTag_, myMonat_] := 
        Module[{dayNow}, 
dayNow = 
            tage[myTag, myMonat]; 
deltaAngle[dd_] := 
            360/(2 Pi) ArcSin[
                Sin[2 ArcTan[
                          Sqrt[(1 + e)/(1 - e)] Tan[
                              Evaluate[eE[dd]]/2 ]] + L0 + L01 dd]  Sin[
                    Eps]]; 
Print["OUT-Funktionen: \
deltaAngle = ", 
            deltaAngle[
              tage[myTag, myMonat]] ]; 
deltaAngle[
            dayNow] ];
  
\(\(dekPlot[dataListe_, horVert_, tMin_, tMax_, yRangeMin_, yRangeMax_, 
          plotYes1_] := 
        Module[{fi}, 
\ \ If[horVert == 1, 
            fi = φ, \ 
            If[horVert == 0, fi = φVert, 
              Print["Vertikal: horVert=0 und horizontal horVert = 1 !!!!"]]]; 
 (*\ 
            Definitionen\ und\ Rechnungen\ *) 
v[d_, fi_, 
              t_] := g/\((Cos[Sign[φ]\ \ d\ Degree]\ Cos[
                        t\ hour]\ Sin[fi\ Degree]\  + \ 
                    Sin[Sign[φ]\ d\ Degree]\ Cos[
                        fi\ Degree])\)\ {\((Cos[
                      Sign[φ]\ d\ Degree]\ Sin[t\ hour])\), 
                Sign[φ] \((\((Cos[
                            Sign[φ]\ d\ Degree]\ Cos[t\ hour]\ Cos[
                            fi\ Degree]\  - \ 
                        Sin[Sign[φ]\ d\ Degree]\ Sin[
                            fi\ Degree])\)\ )\)}; 
If[
            plotYes1 == 1, Goto[erstens], 
            Goto[zweitens]]; 
Label[erstens]; 
          ParametricPlot[
            Evaluate[
              Table[v[dataListe[\([j]\)], fi, t], {j, 1, 
                  Length[dataListe]}]], {t, tMin, tMax}, \ 
            AspectRatio -> Automatic, 
            PlotRange -> {yRangeMin, yRangeMax}]; 
          Print["Goto ist verwendet worden"]; 
          Goto[drittens]; 
Label[zweitens]; 
          Print["Kein Plot, nur Initialisierung von v[d,fi,t]!"]; 
          Print["Goto ist verwendet worden"]; 
Label[
            drittens]; 
Print["OUT-Funktionen: v"];\ ];\)
 (*\(\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\)\(=\)*) \)
\(\(zeitSchlaufen[dataListe_, horVert_, 
          maxDekNummer_, {paramMin_, paramMax_}, {rangeMin_, 
            rangeMax_}, {minNumber_, maxNumber_}] := 
        Module[{fi}, 
\ \ If[horVert == 1, 
            fi = φ, \ 
            If[horVert == 0, fi = φVert, 
              Print["Vertikal: horVert=0 und horizontal horVert = 1 !!!!"]; Goto[endeProgramm]]]; 
parPlot = 
            ParametricPlot[
              Evaluate[
                Table[v[dataListe[\([k]\)], fi, t], {k, 1, 
                    Length[dataListe]}]], {t, paramMin, paramMax}, \ 
              AspectRatio -> Automatic, 
              PlotRange -> {rangeMin, 
                  rangeMax}, 
Epilog -> {Table[
                    Line[{\ v[dataListe[\([maxDekNummer]\)], fi, k], 
                        ursprung[fi]}], {k, minNumber, maxNumber, 1}]}, 
              DisplayFunction -> Identity]; 
tabd[n_] := 
            Table[v[ArcSin[
                    Sin[2\ ArcTan[
                              Sqrt[\((1 + e)\)/\((1 - e)\)]\ Tan[
                                  eE[d]/2\ ]] + L0 + L01\ d]\ Sin[Eps]]\ /
                  Degree, fi, \((n - zgStd[d])\)], {d, \(-100\), 
                300}]; 
listp[n_] := 
            ListPlot[tabd[n], PlotJoined -> True, \ 
              AspectRatio -> Automatic, 
              DisplayFunction -> Identity]; 
listp0 = 
            Show[Table[listp[j], {j, minNumber, maxNumber, 1}], 
              DisplayFunction -> Identity]; 
Show[
            parPlot, listp0, 
            DisplayFunction -> $DisplayFunction]; 
Label[
            endeProgramm]; 
Print["Ende"]; 
Print["OUT-Funktionen und Variablen: parPlot, tabd, listp, listp0"];];\)
 (*\ 
      Alternativdefinition\ ohne\ Klammern\ *) \)
zeitSchlaufen[dataListe_, horVert_, maxDekNummer_, paramMin_, 
          paramMax_, rangeMin_, rangeMax_, minNumber_, maxNumber_] := 
        zeitSchlaufen[dataListe, horVert, 
          maxDekNummer, {paramMin, paramMax}, {rangeMin, 
            rangeMax}, {minNumber, 
            maxNumber}];
 (*====================================================*) 
\(\(newPositionWithPrint[ostNord_, zenitNord_, φ_] := 
        Module[{a, b, φOld, u, v, w, d, r, r1, R, dY, dZ, xKS, yKS, 
            zKS, goAeq, xNew, yNew, zNew, solvU, solvV, uRichtung, vRichtung, 
            u1, u2, u3, v1, v2, v3, vv}, 
 (*\ 
            Umrechnung\ mit\ Vektorprodukt\ *) 
 (*\ \(\(===\)\(\(>\)\(\ \)\(INPUT\)\)\), \ 
            Altgrad\ *) \ \ \ \ \ 
a = \ ostNord\ ; \ 
          b = zenitNord\ ; \ φOld = φ; 
u = {Cos[a\ Degree], Sin[a\ Degree], 0}; 
          Print["u = ", \ 
            u // N]; 
v = {\(-Sin[a\ Degree]\) 
                Sin[b\ Degree], Cos[a\ Degree] Sin[b\ Degree], 
              Cos[b\ Degree]}; 
          Print["v = ", v // N]; 
 (*\ 
            w : \ Normalenvektor\ im\ Ortshorizontsystem\ *) 
w = Transpose[{Cross[u, v]}]; 
          Print["w = ", \(w // N\) // 
              MatrixForm]; 
 (*\ 
            Drehung\ um\ Ost - West - 
              Achse\ im\ Ortshorizontsystem\ *) 
 (*\ 
            Drehung\ ins\ Orstäquatorsystem\ *) 
φOld = φ; 
          d = \((90 - φOld)\)\ ; 
          Print["d = ", 
            d // N]; 
dreh = {{1, 0, 0}, {0, 
                Cos[d\ Degree], \(-Sin[d\ Degree]\)}, {0, Sin[d\ Degree], 
                Cos[d\ Degree]}}; 
          Print["dreh = "\ , \ \(dreh // N\) // 
              MatrixForm]; 
r = dreh . w; 
          Print["r = ", \ \(r // N\) // MatrixForm]; \ r1 = Flatten[r]; 
          Print["r1 = ", 
            r1 // N]; 
R = {\(-\ 
                r1[\([2]\)]\), \(-r1[\([1]\)]\), r1[\([3]\)]}; 
          Print["R = ", R // N]; 
Delta1 = 
            Sign[r1[\([3]\)]]\ ArcCos[
                Sqrt[\((R[\([1]\)]^2 + R[\([2]\)]^2)\)/\((R[\([1]\)]^2 + 
                        R[\([2]\)]^2 + 
                        R[\([3]\)]^2)\)]]\ ; 
 (*\ 
            Delta1\ ist\ Winkel\ zwischen\ Vektor\ und\ Ortsäquatorebene, \ 
            d . h . \ 
                die\ neue\ geographische\ Breite\ *) 
Delta2 = \ 
            Sign[r1[\([3]\)]]\ ArcCos[
                Sqrt[R[\([1]\)]^2/\((R[\([1]\)]^2 + 
                        R[\([2]\)]^2)\)]]; 
 (*\ 
            Delta2\ ist\ Winkel\ zwischen\ Vektorprojektion\ in\ Ortsäquatorebene\ x\ resp . \ 
                Süd\ *) 
dY = Delta1; 
          dZ = Delta2; 
Delta1Grad = Delta1/Degree // N; \ 
          Delta2Grad = Delta2/\((2\ Pi)\)\ 360 // N;; \ 
          Delta2Std = 
            Delta2/\((2\ Pi)\)\ 24 // 
              N; 
Print["Delta1Grad = ", 
            Delta1Grad, " Vorzeichen= "\ , \ Sign[r1[\([3]\)]]]; 

          Print["Delta2Grad = ", Delta2Grad, ", Delta2Std = ", 
            Delta2Std, " Vorzeichen= "\ , \ 
            Sign[r1[\([2]\)]]]; 
 (*Umrechnen\ des\ Vertikalvektors\ der\ Wand\ zur\ Drehung\ des\ Outputs\ in\ Vertikallage, \ 
            in\ Einzelschritten*) 
Print["Test Matrixprodukt ===> ", 
            dreh . v == 
              Flatten[dreh . Transpose[{v}]]]; 
xKS = {1, 
              0, 0}; yKS = {0, 1, 0}; 
          zKS = {0, 0, 
              1}; 
Print["Koordinatensystem : ", {xKS, 
                  yKS, zKS} // MatrixForm\ \ ]
\(goAeq[
                vec_] := {\(-\((dreh . vec)\)[\([2]\)]\), \(-\((dreh . 
                        vec)\)[\([1]\)]\), \((dreh . 
                      vec)\)[\([3]\)]}\); 
Print["Prozedur Koord.Umrechnung von - r1[[2]],-r1[[1]],r1[[3]] auf dreh.vec anwenden"]; 
vAeq = 
            goAeq[v]; uAeq = goAeq[u]; xAeq = goAeq[xKS]; yAeq = goAeq[yKS]; 
          zAeq = goAeq[zKS]; 
Print["===>vAeq = ", 
            vAeq // N]; 
Print["===>uAeq = ", 
            uAeq // N]; 
Print["===>xAeq = ", 
            xAeq // N]; 
Print["===>yAeq = ", 
            yAeq // N]; 
Print["===>zAeq = ", 
            zAeq // N]; 
drehZ = {{Cos[dZ], \(-Sin[dZ]\), 
                0}, {Sin[dZ], Cos[dZ], 0}, {0, 0, 
                1}}; 
Print["drehZ =", \ \(drehZ // 
                N\) // MatrixForm]; 
drehY = {{Cos[dY], 
                0, \(-Sin[dY]\)}, {0, 1, 0}, {Sin[dY], 0, 
                Cos[dY]}}; 
Print["drehY =", \ \(drehY // 
                N\) // MatrixForm]; 
goNew[vec_] := 
            drehZ . \((drehY . 
                  vec)\); 
Print["Vektor um Breitendifferenz und dann um Längendifferenz drehen"]; 
xNew = goNew[xKS]; yNew = goNew[yKS]; 
          zNew = goNew[zKS]; 
Print["xNew KS =", \ 
            xNew // N]; 
Print["yNew KS =", \ 
            yNew // N]; 
Print["zNew KS =", \ 
            zNew // N]; 
solvU = \(\(Solve[
                    uAeq == 
                      u1\ xNew\  + \ u2\ yNew\  + \ u3\ zNew, {u1, u2, u3}] // 
                  Chop\) // Flatten\) // N; 
          uRichtung = {u1, u2, u3} /. 
              solvU; 
Print["Kontrolle: gedrehtes u im neuen Parallelebenen-KS dargestellt ===> ", \ 
            uRichtung, " 1. Koord. muss 0 sein"]; 
 (*\ 
            vAeq\ hat\ schon\ ins\ Ortsäquatorsyst . \ 
                umgerechnete\ \(\(Koord\)\(.\)\)*) 
solvV = \(\(Solve[vAeq == v1\ xNew\  + \ v2\ yNew\  + \ v3\ zNew, {v1, v2, 
                      v3}] // Chop\) // Flatten\) // 
              N; 
vRichtung = {v1, v2, v3} /. 
              solvV; 
Print["Kontrolle: gedrehtes v im neuen Parallelebenen-KS dargestellt ===> ", \ 
            vRichtung, " 1. Koord. muss 0 sein"]; 
vLen[
              vec_] := 
            Sqrt[vec . 
                vec]; \  (*\ \(===\)\(\(>\)\(\ \)\(Vektorlänge\)\)\ *) 
\  (*\ \(===\)\(\(>\)\(\ \)\(Vektorlänge\)\)\ *) 
\  (*\ \(===\)\(\(>\)\(\ \)\(Drehung\ der\ Vertikalen\)\)\ *) 
drehNewArc = \(-Sign[vRichtung[\([2]\)]]\)\ ArcCos[
                vRichtung . zKS/\((vLen[vRichtung]\ vLen[zKS])\)]; 
          drehNewGrad = drehNewArc\ /\((2  Pi)\)\ 360; 
\ 
          vv = drehNewArc; 
Print["drehNewGrad, ", 
            drehNewGrad]; 
Print["vRichtung ", 
            vRichtung]; 
Print["zKS ", 
            zKS]; 
drehPlot = {{Cos[
                  vv], \(-Sin[vv]\)}, {Sin[vv], 
                Cos[vv]}}; \ 
Print["drehPlot = ", \ 
            drehPlot // 
              MatrixForm]; 
Print["Out-Variablen: Delta1, Delta1Grad, Delta2, Delta2Std, drehNewArc,drehNewGrad, drehPlot, vLen"];];\)
 (*\(\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\)\(=\)*) \)
\(\(newPosition[ostNord_, zenitNord_, φ_] := 
        Module[{a, b, φOld, u, v, w, d, r, r1, R, dY, dZ, xKS, yKS, 
            zKS, goAeq, xNew, yNew, zNew, solvU, solvV, uRichtung, vRichtung, 
            u1, u2, u3, v1, v2, v3, vv}, 
 (*\ 
            Umrechnung\ mit\ Vektorprodukt\ *) 
 (*\ \(\(===\)\(\(>\)\(\ \)\(INPUT\)\)\), \ 
            Altgrad\ *) \ \ \ \ \ 
a = \ ostNord\ ; \ 
          b = zenitNord\ ; \ φOld = φ; 
u = {Cos[a\ Degree], Sin[a\ Degree], 0}; 
          v = {\(-Sin[a\ Degree]\) Sin[b\ Degree], 
              Cos[a\ Degree] Sin[b\ Degree], 
              Cos[b\ Degree]}; 
 (*\ 
            w : \ Normalenvektor\ im\ Ortshorizontsystem\ *) 
w = Transpose[{Cross[u, v]}]; 
 (*\ 
            Drehung\ um\ Ost - West - 
              Achse\ im\ Ortshorizontsystem\ *) 
 (*\ 
            
            Drehung\ ins\ Orstäquatorsystem\ *) 
d = \((90 - φOld)\)\ ; 
dreh = {{1, 0, 0}, {0, 
                Cos[d\ Degree], \(-Sin[d\ Degree]\)}, {0, Sin[d\ Degree], 
                Cos[d\ Degree]}}; 
r = dreh . w; \ 
          r1 = Flatten[r]; 
 (*\ alte\  - y\ heisst\ x, \ 
            alte\  - 
              x\ heisst\ y\ *) 
R = {\(-\ 
                r1[\([2]\)]\), \(-r1[\([1]\)]\), 
              r1[\([3]\)]}; 
Delta1 = 
            Sign[r1[\([3]\)]]\ \ ArcCos[
                Sqrt[\((R[\([1]\)]^2 + R[\([2]\)]^2)\)/\((R[\([1]\)]^2 + 
                        R[\([2]\)]^2 + 
                        R[\([3]\)]^2)\)]]\ ; 
 (*\ 
            Delta1\ ist\ Winkel\ zwischen\ Vektor\ und\ Ortsäquatorebene, \ 
            d . h . \ 
                die\ neue\ geographische\ Breite\ *) 
Delta2 = \ 
            Sign[r1[\([3]\)]]\ ArcCos[
                Sqrt[R[\([1]\)]^2/\((R[\([1]\)]^2 + 
                        R[\([2]\)]^2)\)]]; 
 (*\ 
            Delta2\ ist\ Winkel\ zwischen\ Vektorprojektion\ in\ Ortsäquatorebene\ x\ resp . \ 
                Süd\ *) 
dY = Delta1; 
          dZ = Delta2; 
Delta1Grad = Delta1/Degree // N; \ 
          Delta2Grad = Delta2/\((2\ Pi)\)\ 360 // N;; \ 
          Delta2Std = 
            Delta2/\((2\ Pi)\)\ 24 // 
              N; 
Print["Delta1Grad = ", 
            Delta1Grad, " Vorzeichen= "\ , \ 
            Sign[r1[\([3]\)]]]; 
\ \ \ \ \ Print["Delta2Grad = ", 
            Delta2Grad, ", Delta2Std = ", 
            Delta2Std, " Vorzeichen= "\ , \ 
            Sign[r1[\([2]\)]]]; 
 (*Umrechnen\ des\ Vertikalvektors\ der\ Wand\ zur\ Drehung\ des\ Outputs\ in\ Vertikallage, \ 
            in\ Einzelschritten*) 
xKS = {1, 0, 0}; 
          yKS = {0, 1, 0}; 
          zKS = {0, 0, 1}; 
goAeq[
              vec_] := {\(-\((dreh . vec)\)[\([2]\)]\), \(-\((dreh . 
                      vec)\)[\([1]\)]\), \((dreh . 
                    vec)\)[\([3]\)]}; 
vAeq = goAeq[v]; 
          uAeq = goAeq[u]; xAeq = goAeq[xKS]; yAeq = goAeq[yKS]; 
          zAeq = goAeq[
              zKS]; 
drehZ = {{Cos[dZ], \(-Sin[dZ]\), 
                0}, {Sin[dZ], Cos[dZ], 0}, {0, 0, 
                1}}; 
drehY = {{Cos[dY], 
                0, \(-Sin[dY]\)}, {0, 1, 0}, {Sin[dY], 0, 
                Cos[dY]}}; 
goNew[vec_] := 
            drehZ . \((drehY . vec)\); 
xNew = goNew[xKS]; 
          yNew = goNew[yKS]; 
          zNew = goNew[
              zKS]; 
solvU = \(\(Solve[
                    uAeq == 
                      u1\ xNew\  + \ u2\ yNew\  + \ u3\ zNew, {u1, u2, u3}] // 
                  Chop\) // Flatten\) // 
              N; 
solvV = \(\(Solve[
                    vAeq == 
                      v1\ xNew\  + \ v2\ yNew\  + \ v3\ zNew, {v1, v2, v3}] // 
                  Chop\) // Flatten\) // 
              N; 
uRichtung = {u1, u2, u3} /. 
              solvU; 
vRichtung = {v1, v2, v3} /. 
              solvV; 
vLen[vec_] := 
            Sqrt[vec . 
                vec]; 
drehNewArc = \(-Sign[
                  vRichtung[\([2]\)]]\)\ ArcCos[
                vRichtung . zKS/\((vLen[vRichtung]\ vLen[zKS])\)]; 
          drehNewGrad = 
            drehNewArc\ /\((2  Pi)\)\ 360; \ 
vv = 
            drehNewArc; 
Print["drehNewGrad = ", 
            drehNewGrad]; 
drehPlot = {{Cos[
                  vv], \(-Sin[vv]\)}, {Sin[vv], 
                Cos[vv]}}; \ 
Print["drehPlot = ", \ 
            drehPlot // 
              MatrixForm]; 
Print["Out-Variablen: Delta1, Delta1Grad, Delta2, Delta2Std, drehNewArc,drehNewGrad, drehPlot, vLen"];];\)
 (*\(\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\)\(=\)*) \)
drehOmbrixDekSlPlot[{hMin_, hMax_}, {t1_, t2_}, {t3_, t4_}, {k1_, 
            k2_}, {k3_, k4_}, {pr1_, pr2_}, {faktor1_, faktor2_}, {nMitte_, 
            nZiel_}, {nn1_, nn2_}] := 
        Module[{φNew, parPlotNow, k5, k6, 
            tabd}, 
φNew =  Delta1Grad;  
          fiNew =  (90 - Abs[φNew]); 
k5 = 
            Sign[k3]^2 k3  +  (1 - Sign[k3]^2) 
                hMin; 
k6 = 
            Sign[k4]^2 k4  +  (1 - Sign[k4]^2) 
                hMax; 
v[gNow_, φNow_, dNow_, 
              fiNow_, tNow_] := 
            gNow/(Cos[Sign[φNow]  dNow Degree] Cos[
                        tNow hour] Sin[fiNow Degree]  +  
                    Sin[Sign[φNow] dNow Degree] Cos[
                        fiNow Degree]) {(Cos[
                      Sign[φNow] dNow Degree] Sin[
                      tNow hour]), 
                Sign[φNow] ((Cos[
                            Sign[φNow] dNow Degree] Cos[
                            tNow hour] Cos[fiNow Degree]  -  
                        Sin[Sign[φNow] dNow Degree] Sin[
                            fiNow Degree]) )}; 
vDreh[
              gNow_, φNow_, dNow_, fiNow_, tNow_] := 
            drehPlot . 
              v[gNow, φNow, dNow, fiNow, 
                tNow]; 
 (*===> hMin, hMax eingeben!*) 
tabPlotPunkteDelta[φVar_, 
              hMinInt_, hMaxInt_] := 
            Table[{MP[tVar - Delta2Std, φVar], 
                g/Tan[(90 - φVar) Degree]}, {tVar, hMinInt, 
                hMaxInt, 1}]; 
 (* Drehombrix,  
            Deklinationslinien*) 
ParametricPlot[
            Evaluate[
              Table[vDreh[g, φNew, d[k], fiNew, t], {k, k1, 
                  k2}]], {t, t1, t2},  AspectRatio -> Automatic, 
            PlotRange -> {pr1, pr2} , 
Epilog -> 
              Join[Table[
                  Line[{drehPlot . ursprung[φNew], 
                      drehPlot . (faktor1 ( tabPlotPunkteDelta[φNew, hMin, hMax][[n]] - ursprung[φNew]) + 
                            ursprung[φNew])}], {n, 1, 
                    Length[tabPlotPunkteDelta[φNew, hMin, 
                        hMax]]}], {Line[{drehPlot . ursprung[φNew], 
                      faktor2 drehPlot . tabPlotPunkte[φNew][[nMitte]]}]}]]; 
nn1 = Sign[nn1]^2 nn1  +  (1 - Sign[nn1]^2) hMin; 
nn2 = 
            Sign[nn2]^2 nn2  +  (1 - Sign[nn2]^2) 
                hMax; 
parPlotNow = 
            ParametricPlot[
              Evaluate[
                Table[vDreh[g, φNew, d[k], 
                    fiNew, (t - Delta2Std)], {k, k1, k2}]], {t, 
                t3 + Delta2Std, t4 + Delta2Std},  
              AspectRatio -> Automatic, 
              PlotRange -> {pr1, 
                  pr2}, 
Epilog -> {Join[
                    Table[Line[{vDreh[g, φNew, d[nZiel], fiNew, 
                            k - Delta2Std], 
                          drehPlot . ursprung[φNew]}], {k, k5, k6, 
                        1}],  {Line[{drehPlot . ursprung[φNew], 
                          faktor2 drehPlot . tabPlotPunkte[φNew][[nMitte]]}]}  ]}, 
              DisplayFunction -> Identity]; 
tabd[n_] := 
            Table[vDreh[g, φNew, 
                ArcSin[Sin[
                        2 ArcTan[
                              Sqrt[(1 + e)/(1 - e)] Tan[
                                  eE[dd]/2 ]] + L0 + L01 dd +  
                          L01 jahresTage[jahrOut]] Sin[Eps]] /Degree, 
                fiNew, (n - zgStd[dd] - Delta2Std)], {dd, -100, 
                300}]; 
listp[n_] := 
            ListPlot[tabd[n], PlotJoined -> True,  
              AspectRatio -> Automatic, 
              DisplayFunction -> Identity]; 
listp0 = 
            Show[Table[listp[nn], {nn, nn1, nn2}], 
              DisplayFunction -> Identity]; 
Show[
              parPlotNow, listp0, 
              DisplayFunction -> $DisplayFunction];];
\(\(\(drehOmbrixDekSlPlot[hMin_, hMax_, t1_, t2_, t3_, t4_, k1_, k2_, 
        k3_, k4_, pr1_, pr2_, faktor1_, faktor2_, nMitte_, nZiel_, nn1, 
        nn2]\)\(:=\)\(drehOmbrixDekSlPlot[{hMin, hMax}, {t1, t2}, {t3, 
          t4}, {k1, k2}, {k3, k4}, {pr1, pr2}, {faktor1, faktor2}, {nMitte, 
          nZiel}, {nn1, 
          nn2}, 
\(Print["Ende"];\)]\)\(
\)\( (*\(\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\(===\)\)\(=\)*) \)\)\)

Initialisation der aktivierten Module durch Aufruf unter Beachtung Aufrufhierarchie:

Die Sache FUNKTIONIERT NUR, wenn die Hierarchie eingehalten wird. Gewisse Ausgelassene Module verursachen sonst Fehler, weil sie in andern Modulen benutzt werden!!!

Beispiele (* INITIALISATIONEN *)

m0

dataEntry[30, 50, 12]

dataEntry[0, 0, 0]

dataEntry[0, 0, 0]; φVert

{g, φ}

φVert

{jahresTage[12], jahresTage[2012]}

dataEntry[30, 50, 01]; jahrOut

dataEntry[0, 0]; ombrixGzentr[-4, 4]

dataEntry[0, 0]; ombrixGzentr[-1, 5]

ombrixGzentrDeltaStd[-3, 4, 2]

dataEntry[φ - 90, 1]; ombrixGzentr[-5, 5]

ombrixGzentrDeltaStd[-3, 4, 2]

kalender[21, 3]

{tage[21, 3] , tage[6, 5]}

{{"Test", "21.3.", 
        kalender[21, 3]}, 
{"Test", "29.8.", 
        kalender[29, 8]}, 
{"Test", "21.12.", 
        kalender[21, 12]}, {"Test", "31.12.", 
        kalender[20, 15]}, 
{"Test", "21.3.", 
        tage[21, 3]}, 
{"Test", "29.8.", 
        tage[29, 8]}, 
{"Test", "21.12.", 
        tage[21, 12]}, 
{"Test", "31.12.", 
        tage[31, 12]}}

?eE

zeitGleichung[2, 01]

zeitGleichung[1,  01]

zeitGleichung[2,  01]; zgStd[5]

dataEntry[0, 
      0]; zeitGleichung[0, 01]; kalender[29, 8]; tage[29, 8];

deklin[0, 0]

deltaAngle[0]

?eE

e

?deltaAngle

deltaAngle[0];Plot[
      deltaAngle[d]/(2  Pi) 360, {d, 0, 366}];

{deklin[28, 8], deklin[21, 12], 
        deklin[17.805, 3], deklin[21, 3]} // N

tage[21, 3]

(* ===> Input von Hand *) 
 n = 8; d[1] = deklin[20, 12]; d[2] = deklin[1, 2]; d[3] = deklin[1, 3]; 
    d[4] = deklin[17.805, 3]; d[5] = deklin[1, 5]; d[6] = deklin[1, 6]; 
    d[7] = deklin[21, 6]; 
    d[8] = deklin[29, 
        8];
 (* ===> Listengenerierung mit dem Input *) 
dlist[n_] := Table[d[k], {k, 1, n}];
dlist[n]

dekPlot[dlist[n], 1, -5, 5, -1, 4, 0]

dekPlot[dlist[n], 1, -5, 5, -1, 4, 1]

dekPlot[dlist[n], 0, -5, 5, -4, 1, 1]

zeitSchlaufen[dlist[7], 2, 
      7, {-3.5, 3.5}, {-4, 1.2}, {-3, 3}]

zeitSchlaufen[dlist[7], 0, 
      7, {-3.5, 3.5}, {-4, 1.2}, {-3, 3}]

zeitSchlaufen[dlist[7], 1, 
      7, {-3.5, 3.5}, {-1.2, 4}, {-3, 3}]

newPositionWithPrint[30, 6, φ]

newPosition[30, 6, φ]

drehOmbrixDekSlPlot[{-7, 2}, {-4, 4}, {-4, 4}, {1, 8}, {0, 
        0}, {-4, 2}, {4, 5}, {6, 7}, {-7, 2}]