############################################################################
#                       MAPLE IN DER PHYSIK                                #
############################################################################
#                                                                          #  
#                 (c) H. Schwarze / J. Borgert 1995                        #  
#                                                                          #
############################################################################
#
# polyg von Michael Kofler
#
polyg:=proc(x:numeric, y:numeric, rx:numeric, ry:numeric, n:numeric)
        local data, i;
        data := [];
        for i from 0 to evalf(2*Pi-0.00001) by evalf(2*Pi/n) do
                data := [op(data), [evalf(x+rx*sin(i), 5), evalf(y+ry*cos(i), 5)] ];
        od;
        data;
end:
#
assign(`help/text/polyg`, TEXT(
`FUNCTION: polyg / polyg3d - Berechnung der Eckpunkte eines regelmaessigen Vielecks`,
``,
`CALLING SEQUENCE:`,
`   polyg(x, y, rx, ry, n) / polyg3d(x, y, rx, ry, n)`,
``,
``,
`PARAMETERS:`,
`   x               - x-Koordinate des Mittelspunktes`,
`   y               - y-Koordinate des Mittelspunktes`,
`   rx              - Radius in x-Richtung`,
`   ry              - Radius in x-Richtung`,
`   n               - Anzahl der Eckpunkte`,
``,
``,
`SYNOPSIS:   `,
`- Diese beiden Prozeduren koennen verwendet werden, um die Koordinaten`,
`  der Eckpunkte eines gleichmaessigen Vielecks zu berechnen. Mit diesen`,
`  lassen sich dann die Graphikelelmente fuer Kreise oder Punkte`,
`  erzeugen, die in Maple nicht vorgesehen sind. Im Vergeich zu`,
`  polyg besitzt polyg3d eine zusaetzliche z-Komponente, so dass `,
`  es sich in dreidimensionalen Graphiken verwenden laesst. Sie ist`,
`  jedoch immer Null, so dass der Kreis oder Punkt in der x-y-Ebene`,
`  liegt. `,
``,
`EXAMPLES:   `,
``,
`> polyg(0,0,1,1,5);`,
``,
`  [[0, 1.], [.95105, .30905], [.58776, -.80903], [-.58778, -.80902],`,
`      [-.95107, .30897]]`,
``,
`> polyg3d(0,0,1,1,5);`,
``,
`  [[0, 0, 1.], [0, .95105, .30905], [0, .58776, -.80903],`,
`      [0, -.58778, -.80902], [0, -.95107, .30897]]`,
``,
``,
`SEE ALSO:  `));
#
# polyg - abgewandelt fuer dir 3D-Darstellung
#
polyg3d:=proc(x:numeric, y:numeric, rx:numeric, ry:numeric, n:numeric)
        local data, i;
        data := [];
        for i from 0 to evalf(2*Pi-0.00001) by evalf(2*Pi/n) do
                data := [op(data), [0,evalf(x+rx*sin(i), 5), evalf(y+ry*cos(i), 5)] ];
        od;
        data;
end:
#
assign(`help/text/polyg3d`, TEXT(
`FUNCTION: polyg / polyg3d - Berechnung der Eckpunkte eines regelmaessigen Vielecks`,
``,
`CALLING SEQUENCE:`,
`   polyg(x, y, rx, ry, n) / polyg3d(x, y, rx, ry, n)`,
``,
``,
`PARAMETERS:`,
`   x               - x-Koordinate des Mittelspunktes`,
`   y               - y-Koordinate des Mittelspunktes`,
`   rx              - Radius in x-Richtung`,
`   ry              - Radius in x-Richtung`,
`   n               - Anzahl der Eckpunkte`,
``,
``,
`SYNOPSIS:   `,
`- Diese beiden Prozeduren koennen verwendet werden, um die Koordinaten`,
`  der Eckpunkte eines gleichmaessigen Vielecks zu berechnen. Mit diesen`,
`  lassen sich dann die Graphikelelmente fuer Kreise oder Punkte`,
`  erzeugen, die in Maple nicht vorgesehen sind. Im Vergeich zu`,
`  polyg besitzt polyg3d eine zusaetzliche z-Komponente, so dass `,
`  es sich in dreidimensionalen Graphiken verwenden laesst. Sie ist`,
`  jedoch immer Null, so dass der Kreis oder Punkt in der x-y-Ebene`,
`  liegt. `,
``,
`EXAMPLES:   `,
``,
`> polyg(0,0,1,1,5);`,
``,
`  [[0, 1.], [.95105, .30905], [.58776, -.80903], [-.58778, -.80902],`,
`      [-.95107, .30897]]`,
``,
`> polyg3d(0,0,1,1,5);`,
``,
`  [[0, 0, 1.], [0, .95105, .30905], [0, .58776, -.80903],`,
`      [0, -.58778, -.80902], [0, -.95107, .30897]]`,
``,
``,
`SEE ALSO:  `));
#
# listplot - abgewandelt fuer die Verwendung mit Optionen 
#
listplot := proc (data:list, rx:numeric) 
   local i, j, pol, prop, opts, testopt; 
   testopt[proportion] := 1; 
   testopt[view] := []; 
   testopt[axes] := none; 
   opts  := [args[3 .. nargs]]; 
   for j in opts do 
      if type(j,identical(proportion) = numeric) then testopt[proportion] := rhs(j) 
      elif type(j,identical(view) = list) then testopt[view] := op(rhs(j)) 
      elif type(j,identical(axes) = string)  then testopt[axes] := rhs(j) 
      else ERROR(`ungueltige Option`,j) 
      fi
   od; 
   prop  := testopt[proportion]; 
   if testopt[axes] = normal then testopt[axes] := NORMAL 
   elif testopt[axes] = none then testopt[axes] := NONE 
   fi; 
   pol := []; 
   pol := seq(polyg(data[i][1],data[i][2],rx,rx*prop,25),i = 1 .. nops(data)); 
   pol := POLYGONS(pol,COLOR(RGB,0,0,0)); 
   if testopt[view] = [] then PLOT(pol, AXESSTYLE(NONE)) 
   else PLOT(pol,VIEW(testopt[view]),AXESSTYLE(testopt[axes]))
   fi
end:
#
assign(`help/text/listplot`, TEXT(
`FUNCTION: arrow - plotten einer Liste von Datenpunkten`,
``,
`CALLING SEQUENCE:`,
`   listplot(L, r, Optionen)`,
``,
``,
`PARAMETERS:`,
`   L               - Liste der Datenpunkte`,
`   r               - Radius der Datenpunkte bei der Darstellung`,
`   Optionen        - proportion -> Verhaeltnis von vertikalem zu`,
`                                   horizontalem Radius`,
`                                   Vorgabe: proportion=1`,
`                   - view       -> Angabe des darzustellenden `,
`                                   Ausschnitts (siehe ?plot)`,
`                   - axes       -> Angabe ueber die Darstellung der Achsen`,
`                                   Vorgabe: axes=none, Alternative: axes=normal `,
``,
`SYNOPSIS:   `,
`- Die Prozedur ermoeglicht es, im Gegensatz zu plot Einfluss auf `,
`  den Radius der dargestellten Datenpunkte zu nehmen. Der Parameter`,
`  r gibt dabei den Radius im Verhaeltnis zur gesamten Graphik an.`,
`  Etwas Probieren fuehrt meistens zu den gewuenschten Ergebnissen.`,
`  Die Option proportion kann verwendet werden, wenn die Achsen`,
`  Der Graphik unterschiedlich skaliert sind, um das Verhaeltnis der`,
`  Radien daran anzupassen.`,
``,
`EXAMPLES:   `,
``,
`> data := [seq([x,x^2], x=1..4)]:`,
``,
`> listplot(data, 0.1, proportion=4);`,
``,
`> listplot(data, 0.1, proportion=4, view=[-1..5, 0..20]);`,
``,
`> listplot(data, 0.1, proportion=4, axes=normal);`,
``,
``,
`SEE ALSO:  plot`));
#
# seqn von Michael Kofler
#
seqn:= proc( f, l:list )
  local i, data, range, `&vgl`;
  range:=l:
  if not type(range[1],name=`..`) then
    ERROR(`falscher Parameter`, range);
  elif nops(range)>1 then
    if not type(range[2], algebraic) or evalf(range[2])=0 then
      ERROR(`falscher Parameter`, range);
    fi;
  else
    range:=[ op(range), 1]:
  fi;
  data:=[]:
  i:=op(1,op(2,range[1])):
  if evalf(range[2])>0 then `&vgl`:=(x,y)->(x<=y):
  else `&vgl`:=(x,y)->(x>=y): fi:
  while evalf(i) &vgl evalf(op(2,op(2,range[1]))) do
    if nargs>2 then
      data := [ op(data),
        seqn( eval(subs( op(1,range[1])=i, f)),
              op(eval(subs( op(1,range[1])=i, [args[3..nargs]])))) ]; 
    else
      data := [ op(data), eval(subs( op(1,range[1])=i, f)) ];
    fi:
    i:=eval(i)+range[2];
  od;
  [op(data)];
end:
#
assign(`help/text/seqn`, TEXT(
`FUNCTION: seqn - create a nested list`,
``,
`CALLING SEQUENCE:`,
`   seqn(f, [x=a..b,c])`,
`   seqn(f, [x1=a1..b1,c1], [x2=a2..b2,c2], [..])`,
``,
``,
`PARAMETERS:`,
`   f           - any expression`,
`   xi          - name`,
`   ai, bi, ci  - numerical values`,
``,
`SYNOPSIS:   `,
`- The seqn function behaves similar to seq. There are two main differences:`,
`  seqn allows to build nested lists (instead of linear sequences).`,
`  seqn allows any step c for its loops (instead of a fixed step 1).`,
``,
`EXAMPLES:   `,
``,
`> seqn( x^y, [x=0..3], [y=2..4]); `,
`                  [[0, 0, 0], [1, 1, 1], [4, 8, 16], [9, 27, 81]]`,
``,
`> seqn( x^y, [x=0..3], [y=0..x]);`,
`                       [[0], [1, 1], [1, 2, 4], [1, 3, 9, 27]]`,
``,
`> seqn( x+y+z, [x=1..2], [y=10..20, 10], [z=100..200, 100]);`,
`                [[[111, 211], [121, 221]], [[112, 212], [122, 222]]]`,
``,
``,
`SEE ALSO:  seq`));
#
# arrow - Darstellung von Pfeilen
#
arrow := proc(x1,y1,x2,y2)
local dx,dy,s1,s2;
dx := (x2-x1):
dy := (y2-y1):
s1 := [evalf(x1+0.8*dx+0.1*dy),evalf(y1+0.8*dy-0.1*dx)]:
s2 := [evalf(x1+0.8*dx-0.1*dy),evalf(y1+0.8*dy+0.1*dx)]:
CURVES([[evalf(x1),evalf(y1)],[evalf(x2),evalf(y2)],s1,
[evalf(x2),evalf(y2)],s2], COLOR(RGB,0,0,0)):
end:
# 
assign(`help/text/arrow`, TEXT(
`FUNCTION: arrow - zeichnen eines Pfeiles`,
``,
`CALLING SEQUENCE:`,
`   arrow(x1, y1, x2, y2)`,
``,
``,
`PARAMETERS:`,
`   x1, y1      - Koordinaten des Startpunktes (von wo der Pfeil wegzeigt)`,
`   x2, y2      - Koordinaten des Endpunktes (wo der Pfeil hinzeigt)`,
``,
`SYNOPSIS:   `,
`- Die Funktion stellt die Graphikkonstrukte zum Zeichnen eines Pfeiles`,
`  mit PLOT zur Verfuegung. Die Pfeilspitze ist nicht ausgefuellt.`,
``,
`EXAMPLES:   `,
``,
`> PLOT(arrow(0,0,1,1));`,
``,
``,
`SEE ALSO:  filledarrow`));
#
# filledarrow - Darstellung von Pfeilen
#
filledarrow := proc(x1,y1,x2,y2)
local dx,dy,s1,s2;
dx := (x2-x1):
dy := (y2-y1):
s1 := [evalf(x1+0.8*dx+0.1*dy),evalf(y1+0.8*dy-0.1*dx)]:
s2 := [evalf(x1+0.8*dx-0.1*dy),evalf(y1+0.8*dy+0.1*dx)]:
CURVES([[evalf(x1),evalf(y1)],[evalf(x2),evalf(y2)]]), 
POLYGONS([[evalf(x2),evalf(y2)],s1,s2]),COLOR(RGB,0,0,0):
end:
#
assign(`help/text/filledarrow`, TEXT(
`FUNCTION: filledarrow - zeichnen eines Pfeiles`,
``,
`CALLING SEQUENCE:`,
`   filledarrow(x1, y1, x2, y2)`,
``,
``,
`PARAMETERS:`,
`   x1, y1      - Koordinaten des Startpunktes (von wo der Pfeil wegzeigt)`,
`   x2, y2      - Koordinaten des Endpunktes (wo der Pfeil hinzeigt)`,
``,
`SYNOPSIS:   `,
`- Die Funktion stellt die Graphikkonstrukte zum Zeichnen eines Pfeiles`,
`  mit PLOT zur Verfuegung. Die Pfeilspitze ist ausgefuellt.`,
``,
`EXAMPLES:   `,
``,
`> PLOT(filledarrow(0,0,1,1));`,
``,
``,
`SEE ALSO:  arrow`));
#
#
#
bildoff := proc(n, offx, offy)
   local l1, l2;
   l1 := seqn([cos(alpha)+offx,sin(alpha)+offy], [alpha=0..n*Pi/10,Pi/10]);
   l2 := seqn([1.5+offx,sin(alpha)+offy], [alpha=0..n*Pi/10,Pi/10]);
   evalf(convert((convert(l1, set) union convert(l2, set)), list));
end:
#
#
#
bild := n -> listplot(bildoff(n, 0, 0), 0.05):
#
assign(`help/text/bild`, TEXT(
`FUNCTION: bild - Darstellung einer Schwingung und ihrer Projektion`,
``,
`CALLING SEQUENCE:`,
`   bild(n)`,
``,
``,
`PARAMETERS:`,
`   n               - Anzahl der darzustellenden Graphiken`,
``,
`SYNOPSIS:   `,
`- Die Prozedur stellt eine Schwingung zusammen mit ihrer  `,
`  Projektion dar.`,
``,
`  Verwendung in Kapitel 3.1.`,
``,
`EXAMPLES:   `,
``,
`> bild(10):`,
``,
``,
`SEE ALSO: bildarray`));
#
#
#
bildarray := proc(m, n)
  local dat, l1, l2, tz;
  tz := 0:
  dat := [ ]:
  for l2 from 0 to (n-1) do for l1 from 0 to (m-1) do
    dat := [op(dat), op(bild(tz,3*l1,(n-1)*3-3*l2))];
    tz := tz+1:
  od:
  od:
  listplot(dat, 0.02, view=[-1.5..(m-1)*3+2,-1.5..(n-1)*3+1.5]);
end:
#
assign(`help/text/bildarray`, TEXT(
`FUNCTION: bildarray - Darstellung einer Schwingung und ihrer Projektion`,
``,
`CALLING SEQUENCE:`,
`   bildarray(m, n);`,
``,
``,
`PARAMETERS:`,
`   m, n            - Horizontale und vertikale Anzahl der`,
`                     darzustellenden Graphiken.`,
`                     -> es werden insgesamt m*n Graphiken  `,
`                     dargestellt.`,
``,
`SYNOPSIS:   `,
`- Die Prozedur stellt, im Gegensatz zu bild eine ganze Abfolge `,
`  von Graphiken einer Schwingung und ihrer Prohektion dar. `,
``,
`  Verwendung in Kapitel 3.1`,
``,
`EXAMPLES:   `,
``,
`> bildarray(4, 5);`,
``,
``,
`SEE ALSO:  bild`));
#
#
#
zeiger32 := proc(n, m, dt, f, df) 
   local m1,n1,zeigerliste,tz,xx1,xx2,yy1,yy2; 
   xx1 := (t,f,df) -> cos(2 * Pi * (f+df/2) * t): 
   yy1 := (t,f,df) -> sin(2 * Pi * (f+df/2) * t): 
   xx2 := (t,f,df) -> cos(2 * Pi * (f-df/2) * t): 
   yy2 := (t,f,df) -> sin(2 * Pi * (f-df/2) * t): 
   zeigerliste:= []: 
   tz := 0; 
   for n1 from 0 to (n-1) do for m1 from 0 to (m-1) do 
      zeigerliste := 
         [op(zeigerliste), filledarrow(evalf(3*m1),evalf(-3*n1), 
         evalf(3*m1+xx1(dt*tz,f,df)),evalf(-3*n1+yy1(dt*tz,f,df)))]: 
      zeigerliste := 
         [op(zeigerliste), filledarrow(evalf(3*m1),evalf(-3*n1), 
         evalf(3*m1+xx2(dt*tz,f,df)), evalf(-3*n1+yy2(dt*tz,f,df)))]: 
      tz := tz+1; 
   od: 
   od: 
   PLOT(op(zeigerliste),  VIEW(-1..3*m+1,-3*n+1..1), AXESSTYLE(NONE)); 
end:
#
assign(`help/text/zeiger32`, TEXT(
`FUNCTION: zeiger32 - Darstellung eines Diagramms aus zwei Zeigern`,
``,
`CALLING SEQUENCE:`,
`   zeiger32(n, m, dt, f, df)`,
``,
``,
`PARAMETERS:`,
`   n               - horizontale Anzahl der Diagramme`,
`   m               - vertikale Anzahl der Diagramme`,
`   dt              - Zeit zwischen zwei Diagrammen`,
`   f               - Mittenfrequenz`,
`   df              - Frequenzdifferenz zwischen den Zeigern und der `,
`                     Mittenfrequenz`,
``,
`SYNOPSIS:   `,
`- Verwendung in Kapitel 3.2.`,
``,
`EXAMPLES:   `,
``,
`> zeiger32(10, 10, 0.0002, 1000, 100);`,
``,
``,
`SEE ALSO:  sumzeiger32`));
#
#
#
summenzeiger32 := proc(n, m, dt, f, df) 
   local m1,n1,zeigerliste,tz,xx1,xx2,yy1,yy2; 
   xx1 := (t,f,df) -> cos(2 * Pi * (f+df/2) * t): 
   yy1 := (t,f,df) -> sin(2 * Pi * (f+df/2) * t): 
   xx2 := (t,f,df) -> cos(2 * Pi * (f-df/2) * t): 
   yy2 := (t,f,df) -> sin(2 * Pi * (f-df/2) * t): 
   zeigerliste := []: 
   tz := 0; 
   for n1 from 0 to (n-1) do for m1 from 0 to (m-1) do 
      zeigerliste :=  
         [op(zeigerliste), filledarrow(evalf(5*m1), evalf(-5*n1), 
         evalf(5*m1+xx1(dt*tz,f,df)+xx2(dt*tz,f,df)), 
         evalf(-5*n1+yy1(dt*tz,f,df)+yy2(dt*tz,f,df)))]: 
      tz := tz+1; 
   od: 
   od: 
   PLOT(op(zeigerliste),  VIEW(-2..5*m+1,-5*n+1..2), AXESSTYLE(NONE)); 
end:
#
assign(`help/text/sumzeiger32`, TEXT(
`FUNCTION: zeiger32 - Darstellung des Summenzeigers zu zeiger32`,
``,
`CALLING SEQUENCE:`,
`   sumzeiger32(n, m, dt, f, df)`,
``,
``,
`PARAMETERS:`,
`   n               - horizontale Anzahl der Diagramme`,
`   m               - vertikale Anzahl der Diagramme`,
`   dt              - Zeit zwischen zwei Diagrammen`,
`   f               - Mittenfrequenz`,
`   df              - Frequenzdifferenz zwischen den Zeigern und der `,
`                     Mittenfrequenz`,
``,
`SYNOPSIS:   `,
`- Verwendung in Kapitel 3.2.`,
``,
`EXAMPLES:   `,
``,
`> sumzeiger32(10, 10, 0.0002, 1000, 100);`,
``,
``,
`SEE ALSO:  zeiger32`));
#
#
#
bahnen := proc(randbedingungen, tmax)
   local loesung, gravitation, p1, p2;
   gravitation := D[1$2](x)(t) + gamma*MErde*(x(t) * (x(t)^2 + y(t)^2)^(-3/2)) = 0,
                  D[1$2](y)(t) + gamma*MErde*(y(t) * (x(t)^2 + y(t)^2)^(-3/2)) = 0:
   readlib(dsolve):
   with(plots):
   loesung := dsolve({gravitation, op(randbedingungen)}, {x(t), y(t)}, type=numeric):
   p1 := odeplot(loesung, [t, x(t), y(t)], 0..tmax, numpoints=150, shading=none, 
      orientation=[0,90],axes=normal):
   p2 := PLOT3D(CURVES(polyg3d(0,0,RadiusErde,RadiusErde,40),COLOR(RGB,0,0,0))):
   display3d({p1,p2}, orientation=[0,90], projection=1, scaling=constrained);
end:
#
assign(`help/text/bahnen`, TEXT(
`FUNCTION: bahnen - numerische Berechnung und Darstellung von`,
`                   Erdumlaufbahnen`,
``,
`CALLING SEQUENCE:`,
`   bahnen(startbedingungen, tmax)`,
``,
``,
`PARAMETERS:`,
`   startbedingungen - Die Startbedingungen zur Differentialgleichung`,
`   tmax             - maximale Zeit, bis zu das Ergebnis dargestellt`,
`                      werden soll`,
``,
`SYNOPSIS:   `,
`- Verwendung in Kapitel 4.1. `,
``,
`EXAMPLES:   `,
``,
`> startbedingungen := {x(0)=5*RadiusErde, D(x)(0)=0, y(0)=0, D(y)(0)=4000}:`,
``,
`> bahnen(startbedingungen, 1e5);`,
``,
``,
`SEE ALSO:  `));
#
#
#
zeigespektrum := proc(f, t, td ,dt, anz)
   local i,dr, di, dz, potenz, anzahl, korr:
   readlib(FFT):
   Digits := 7:
   potenz := round(log[2](td/dt)):
   anzahl := 2^potenz;
   dr := array(1..anzahl);
   for i from 1 to anzahl do dr[i] := 
      evalf(subs(t=td/anzahl*i ,f)) od:
   di := array([0$anzahl]):
   FFT(potenz, dr, di);
   dz := [seq([i/td, abs(dr[i]+I*di[i])], i=1..anz)]:
   plot(dz);
end:
#
assign(`help/text/zeigespektrum`, TEXT(
`FUNCTION: zeigespektrum - berechnet und stellt das Spektrum`,
`                          einer abgetasteten Funktion dar`,
``,
`CALLING SEQUENCE:`,
`   zeigespektrum(f, t, dauer ,dt, anz)`,
``,
``,
`PARAMETERS:`,
`   f               - Funktion von t`,
`   t               - Parameter der Funktion f`,
`   dauer           - Dauer des Signals bzw. der Funktion f `,
`   dt              - Zeit zwischen zwei Abtastungen`,
`   anz             - maximal darzustellende Punkte im Spektrum`,
``,
`SYNOPSIS:   `,
`- Die Prozedur tastet ein ihr uebergebene Funktion im Zeitintervall dauer`,
`  ab und berechnet das Spektrum mit einer Fast-Fourier-Transformation (FFT).`,
`  Das Spektrum wird dargestellt.`,
``,
`  Verwendung in Kapitel 7.1, 7.2.`,
``,
`EXAMPLES:   `,
``,
`> {\mi\verb?f0 := t -> sin(2*Pi*1000*t):?}`,
``,
`> zeigespektrum(f0(t), t, 0.1, 0.0001, 200);`,
``,
``,
`SEE ALSO:  `));
#
#
#
zeiger71 := proc(n,m,dt,anz)
   local m1,n1,zeigerliste, zeigerlistet, tz,xx,yy,l;
   xx := (t,l) -> cos(2 * Pi * (1000 + 50*l) * t):
   yy := (t,l) -> sin(2 * Pi * (1000 + 50*l) * t):
   zeigerliste := []:
   tz := 0;
   for n1 from 0 to (n-1) do for m1 from 0 to (m-1) do
      zeigerlistet := [seq(filledarrow(evalf(3*m1), evalf(-3*n1),
         evalf(3*m1+xx(dt*tz,l)),evalf(-3*n1+yy(dt*tz,l))),l=-2^anz..2^anz)]:
      zeigerliste := [op(zeigerliste), op(zeigerlistet)]:
      tz := tz+1;
   od:
   od:
   PLOT(op(zeigerliste), VIEW(-2.5..3*m+1,-3*n+1..2.5),AXESSTYLE(NONE));
end:
#
assign(`help/text/zeiger71`, TEXT(
`FUNCTION: zeiger71 - Darstellung eines Diagramms aus mehreren Zeigern`,
``,
`CALLING SEQUENCE:`,
`   zeiger71(n, m, dt, anz)`,
``,
``,
`PARAMETERS:`,
`   n               - horizontale Anzahl der Diagramme`,
`   m               - vertikale Anzahl der Diagramme`,
`   dt              - Zeit zwischen zwei Diagrammen`,
`   anz             - Anzahl der Zeiger nach der Formel 2^(anz+1)+1`,
``,
`SYNOPSIS:   `,
`- Zeigerdiagramme zur Veranschaulichung der Lage des ersten Nebenmaximums`,
`  bei zunehmender Zeigerzahl.`,
``,
`  Verwendung in Kapitel 7.1.`,
``,
`EXAMPLES:   `,
``,
`> zeiger71(10,10,0.0002,0);`,
``,
``,
`SEE ALSO:  sumzeiger71`));
#
#
#
sumzeiger71 := proc(n,m,dt,anz)
   local m1,n1,zeigerliste, zeigerlistet, tz,xx,yy,l,norm;
   norm:=evalf(2^(anz+1)+1);
   xx := (t,l) -> cos(2 * Pi * (1000 + 50*l) * t):
   yy := (t,l) -> sin(2 * Pi * (1000 + 50*l) * t):
   zeigerliste := []:
   tz := 0;
   for n1 from 0 to (n-1) do for m1 from 0 to (m-1) do
      zeigerlistet := [filledarrow(evalf(3*m1), evalf(-3*n1),
         evalf(3*m1+sum('xx(dt*tz,l)', 'l'=-2^anz..2^anz)/norm*2),
         evalf(-3*n1+sum('yy(dt*tz,l)', 'l'=-2^anz..2^anz)/norm*2) )]:
      zeigerliste := [op(zeigerliste), op(zeigerlistet)]:
      tz := tz+1;
   od:
   od:
   PLOT(op(zeigerliste), VIEW(-2.5..3*m+1,-3*n+1..2.5),AXESSTYLE(NONE));
end:
#
assign(`help/text/sumzeiger71`, TEXT(
`FUNCTION: sumzeiger71 - Darstellung des Summenzeigers zu zeiger71`,
``,
`CALLING SEQUENCE:`,
`   sumzeiger71(n, m, dt, anz)`,
``,
``,
`PARAMETERS:`,
`   n               - horizontale Anzahl der Diagramme`,
`   m               - vertikale Anzahl der Diagramme`,
`   dt              - Zeit zwischen zwei Diagrammen`,
`   anz             - Anzahl der Zeiger nach der Formel 2^(anz+1)+1`,
``,
`SYNOPSIS:   `,
`- Zeigerdiagramme zur Veranschaulichung der Lage des ersten Nebenmaximums`,
`  bei zunehmender Zeigerzahl.`,
``,
`  Verwendung in Kapitel 7.1.`,
``,
`EXAMPLES:   `,
``,
`> sumzeiger71(10,10,0.0002,0);`,
``,
``,
`SEE ALSO:  zeiger71`));
#
#
#
intensplot61 := proc(theb,thed,thelambda,theInt0,theGrenze)
   plot(subs(b=theb, d=thed, lambda=thelambda, Int0=theInt0,
      IntX(x)), x=-theGrenze..theGrenze);
end:
#
assign(`help/text/intensplot61`, TEXT(
`FUNCTION: intensplot61 - Intensitaetsplot der Funktion IntX(x)`,
``,
`CALLING SEQUENCE:`,
`   intensplot61(b, d, lambda, Int0, Grenze)`,
``,
``,
`PARAMETERS:`,
`   b               - Abstand der Spalte`,
`   d               - Schirmabstand`,
`   lambda          - Wellenlaenge des verwendeten Lichtes`,
`   Int0            - Intensitaet im Punkt x=0`,
`   Grenze          - der Bereich der Darstellung reicht von `,
`                     -Grenze bis Grenze`,
``,
`SYNOPSIS:   `,
`- Verwendung in Kapitel 6.1`,
``,
`EXAMPLES:   `,
``,
`> intensplot61(100, 4500000, 0.633, 1/4, 72000);`,
``,
`SEE ALSO:  intensbild61, intensplot63, intensbild63`));
#
#
#
intensbild61 := proc(theb,thed,thelambda,theInt0,theGrenze)
   with(plots):
   densityplot(subs(b=theb, d=thed, lambda=thelambda, Int0=theInt0,
      IntX(x)), x=-theGrenze..theGrenze, y=0..1,
      axes=boxed, grid=[120,100], style=patchnogrid);
end:
#
assign(`help/text/intensbild61`, TEXT(
`FUNCTION: intensbild61 - Intensitaetsbild der Funktion IntX(x)`,
``,
`CALLING SEQUENCE:`,
`   intensbild61(b, d, lambda, Int0, Grenze)`,
``,
``,
`PARAMETERS:`,
`   b               - Abstand der Spalte`,
`   d               - Schirmabstand`,
`   lambda          - Wellenlaenge des verwendeten Lichtes`,
`   Int0            - Intensitaet im Punkt x=0`,
`   Grenze          - der Bereich der Darstellung reicht von `,
`                     -Grenze bis Grenze`,
``,
`SYNOPSIS:   `,
`- Verwendung in Kapitel 6.1`,
``,
`EXAMPLES:   `,
``,
`> intensbild61(100, 4500000, 0.633, 1/4, 72000);`,
``,
`SEE ALSO:  intensplot61, intensplot63, intensbild63`));
#
#
#
intensplot63 := proc(theb,thed,thelambda,theInt0,Grenze)
   plot(subs(b=theb,d=thed,lambda=thelambda,Int0=theInt0, IntX(x)), 
   x=-Grenze..Grenze, view=[-Grenze..Grenze, 0..1]);
end:
#
assign(`help/text/intensplot63`, TEXT(
`FUNCTION: intensplot63 - Intensitaetsplot der Funktion IntX(x)`,
``,
`CALLING SEQUENCE:`,
`   intensplot63(b, d, lambda, Int0, Grenze)`,
``,
``,
`PARAMETERS:`,
`   b               - Abstand der Spalte`,
`   d               - Schirmabstand`,
`   lambda          - Wellenlaenge des verwendeten Lichtes`,
`   Int0            - Intensitaet im Punkt x=0`,
`   Grenze          - der Bereich der Darstellung reicht von `,
`                     -Grenze bis Grenze`,
``,
`SYNOPSIS:   `,
`- Verwendung in Kapitel 6.3`,
``,
`EXAMPLES:   `,
``,
`> intensplot63(100, 4500000, 0.633, 1, 72000);`,
``,
`SEE ALSO:  intensplot61, intensbild61, intensbild63`));
#
#
# 
intensbild := proc(theb,thed,thelambda,theInt0,Grenze)
   with(plots);
   readlib(log10):
   densityplot(subs(b=theb,d=thed,lambda=thelambda,Int0=theInt0, log10(IntX(x))),
      x=-Grenze..Grenze, y=0..1,axes=boxed, grid=[120,100],
      style=patchnogrid);
end:
#
assign(`help/text/intensbild63`, TEXT(
`FUNCTION: intensplot63 - Intensitaetsbild der Funktion IntX(x)`,
``,
`CALLING SEQUENCE:`,
`   intensbild63(b, d, lambda, Int0, Grenze)`,
``,
``,
`PARAMETERS:`,
`   b               - Abstand der Spalte`,
`   d               - Schirmabstand`,
`   lambda          - Wellenlaenge des verwendeten Lichtes`,
`   Int0            - Intensitaet im Punkt x=0`,
`   Grenze          - der Bereich der Darstellung reicht von `,
`                     -Grenze bis Grenze`,
``,
`SYNOPSIS:   `,
`- Verwendung in Kapitel 6.3`,
``,
`EXAMPLES:   `,
``,
`> intensbild63(100, 4500000, 0.633, 1, 72000);`,
``,
`SEE ALSO:  intensplot61, intensbild61, intensplot63`));
#
#
#
assign(`help/text/midphys`, TEXT(
`SYNOPSIS:   `,
``,
`   %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%`,
`   %              Maple in der Physik                %`,
`   %                                                 %`,
`   %    (c) Heiner Schwarze / Joern Borgert 1995     %`,
`   %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%`,
``,
`-    Die Datei MIDPHYS.TXT. `,
`     Zusaetzliche Prozeduren zur Verwendung in den `,
`     Beispielen auf der beigefuegten Diskette.`,
``,
`     Zum Erweitern, zum Ausprobieren, `,
`     zum Weiterverwenden.`,
``,
`     Enthaltene Prozeduren:`,
``,
`         polyg / polyg3d`,
`         listplot`,
`         seqn`,
`         arrow / filledarrow`,
`         bild / bildarray`,
`         zeiger32 / sumzeiger32`,
`         bahnen`,
`         zeigespektrum`,
`         zeiger71 / sumzeiger71`,
`         intenplot61 / intensbild61`,
`         intenplot63 / intensbild63`,
``,
`     Detailierte Beschreibungen der Prozeduren und`,
`     die Bedeutung aller Parameter entnehmen Sie`,
`     bitte den entsprechenden Hilfeseiten oder dem`,
`     Anhang A.`,
``,
``));