M/Ph/Info (Beslmeisl)

Diese Seite ist nicht editierbar. Sie können den Quelltext sehen, jedoch nicht verändern. Kontaktieren Sie den Administrator, wenn Sie glauben, dass hier ein Fehler vorliegt.
=====Die wichtigsten Konstruktionen=====

Die wichtigsten Grundkonstruktionen sind **Mittelsenkrechte**, **Lot**, **Winkelhalbierende**, **Parallele**. Man braucht sie in fast jeder größeren Konstruktion. Man sollte sie also so gut beherrschen, dass man darüber nicht mehr nachdenken muss. Wenn man dann so weit ist, kann man auch die Befehle gleichen Namens verwenden und damit auf die Einzelschritte verzichten.

Zu den Grundlagen gehören auch **Umkreis** und **Inkreis** eines Dreiecks, der **Thaleskreis** über eine Strecke, und **Flächenumwandlungen**.

====Mittelsenkrechte====
Fangen wir mit der Mittelsenkrechten ''m'' zweier gegebener Punkte ''A'' und ''B'' an.

<applet code="browser.KonApplet" archive="mathe:konstruktion.jar" width="610" height="260">
  <param name="konstruktion" value='
hilf={_grau20,_s1};;;
A=VarPunkt(-3,1); Zeichner(A,_rot);;;
B=VarPunkt(2,0); Zeichner(B,_rot);;;
k1=Kreis(A,B); Zeichner(k1,hilf);;;
k2=Kreis(B,A); Zeichner(k2,hilf);;;
P=Schnitt(k1,k2); #Zeichner(P,_rot);;;
Q=Schnitt(k2,k1); #Zeichner(Q,_rot);;;
m=Gerade(P,Q); Zeichner(m,_blau);;;
# m=Mittelsenkrechte(A,B); Zeichner(m,_blau);;;
'>
  <param name="titel" value ="Mittelsenkrechte zweier Punkte">
  <param name="permissions" value="sandbox">
  <param name="codebase" value ="*">
</applet>

====Lot====
Das Lot ell auf eine gegebene Gerade ''g'' durch einen gegebenen Punkt ''P'' ist eine Erweiterung der letzten Aufgabe. Es muss nur von ''P'' ein Kreis geschlagen werden, der ''g'' zweimal schneidet. Von diesen beiden Schnittpunkten wird die Mittelsenkrechte konstruiert. (Dass der Kreis zweimal schneidet darf angenommen werden, wenn er durch einen beliebigen Punkt der Geraden geht. Wenn nicht, brauchen wir den Punkt nur einmal an anderer Stelle zu wählen.)

<applet code="browser.KonApplet" archive="mathe:konstruktion.jar" width="610" height="280">
  <param name="konstruktion" value='
hilf={Farbe(0.7, 0.7, 0.7),Strich(0.8,{6,3})};;;
g=Gerade(-6,3,5,-1); Zeichner(g,_rot);;;
P=VarPunkt(-1,-2); Zeichner(P,_rot);;;
V=PunktAuf(g,-2,2); Zeichner(V,_rot);;;
k1=Kreis(P,V); Zeichner(k1,hilf);;;
A=Schnitt(k1,g); B=Schnitt(g,k1);;;
k2=Kreis(A,B); Zeichner(k2,hilf);;;
k3=Kreis(B,A); Zeichner(k3,hilf);;;
C=Schnitt(k2,k3); D=Schnitt(k3,k2);;;
ell=Gerade(C,D); Zeichner(ell,_blau); # oder ell=Mittelsenkrechte(A,B); Zeichner(ell,_blau);;;
# ell=Lot(g,P);;;
'>
  <param name="titel" value="Lot auf Gerade durch Punkt">
  <param name="permissions" value="sandbox">
  <param name="codebase" value ="*">
</applet>

====Winkelhalbierende====
Für die Winkelhalbierende der Geraden ''g'' und ''h'' trägt man vom Schnittpunkt ''S'' der beiden aus auf beiden den gleichen Radius ab. Von den Schnittpunkten des Kreises mit den beiden Geraden zieht man eine Gerade durch ''S''. Das ist die Winkelhalbierende.

<applet code="browser.KonApplet" archive="mathe:konstruktion.jar" width="610" height="280">
  <param name="konstruktion" value='
hilf={_grau20,_s1};;;
g=Gerade(-6,2,5,-1); Zeichner(g,{_rot,_Punkt});;;
A=VarPunkt(-5,-2); B=VarPunkt(1,2); Zeichner(A,_rot); Zeichner(B,_rot);;;
h=Gerade(A,B); Zeichner(h,{_rot,_Punkt});;;
S=Schnitt(g,h); Zeichner(S,_blau);;;
k1=Kreis(S,3); Zeichner(k1,hilf);;;
P=Schnitt(k1,g);;;
Q=Schnitt(k1,h);;;
k2=Kreis(P,Q); Zeichner(k2,hilf);;;
k3=Kreis(Q,P); Zeichner(k3,hilf);;;
w=Gerade(S,Schnitt(k3,k2)); Zeichner(w,{_blau,_Punkt});;;
# w=Winkelhalbierende(g,h); Zeichner(w,{_blau,_Punkt});;;
'>
  <param name="titel" value="Winkelhalbierende zweier Geraden">
  <param name="permissions" value="sandbox">
  <param name="codebase" value ="*">
</applet>

====Parallele====
Die Konstruktion einer Parallelen ''h'' zur Geraden ''g'' durch den Punkt ''P'' kann man zurückführen auf die Konstruktion zweier Lote. Für die Lote wollen wir jetzt einmal die Tatsache ausnutzen, dass es den Befehl Lot schon gibt und wir ihn verwenden dürfen, weil wir ja die Lotkonstruktion verstanden haben. Wem das zu einfach ist, der kann alles als Übung ausformulieren.

<applet code="browser.KonApplet" archive="mathe:konstruktion.jar" width="610" height="200">
  <param name="konstruktion" value='
hilf={_grau20,_s1};;;
g=Gerade(-6,3,5,-1); Zeichner(g,{_rot,_Punkt});;;
P=VarPunkt(-2,-1); Zeichner(P,_rot);;;
lot1=Lot(g,P); Zeichner(lot1, hilf);;;
h=Lot(lot1,P); Zeichner(h,{_blau,_Punkt});;;
# h=Parallele(g,P); Zeichner(h,{_blau,_Punkt});;;
'>
  <param name="titel" value="Parallelenkonstruktion">
  <param name="permissions" value="sandbox">
  <param name="codebase" value ="*">
</applet>

====Umkreis eines Dreiecks====
Jedes Dreieck (dessen Eckpunkte nicht alle auf einer Geraden liegen) hat einen Umkreis. Der Beweis dieser Aussage ist sehr einfach: Auf der Mittelsenkrechten von ''A'' und ''B'' liegen nur Punkte, die von ''A'' und ''B'' gleich weit entfernt sind. Auf der Mittelsenkrechten von ''B'' und ''C'' liegen nur Punkte, die von ''B'' und ''C'' gleich weit weg sind. Der Schnittpunkt ''M'' dieser beiden Mittelsenkrechten hat also sowohl gleichen Abstand von ''A'' und ''B'', wie auch gleichen Abstand von ''B'' und ''C''. Damit hat ''M'' von allen drei Punkten den gleichen Abstand. Also ist ''M'' der Mittelpunkt des Umkreises.

<applet code="browser.KonApplet" width="610" height="260" archive="mathe:konstruktion.jar">
  <param name="konstruktion" value='
kon1={_grau60,_s2}; kon2={_blau,_dünn};;;
A=VarPunkt(-2,-3); B=VarPunkt(5,-4); C=VarPunkt(1,4);;;
Zeichner({A,B,C,A}, Farbe(1,0,0));;;
k1=Kreis(A,B); k2=Kreis(B,A); k3=Kreis(C,B); k4=Kreis(B,C);;;
#Zeichner(k1,kon1); Zeichner(k2,kon1); Zeichner(k3,kon1); Zeichner(k4,kon1);;;
m1=Gerade(Schnitt(k1,k2), Schnitt(k2,k1));;;
m2=Gerade(Schnitt(k3,k4), Schnitt(k4,k3));;;
Zeichner(m1,kon2); Zeichner(m2,kon2);;;
M=Schnitt(m1,m2);;;
k=Kreis(M,A); Zeichner(k);;;
'>
  <param name="titel" value="Umkreis dreier Punkte">
  <param name="permissions" value="sandbox">
  <param name="codebase" value ="*">
</applet>

====Inkreis eines Dreiecks====
Jedes Dreieck hat einen Inkreis. Auf der Winkelhalbierenden von ''a'' und ''b'' liegen nur Punkte, die von ''a'' und ''b'' gleich weit weg sind. Auf der Winkelhalbierenden von ''b'' und ''c'' liegen nur Punkte, die von ''b'' und ''c'' gleich weit weg sind. Der Schnittpunkt ''N'' der beiden ist also von ''a'', ''b'' und ''c'' gleich weit weg, d.h. die Lote auf alle drei Seiten sind gleich lang. ''N'' ist also der Inkreismittelpunkt.

<applet code="browser.KonApplet" width="610" height="230" archive="mathe:konstruktion.jar">
  <param name="titel" value="Inkreis dreier Geraden">
  <param name="konstruktion" value='
blau=Farbe(0.6,0.6,1);;;
dots=Strich(0.6,{8,2}); line=Strich(0.5);;;
kon1={_grau60,dots}; kon2={blau,line};;;
A=VarPunkt(-2,-3); B=VarPunkt(5,-4); C=VarPunkt(1,4);;;
Zeichner({A,B,C,A}, _rot);;;
w1=Winkelhalbierende(B,A,C); Zeichner(w1,kon2);;;
w2=Winkelhalbierende(A,C,B); Zeichner(w2,kon2);;;
M=Schnitt(w1,w2); c=Gerade(A,B);;;
P=Schnitt(c,Lot(c,M)); Zeichner({P,M},kon1);;;
k=Kreis(M,P); Zeichner(k,blau);;;
'>
  <param name="permissions" value="sandbox">
  <param name="codebase" value ="*">
</applet>

====Thaleskreis====
Zieht man von einem beliebigen Punkt eines Kreises Linien zu den beiden Enden eines Durchmessers, so ist der eingeschlossene Winkel stets 90° groß. Der Kreis wird dann Thaleskreis über diesem Durchmesser genannt.

<applet code="browser.KonApplet" width="610" height="210" archive="mathe:konstruktion.jar">
  <param name="titel" value="Thaleskreis">
  <param name="konstruktion" value='
hilf={_grau20,_s1};;;
A=VarPunkt(-4,1); B=VarPunkt(3,-2);;;
Zeichner({A,B},_rot);;;
M=Mittelpunkt(A,B); Zeichner(M,hilf);;;
k=Kreis(M,A); Zeichner(k,hilf);;;
P=PunktAuf(k,<100°); Zeichner(P,_rot);;;
Zeichner({A,P,B},_blau);;;
'>
  <param name="permissions" value="sandbox">
  <param name="codebase" value ="*">
</applet>

====Tangente an einen Kreis====
Den Thaleskreis kann man auch verwenden, um durch einen gegebenen Punkt die Tangente an einen gegebenen Kreis zu legen. Der Radius muss nämlich senkrecht zur Tangente sein.

<applet code="browser.KonApplet" width="610" height="200" archive="mathe:konstruktion.jar">
  <param name="konstruktion" value='
hilf={_grau20,_s2,_Punkt};;;
A=VarPunkt(-4,0); Zeichner(A,_rot);;;
B=VarPunkt(3,-2);Zeichner(B,_rot);;;
k=Kreis(A,3); Zeichner(k,_rot);;;
th=Kreis(Mittelpunkt(A,B),A); Zeichner(th,hilf);;;
P=Schnitt(k,th); Zeichner({A,P},hilf);;;
t=Gerade(P,B); Zeichner(t,_blau);;;
'>
  <param name="titel" value="Tangente an einen Kreis">
  <param name="permissions" value="sandbox">
  <param name="codebase" value ="*">
</applet>

====Umwandlung einer Fläche====
Da der Flächeninhalt eines Dreiecks nur von dessen Grundlinie und Höhe abhängt, kann man leicht die Anzahl der Ecken eines Vielecks verkleinern ohne seinen Flächeninhalt zu verändern. Dazu denkt man sich eine Ecke des Vielecks als Ecke des nächstliegenden Dreiecks und verschiebt sie so lange, bis eine Ecke dieses Dreiecks verschwindet. Aus dem 5-Eck ''ABCDE'' wird im folgenden Beispiel das flächengleiche 4-Eck ''APDE'', indem man ''C'' nach ''P'' verschiebt. Der Vorganz heißt Scherung.

<applet code="browser.KonApplet" width="610" height="220" archive="mathe:konstruktion.jar">
  <param name="konstruktion" value='
hilf={_grau40,_s2};;;
A=Punkt(2,3); B=Punkt(3,2.5); C=VarPunkt(5,0);;;
D=Punkt(1,-4); E=Punkt(-3,-2);;;
g=Gerade(B,D); Zeichner(g,hilf);;;
h=Parallele(g,C); Zeichner(h,hilf);;;
a=Gerade(A,B); Zeichner(a,hilf);;;
Zeichner({A,B,C,D,E,A},{_rot,Strich(3)});;;
P=Schnitt(h,a); Zeichner({A,B,P,D,E,A},_blau);;;
'>
  <param name="titel" value="Viereck aus F&uuml;nfeck">
  <param name="permissions" value="sandbox">
  <param name="codebase" value ="*">
</applet>

Mit der Kenntnis z.B. des Höhensatzes kann man ein Rechteck in ein flächengleiches Quadrat verwandeln.

<applet code="browser.KonApplet" width="610" height="220" archive="mathe:konstruktion.jar">
  <param name="konstruktion" value='
hilf={_grau20,_s3};;;
#Wir brauchen erst mal ein Rechteck ABCD;;
a=Gerade(-6,-4,1,0); d=Gerade(-6,-4,0,-1);;;
A=Schnitt(a,d); B=PunktAuf(a,0,4); D=PunktAuf(d,-7,-1);;;
b=Parallele(d,B); c=Parallele(a,D); C=Schnitt(b,c);;;

#Mit dem Höhensatz ermitteln wir x=Wurzel der Fläche;;
k=Kreis(C,B); Zeichner(k,hilf);;;
B1=Schnitt(k,c);;;
Zeichner(c,hilf); Zeichner(b,hilf);;;
Zeichner({A,B,C,D,A},_rot);;;
M=Mittelpunkt(D,B1); Zeichner(M,hilf);;;
t=Kreis(M,D); Zeichner(t,hilf);;;
P=Schnitt(b,t); x=Abstand(C,P);;;

#Jetzt errichten wir noch das Quadrat über der Höhe;;
Q=Schnitt(Kreis(C,x),c);;;
R=Schnitt(Parallele(b,Q),Parallele(c,P));;;
Zeichner({C,Q,R,P,C},_blau);;;
'>
  <param name="titel" value="Rechteck zu Quadrat">
  <param name="permissions" value="sandbox">
  <param name="codebase" value ="*">
</applet>
M/Ph/Info (Beslmeisl)

Benutzer-Werkzeuge

Webseiten-Werkzeuge

Seiten-Werkzeuge
