\(\(\(Remove["Global`*"]\)\(
\)\( (*\ 
      Mit\ diesen\ Vorlagen\ können\ Berechnungen\ in\ der\ Vektorrechnung
\ 
        erfolgen . \ 
          Für\ eine\ Berechnung\ sind\ die\ Kommentarzeichen\ 
\ 
        um\ den\ zugehörigen\ Prozeduraufruf\ zu\ \(\(löschen\)\(.\)\)\ \ *) \)\(
\)
    \)\)
\(\(\(Vektorprodukt[v1_?VectorQ, v2_?VectorQ] := 
\ 
      Module[{m = \(Minors[{v1, v2}, 
                  2]\)[[1]]}, {m[[3]], \(-m[[2]]\), 
            m[[1]]}] /; 
\ 
        Length[v1] == Length[v2] == 
          3\)\(
\)\( (*\ 
      Vektorprodukt[{0, 0, 1}, {1, 0, 0}]\ *) \)\(
\)
    \)\)
EbeneParameterHNF[a_, u_, 
          v_] := 
  Module[{ebene, n, nBetrag, x, y, z, 
            ebene1}, n = Vektorprodukt[u, v]; 
          nBetrag = (Sqrt[n . n]); 
ebene = 
            Simplify[
              n . ((({x, y, z} - a))/nBetrag) == 
                0]; 
ebene1 = 
            ebene /. {x -> "x", y -> "y", 
                z -> "z"}; 
Print[" "]; 
          Print["Normalenvektor n = ", n, " mit |n| = ", 
            nBetrag]; 
Print["HNF: ", 
            ebene1]; 
Print["Abstand der Ebene vom \
Ursprung: d(O,E) = ", Abs[n . (a/nBetrag)]]];

Normalenform[a_, b_, c_] := 
        EbeneParameterHNF[a, b - a, c - a];

\(\(\(\ \ \ \ \ \ \ \)\(\(AbstandPunktEbene[a_, n_, 
          b_] := 
\ \ Module[{ebene, hnf, x, y, z, abstand, 
            nBetrag}, 
          nBetrag = \@\(n . n\); 
ebene = 
            Simplify[\(n . {x, y, z} - b\)\/nBetrag == 
                0]; 
ebene1 = 
            ebene /. {x -> "x", y -> "y", 
                z -> "z"}; 
abstand = \(n . a - b\)\/nBetrag; Print[""]; 
          Print["HNF: ", ebene1]; 
Print["d[(", 
            a[[1]], "|", 
            a[[2]], "|", 
            a[[3]], "),HNF] = ", 
            abstand];];\)\(
\)\(
\)\( (*\ 
      AbstandPunktEbene[{2, \(-4\), 1}, {3, \(-2\), 6}, 
        27]\ *) \)\(
\)
    \)\)\)

(* Schnitt von 2 Geraden in 
                Parameterform *)

\(\(\( (*\ g1 = {\(,\)\(,\)} + t\ {\(,\)\(,\)}; 

      g2 = \({\(,\)\(,\)} + s\ {\(,\)\(,\)}

        lsg = Solve[g1 == g2, {s, t}]\); 
g1 /. 
        lsg\ *) \)\(\ \ \)\( (*Schnittpunkt*) \)\(
\)\(
\)\( (*
Punkt\ A\ \ auf\ einer\ Geraden
\(g = {0, 2, 5} + t\ {1, 1, 2}\); 

      A = \({a, \(-5\), b}
lsg = 
          Solve[g == A, {a, b, t}]
A /. 
            lsg\)\ 
\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ *) \)\(
\)\(
\)\(
\)\(
\)\)\)

(*Schnitt Gerade/Ebene in Param.*)
(*
g1={,,}+t{,,};
ebene={,,}+r{,,}+u{,,};
lsg=Solve[g1==ebene,{r,u,t}]
g1/.lsg
ebene/.lsg
*)

Remove["Global`*"]
PunktanEbenespiegeln[p_,a_,u_]:=Module[{g,nf,F,s},
      g={x,y,z}==p+t*a;
      nf=a.{x,y,z}-u==0;
      lsg=Solve[{g,nf},{x,y,z,t}][[1]];
      Print["Lsg ",lsg];
      F={x,y,z}/.lsg;
      Print["F ",F];
      s=2*F-p;
      Print["Spiegelpunkt ",s];
      ];
PunktanEbenespiegeln[{1,7,4},{1,-2,-1},-11]

(* a={}
betrag=Sqrt[a.a] *)

(*Schnitt Gerade/Ebene in Koordinatenf *)

(* g={x,y,z}=={,,}+t{,,};
nf={,,}.({x,y,z}-{,,})==0;
Solve[{g,nf},{x,y,z,t}]
*)

(* e1=x+y+z==1; e2=x-y+2z==7;*)


(* e1=  ; e2= 
lsg=Solve[{e1,e2},{x,y,z}]//Simplify;
{x,y,z}/.lsg *)

(* Solve[{  x +  y  +  z == ,
         x +  y  +  z == ,
         x +  y  +  z ==  },{x,y,z}] *)

(* Solve[{  x +  y  == ,
         x +  y  == ,
         x +  y  ==  },{x,y}] *)

\(\(\(AbstandwindschieferGeraden[a_, u_, b_, 
          v_] := 
\ \ Module[{kreuz, betrag, abstn}, 
          kreuz = Vektorprodukt[u, 
              v]; 
betrag = \@\(kreuz . kreuz\); 
          abstand = \((a - b)\) . kreuz\/betrag; 
abstn = 
            N[abstand]; Print["Abstand der Geraden:  ", abstand]; 
          Print["Abstand numerisch:  ", 
            abstn]; 
abvektor = \(abstand\ kreuz\)\/betrag; 
          Print["Abstandsvektor:  ", abvektor]; 
g1 = 
            a + t\ u; 
          Print["1. Gerade  ", g1]; 
g2 = b + s\ v; 
          Print["2. Gerade  ", g2]; 
lsg = 
            Solve[g1 - g2 == abvektor, {s, t}]; 
          Print[lsg]; 
Print["Fußpunkt auf 1. Geraden  ", g1 /. lsg]; 
          Print["Fußpunkt auf 2. Geraden  ", 
            g2 /. lsg];];\)\(
\)\(
\)\( (*\ 
      AbstandwindschieferGeraden[{0, 0, 1}, {0, 2, 1}, {0, \(-1\), 1}, {2, 0, 
          1}]\ *) \)\(
\)
    \)\)

AbstandPunktGerade[p_, a_, 
          u_] := 
  Module[{kreuz, betrag, einh, abstand, 
            abstn, ebene, x, y, z, gerade, t, lsg, p1}, 
          betrag = (Sqrt[u . u]); 
einh = (u/betrag); 
          kreuz = Vektorprodukt[einh, p - a]; abstand = (Sqrt[kreuz . kreuz]); 
          abstn = N[
              abstand]; 
Print["Normalenvektor der Ebene: \
   ", u]; 
          Print["Konstante in der Normalenform:    ", 
            p . u]; 
Print["Abstand des Punktes:  ", 
            abstand]; 
          Print["Abstand numerisch:    ", 
            abstn]; 
ebene = 
            u . ({x, y, z} - p) == 
              0; 
gerade = {x, y, z} == a + t u; 
          lsg = Solve[{ebene, gerade}, {x, y, z, 
                t}]; 
p1 = {x, y, z, 
                t} /. lsg; 
Print["Lotfu\
ßpunkt und Lambda:   ", 
            p1];];

\(\(AbstPunktGerade[p_, a_, 
          u_] := 
\ \ Module[{gl, ls, k, f}, 
          gl := a . u + x\ u . u - p . u == 0; 
          ls = Solve[gl, x]; 
f := 
            x /. ls; Print[" lamba  ", f]; 
          Fu := a + f[[1]]\ u; 
          Print[" Fußpunkt  ", 
            Fu]; 
betrag = \@\(\((Fu - p)\) . \((Fu - p)\)\); num1 = betrag; Print[" Entfernung  ", num1]; 
          num = N[betrag]; 
Print[" Entfernung  ", 
            num];];\)

 (*\ 
      AbstPunktGerade[{5, 1, \(-2\)}, {0, 2, \(-2\)}, {2, 
          0, \(-1\)}]\ *) 

\ \)
AbstUrsprungGerade
 g1 = {2, 3, 1} + t {1, 0, 1}
g2 = {1, 0, 1}
lsg = Solve[g1 . g2 == 0, t]
F = g1 /. lsg
d = (Sqrt[F[[1]] . F[[1]]])

AbstPunktGerade
u = {2, 0, -1}
g1 = {0, 2, -2} + t*u
P = {5, 1, -2}
lsg = Solve[(g1 - P) . u == 0, t];
F = g1 /. lsg;
Print["Fußpunkt  ", F]
d = (Sqrt[(F[[1]] - P) . (F[[1]] - P)]);
Print["Abstand ", 
      d]


\(\(PunktanGeradespiegeln[p_, a_, 
          u_] := 
\ \ Module[{gl, ls, k, f}, 
          gl := a . u + x\ u . u - p . u == 0; 
          ls = Solve[gl, x]; 
f := 
            x /. ls; Print[" lamba  ", f]; 
          Fu := a + f[[1]]\ u; 
          Print[" Fußpunkt  ", 
            Fu]; 
betrag = \@\(\((Fu - p)\) . \((Fu - p)\)\); num1 = betrag; Print[" Entfernung  ", num1]; 
          num = N[betrag]; 
Print[" Entfernung  ", 
            num]; 
s = 
            2  Fu - p; 
Print["Spiegelpunkt ", 
            s];
];\)
\)
PunktanGeradespiegeln[{4, 2, 3}, {2, 2, 1}, {1, 1, 
        0}]

\(\(\(FlaecheninhaltDreieck[a_, b_, 
          c_] := 
\ \ Module[{kreuz, betrag, num}, 
          kreuz = Vektorprodukt[c - a, 
              b - a]; 
betrag = \@\(kreuz . kreuz\)\/2; 
          num = N[betrag]; 
Print["Flächeninhalt des Dreiecks:  ", 
            betrag]; 
Print["                 numerisch:  ", num];];\)\(
\)\(
\)\( (*\ \ FlaecheninhaltDreieck[{5, 0, 0}, {0, 2, 0}, {0, 0, 
          0}]\ *) \)\(
\)
    \)\)

\(\(\(Winkel[a_, 
          b_] := 
\ \ Module[{wert, wert2, wert3, alpha, 
            alpha2, alpha3, alpha4, alpha5, alpha6}, 
          wert = a . b\/\(\@\(a . a\)\ \@\(b . b\)\); 
Print["Quotient:  ", wert]; wert2 = N[wert]; 
          Print["numerisch: ", wert2]; 
alpha = 
            ArcCos[wert2]; Print["Bogenmaß:  ", alpha]; 
          alpha2 = 
            N[\(180\ alpha\)\/π]; 
Print["           ", alpha2, "°"]; 
          Print["Schnittwinkel von Geraden bzw. Ebenen: "]; 
wert3 = Abs[wert]; alpha3 = ArcCos[wert3]; 
          alpha4 = 
            N[\(180\ alpha3\)\/π]; 
Print["           ", alpha4, "°"]; 
Print["Schnittwinkel von Gerade und Ebene: "]; alpha5 = ArcSin[wert3]; 
          alpha6 = 
            N[\(180\ alpha5\)\/π]; 
Print["           ", alpha6, "°"];];\)\(
\)\(
\)\( (*\ 
      Winkel[{0, 0, 1}, {1, 0, 
          0}]\ *) \)\(
\)\(
\)
    \)\)

\(\(KugelGerade[m_, r_, a_, 
          b_] := 
Module[{kugel, gerade, x, y, z, t, lsg, 
            p1, p2, glg, glg1}, 
          kugel = \((x - m[[1]])\)\^2 + \((y - m[[2]])\)\^2 + \((z - m[[3]])\)\^2 == 
              r\^2; 
gerade = {x == 
                a[[1]] + 
                  t\ b[[1]], 
              y == 
                a[[2]] + 
                  t\ b[[2]], 
              z == 
                a[[3]] + 
                  t\ b[[3]]}; 
          glg = Append[gerade, kugel]; 
lsg = 
            Solve[glg, {x, y, z, t}]; 
          glg1 = Eliminate[
                glg, {x, y, z}] /. t -> "t"; 
          p1 = {x, y, z, 
                t} /. lsg[[1]]; 
p2 = {x, y, z, 
                t} /. lsg[[2]]; Print[""]; 
          Print["Schnittpunkte der Geraden g mit der Kugel K :"]; 
Print["Gerade g: x= ", a, " + t", b]; 
          Print["Kugel K: [x - ", m, "]^2 = ", 
            r\^2]; 
Print["g in K eingesetzt: ", 
            glg1]; 
If[
            Im[N[p1[[1]]]] ≠ 
              0, Print["Lösung: {}, d.h.: g ist eine Passante"], {Print["Lösung: t1 = ", 
                p1[[4]], "; 
   t2 = ", p2[[4]]]; 
              Print["t1 liefert den Schnittpunkt S1(", 
                p1[[1]], " | ", 
                p1[[2]], " | ", 
                p1[[3]], ")"]; 
Print["t2 liefert den Schnittpunkt S2(", 
                p2[[1]], " | ", 
                p2[[2]], " | ", 
                p2[[3]], ")"]}];];\)

 (*\ 
      KugelGerade[{0, 0, 0}, 
        6, {5, 5, 4}, {3, 1, 
          0}]\ *) 

\)
\(\(KreisGerade[m_, r_, a_, 
          b_] := 
\ \ Module[{kreis, gerade, x, y, t, lsg, 
            p1, p2, glg, 
            glg1}, 
kugel = \((x - m[[1]])\)\^2 + \((y - m[[2]])\)\^2 - r\^2 == 0; 
          gerade = {x == 
                a[[1]] + 
                  t\ b[[1]], 
              y == 
                a[[2]] + 
                  t\ b[[2]]}; 
glg = Append[gerade, kugel]; 
          lsg = Solve[glg, {x, y, t}]; 
glg1 = 
            Eliminate[glg, {x, y}] /. t -> "t"; 
          p1 = {x, y, 
                t} /. lsg[[1]]; 
          p2 = {x, y, 
                t} /. lsg[[2]]; 
          Print[""]; 
Print["Schnittpunkte der Geraden g mit dem Kreis K :"]; 
Print["Gerade g: x= ", a, " + t", b]; 
          Print["Kreis  K: [x - ", m, "]^2 = ", 
            r\^2]; 
Print["g in K eingesetzt: ", 
            glg1]; 
If[
            Im[N[p1[[1]]]] ≠ 
              0, Print["Lösung: {}, d.h.: g ist eine Passante"], {Print["Lösung: t1 = ", 
                p1[[3]], "; 
   t2 = ", p2[[3]]]; 
              Print["t1 liefert den Schnittpunkt S1(", 
                p1[[1]], " | ", 
                p1[[2]], ")"]; 
Print["t2 liefert den Schnittpunkt S2(", 
                p2[[1]], " | ", 
                p2[[2]], ")"]}];];\)

 (*\ 
      KreisGerade[{0, 0}, 
        6, {5, 5}, {3, 1}]\ *) 
\)

InkreisDreieck[a_,b_,c_]:=
  Module[{u,v,w,z,bu,bv,bw,bz,lsg,sp },
u=c-a;  v=b-a; w=c-b; z=a-b;
bu=Sqrt[u.u];
bv=Sqrt[v.v];
bw=Sqrt[w.w];
bz=Sqrt[z.z];
  g1=a+t(1/bu*u+ 1/bv*v);   
         g2=b+s(1/bw*w+ 1/bz*z); 
      lsg=Solve[g1==g2,{s,t}];
sp=g1 /. lsg ;   (* Schnittpunkt *)
Print["Lösung",lsg,sp]; ];

(* gegeben sind die beiden Vektoren,
      die das Dreieck in der Ebene aufspannen *)

\(\(\(UmkreisDreieck[a1_, a2_, b1_, 
          b2_] := 
Module[{a, b}, a = {a1, a2}; 
          b = {b1, b2}; 
g1 = a\/2 + t\ {\(-a2\), a1}; 
          g2 = b\/2 + s\ {\(-b2\), b1}; 
          lsg = Solve[g1 == g2, {s, t}]; 
sp = 
            g1 /. lsg; 
          Print["Lösung", lsg, sp]; 
          Print["1. Gerade:  ", g1]; 
          Print["2. Gerade:  ", 
            g2]; 
Print["Kontrolle"]; 
          Print["Abstand zum Ursprung  ", \@\(First[sp] . First[sp]\)]; 
Print["Abstand zu  a ", \@\(\((First[sp] - a)\) . \((First[sp] - a)\)\)]; 
Print["Abstand zu  b ", \@\(\((First[sp] - b)\) . \((First[sp] - b)\)\)];];\)\(
\)\(
\)\( (*\ 
      UmkreisDreieck[3, 0, 0, 4]\ *) \)\(
\)
    \)\)

(* Spurgerade
    e1=4x+3y+2z==12; e2=z==0;*)
(*
e1=4x+3y+2z==12  ; e2=z==0
lsg=Solve[{e1,e2},{x,y,z}]//Simplify;
{x,y,z}/.lsg *)

Volumen[a_,b_,c_]:=
  Module[{kreuz, v},           
            kreuz=Vektorprodukt[a,b];
                v=kreuz.c;            
            Print["Spatvolumen ",v];
       ];
(* Volumen[{5,2,-3},{5,1,0},{-1,0,1}] *)



AbstandwindschieferGeraden2[a_,u_,b_,v_]:=
  Module[{betrag,abstn},
g1=a+s*u;
g2=b+t*v;
 Print["1. Gleichung  ",(g1-g2).u==0//Simplify ];
 Print["2. Gleichung  ",(g1-g2).v==0//Simplify ];
         lsg=Solve[{ (g1-g2).u==0, (g1-g2).v==0  } ,{s,t}];    
         Print[lsg]; 
p=First[g1 /. lsg];
q=First[g2 /. lsg];

         Print[ "Fußpunkt auf 1. Geraden  ", p] ;
         Print[ "Fußpunkt auf 2. Geraden  ", q ];   


    
           abstand=Sqrt[(p-q).(p-q)];
                    abstn=abstand//N;
          Print["Abstand der Geraden:  ",abstand];
          Print["Abstand numerisch:  ",abstn];
                    
       ];

AbstandwindschieferGeraden2[{-2, 2, -5}, {6, 2, 
              3}, {-1, -1, 2}, {3, 2, 2}];

Remove["Global`*"]
a = {0, 0, 2};
b = {0, 0, 8};
g={1, 0, 0}+t {0, 1,  0};
u = a - g;
v = b - g;
f[t_] := ArcCos[u . (v/((Sqrt[u . u]) (Sqrt[v . v])))]
f[t]
Extremstellen = Solve[D[f[t], t] == 0, t] // N
g /. Extremstellen
w = f[t] /. Extremstellen
w*180/Pi
Plot[180/Pi*f[t], {t, -10, 10}, 
        PlotRange -> {0, 40}]