# data[].attributes.body
Download der Aufgaben für den hilfsmittelfreien schriftlichen Prüfungsteil - diese Aufgaben sind auch gut zur Vorbereitung der mündlichen Prüfung geeignet

# data[].attributes.attachment_link.readable_text
Dieser Prüfungsteil ist ohne elektronische Hilfsmittel (z.B. Taschenrechner, Software) sowie ohne Tabellen und Formelsammlung zu bearbeiten. Zur Orientierung für Lehrkräfte und Schülerinnen und Schüler wurden Musteraufgaben entwickelt, die über den nachfolgenden Link herunterzuladen sind. Weiterhin werden in der länderübergreifenden zwei Pools mit Prüfungsaufgaben entwickelt, aus denen die Länder Aufgaben für die schriftliche Abiturprüfung auswählen werden.

Die Einführung eines hilfsmittelfreien Aufgabenformats in der schriftlichen Abiturprüfung ab dem Abitur 2014 war in Hamburg ohnehin vorgesehen. Beispielaufgaben für Kurse auf grundlegendem Niveau werden in Kürze auf dieser Seite zur Verfügung gestellt.

Da jedes der beteiligten Länder unterschiedliche Skalen bei der Bewertung der in den Aufgaben zu erbringenden Leistungen ansetzte, hat die Arbeitsgruppe beschlossen, eine einheitliche Bewertungsskala auf einer 120-Punkte-Basis einzuführen, die ab 2014 auch für die schriftliche Abiturprüfung Mathematik verbindlich ist. Weitere Informationen zum Einsatz des Aufgabenformats in einer zentralen Abiturprüfung sind den Vorbemerkungen des Textes mit den Musteraufgaben zu entnehmen.

# data[].attributes.attachment_link.description
Dieser Prüfungsteil ist ohne elektronische Hilfsmittel (z.B. Taschenrechner, Software) sowie ohne Tabellen und Formelsammlung zu bearbeiten. Zur Orientierung für Lehrkräfte und Schülerinnen und Schüler wurden Musteraufgaben entwickelt, die über den nachfolgenden Link herunterzuladen sind. Weiterhin werden in der länderübergreifenden zwei Pools mit Prüfungsaufgaben entwickelt, aus denen die Länder Aufgaben für die schriftliche Abiturprüfung auswählen werden.

# data[].attributes.attachment_caption
MÜNDLICHE ABIPRÜFUNG IN MATHE - STOCHASTIK: zum Mitmachen!

# data[].attributes.attachment_link.title
MÜNDLICHE ABIPRÜFUNG IN MATHE - STOCHASTIK: zum Mitmachen!

# data[].attributes.attachment_caption
MÜNDLICHE ABIPRÜFUNG IN MATHE - ANALYSIS: zum Mitmachen!

# data[].attributes.attachment_link.title
MÜNDLICHE ABIPRÜFUNG IN MATHE - ANALYSIS: zum Mitmachen!

# data[].attributes.attachment_caption
MÜNDLICHE ABIPRÜFUNG IN MATHE - VEKTORRECHNUNG: zum Mitmachen!

# data[].attributes.attachment_link.title
MÜNDLICHE ABIPRÜFUNG IN MATHE - VEKTORRECHNUNG: zum Mitmachen!

# data[].attributes.attachment_link.readable_text
Dieser Kurs dient zur Abiturvorbereitung im Themengebiet Analysis. Er bietet zunächst eine Übersicht über viele möglichen Aufgabentypen, die das Grundgerüst der Analysis im Abitur darstellen. Hast du diese Aufgaben gelöst, kommen nach und nach längere und schwierigere Aufgaben, darunter auch frühere Abituraufgaben.

In diesem Kurs wiederholst du die Aspekte der Kurvendiskussion sowie u. a. das Arbeiten mit mathematischen Textaufgaben.

# data[].attributes.attachment_link.description
Dieser Kurs dient zur Abiturvorbereitung im Themengebiet Analysis. Er bietet zunächst eine Übersicht über viele möglichen Aufgabentypen, die das Grundgerüst der Analysis im Abitur darstellen. Hast du diese Aufgaben gelöst, kommen nach und nach längere und schwierigere Aufgaben, darunter auch frühere Abituraufgaben. In diesem Kurs wiederholst du die Aspekte der Kurvendiskussion sowie u. a.

# data[].attributes.attachment_link.readable_text
Dieser Kurs befindet sich noch im Aufbau!

Inhalt des Kurses

Dieser Kurs soll dem Leser das zentrale Grundwissen, das für das bayrische Abitur relevant ist, vermitteln. Dabei werden alle zentrale Formeln und Sachverhalte kurz genannt und an Beispielen erklärt.

Falls gewisse Sachverhalte noch unklar sein sollten, gibt es Links zu ausführlicheren Erklärungen. Falls weitere Fragen offen bleiben, könnt ihr gerne die Kommentarfelder nutzen!

Vorkenntnisse

Das ist ein Überblickskurs, der eine kompakte Zusammenfassung für die Abiturvorbereitung bieten soll. Deshalb solltest du bereits die elfte und zwölfte Klasse besucht haben.

Kursdauer

Je nachdem, an wie viel du dich noch erinnern kannst, kann es kurz oder lange sein.

# data[].attributes.attachment_link.description
Dieser Kurs soll dem Leser das zentrale Grundwissen, das für das bayrische Abitur relevant ist, vermitteln. Dabei werden alle zentrale Formeln und Sachverhalte kurz genannt und an Beispielen erklärt. Falls gewisse Sachverhalte noch unklar sein sollten, gibt es Links zu ausführlicheren Erklärungen. Falls weitere Fragen offen bleiben, könnt ihr gerne die Kommentarfelder nutzen!

# data[].attributes.attachment_link.readable_text
Bei den Beispielaufgaben für das Fach Mathematik handelt es sich um die Aufgaben der Aufgabensammlung, die vor Beginn der Entwicklung der Abituraufgabenpools zur Orientierung für Lehrkräfte sowie Schülerinnen und Schüler veröffentlicht wurde. Dazu gehören Aufgaben der folgenden Arten (vgl. dazu "Begleitende Dokumente" → "Mathematik" → "Hinweise zur Verwendung von Hilfsmitteln"):

Aufgaben, für deren Bearbeitung eine Verwendung von Hilfsmitteln nicht vorgesehen ist;

Aufgaben, für deren Bearbeitung als digitales Hilfsmittel ein Computeralgebrasystem (CAS)* vorgesehen ist;

Aufgaben, für deren Bearbeitung als digitales Hilfsmittel ein einfacher wissenschaftlicher Taschenrechner (WTR) vorgesehen ist.

* Seit Juli 2021 wird - entsprechend der Funktionalität dieses Hilfsmittels - anstelle der Bezeichnung "Computeralgebrasystem (CAS)" die Bezeichnung "Modulares Mathematiksystem (MMS)" verwendet.

# data[].attributes.attachment_link.description
Bei den Beispielaufgaben für das Fach Mathematik handelt es sich um die Aufgaben der Aufgabensammlung, die vor Beginn der Entwicklung der Abituraufgabenpools zur Orientierung für Lehrkräfte sowie Schülerinnen und Schüler veröffentlicht wurde. Dazu gehören Aufgaben der folgenden Arten (vgl. dazu “Beg…

# data[].attributes.body
1. Filtern: Mathematik / Hamburg / Gymnasium

2. Interaktive Aufgaben auswählen: Bundesabitur, HH eA oder HH gA

3. Aufgaben auswählen und bearbeiten

# data[].attributes.attachment_link.title
MyStark - Digitale Zusatzmaterialien für vertiefendes Lernen

# data[].attributes.attachment_link.description
Entdecken Sie auf MyStark die Plattform für digitale Zusatzmaterialien, die speziell auf unsere Bücher und den Lehrplan Ihres Bundeslandes abgestimmt sind. Profitieren Sie von maßgeschneiderten Übungsmaterialien, die Sie beim Lernen unterstützen und Ihnen dabei helfen, sich optimal auf Ihre Prüfungen vorzubereiten.

# data[].attributes.attachment_link.description
Mathe online lernen und üben mit Erklärungen zu allen Themen, wie Analysis, Algebra, Stochastik und Geometrie. Kostenlos und einfach Mathematik bis zum Abi lernen.

# data[].attributes.attachment_link.readable_text
<html><div style="margin-left:25px; line-height: 1.5; ">
*[[Ableitung]]
*[[Ableitungsregeln]]
*[[Abstand]]
*[[Abstand zweier Ebenen]]
*[[Abstand zweier Geraden]]
*[[Abstand zwischen Gerade und Ebene]]
*[[Abstand zwischen Punkt und Ebene]]
*[[Abstand zwischen Punkt und Gerade]]
*[[Achsenabschnittsform]]
*[[Additionsregel]]
*[[Arithmetisches Mittel]]
*[[Asymptote]]

</div></html>

<<tiddler HideTiddlerSubtitle>>
<html>Die Ableitung \(\mathrm{ f'(x)}\) einer [[Funktion]] \(\mathrm{ f(x)}\) gibt das [[Steigungsverhalten]] der Funktion \(\mathrm{f(x)}\) an.
<p>Wenn \(\mathrm{ f(x)}\) in \(\mathrm{ x_0}\) differenzierbar (ableitbar) ist, lässt sich die Steigung von \(\mathrm{ f(x)}\) im Punkt \(\mathrm{ \left(x_0 \, | \, f(x_0)\right)}\) mit dem Grenzwert des [[Differenzenquotienten|Differenzenquotient]] berechnen:
$$\mathrm{ \underset{\Delta x\rightarrow 0}{lim} \cfrac{{\Delta} y}{{\Delta} x} \, = \, \underset{x\rightarrow x_0}{lim} \cfrac{f(x) - f(x_0)}{x - x_0} \, = \, \underset{h\rightarrow 0}{lim} \cfrac{f(x_0+h) - f(x_0)}{h} \, = \, f'(x_0)}$$
<p>Diesen Grenzwert nennt man [[Differenzialquotient]].
<p>Wenn der Grenzwert nicht existiert, ist \(\mathrm{ f(x)}\) in \(\mathrm{ x_0}\) nicht differenzierbar. </html>

<<tiddler HideTiddlerSubtitle>><html>!!!Summenregel:
<p>\(\mathrm{ f(x) \, = \, u(x) \, + \, v(x) \ \ \ {\large\Rightarrow} \ \ \ f'(x) \, = \, u'(x) \, + \, v'(x)}\)

!!!Faktorregel:
<p>\(\mathrm{ f(x) \, = \, c\, \cdot \, u(x) \ \ \ {\large\Rightarrow} \ \ \ f'(x) \, = \, c \, \cdot \, u'(x)}\)

!!!Produktregel:
<p>\(\mathrm{ f(x) \, = \, u(x)\, \cdot \, v(x) \ \ \ {\large\Rightarrow} \ \ \ f'(x) \, = \, u'(x)\, \cdot \, v(x)\, + \,u(x)\, \cdot \, v'(x)}\)

!!!Quotientenregel:
<p>\(\mathrm{ f(x) \, = \, \cfrac{u(x)}{v(x)}  \ \ \ {\large\Rightarrow} \ \ \ f'(x) \, =\, \cfrac{u'(x)\, \cdot \, v(x)\, - \,u(x)\, \cdot \, v'(x)}{v(x)^2}}\)

!!!Kettenregel:
<p>\(\mathrm{ f(x) \, = \, u(v(x)) \ \ \ {\large\Rightarrow} \ \ \ f'(x) \, = \, u'(v(x))\, \cdot \, v'(x)}\)</html>

<<tiddler HideTiddlerSubtitle>>
<html>Unter Abstand versteht man in der Geometrie die minimale Entfernung zweier geometrischer Objekte. Zur Berechnung des Abstands bestimmt man die Länge der kürzesten Verbindungsstrecke der beiden betrachteten Objekte.
<p>\( \ \rightarrow \) [[Entfernung zweier Punkte]]
\( \ \rightarrow \) [[Abstand zwischen Punkt und Gerade]]
\( \ \rightarrow \) [[Abstand zwischen Punkt und Ebene]]
\( \ \rightarrow \) [[Abstand zweier Geraden]]
\( \ \rightarrow \) [[Abstand zwischen Gerade und Ebene]]
\( \ \rightarrow \) [[Abstand zweier Ebenen]]
</html>

<<tiddler HideTiddlerSubtitle>>
<html>Um den [[Abstand]] zweier paralleler [[Ebenen|Ebene]] zu berechnen, wird ein beliebiger Punkt auf einer der Ebenen gewählt und dessen Abstand zur anderen Ebene bestimmt.
<p>\( \ \rightarrow \) [[Abstand zwischen Punkt und Ebene ]]
</html>

<<tiddler HideTiddlerSubtitle>><html>!!!Abstand zweier windschiefer Geraden
Die Berechnung des [[Abstands|Abstand]] zweier windschiefer [[Geraden|Gerade]] $\mathrm{g}$ und $\mathrm{h}$ lässt sich zurückführen auf die Berechnung des Abstands eines beliebigen Punktes der einen Geraden zu einer Hilfsebene:
<img  vspace="0" hspace="20" border="0" align="right" style="padding-top:20pt;" src="img_glossar/Abstand.Gerade.Gerade.png" alt="Abstand zweier Geraden" />
''Schritt 1:'' Gleichung einer Hilfsebene $\mathrm{H}$, die die Gerade $\mathrm{h}$ enthält und parallel zur Geraden $\mathrm{g}$ liegt, in Normalenform aufstellen
$$\mathrm{H: \ \ (\vec u \times \vec v) \circ (\vec X - \vec B)=0}$$
(mit $\mathrm{\vec u}$ und $\mathrm{\vec v}$ als Richtungsvektoren von $\mathrm{g}$ und $\mathrm{h}$ und $\mathrm{B}$ als Aufpunkt von $\mathrm{h}$)

''Schritt 2:'' Abstand von $\mathrm{g}$ zu $\mathrm{h}$ als Abstand eines Punktes der Geraden $\mathrm{g}$ zur Ebene $\mathrm{H}$ berechnen
$$\mathrm{d(g;\, h)=d(A; \, H)}$$
(mit $\mathrm{A \in g}$ beliebig)

!!!Abstand zweier paralleler Geraden
Um den Abstand zweier paralleler Geraden zu berechnen, wird ein beliebiger Punkt auf einer der Geraden gewählt und dessen Abstand zur anderen Geraden bestimmt.
<p>\( \ \rightarrow \) [[Abstand zwischen Punkt und Gerade]]
</html>

<<tiddler HideTiddlerSubtitle>>
<html>Um den [[Abstand]] zwischen einer [[Ebene]] und einer dazu parallelen [[Geraden|Gerade]] zu berechnen, wählt man einen beliebigen Punkt der Geraden und berechnet dessen Abstand zur Ebene.
<p>\( \ \rightarrow \) [[Abstand zwischen Punkt und Ebene]]
</html>

<<tiddler HideTiddlerSubtitle>>
<html>Um den [[Abstand]] eines Punktes $\mathrm{P(p_1\, |\, p_2\, | \,p_3)}$ zu einer [[Ebene]] $\mathrm{E}$ zu berechnen, wird die [[Hesse'sche Normalenform (HNF)|Hesse'sche Normalenform]] der Ebene verwendet. Die Koordinaten von $\mathrm{P}$ werden in die HNF von $\mathrm{E}$ eingesetzt. Der Betrag des Ergebnisses ist der Abstand des Punktes zur Ebene:
$$\mathrm{ d(P,E )= \left|\cfrac{n_1 \cdot p_1 + n_2 \cdot p_2 + n_3 \cdot p_3 + n_0}{\left|\vec{n}\right|}\right| }$$
<p>Dabei bezeichnet \(\mathrm{ \vec n }\) einen [[Normalenvektor]] der Ebene $\mathrm{E}$.
</html>

<<tiddler HideTiddlerSubtitle>>
<html>Um den [[Abstand]] $\mathrm{d}$ eines Punktes $\mathrm{P}$ zu einer [[Geraden|Gerade]] $\mathrm{g}$ berechnen zu können, benötigt man eine Hilfsebene $\mathrm{H}$, die <img src="img_glossar/Abstand.Punkt.Gerade.png"; width="257"; height="289", alt="Abstand.Punkt.Gerade"; align="right"; vspace="0"; hspace="20"; style="padding-bottom:20pt;" />senkrecht auf $\mathrm{g }$ steht und $\mathrm{P}$ enthält.
<p>Eine Gleichung von $\mathrm{H}$ erhält man, indem man den Richtungsvektor \(\mathrm{ \vec u }\) von $\mathrm{g}$ als [[Normalenvektor]] verwendet und die Konstante \(\mathrm{n_0}\) der Koordinatenform von $\mathrm{H}$ durch Einsetzen der Koordinaten von $\mathrm{P}$ berechnet.
<p>Durch Schneiden von $\mathrm{g}$ und $\mathrm{H}$ erhält man den Lotfußpunkt $\mathrm{F}$ von $\mathrm{P}$ auf $\mathrm{g}$.
<p>Der Abstand zwischen Punkt und Gerade ist nun gleich dem Abstand von $\mathrm{P}$ und $\mathrm{F}$.
<p>Alternativ kann man den Punkt $\mathrm{F}$ bestimmen, indem man den allgemeinen [[Verbindungsvektor]] \(\mathrm{ \vec{PF} }\), zwischen $\mathrm{P}$ und $\mathrm{F}$ aufstellt, wobei $\mathrm{F}$ zunächst ein allgemeiner Geradenpunkt von $\mathrm{g}$ ist. Mithilfe der Bedingung \(\mathrm{ \vec{PF}\,\circ\,\vec u=0}\) können dann die Koordinaten des Lotfußpunktes $\mathrm{F}$ ermittelt werden.
<p>\( \ \rightarrow \) [[Entfernung zweier Punkte]]
</html>

<<tiddler HideTiddlerSubtitle>>
<html>Die Achsenabschnittsform ist eine spezielle Koordinatenform der [[Ebenengleichung]], aus der man die [[Durchstoßpunkte|Durchstoßpunkt]] der Koordinatenachsen durch die [[Ebene]] direkt ablesen kann. Sie kann nur für Ebenen gebildet werden, die nicht durch den Koordinatenursprung verlaufen.
<p>Die Achsenabschnittsform der Ebenengleichung einer Ebene $\mathrm{E}$ wird gebildet, indem man die Konstante in der Normalenform (in Koordinatendarstellung) auf -1 normiert. Dazu dividiert man die Ebenengleichung durch das Negative dieser Konstante und erhält:
<p style="margin-top:-5pt";>$$\mathrm{ E: \ \ \cfrac{n_1}{-n_0} \cdot x_1  + \cfrac{n_2}{-n_0} \cdot x_2 + \cfrac{n_3}{-n_0} \cdot x_3 -  1 = 0 }$$
<p>Die Koordinaten der Durchstoßpunkte der x~~1~~- bzw. x~~2~~- bzw. x~~3~~-Achse durch die Ebene $\mathrm{E}$ lauten dann:
<p>\(\mathrm{ \hspace{4em} D_1 (\, \cfrac{-n_0}{n_1} \, | \, 0 \, | \, 0 \,) }\) bzw. \(\mathrm{D_2( \, 0 \, | \, \cfrac{-n_0}{n_2} \, | \, 0 \, ) }\) bzw. \(\mathrm{D_3( \, 0 \, | \, 0 \, | \, \cfrac{-n_0}{n_3} \, )}\)
</html>

<<tiddler HideTiddlerSubtitle>>
<html>Die Additionsregel für [[Wahrscheinlichkeiten|Wahrscheinlichkeit]] zweier [[Ereignisse|Ereignis]] \(\mathrm{A,\, B \subseteq \Omega}\) lautet:
<p>$$\mathrm{ P(A \cup B)=P(A)+P(B)-P(A \cap B)}$$
<p>Anschaulich wird diese Regel mit einem [[Mengendiagramm]]:
<p><img width="199" vspace="0" hspace="20" border="0" height="137" src="img_glossar/Additionsregel.png" alt="Additionsregel" />
 <p>Die Schnittmenge \(\mathrm{A \cap B}\) ist sowohl im Ereignis $\mathrm{A}$ als auch im Ereignis $\mathrm{B}$ enthalten. Sie darf aber nur einmal gezählt werden und muss deshalb einmal wieder abgezogen werden.
<p>''Spezialfall:'' Wenn $\mathrm{A}$ und $\mathrm{B}$ [[unvereinbar|Unvereinbare Ereignisse]] sind, ist \(\mathrm{A \cap B = \{\ \}}\) . Dann vereinfacht sich die obige Gleichung zu \(\mathrm{P(A \cup B)=P(A)+P(B)}\), da \(\mathrm{P(A \cap B) = 0}\).

<p>!!!Beispiel:
<div style="line-height:2;">Beim Wurf eines fairen Würfels seien die Ereignisse \(\mathrm{A,\, B,\, C \subseteq \Omega}\) wie folgt definiert:
\(\mathrm{A = \{1,\, 2,\, 3\}}\)
\(\mathrm{B = \{2,\, 4,\, 6\}}\)
\(\mathrm{C = A \cup B}\)
<p>Für die Wahrscheinlichkeiten gilt:
\(\mathrm{ P(A)  =  \cfrac{|A|}{| \Omega |}  =  \cfrac{3}{6}} \ \ \) bzw. \(\mathrm{ \ \ P(B) = \cfrac{|A|}{| \Omega |}  =  \cfrac{3}{6}}\)
<p>Nach der Additionsregel gilt für die Wahrscheinlichkeit des Ereignisses \(\mathrm{C = \{1,\, 2,\, 3,\, 4,\, 6\}}\):
\(\mathrm{ P(C)  =  P(A)  +  P(B)  -  P(A \cap B)  =  \cfrac{3}{6}  +  \cfrac{3}{6}  -  P( \lbrace 2 \rbrace)  =  1  -  \cfrac{1}{6}  =  \cfrac{5}{6}}\)</div>
</html>

<<tiddler HideTiddlerSubtitle>>
<html>Das arithmetische Mittel beschreibt einen Durchschnittswert beobachteter Werte. Es wird durch den Quotienten der Summe aller Werte und der absoluten Anzahl der Werte definiert:
<p>$$\mathrm{ \overline{x}  =  \cfrac{\text{Summe aller Werte}}{ \text{Anzahl der Werte}}  =  \cfrac{x_1  +  x_2  +  \ldots  +  x_n}{n}}$$

<p>!!!Beispiel:
Das arithmetische Mittel der Werte 1, 2, 3, 4, 5 lautet:
<p>$$\mathrm{ \overline{x}  =  \cfrac{1  +  2  +  3  +  4  +  5}{5}  =  \cfrac{15}{5}  =  3}$$
</html>

<<tiddler HideTiddlerSubtitle>>
<html>Asymptoten sind Geraden, denen sich der Graph einer [[Funktion]] beliebig genau annähert. Es gibt drei verschiedene Arten von Asymptoten:
<p>!!!Senkrechte Asymptoten
Die Senkrechten Asymptoten einer Funktion treten an ihren Unendlichkeitsstellen (z.B. an ihren [[Polstellen|Polstelle]] oder am Rand des [[Definitionsbereichs|Definitionsmenge]]) auf. Ist beispielsweise $\mathrm{2}$ eine Polstelle der Funktion \(\mathrm{f(x)}\), so lautet die Gleichung der senkrechten Asymptote \(\mathrm{x = 2}\).
<p><img width="240" height="322" vspace="0" hspace="20" border="0" alt="Asymptote.senkrecht" src="img_glossar/Asymptote_senkrecht.png" />

<p>!!!Waagrechte Asymptoten
Waagrechte Asymptoten einer Funktion \(\mathrm{f(x)}\) liegen vor, wenn \(\mathrm{\underset{x \rightarrow \infty}{lim} \ f(x)  =  b \  }\) oder \(\mathrm{ \  \underset{x \rightarrow -\infty}{lim} \ f(x)  =  b}\).
Dann ist \(\mathrm{y = b}\) waagrechte Asymptote von \(\mathrm{f(x)}\).
<p><img width="326" height="218" vspace="0" hspace="20" border="0"  alt="Asymptote.waagrecht" src="img_glossar/Asymptote_waagrecht.png" />

<p>!!!Schräge Asymptoten
Schräge Asymptoten einer Funktion \(\mathrm{f(x)}\) liegen vor, wenn \(\mathrm{\underset{x \rightarrow \infty}{lim} \ [f(x)  -  (mx  +  t)]  =  0 \  }\) oder \(\mathrm{  \ \underset{x \rightarrow  -  \infty}{lim} \ [f(x)  -  (mx  +  t)]  =  0}\).
Dann ist \(\mathrm{y = mx + t}\) schräge Asymptote von \(\mathrm{f(x)}\).
<p><img width="257" height="355" vspace="0" hspace="20" border="0" alt="Asymptote.schraeg" src="img_glossar/Asymptote_schraeg.png" />
</html>

[[Automatisches Speichern|AutoSave]] speichert automatisch Änderungen jedes Mal, wenn Sie einen Tiddler bearbeiten. Damit sinken die Chancen, dass Sie Daten verlieren. Beachten Sie jedoch, dass bei aktivierter [[Backup-Funktion|SaveBackups]] natürlich auch eine Menge Backup-Dateien erstellt werden. Entscheiden Sie sich deshalb für die eine oder andere Funktion.

<html><div style="margin-left:25px; line-height: 1.5;">
*[[Baumdiagramm]]
*[[Bedingte Wahrscheinlichkeit]]
*[[Bernoulli-Experiment]]
*[[Bernoulli-Kette]]
*[[Bestimmtes Integral]]
*[[Betragsfunktion]]
*[[Binomialkoeffizient]]
*[[Binomialverteilung]]

</div></html>

<<tiddler HideTiddlerSubtitle>>
<html>Mithilfe von Baumdiagrammen lassen sich zusammengesetzte [[Zufallsexperimente|Zufallsexperiment]] darstellen. Bei jeder Stufe des Experiments zweigen wie bei einem Baum Pfade zu den einzelnen [[Ergebnissen|Ereignis]] ab.
<p><img width="449" vspace="0" hspace="20" border="0" height="171" alt="Baumdiagramm1" src="img_glossar/Baumdiagramm1.png" />
<p> Zudem gilt in jedem vollständigen Baumdiagramm die ''Verzweigungsregel'':
Die Summe aller [[Wahrscheinlichkeiten|Wahrscheinlichkeit]], die von einem Verzweigungspunkt ausgehen, ist stets 1.

<p>!!!Beispiel:
Der dreifache Münzwurf ist ein dreistufiges Zufallsexperiment. Wenn $\mathrm{K}$ für das Ergebnis "Kopf" und $\mathrm{Z}$ für "Zahl" geschrieben wird, ergibt sich folgendes Baumdiagramm:
<p><img width="453" vspace="0" hspace="20" border="0" height="205" alt="Baumdiagramm2" src="img_glossar/Baumdiagramm2.png" />

<p style="margin-top:-5pt";>Wegen der Verzweigungsregel gilt außerdem:
$$\mathrm{P(K)+P(Z)=1}$$
<p>\( \ \rightarrow \) [[Pfadregeln]]
</html>

<<tiddler HideTiddlerSubtitle>>
<html>Unter einer bedingten Wahrscheinlichkeit versteht man die [[Wahrscheinlichkeit]], dass ein [[Ereignis]] $\mathrm{A}$ eintritt unter der Bedingung, dass ein anderes Ereignis $\mathrm{B}$ bereits eingetreten ist. Es gilt die Formel:
<p>$$\mathrm{P_{B}(A) = \cfrac{P(A \cap B)}{P(B)} }$$
<p>Für zwei [[stochastisch unabhängige|Stochastische Unabhängigkeit]] Ereignisse gilt \(\mathrm{P_B(A) = P(A)}\), weil $\mathrm{B}$ keinen Einfluss auf $\mathrm{A}$ hat.
<p>\( \ \rightarrow \) [[Satz von Bayes]]
\( \ \rightarrow \) [[Totale Wahrscheinlichkeit]]
</html>

<<tiddler HideTiddlerSubtitle>>
<html>Ein [[Zufallsexperiment]], bei dem nur zwei [[Ergebnisse|Ergebnis]] eintreten können, heißt ~Bernoulli-Experiment.
<p>!!!Beispiel
Der Münzwurf ist ein ~Bernoulli-Experiment, da entweder Kopf oder Zahl geworfen wird.
<p>\( \ \rightarrow \) [[Bernoulli-Kette]]
</html>

<<tiddler HideTiddlerSubtitle>>
<html>Ein [[Zufallsexperiment]], das aus mehreren unabhängigen [[Bernoulli-Experimenten|Bernoulli-Experiment]] zusammengesetzt wird, heißt ~Bernoulli-Kette. Die Anzahl der ~Bernoulli-Experimente wird als Kettenlänge $\mathrm{n}$ bezeichnet. Die [[Wahrscheinlichkeit]] $\mathrm{p}$ für das Eintreten eines [[Ergebnisses|Ereignis]] heißt Parameter der ~Bernoulli-Kette.
<p>!!!Beispiel:
Der dreifache Münzwurf ist eine Bernoulli-Kette der Länge 3 mit dem Parameter \(\mathrm{ p = {\large\frac{1}{2}}}\).
<p>\( \ \rightarrow \) [[Binomialverteilung]]
</html>

<<tiddler HideTiddlerSubtitle>>
<html>Mit dem bestimmten Integral kann man die gerichtete Fläche (Flächenbilanz) berechnen, die der Graph einer [[Funktion]] \(\mathrm{f(x)}\) mit der x-Achse einschließt. Flächen, die unter der x-Achse liegen, werden negativ gezählt.
<p><img width="472px" height="258px" vspace="0" hspace="20" border="0" alt="Bestimmtes Integral" src="img_glossar/Bestimmtes_Integral.png" />
<p>Wenn man die Bilanz der Fläche berechnen will, die \(\mathrm{f(x)}\) im Intervall $\mathrm{a}$ bis $\mathrm{b}$ mit der x-Achse einschließt, ist dies mithilfe der [[Stammfunktion]] \(\mathrm{F(x)}\) möglich:
$$\mathrm{ \int\limits_a^b f(x) \:dx =  [F(x)]_a^b = F(b) - F(a)}$$
<p>\( \ \rightarrow \) [[Rechenregeln für Integrale]]
\( \ \rightarrow \) [[Unbestimmtes Integral]]
\( \ \rightarrow \) [[HDI]]
\( \ \rightarrow \) [[Integralfunktion]]
</html>

<<tiddler HideTiddlerSubtitle>>
<html>Die Grundfunktion ist \(\mathrm{f:\,x \mapsto |\,x\,|}\).
<p>Schreibweise ohne Betragsstriche:
$$\mathrm{ \hspace{4mm} f(x)=\left\{ \begin{array}{rl}\mathrm{x,} & \mathrm{falls \ \ x\geq 0}  \\  \mathrm{-x,} & \mathrm{falls \ \ x<0} \end {array} \right.}$$
<p>Für die [[Funktion]] $\mathrm{f}$ lassen sich folgende Aussagen treffen:
<p style="margin-top:-5px";>*[[Definitionsmenge]]: \(\mathrm{ \ D=\mathbb R}\)
<p style="margin-top:-5px";>*[[Wertemenge]]: \(\mathrm{ \ W=\mathbb{R}_0^+}\)
<p style="margin-top:-5px";>*[[Nullstellen|Nullstelle]]: \(\mathrm{ |\, x \,|  =0\;\Leftrightarrow\; x=0}\)
<p style="margin-top:-5px";>*Verhalten im Unendlichen: \(\mathrm{ \underset{x\rightarrow\pm\infty}{lim}|\,x\,|=\infty }\)
<p style="margin-top:-15px";>*[[Differenzierbarkeit]]: an der Knickstelle \(\mathrm{x = 0}\) nicht differenzierbar
<p style="margin-top:-5px";>*[[Symmetrie]]: achsensymmetrisch zur y-Achse
<p>Der Graph einer Betragsfunktion entsteht aus dem Graphen der Funktion ohne Betragsstriche, indem alle unter der x-Achse liegenden Teile des Graphen an der x-Achse gespiegelt werden. Alle über der x-Achse liegenden Teile des Graphen bleiben unverändert.
<p><img vspace="0" hspace="20" border="0"  alt="Betragsfunktion" src="img_glossar/Betragsfunktion.png" />
</html>

<<tiddler HideTiddlerSubtitle>>
<html>Der Binomialkoeffizient gibt die Anzahl der Möglichkeiten an, $\mathrm{k}$ Objekte aus einer $\mathrm{n}$-elementigen Menge auszuwählen (Modell ohne Zurücklegen, ohne Beachtung der Reihenfolge). Im Fall \(\mathrm{ 0 \leq k \leq n}\) gilt:
<p style="margin-top:-5px";>$$\mathrm{  \left(\array{n\\\text{k}}\right) = \cfrac{n!}{k!  \cdot (n -  k)!} }$$
<p>Gelesen wird diese Schreibweise als „$\mathrm{k}$ aus $\mathrm{n}$" oder „$\mathrm{n}$ über $\mathrm{k}$".
<p>Falls \(\mathrm{ k > n}\), so hat der Binomialkoeffizent den Wert $\mathrm{0}$.
<p> Bei Benutzung des Taschenrechners verwendet man die „nCr"-Taste, um den Binomialkoeffizienten auszurechnen.
<p>\( \ \rightarrow \) [[Binomialverteilung]]
\( \ \rightarrow \) [[Fakultät]]
</html>

<<tiddler HideTiddlerSubtitle>>
<html>Die [[Wahrscheinlichkeitsverteilung]] einer [[Bernoulli-Kette]] heißt Binomialverteilung. Sie hängt von der Kettenlänge $\mathrm{n}$ und der [[Wahrscheinlichkeit]] $\mathrm{p}$ des beobachteten [[Ergebnisses|Ereignis]] ab. Man formuliert das Eintreten dieses Ergebnisses als Treffer.
<p>Für die Wahrscheinlichkeit, dass genau $\mathrm{k}$ Treffer bei $\mathrm{n}$ Versuchen eintreten, gilt:
<p style="margin-top:-5pt";>$$\mathrm{ P(Z = k)= B(n; \ p; \ k) = \left(\array{n\\\text{k}}\right) \cdot p^{k} \cdot (1 - p)^{n-k}}$$
<p>Oft will man nicht die Wahrscheinlichkeit für eine genaue Anzahl von Treffern bestimmen. Für Fragestellungen, bei denen höchstens $\mathrm{k}$-mal das Ergebnis eintreten soll, verwendet man die [[kumulative Verteilungsfunktion|Kumulative Verteilungsfunktion]]:
<p style="margin-top:-5pt";>$$\mathrm{ P(Z \le k) = \sum\limits_{i=0}^k B(n; \ p; \ i)}$$
<p>Wenn die Anzahl der Treffer mindestens $\mathrm{k}$ betragen soll, geht man zum [[Gegenereignis]] über:
<p style="margin-top:-5pt";>$$\mathrm{ P(Z \ge k) = 1-  P(Z \le k-1) = 1 - \sum\limits_{i=0}^{k-1} B(n; \ p; \ i)}$$
<p>Meist können die Werte der kumulativen Binomialverteilung aus vorgefertigten Tabellen abgelesen werden.
<p>Für eine binomialverteilte [[Zufallsgröße]] $\mathrm{Z}$ erhält man den [[Erwartungswert]] \(\mathrm{E(Z) = n \cdot p}\) und die [[Varianz]] \(\mathrm{Var(Z) = n \cdot p \cdot (1 - p)}\).
</html>

Die Unterscheidung der [[Groß-/Kleinschreibung in Suche|CaseSensitiveSearch]] tut genau dies.

Background: #fff
Foreground: #000
PrimaryPale: #8cf
PrimaryLight: #18f
PrimaryMid: #04b
PrimaryDark: #014
SecondaryPale: #ffc
SecondaryLight: #fe8
SecondaryMid: #db4
SecondaryDark: #841
TertiaryPale: #eee
TertiaryLight: #ccc
TertiaryMid: #999
TertiaryDark: #666
Error: #f88

Bei Aktivierung dieser Funktion fordert TiddlyWiki eine Bestätigung des Benutzers an, wenn ein Tiddler gelöscht werden soll.

<html><div width="100%"; align="center"; style="border-top:solid; border-top-width:1px; border-color:#0044BB"></div></html><<tiddler HideTiddlerTags>><<tiddler HideTiddlerSubtitle>><<tiddler HideTiddlerSubtitle with: TiddlerTitle>>© 2016 by Stark Verlagsgesellschaft mbH & Co. KG
Besuchen Sie uns im Internet: http://www.stark-verlag.de

Das Werk einschließlich aller seiner Teile ist urheberrechtlich geschützt.
Dieses eBook stellen wir lediglich als persönliche Lizenz zur Verfügung.
Jede andere Verwertung bedarf der schriftlichen Genehmigung des Verlags.
Dies gilt insbesondere für Vervielfältigungen, Übersetzungen, Mikroverfilmungen
sowie die Einspeicherung und Verarbeitung in elektronischen Systemen.

Diese Arbeit basiert auf ~TiddlyWiki 2.8.1 © Jeremy Ruston 2004-2007, © ~UnaMesa Association 2007-2012. Diese Software wird von den Rechteinhabern und den Beitragsleistenden ohne jegliche spezielle oder implizierte Garantien zur Verfügung gestellt, die unter anderem einschließen: die implizierte Garantie der Verwendbarkeit der Software für einen bestimmten Zweck. Auf keinen Fall sind die Rechteinhaber oder die Beitragsleistenden für irgendwelche direkten, indirekten, zufälligen, speziellen, beispielhaften oder folgenden Schäden (unter anderem Verschaffen von Ersatzgütern oder -dienstleistungen; Einschränkung der Nutzungsfähigkeit; Verlust der Nutzungsfähigkeit; Daten; Profit oder Geschäftsunterbrechung) wie auch immer verursacht und unter welcher Verpflichtung auch immer, ob in Vertrag, strikter Verpflichtung oder unerlaubter Handlung (inklusive Fahrlässigkeit) verantwortlich, auf welchem Weg sie auch immer durch die Benutzung dieser Software entstanden sind, sogar, wenn sie auf die Möglichkeit eines solchen Schadens hingewiesen worden sind.

Die in diesem ~TiddlyWiki verwenden Plugins [[CoreTweaks]] © Eric Shulman, [[GermanTranslation2.7a]] © Besim Karadeniz, [[HideTiddlerTags]] © Eric Shulman, [[HideTiddlerSubtitle]] © Eric Shulman, [[HTMLFormattingPlugin]] © Eric Shulman, [[ImageSizePlugin]] © Eric Shulman, [[InlineJavascriptPlugin]] © Eric Shulman, [[TiddlerTweakerPlugin]] © Eric Shulman sind lizenziert unter cc-by-sa-3.0. Eine Kopie der Lizenz erhalten Sie auf http://creativecommons.org/licenses/by-sa/3.0/.

[[MathJaxPlugin]] © Canada East, verwendet © 2011 ~MathJax. Lizenziert gemäß Apache Licence Version 2.0 (die „Lizenz"); Nutzung dieser Datei nur in Übereinstimmung mit der Lizenz erlaubt. Eine Kopie der Lizenz erhalten Sie auf http://www.apache.org/licenses/LICENSE-2.0. Sofern nicht gemäß geltendem Recht vorgeschrieben oder schriftlich vereinbart, erfolgt die Bereitstellung der im Rahmen der Lizenz verbreiteten Software OHNE GEWÄHR ODER VORBEHALTE - ganz gleich, ob ausdrücklich oder stillschweigend. Informationen über die jeweiligen Bedingungen für Genehmigungen und Einschränkungen im Rahmen der Lizenz finden Sie in der Lizenz.

/***
|Name|CoreTweaks|
|Source|http://www.TiddlyTools.com/#CoreTweaks|
|Version||
|Author|Eric Shulman|
|License|http://www.TiddlyTools.com/#LegalStatements|
|~CoreVersion|2.2.0|
|Type|plugin|
|Description|a small collection of overrides to TW core functions|
This tiddler contains small changes to TW core functions that correct or enhance standard features or behaviors.
***/
//{{{
// calculate TW version number - used to determine which tweaks should be applied
var ver=version.major+version.minor/10+version.revision/100;
//}}}
/***
----

***/
// // closed: won't fix //(leave as core tweaks)//
// // {{block{
/***
!!!637 TiddlyLink tooltip - custom formatting
***/
// // {{groupbox small{
/***
http://trac.tiddlywiki.org/ticket/637 - CLOSED: WON'T FIX
This tweak modifies the tooltip format that appears when you mouseover a link to a tiddler.  It adds an option to control the date format, as well as displaying the size of the tiddler (in bytes)

Tiddler link tooltip format:
{{stretch{<<option txtTiddlerLinkTootip>>}}}
^^where: %0=title, %1=username, %2=modification date, %3=size in bytes, %4=description slice, %5=first N characters of tiddler content^^
Tiddler link tooltip date format:
{{stretch{<<option txtTiddlerLinkTooltipDate>>}}}
Tiddler excerpt limit (chars):
{{stretch{<<option txtTiddlerLinkTooltipLimit>>}}}
***/
//{{{
config.messages.tiddlerLinkTooltip='%0';
config.messages.tiddlerLinkTooltipDate='';
config.messages.tiddlerLinkTooltipLimit=50;

config.options.txtTiddlerLinkTootip=
	/*config.options.txtTiddlerLinkTootip||*/config.messages.tiddlerLinkTooltip;
config.options.txtTiddlerLinkTooltipDate=
	/*config.options.txtTiddlerLinkTooltipDate||*/config.messages.tiddlerLinkTooltipDate;
config.options.txtTiddlerLinkTooltipLimit=
	/*config.options.txtTiddlerLinkTooltipLimit||*/config.messages.tiddlerLinkTooltipLimit;

Tiddler.prototype.getSubtitle = function() {
	var modifier = this.modifier;
	if(!modifier) modifier = config.messages.subtitleUnknown;
	var modified = this.modified;
	if(modified) modified = modified.formatString(config.options.txtTiddlerLinkTooltipDate);
	else modified = config.messages.subtitleUnknown;
	var descr=store.getTiddlerSlice(this.title,'Description')||'';
	var txt=this.text.substr(0,config.options.txtTiddlerLinkTooltipLimit);
	if (this.text.length>config.options.txtTiddlerLinkTooltipLimit) txt+="...";
	return config.options.txtTiddlerLinkTootip.format([this.title,modifier,modified,this.text.length,descr,txt]);
};
//}}}
// // }}}}}}// // {{block{
/***
!!!607 add HREF link on permaview command
***/
// // {{groupbox small{
/***
http://trac.tiddlywiki.org/ticket/607 - CLOSED: WON'T FIX
This tweak automatically sets the HREF for the 'permaview' sidebar command link so you can use the 'right click' context menu for faster, easier bookmarking.  Note that this does ''not'' automatically set the permaview in the browser's current location URL... it just sets the HREF on the command link.  You still have to click the link to apply the permaview.
***/
//{{{
config.macros.permaview.handler = function(place)
{
	var btn=createTiddlyButton(place,this.label,this.prompt,this.onClick);
	addEvent(btn,'mouseover',this.setHREF);
	addEvent(btn,'focus',this.setHREF);
};
config.macros.permaview.setHREF = function(event){
	var links = [];
	story.forEachTiddler(function(title,element) {
		links.push(String.encodeTiddlyLink(title));
	});
	var newURL=document.location.href;
	var hashPos=newURL.indexOf('#');
	if (hashPos!=-1) newURL=newURL.substr(0,hashPos);
	this.href=newURL+'#'+encodeURIComponent(links.join(' '));
}
//}}}
// // }}}}}}// // {{block{
/***
!!!458 add permalink-like HREFs on internal TiddlyLinks
***/
// // {{groupbox small{
/***
http://trac.tiddlywiki.org/ticket/458 - CLOSED: WON'T FIX
This tweak assigns a permalink-like HREF to internal Tiddler links (which normally do not have any HREF defined).  This permits the link's context menu (right-click) to include 'open link in another window/tab' command.  Based on a request from Dustin Spicuzza.
***/
//{{{
window.coreTweaks_createTiddlyLink=window.createTiddlyLink;
window.createTiddlyLink=function(place,title,includeText,theClass,isStatic,linkedFromTiddler,noToggle)
{
	// create the core button, then add the HREF (to internal links only)
	var link=window.coreTweaks_createTiddlyLink.apply(this,arguments);
	if (!isStatic)
		link.href=document.location.href.split('#')[0]+'#'+encodeURIComponent(String.encodeTiddlyLink(title));
	return link;
}
//}}}
// // }}}}}}
// // to be fixed in 2.6.0:
// // {{block{
/***
!!!1151 adjust popup placement when root element is in scrolled DIV
***/
// // {{groupbox small{
/***
http://trac.tiddlywiki.org/ticket/1151
When a popup link is placed inside a DIV with style "overflow:scroll" or "overflow:auto" and that DIV is then scrolled, the position of the resulting popup appears further down the page that intended, because it is not adjusting for the relative scroll offset of the containing DIV.  This tweak patches the Popup.place() function to calculate and subtract the current scroll offset from the computed popup position, so that it appears in the correct location on the page.

Test case: //(scroll to the bottom of this DIV and click on "test popup")//
{{groupbox{
 <<tiddler ScrollBox with: CoreTweaks##1151test 12em>>}}}/%
!1151test
<<tiddler About>>
<<showPopup tiddler:About label:"test popup" tip:About popupClass:sticky>>
!end
%/
***/
//{{{
window.findScrollOffsetX=function(obj) {
	var x=0;
	while(obj) {
		if (obj.scrollLeft && obj.nodeName!='HTML')
			x+=obj.scrollLeft;
		obj=obj.parentNode;
	}
	return -x;
}

window.findScrollOffsetY=function(obj) {
	var y=0;
	while(obj) {
		if (obj.scrollTop && obj.nodeName!='HTML')
			y+=obj.scrollTop;
		obj=obj.parentNode;
	}
	return -y;
}

var fn=Popup.place.toString();
if (fn.indexOf('findScrollOffsetX')==-1) { // only once
	fn=fn.replace(/var\s*rootLeft\s*=/,'var rootLeft = window.findScrollOffsetX(root) +');
	fn=fn.replace(/var\s*rootTop\s*=/,'var rootTop = window.findScrollOffsetY(root) +');
	eval('Popup.place='+fn);
}
//}}}
// // }}}}}}// // {{block{
/***
!!!1147 tiddler macro with params does not refresh
***/
// // {{groupbox small{
/***
http://trac.tiddlywiki.org/ticket/1147
when the {{{<<tiddler SomeTiddler>>}}} macro is handled, the resulting span has extra attributes: {{{refresh='content'}}} and {{{tiddler='SomeTiddler'}}}.  If SomeTiddler is changed, {{{store.notify('SomeTiddler')}}} triggers {{{refreshDisplay()}}}, which automatically re-renders transcluded content in any span that has these extra attributes.  However, when additional arguments are passed by using {{{<<tiddler SomeTiddler with: arg arg arg ...>>}}} then the resulting span does NOT get the extra attributes noted above and, as a consequence, the transcluded content is not being refreshed, even though the underlying tiddler has changed

To correct this, in {{{config.macros.tiddler.handler}}}:
*set the 'refresh' and 'tiddler' attributes even when arguments are present in the macro
*store the arguments themselves in an attribute (e.g, 'args'), using as a space-separated, bracketed list
Then, in {{{config.refreshers.content}}}:
*retrieve the stored arguments (if any) and the tiddler source
*substitute arguments into source and re-render the span with the updated content

***/
//{{{
config.refreshers.content=function(e,changeList) {
		var title = e.getAttribute("tiddler");
		var force = e.getAttribute("force");
		var args = e.getAttribute("args"); // ADDED
		if(force != null || changeList == null || changeList.indexOf(title) != -1) {
			removeChildren(e);
//			wikify(store.getTiddlerText(title,""),e,null,store.fetchTiddler(title)); // REMOVED
			config.macros.tiddler.transclude(e,title,args); // ADDED
			return true;
		} else
			return false;
};

config.macros.tiddler.handler=function(place,macroName,params,wikifier,paramString,tiddler) {
	params = paramString.parseParams("name",null,true,false,true);
	var names = params[0]["name"];
	var tiddlerName = names[0];
	var className = names[1] || null;
	var args = params[0]["with"];
	var wrapper = createTiddlyElement(place,"span",null,className);
//	if(!args) { // REMOVED
		wrapper.setAttribute("refresh","content");
		wrapper.setAttribute("tiddler",tiddlerName);
// 	} // REMOVED
	if(args!==undefined) wrapper.setAttribute("args",'[['+args.join(']] [[')+']]'); // ADDED
	this.transclude(wrapper,tiddlerName,args); // REFACTORED TO ...tiddler.transclude
}

// REFACTORED FROM ...tiddler.handler
config.macros.tiddler.transclude=function(wrapper,tiddlerName,args) {
	var text = store.getTiddlerText(tiddlerName); if (!text) return;
	var stack = config.macros.tiddler.tiddlerStack;
	if(stack.indexOf(tiddlerName) !== -1) return;
	stack.push(tiddlerName);
	try {
		if (typeof args == "string") args=args.readBracketedList(); // ADDED
		var n = args ? Math.min(args.length,9) : 0;
		for(var i=0; i<n; i++) {
			var placeholderRE = new RegExp("\\$" + (i + 1),"mg");
			text = text.replace(placeholderRE,args[i]);
		}
		config.macros.tiddler.renderText(wrapper,text,tiddlerName,null); // REMOVED UNUSED 'params'
	} finally {
		stack.pop();
	}
};
//}}}
// // }}}}}}// // {{block{
/***
!!!1134 allow leading whitespace in section headings / TBD handle shadow tiddler sections
***/
// // {{groupbox small{
/***
http://trac.tiddlywiki.org/ticket/1134
This tweak REPLACES and extends {{{store.getTiddlerText()}}} so it can return sections defined in shadow tiddlers as well as permitting use of leading whitespace in section headings.
***/
//{{{
TiddlyWiki.prototype.getTiddlerText = function(title,defaultText)
{
	if(!title) return defaultText;
	var parts = title.split(config.textPrimitives.sectionSeparator);
	var title = parts[0];
	var section = parts[1];
	var parts = title.split(config.textPrimitives.sliceSeparator);
	var title = parts[0];
	var slice = parts[1]?this.getTiddlerSlice(title,parts[1]):null;
	if(slice) return slice;
	var tiddler = this.fetchTiddler(title);
	var text = defaultText;
	if(this.isShadowTiddler(title))
		text = this.getShadowTiddlerText(title);
	if(tiddler)
		text = tiddler.text;
	if(!section) return text;
	var re = new RegExp("(^!{1,6}[ \t]*" + section.escapeRegExp() + "[ \t]*\n)","mg");
	re.lastIndex = 0;
	var match = re.exec(text);
	if(match) {
		var t = text.substr(match.index+match[1].length);
		var re2 = /^!/mg;
		re2.lastIndex = 0;
		match = re2.exec(t); //# search for the next heading
		if(match)
			t = t.substr(0,match.index-1);//# don't include final \n
		return t;
	}
	return defaultText;
};
//}}}
// // }}}}}}// // {{block{
/***
!!!824 ~WindowTitle - alternative to combined ~SiteTitle/~SiteSubtitle in window titlebar
***/
// // {{groupbox small{
/***
http://trac.tiddlywiki.org/ticket/824 - OPEN
This tweak allows definition of an optional [[WindowTitle]] tiddler that, when present, provides alternative text for display in the browser window's titlebar, instead of using the combined text content from [[SiteTitle]] and [[SiteSubtitle]] (which will still be displayed as usual in the TiddlyWiki document header area).

Note: this ticket replaces http://trac.tiddlywiki.org/ticket/401 (closed), which proposed using a custom [[PageTitle]] tiddler for this purpose.  ''If you were using the previous '401 ~PageTitle' tweak, you will need to rename [[PageTitle]] to [[WindowTitle]] to continue to use your custom window title text''
***/
//{{{
config.shadowTiddlers.WindowTitle='<&llt;lt;tiddler SiteTitle>> - <<tiddler SiteSubtitle>>';
window.getPageTitle=function() { return wikifyPlain('WindowTitle'); }
store.addNotification('WindowTitle',refreshPageTitle); // so title stays in sync with tiddler changes
//}}}
// // }}}}}}// // {{block{
/***
!!!471 'creator' field for new tiddlers
***/
// // {{groupbox small{
/***
http://trac.tiddlywiki.org/ticket/471 - OPEN
This tweak HIJACKS the core's saveTiddler() function to automatically add a 'creator' field to a tiddler when it is FIRST created. You can use """<<view creator>>""" (or """<<view creator wikified>>""" if you prefer) to show this value embedded directly within the tiddler content, or {{{<span macro="view creator"></span>}}} in the ViewTemplate and/or EditTemplate to display the creator value in each tiddler.
***/
//{{{
// hijack saveTiddler()
TiddlyWiki.prototype.CoreTweaks_creatorSaveTiddler=TiddlyWiki.prototype.saveTiddler;
TiddlyWiki.prototype.saveTiddler=function(title,newTitle,newBody,modifier,modified,tags,fields)
{
	var existing=store.tiddlerExists(title);
	var tiddler=this.CoreTweaks_creatorSaveTiddler.apply(this,arguments);
	if (!existing) store.setValue(title,'creator',config.options.txtUserName);
	return tiddler;
}
//}}}
// // }}}}}}
// // fixed in ~TW2.4.3
// // {{block{
/***
!!!444 'tiddler' and 'place' - global variables for use in computed macro parameters
***/
// // {{groupbox small{
/***
http://trac.tiddlywiki.org/ticket/444 - CLOSED:FIXED - TW2.4.3 - http://trac.tiddlywiki.org/changeset/8367
When invoking a macro, this tweak makes the current containing tiddler object and DOM rendering location available as global variables (window.tiddler and window.place, respectively).  These globals can then be used within //computed macro parameters// to retrieve tiddler-relative and/or DOM-relative values or perform tiddler-specific side-effect functionality.
***/
//{{{
if (ver<2.43) {
window.coreTweaks_invokeMacro = window.invokeMacro;
window.invokeMacro = function(place,macro,params,wikifier,tiddler) {
	var here=story.findContainingTiddler(place);
	window.tiddler=here?store.getTiddler(here.getAttribute('tiddler')):tiddler;
	window.place=place;
	window.coreTweaks_invokeMacro.apply(this,arguments);
}
}
//}}}
// // }}}}}}
// // fixed in ~TW2.4.2:
// // {{block{
/***
!!!823 apply option values via paramifiers (e.g. #chk...and #txt...)
***/
// // {{groupbox small{
/***
http://trac.tiddlywiki.org/ticket/823 - CLOSED:FIXED - TW2.4.2 http://trac.tiddlywiki.org/changeset/7988
This tweak extends and ''//replaces//'' the core {{{invokeParamifier()}}} function to support use of ''option paramifiers'' that set TiddlyWiki option values on-the-fly, directly from a document URL.

If a paramifier begins with 'chk' (checkbox) or 'txt' (text field), it's value will be automatically stored in {{{config.options.*}}}, adding to or overriding any existing 'chk' or 'txt' option values that may have already been loaded from browser cookies and/or assigned by the TW core or plugin initialization functions using hard-coded default values.  Note: option values that have been overriden by paramifiers are only applied during the current document session, and are not //automatically// retained.  However, if you edit an overridden option value during that session, then the modified value is, of course, saved in a browser cookie, as usual.
***/
//{{{
if (ver<2.42) {
function invokeParamifier(params,handler)
{
	if(!params || params.length == undefined || params.length <= 1)
		return;
	for(var t=1; t<params.length; t++) {
		var p = config.paramifiers[params[t].name];
		if(p && p[handler] instanceof Function)
			p[handler](params[t].value);
		else { // not a paramifier with handler()... check for an 'option' prefix
			var h=config.optionHandlers[params[t].name.substr(0,3)];
			if (h && h.set instanceof Function)
				h.set(params[t].name,params[t].value);
		}
	}
}
}
//}}}
// // }}}}}}
// // open tickets:
// // {{block{
/***
!!!608/609/610 toolbars - toggles, separators and transclusion
***/
// // {{groupbox small{
/***
http://trac.tiddlywiki.org/ticket/608 - OPEN (more/less toggle)
http://trac.tiddlywiki.org/ticket/609 - OPEN (separators)
http://trac.tiddlywiki.org/ticket/610 - OPEN (wikify tiddler/slice/section content)

This combination tweak extends the """<<toolbar>>""" macro to add use of '<' to insert a 'less' menu command (the opposite of '>' == 'more'), as well as use of '*' to insert linebreaks and "!" to insert a vertical line separator between toolbar items.  In addition, this tweak add the ability to use references to tiddlernames, slices, or sections and render their content inline within the toolbar, allowing easy creation of new toolbar commands using TW content (such as macros, links, inline scripts, etc.)

To produce a one-line style, with "less" at the end, use
| ViewToolbar| foo bar baz > yabba dabba doo < |
or to use a two-line style with more/less toggle:
| ViewToolbar| foo bar baz > < * yabba dabba doo |
***/
//{{{
merge(config.macros.toolbar,{
	moreLabel: 'more▼',
	morePrompt: 'Show additional commands',
	lessLabel: '◄less',
	lessPrompt: 'Hide additional commands',
	separator: '|'
});
config.macros.toolbar.onClickMore = function(ev) {
	var e = this.nextSibling;
	e.style.display = 'inline'; // show menu
	this.style.display = 'none'; // hide button
	return false;
};
config.macros.toolbar.onClickLess = function(ev) {
	var e = this.parentNode;
	var m = e.previousSibling;
	e.style.display = 'none'; // hide menu
	m.style.display = 'inline'; // show button
	return false;
};
config.macros.toolbar.handler = function(place,macroName,params,wikifier,paramString,tiddler) {
	for(var t=0; t<params.length; t++) {
		var c = params[t];
		switch(c) {
			case '!':  // ELS - SEPARATOR (added)
				createTiddlyText(place,this.separator);
				break;
			case '*':  // ELS - LINEBREAK (added)
				createTiddlyElement(place,'BR');
				break;
			case '<': // ELS - LESS COMMAND (added)
				var btn = createTiddlyButton(place,
					this.lessLabel,this.lessPrompt,config.macros.toolbar.onClickLess,'moreCommand');
				break;
			case '>':
				var btn = createTiddlyButton(place,
					this.moreLabel,this.morePrompt,config.macros.toolbar.onClickMore,'moreCommand');
				var e = createTiddlyElement(place,'span',null,'moreCommand');
				e.style.display = 'none';
				place = e;
				break;
			default:
				var theClass = '';
				switch(c.substr(0,1)) {
					case '+':
						theClass = 'defaultCommand';
						c = c.substr(1);
						break;
					case '-':
						theClass = 'cancelCommand';
						c = c.substr(1);
						break;
				}
				if(c in config.commands)

					this.createCommand(place,c,tiddler,theClass);
				else { // ELS - WIKIFY TIDDLER/SLICE/SECTION (added)
					if (c.substr(0,1)=='~') c=c.substr(1); // ignore leading ~
					var txt=store.getTiddlerText(c);
					if (txt) {
						// trim any leading/trailing newlines
						txt=txt.replace(/^\n*/,'').replace(/\n*$/,'');
						// trim PRE format wrapper if any
						txt=txt.replace(/^\{\{\{\n/,'').replace(/\n\}\}\}$/,'');
						// render content into toolbar
						wikify(txt,createTiddlyElement(place,'span'),null,tiddler);
					}
				} // ELS - end WIKIFY CONTENT
				break;
		}
	}
};
//}}}
// // }}}}}}// // {{block{
/***
!!!529 IE fixup - case-sensitive element lookup of tiddler elements
***/
// // {{groupbox small{
/***
http://trac.tiddlywiki.org/ticket/529 - OPEN
This tweak hijacks the standard browser function, document.getElementById(), to work-around the case-INsensitivity error in Internet Explorer (all versions up to and including IE7) //''Note: This tweak is only applied when using IE, and only for lookups of rendered tiddler elements within the containing 'tiddlerDisplay' element.''//
***/
//{{{
if (config.browser.isIE) {
document.coreTweaks_coreGetElementById=document.getElementById;
document.getElementById=function(id) {
	var e=document.coreTweaks_coreGetElementById(id);
	if (!e || !e.parentNode || e.parentNode.id!='tiddlerDisplay') return e;
	for (var i=0; i<e.parentNode.childNodes.length; i++)
		if (id==e.parentNode.childNodes[i].id) return e.parentNode.childNodes[i];
	return null;
};
}
//}}}
// // }}}}}}// // {{block{
/***
!!!890 add conditional test to """<<tiddler>>""" macro
***/
// // {{groupbox small{
/***
http://trac.tiddlywiki.org/ticket/890 - OPEN
This tweak extends the {{{<<tiddler>>}}} macro syntax so you can include a javascript-based //test expression// to determine if the tiddler transclusion should be performed:
{{{
<<tiddler TiddlerName if:{{...}} with: param param etc.>>
}}}
If the test is ''true'', then the tiddler is transcluded as usual.  If the test is ''false'', then the transclusion is skipped and //no output is produced//.
***/
//{{{
config.macros.tiddler.if_handler = config.macros.tiddler.handler;
config.macros.tiddler.handler = function(place,macroName,params,wikifier,paramString,tiddler)
{
	params = paramString.parseParams('name',null,true,false,true);
	if (!getParam(params,'if',true)) return;
	this.if_handler.apply(this,arguments);
};
//}}}
// // }}}}}}// // {{block{
/***
!!!831 backslash-quoting for embedding newlines in 'line-mode' formats
***/
// // {{groupbox small{
/***
http://trac.tiddlywiki.org/ticket/831 - OPEN
This tweak pre-processes source content to convert 'double-backslash-newline' into {{{<br>}}} before wikify(), so that literal newlines can be embedded in line-mode wiki syntax (e.g., tables, bullets, etc.)
***/
//{{{
window.coreWikify = wikify;
window.wikify = function(source,output,highlightRegExp,tiddler)
{
	if (source) arguments[0]=source.replace(/\\\\\n/mg,'<br>');
	coreWikify.apply(this,arguments);
}
//}}}
// // }}}}}}// // {{block{
/***
!!!683 FireFox3 Import bug: 'browse' button replacement
***/
// // {{groupbox small{
/***
http://trac.tiddlywiki.org/ticket/683 - OPEN
The web standard 'type=file' input control that has been used as a local path/file picker for TiddlyWiki no longer works as expected in FireFox3, which has, for security reasons, limited javascript access to this control so that *no* local filesystem path information can be revealed, even when it is intentional and necessary, as it is with TiddlyWiki.  This tweak provides alternative HTML source that patches the backstage import panel.  It replaces the 'type=file' input control with a text+button combination of controls that invokes a system-native secure 'file-chooser' dialog box to provide TiddlyWiki with access to a complete path+filename so that TW functions properly locate user-selected local files.
>Note: ''This tweak also requires http://trac.tiddlywiki.org/ticket/604 - cross-platform askForFilename()''
***/
//{{{
if (window.Components) {
	var fixhtml='<input name="txtBrowse" style="width:30em"><input type="button" value="..."'
		+' onClick="window.browseForFilename(this.previousSibling,true)">';
	var cmi=config.macros.importTiddlers;
	cmi.step1Html=cmi.step1Html.replace(/<input type='file' size=50 name='txtBrowse'>/,fixhtml);
}

merge(config.messages,{selectFile:'Please enter or select a file'}); // ready for I18N translation

window.browseForFilename=function(target,mustExist) { // note: both params are optional
	var msg=config.messages.selectFile;
	if (target && target.title) msg=target.title; // use target field tooltip (if any) as dialog prompt text
	// get local path for current document
	var path=getLocalPath(document.location.href);
	var p=path.lastIndexOf('/'); if (p==-1) p=path.lastIndexOf('\\'); // Unix or Windows
	if (p!=-1) path=path.substr(0,p+1); // remove filename, leave trailing slash
	var file=''
	var result=window.askForFilename(msg,path,file,mustExist); // requires #604
	if (target && result.length) // set target field and trigger handling
		{ target.value=result; target.onchange(); }
	return result;
}
//}}}
// // }}}}}}// // {{block{
/***
!!!604 cross-platform askForFilename()
***/
// // {{groupbox small{
/***
http://trac.tiddlywiki.org/ticket/604 - OPEN
invokes a system-native secure 'file-chooser' dialog box to provide TiddlyWiki with access to a complete path+filename so that TW functions properly locate user-selected local files.
***/
//{{{
window.askForFilename=function(msg,path,file,mustExist) {
	var r = window.mozAskForFilename(msg,path,file,mustExist);
	if(r===null || r===false)
		r = window.ieAskForFilename(msg,path,file,mustExist);
	if(r===null || r===false)
		r = window.javaAskForFilename(msg,path,file,mustExist);
	if(r===null || r===false)
		r = prompt(msg,path+file);
	return r||'';
}

window.mozAskForFilename=function(msg,path,file,mustExist) {
	if(!window.Components) return false;
	try {
		netscape.security.PrivilegeManager.enablePrivilege('UniversalXPConnect');
		var nsIFilePicker = window.Components.interfaces.nsIFilePicker;
		var picker = Components.classes['@mozilla.org/filepicker;1'].createInstance(nsIFilePicker);
		picker.init(window, msg, mustExist?nsIFilePicker.modeOpen:nsIFilePicker.modeSave);
		var thispath = Components.classes['@mozilla.org/file/local;1'].createInstance(Components.interfaces.nsILocalFile);
		thispath.initWithPath(path);
		picker.displayDirectory=thispath;
		picker.defaultExtension='html';
		picker.defaultString=file;
		picker.appendFilters(nsIFilePicker.filterAll|nsIFilePicker.filterText|nsIFilePicker.filterHTML);
		if (picker.show()!=nsIFilePicker.returnCancel)
			var result=picker.file.path;
	}
	catch(ex) { displayMessage(ex.toString()); }
	return result;
}

window.ieAskForFilename=function(msg,path,file,mustExist) {
	if(!config.browser.isIE) return false;
	try {
		var s = new ActiveXObject('UserAccounts.CommonDialog');
		s.Filter='All files|*.*|Text files|*.txt|HTML files|*.htm;*.html|';
		s.FilterIndex=3; // default to HTML files;
		s.InitialDir=path;
		s.FileName=file;
		return s.showOpen()?s.FileName:'';
	}
	catch(ex) { displayMessage(ex.toString()); }
	return result;
}

window.javaAskForFilename=function(msg,path,file,mustExist) {
	if(!document.applets['TiddlySaver']) return false;
	// TBD: implement java-based askFile(...) function
	try { return document.applets['TiddlySaver'].askFile(msg,path,file,mustExist); }
	catch(ex) { displayMessage(ex.toString()); }
}
//}}}
// // }}}}}}// // {{block{
/***
!!!657 wrap tabs onto multiple lines
***/
// // {{groupbox small{
/***
http://trac.tiddlywiki.org/ticket/657 - OPEN
This tweak inserts an extra space element following each tab, allowing them to wrap onto multiple lines if needed.
***/
//{{{
config.macros.tabs.handler = function(place,macroName,params)
{
	var cookie = params[0];
	var numTabs = (params.length-1)/3;
	var wrapper = createTiddlyElement(null,'div',null,'tabsetWrapper ' + cookie);
	var tabset = createTiddlyElement(wrapper,'div',null,'tabset');
	tabset.setAttribute('cookie',cookie);
	var validTab = false;
	for(var t=0; t<numTabs; t++) {
		var label = params[t*3+1];
		var prompt = params[t*3+2];
		var content = params[t*3+3];
		var tab = createTiddlyButton(tabset,label,prompt,this.onClickTab,'tab tabUnselected');
		createTiddlyElement(tab,'span',null,null,' ',{style:'font-size:0pt;line-height:0px'}); // ELS
		tab.setAttribute('tab',label);
		tab.setAttribute('content',content);
		tab.title = prompt;
		if(config.options[cookie] == label)
			validTab = true;
	}
	if(!validTab)
		config.options[cookie] = params[1];
	place.appendChild(wrapper);
	this.switchTab(tabset,config.options[cookie]);
};
//}}}
// // }}}}}}// // {{block{
/***
!!!628 hide 'no such macro' errors
***/
// // {{groupbox small{
/***
http://trac.tiddlywiki.org/ticket/628 - OPEN
When invoking a macro that is not defined, this tweak prevents the display of the 'error in macro... no such macro' message.  This is useful when rendering tiddler content or templates that reference macros that are defined by //optional// plugins that have not been installed in the current document.

<<option chkHideMissingMacros>> hide 'no such macro' error messages
***/
//{{{
if (config.options.chkHideMissingMacros===undefined)
	config.options.chkHideMissingMacros=false;

window.coreTweaks_missingMacro_invokeMacro = window.invokeMacro;
window.invokeMacro = function(place,macro,params,wikifier,tiddler) {
	if (!config.macros[macro] || !config.macros[macro].handler)
		if (config.options.chkHideMissingMacros) return;
	window.coreTweaks_missingMacro_invokeMacro.apply(this,arguments);
}
//}}}
// // }}}}}}
// // <<foldHeadings>><<tiddler HideTiddlerTags>><<tiddler HideTiddlerSubtitle>><<tiddler HideTiddlerSubtitle with: TiddlerTitle>>

<html><div style="margin-left:25px; line-height: 1.5;">
*[[Definitionsmenge]]
*[[Drachenviereck]]
*[[Dreieck]]
*[[Durchstoßpunkt]]
*[[Differenzenquotient]]
*[[Differenzialquotient]]
*[[Differenzierbarkeit]]
</div></html>

<<tiddler HideTiddlerSubtitle>>
<html>Die Definitionsmenge \(\mathrm{D_f}\) einer [[Funktion]] $\mathrm{f}$ ist die Menge aller Werte $\mathrm{x}$, die man in die Funktion einsetzen darf.
Wenn keine Definitionsmenge angegeben ist, so darf man alle $\mathrm{x}$ aus den reellen Zahlen einsetzen, die nicht Definitionslücke von $\mathrm{f}$ sind. Hier spricht man von der maximalen Definitionsmenge. </html>

<<tiddler HideTiddlerSubtitle>>
<html><img  width="274" height="184" border="0" align="right" hspace="0" style="padding:0 0 20pt 20pt"; src="img_glossar/Differenzenquotienten.png" alt="Differenzenquotienten" />Unter dem Differenzenquotienten einer reellen [[Funktion]] \(\mathrm{f:\,x\mapsto f(x)}\) an der Stelle \(\mathrm{x_0}\) ihrer [[Definitionsmenge]] versteht man den Ausdruck
$$\mathrm{\frac{f(x)-f(x_0)}{x-x_0}.}$$Er beschreibt das Verhältnis der Differenzen der Funktionswerte \(\mathrm{f(x)-f(x_0)}\) zur Differenz der Argumentwerte \(\mathrm{x-x_0}\).
<p>Geometrisch kann er als [[Steigung|Steigungsverhalten]] \(\mathrm{m_{\, s}}\) der Sekante durch die Graphenpunkte \(\mathrm{(x_0\, |\, f(x_0))}\) und \(\mathrm{(x\, |\, f(x))}\) interpretiert werden und kann somit zur Berechnung der Sekantensteigung bzw. der [[mittleren Änderungsrate|Mittlere Änderungsrate]] einer Funktion eingesetzt werden.
</html>

<<tiddler HideTiddlerSubtitle>>
\( \ \rightarrow \) [[Ableitung]]

<<tiddler HideTiddlerSubtitle>>
\( \ \rightarrow \) [[Ableitung]]

<<tiddler HideTiddlerSubtitle>>
<html><img width="135" vspace="0" hspace="0" border="0" align="right" height="193"  alt="Drachenviereck.png" src="img_glossar/Drachenviereck.png" />Ein Drachenviereck ist ein Viereck, bei dem je zwei aneinanderliegende Seiten gleich lang sind.
Für ein Drachenviereck $\mathrm{ABCD}$, wie es in der Skizze abgebildet ist, gilt:
<p>*Die Diagonale $\mathrm{e}$ ist Symmetrieachse und halbiert die Diagonale $\mathrm{f}$.
<p>*Die Innenwinkelsumme beträgt 360°.
<p>*Die Winkel bei $\mathrm{B}$ und $\mathrm{D}$ sind gleich groß.
<p>*Die Winkel bei $\mathrm{A}$ und $\mathrm{C}$ werden durch die Diagonale $\mathrm{e}$ halbiert.
<p>*Der Flächeninhalt berechnet sich zu:
<p style="margin-top:-5pt";>\(\mathrm{ \hspace{8mm} A_{Dr} =  \cfrac{{\Large\mid}\vec{AC}{\Large\mid}  \cdot {\Large\mid} \vec{BD}{\Large\mid} }{2}  =  \cfrac{e \cdot f}2} \)
<p>Spezialfälle des Drachenvierecks sind [[Raute]] und [[Quadrat]].
</html>

<<tiddler HideTiddlerSubtitle>>
<html><img width="135" height="96" vspace="0" hspace="20" border="0" align="right" style="padding-right: 80pt;" src="img_glossar/Dreieck.png" alt="Dreieck" /> Für das Dreieck $\mathrm{ABC}$, wie es in der Skizze abgebildet ist, gilt:
<p>*Die Innenwinkelsumme beträgt 180°.
<p>*Der Flächeninhalt lässt sich mithilfe des [[Vektorprodukts|Vektorprodukt]] wie folgt berechnen:
<p style="margin-top: -5px;">$$\mathrm{ A_D = \cfrac{1}{2} \cdot {\Large\mid} \vec{AB} \times \vec{AC}{\Large\mid}}$$
<p>*Der Ortsvektor des [[Schwerpunktes|Schwerpunkt eines Dreiecks]] $\mathrm{S}$ ergibt sich aus:
<p style="margin-top: -5px;">$$\mathrm{\vec S = \cfrac13 \cdot \left( \vec A +\vec B + \vec C \right) }$$
<p>Ist einer der drei Innenwinkel gleich 90°, so heißt das Dreieck rechtwinklig. Die dem rechten Winkel gegenüberliegende Seite wird Hypotenuse genannt, die anderen beiden Seiten heißen Katheten.
<p>Sind zwei Seiten des Dreiecks gleich lang, so nennt man das Dreieck gleichschenklig. Die dritte Seite heißt Basis; die beiden Basiswinkel sind gleich groß.
<p>Ein Dreieck, bei dem alle drei Seiten die gleiche Länge haben, heißt gleichseitig. Im gleichseitigen Dreieck sind alle Winkel gleich groß, nämlich gleich 60°.
</html>

<<tiddler HideTiddlerSubtitle>>
<html>Unter einem Durchstoßpunkt versteht man den [[Schnittpunkt einer Geraden mit einer Ebene|Schnittpunkt von Gerade und Ebene]].
<p>Spricht man von den Durchstoßpunkten einer [[Geraden|Gerade]], so sind damit die Schnittpunkte dieser Geraden mit den Koordinatenebenen gemeint.
<p>Unter den Durchstoßpunkten einer [[Ebene]] hingegen versteht man die Schnittpunkte der Koordinatenachsen mit dieser Ebene. Die Durchstoßpunkte einer Ebene kann man direkt aus einer speziellen Koordinatenform der [[Ebenengleichung]], der sogenannten [[Achsenabschnittsform]], ablesen.
<p>Man nennt die Durchstoßpunkte von Geraden und Ebenen auch Spurpunkte.
<p>Für eine allgemeine Anleitung zur Bestimmung von Durchstoßpunkten sei auf den Eintrag [[Schnittpunkt von Gerade und Ebene]] verwiesen.
</html>

<html><div style="margin-left:25px; line-height: 1.5;">
*[[Ebene]]
*[[Ebenengleichung]]
*[[Einheitsvektor]]
*[[Elementarereignis]]
*[[Entfernung zweier Punkte]]
*[[Ereignis]]
*[[Ereignismenge]]
*[[Ergebnis]]
*[[Ergebnismenge]]
*[[Erwartungswert]]
*[[Exponentialfunktion]]
*[[Exponentielles Wachstum und exponentieller Zerfall]]
*[[Extremstellen]]

</div></html>

<<tiddler HideTiddlerSubtitle>>
<html>Eine Ebene ist ein geometrisches Objekt, das eindeutig festgelegt ist durch drei Punkte, die nicht auf einer [[Geraden|Gerade]] liegen. Mathematisch kann eine Ebene durch eine Gleichung beschrieben werden, die genau von allen Punkten der Ebene erfüllt wird.

\( \ \rightarrow \) [[Ebenengleichung]]
</html>

<<tiddler HideTiddlerSubtitle>>
<html>Eine [[Ebene]] kann durch eine Gleichung beschrieben werden, deren Lösungsmenge genau die Punkte der Ebene umfasst. Bei der Darstellung von Ebenen durch Gleichungen unterscheidet man die Parameter- und die Normalenform.
<p>!!!Parameterform einer Ebene
Die Parameterform der Ebenengleichung stellt die Ebene $\mathrm{E}$ mithilfe eines beliebigen Punktes $\mathrm{A}$ der Ebene sowie zwei [[linear unabhängigen|Lineare (Un-)Abhängigkeit]] Spannvektoren \(\mathrm{ \vec v }\) und \(\mathrm{ \vec w }\) dar:
<p>\(\mathrm{\hspace{5em} E: \ \ \vec X  = \vec A  +  \lambda  \cdot  \vec v  + \mu \cdot \vec w \ }\) wobei \(\mathrm{ \ \vec v &ne;  r \cdot \vec w \ }\) und \(\mathrm{ \ \lambda, \ \mu \in\mathbb R}\)
<p>Sind drei Punkte $\mathrm{A}$, $\mathrm{B}$ und $\mathrm{C}$ der Ebene $\mathrm{E}$ bekannt, die zudem nicht auf einer [[Geraden|Gerade]] liegen, so kann man $\mathrm{A}$ als Aufpunkt und die beiden Verbindungsvektoren von $\mathrm{A}$ und $\mathrm{B}$ bzw. $\mathrm{A}$ und $\mathrm{C}$ als Spannvektoren verwenden:
<p>\(\mathrm{\hspace{5em} E: \ \ \vec X = \vec A + \lambda \cdot  \vec{AB}  + \mu \cdot  \vec{AC} \ }\) mit \(\mathrm{ \ \lambda, \ \mu \in \mathbb R}\)
<p>Der allgemeine Ebenenpunkt steht als Platzhalter für einen beliebigen Punkt der Ebene. Der [[Ortsvektor]] des allgemeinen Ebenenpunktes $\mathrm{G}$ der Ebene $\mathrm{E}$ mit Aufpunkt $\mathrm{A(a_1\, |\, a_2 \, |\, a_3)}$ und den Spannvektoren \(\mathrm{ \vec v }\) und \(\mathrm{ \vec w }\) lautet:
<p>\(\mathrm{ \hspace{5em} \vec G = \left( \begin{array}{l} \mathrm{a_1 + \lambda \cdot v_1 + \mu \cdot w_1} \\ \mathrm{ a_2 + \lambda \cdot v_2 + \mu \cdot w_2} \\ \mathrm{a_3 + \lambda \cdot v_3 + \mu \cdot w_3} \end{array} \right) \ }\) mit \(\mathrm{ \ \lambda , \ \mu \in\mathbb{R} }\)

<p>!!!Normalenform einer Ebene
Die Normalenform der Ebenengleichung stellt die Ebene $\mathrm{E}$ mithilfe ihres [[Normalenvektors|Normalenvektor]] \(\mathrm{ \vec n}\) dar. Sie lautet in Vektordarstellung mit einem Punkt $\mathrm{A}$ der Ebene $\mathrm{E}$:
<p>\(\mathrm{\hspace{5em} E: \ \ \vec n  \circ  (\vec X  -  \vec A)  = 0}\)
<p>bzw. ausmultipliziert:
<p>\(\mathrm{\hspace{5em} E: \ \ n_1 \cdot  x_1 +  n_2 \cdot x_2 +  n_3 \cdot  x_3  +  n_0  =  0}\)
<p>Die letzte Darstellung wird auch oft Normalenform in Koordinatendarstellung oder Koordinatengleichung genannt.
</html>

<<tiddler HideTiddlerSubtitle>>
<html>Ein Vektor mit Betrag 1 wird Einheitsvektor oder normierter Vektor genannt.
<p>Der Einheitsvektor \(\mathrm{ \vec a^{\,0}}\) zu einem Vektor \(\mathrm{ \vec a}\) ist der Vektor, der in dieselbe Richtung wie \(\mathrm{ \vec a}\) zeigt und den Betrag 1 hat:
<p style="margin-top:-5pt";>$$\mathrm{\vec a^{\, 0} = \cfrac{1}{\left|\,\vec a \,\right|} \cdot  \vec a }$$
</html>

<<tiddler HideTiddlerSubtitle>>
<html>Ein [[Ereignis]], das nur ein einziges Element beinhaltet, heißt Elementarereignis.
Die [[Mächtigkeit]] eines Elementarereignisses \(\mathrm{A}\) beträgt \(\mathrm{|\,A\,| = 1}\) und die [[Wahrscheinlichkeit]] \(\mathrm{P(A) = p}\), wobei \(\mathrm{0 \leq p \leq 1}\).

<p style="margin-top:-10px";>!!!Beispiel:
Beim fairen Würfelwurf ist $\mathrm{A =}$ „Es wird die 6 gewürfelt." $\mathrm{= \{6\}}$ ein Elementarereignis mit der Wahrscheinlichkeit \(\mathrm{ P(A) = \frac{1}{6} }\).
</html>

Diese Funktion aktiviert Animationen, wenn Sie einen Tiddler öffnen oder schließen.

<<tiddler HideTiddlerSubtitle>>
<html>Die Entfernung zweier Punkte \(\mathrm{A(a_1\, |\, a_2\, |\, a_3)}\) und \(\mathrm{B(b_1\, |\, b_2\, |\, b_3)}\) wird folgendermaßen berechnet:
<p>$$\mathrm{ d(A, \, B) = \sqrt{(a_1 - b_1)^2 + (a_2 - b_2)^2 + (a_3 - b_3)^2}}$$
</html>

<<tiddler HideTiddlerSubtitle>>
<html>Eine Teilmenge der [[Ergebnismenge]]  \(\mathrm{\Omega}\) heißt Ereignis. In der Mengenschreibweise gilt für jedes Ereignis \(\mathrm{A:\, A \subseteq \Omega}\)
<p>__Ab__g__renzun__g__ zum Er__g__ebnis:__
Ein [[Ergebnis]] ist ein Element der Ergebnismenge. Eine beliebige Teilmenge dieser Ergebnismenge heißt Ereignis. Ein Ereignis kann mehrere Ergebnisse beinhalten.

<p style="margin-top:-10px";>!!!Beispiel:
<p style="margin-top:-5px";>Beim Würfelwurf ist  \(\mathrm{A = \{1, 3, 5\}}\) (in Worten: „Es wird eine ungerade Zahl gewürfelt") ein Ereignis.
<p>\( \ \rightarrow \) [[Sicheres Ereignis]]
\( \ \rightarrow \) [[Unmögliches Ereignis]]
\( \ \rightarrow \) [[Elementarereignis]]
\( \ \rightarrow \) [[Gegenereignis]]
\( \ \rightarrow \) [[Ereignismenge]]
</html>

<<tiddler HideTiddlerSubtitle>>
<html>Die Menge aller [[Ereignisse|Ereignis]] heißt Ereignismenge \(\mathcal{P(\Omega)}\).
Sie enthält immer die leere Menge \(\mathrm{\{\ \}}\) und die Ergebnismenge \(\mathrm{\Omega}\).
<p>Die [[Mächtigkeit]] der Ereignismenge berechnet sich folgendermaßen: \(\mathrm{|\,\mathcal{P}(\Omega)\,|=2^{\large\, |\,\Omega\,|}}\)
<p>__Ab__g__renzun__g__ zur Er__g__ebnismen__g__e:__
Die [[Ergebnismenge]] \(\mathrm{\Omega}\) beinhaltet alle möglichen Einzelergebnisse \(\mathrm{\omega}\). Aus den einzelnen [[Ergebnissen|Ergebnis]] kann man beliebige Teilmengen (Ereignisse) mit unterschiedlichen Mächtigkeiten erstellen. Die Menge dieser Teilmengen heißt Ereignismenge.

<p style="margin-top:-10px";>!!!Beispiel:
<div style="line-height: 2;">Beim Wurf eines Tetraeders mit den Seiten 1, 2, 3 und 4 lautet die Ereignismenge:
\(\mathrm{\mathcal{P}(\Omega) = \{ \{\ \}, \{1\}, \{2\}, \{3\}, \{4\}, \{1,2\}, \{1,3\}, \{1,4\}, \{2,3\}, \{2,4\}, \{3,4\}, \{1,2,3\}, \{1,2,4\}, \{1,3,4\}, \{2,3,4\}, \Omega \}}\)
Für die Mächtigkeit gilt: \(\mathrm{|\,\mathcal{P}(\Omega)\,| = 2^4 = 16}\)</div>
</html>

<<tiddler HideTiddlerSubtitle>>
<html>Eine Teilmenge der [[Ergebnismenge]]  \(\mathrm{\Omega}\) heißt Ereignis. In der Mengenschreibweise gilt für jedes Ereignis \(\mathrm{A:\, A \subseteq \Omega}\)
<p>__Ab__g__renzun__g__ zum Er__g__ebnis:__
Ein Ergebnis ist ein Element der Ergebnismenge. Eine beliebige Teilmenge dieser Ergebnismenge heißt [[Ereignis]]. Ein Ereignis kann mehrere Ergebnisse beinhalten.

<p style="margin-top:-10px";>!!!Beispiel:
Beim Würfelwurf ist  \(\mathrm{A = \{1, 3, 5\}}\) (in Worten: „Es wird eine ungerade Zahl gewürfelt") ein Ereignis.
<p>\( \ \rightarrow \) [[Sicheres Ereignis]]
\( \ \rightarrow \) [[Unmögliches Ereignis]]
\( \ \rightarrow \) [[Elementarereignis]]
\( \ \rightarrow \) [[Gegenereignis]]
\( \ \rightarrow \) [[Ereignismenge]]
</html>

<<tiddler HideTiddlerSubtitle>>
<html>Alle [[Ergebnisse|Ergebnis]] eines [[Zufallsexperiments|Zufallsexperiment]] bilden die Ergebnismenge \(\mathrm{\Omega}\).
In der Mengenschreibweise gilt für die Ergebnismenge: \(\mathrm{\Omega = \{\omega_1, \omega_2, \cdots,\omega_n\}}\)
<p>__Ab__g__renzun__g__ zur Erei__g__nismen__g__e:__
Aus den einzelnen Ergebnissen kann man beliebige Teilmengen ([[Ereignisse|Ereignis]]) mit unterschiedlichen Mächtigkeiten erstellen. Die Menge dieser Teilmengen heißt [[Ereignismenge]].

<p style="margin-top:-10px";>!!!Beispiel:
Beim Wurf eines Tetraeders mit den Seiten 1, 2, 3 und 4 lautet die Ergebnismenge \(\mathrm{Ω = \{1, 2, 3, 4\}}\).
</html>

<<tiddler HideTiddlerSubtitle>>
<html>Der Wert, der sich bei mehrmaliger Wiederholung eines [[Zufallsexperiments|Zufallsexperiment]] als Mittelwert der [[Ergebnisse|Ergebnis]] stabilisiert, heißt Erwartungswert der [[Zufallsgröße]]. Er wird häufig mit dem griechischem Buchstaben \(\mathrm{\mu}\) bezeichnet. Man kann ihn als Summe der Produkte aller Ausprägungen mit ihren Einzelwahrscheinlichkeiten berechnen:
<p style="margin-top:-5pt";>$$\mathrm{E(Z) = \sum\limits_{i=1}^{n} \ z_{i} \cdot P(Z=z_{i})}$$
<p>Der Erwartungswert muss kein mögliches Ergebnis des Zufallsexperiments sein.

<p style="margin-top:-10px";>!!!Beispiel:
Beim Wurf eines fairen Würfels ergibt sich folgender Erwartungswert für die Zufallsgröße $\mathrm{Z}$ (Augenzahl eines Wurfes):
<p style="margin-top:-5px";>\(\mathrm{ E(Z) = 1  \cdot  P(Z=1)+ 2  \cdot  P(Z=2) + \cdots + 6  \cdot  P(Z=6) = 21  \cdot  \cfrac{1}{6} = 3,5 }\)
</html>

<<tiddler HideTiddlerSubtitle>>
<html>Eine [[Funktion]], bei der die Variable $\mathrm{x}$ im Exponenten steht, nennt man allgemeine Exponentialfunktion.
<p>Die Grundform lautet: $\mathrm{ f:\,x \mapsto a^x}$ mit $\mathrm{a \in \mathbb{R}^+ \, \backslash \, \{1\}}$

<p>!!!Natürliche Exponentialfunktion
Die wichtigste Exponentialfunktion ist die zur Basis $\mathrm e$ (Euler'sche Zahl).
<p>Grundform: $\mathrm{f:\,x \mapsto  e^x}$
<p>Für die Funktion lassen sich folgende Aussagen treffen:
<p style="margin-top:-5px";>*[[Definitionsmenge]]: $\mathrm{ D =\mathbb {R}}$
<p style="margin-top:-5px";>*[[Wertemenge]]: $\mathrm{ W=\mathbb{R}^+}$
<p style="margin-top:-5px";>*[[Nullstellen|Nullstelle]]: keine
<p>*Verhalten im Unendlichen: $\mathrm{ \underset{x\to\infty}{lim} \ e^x = \infty} \$ und $\mathrm{ \ \underset{x\to -\infty}{lim} \ e^x = 0}$
<p style="margin-top:-5px";>*[[Ableitung]]: $\mathrm{ f'(x) \, = \, e^x}$
<p style="margin-top:-5px";>*[[Stammfunktion]]: $\mathrm{ F(x) = e^x + C}$
<p style="margin-top:-5px";>*Die [[Umkehrfunktion|Umkehrbarkeit von Funktionen]] ist die natürliche [[Logarithmusfunktion]]: $\mathrm{ f^{-1}(x) \, = \, \ln x}$
<p><img width="309" height="304" vspace="0" hspace="20" border="0"  alt="Exponentialfunktion" src="img_glossar/Exponentialfunktion.png" />
</html>

<<tiddler HideTiddlerSubtitle>>
<html>Für viele in der Natur vorkommende Phänomene, wie das Wachstum von Pflanzen oder der Zerfall von radioaktiven Elementen, lassen sich in der Mathematik unter Verwendung von [[Exponentialfunktionen|Exponentialfunktion]] Modelle erstellen.

<p>!!!Exponentielles Wachstum (z.B. Vermehrung einer Bakterienkultur):
Bei exponentiellem Wachstum sind momentane Änderungsrate und aktueller Bestand direkt proportional. Der Bestand wächst immer weiter an, die Wachstumsfunktion steigt also ins Unendliche.
$$\mathrm{ N(x) = N_0 \cdot  e^{\large +k\cdot x}} \$$
Bedeutung der Parameter:
{{wachstum{
|width:5em;$\mathrm{N_0:}$ |Startwert für $\mathrm{x=0}$; $\mathrm{N_0>0}$|
|$\mathrm{x:}$ |Zeit ab einem bestimmten Startpunkt; $\mathrm{x\geq 0}$|
|$\mathrm{k:}$ |Wachstumskonstante; $\mathrm{k\geq 0}$|
|$\mathrm{N(x):}$ |Wert nach der Zeit $\mathrm{x}$|
}}}Die Verdopplungszeit $\mathrm{T_D}$, also der Zeitpunkt, zu dem sich der Anfangsbestand $\mathrm{N_0}$ verdoppelt hat, berechnet man folgendermaßen:
$$\mathrm{ T_D = \frac{ln2}k \ , \ \ k>0}$$

!!!Begrenztes exponentielles Wachstum (z.B. Wachstum eines Baumes):
Beim begrenzten exponentiellen Wachstum nähert sich der Bestand einem Zielwert an, ohne ihn zu überschreiten oder zu erreichen.
$$\mathrm{ N(x) = -N_0 \cdot  e^{\large -k\cdot x}+c} \$$
Bedeutung der Parameter:
{{wachstum{
|width:5em;$\mathrm{c:}$ |Zielwert (z.B. maximale Höhe eines Baumes); $\mathrm{c> 0}$|
|$\mathrm{c − N_0}:$ |Bestand zum Zeitpunkt $\mathrm{x = 0}$; $\mathrm{c>N_0>0}$|
|$\mathrm{x:}$ |Zeit ab einem bestimmten Startpunkt; $\mathrm{x\geq 0}$|
|$\mathrm{k:}$ |Wachstumskonstante; $\mathrm{k > 0}$|
|$\mathrm{N(x):}$ |Wert nach der Zeit $\mathrm{x}$|
}}}
!!!Exponentielle Abnahme (z.B. radioaktiver Zerfall):
<p style="margin-top:-5px";>Bei der exponentiellen Abnahme sinkt der Bestand von einem Anfangswert in Richtung 0, ohne jedoch ganz zu verschwinden.
$$\mathrm{ N(x) = N_0 \cdot  e^{\large -k\cdot x}} \$$
Bedeutung der Parameter:
{{wachstum{
|width:5em;$\mathrm{N_0:}$ |Startwert für $\mathrm{x=0}$; $\mathrm{N_0>0}$|
|$\mathrm{x:}$ |Zeit ab einem bestimmten Startpunkt; $\mathrm{x\geq 0}$|
|$\mathrm{k:}$ |Zerfallskonstante; $\mathrm{k > 0}$|
|$\mathrm{N(x):}$ |Wert nach der Zeit $\mathrm{x}$|
}}}Die Halbwertszeit $\mathrm{T_H}$, also der Zeitpunkt, zu dem noch die Hälfte des Anfangsbestandes $\mathrm{N_0}$ vorhanden ist, berechnet man folgendermaßen:
$$\mathrm{ T_H = \frac{ln2}k \ , \ \ k>0}$$
</html>

<<tiddler HideTiddlerSubtitle>>
<html><img width="230" height="196" vspace="0" hspace="30" border="0" src="img_glossar/Extremstellen2.png" alt="Extremstellen2_940021" align="right"/>Unter dem Oberbegriff Extremstellen fasst man Maximum- bzw. Minimumstellen zusammen. Allgemein unterscheidet man zwischen relativen ﻿(auch: lokalen) und absoluten (auch: globalen) Extremstellen.
<p>Eine [[Funktion]] $\mathrm{f}$ besitzt ein relatives (auch: lokales) Maximum an der Stelle $\mathrm{x_0}$, wenn in einer Umgebung von $\mathrm{x_0}$ alle Funktionswerte kleiner oder gleich dem Funktionswert $\mathrm{f(x_0)}$ sind. In diesem Falle ist der Punkt $\mathrm{(x_0 \, | \, f(x_0))}$ Hochpunkt der Funktion $\mathrm{f}$.
<p>Eine Funktion f besitzt ein relatives ﻿(auch: lokales) Minimum an der Stelle $\mathrm{x_0}$, wenn in einer Umgebung von $\mathrm{x_0}$ alle Funktionswerte größer oder gleich dem Funktionswert $\mathrm{f(x_0)}$ sind. In diesem Falle ist der Punkt $\mathrm{(x_0 \, | \, f(x_0))}$ Tiefpunkt der Funktion $\mathrm{f}$.
<p>Ist ein relatives Maximum bzw. Minimum gleichzeitig der größte bzw. kleinste Wert einer Funktion, so spricht man von einem absoluten Maximum bzw. Minimum. Relative Extrema können somit absolute Extrema sein, müssen aber nicht (vgl. nebenstehende Abbildung).
<p>Bei Extremstellen liegen waagrechte [[Tangenten|Tangente]] vor, d.h., es gilt stets: $\mathrm{f'(x_0)=0}$

<p>!!!Ermittlung der Art von Extremstellen
Die Art von Extremstellen bestimmt man entweder mithilfe der 2. [[Ableitung]] oder mithilfe einer [[Monotoniebetrachtung|Monotonie]].
<p>''1. Möglichkeit: mithilfe der 2. Ableitung''
<p style="margin-top:-5px";>*$\mathrm{f'(x_0) = 0}$ und $\mathrm{f''(x_0) > 0 \ \ \ \Rightarrow \ \ \ f}$ hat an der Stelle $\mathrm{x_0}$ ein relatives Minimum.
<p style="margin-top:-5px";>*$\mathrm{f'(x_0) = 0}$ und $\mathrm{f''(x_0) < 0 \ \ \ \Rightarrow \ \ \ f}$ hat an der Stelle $\mathrm{x_0}$ ein relatives Maximum.
<p>''2. Möglichkeit: mithilfe einer Monotoniebetrachtung''
<p style="margin-top:-5px";>*Das Vorzeichen von $\mathrm{f'(x)}$ wechselt an der Stelle $\mathrm{x_0}$ von $\mathrm{-}$ nach $\mathrm{+ \ \ \ \Rightarrow \ \ \ f}$ hat an der Stelle $\mathrm{x_0}$ ein relatives Minimum.
<p style="margin-top:-5px";>*Das Vorzeichen von $\mathrm{f'(x)}$ wechselt an der Stelle $\mathrm{x_0}$ von $\mathrm{+}$ nach $\mathrm{- \ \ \ \Rightarrow \ \ \ f}$ hat an der Stelle $\mathrm{x_0}$ ein relatives Maximum.
<p><img width="230" height="196" vspace="0" hspace="30" border="0" src="img_glossar/Extremstellen1.png" alt="Extremstellen1_940021" />
</html>

<html><div style="margin-left:25px; line-height: 1.5;">
*[[Fakultät]]
*[[Funktion]]

</div></html>

<<tiddler HideTiddlerSubtitle>>
<html>Die Fakultät von $\mathrm{n}$ (in Zeichen: $\mathrm{n!}$) beschreibt das Produkt der ganzen Zahlen von 1 bis $\mathrm{n}$:
$$\mathrm{n! = n \cdot (n - 1) \cdot (n - 2) \cdot \ \ldots \ \cdot 2 \cdot 1}$$
In der Stochastik berechnet man mithilfe der Fakultät Permutationsprobleme.

<p>!!!Beispiel:
Zehn Personen kann man auf 10$\mathrm{! =}$ 3 628 800 Möglichkeiten auf zehn Stühlen anordnen, da die erste Person zehn freie Stühle zur Auswahl hat, die zweite Person noch neun, usw.
</html>

[[SideBarOptions]]
[[PageTemplate]]
[[ToolbarCommands]]

<<tiddler HideTiddlerSubtitle>>
<html>Eine Funktion ist eine eindeutige Zuordnung, die jedem Element aus der [[Definitionsmenge]] $\mathrm{D}$ genau ein Element aus der [[Wertemenge]] $\mathrm{W}$ zuordnet.
<p>Für jede Funktion $\mathrm{f}$ mit $\mathrm{x \in D}$ und $\mathrm{y \in W}$ gibt es zwei verschiedene Schreibweisen:
<p style="margin-top:-5px";>*Schreibweise als Zuordnungsvorschrift: $\mathrm{f: \ x \mapsto y} \ $ bzw. $ \ \mathrm{f: \; x \mapsto f(x)}$
<p style="margin-top:-5px";>*Schreibweise als Funktionsgleichung: $\mathrm{y = f(x)}$
</html>

<html><div style="margin-left:25px; line-height: 1.5;">
*[[Ganzrationale Funktion]]
*[[Gebrochen-rationale Funktion]]
*[[Gegenereignis]]
*[[Gegenseitige Lage von Gerade und Ebene]]
*[[Gegenseitige Lage zweier Ebenen]]
*[[Gegenseitige Lage zweier Geraden]]
*[[Gegenvektor]]
*[[Gerade]]
*[[Geradengleichung]]
*[[Gesetz der großen Zahlen]]
*[[Grenzwert]]

</div></html>

<<tiddler HideTiddlerSubtitle>>
<html>Eine [[Funktion]], deren Funktionsterm ein Polynom ist, nennt man ganzrational.
<p>Allgemein kann man ganzrationale Funktionen folgendermaßen definieren:
$$\mathrm{f:\, x \ \mapsto \ a_nx^n + a_{n-1}x^{n-1} + \ldots + a_2x^2 + a_1x + a_0}$$
<p style="margin-top:-5px; margin-left:5em;">mit $\mathrm{a_n &ne; 0; \ \ \ a_i\in\mathbb{R}; \  i = 0 \ \ldots \ n -1 }$
<p>Für die Funktion $\mathrm{f}$ lassen sich folgende Aussagen treffen.
<p style="margin-top:-5px";>*[[Definitionsmenge]]: $\mathrm{ D = \mathbb R}$
<p style="margin-top:-5px";>*[[Ableitung]]: $\mathrm{ f'(x) = n \cdot  a_n x^{n-1} + (n  - 1) \cdot a_{n-1}x^{n-2} + \ldots +2  \cdot a_2x + a_1}$
<p style="margin-top:-5px";>*[[Stammfunktion]]: $\mathrm{ F(x) = \frac{\large a_n}{\large n + 1}x^{n + 1} + \frac{\large a_{n-1}}{\large n}x^{n} + \ldots + \frac{\large a_2}{\large 3}x^3 +  \frac{\large a_1}{\large 2}x^2 + a_0x + C}$
<p>Die [[Nullstellen|Nullstelle]] einer ganzrationalen Funktion lassen sich unter anderem mithilfe der [[Polynomdivision]] ermitteln.
<p><img width="329" height="329" vspace="0" hspace="20" border="0"  alt="Ganzrationale Funktion" src="img_glossar/Ganzrationale_Funktion.png" />
</html>

<<tiddler HideTiddlerSubtitle>>
<html>Eine gebrochen-rationale Funktion f ist der Quotient zweier ganzrationaler Funktionen g und h. Es gilt:
$$\mathrm{f:\, x \ \mapsto \  \cfrac{g(x)}{h(x)}}$$
<p>Für die Funktion f lassen sich folgende Aussagen treffen:
<p style="margin-top:-5px";>*Definitionsmenge: $\mathrm{D = \mathbb{R} \ \backslash \ \{x \, | \, x \ ist \ Nullstelle \ von \ h(x)\}}$
<p style="margin-top:-5px";>*Nullstellen: Nullstellen von $\mathrm{g(x)}$, wenn sie nicht gleichzeitig Nullstellen von $\mathrm{h(x)}$ sind
<p style="margin-top:-5px";>*Definitionslücken: Nullstellen des Nenners $\mathrm{h(x)}$
<p style="margin-top:-5px";>*Polstellen: Nullstellen des Nenners $\mathrm{h(x)}$, wenn diese nicht gleichzeitig Nullstellen des Zählers $\mathrm{g(x)}$ sind (nach vollständigem Kürzen von $\mathrm{f(x)}$)
<p>Die Ableitung von gebrochen-rationalen Funktionen kann mithilfe der [[Quotientenregel|Ableitungsregeln]] berechnet werden.
<p>An ihren [[Polstellen|Polstelle]] besitzt eine gebrochen-rationale Funktion senkrechte [[Asymptoten|Asymptote]]. Falls $\mathrm{a}$ eine Polstelle ist, so lautet die Gleichung der senkrechten Asymptote $\mathrm{x = a}$.
<p><img vspace="0" hspace="20" border="0"  alt="Gebrochen-rationale Funktion" src="img_glossar/Gebrochen-rationale-Funktion.png" />
</html>

<<tiddler HideTiddlerSubtitle>>
<html>Das Gegenereignis $\mathrm{\overline{A}}$ ist genau das [[Ereignis]], das alle [[Ergebnisse|Ergebnis]] enthält, die nicht im Ereignis $\mathrm{A}$ liegen.
In Mengenschreibweise bedeutet dies: $\mathrm{\overline{A} = \Omega \, \backslash \, A}$, wobei $\mathrm{\Omega}$ die [[Ergebnismenge]] darstellt.
<p>Für die [[Wahrscheinlichkeit]] des Gegenereignisses gilt:
<p style="margin-top:-5px";>$$\mathrm{\overline{A} = 1 − P(A)}$$

<p style="margin-top:-15px";>!!!Beispiel:
Beim Würfelwurf ist $\mathrm{\overline{A} = \{1, 3, 5\}}$ (in Worten: „Es wird eine ungerade Zahl gewürfelt") das Gegenereignis von $\mathrm{A = \{2, 4, 6\}}$ (in Worten: „Es wird eine gerade Zahl gewürfelt").
</html>

<<tiddler HideTiddlerSubtitle>>
<html>Eine [[Gerade]] kann im Raum
<p style="margin-top:-5px";>*eine [[Ebene]] schneiden,
<p style="margin-top:-10px";>*[[parallel|Parallelität]] zu einer Ebene verlaufen,
<p style="margin-top:-10px";>*in einer Ebene liegen.
<p>Um die Lage einer Geraden und einer Ebene zueinander zu untersuchen, überprüft man den Richtungsvektor $\mathrm{\vec v}$ der Geraden und den [[Normalenvektor]] $\mathrm{\vec n}$ der Ebene auf [[Orthogonalität]]:
<p style="margin-top:-5px";>*Stehen $\mathrm{\vec v}$  und $\mathrm{\vec n}$  senkrecht aufeinander, so sind Gerade und Ebene parallel. Liegt zusätzlich ein beliebiger Punkt der Geraden auch in der Ebene, so liegt die Gerade vollständig in der Ebene. Andernfalls verläuft sie echt parallel zur Ebene.
<p style="margin-top:-5px";>*Sind $\mathrm{\vec v}$  und $\mathrm{\vec n}$  nicht orthogonal, so haben Gerade und Ebene einen [[Schnittpunkt]].
<p style="margin-top:-10px";>$ \hspace{2em} \rightarrow $ [[Schnittpunkt von Gerade und Ebene]]
</html>

<<tiddler HideTiddlerSubtitle>>
<html>Zwei [[Ebenen|Ebene]] im Raum können
<p style="margin-top:-5px";>*identisch sein,
<p style="margin-top:-10px";>*[[parallel|Parallelität]] sein,
<p style="margin-top:-10px";>*sich [[schneiden|Schnittpunkt]].
<p>Um die Lage zweier Ebenen zueinander zu untersuchen, überprüft man ihre [[Normalenvektoren|Normalenvektor]] auf [[lineare Unabhängigkeit|Lineare (Un-)Abhängigkeit]]:
<p style="margin-top:-5px";>*Sind die Normalenvektoren linear unabhängig, so schneiden sich die Ebenen in einer [[Geraden|Gerade]].
<p style="margin-top:-10px";>$ \hspace{2em} \rightarrow $ [[Schnittgerade]]
<p style="margin-top:-8px";>*Sind die Normalenvektoren linear abhängig, so sind die Ebenen entweder identisch oder echt parallel. Zwei Ebenen werden auf echte Parallelität überprüft, indem man einen beliebigen Punkt der einen Ebene in die [[Ebenengleichung]] der anderen einsetzt. Wenn der Punkt nicht in der Ebene enthalten ist, so sind die Ebenen echt parallel.
</html>

<<tiddler HideTiddlerSubtitle>>
<html>Zwei [[Geraden|Gerade]] im Raum können
<p style="margin-top:-5px";>*identisch sein,
<p style="margin-top:-10px";>*[[parallel|Parallelität]] sein,
<p style="margin-top:-10px";>*sich [[schneiden|Schnittpunkt]],
<p style="margin-top:-10px";>*windschief sein.
<p>Um die Lage zweier Geraden zueinander zu untersuchen, überprüft man zuerst die beiden Richtungsvektoren auf [[lineare Unabhängigkeit|Lineare (Un-)Abhängigkeit]]:
*Die Richtungsvektoren $\mathrm{\vec v}$ und $\mathrm{\vec w}$ der beiden Geraden sind linear abhängig, d. h.:
<p>$\hspace{5em}\mathrm{\vec v = \lambda \cdot \vec w}$ mit  $\mathrm{\lambda\in\mathbb R}$
<p style="margin-left:2em";>Dann sind die Geraden identisch oder echt parallel. Liegt zudem ein beliebiger Punkt der einen Geraden auch in der anderen Geraden, so sind die Geraden identisch; andernfalls verlaufen sie echt parallel.
<p>*Die Richtungsvektoren $\mathrm{\vec v}$ und $\mathrm{\vec w}$ der beiden Geraden sind linear unabhängig, d. h.:
<p>$\hspace{5em} \mathrm{ \vec v  &ne;  \lambda \cdot \vec w}$ mit $\mathrm{\lambda\in\mathbb R}$
<p style="margin-left:2em";>Dann sind die Geraden windschief oder haben einen Schnittpunkt. Dies wird überprüft, indem man den allgemeinen Geradenpunkt der einen Geraden in die [[Gleichung|Geradengleichung]] der anderen Geraden einsetzt. Ist das entstehende Gleichungssystem nicht lösbar, sind die Geraden windschief; andernfalls schneiden sie sich.
<p>$ \hspace{2em} \rightarrow $ [[Schnittpunkt zweier Geraden]]
</html>

<<tiddler HideTiddlerSubtitle>>
<html>Der Vektor $\mathrm{ -\vec v = \left( \begin{array}{lll} -v_1 \\ \mathrm{-v_2} \\ \mathrm{-v_3} \end{array} \right) }$ heißt Gegenvektor zum Vektor $\mathrm{ \vec v = \left( \begin{array}{lll} v_1 \\ \mathrm{v_2} \\ \mathrm{v_3} \end{array} \right) }$.
<p>Er hat dieselbe [[Länge|Länge eines Vektors]] wie $\mathrm{ \vec v }$, zeigt aber in die entgegengesetzte Richtung.
<p>Zudem gilt: $\mathrm{ \vec v + (-\vec v) =  \vec o }$
</html>

Wenn Sie [[RSS-Feed generieren|GenerateAnRssFeed]] aktivieren, speichert TiddlyWiki automatisch einen RSS-2.0-gültigen Feed, so bald Ihr TiddlyWiki gespeichert wird. Der Feed hat den gleichen Dateinamen wie das TiddlyWiki, lediglich jedoch mit der Endung '.xml'.

Die Grafik wurde in Geo Gebra als HTML exportiert und der Quellcode hier eingefügt:

$$f(x)=ax^2+bx+c$$
<html><head><title>GeoGebra Dynamisches Arbeitsblatt</title><meta http-equiv="Content-Type" content="text/html; charset=utf-8" /><meta name="generator" content="GeoGebra" /><style type="text/css"><!--body { font-family:Arial,Helvetica,sans-serif; margin-left:0px }--></style></head><body><table border="0" width="600"><tr><td><p></p>

<applet name="ggbApplet" code="geogebra.GeoGebraApplet" archive="geogebra.jar"
	codebase="ggb/"
	width="600" height="472">
	<param name="ggbBase64" value="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" />
	<param name="java_arguments" value="-Xmx1024m -Djnlp.packEnabled=true" />
		<param name="showResetIcon" value="false" />
	<param name="enableRightClick" value="false" />
	<param name="errorDialogsActive" value="true" />
	<param name="enableLabelDrags" value="false" />
	<param name="showMenuBar" value="false" />
	<param name="showToolBar" value="false" />
	<param name="showToolBarHelp" value="false" />
	<param name="showAlgebraInput" value="false" />
	<param name="useBrowserForJS" value="true" />
	<param name="allowRescaling" value="true" />
Das ist ein mit GeoGebra www.geogebra.org erstelltes Java-Applet. Möglicherweise ist Java auf Ihrem Computer nicht installiert; bitte besuchen Sie in diesem Fall www.java.com
</applet>
<p></p>
<p><span style="font-size:small">15 Mai 2013, erstellt mit <a href="http://www.geogebra.org/" target="_blank" >GeoGebra</a></span></p>
</td></tr>
</table><script type="text/javascript">
var ggbApplet = document.ggbApplet;
function ggbOnInit() {}
</script>
</body>
</html>

<<tiddler HideTiddlerSubtitle>>
<html>Eine Gerade ist ein geometrisches Objekt, das eindeutig festgelegt ist durch zwei Punkte. Mathematisch kann eine Gerade durch eine Gleichung beschrieben werden, die genau von allen Punkten der Geraden erfüllt wird.
<p>\( \ \rightarrow \) [[Geradengleichung]]
</html>

<<tiddler HideTiddlerSubtitle>>
<html>Eine [[Gerade]] kann durch eine Gleichung beschrieben werden, deren Lösungsmenge genau die Punkte der Geraden umfasst.
<p>Die Parametergleichung stellt eine Gerade $\mathrm{g}$ mithilfe eines beliebigen Punktes $\mathrm{A}$ der Geraden sowie eines Richtungsvektors $\mathrm{\vec w}$ dar:
$$\mathrm{ g: \ \ \vec X = \vec A + \lambda \cdot  \vec w \ \, ,\ \ \  \lambda\in\mathbb R}$$

Sind zwei Punkte $\mathrm{A}$ und $\mathrm{B}$ der Geraden bekannt, so kann man $\mathrm{A}$ als Aufpunkt und den [[Verbindungsvektor]] von $\mathrm{A}$ und $\mathrm{B}$ als Richtungsvektor verwenden:
$$\mathrm{ g: \ \ \vec X= \vec A + \lambda \cdot \vec{AB} \ \, ,\ \ \ \lambda\in\mathbb R}$$

Der allgemeine Geradenpunkt steht als Platzhalter für einen beliebigen Punkt der Geraden. Der [[Ortsvektor]] des allgemeinen Geradenpunktes $\mathrm{G}$ der Geraden $\mathrm{g}$ mit Aufpunkt $\mathrm{A(a_1\, |\, a_2\, |\, a_3)}$ und Richtungsvektor $\mathrm{ \vec w}$ lautet:
$$\mathrm{ \vec G = \begin{pmatrix}a_1 + \lambda  \cdot  w_1\\ \mathrm{a_2 + \lambda  \cdot  w_2}\\ \mathrm{a_3 + \lambda  \cdot  w_3}\\\end{pmatrix}  \ \, , \ \ \ \lambda\in\mathbb R}$$
</html>

/***
|''Name:''|GermanTranslationPlugin|
|''Description:''|Translation of TiddlyWiki into German|
|''Author:''|BesimKaradeniz (besim (at) karadeniz (dot) de)|
|''Version:''|2.7.2|
|''Date:''|May 29, 2013|
|''Comments:''|Visit the home of this translation on [[TiddlyWikiDeutsch|http://www.karadeniz.de/tiddlywiki/]] |
|''License:''|[[Creative Commons Attribution-ShareAlike 3.0 License|http://creativecommons.org/licenses/by-sa/3.0/]] |
|''~CoreVersion:''|2.7.2|
***/

//{{{

//--
//-- TiddlyWiki German Translation - based on lingo.js commit 8bf8ca077c
//-- Maintainer: Besim Karadeniz <besim(-at-)karadeniz(-dot-)de>
//-- Web: www.karadeniz.de/tiddlywiki/
//--

if (config.options.txtUserName == "YourName")
	merge(config.options,{txtUserName: "IhrName"});

merge(config.tasks,{
	save: {text: "speichern", tooltip: "Änderungen in dieses TiddlyWiki speichern", action: saveChanges},
	importTask: {text: "importieren", tooltip: "Tiddler und Plugins aus anderen TiddlyWiki-Dateien und Servern importieren", content: '<<importTiddlers>>'},
	tweak: {text: "optimieren", tooltip: "Erscheinungsbild und Reaktion des TiddlyWiki optimieren", content: '<<options>>'},
	upgrade: {text: "upgraden", tooltip: "Upgraden des Kerncodes von TiddlyWiki", content: '<<upgrade>>'},
	plugins: {text: "Plugins", tooltip: "Installierte Plugins verwalten", content: '<<plugins>>'}
});

// Optionen, die im Options-Panel oder/in Cookies eingestellt werden koennen
merge(config.optionsDesc,{
	txtUserName: "Ihr Benutzername zum Unterzeichnen Ihrer Einträge",
	chkRegExpSearch: "Reguläre Ausdrücke in der Suche aktivieren",
	chkCaseSensitiveSearch: "Groß-/Kleinschreibung in der Suche aktivieren",
	chkIncrementalSearch: "Inkrementelle Zeichen-für-Zeichen-Suche",
	chkAnimate: "Animationen aktivieren",
	chkSaveBackups: "Beim Speichern ein Backup erstellen",
	chkAutoSave: "Automatisch speichern",
	chkGenerateAnRssFeed: "RSS-Feed beim Speichern generieren",
	chkSaveEmptyTemplate: "Leere Vorlage beim Speichern generieren",
	chkOpenInNewWindow: "Externe Links in einem neuen Fenster öffnen",
	chkToggleLinks: "Klick auf geöffnete Tiddler lässt diese schließen",
	chkHttpReadOnly: "Bearbeitungsfunktionen ausblenden, wenn Zugriff via HTTP",
	chkForceMinorUpdate: "Bearbeitungen als kleine Änderungen mit Beibehaltung von Datum und Zeit behandeln",
	chkConfirmDelete: "Löschbestätigung vor dem Löschen von Tiddlern",
	chkInsertTabs: "Benutzen Sie die Tabulatortaste um Tabulatorzeichen einzufügen anstelle jeweils zum nächsten Feld zu springen",
	txtBackupFolder: "Verzeichnisname für Backup Dateien:",
	txtMaxEditRows: "Maximale Zahl von Zeilen in einer Textbox eines Tiddlers:",
	txtTheme: "Name des zu verwendenden Themes",
	txtFileSystemCharSet: "Standard-Zeichensatz beim Speichern von Änderungen (nur Firefox/Mozilla)"});

merge(config.messages,{
	customConfigError: "Beim Laden von Plugins sind Fehler aufgetreten. Siehe PluginManager für Details",
	pluginError: "Fehler: %0",
	pluginDisabled: "Nicht ausgeführt, da durch 'systemConfigDisable'-Tag deaktiviert",
	pluginForced: "Ausgeführt, da durch 'systemConfigForce'-Tag erzwungen",
	pluginVersionError: "Nicht ausgeführt, da dieses Plugin eine neuere Version von TiddlyWiki erfordert",
	nothingSelected: "Nichts ausgewählt. Sie müssen zuerst ein oder mehrere Elemente auswählen",
	savedSnapshotError: "Es scheint, dass dieses TiddlyWiki inkorrekt gespeichert wurde. Bitte besuchen Sie http://www.tiddlywiki.com/#Download für Details",
	subtitleUnknown: "(unbekannt)",
	undefinedTiddlerToolTip: "Der Tiddler '%0' existiert noch nicht",
	shadowedTiddlerToolTip: "Der Tiddler '%0' existiert noch nicht, hat aber einen vordefinierten Schatteneintrag",
	tiddlerLinkTooltip: "%0 - %1, %2",
	externalLinkTooltip: "Externer Link zu %0",
	noTags: "Es gibt keine getaggten Tiddler",
	notFileUrlError: "Sie müssen zunächst dieses TiddlyWiki in eine Datei speichern, bevor Änderungen gespeichert werden können",
	cantSaveError: "Änderungen können nicht gespeichert werden. Mögliche Gründe:\n- Ihr Browser unterstützt das Abspeichern nicht (Firefox, Internet Explorer, Safari und Opera können dies mit richtiger Konfiguration)\n- Der Pfadname zu Ihrem TiddlyWiki enthält ungültige Zeichen\n- Die TiddlyWiki-HTML-Datei wurde verschoben oder umbenannt",
	invalidFileError: "Die originale Datei '%0' scheint kein gültiges TiddlyWiki zu sein",
	backupSaved: "Backup gespeichert",
	backupFailed: "Fehler beim Speichern des Backup",
	rssSaved: "RSS-Feed gespeichert",
	rssFailed: "Fehler beim Speichern des RSS-Feed",
	emptySaved: "Leere Vorlage gespeichert",
	emptyFailed: "Fehler beim Speichern der leeren Vorlage",
	mainSaved: "TiddlyWiki-Datei gespeichert",
	mainDownload: "Herunterladen/speichern der TiddlyWiki-Datei",
	mainDownloadManual: "MIT DER RECHTEN MAUSTASTE HIER KLICKEN zum herunterladen/speichern der TiddlyWiki-Datei",
	mainFailed: "Fehler beim Speichern der TiddlyWiki-Datei. Ihre Änderungen wurden nicht gespeichert",
	macroError: "Fehler im Makro <<%0>>",
	macroErrorDetails: "Fehler beim Ausführen von Makro <<%0>>:\n%1",
	missingMacro: "Kein entsprechendes Makro vorhanden",
	overwriteWarning: "Ein Tiddler namens '%0' existiert bereits. Wählen Sie OK zum Überschreiben",
	unsavedChangesWarning: "WARNUNG! Ungespeicherte Änderungen im TiddlyWiki vorhanden\n\nWählen Sie OK zum Speichern\nWählen Sie ABBRECHEN/CANCEL zum Verwerfen",
	confirmExit: "--------------------------------\n\nUngespeicherte Änderungen im TiddlyWiki vorhanden. Wenn Sie fortfahren, werden Sie diese Änderungen verlieren\n\n--------------------------------",
	saveInstructions: "SaveChanges",
	unsupportedTWFormat: "Nicht unterstütztes TiddlyWiki-Format '%0'",
	tiddlerSaveError: "Fehler beim Speichern von Tiddler '%0'",
	tiddlerLoadError: "Fehler beim Laden von Tiddler '%0'",
	wrongSaveFormat: "Speichern im Speicherformat '%0' nicht möglich. Standardformat zum Speichern wird verwendet.",
	invalidFieldName: "Ungültiger Dateiname %0",
	fieldCannotBeChanged: "Feld '%0' kann nicht geändert werden",
	loadingMissingTiddler: "Es wird versucht, den Tiddler '%0' vom Server '%1' bei\n\n'%2' im Workspace '%3' abzurufen",
	upgradeDone: "Das Upgrade auf Version %0 ist komplett\n\nKlicken Sie auf 'OK' zum Neuladen des aktualisierten TiddlyWiki",
	invalidCookie: "Ungültiger Cookie '%0'"});

merge(config.messages.messageClose,{
	text: "schließen",
	tooltip: "diesen Textbereich schließen"});

config.messages.backstage = {
	open: {text: "Backstage", tooltip: "Öffnen Sie den Backstage-Bereich für Arbeiten an Entwicklungs- und Bearbeitungsaufgaben"},
	close: {text: "schließen", tooltip: "Backstage-Bereich schließen"},
	prompt: "Backstage: ",
	decal: {
		edit: {text: "bearbeiten", tooltip: "Den Tiddler '%0' bearbeiten"}
	}
};

config.messages.listView = {
	tiddlerTooltip: "Klick für den vollen Text dieses Tiddlers",
	previewUnavailable: "(Vorschau nicht vorhanden)"
};

config.messages.dates.months = ["Januar", "Februar", "März", "April", "Mai", "Juni", "Juli", "August", "September", "Oktober", "November","Dezember"];
config.messages.dates.days = ["Sonntag", "Montag", "Dienstag", "Mittwoch", "Donnerstag", "Freitag", "Samstag"];
config.messages.dates.shortMonths = ["Jan", "Feb", "Mär", "Apr", "Mai", "Jun", "Jul", "Aug", "Sep", "Okt", "Nov", "Dez"];
config.messages.dates.shortDays = ["So", "Mo", "Di", "Mi", "Do", "Fr", "Sa"];
// Suffixe für Datum (englischsprachig), z.B. "1st","2nd","3rd"..."30th","31st"
config.messages.dates.daySuffixes = ["st","nd","rd","th","th","th","th","th","th","th",
	"th","th","th","th","th","th","th","th","th","th",
	"st","nd","rd","th","th","th","th","th","th","th",
	"st"];
config.messages.dates.am = "am";
config.messages.dates.pm = "pm";

merge(config.messages.tiddlerPopup,{
	});

merge(config.views.wikified.tag,{
	labelNoTags: "keine Tags",
	labelTags: "Tags: ",
	openTag: "Öffne Tag '%0'",
	tooltip: "Zeige Tiddlers mit Tags '%0'",
	openAllText: "Öffne alle",
	openAllTooltip: "Alle diese Tiddler öffnen",
	popupNone: "Keine anderen Tiddler mit '%0' getaggt"});

merge(config.views.wikified,{
	defaultText: " ",
	defaultModifier: "(fehlt)",
	shadowModifier: "(vordefinierter Schatten-Tiddler)",
	dateFormat: "DD. MMM YYYY",
	createdPrompt: "erstellt am"});

merge(config.views.editor,{
	tagPrompt: "Geben Sie die Tags durch Leerstellen getrennt ein, [[benutzen Sie doppelte eckige Klammern]] falls nötig, oder wählen Sie vorhandene",
	defaultText: "Geben Sie den Text für '%0' ein"});

merge(config.views.editor.tagChooser,{
	text: "Tags",
	tooltip: "Wählen Sie vorhandene Tags zum Hinzufügen zu diesem Tiddler aus",
	popupNone: "Es sind keine Tags definiert",
	tagTooltip: "Tag '%0' hinzufügen"});

merge(config.messages,{
	sizeTemplates:
		[
		{unit: 1024*1024*1024, template: "%0 GB"},
		{unit: 1024*1024, template: "%0 MB"},
		{unit: 1024, template: "%0 KB"},
		{unit: 1, template: "%0 B"}
		]});

merge(config.macros.search,{
	label: "suchen",
	prompt: "Dieses TiddlyWiki durchsuchen",
	placeholder: "",
	accessKey: "F",
	successMsg: "%0 Einträge gefunden, die %1 enthalten.",
	failureMsg: "Keinen Eintrag gefunden, der %0 enthält"});

merge(config.macros.tagging,{
	label: "Tagging: ",
	labelNotTag: "kein Tagging",
	tooltip: "Liste der Tiddler, die mit '%0' getaggt sind"});

merge(config.macros.timeline,{
	dateFormat: "DD. MMM YYYY"});

merge(config.macros.allTags,{
	tooltip: "Tiddler, die mit '%0' getagged sind, anzeigen",
	noTags: "Keine getaggten Tiddler vorhanden"});

config.macros.list.all.prompt = "Alle Tiddler in alphabetischer Reihenfolge";
config.macros.list.missing.prompt = "Tiddler, auf die verwiesen wird, die aber nicht existieren";
config.macros.list.orphans.prompt = "Tiddler, auf die nicht von anderen Tiddlern verwiesen wird";
config.macros.list.shadowed.prompt = "Tiddler, für die Standardeinträge existieren";
config.macros.list.touched.prompt = "Tiddlers, die lokal verändert wurden";

merge(config.macros.closeAll,{
	label: "Alle Fenster schließen",
	prompt: "Alle angezeigten Tiddler schließen (außer denen, die gerade bearbeitet werden)"});

merge(config.macros.permaview,{
	label: "Permaview",
	prompt: "Erzeugt einen URL, mit dem auf alle gerade geöffneten Tiddler verwiesen werden kann"});

merge(config.macros.saveChanges,{
	label: "Änderungen speichern",
	prompt: "Alle Änderungen speichern",
	accessKey: "S"});

merge(config.macros.newTiddler,{
	label: "Neuer Tiddler",
	prompt: "Neuen Tiddler erstellen",
	title: "Neuer Tiddler",
	accessKey: "N"});

merge(config.macros.newJournal,{
	label: "Neues Journal",
	prompt: "Neuen Tiddler mit aktuellem Datum und aktueller Zeit erstellen",
	accessKey: "J"});

merge(config.macros.options,{
	wizardTitle: "Erweiterte Optionen verändern",
	step1Title: "Diese Optionen werden mit Cookies in Ihrem Browser gespeichert",
	step1Html: "<input type='hidden' name='markList'></input><br><input type='checkbox' checked='false' name='chkUnknown'>Unbekannte Optionen anzeigen</input>",
	unknownDescription: "//(unbekannt)//",
	listViewTemplate: {
		columns: [
			{name: 'Option', field: 'option', title: "Option", type: 'String'},
			{name: 'Description', field: 'description', title: "Beschreibung", type: 'WikiText'},
			{name: 'Name', field: 'name', title: "Name", type: 'String'}
			],
		rowClasses: [
			{className: 'lowlight', field: 'lowlight'}
			]}
	});

merge(config.macros.plugins,{
	wizardTitle: "Plugins verwalten",
	step1Title: "Aktuell geladene Plugins",
	step1Html: "<input type='hidden' name='markList'></input>",
	skippedText: "(Dieses Plugin wurde nicht ausgeführt, da es nach dem Start hinzugefügt wurde)",
	noPluginText: "Es sind keine Plugins installiert",
	confirmDeleteText: "Wollen Sie wirklich folgende Plugins löschen:\n\n%0",
	removeLabel: "systemConfig-Tag entfernen",
	removePrompt: "systemConfig-Tag entfernen",
	deleteLabel: "löschen",
	deletePrompt: "Diese Tiddler endgültig löschen",
	listViewTemplate: {
		columns: [
			{name: 'Selected', field: 'Selected', rowName: 'title', type: 'Selector'},
			{name: 'Tiddler', field: 'tiddler', title: "Tiddler", type: 'Tiddler'},
			{name: 'Description', field: 'Description', title: "Beschreibung", type: 'String'},
			{name: 'Version', field: 'Version', title: "Version", type: 'String'},
			{name: 'Size', field: 'size', tiddlerLink: 'size', title: "Größe", type: 'Size'},
			{name: 'Forced', field: 'forced', title: "Erzwungen", tag: 'systemConfigForce', type: 'TagCheckbox'},
			{name: 'Disabled', field: 'disabled', title: "Deaktiviert", tag: 'systemConfigDisable', type: 'TagCheckbox'},
			{name: 'Executed', field: 'executed', title: "Geladen", type: 'Boolean', trueText: "Ja", falseText: "Nein"},
			{name: 'Startup Time', field: 'startupTime', title: "Startzeit", type: 'String'},
			{name: 'Error', field: 'error', title: "Status", type: 'Boolean', trueText: "Fehler", falseText: "OK"},
			{name: 'Log', field: 'log', title: "Log", type: 'StringList'}
			],
		rowClasses: [
			{className: 'error', field: 'error'},
			{className: 'warning', field: 'warning'}
			]},
	listViewTemplateReadOnly: {
		columns: [
			{name: 'Tiddler', field: 'tiddler', title: "Tiddler", type: 'Tiddler'},
			{name: 'Description', field: 'Description', title: "Beschreibung", type: 'String'},
			{name: 'Version', field: 'Version', title: "Version", type: 'String'},
			{name: 'Size', field: 'size', tiddlerLink: 'size', title: "Größe", type: 'Size'},
			{name: 'Executed', field: 'executed', title: "Geladen", type: 'Boolean', trueText: "Ja", falseText: "Nein"},
			{name: 'Startup Time', field: 'startupTime', title: "Startzeit", type: 'String'},
			{name: 'Error', field: 'error', title: "Status", type: 'Boolean', trueText: "Fehler", falseText: "OK"},
			{name: 'Log', field: 'log', title: "Log", type: 'StringList'}
			],
		rowClasses: [
			{className: 'error', field: 'error'},
			{className: 'warning', field: 'warning'}
			]}
	});

merge(config.macros.toolbar,{
	moreLabel: "mehr",
	morePrompt: "Weitere Funktionen anzeigen",
	lessLabel: "weniger",
	lessPrompt: "Zusätzliche Befehle verstecken",
	separator: "|"
	});

merge(config.macros.refreshDisplay,{
	label: "aktualisieren",
	prompt: "Gesamte TiddlyWiki-Ansicht aktualisieren"
	});

merge(config.macros.importTiddlers,{
	readOnlyWarning: "Sie können nicht in eine schreibgeschützte TiddlyWiki-Datei importieren. Versuchen Sie diese über eine file:// URL zu öffnen",
	wizardTitle: "Tiddler aus anderer Datei oder anderem Server importieren",
	step1Title: "Schritt 1: Server oder TiddlyWiki-Datei ausfindig machen",
	step1Html: "Typ des Servers auswählen: <select name='selTypes'><option value=''>Wählen...</option></select><br>URL oder Pfadnamen eingeben: <input type='text' size=50 name='txtPath'><br>...oder nach einer Datei browsen: <input type='file' size=50 name='txtBrowse'><br><hr>...oder einen vordefinierten Feed auswählen: <select name='selFeeds'><option value=''>Wählen...</option></select>",
	openLabel: "öffnen",
	openPrompt: "Verbindung zu dieser Datei oder Server starten",
	statusOpenHost: "Verbindung zum Host starten",
	statusGetWorkspaceList: "Liste von vorhandenen Workspaces abrufen",
	step2Title: "Schritt 2: Workspace auswählen",
	step2Html: "Einen Workspace-Namen eingeben: <input type='text' size=50 name='txtWorkspace'><br>...oder ein Workspace auswählen: <select name='selWorkspace'><option value=''>Wählen...</option></select>",
	cancelLabel: "abbrechen",
	cancelPrompt: "Diesen Import abbrechen",
	statusOpenWorkspace: "Workspace wird geöffnet",
	statusGetTiddlerList: "Abrufen der Liste von vorhandenen Workspaces",
	errorGettingTiddlerList: "Fehler beim Abrufen der Liste der Tiddler, klicken Sie auf ABBRECHEN/CANCEL, um es nochmal zu probieren",
	errorGettingTiddlerListHttp404: "Fehler beim Abrufen der Tiddler von der URL, bitte stellen Sie sicher, dass der URL existiert. Klicken Sie auf ABBRECHEN/CANCEL, um es nochmal zu probieren.",
	errorGettingTiddlerListHttp: "Fehler beim Abrufen der Tiddler von der URL, bitte stellen Sie sicher, dass der URL existiert und <a href='http://enable-cors.org/'>CORS</a>-kompatibel ist",
	errorGettingTiddlerListFile: "Fehler beim Abrufen der Tiddler aus der lokalen Datei, bitte stellen Sie sicher, dass die Datei im gleichen Verzeichnis ist wie Ihr TiddlyWiki. Klicken Sie auf ABBRECHEN/CANCEL, um es nochmal zu probieren.",
	step3Title: "Schritt 3: Zu importierende Tiddler auswählen",
	step3Html: "<input type='hidden' name='markList'></input><br><input type='checkbox' checked='true' name='chkSync'>Links dieser Tiddler zum Server erhalten, um nachfolgende Änderungen synchronisieren zu können</input><br><input type='checkbox' checked='false' name='chkSave'>Speichern der Details dieses Servers in einem 'systemServer'Tiddler namens:</input> <input type='text' size=25 name='txtSaveTiddler'>",
	importLabel: "importieren",
	importPrompt: "Diese Tiddler importieren",
	confirmOverwriteText: "Wollen Sie wirklich folgende Tiddler überschreiben:\n\n%0",
	step4Title: "Schritt 4: Importieren von %0 Tiddler",
	step4Html: "<input type='hidden' name='markReport'></input>",
	doneLabel: "Erledigt",
	donePrompt: "Diesen Assistenten schließen",
	statusDoingImport: "Tiddler werden importiert",
	statusDoneImport: "Alle Tiddler importiert",
	systemServerNamePattern: "%2 auf %1",
	systemServerNamePatternNoWorkspace: "%1",
	confirmOverwriteSaveTiddler: "Der Tiddler '%0' existiert bereits. Klicken Sie auf 'OK' um ihn mit den Details dieses Servers zu überschreiben, oder 'Abbrechen', um ihn unverändert zu lassen",
	serverSaveTemplate: "|''Eingabe:''|%0|\n|''URL:''|%1|\n|''Workspace:''|%2|\n\nDieser Tiddler wurde automatisch erstellt, um Details dieses Servers aufzuzeichnen",
	serverSaveModifier: "(System)",
	listViewTemplate: {
		columns: [
			{name: 'Selected', field: 'Selected', rowName: 'title', type: 'Selector'},
			{name: 'Tiddler', field: 'tiddler', title: "Tiddler", type: 'Tiddler'},
			{name: 'Size', field: 'size', tiddlerLink: 'size', title: "Größe", type: 'Size'},
			{name: 'Tags', field: 'tags', title: "Tags", type: 'Tags'}
			],
		rowClasses: [
			]}
	});

merge(config.macros.upgrade,{
	wizardTitle: "Upgraden des Kerncodes von TiddlyWiki",
	step1Title: "Update oder Reparatur dieses TiddlyWiki auf die aktuellste Version",
	step1Html: "Sie sind dabei, auf die aktuellste Version des TiddlyWiki-Kerncodes upzugraden (von <a href='%0' class='externalLink' target='_blank'>%1</a>). Ihre Inhalte werden während dem Upgrade erhalten bleiben.<br><br>Bitte beachten Sie, dass Kerncode-Updates mit älteren Plugins kollidieren können. Wenn Sie Probleme mit der aktualisierten Datei beobachten, besuchen Sie bitte <a href='http://www.tiddlywiki.org/wiki/CoreUpgrades' class='externalLink' target='_blank'>http://www.tiddlywiki.org/wiki/CoreUpgrades</a>",
	errorCantUpgrade: "Upgrade dieses TiddlyWiki nicht möglich. Sie können nur lokal abgespeicherte TiddlyWiki-Dateien upgraden",
	errorNotSaved: "Sie müssen zunächst Änderungen speichern, bevor Sie ein Upgrade starten können",
	step2Title: "Upgrade-Details bestätigen",
	step2Html_downgrade: "Sie sind dabei, von der TiddlyWiki-Version %1 auf die Version %0 downzugraden.<br><br>Der Downgrade auf eine frühere Version von TiddlyWiki wird nicht empfohlen",
	step2Html_restore: "Dieses TiddlyWiki scheint bereits die aktuellste Version des Kerncodes (%0) einzusetzen.<br><br>Sie können mit dem Upgrade fortsetzen, um sicherzustellen, dass der Kerncode nicht korrumpiert oder beschädigt wurde",
	step2Html_upgrade: "Sie sind dabei, von der TiddlyWiki-Version %1 auf die Version %0 upzugraden",
	upgradeLabel: "upgraden",
	upgradePrompt: "Vorbereiten des Upgrade-Prozesses",
	statusPreparingBackup: "Backup vorbereiten",
	statusSavingBackup: "Backup-Datei speichern",
	errorSavingBackup: "Ein Problem mit dem Speichern der Backup-Datei ist aufgetreten",
	statusLoadingCore: "Kerncode laden",
	errorLoadingCore: "Fehler beim Laden des Kerncodes",
	errorCoreFormat: "Fehler im neuen Kerncode",
	statusSavingCore: "Neuen Kerncode speichern",
	statusReloadingCore: "Neuen Kerncode neu laden",
	startLabel: "starten",
	startPrompt: "Upgrade-Prozess starten",
	cancelLabel: "abbrechen",
	cancelPrompt: "Upgrade-Prozess abbrechen",
	step3Title: "Upgrade abgebrochen",
	step3Html: "Sie haben den Upgrade-Prozess abgebrochen"
	});

merge(config.macros.annotations,{
	});

merge(config.commands.closeTiddler,{
	text: "schließen",
	tooltip: "Diesen Tiddler schließen"});

merge(config.commands.closeOthers,{
	text: "andere schließen",
	tooltip: "Alle anderen Tiddler schließen"});

merge(config.commands.editTiddler,{
	text: "bearbeiten",
	tooltip: "Diesen Tiddler bearbeiten",
	readOnlyText: "betrachten",
	readOnlyTooltip: "Quellcode dieses Tiddlers betrachten"});

merge(config.commands.saveTiddler,{
	text: "fertig",
	tooltip: "Änderungen an diesem Tiddler speichern"});

merge(config.commands.cancelTiddler,{
	text: "abbrechen",
	tooltip: "Änderungen an diesem Tiddler verwerfen",
	warning: "Wollen Sie wirklich Änderungen in '%0' verwerfen?",
	readOnlyText: "fertig",
	readOnlyTooltip: "Diesen Tiddler normal anzeigen"});

merge(config.commands.deleteTiddler,{
	text: "löschen",
	tooltip: "Diesen Tiddler löschen",
	warning: "Wollen Sie '%0' wirklich löschen?"});

merge(config.commands.permalink,{
	text: "Permalink",
	tooltip: "Permalink für diesen Tiddler"});

merge(config.commands.references,{
	text: "Referenzen",
	tooltip: "Alle Tiddler zeigen, die auf diesen verweisen",
	popupNone: "Keine Referenzen"});

merge(config.commands.jump,{
	text: "springen",
	tooltip: "Zu anderem, geöffneten Tiddler springen"});

merge(config.commands.fields,{
	text: "Felder",
	tooltip: "Erweiterte Felder dieses Tiddlers anzeigen",
	emptyText: "Keine erweiterten Felder für diesen Tiddler vorhanden",
	listViewTemplate: {
		columns: [
			{name: 'Field', field: 'field', title: "Feld", type: 'String'},
			{name: 'Value', field: 'value', title: "Wert", type: 'String'}
			],
		rowClasses: [
			],
		buttons: [
			]}});

merge(config.shadowTiddlers,{
	DefaultTiddlers: "[[GettingStarted]]",
	MainMenu: "[[GettingStarted]]",
	SiteTitle: "Mein TiddlyWiki",
	SiteSubtitle: "ein wiederverwendbares nichtlineares, persönliches ~Web-Notizbuch",
	SiteUrl: "",
	SideBarOptions: '<<search>><<closeAll>><<permaview>><<newTiddler>><<newJournal "DD. MMM YYYY" "Journal">><<saveChanges>><<slider chkSliderOptionsPanel OptionsPanel "Optionen »" "Optionen von TiddlyWiki ändern">>',
	SideBarTabs: '<<tabs txtMainTab "Zeitachse" "Zeitachse" TabTimeline "Alles" "Alle Tiddler" TabAll "Tags" "Alle Tags" TabTags "Mehr" "Weitere Listen" TabMore>>',
	TabMore: '<<tabs txtMoreTab "Fehlend" "Fehlende Tiddler" TabMoreMissing "Waisen" "Verwaiste Tiddler" TabMoreOrphans "Schatten" "Tiddler mit Schatteneinträgen" TabMoreShadowed>>'
	});

merge(config.annotations,{
	AdvancedOptions: "Dieser Schatten-Tiddler bietet Zugang zu diversen erweiterten Optionen",
	ColorPalette: "Diese Werte in diesem Schatten-Tiddler legen das Farbschema der Benutzerschnittstelle des TiddlyWiki fest",
	DefaultTiddlers: "Die in diesem Schatten-Tiddler aufgelisteten Tiddler werden automatisch beim Start des TiddlyWiki angezeigt",
	EditTemplate: "Die HTML-Vorlage in diesem Schatten-Tiddler legt das Aussehen von Tiddler während ihrer Bearbeitung fest",
	GettingStarted: "Dieser Schatten-Tiddler bietet eine einfache Bedienungsanleitung",
	ImportTiddlers: "Dieser Schatten-Tiddler bietet Zugang zum Import von Tiddler",
	MainMenu: "Dieser Schatten-Tiddler dient als Container für das Hauptmenü in der linksseitigen Spalte des Bildschirms",
	MarkupPreHead: "Dieser Tiddler wird an der Spitze der <head>-Sektion der HTML-Datei des TiddlyWiki eingefügt",
	MarkupPostHead: "Dieser Tiddler wird am Ende der <head>-Sektion der HTML-Datei des TiddlyWiki eingefügt",
	MarkupPreBody: "Dieser Tiddler wird an der Spitze der <body>-Sektion der HTML-Datei des TiddlyWiki eingefügt",
	MarkupPostBody: "Dieser Tiddler wird am Ende der <body>-Sektion der HTML-Datei des TiddlyWiki unmittelbar nach dem Scriptblock eingefügt",
	OptionsPanel: "Dieser Schatten-Tiddler dient als Container für das einblendbare Optionsfeld in der rechtsseitigen Seitenleiste",
	PageTemplate: "Die HTML-Vorlage in diesem Schatten-Tiddler legt das allgemeine Aussehen des TiddlyWiki fest",
	PluginManager: "Dieser Schatten-Tiddler bietet Zugang zum Plugin-Manager",
	SideBarOptions: "Dieser Schatten-Tiddler dient als Container für das Optionsfeld in der rechtsseitigen Seitenleiste",
	SideBarTabs: "Dieser Schatten-Tiddler dient als Container für das Tab-Panel in der rechtsseitigen Seitenleiste",
	SiteSubtitle: "Dieser Schatten-Tiddler enthält den zweiten Teil der Seitenüberschrift",
	SiteTitle: "Dieser Schatten-Tiddler enthält den ersten Teil der Seitenüberschrift",
	SiteUrl: "Dieser Schatten-Tiddler sollte den vollständigen Ziel-URL der Veröffentlichung enthalten",
	StyleSheetColors: "Dieser Schatten-Tiddler enthält CSS-Definitionen bezüglich der Farbe von Seitenelementen. ''DIESEN TIDDLER NICHT BEARBEITEN'', fügen Sie Ihre Änderungen stattdessen in den StyleSheet-Schatten-Tiddler ein",
	StyleSheet: "Dieser Tiddler kann benutzerspezifische CSS-Definitionen enthalten",
	StyleSheetLayout: "Dieser Schatten-Tiddler enthält CSS-Definitionen bezüglich dem Aussehen von Seitenelementen. ''DIESEN TIDDLER NICHT BEARBEITEN'', fügen Sie Ihre Änderungen stattdessen in den StyleSheet-Schatten-Tiddler ein",
	StyleSheetLocale: "Dieser Schatten-Tiddler enthält CSS-Definitionen bezüglich lokale Übersetzungen",
	StyleSheetPrint: "Dieser Schatten-Tiddler enthält CSS-Definitionen zum Drucken",
	SystemSettings: "Dieser Tiddler wird zum Speichern von Konfigurationsoptionen für dieses TiddlyWiki-Dokument genutzt",
	TabAll: "Dieser Schatten-Tiddler enthält den Inhalt des 'Alles'-Tab in der rechtsseitigen Seitenleiste",
	TabMore: "Dieser Schatten-Tiddler enthält den Inhalt des 'Mehr'-Tab in der rechtsseitigen Seitenleiste",
	TabMoreMissing: "Dieser Schatten-Tiddler enthält den Inhalt des 'Fehlend'-Tab in der rechtsseitigen Seitenleiste",
	TabMoreOrphans: "Dieser Schatten-Tiddler enthält den Inhalt des 'Waisen'-Tab in der rechtsseitigen Seitenleiste",
	TabMoreShadowed: "Dieser Schatten-Tiddler enthält den Inhalt des 'Schatten'-Tab in der rechtsseitigen Seitenleiste",
	TabTags: "Dieser Schatten-Tiddler enthält den Inhalt des 'Tags'-Tab in der rechtsseitigen Seitenleiste",
	TabTimeline: "Dieser Schatten-Tiddler enthält den Inhalt des 'Zeitachse'-Tab in der rechtsseitigen Seitenleiste",
	ToolbarCommands: "Dieser Schatten-Tiddler legt fest, welche Befehle in Tiddler-Toolbars angezeigt werden",
	ViewTemplate: "Die HTML-Vorlage in diesem Schatten-Tiddler legt das Aussehen der Tiddler fest"
	});

// Uebersetzungen von Schatten-Tiddlern ausserhalb der offiziellen lingo.js
merge(config.shadowTiddlers,{
	OptionsPanel: "Diese [[Interface-Einstellungen|InterfaceOptions]] zur Anpassung von TiddlyWiki werden in Ihrem Browser gespeichert\n\nIhr Benutzername zum Unterzeichnen Ihrer Einträge. Bitte als WikiWord (z.B. KlausBrandmüller) schreiben\n\n<<option txtUserName>>\n<<option chkSaveBackups>> [[Backups speichern|SaveBackups]]\n<<option chkAutoSave>> [[Automatisch speichern|AutoSave]]\n<<option chkRegExpSearch>> [[RegExp Suche|RegExpSearch]]\n<<option chkCaseSensitiveSearch>> [[Groß-/Kleinschreibung in Suche|CaseSensitiveSearch]]\n<<option chkAnimate>> [[Animationen aktivieren|EnableAnimations]]\n\n----\[[Erweiterte Optionen|AdvancedOptions]]\nPluginManager\nImportTiddlers",
	GettingStarted: "Um mit diesem TiddlyWiki zu starten, sollten Sie folgende Tiddler modifizieren:\n* SiteTitle & SiteSubtitle: Den [[Titel|SiteTitle]] und [[Untertitel|SiteSubtitle]] der Site, wie oben angezeigt (nach dem Speichern werden diese auch in der Titelzeile des Browsers angezeigt)\n* MainMenu: Ihr Inhaltsverzeichnis (für gewöhnlich Links)\n* DefaultTiddlers: Beinhaltet die Namen der Tiddler, die Sie angezeigt haben möchten, wenn das TiddlyWiki geöffnet wird.\nSie sollten zudem Ihren Benutzernamen zum Unterzeichnen Ihrer Bearbeitungen eingeben: <<option txtUserName>>",
	InterfaceOptions: "Die [[Interface-Einstellungen|InterfaceOptions]] werden angezeigt, wenn Sie rechts auf 'Optionen' klicken. Sie werden mit einem Cookie in Ihrem Browser gespeichert, um sie zwischen den Aufrufen zu sichern. Nähere Informationen zu den einzelnen Funktionen finden Sie, wenn Sie die Funktion selbst anklicken.",
	WikiWord: "Ein WikiWord ist ein Wort, das aus mehreren einzelnen Wörtern zusammengesetzt ist, in dem jedes Wort mit einem Großbuchstaben beginnt und eine individuelle Seite bezeichnet.",
	SaveBackups: "[[Backups speichern|SaveBackups]] ist eine Funktion, mit der automatisch bei jedem Abspeichern ein Backup erstellt wird.",
	AutoSave: "[[Automatisches Speichern|AutoSave]] speichert automatisch Änderungen jedes Mal, wenn Sie einen Tiddler bearbeiten. Damit sinken die Chancen, dass Sie Daten verlieren. Beachten Sie jedoch, dass bei aktivierter [[Backup-Funktion|SaveBackups]] natürlich auch eine Menge Backup-Dateien erstellt werden. Entscheiden Sie sich deshalb für die eine oder andere Funktion.",
	RegExpSearch: "Mit der [[RegExp Suche|RegExpSearch]] können Sie mit regulären Suchausdrücken flexible Suchanfragen vornehmen.",
	CaseSensitiveSearch: "Die Unterscheidung der [[Groß-/Kleinschreibung in Suche|CaseSensitiveSearch]] tut genau dies.",
	EnableAnimations: "Diese Funktion aktiviert Animationen, wenn Sie einen Tiddler öffnen oder schließen.",
	GenerateAnRssFeed: "Wenn Sie [[RSS-Feed generieren|GenerateAnRssFeed]] aktivieren, speichert TiddlyWiki automatisch einen RSS-2.0-gültigen Feed, so bald Ihr TiddlyWiki gespeichert wird. Der Feed hat den gleichen Dateinamen wie das TiddlyWiki, lediglich jedoch mit der Endung '.xml'.",
	OpenLinksInNewWindow: "Diese Funktion öffnet externe Links in einem neuen ~Browser-Fenster.",
	SaveEmptyTemplate: "Diese Funktion erwirkt, dass beim Abspeichern von Änderungen eine leere Vorlage von TiddlyWiki erzeugt wird. Dies ist als Hilfe gedacht für Entwickler, die Adaptionen von TiddlyWiki bereitstellen. Die Funktion ist nicht erforderlich, wenn Sie ein normaler Benutzer sind.",
	HideEditingFeatures: "Ist diese Funktion aktiviert, werden die Bearbeitungsfunktionen ausgeblendet, wenn das TiddlyWiki über HTTP aufgerufen wird. Der Benutzer hat dann die Möglichkeit, den Tiddler zwar betrachten zu können, aber nicht zu bearbeiten.",
	MinorChanged: "Manchmal ist es sinnvoll, dass bei kleinen Änderungen der Tiddler in der Zeitachse nicht automatisch an den Anfang gesetzt wird. Mit Aktivierung dieser Funktion werden alle Bearbeitungen von Tiddlern als kleine Änderungen betrachtet und das Änderungsdatum nicht geändert.",
	ConfirmBeforeDeleting: "Bei Aktivierung dieser Funktion fordert TiddlyWiki eine Bestätigung des Benutzers an, wenn ein Tiddler gelöscht werden soll."});

//}}}<<tiddler HideTiddlerTags>><<tiddler HideTiddlerSubtitle>><<tiddler HideTiddlerSubtitle with: TiddlerTitle>>

<<tiddler HideTiddlerSubtitle>>
<html>Führt man ein [[Zufallsexperiment]] sehr oft durch, so stabilisiert sich die relative [[Häufigkeit]] für jedes Ergebnis. Dieser Wert wird [[Wahrscheinlichkeit]] genannt.
<p>!!!Beispiel:
Simuliert man mithilfe eines Computers 10 000 faire Münzwürfe, so wird sich die relative Häufigkeit für das Ergebnis $\mathrm{A = \{Kopf\}}$ etwa bei der Wahrscheinlichkeit $\mathrm{p = 0,5}$ einpendeln.
</html>

Um mit diesem TiddlyWiki zu starten, sollten Sie folgende Tiddler modifizieren:
* SiteTitle & SiteSubtitle: Den [[Titel|SiteTitle]] und [[Untertitel|SiteSubtitle]] der Site, wie oben angezeigt (nach dem Speichern werden diese auch in der Titelzeile des Browsers angezeigt)
* MainMenu: Ihr Inhaltsverzeichnis (für gewöhnlich Links)
* DefaultTiddlers: Beinhaltet die Namen der Tiddler, die Sie angezeigt haben möchten, wenn das TiddlyWiki geöffnet wird.
Sie sollten zudem Ihren Benutzernamen zum Unterzeichnen Ihrer Bearbeitungen eingeben: <<option txtUserName>>

<<tiddler HideTiddlerSubtitle>>
<html>Der Grenzwert einer [[Funktion]] bezeichnet denjenigen Wert, dem sich die Funktion an einer Grenze des [[Definitionsbereiches|Definitionsmenge]] beliebig nähert.
<p>Existiert ein reeller Grenzwert, so konvergiert die Funktion gegen diesen Wert. Wird die Funktion an diesem Grenzwert unendlich groß oder unendlich klein, so spricht man von bestimmter Divergenz der Funktion.
<p>Wenn eine Funktion weder konvergiert noch bestimmt divergiert, so spricht man von unbestimmter Divergenz.
<p>Für Grenzwerte gilt ($\mathrm{a}$ bezeichne jeweils den Rand des Definitionsbereichs von $\mathrm{f}$ oder $\mathrm{h}$):
$$\mathrm{\lim\limits_{x \rightarrow a}(f(x) + h(x)) = \lim\limits_{x \rightarrow a} f(x) + \lim\limits_{x \rightarrow a}h(x)}$$
$$\mathrm{\lim\limits_{x \rightarrow a}(f(x) - h(x)) = \lim\limits_{x \rightarrow a}f(x) - \lim\limits_{x \rightarrow a}h(x)}$$
$$\mathrm{\lim\limits_{x \rightarrow a}(f(x) \cdot  h(x)) = \lim\limits_{x \rightarrow a}f(x) \cdot \lim\limits_{x \rightarrow a}h(x)}$$
$$\mathrm{\underset{x \rightarrow a}{\lim} \ \frac{f(x)}{h(x)}  =  \frac{\lim\limits_{x \to a} f(x)}{\lim\limits_{x \rightarrow a} h(x)}}$$
\( \ \rightarrow \) [[Verhalten an den Rändern des Definitionsbereichs]]
</html>

<html><div style="margin-left:25px; line-height: 1.5;">
*[[Häufigkeit]]
*[[HDI]]
*[[Hesse'sche Normalenform]]
*[[Histogramm]]

</div></html>

<<tiddler HideTiddlerSubtitle>><html>Der Hauptsatz der Differenzial- und Integralrechnung (kurz HDI) besagt:
<p>Jede [[Integralfunktion]] $\mathrm{I}$ einer [[stetigen Funktion|Stetigkeit]] $\mathrm{f}$,
$$\mathrm{ I(x) = \int\limits_a^x f(t) \:dt\:,}$$
ist eine [[Stammfunktion]] von $\mathrm{f(x)}$, d.h. $\mathrm{I'(x) = f(x)}$.
</html>

/***
|Name|HTMLFormattingPlugin|
|Source|http://www.TiddlyTools.com/#HTMLFormattingPlugin|
|Documentation|http://www.TiddlyTools.com/#HTMLFormattingPluginInfo|
|Version|2.4.1|
|Author|Eric Shulman|
|License|http://www.TiddlyTools.com/#LegalStatements|
|~CoreVersion|2.1|
|Type|plugin|
|Description|embed wiki syntax formatting inside of HTML content|
The ~HTMLFormatting plugin allows you to ''mix wiki-style formatting syntax within HTML formatted content'' by extending the action of the standard TiddlyWiki formatting handler.
!!!!!Documentation
>see [[HTMLFormattingPluginInfo]]
!!!!!Configuration
<<<
Use {{{<hide linebreaks>}}} within HTML content to wiki-style rendering of line breaks.  To //always// omit all line breaks from the rendered output, you can set this option:
><<option chkHTMLHideLinebreaks>> ignore all line breaks
which can also be 'hard coded' into your document by adding the following to a tiddler, tagged with <<tag systemConfig>>
>{{{config.options.chkHTMLHideLinebreaks=true;}}}
<<<
!!!!!Revisions
<<<
2010.05.07 2.4.1 added chkHTMLHideLinebreaks option
| see [[HTMLFormattingPluginInfo]] for additional revision details |
2005.06.26 1.0.0 Initial Release (as code adaptation - pre-dates TiddlyWiki plugin architecture!!)
<<<
!!!!!Code
***/
//{{{
version.extensions.HTMLFormattingPlugin= {major: 2, minor: 4, revision: 1, date: new Date(2010,5,7)};

// find the formatter for HTML and replace the handler
initHTMLFormatter();
function initHTMLFormatter()
{
	for (var i=0; i<config.formatters.length && config.formatters[i].name!="html"; i++);
	if (i<config.formatters.length)	config.formatters[i].handler=function(w) {
		if (!this.lookaheadRegExp)  // fixup for TW2.0.x
			this.lookaheadRegExp = new RegExp(this.lookahead,"mg");
		this.lookaheadRegExp.lastIndex = w.matchStart;
		var lookaheadMatch = this.lookaheadRegExp.exec(w.source)
		if(lookaheadMatch && lookaheadMatch.index == w.matchStart) {
			var html=lookaheadMatch[1];
			// if <nowiki> is present, just let browser handle it!
			if (html.indexOf('<nowiki>')!=-1)
				createTiddlyElement(w.output,"span").innerHTML=html;
			else {
				// if <hide linebreaks> is present, or chkHTMLHideLinebreaks is set
				// suppress wiki-style literal handling of newlines
				if (config.options.chkHTMLHideLinebreaks||(html.indexOf('<hide linebreaks>')!=-1))
					html=html.replace(/\n/g,' ');
				// remove all \r's added by IE textarea and mask newlines and macro brackets
				html=html.replace(/\r/g,'').replace(/\n/g,'\\n').replace(/<</g,'%%(').replace(/>>/g,')%%');
				// create span, let browser parse HTML
				var e=createTiddlyElement(w.output,"span"); e.innerHTML=html;
				// then re-render text nodes as wiki-formatted content
				wikifyTextNodes(e,w);
			}
			w.nextMatch = this.lookaheadRegExp.lastIndex; // continue parsing
		}
	}
}

// wikify #text nodes that remain after HTML content is processed (pre-order recursion)
function wikifyTextNodes(theNode,w)
{
	function unmask(s) { return s.replace(/\%%\(/g,'<<').replace(/\)\%%/g,'>>').replace(/\\n/g,'\n'); }
	switch (theNode.nodeName.toLowerCase()) {
		case 'style': case 'option': case 'select':
			theNode.innerHTML=unmask(theNode.innerHTML);
			break;
		case 'textarea':
			theNode.value=unmask(theNode.value);
			break;
		case '#text':
			var txt=unmask(theNode.nodeValue);
			var newNode=createTiddlyElement(null,"span");
			theNode.parentNode.replaceChild(newNode,theNode);
			wikify(txt,newNode,highlightHack,w.tiddler);
			break;
		default:
			for (var i=0;i<theNode.childNodes.length;i++)
				wikifyTextNodes(theNode.childNodes.item(i),w); // recursion
			break;
	}
}
//}}}<<tiddler HideTiddlerTags>><<tiddler HideTiddlerSubtitle>><<tiddler HideTiddlerSubtitle with: TiddlerTitle>>

|Name|HTMLFormattingPluginInfo|
|Source|http://www.TiddlyTools.com/#HTMLFormattingPlugin|
|Documentation|http://www.TiddlyTools.com/#HTMLFormattingPluginInfo|
|Version|2.4.1|
|Author|Eric Shulman|
|License|http://www.TiddlyTools.com/#LegalStatements|
|~CoreVersion|2.1|
|Type|documentation|
|Description|documentation for HTMLFormattingPlugin|
The ~HTMLFormatting plugin allows you to freely ''mix wiki-style formatting syntax within HTML formatted content'' by extending the action of the standard TiddlyWiki formatting handler.
!!!!!Usage
<<<
The shorthand Wiki-style formatting syntax of ~TiddlyWiki is very convenient and enables most content to be reasonably well presented. However, there are times when tried-and-true HTML formatting syntax allows more more precise control of the content display.

When a tiddler is about to be displayed, ~TiddlyWiki looks for tiddler content contained within {{{<html>}}} and {{{</html>}}} markers.  When present, the TiddlyWiki core simply passes this content directly to the browser's internal "rendering engine" to process as ~HTML-formatted content.  However, TiddlyWiki does not also process the HTML source content for any embedded wiki-formatting syntax it may contain.  This means that while you can use HTML formatted content, you cannot mix wiki-formatted content within the HTML formatting.

This plugin extends the TiddlyWiki core processing so that, after the HTML formatting has been processed, all the pieces of text occuring within the HTML block are then processed one piece at a time, so that normal wiki-style formatting can be applied to the individual text pieces.

Note: To bypass this extended processing for a specific section of HTML content, embed ''{{{<nowiki>}}}'' //anywhere// inside the {{{<html>...</html>}}} delimiters, and wiki formatting will not be applied to that content.
<<<
!!!!!Line breaks
<<<
One major difference between Wiki formatting and HTML formatting is how "line breaks" are processed. Wiki formatting treats all line breaks as literal content to be displayed //as-is//. However, because HTML normally ignores line breaks and actually processes them as simple "word separators" instead, many people who write HTML include extra line breaks in their documents, just to make the "source code" easier to read.

Even though you can use HTML tags within your tiddler content, the default treatment for line breaks still follows the Wiki-style rule (i.e., all new lines are displayed as-is). When adding HTML content to a tiddler (especially if you cut-and-paste it from another web page), you should take care to avoid adding extra line breaks to the text.

If removing all the extra line breaks from your HTML content would be a big hassle, you can quickly //override the default Wiki-style line break rule// so that the line breaks use the standard HTML rules, by placing ''{{{<hide linebreaks>}}}'' //anywhere// within the HTML content.  This automatically converts all line breaks to spaces before rendering the content, so that the literal line breaks will be processed as simple word-breaks instead.

Alternatively, if you //always// want to omit all line breaks from the rendered output, you can set this option:
><<option chkHTMLHideLinebreaks>> ignore all line breaks
which can also be 'hard coded' into your document by adding the following to a tiddler, tagged with <<tag systemConfig>>
>{{{config.options.chkHTMLHideLinebreaks=true;}}}

Note: this does //not// alter the actual tiddler content that is stored in the document, just the manner in which it is displayed. Any line breaks contained in the tiddler will still be there when you edit its content. Also, to include a literal line break when the ''<{{{hide linebreaks}}}>'' tag is present, you will need to use a ''<{{{br}}}>'' or ''<{{{p}}}>'' HTML tag instead of simply typing a line break.
<<<
!!!!!How it works
<<<
The TW core support for HTML does not let you put ANY wiki-style syntax (including TW macros) *inside* the {{{<html>...</html>}}} block.  Everything between {{{<html>}}} and {{{</html>}}} is handed to the browser for processing and that is it.

However, not all wiki syntax can be safely passed through the browser's parser. Specifically, any TW macros inside the HTML will get 'eaten' by the browser since the macro brackets, {{{<<...>>}}} use the "<" and ">" that normally delimit the HTML/XML syntax recognized by the browser's parser.

Similarly, you can't use InlineJavascript within the HTML because the {{{<script>...</script>}}} syntax will also be consumed by the browser and there will be nothing left to process afterward.  Note: unfortunately, even though the browser removes the {{{<script>...</script>}}} sequence, it doesn't actually execute the embedded javascript code that it removes, so any scripts contained inside of <html> blocks in TW are currently being ignored. :-(

As a work-around to allow TW *macros* (but not inline scripts) to exist inside of <html> formatted blocks of content, the plugin first converts the {{{<<}}} and {{{>>}}} into "%%(" and ")%%", making them "indigestible" so they can pass unchanged through the belly of the beast (the browser's HTML parser).

After the browser has done its job, the wiki syntax sequences (including the "undigested" macros) are contained in #text nodes in the browser-generated DOM elements.  The plugin then recursively locates and processes each #text node, converts the %%( and )%% back into {{{<<}}} and {{{>>}}}, passes the result to wikify() for further rendering of the wiki-formatted syntax into a containing SPAN that replaces the previous #text node.  At the end of this process, none of the encoded %%( and )%% sequences remain in the rendered tiddler output.
<<<
!!!!!Revisions
<<<
2010.05.07 2.4.1 added chkHTMLHideLinebreaks option
2009.01.05 2.4.0 in wikifyTextNodes(), pass w.highlightRegExp and w.tiddler to wikify() so that search term highlighting and tiddler-relative macro processing will work
2008.10.02 2.3.0 added use of {{{<nowiki>}}} marker to bypass all wikification inside a specific HTML block
2008.09.19 2.2.0 in wikifyTextNodes(), don't wikify the contents of STYLE nodes (thanks to MorrisGray for bug report)
2008.04.26 [*.*.*] plugin size reduction: more documentation moved to HTMLFormattingInfo
2008.01.08 [*.*.*] plugin size reduction: documentation moved to HTMLFormattingInfo
2007.12.04 [*.*.*] update for TW2.3.0: replaced deprecated core functions, regexps, and macros
2007.06.14 2.1.5 in formatter, removed call to e.normalize().  Creates an INFINITE RECURSION error in Safari!!!!
2006.09.10 2.1.4 update formatter for 2.1 compatibility (use this.lookaheadRegExp instead of temp variable)
2006.05.28 2.1.3 in wikifyTextNodes(), decode the *value* of TEXTAREA nodes, but don't wikify() its children.  (thanks to "ayj" for bug report)
2006.02.19 2.1.2 in wikifyTextNodes(), put SPAN element into tiddler DOM (replacing text node), BEFORE wikifying the text content.  This ensures that the 'place' pasced to any macros is correctly defined when the macro is evaluated, so that calls to story.findContainingTiddler(place) will work as expected. (Thanks for bug report from GeoffSlocock)
2006.02.05 2.1.1 wrapped wikifier hijack in init function to eliminate globals and avoid FireFox 1.5.0.1 crash bug when referencing globals
2005.12.01 2.1.0 don't wikify #TEXT nodes inside SELECT and TEXTAREA elements
2005.11.06 2.0.1 code cleanup
2005.10.31 2.0.  replaced hijack wikify() with hijack config.formatters["html"] and simplified recursive WikifyTextNodes() code
2005.10.09 1.0.2 combined documentation and code into a single tiddleb
2005.08.05 1.0.1 moved HTML and CSS definitions into plugin code instead of using separate tiddlers
2005.07.26 1.0.1 Re-released as a plugin. Added <{{{html}}}>...</{{{nohtml}}}> and <{{{hide newlines}}}> handling
2005.06.26 1.0.0 Initial Release (as code adaptation - pre-dates TiddlyWiki plugin architecture!!)
<<<

<<tiddler HideTiddlerSubtitle>>
<html>Die Hesse'sche Normalenform (kurz: HNF) einer [[Ebene]] ist eine besondere Form der [[Ebenengleichung]], die zur Abstandsberechnung eingesetzt wird. Sie wird ermittelt, indem man die Normalenform der Ebenengleichung in Vektor- bzw. Koordinatendarstellung durch den Betrag des zugehörigen [[Normalenvektors|Normalenvektor]] dividiert bzw. den Normaleneinheitsvektor verwendet:
$$\mathrm{ E_{HNF}: \ \ \vec n^{\, 0}  \circ  (\vec X - \vec A) = 0}$$
$\hspace{4em}$bzw.
$$\mathrm{ E_{HNF}: \ \ \frac{n_1  \cdot  x_1  +  n_2  \cdot  x_2  +  n_3  \cdot  x_3  +  n_0}{|\, \vec n \,|}  =  0 }$$
Dabei bezeichnet $\mathrm{A}$ einen Punkt der Ebene $\mathrm{E}$ und $\mathrm{\vec n^{\, 0}}$ ihren Normaleneinheitsvektor.
</html>

window.showBackstage=config.options.txtUserName=="Kapitano";

{{{
config.options.chkHttpReadOnly = true;
}}}

/%
!info
|Name|HideTiddlerSubtitle|
|Source|http://www.TiddlyTools.com/#HideTiddlerSubtitle|
|Version|2.0.1|
|Author|Eric Shulman|
|License|http://www.TiddlyTools.com/#LegalStatements|
|~CoreVersion|2.1|
|Type|transclusion|
|Description|hide a tiddler's subtitle (date and author)|
Usage:
<<<
{{{
<<tiddler HideTiddlerSubtitle>>
<<tiddler HideTiddlerSubtitle with: TiddlerTitle>>
}}}
<<<
!end
!show
<<tiddler {{
	var title="$1";
	if (title=='$'+'1')
		title=(story.findContainingTiddler(place)||place).getAttribute('tiddler')||'';
	var t=story.getTiddler(title); if (t) {
		var e=t.getElementsByTagName('*');
		for (var i=0; i<e.length; i++)
			if (hasClass(e[i],'subtitle')) e[i].style.display='none';
	}
'';}}>>
!end
%/<<tiddler {{
	var src='HideTiddlerSubtitle';
	src+(tiddler&&tiddler.title==src?'##info':'##show');}}
with: [[$1]]<<tiddler HideTiddlerTags>><<tiddler HideTiddlerSubtitle>><<tiddler HideTiddlerSubtitle with: TiddlerTitle>>

/%
!info
|Name|HideTiddlerTags|
|Source|http://www.TiddlyTools.com/#HideTiddlerTags|
|Version|2.0.1|
|Author|Eric Shulman|
|License|http://www.TiddlyTools.com/#LegalStatements|
|~CoreVersion|2.1|
|Type|transclusion|
|Description|hide a tiddler's 'tagged' and 'tagging' displays (if any)|
Usage:
<<<
{{{
<<tiddler HideTiddlerTags>>
<<tiddler HideTiddlerTags with: TiddlerTitle>>
}}}
<<<
!end
!show
<<tiddler {{
	var title="$1";
	if (title=='$'+'1') {
		var here=story.findContainingTiddler(place);
		if (here) title=here.getAttribute('tiddler');
	}
	var t=story.getTiddler(title); if (t) {
		var e=t.getElementsByTagName('*');
		for (var i=0; i<e.length; i++)
			if (hasClass(e[i],'tagging')||hasClass(e[i],'tagged'))
				e[i].style.display='none';
	}
'';}}>>
!end
%/<<tiddler {{
	var src='HideTiddlerTags';
	src+(tiddler&&tiddler.title==src?'##info':'##show');}}
with: [[$1]]>>
<<tiddler HideTiddlerTags>><<tiddler HideTiddlerSubtitle>><<tiddler HideTiddlerSubtitle with: TiddlerTitle>>

<<tiddler HideTiddlerSubtitle>>
<html>Mithilfe eines Histogramms lässt sich die [[Wahrscheinlichkeitsverteilung]] einer [[Zufallsgröße]] beschreiben. Die [[Wahrscheinlichkeiten|Wahrscheinlichkeit]] werden als Rechtecksflächen dargestellt, wobei die Breite beliebig gewählt werden kann. Der Einfachheit halber wird für die Breite meist 1 gewählt. Die Rechtecke grenzen dabei direkt aneinander.
<p>Häufig wird die [[Binomialverteilung]] durch ein Histogramm veranschaulicht.

<p>!!!Beispiel:
<img width="262" height="280" hspace="20" style=" padding-bottom:20pt;  padding-top:10pt"  border="0" align="right" alt="Histogramm" src="img_glossar/Histogramm.png" />
Ein gezinktes Tetraeder mit den Seiten 1, 2, 3 und 4 hat folgende Wahrscheinlichkeitsverteilung:
{{Histogramm{
|Ergebnis | $\mathrm{1}$ | $\mathrm{2}$ | $\mathrm{3}$ | $\mathrm{4}$ |
|Wahrscheinlichkeit $\hspace{0.5em}$ | $\hspace{1em}\mathrm{\cfrac{2}{20}}\hspace{1em}$ | $\hspace{1em}\mathrm{\cfrac{10}{20}}\hspace{1em}$ | $\hspace{1em}\mathrm{\cfrac{5}{20}}\hspace{1em}$ | $\hspace{1em}\mathrm{\cfrac{3}{20}}\hspace{1em}$ |
}}}
\( \hspace{1.5em} \rightarrow \) [[Säulendiagramm]]
\( \hspace{1.5em} \rightarrow \) [[Kreisdiagramm]]
</html>

/***
To use, add {{{[[HorizontalMainMenuStyles]]}}} to your StyleSheet tiddler, or you can just paste the CSS in directly. See also HorizontalMainMenu and PageTemplate.
***/
/*{{{*/

#topMenu br {display:none; }
/*
#topMenu { background: #39a; }
*/
#topMenu { padding:2px; }
#topMenu .button,  #topMenu .tiddlyLink { padding-left:1em; padding-right:1em; color:white; font-size:115%;}
#displayArea { margin: 1em 15.7em 0em 1em; }

/* just in case want some QuickOpenTags in your topMenu */
#topMenu .quickopentag { padding:0px; margin:0px; border:0px; }
#topMenu .quickopentag .tiddlyLink { padding-right:1px; }
#topMenu .quickopentag .button { padding-left:1px; border:0px; }


/*}}}*/

<<tiddler HideTiddlerSubtitle>>
<html>In der Stochastik unterscheidet man zwischen absoluter und relativer Häufigkeit:
Die Anzahl, wie oft z.B. ein Ereignis A eines [[Zufallsexperiments|Zufallsexperiment]] eintritt, heißt absolute Häufigkeit.
Die relative Häufigkeit setzt dagegen diese Anzahl mit der Gesamtzahl der Wiederholungen des Experiments ins Verhältnis.
Häufigkeitsverteilungen werden oftmals durch [[Kreis-|Kreisdiagramm]] oder [[Säulendiagramme|Säulendiagramm]] veranschaulicht.

<p>!!!Beispiel:
Wirft man n-mal eine Münze, wobei $\mathrm{k}$-mal das [[Ereignis]] $\mathrm{A = \{Zahl\}}$ und $\mathrm{(n-k)}$-mal das Ereignis $\mathrm{B = {Kopf}}$ eintritt, dann ergeben sich:
<p style="margin-top:-5px";>*absolute Häufigkeit für Ereignis $\mathrm{A}$: $\mathrm{k}$
<p style="margin-top:-5px";>*relative Häufigkeit für Ereignis $\mathrm{A}$: $\mathrm{\large\frac{k}{n}}$
<p style="margin-top:-5px";>*absolute Häufigkeit für Ereignis $\mathrm{B}$: $\mathrm{n-k}$
<p style="margin-top:-5px";>*relative Häufigkeit für Ereignis $\mathrm{B}$: $\mathrm{\large \frac{n - k}{n}}$
</html>

<html><div style="margin-left:25px; line-height: 1.5;">
* [[Integral]]
* [[Integralfunktion]]

</div></html>

/***
|Name|ImageSizePlugin|
|Source|http://www.TiddlyTools.com/#ImageSizePlugin|
|Version|1.2.3|
|Author|Eric Shulman|
|License|http://www.TiddlyTools.com/#LegalStatements|
|~CoreVersion|2.1|
|Type|plugin|
|Description|adds support for resizing images|
This plugin adds optional syntax to scale an image to a specified width and height and/or interactively resize the image with the mouse.
!!!!!Usage
<<<
The extended image syntax is:
{{{
[img(w+,h+)[...][...]]
}}}
where ''(w,h)'' indicates the desired width and height (in CSS units, e.g., px, em, cm, in, or %). Use ''auto'' (or a blank value) for either dimension to scale that dimension proportionally (i.e., maintain the aspect ratio). You can also calculate a CSS value 'on-the-fly' by using a //javascript expression// enclosed between """{{""" and """}}""". Appending a plus sign (+) to a dimension enables interactive resizing in that dimension (by dragging the mouse inside the image). Use ~SHIFT-click to show the full-sized (un-scaled) image. Use ~CTRL-click to restore the starting size (either scaled or full-sized).
<<<
!!!!!Examples
<<<
{{{
[img(100px+,75px+)[images/meow2.jpg]]
}}}
[img(100px+,75px+)[images/meow2.jpg]]
{{{
[<img(34%+,+)[images/meow.gif]]
[<img(21% ,+)[images/meow.gif]]
[<img(13%+, )[images/meow.gif]]
[<img( 8%+, )[images/meow.gif]]
[<img( 5% , )[images/meow.gif]]
[<img( 3% , )[images/meow.gif]]
[<img( 2% , )[images/meow.gif]]
[img(  1%+,+)[images/meow.gif]]
}}}
[<img(34%+,+)[images/meow.gif]]
[<img(21% ,+)[images/meow.gif]]
[<img(13%+, )[images/meow.gif]]
[<img( 8%+, )[images/meow.gif]]
[<img( 5% , )[images/meow.gif]]
[<img( 3% , )[images/meow.gif]]
[<img( 2% , )[images/meow.gif]]
[img(  1%+,+)[images/meow.gif]]
{{tagClear{
}}}
<<<
!!!!!Revisions
<<<
2011.09.03 [1.2.3] bypass addStretchHandlers() if no '+' suffix is used (i.e., not resizable)
2010.07.24 [1.2.2] moved tip/dragtip text to config.formatterHelpers.imageSize object to enable customization
2009.02.24 [1.2.1] cleanup width/height regexp, use '+' suffix for resizing
2009.02.22 [1.2.0] added stretchable images
2008.01.19 [1.1.0] added evaluated width/height values
2008.01.18 [1.0.1] regexp for "(width,height)" now passes all CSS values to browser for validation
2008.01.17 [1.0.0] initial release
<<<
!!!!!Code
***/
//{{{
version.extensions.ImageSizePlugin= {major: 1, minor: 2, revision: 3, date: new Date(2011,9,3)};
//}}}
//{{{
var f=config.formatters[config.formatters.findByField("name","image")];
f.match="\\[[<>]?[Ii][Mm][Gg](?:\\([^,]*,[^\\)]*\\))?\\[";
f.lookaheadRegExp=/\[([<]?)(>?)[Ii][Mm][Gg](?:\(([^,]*),([^\)]*)\))?\[(?:([^\|\]]+)\|)?([^\[\]\|]+)\](?:\[([^\]]*)\])?\]/mg;
f.handler=function(w) {
	this.lookaheadRegExp.lastIndex = w.matchStart;
	var lookaheadMatch = this.lookaheadRegExp.exec(w.source)
	if(lookaheadMatch && lookaheadMatch.index == w.matchStart) {
		var floatLeft=lookaheadMatch[1];
		var floatRight=lookaheadMatch[2];
		var width=lookaheadMatch[3];
		var height=lookaheadMatch[4];
		var tooltip=lookaheadMatch[5];
		var src=lookaheadMatch[6];
		var link=lookaheadMatch[7];

		// Simple bracketted link
		var e = w.output;
		if(link) { // LINKED IMAGE
			if (config.formatterHelpers.isExternalLink(link)) {
				if (config.macros.attach && config.macros.attach.isAttachment(link)) {
					// see [[AttachFilePluginFormatters]]
					e = createExternalLink(w.output,link);
					e.href=config.macros.attach.getAttachment(link);
					e.title = config.macros.attach.linkTooltip + link;
				} else
					e = createExternalLink(w.output,link);
			} else
				e = createTiddlyLink(w.output,link,false,null,w.isStatic);
			addClass(e,"imageLink");
		}

		var img = createTiddlyElement(e,"img");
		if(floatLeft) img.align="left"; else if(floatRight) img.align="right";
		if(width||height) {
			var x=width.trim(); var y=height.trim();
			var stretchW=(x.substr(x.length-1,1)=='+'); if (stretchW) x=x.substr(0,x.length-1);
			var stretchH=(y.substr(y.length-1,1)=='+'); if (stretchH) y=y.substr(0,y.length-1);
			if (x.substr(0,2)=="{{")
				{ try{x=eval(x.substr(2,x.length-4))} catch(e){displayMessage(e.description||e.toString())} }
			if (y.substr(0,2)=="{{")
				{ try{y=eval(y.substr(2,y.length-4))} catch(e){displayMessage(e.description||e.toString())} }
			img.style.width=x.trim(); img.style.height=y.trim();
			if (stretchW||stretchH) config.formatterHelpers.addStretchHandlers(img,stretchW,stretchH);
		}
		if(tooltip) img.title = tooltip;

		// GET IMAGE SOURCE
		if (config.macros.attach && config.macros.attach.isAttachment(src))
			src=config.macros.attach.getAttachment(src); // see [[AttachFilePluginFormatters]]
		else if (config.formatterHelpers.resolvePath) { // see [[ImagePathPlugin]]
			if (config.browser.isIE || config.browser.isSafari) {
				img.onerror=(function(){
					this.src=config.formatterHelpers.resolvePath(this.src,false);
					return false;
				});
			} else
				src=config.formatterHelpers.resolvePath(src,true);
		}
		img.src=src;
		w.nextMatch = this.lookaheadRegExp.lastIndex;
	}
}

config.formatterHelpers.imageSize={
	tip: 'SHIFT-CLICK=show full size, CTRL-CLICK=restore initial size',
	dragtip: 'DRAG=stretch/shrink, '
}

config.formatterHelpers.addStretchHandlers=function(e,stretchW,stretchH) {
	e.title=((stretchW||stretchH)?this.imageSize.dragtip:'')+this.imageSize.tip;
	e.statusMsg='width=%0, height=%1';
	e.style.cursor='move';
	e.originalW=e.style.width;
	e.originalH=e.style.height;
	e.minW=Math.max(e.offsetWidth/20,10);
	e.minH=Math.max(e.offsetHeight/20,10);
	e.stretchW=stretchW;
	e.stretchH=stretchH;
	e.onmousedown=function(ev) { var ev=ev||window.event;
		this.sizing=true;
		this.startX=!config.browser.isIE?ev.pageX:(ev.clientX+findScrollX());
		this.startY=!config.browser.isIE?ev.pageY:(ev.clientY+findScrollY());
		this.startW=this.offsetWidth;
		this.startH=this.offsetHeight;
		return false;
	};
	e.onmousemove=function(ev) { var ev=ev||window.event;
		if (this.sizing) {
			var s=this.style;
			var currX=!config.browser.isIE?ev.pageX:(ev.clientX+findScrollX());
			var currY=!config.browser.isIE?ev.pageY:(ev.clientY+findScrollY());
			var newW=(currX-this.offsetLeft)/(this.startX-this.offsetLeft)*this.startW;
			var newH=(currY-this.offsetTop )/(this.startY-this.offsetTop )*this.startH;
			if (this.stretchW) s.width =Math.floor(Math.max(newW,this.minW))+'px';
			if (this.stretchH) s.height=Math.floor(Math.max(newH,this.minH))+'px';
			clearMessage(); displayMessage(this.statusMsg.format([s.width,s.height]));
		}
		return false;
	};
	e.onmouseup=function(ev) { var ev=ev||window.event;
		if (ev.shiftKey) { this.style.width=this.style.height=''; }
		if (ev.ctrlKey)  { this.style.width=this.originalW; this.style.height=this.originalH; }
		this.sizing=false;
		clearMessage();
		return false;
	};
	e.onmouseout=function(ev) { var ev=ev||window.event;
		this.sizing=false;
		clearMessage();
		return false;
	};
}
//}}}<<tiddler HideTiddlerTags>><<tiddler HideTiddlerSubtitle>><<tiddler HideTiddlerSubtitle with: TiddlerTitle>>

<html><div style="font-size:12px; margin-left:10px;">
http://www.stark-verlag.de and powered by ~TiddlyWiki 2.8.1. [[Copyright Information]]

</div></html>

/***
|Name|InlineJavascriptPlugin|
|Source|http://www.TiddlyTools.com/#InlineJavascriptPlugin|
|Documentation|http://www.TiddlyTools.com/#InlineJavascriptPluginInfo|
|Version|1.9.5|
|Author|Eric Shulman|
|License|http://www.TiddlyTools.com/#LegalStatements|
|~CoreVersion|2.1|
|Type|plugin|
|Requires||
|Overrides||
|Description|Insert Javascript executable code directly into your tiddler content.|
''Call directly into TW core utility routines, define new functions, calculate values, add dynamically-generated TiddlyWiki-formatted output'' into tiddler content, or perform any other programmatic actions each time the tiddler is rendered.
!!!!!Documentation
>see [[InlineJavascriptPluginInfo]]
!!!!!Revisions
<<<
2009.04.11 [1.9.5] pass current tiddler object into wrapper code so it can be referenced from within 'onclick' scripts
2009.02.26 [1.9.4] in $(), handle leading '#' on ID for compatibility with JQuery syntax
|please see [[InlineJavascriptPluginInfo]] for additional revision details|
2005.11.08 [1.0.0] initial release
<<<
!!!!!Code
***/
//{{{
version.extensions.InlineJavascriptPlugin= {major: 1, minor: 9, revision: 5, date: new Date(2009,4,11)};

config.formatters.push( {
	name: "inlineJavascript",
	match: "\\<script",
	lookahead: "\\<script(?: src=\\\"((?:.|\\n)*?)\\\")?(?: label=\\\"((?:.|\\n)*?)\\\")?(?: title=\\\"((?:.|\\n)*?)\\\")?(?: key=\\\"((?:.|\\n)*?)\\\")?( show)?\\>((?:.|\\n)*?)\\</script\\>",

	handler: function(w) {
		var lookaheadRegExp = new RegExp(this.lookahead,"mg");
		lookaheadRegExp.lastIndex = w.matchStart;
		var lookaheadMatch = lookaheadRegExp.exec(w.source)
		if(lookaheadMatch && lookaheadMatch.index == w.matchStart) {
			var src=lookaheadMatch[1];
			var label=lookaheadMatch[2];
			var tip=lookaheadMatch[3];
			var key=lookaheadMatch[4];
			var show=lookaheadMatch[5];
			var code=lookaheadMatch[6];
			if (src) { // external script library
				var script = document.createElement("script"); script.src = src;
				document.body.appendChild(script); document.body.removeChild(script);
			}
			if (code) { // inline code
				if (show) // display source in tiddler
					wikify("{{{\n"+lookaheadMatch[0]+"\n}}}\n",w.output);
				if (label) { // create 'onclick' command link
					var link=createTiddlyElement(w.output,"a",null,"tiddlyLinkExisting",wikifyPlainText(label));
					var fixup=code.replace(/document.write\s*\(/gi,'place.bufferedHTML+=(');
					link.code="function _out(place,tiddler){"+fixup+"\n};_out(this,this.tiddler);"
					link.tiddler=w.tiddler;
					link.onclick=function(){
						this.bufferedHTML="";
						try{ var r=eval(this.code);
							if(this.bufferedHTML.length || (typeof(r)==="string")&&r.length)
								var s=this.parentNode.insertBefore(document.createElement("span"),this.nextSibling);
							if(this.bufferedHTML.length)
								s.innerHTML=this.bufferedHTML;
							if((typeof(r)==="string")&&r.length) {
								wikify(r,s,null,this.tiddler);
								return false;
							} else return r!==undefined?r:false;
						} catch(e){alert(e.description||e.toString());return false;}
					};
					link.setAttribute("title",tip||"");
					var URIcode='javascript:void(eval(decodeURIComponent(%22(function(){try{';
					URIcode+=encodeURIComponent(encodeURIComponent(code.replace(/\n/g,' ')));
					URIcode+='}catch(e){alert(e.description||e.toString())}})()%22)))';
					link.setAttribute("href",URIcode);
					link.style.cursor="pointer";
					if (key) link.accessKey=key.substr(0,1); // single character only
				}
				else { // run script immediately
					var fixup=code.replace(/document.write\s*\(/gi,'place.innerHTML+=(');
					var c="function _out(place,tiddler){"+fixup+"\n};_out(w.output,w.tiddler);";
					try	 { var out=eval(c); }
					catch(e) { out=e.description?e.description:e.toString(); }
					if (out && out.length) wikify(out,w.output,w.highlightRegExp,w.tiddler);
				}
			}
			w.nextMatch = lookaheadMatch.index + lookaheadMatch[0].length;
		}
	}
} )
//}}}

// // Backward-compatibility for TW2.1.x and earlier
//{{{
if (typeof(wikifyPlainText)=="undefined") window.wikifyPlainText=function(text,limit,tiddler) {
	if(limit > 0) text = text.substr(0,limit);
	var wikifier = new Wikifier(text,formatter,null,tiddler);
	return wikifier.wikifyPlain();
}
//}}}

// // GLOBAL FUNCTION: $(...) -- 'shorthand' convenience syntax for document.getElementById()
//{{{
if (typeof($)=='undefined') { function $(id) { return document.getElementById(id.replace(/^#/,'')); } }
//}}}<<tiddler HideTiddlerTags>><<tiddler HideTiddlerSubtitle>><<tiddler HideTiddlerSubtitle with: TiddlerTitle>>

/***
|Name|InlineJavascriptPluginInfo|
|Source|http://www.TiddlyTools.com/#InlineJavascriptPlugin|
|Documentation|http://www.TiddlyTools.com/#InlineJavascriptPluginInfo|
|Version|1.9.6|
|Author|Eric Shulman|
|License|http://www.TiddlyTools.com/#LegalStatements|
|~CoreVersion|2.1|
|Type|documentation|
|Description|Documentation for InlineJavascriptPlugin|
''Call directly into TW core utility routines, define new functions, calculate values, add dynamically-generated TiddlyWiki-formatted output'' into tiddler content, or perform any other programmatic actions each time the tiddler is rendered.
!!!!!Usage
<<<
This plugin adds wiki syntax for surrounding tiddler content with {{{<script>}}} and {{{</script>}}} markers, so that it can be recognized as embedded javascript code.  When a tiddler is rendered, the plugin automatically invokes any embedded scripts, which can be used to construct and return dynamically-generated output that is inserted into the tiddler content.
{{{
<script type="..." src="..." label="..." title="..." key="..." show>
	/* javascript code goes here... */
</script>
}}}
All parameters are //optional//.    When the ''show'' keyword is used, the plugin will also include the script source code in the output that it displays in the tiddler.  This is helpful when creating examples for documentation purposes (such as used in this tiddler!)

__''Deferred execution from an 'onClick' link''__
<script label="click here" title="mouseover tooltip text" key="X" show>
	/* javascript code goes here... */
	alert('you clicked on the link!');
</script>
By including a {{{label="..."}}} parameter in the initial {{{<script>}}} marker, the plugin will create a link to an 'onclick' script that will only be executed when that specific link is clicked, rather than running the script each time the tiddler is rendered.  You may also include a {{{title="..."}}} parameter to specify the 'tooltip' text that will appear whenever the mouse is moved over the onClick link text, and a {{{key="X"}}} parameter to specify an //access key// (which must be a //single// letter or numeric digit only).

__''Loading scripts from external source files''__
<script src="URL" show>
	/* optional javascript code goes here... */
</script>You can also load javascript directly from an external source URL, by including a src="..." parameter in the initial {{{<script>}}} marker (e.g., {{{<script src="demo.js"></script>}}}).  This is particularly useful when incorporating third-party javascript libraries for use in custom extensions and plugins.  The 'foreign' javascript code remains isolated in a separate file that can be easily replaced whenever an updated library file becomes available.

In addition to loading the javascript from the external file, you can also use this feature to invoke javascript code contained within the {{{<script>...</script>}}} markers.  This code is invoked //after// the external script file has been processed, and can make immediate use of the functions and/or global variables defined by the external script file.
>Note: To ensure that your javascript functions are always available when needed, you should load the libraries from a tiddler that is rendered as soon as your TiddlyWiki document is opened, such as MainMenu.  For example: put your {{{<script src="..."></script>}}} syntax into a separate 'library' tiddler (e.g., LoadScripts), and then add {{{<<tiddler LoadScripts>>}}} to MainMenu so that the library is loaded before any other tiddlers that rely upon the functions it defines.
>
>Normally, loading external javascript in this way does not produce any direct output, and should not have any impact on the appearance of your MainMenu.  However, if your LoadScripts tiddler contains notes or other visible content, you can suppress this output by using 'inline CSS' in the MainMenu, like this: {{{@@display:none;<<tiddler LoadScripts>>@@}}}
<<<
!!!!!Creating dynamic tiddler content and accessing the ~TiddlyWiki DOM
<<<
An important difference between TiddlyWiki inline scripting and conventional embedded javascript techniques for web pages is the method used to produce output that is dynamically inserted into the document: in a typical web document, you use the {{{document.write()}}} (or {{{document.writeln()}}}) function to output text sequences (often containing HTML tags) that are then rendered when the entire document is first loaded into the browser window.

However, in a ~TiddlyWiki document, tiddlers (and other DOM elements) are created, deleted, and rendered "on-the-fly", so writing directly to the global 'document' object does not produce the results you want (i.e., replacing the embedded script within the tiddler content), and instead will //completely replace the entire ~TiddlyWiki document in your browser window (which is clearly not a good thing!)//.  In order to allow scripts to use {{{document.write()}}}, the plugin automatically converts and buffers all HTML output so it can be safely inserted into your tiddler content, immediately following the script.

''Note that {{{document.write()}}} can only be used to output "pure HTML" syntax.  To produce //wiki-formatted// output, your script should instead return a text value containing the desired wiki-syntax content'', which will then be automatically rendered immediately following the script.  If returning a text value is not sufficient for your needs, the plugin also provides an automatically-defined variable, 'place', that gives the script code ''direct access to the //containing DOM element//'' into which the tiddler output is being rendered.  You can use this variable to ''perform direct DOM manipulations'' that can, for example:
* generate wiki-formatted output using {{{wikify("...content...",place)}}}
* vary the script's actions based upon the DOM element in which it is embedded
* access 'tiddler-relative' DOM information using {{{story.findContainingTiddler(place)}}}
Note:
''When using an 'onclick' script, the 'place' element actually refers to the onclick //link text// itself, instead of the containing DOM element.''  This permits you to directly reference or modify the link text to reflect any 'stateful' conditions that might set by the script.  To refer to the containing DOM element from within an 'onclick' script, you can use "place.parentNode" instead.
<<<
!!!!!Instant "bookmarklets"
<<<
You can also use an 'onclick' link to define a "bookmarklet": a small piece of javascript that can be ''invoked directly from the browser without having to be defined within the current document.''  This allows you to create 'stand-alone' commands that can be applied to virtually ANY TiddlyWiki document... even remotely-hosted documents that have been written by others!!  To create a bookmarklet, simply define an 'onclick' script and then grab the resulting link text and drag-and-drop it onto your browser's toolbar (or right-click and use the 'bookmark this link' command to add it to the browser's menu).

Notes:
*When writing scripts intended for use as bookmarklets, due to the ~URI-encoding required by the browser, ''you cannot not use ANY double-quotes (") within the bookmarklet script code.''
*All comments embedded in the bookmarklet script must ''use the fully-delimited {{{/* ... */}}} comment syntax,'' rather than the shorter {{{//}}} comment syntax.
*Most importantly, because bookmarklets are invoked directly from the browser interface and are not embedded within the TiddlyWiki document, there is NO containing 'place' DOM element surrounding the script.  As a result, ''you cannot use a bookmarklet to generate dynamic output in your document,''  and using {{{document.write()}}} or returning wiki-syntax text or making reference to the 'place' DOM element will halt the script and report a "Reference Error" when that bookmarklet is invoked.
Please see [[InstantBookmarklets]] for many examples of 'onclick' scripts that can also be used as bookmarklets.
<<<
!!!!!Special reserved function name
<<<
The plugin 'wraps' all inline javascript code inside a function, {{{_out()}}}, so that any return value you provide can be correctly handled by the plugin and inserted into the tiddler.  To avoid unpredictable results (and possibly fatal execution errors), this function should never be redefined or called from ''within'' your script code.
<<<
!!!!!$(...) 'shorthand' function
<<<
As described by Dustin Diaz [[here|http://www.dustindiaz.com/top-ten-javascript/]], the plugin defines a 'shorthand' function that allows you to write:
{{{
$(id)
}}}
in place of the normal standard javascript syntax:
{{{
document.getElementById(id)
}}}
This function is provided merely as a convenience for javascript coders that may be familiar with this abbreviation, in order to allow them to save a few bytes when writing their own inline script code.
<<<
!!!!!Examples
<<<
simple dynamic output:
><script show>
	document.write("The current date/time is: "+(new Date())+"<br>");
	return "link to current user: [["+config.options.txtUserName+"]]\n";
</script>
dynamic output using 'place' to get size information for current tiddler:
><script show>
	if (!window.story) window.story=window;
	var title=story.findContainingTiddler(place).getAttribute("tiddler");
	var size=store.getTiddlerText(title).length;
	return title+" is using "+size+" bytes";
</script>
dynamic output from an 'onclick' script, using {{{document.write()}}} and/or {{{return "..."}}}
><script label="click here" show>
	document.write("<br>The current date/time is: "+(new Date())+"<br>");
	return "link to current user: [["+config.options.txtUserName+"]]\n";
</script>
creating an 'onclick' button/link that accesses the link text AND the containing tiddler:
><script label="click here" title="clicking this link will show an 'alert' box" key="H" show>
	if (!window.story) window.story=window;
	var txt=place.firstChild.data;
	var tid=story.findContainingTiddler(place).getAttribute('tiddler');
	alert('Hello World!\nlinktext='+txt+'\ntiddler='+tid);
</script>
dynamically setting onclick link text based on stateful information:
>{{block{
{{{
<script label="click here">
	/* toggle "txtSomething" value */
	var on=(config.txtSomething=="ON");
	place.innerHTML=on?"enable":"disable";
	config.txtSomething=on?"OFF":"ON";
	return "\nThe current value is: "+config.txtSomething;
</script><script>
	/* initialize onclick link text based on current "txtSomething" value */
	var on=(config.txtSomething=="ON");
	place.lastChild.previousSibling.innerHTML=on?"disable":"enable";
</script>
}}}
<script label="click here">
	/* toggle "txtSomething" value */
	var on=(config.txtSomething=="ON");
	place.innerHTML=on?"enable":"disable";
	config.txtSomething=on?"OFF":"ON";
	return "\nThe current value is: "+config.txtSomething;
</script><script>
	/* initialize onclick link text based on current "txtSomething" value */
	var on=(config.txtSomething=="ON");
	place.lastChild.innerHTML=on?"enable":"disable";
</script>
}}}
loading a script from a source url:
>http://www.TiddlyTools.com/demo.js contains:
>>{{{function inlineJavascriptDemo() { alert('Hello from demo.js!!') } }}}
>>{{{displayMessage('InlineJavascriptPlugin: demo.js has been loaded');}}}
>note: When using this example on your local system, you will need to download the external script file from the above URL and install it into the same directory as your document.
>
><script src="demo.js" show>
	return "inlineJavascriptDemo() function has been defined"
</script>
><script label="click to invoke inlineJavascriptDemo()" key="D" show>
	inlineJavascriptDemo();
</script>
<<<
!!!!!Revisions
<<<
2010.12.15 1.9.6 allow (but ignore) type="..." syntax
2009.04.11 1.9.5 pass current tiddler object into wrapper code so it can be referenced from within 'onclick' scripts
2009.02.26 1.9.4 in $(), handle leading '#' on ID for compatibility with JQuery syntax
2008.06.11 1.9.3 added $(...) function as 'shorthand' for document.getElementById()
2008.03.03 1.9.2 corrected fallback declaration of wikifyPlainText() (fixes Safari "parse error")
2008.02.23 1.9.1 in onclick function, use string instead of array for 'bufferedHTML' (fixes IE errors)
2008.02.21 1.9.0 output from 'onclick' scripts (return value or document.write() calls) are now buffered and rendered into into a span following the script.  Also, added default 'return false' handling if no return value provided (prevents HREF from being triggered -- return TRUE to allow HREF to be processed).  Thanks to Xavier Verges for suggestion and preliminary code.
2008.02.14 1.8.1 added backward-compatibility for use of wikifyPlainText() in TW2.1.3 and earlier
2008.01.08 [*.*.*] plugin size reduction: documentation moved to ...Info tiddler
2007.12.28 1.8.0 added support for key="X" syntax to specify custom access key definitions
2007.12.15 1.7.0 autogenerate URI encoded HREF on links for onclick scripts.  Drag links to browser toolbar to create bookmarklets.  IMPORTANT NOTE: place is NOT defined when scripts are used as bookmarklets.  In addition, double-quotes will cause syntax errors.  Thanks to PaulReiber for debugging and brainstorming.
2007.11.26 1.6.2 when converting "document.write()" function calls in inline code, allow whitespace between "write" and "(" so that "document.write ( foobar )" is properly converted.
2007.11.16 1.6.1 when rendering "onclick scripts", pass label text through wikifyPlainText() to parse any embedded wiki-syntax to enable use of HTML entities or even TW macros to generate dynamic label text.
2007.02.19 1.6.0 added support for title="..." to specify mouseover tooltip when using an onclick (label="...") script
2006.10.16 1.5.2 add newline before closing '}' in 'function out_' wrapper.  Fixes error caused when last line of script is a comment.
2006.06.01 1.5.1 when calling wikify() on script return value, pass hightlightRegExp and tiddler params so macros that rely on these values can render properly
2006.04.19 1.5.0 added 'show' parameter to force display of javascript source code in tiddler output
2006.01.05 1.4.0 added support 'onclick' scripts.  When label="..." param is present, a button/link is created using the indicated label text, and the script is only executed when the button/link is clicked.  'place' value is set to match the clicked button/link element.
2005.12.13 1.3.1 when catching eval error in IE, e.description contains the error text, instead of e.toString().  Fixed error reporting so IE shows the correct response text.  Based on a suggestion by UdoBorkowski
2005.11.09 1.3.0 for 'inline' scripts (i.e., not scripts loaded with src="..."), automatically replace calls to 'document.write()' with 'place.innerHTML+=' so script output is directed into tiddler content.  Based on a suggestion by BradleyMeck
2005.11.08 1.2.0 handle loading of javascript from an external URL via src="..." syntax
2005.11.08 1.1.0 pass 'place' param into scripts to provide direct DOM access
2005.11.08 1.0.0 initial release
<<<

<<tiddler HideTiddlerSubtitle>>
\( \ \rightarrow \) [[Bestimmtes Integral]]
\( \ \rightarrow \) [[Integralfunktion]]

<<tiddler HideTiddlerSubtitle>>
<html>Eine [[Funktion]] $\mathrm{F}$ der Form
$$\mathrm{ F(x) = \int\limits_a^x f(t) \:dt \, \ \ x \in D_F}$$
heißt Integralfunktion.
<p>$\mathrm{f(t)}$ wird dabei als Integrand bezeichnet.
</html>

Die [[Interface-Einstellungen|InterfaceOptions]] werden angezeigt, wenn Sie rechts auf 'Optionen' klicken. Sie werden mit einem Cookie in Ihrem Browser gespeichert, um sie zwischen den Aufrufen zu sichern. Nähere Informationen zu den einzelnen Funktionen finden Sie, wenn Sie die Funktion selbst anklicken.

<html><div style="margin-left:25px; line-height: 1.5;">
*[[Kosinusfunktion]]
*[[Kreis]]
*[[Kreisdiagramm]]
*[[Kreuzprodukt]]
*[[Krümmung]]
*[[Kugel]]
*[[Kumulative Verteilungsfunktion]]

</div></html>

<<tiddler HideTiddlerSubtitle>>
<html>Die Grundfunktion ist $\mathrm{f:\,x \mapsto \cos x}$.
<p>Für die [[Funktion]] $\mathrm{f}$ lassen sich folgende Aussagen treffen.
<p style="margin-top:-5px";>*[[Definitionsmenge]]: $\mathrm{ D=\mathbb R}$
<p style="margin-top:-5px";>*[[Wertemenge]]: $\mathrm{ W=[-1; \ 1]}$
<p style="margin-top:-5px";>*[[Nullstellen|Nullstelle]]: $\mathrm{\ldots \, , -\frac{\pi}{2},\ \frac{\pi}{2},\ \frac{3}{2} \pi,\ \frac{5}{2} \pi, \, \ldots}$
<p style="margin-top:-5px";>*[[Ableitung]]: $\mathrm{ f'(x) = -\sin x}$
<p style="margin-top:-5px";>*[[Stammfunktion]]: $\mathrm{ F(x)= \sin x \, + \, C}$
<p style="margin-top:-5px";>*[[Symmetrie]]: achsensymmetrisch zur y-Achse
<p style="margin-top:-5px";>*[[Periodizität]]: $\mathrm{2\pi}$-periodisch
<p><img vspace="0" hspace="20" border="0"  alt="Kosinusfunktion" src="img_glossar/Kosinusfunktion.png" />
</html>

<<tiddler HideTiddlerSubtitle>>
<html><img width="130"; vspace="0"; hspace="20"; border="0"; align="right"; height="200"; alt="Kreis" src="img_glossar/Kreis.png" />Ein Kreis ist die Menge aller Punkte in einer [[Ebene]], die von einem Punkt $\mathrm{M}$ - dem Mittelpunkt des Kreises - denselben [[Abstand]] haben. Dieser Abstand heißt Radius $\mathrm{r}$ des Kreises.
<p>Für alle Punkte X des Kreises gilt also:
<p style="margin-top: -5px;">$$\mathrm{{\Large|}\,\vec{MX}\,{\Large|} = {\Large|}\,\vec{X} - \vec{M}\,{\Large|} = r}$$
<p style="margin-top: -5px;">Hieraus entsteht durch Quadrieren die Kreisgleichung
<p style="margin-top: -5px;">$$\mathrm{(\vec X - \vec M )^2 = r^2 }$$
<p style="margin-top: -5px;">bzw. ausmultipliziert in Koordinatenform:
<p style="margin-top: -5px;">$$\mathrm{(x_1 - m_1)^2 + (x_2 - m_2)^2 = r^2}$$
</html>

<<tiddler HideTiddlerSubtitle>>
<html>Mithilfe eines Kreisdiagramms lässt sich die Häufigkeitsverteilung einer [[Zufallsgröße]] darstellen. Hierbei werden die relativen [[Häufigkeiten|Häufigkeit]] der [[Ergebnisse|Ergebnis]] anteilig auf einer Kreisfläche (360°) angetragen.
<p>!!!Beispiel:
Ein Tetraeder mit den Seiten 1, 2, 3 und 4 wird 36-mal geworfen. Aus den beobachteten Werten erhält man folgende Tabelle:
<p>|Ergebnis | $\mathrm{1}$ | $\mathrm{2}$ | $\mathrm{3}$ | $\mathrm{4}$ |
|Absolute Häufigkeit$\hspace{1em}$ | $\mathrm{10}$ | $\mathrm{6}$ | $\mathrm{12}$ | $\mathrm{8}$ |
|Relative Häufigkeit | $\hspace{1em}\mathrm{\cfrac{10}{36}}\hspace{1em}$ | $\hspace{1em}\mathrm{\cfrac{6}{36}}\hspace{1em}$ | $\hspace{1em}\mathrm{\cfrac{12}{36}}\hspace{1em}$ | $\hspace{1em}\mathrm{\cfrac{8}{36}}\hspace{1em}$ |
<p>Die zu den Ergebnissen gehörigen Winkel berechnet man über:
<p style=margin-top:-5px";>$\hspace{4em}\mathrm{\alpha_1 = \cfrac{10}{36} \cdot 360^\circ = 100^\circ}$
<p style=margin-top:-5px";>$\hspace{4em}\mathrm{\alpha_2 = \cfrac{6}{36} \cdot 360^\circ = 60^\circ}$
<p style=margin-top:-5px";>$\hspace{4em}\mathrm{\alpha_3 = \cfrac{12}{36} \cdot 360^\circ = 120^\circ}$
<p style=margin-top:-5px";>$\hspace{4em}\mathrm{\alpha_4 = \cfrac{8}{36} \cdot 360^\circ = 80^\circ}$
<p>Man erhält folgendes Kreisdiagramm:
<p><img width="171" vspace="0" hspace="20" border="0" height="171" alt="Kreisdiagramm" src="img_glossar/Kreisdiagramm.png" /><br /></span>
<p>\( \ \rightarrow \) [[Säulendiagramm]]
\( \ \rightarrow \) [[Histogramm]]
</html>

<<tiddler HideTiddlerSubtitle>>
<html>\( \ \rightarrow \) [[Vektorprodukt]]
</html>

<<tiddler HideTiddlerSubtitle>>
<html>Eine [[Funktion]] $\mathrm{f}$ ist rechtsgekrümmt (auch: konkav) in einem Intervall, wenn die zweite [[Ableitung]] $\mathrm{f''}$ in diesem Intervall negativ ist.
<p>Eine Funktion $\mathrm{f}$ ist linksgekrümmt (auch: konvex) in einem Intervall, wenn die zweite Ableitung $\mathrm{f''}$ in diesem Intervall positiv ist.

<p><img width="446"; height="131"; vspace="0"; hspace="20"; alt="Kruemmung"; src="img_glossar/Kruemmung.png"/>
</html>

<<tiddler HideTiddlerSubtitle>>
<html><img width="130"; height="201"; vspace="0"; hspace="20"; align="right"; src="img_glossar/Kugel.png" alt="Kugel" />Eine Kugel (eigentlich Kugeloberfläche) ist die Menge aller Punkte, die von  einem Punkt $\mathrm{M}$ - dem Mittelpunkt der Kugel - denselben [[Abstand]] haben. Dieser Abstand heißt Radius $\mathrm{r}$ der Kugel.
<p>Für alle Punkte X der Kugeloberfläche gilt also:
<p style="margin-top: -5px;">$$\mathrm{{\Large|}\,\vec{MX}\,{\Large|} = {\Large|}\,\vec{X} - \vec{M}\,{\Large|} = r}$$
<p style="margin-top: -5px;">Hieraus entsteht durch Quadrieren die Kugelgleichung
<p style="margin-top: -5px;">$$\mathrm{(\vec X - \vec M )^2 = r^2 }$$
<p style="margin-top: -5px;">bzw. ausmultipliziert in Koordinatenform:
<p style="margin-top: -5px;">$$\mathrm{(x_1 - m_1)^2 + (x_2 - m_2)^2 + (x_3 - m_3)^2 = r^2}$$
</html>

<<tiddler HideTiddlerSubtitle>>
<html>Eine kumulative Verteilungsfunktion ordnet ähnlich wie die Wahrscheinlichkeitsfunktion jeder Ausprägung einer [[Zufallsgröße]] eine [[Wahrscheinlichkeit]] zu. Jedoch werden hierbei nicht die Einzelwahrscheinlichkeiten betrachtet, sondern die Summe aller Wahrscheinlichkeiten, die kleiner oder gleich der angegebenen Ausprägung sind:
$$\mathrm{ F: \ \ z_{i} \ \mapsto \ P(Z \le z_{i})}$$

<p style="margin-top:-10px";>!!!Beispiel:
Beim Wurf eines fairen Würfels beschreibt die Zufallsgröße $\mathrm{Z}$ die Augenzahl. Dann gilt für die kumulative Verteilungsfunktion $\mathrm{F(3)}$:
<p style="margin-top:-5px";>$$\mathrm{ F(3)  =  P(Z \le 3)  =  P(1)  +  P(2)  +  P(3)  =  \cfrac{1}{6}  +  \cfrac{1}{6}  +  \cfrac{1}{6}  =  \cfrac{1}{2} }$$
</html>

<html><div style="margin-left:25px; line-height: 1.5;">
*[[Lage einer Ebene im Koordinatensystem]]
*[[Lage einer Geraden im Koordinatensystem]]
*[[Lagebeziehungen]]
*[[Länge eines Vektors]]
*[[Laplace-Experiment]]
*[[Lineare (Un-)Abhängigkeit]]
*[[Logarithmusfunktion]]
*[[Lösungsformel für quadratische Gleichungen]]

</div></html>

<<tiddler HideTiddlerSubtitle>>
<html>Um die (besondere) Lage einer [[Ebene]] im Koordinatensystem zu untersuchen, ist es vorteilhaft, die Normalenform in Koordinatendarstellung der Ebene zu betrachten.
Für eine Ebene $\mathrm{E}$ der Form $\mathrm{ E: \ \ n_1  \cdot  x_1  +  n_2  \cdot  x_2  +  n_3  \cdot  x_3  +  n_0  =  0}$ gilt:
<p>*Die Ebene $\mathrm{E}$ geht durch den Ursprung, wenn $\mathrm{n_0=0}$ ist.
<p style="margin-top:-5px";>*Die Ebene $\mathrm{E}$ ist [[parallel|Parallelität]] zur x~~1~~-Achse, wenn $\mathrm{n_1=0}$ ist.
<p style="margin-top:-10px";>$\hspace{2em} \rightarrow$ Analoge Aussagen gelten für die anderen beiden Koordinatenachsen.
<p style="margin-top:-5px";>*Die Ebene $\mathrm{E}$ ist parallel zur x~~1~~x~~2~~-Ebene, wenn $\mathrm{n_1=n_2=0}$ gilt.
<p style="margin-top:-10px";>$\hspace{2em} \rightarrow$ Auch hier gelten analoge Aussagen für die anderen Koordinatenebenen.
</html>

<<tiddler HideTiddlerSubtitle>>
<html>Eine Gerade g mit der Geradengleichung $\ \mathrm{ g: \ \ \vec X = \vec A + \mu  \cdot  \vec v \ ; \ \ \mu\in\mathbb R}$
<p style="margin-top:-5px";>*ist parallel zur x~~1~~-Achse, wenn ihr Richtungsvektor $\mathrm{\vec v}$ parallel zum Vektor $\mathrm{\begin{pmatrix}1\\ \mathrm{0}\\ \mathrm{0}\\ \end{pmatrix}}$ ist.
<p style="margin-top:-15px";>$\hspace{2em} \rightarrow$ Analoge Aussagen gelten für die anderen Koordinatenachsen.
<p style="margin-top:-5px";>*ist parallel zur x~~1~~x~~2~~-Ebene, wenn ihr Richtungsvektor $\mathrm{ \vec v}$ parallel zum Vektor $\mathrm{\begin{pmatrix}1\\ \mathrm{1}\\ \mathrm{0}\\ \end{pmatrix}}$ ist.
<p style="margin-top:-15px";>$\hspace{2em} \rightarrow$ Analoge Aussagen gelten für die anderen Koordinatenebenen.
</html>

<<tiddler HideTiddlerSubtitle>>
<html>Unter Lagebeziehung versteht man in der Geometrie die gegenseitige Lage geometrischer Objekte zueinander. Die Untersuchung der Lagebeziehung von [[Geraden|Gerade]] und [[Ebenen|Ebene]] kann anhand deren Darstellung mithilfe der Richtungs- bzw. [[Normalenvektoren|Normalenvektor]] erfolgen.
<p>\( \ \rightarrow \) [[Gegenseitige Lage zweier Geraden]]
\( \ \rightarrow \) [[Gegenseitige Lage von Gerade und Ebene]]
\( \ \rightarrow \) [[Gegenseitige Lage zweier Ebenen]]
\( \ \rightarrow \) [[Lage einer Ebene im Koordinatensystem]]
\( \ \rightarrow \) [[Lage einer Geraden im Koordinatensystem]]
</html>

<<tiddler HideTiddlerSubtitle>>
<html>Ein [[Zufallsexperiment]], bei dem jedes [[Ergebnis]] mit gleicher [[Wahrscheinlichkeit]] eintritt, heißt ~Laplace-Experiment. Besteht der Ergebnisraum $\mathrm{\Omega}$ aus $\mathrm{n}$ Elementen, so besitzt jedes Ergebnis ([[Elementarereignis]]) die ~Laplace-Wahrscheinlichkeit:
$$\mathrm{ p  =  \cfrac{1}{n}}$$
<p>Außerdem gilt für die Wahrscheinlichkeit eines beliebigen Ereignisses E:
<p style="margin-top: -5px;">$$\mathrm{ P(E)  =  \cfrac{\text{Anzahl der Elemente von }E}{\text{Anzahl der Elemente von }\Omega}  =  \cfrac{E}{\Omega}}$$

<p style="margin-top: -5px;">!!!Beispiel:
Der Wurf eines idealen Würfels ist ein ~Laplace-Experiment. Jede der sechs Zahlen wird mit gleicher Wahrscheinlichkeit geworfen. Daher gilt:
$$\mathrm{ P(\lbrace 1 \rbrace)  =  P(\lbrace 2 \rbrace)  =  P(\lbrace 3 \rbrace)  =  P(\lbrace 4 \rbrace)  =  P(\lbrace 5 \rbrace)  =  P(\lbrace 6 \rbrace)  =  p  = \cfrac{1}{6}}$$
!!!Gegenbeispiel:
Ein Wurf eines veränderten Würfels - auf vier Seiten steht 1, auf zwei Seiten steht 6 - ist kein ~Laplace-Experiment, denn für die Wahrscheinlichkeiten gilt:
$$\mathrm{ P(\lbrace 1 \rbrace)  =  \cfrac{4}{6}  &ne;  \cfrac{2}{6}  =  P(\lbrace 6 \rbrace) }$$
</html>

<<tiddler HideTiddlerSubtitle>>
<html>Zwei Vektoren heißen linear abhängig, wenn der eine ein Vielfaches des anderen ist (vgl. Skalarmultiplikation). Die beiden Vektoren sind dann [[parallel|Parallelität]]. Die Vektoren $\mathrm{\vec a}$ und $\mathrm{\vec b}$ sind also ''linear abhängig'', wenn gilt:
$$\mathrm{\vec a = \lambda \cdot \vec b \ \, ,\ \ \ \lambda\in\mathbb R}$$
<p>Zwei Vektoren $\mathrm{\vec a}$ und $\mathrm{\vec b}$ heißen ''linear unabhängig'', wenn sie nicht linear abhängig, also nicht parallel, sind. Es gilt also:
$$\mathrm{\vec a &ne; \lambda \cdot \vec b \ \, ,\ \ \ \lambda\in\mathbb R}$$
<p>Drei Vektoren im Raum heißen linear abhängig, wenn sie in einer [[Ebene]] liegen; andernfalls nennt man sie linear unabhängig.
</html>

<<tiddler HideTiddlerSubtitle>>
<html>Eine allgemeine Logarithmusfunktion zur Basis $\mathrm{a}$ ist folgende [[Funktion]]:
<p style="margin-top: 10px;">$\hspace{5em}\mathrm{ f:\,x \mapsto \log_a x \ , \ }$ wobei $\ \mathrm{ a\in\mathbb{R}^+\, \backslash\, \{1\}}$

<p>!!!Natürliche Logarithmusfunktion
Die wichtigste Logarithmusfunktion ist die zur Basis $\mathrm e$ (Euler'sche Zahl).
<p>Grundform: $\mathrm{f:\,x \mapsto  \ln x}$
<p>Für die Funktion lassen sich folgende Aussagen treffen:
<p style="margin-top:-5px";>*[[Definitionsmenge]]: \(\mathrm{ D = \mathbb{R}^+}\)
<p style="margin-top:-5px";>*[[Wertemenge]]: \(\mathrm{ W = \mathbb R}\)
<p style="margin-top:-5px";>*[[Nullstelle]]: \(\mathrm{x = 1}\)
<p>*Verhalten im Unendlichen: \(\mathrm{ \underset{x\to\infty}{lim} \ln x = \infty \ }\) und \( \ \mathrm{\underset{x\to 0^+}{lim} \ln x = -\infty}\)
<p style="margin-top:-10px";>*[[Ableitung]]: \(\mathrm{ f'(x) = \large\frac1{x}}\)
<p style="margin-top:-5px";>*[[Stammfunktion]]: \(\mathrm{ F(x) = -x + x\ln x + C}\)
<p style="margin-top:-5px";>*Die [[Umkehrfunktion|Umkehrbarkeit von Funktionen]] ist die [[Exponentialfunktion]]: \(\mathrm{ f^{-1}(x) = e^x}\)
<p><img width="293" height="294" vspace="0" hspace="20" border="0"  alt="Logarithmusfunktion" src="img_glossar/Logarithmusfunktion.png" />
</html>

<<tiddler HideTiddlerSubtitle>>
<html>Für die Länge bzw. den Betrag eines Vektors gilt:
$$\mathrm{ | \, \vec a \, |  =  \sqrt{\vec a  \circ  \vec a}  =  \sqrt{ \vec a^{\, 2}}  =  \sqrt{a_1^2  +  a_2^2  +  a_3^2}}$$
Die Länge der Strecke $\mathrm{[AB]}$ wird durch den Betrag des [[Verbindungsvektors|Verbindungsvektor]] von $\mathrm{A}$ und $\mathrm{B}$ berechnet:
<p style="margin-top: -5px;">$$\mathrm{ \overline {AB}  =  {\Large|} \vec{AB} {\Large|} = {\Large|}\vec B  -  \vec A {\Large|} }$$
</html>

<<tiddler HideTiddlerSubtitle>>
<html>Die Lösungen einer Gleichung der Form
$$\mathrm{ax^2 + bx + c=0 \, ; \ \ \ a &ne; 0 \, ; \ \ b,\,c\in\mathbb R}$$
können mithilfe der Lösungsformel für quadratische Gleichungen (auch als Mitternachtsformel bekannt) berechnet werden. Es gilt:
$$\mathrm{ x_{1/2} = \frac{-b \pm \sqrt{b^2 - 4ac}}{2a}}$$
Die Gleichung hat
<p style="margin-top:-5px";>*eine Lösung, wenn $\mathrm{ b^2-4ac=0,}$
<p style="margin-top:-5px";>*zwei Lösungen, wenn $\mathrm{ b^2-4ac&gt;0,}$
<p style="margin-top:-5px";>*keine Lösung, wenn $\mathrm{ b^2-4ac&lt;0.}$
<p>\( \ \rightarrow \) [[Quadratische Funktion]]
</html>

<html><div style="margin-left:25px; line-height: 1.5;">
*[[Mächtigkeit]]
*[[Maximumstelle]]
*[[Mengendiagramm]]
*[[Mengenschreibweise]]
*[[Minimumstelle]]
*[[Mittelpunkt einer Strecke]]
*[[Mittlere Änderungsrate]]
*[[Monotonie]]
*[[Monotoniekriterium]]

</div></html>

<<tiddler ToggleRightSidebar with: "Entwicklung">>
[[TiddlerTweaker]]
[[StyleSheet]]
[[FinalSaver]]

/***
|''Name''|PluginMathJax|
|''Description''|Displays TeX math using MathJax|
|''Author''|[[Canada East|http://tiddlywiki.canada-east.ca/]]|
|''Version''|1.3|
|''Date''|2010-10-07|
|''CodeRepository''|[[PluginMathJax|http://tiddlywiki.canada-east.ca/#PluginMathJax]]|
|''CoreVersion''|[[2.6.1|http://www.tiddlywiki.com]]|
|''Requires''|[[MathJax v1.01|http://www.mathjax.org/]]|
|''Feedback''|[[Contact|https://spreadsheets.google.com/viewform?formkey=dGg2RkpxZW5zWTh6QjZxOXgzZUlfakE6MQ]]|
|''Tweaks''|~MathJax location and default HTML-CSS scale changed by Gareth Davies.  I've also added a hook to a ~MathJax extension for managing local definitions written by Richard Lupton and I've set the newcommand extension to load on start-up.|
!Description
This plugin uses [[MathJax|http://www.mathjax.org/]] to typeset ([[AMS|http://www.ams.org/publications/authors/tex/amslatex]]) [[LaTeX|http://www.latex-project.org/]]  math. It can also be configured to use additional MathJax functionality.
>"MathJax is an open source JavaScript display engine for mathematics that works in all modern browsers."
!Notes
Right click any math display for a MathJax menu. The user can select the renderer and zoom settings. It performs best in [[Webkit|http://en.wikipedia.org/wiki/List_of_web_browsers#WebKit-based_browsers]] based browsers. Larger math displays such as the additional examples tiddler below can put quite a load on IE. PluginMathJax is based on: [[Plugin: jsMath|http://bob.mcelrath.org/tiddlyjsmath.html]]
!Installation
#''Backup'' your TiddlyWiki!
#It is required that the MathJax directory is installed in '''js/MathJax/''' in the same location as the TiddlyWiki html file.<br>(Or edit the script source where commented in the plugin code below after installation to match the location of your MathJax install.)
#Install this plugin (and examples tiddler linked below if desired).
!Usage
|!Source|!Output|h
|{{{The variable $x$ is real.}}}|The variable $x$ is real.|
|{{{The variable \(y\) is complex.}}}|The variable \(y\) is complex.|
|{{{This \[\int_a^b x = \frac{1}{2}(b^2-a^2)\] is an easy integral.}}}|This \[\int_a^b x = \frac{1}{2}(b^2-a^2)\] is an easy integral.|
|{{{This $$\int_a^b \sin x = -(\cos b - \cos a)$$ is another easy integral.}}}|This $$\int_a^b \sin x = -(\cos b - \cos a)$$ is another easy integral.|
|{{{Block formatted equations may also use the 'equation' environment \begin{equation}  \int \tan x = -\ln \cos x \end{equation} }}}|Block formatted equations may also use the 'equation' environment \begin{equation}  \int \tan x = -\ln \cos x \end{equation}|
|{{{Equation arrays are also supported \begin{eqnarray} a &=& b \\ c &=& d \end{eqnarray} }}}|Equation arrays are also supported \begin{eqnarray} a &=& b \\ c &=& d \end{eqnarray} |
|{{{I spent \$7.38 on lunch.}}}|I spent \$7.38 on lunch.|
|{{{I had to insert a backslash (\\) into my document}}}|I had to insert a backslash (\\) into my document|
| <br>[[Complete list of supported LaTeX commands|http://www.mathjax.org/resources/docs/?tex.html#supported-latex-commands]] |>|
!Examples
[[Additional MathJax Examples|MathJax Examples]]
!Configuration
MathJax can be manually configured if desired by editing the code below (advanced). See the [[MathJax documentation|http://www.mathjax.org/resources/docs/?configuration.html#configuration-options-by-component]] for details.
!Revision History
*v1.3, 2010-10-07, returned to original formatters design, kept modified wikify and recommended way of loading MathJax dynamically, removed the tex2jax extension and corrected several browser compatibility issues (InnerHTML for Opera and IE9).
*v1.2, 2010-10-05, removed some redundant MathJax config entries, moved modified wikify and MathJax.Hub.Queue call.
*v1.1, 2010-10-03, autoLinkWikiWords disabled in absence of DisableWikiLinksPlugin, modifed wikify.
*v1.0, 2010-09-26, Initial Release
!Code
***/
//{{{

if(!version.extensions.PluginMathJax) {
    version.extensions.PluginMathJax = { installed: true };

    config.extensions.PluginMathJax = {

        install: function() {

            var script = document.createElement("script");
            script.type = "text/javascript";

            // *** Use the location of your MathJax! *** :
            /*
             * Gareth: The following line assumes you have
             * MathJax installed on your server in a sensible
             * location.  I've commented this out.
             */
            // script.src = "js/MathJax/MathJax.js";

            /*
             * Because this tiddlywiki is currently hosted on
             * tiddlyspace.com I've had to point to the 'MathJax
             * Content Delivery Network' instead.
             */
            script.src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML"
            // EndGareth

            /*
             * Gareth: Richard's local definition ~MathJax
             * extension (implementation of TeXs \let command)
             * has been added to the list of extensions along
             * with the newcommand extension upon which it
             * depends.  Also, the scale option for HTML-CSS was
             * changed from 115 to 100.
             */
            var mjconfig = 'MathJax.Hub.Config({' +
            'jax: ["input/TeX","output/HTML-CSS"],' +
          	'displayAlign: "left", displayIndent: "5em",'+
            'extensions: ["TeX/AMSmath.js", "TeX/AMSsymbols.js", "TeX/newcommand.js"],' +
            '"HTML-CSS": {' +
                'scale: 100' +
                '}' +
            '});' +

            'MathJax.Hub.Startup.onload();';

            var ie9RegExp = /^9\./;
            var UseInnerHTML = (config.browser.isOpera || config.browser.isIE && ie9RegExp.test(config.browser.ieVersion[1]));

            if (UseInnerHTML) {script.innerHTML = mjconfig;}
                else {script.text = mjconfig;}

            script.text = mjconfig;

            document.getElementsByTagName("head")[0].appendChild(script);

            // Define wikifers for latex
            config.formatterHelpers.mathFormatHelper = function(w) {
                var e = document.createElement(this.element);
                e.type = this.type;
                var endRegExp = new RegExp(this.terminator, "mg");
                endRegExp.lastIndex = w.matchStart+w.matchLength;
                var matched = endRegExp.exec(w.source);
                if(matched) {
                    var txt = w.source.substr(w.matchStart+w.matchLength,
                        matched.index-w.matchStart-w.matchLength);
                    if(this.keepdelim) {
                      txt = w.source.substr(w.matchStart, matched.index+matched[0].length-w.matchStart);
                    }
                    if (UseInnerHTML) {
                        e.innerHTML = txt;
                    } else {
                        e.text = txt;
                    }
                    w.output.appendChild(e);
                    w.nextMatch = endRegExp.lastIndex;
                }
            }

            config.formatters.push({
              name: "displayMath1",
              match: "\\\$\\\$",
              terminator: "\\\$\\\$\\n?",
              termRegExp: "\\\$\\\$\\n?",
              element: "script",
              type: "math/tex; mode=display",
              handler: config.formatterHelpers.mathFormatHelper
            });

            config.formatters.push({
              name: "inlineMath1",
              match: "\\\$",
              terminator: "\\\$",
              termRegExp: "\\\$",
              element: "script",
              type: "math/tex",
              handler: config.formatterHelpers.mathFormatHelper
            });

            var backslashformatters = new Array(0);

            backslashformatters.push({
              name: "inlineMath2",
              match: "\\\\\\\(",
              terminator: "\\\\\\\)",
              termRegExp: "\\\\\\\)",
              element: "script",
              type: "math/tex",
              handler: config.formatterHelpers.mathFormatHelper
            });

            backslashformatters.push({
              name: "displayMath2",
              match: "\\\\\\\[",
              terminator: "\\\\\\\]\\n?",
              termRegExp: "\\\\\\\]\\n?",
              element: "script",
              type: "math/tex; mode=display",
              handler: config.formatterHelpers.mathFormatHelper
            });

            backslashformatters.push({
              name: "displayMath3",
              match: "\\\\begin\\{equation\\}",
              terminator: "\\\\end\\{equation\\}\\n?",
              termRegExp: "\\\\end\\{equation\\}\\n?",
              element: "script",
              type: "math/tex; mode=display",
              handler: config.formatterHelpers.mathFormatHelper
            });

            // These can be nested.  e.g. \begin{equation} \begin{array}{ccc} \begin{array}{ccc} ...
            backslashformatters.push({
              name: "displayMath4",
              match: "\\\\begin\\{eqnarray\\}",
              terminator: "\\\\end\\{eqnarray\\}\\n?",
              termRegExp: "\\\\end\\{eqnarray\\}\\n?",
              element: "script",
              type: "math/tex; mode=display",
              keepdelim: true,
              handler: config.formatterHelpers.mathFormatHelper
            });

            // The escape must come between backslash formatters and regular ones.
            // So any latex-like \commands must be added to the beginning of
            // backslashformatters here.
            backslashformatters.push({
                name: "escape",
                match: "\\\\.",
                handler: function(w) {
                    w.output.appendChild(document.createTextNode(w.source.substr(w.matchStart+1,1)));
                    w.nextMatch = w.matchStart+2;
                }
            });

          config.formatters=backslashformatters.concat(config.formatters);

          old_wikify = wikify;
          wikify = function(source,output,highlightRegExp,tiddler)
          {
              old_wikify.apply(this,arguments);
              if (window.MathJax) {MathJax.Hub.Queue(["Typeset",MathJax.Hub,output])}
          };

        }
    };

  config.extensions.PluginMathJax.install();

}

//}}}<<tiddler HideTiddlerTags>><<tiddler HideTiddlerSubtitle>><<tiddler HideTiddlerSubtitle with: TiddlerTitle>>

<<tiddler HideTiddlerSubtitle>>
\( \ \rightarrow \) [[Extremstellen]]

<<tiddler HideTiddlerSubtitle>>
<html>Mithilfe von Mengendiagrammen (~Venn-Diagrammen) können Mengenbeziehungen veranschaulicht werden.

Beispiele findet man hierzu im Eintrag [[Mengenschreibweise]].
</html>

<<tiddler HideTiddlerSubtitle>>
<html> In der Mengenlehre verwendet man zur Notation bestimmter Beziehungen zwischen verschiedenen Mengen $\mathrm{A}$ und $\mathrm{B}$ folgende Symbole:
| $\hspace{2.5em}\mathrm{A\cup B}\hspace{2.5em}$ | $\hspace{2.5em}$Vereinigung$\hspace{2.5em}$ | [img[Mengenschreibweise_Vereinigung|img_glossar/Mengenschreibweise_Vereinigung.png]] |
| $\hspace{2.5em}\mathrm{A\cap B}\hspace{2.5em}$ | $\hspace{2.5em}$Schnitt$\hspace{2.5em}$ | [img[Mengenschreibweise_Vereinigung|img_glossar/Mengenschreibweise_Schnitt.png]] |
| $\hspace{2.5em}\mathrm{\overline A}\hspace{2.5em}$ | $\hspace{2.5em}$Komplement$\hspace{2.5em}$ | [img[Mengenschreibweise_Komplement|img_glossar/Mengenschreibweise_Komplement.png]] |

<p>!!!Beispiel:
<div style="line-height:2;">Beim [[Zufallsexperiment]] Würfelwurf seien die beiden [[Ereignisse|Ereignis]] $\mathrm{A}$ und $\mathrm{B}$ wie folgt definiert:
$\mathrm{A = {1, 2, 3}}$ (in Worten: „Es wird 1, 2 oder 3 gewürfelt")
$\mathrm{B = {2, 4, 6}}$ (in Worten: „Es wird eine gerade Zahl gewürfelt")
Dann gilt für die Schnittmenge $\mathrm{A ∩ B = \{2\}}$, für die Vereinigung $\mathrm{A ∪ B = \{1, 2, 3, 4, 6\}}$ und für die beiden Komplemente $\mathrm{ \overline A = \{4, 5, 6\}}$ bzw. $\mathrm{ \overline B = \{1, 3, 5\}}$.</div>
</html>

<<tiddler HideTiddlerSubtitle>>
\( \ \rightarrow \) [[Extremstellen]]

Manchmal ist es sinnvoll, dass bei kleinen Änderungen der Tiddler in der Zeitachse nicht automatisch an den Anfang gesetzt wird. Mit Aktivierung dieser Funktion werden alle Bearbeitungen von Tiddlern als kleine Änderungen betrachtet und das Änderungsdatum nicht geändert.

<<tiddler HideTiddlerSubtitle>>
<html>Der [[Ortsvektor]] des Mittelpunktes $\mathrm{M}$ einer Strecke $\mathrm{[AB]}$ wird berechnet, indem man die Ortsvektoren der Punkte $\mathrm{A}$ und $\mathrm{B}$ addiert und diese Summe durch 2 dividiert:
<p style="margin-top:5px;">$$\mathrm{\vec M = \cfrac12  \cdot  (\vec A  + \vec B) }$$
</html>

<<tiddler HideTiddlerSubtitle>>
<html>Die mittlere Änderungsrate oder Sekantensteigung einer [[Funktion]] beschreibt die durchschnittliche Steigung zwischen zwei Punkten auf dem Graphen einer Funktion. Sie kann mithilfe des [[Differenzenquotienten|Differenzenquotient]] bestimmt werden.
</html>

<<tiddler HideTiddlerSubtitle>>
<html>Eine [[Funktion]] $\mathrm{f}$ heißt monoton steigend, wenn für alle $\mathrm{x, \ y}$ in $\mathrm{D_f}$ gilt:
<p style="margin-top:-10px;">$$\mathrm{x \leq y \ \ \ \Rightarrow \ \ \ f(x) \leq f(y)}$$
<p style="margin-top:10px;">$\mathrm{f}$ heißt streng monoton steigend, wenn für alle $\mathrm{x, \ y}$ in $\mathrm{D_f}$ gilt:
<p style="margin-top:-10px;">$$\mathrm{x < y \ \ \ \Rightarrow \ \ \ f( x ) < f( y )}$$
<p style="margin-top:10px;">$\mathrm{f}$ heißt monoton fallend, wenn für alle $\mathrm{x, \ y}$ in $\mathrm{D_f}$ gilt:
<p style="margin-top:-10px;">$$\mathrm{x \leq y \ \ \ \Rightarrow \ \ \ f( x ) \geq f( y )}$$
<p style="margin-top:10px;">$\mathrm{f}$ heißt streng monoton fallend, wenn für alle $\mathrm{x, \ y}$ in $\mathrm{D_f}$ gilt:
<p style="margin-top:-10px;">$$\mathrm{x < y \ \ \ \Rightarrow \ \ \ f( x ) > f( y ) }$$
\( \ \rightarrow \) [[Monotoniekriterium]]
<img width="258"; height="218"; vspace="20"; hspace="20"; alt="Monotonie"; src="img_glossar/Monotonie.png" />
</html>

<<tiddler HideTiddlerSubtitle>>
<html>Ist die erste [[Ableitung]] $\mathrm{f'}$ in einem Intervall negativ, d.h. $\mathrm{f'(x)<0}$, so fällt die Funktion $\mathrm{f}$ in diesem Intervall streng monoton.
<p>Ist die erste Ableitung $\mathrm{f'}$ in einem Intervall positiv, d.h. $\mathrm{f'(x)>0}$, so steigt die Funktion $\mathrm{f}$ in diesem Intervall streng monoton.
<p>\( \ \rightarrow \) [[Monotonie]]
</html>

<<tiddler HideTiddlerSubtitle>>
<html>Mit der Mächtigkeit einer Menge wird die Anzahl der Elemente in der Menge bezeichnet.
Die Mächtigkeit der [[Ergebnismenge]] $\mathrm{|\, \Omega \, |}$ ist die Anzahl der möglichen [[Ergebnisse|Ergebnis]] in $\mathrm{\Omega}$.

<p style="margin-top:-15px";>!!!Beispiel:
Beim Münzwurf ist die Mächtigkeit der Ergebnismenge $\mathrm{|\, \Omega \, | = 2}$, da die beiden möglichen Ergebnisse „Kopf" oder „Zahl" eintreten können.
</html>

<html><div style="margin-left:25px; line-height: 1.5;">
*[[Newton-Verfahren]]
*[[Normale]]
*[[Normalenvektor]]
*[[Nullhypothese]]
*[[Nullstelle]]
*[[Nullvektor]]

</div></html>

<<tiddler HideTiddlerSubtitle>>
<html>Wenn man die [[Nullstellen|Nullstelle]] einer [[Funktion]] nicht einfach berechnen kann, gibt es verschiedene Möglichkeiten, eine genäherte Lösung zu erhalten. Dies geht zum Beispiel mit dem ~Newton-Verfahren.

Um die Nullstelle einer Funktion $\mathrm{f(x)}$ anzunähern, wählt man sich ein $\mathrm{x_0}$ in der Nähe der Nullstelle. Als Nächstes wird die [[Tangente]] von $\mathrm{f(x)}$ in $\mathrm{x_0}$ gebildet. Deren [[Schnittpunkt]] $\mathrm{x_1}$ mit der x-Achse ist die erste Näherung der Nullstelle. Um ein genaueres Ergebnis zu erhalten, nimmt man die Tangente von $\mathrm{f(x)}$ in $\mathrm{x_1}$ und berechnet deren Schnittpunkt $\mathrm{x_2}$ mit der x-Achse.
Umso öfter man das Verfahren anwendet, desto besser wird die Näherung der Nullstelle.

Formal bedeutet dies:
$$\mathrm{ x_{n+1} = x_n - \cfrac{f(x_n)}{f'(x_n)} }$$
<img width="199"; height="171"; vspace="20"; hspace="20"; src="img_glossar/Newtonverfahren.png"; alt="Newton"/>
</html>

<<tiddler HideTiddlerSubtitle>>
<html>Die Normale durch einen Punkt $\mathrm{A(x_0 \, | \, f(x_0))}$ steht senkrecht auf der [[Tangente]] von $\mathrm{f(x)}$ in $\mathrm{x_0}$.
<p>Für die Normalensteigung gilt:
$$\mathrm{ m_{\,N} = -\frac1{m_{\;T}} = -\cfrac1{f'(x_0)} }$$

<img vspace="0" hspace="20" border="0"  alt="Normale" src="img_glossar/Normale.png" />
</html>

<<tiddler HideTiddlerSubtitle>>
<html> Einen Vektor $\mathrm{\vec n}$, der senkrecht auf einer [[Ebene]] $\mathrm{E}$ steht, nennt man Normalenvektor von $\mathrm{E}$.<img width="260"; height="126"; vspace="0"; hspace="20"; align="right";  src="img_glossar/Normalenvektor.png" alt="Normalenvektor" />
Dabei steht ein Vektor genau dann senkrecht auf der Ebene $\mathrm{E}$, wenn er senkrecht auf ihren beiden Spannvektoren steht.
<p>Einen Normalenvektor $\mathrm{\vec n}$ der Ebene $\mathrm{E}$ erhält man
<p style="margin-top:-5px";>*aus der Normalenform der Ebenengleichung, indem man die Koeffizienten der einzelnen Koordinaten als entsprechende Koordinaten von $\mathrm{\vec n}$ wählt:
<p style="margin-top:-5px";>$\mathrm{\hspace{2em} E: \ \ n_1  \cdot  x_1 + n_2 \cdot x_2 + n_3 \cdot x_3 + n_0 = 0 \ \ \ \Rightarrow \ \ \ \vec n  = \begin{pmatrix} n_1 \\ \mathrm{n_2}\\ \mathrm{n_3}\\ \end{pmatrix}}$
<p>*aus der Parameterform der Ebenengleichung, indem man das Vektorprodukt der Spannvektoren $\mathrm{\vec v}$ und $\mathrm{\vec w}$ bildet:
<p style="margin-top:-5px";>$\mathrm{\hspace{2em} E: \ \ \vec X = \vec A + \lambda \cdot \vec v + \mu \cdot \vec w \ \ \ \Rightarrow \ \ \ \vec n  = \vec v \times \vec w}$
</html>

<<tiddler HideTiddlerSubtitle>>
<html>Bei einem [[Signifikanztest]] wird die Nullhypothese $\mathrm{H_0}$ auf ein bestimmtes [[Signifikanzniveau]] $\mathrm \alpha$ überprüft. Sie wird nach der Entscheidungsregel entweder abgelehnt oder angenommen. Auch bei Annahme der Nullhypothese ist ihre Gültigkeit nicht bewiesen. Daher versucht man stets, die Nullhypothese abzulehnen.
</html>

<<tiddler HideTiddlerSubtitle>>
<html>Die Stellen, bei denen der Graph einer [[Funktion]] $\mathrm{f}$ die x-Achse schneidet, heißen Nullstellen. Sie werden berechnet, indem man die Funktionsgleichung gleich null setzt $\mathrm{(f(x) = 0)}$ und die Gleichung nach $\mathrm{x}$ auflöst.
<p>Tritt eine Nullstelle zweimal auf, so spricht man von einer doppelten Nullstelle. Tritt die Nullstelle k-fach auf, so handelt es sich um eine k-fache Nullstelle.  Ist k gerade, so schneidet der Graph der Funktion die x-Achse an dieser Stelle nicht, sondern berührt sie nur.</html>{{invisibletable{
| doppelte Nullstelle bei $\mathrm{x=1}$ |$\hspace{1em}$| dreifache Nullstelle bei $\mathrm{x=0}$ |
|[img[Nullstelle1|img_glossar/Nullstelle1.png]] |$\hspace{1em}$|[img[Nullstelle2|img_glossar/Nullstelle2.png]] |
}}}

<<tiddler HideTiddlerSubtitle>>
<html>Den Ortsvektor des Ursprungs bezeichnet man als Nullvektor: $\mathrm{ \vec o = \begin{pmatrix} 0 \\ \mathrm{0}\\ \mathrm{0} \end{pmatrix} }$
</html>

<html><div style="margin-left:25px; line-height: 1.5;">
*[[Orthogonalität]]
*[[Ortsvektor]]

</div></html>

Diese Funktion öffnet externe Links in einem neuen ~Browser-Fenster.

Diese [[Interface-Einstellungen|InterfaceOptions]] zur Anpassung von TiddlyWiki werden in Ihrem Browser gespeichert

Ihr Benutzername zum Unterzeichnen Ihrer Einträge. Bitte als WikiWord (z.B. KlausBrandmüller) schreiben

<<option txtUserName>>
<<option chkSaveBackups>> [[Backups speichern|SaveBackups]]
<<option chkAutoSave>> [[Automatisch speichern|AutoSave]]
<<option chkRegExpSearch>> [[RegExp Suche|RegExpSearch]]
<<option chkCaseSensitiveSearch>> [[Groß-/Kleinschreibung in Suche|CaseSensitiveSearch]]
<<option chkAnimate>> [[Animationen aktivieren|EnableAnimations]]

----[[Erweiterte Optionen|AdvancedOptions]]
PluginManager
ImportTiddlers

<<tiddler HideTiddlerSubtitle>>
<html>Zwei geometrische Objekte sind orthogonal, wenn sie senkrecht zueinander verlaufen, d. h., wenn sie einen rechten Winkel einschließen.
<p>Zwei Vektoren können mithilfe des [[Skalarprodukts|Skalarprodukt]] auf Orthogonalität überprüft werden:
$$\mathrm{ \vec a \perp \vec b \ \ \ \Leftrightarrow \ \ \ \vec a \circ \vec b = 0}$$
<p>Die Orthogonalität von anderen geometrischen Objekten, wie [[Geraden|Gerade]] und [[Ebenen|Ebene]], lässt sich auf die Orthogonalität bestimmter Vektoren zurückführen:
<p  style="margin-top:-10px;">*Zwei Geraden sind orthogonal, wenn ihre Richtungsvektoren orthogonal sind.
<p  style="margin-top:-10px;">*Zwei Ebenen sind orthogonal, wenn ihre beiden [[Normalenvektoren|Normalenvektor]] orthogonal sind.
<p  style="margin-top:-10px;">*Eine Gerade und eine Ebene sind orthogonal zueinander, wenn der Normalenvektor der Ebene parallel zum Richtungsvektor der Geraden ist.
</html>

<<tiddler HideTiddlerSubtitle>>
<html><img width="300"; height="184";vspace="0"; hspace="20"; align="right"; style="padding-bottom:20px"; alt="Ortsvektor"; src="img_glossar/Ortsvektor.png" />Den [[Verbindungsvektor]] vom Ursprung zu einem Punkt im Koordinatensystem nennt man den Ortsvektor des Punktes.
<p>Der Ortsvektor des Punktes $\mathrm{A(a_1\, | \,a_2 \, | \, a_3)}$ lautet: $\mathrm{ \vec A = \begin{pmatrix} a_1 \\ \mathrm{a_2}\\ \mathrm{a_3} \end{pmatrix}}$
</html>

<html><div style="margin-left:25px; line-height: 1.5;">
*[[Parallelität]]
*[[Parallelogramm]]
*[[Periodizität]]
*[[Pfadregeln]]
*[[Polstelle]]
*[[Polynomdivision]]
*[[Potenzfunktion]]
*[[Pyramide]]

</div></html>

<<tiddler HideTiddlerSubtitle>>
<html>Zwei geometrische Objekte sind parallel zueinander, wenn sie „in die gleiche Richtung" verlaufen.
Konkret sind zwei Vektoren parallel, wenn sie ein Vielfaches voneinander sind, d. h.:
<p>$\hspace{5em}\mathrm{ \vec a \parallel \vec b \ \ \ \Leftrightarrow \ \ \ \vec a = k \cdot \vec b} \ \ $ mit $\ \ {\mathrm k \in \mathbb{R}}$
<p>Die Parallelität von anderen geometrischen Objekten, wie [[Geraden|Gerade]] und [[Ebenen|Ebene]], lässt sich auf die Parallelität bestimmter Vektoren zurückführen:
<p  style="margin-top:-10px;">*Zwei Geraden sind parallel, wenn ihre Richtungsvektoren parallel sind (also linear abhängig).
<p  style="margin-top:-10px;">*Zwei Ebenen sind parallel, wenn ihre beiden [[Normalenvektoren|Normalenvektor]] parallel sind.
<p  style="margin-top:-10px;">*Eine Gerade und eine Ebene sind parallel zueinander, wenn der Normalenvektor der Ebene auch senkrecht auf dem Richtungsvektor der Geraden steht.
</html>

<<tiddler HideTiddlerSubtitle>>
<html>Ein Parallelogramm ist ein Viereck, bei dem die gegenüberliegenden Seiten jeweils parallel sind.
<img width="250"; height="164"; vspace="0"; hspace="20"; align="right"; alt="Parallelogramm"; src=&qquot;img_glossar/Parallelogramm.png" />Spezialfälle des Parallelogramms sind [[Raute]], [[Rechteck]] und [[Quadrat]].
<p>Für das Parallelogramm ABCD, wie es die Skizze zeigt, gilt:
<p  style="margin-top:-5px;">*Gegenüberliegende Seiten sind gleich lang.
<p  style="margin-top:-5px;">*Die Diagonalen halbieren sich gegenseitig.
<p  style="margin-top:-5px;">*Die Innenwinkelsumme beträgt 360°.
<p  style="margin-top:-5px;">*Gegenüberliegende Winkel sind gleich groß.
<p  style="margin-top:-5px;">*Benachbarte Winkel ergänzen sich zu 180°.
<p style="margin-top:15pt;">Der ''Flächeninhalt'' berechnet sich zu:
$$\mathrm{ A_P = {\large |}\, \vec a \,{\large |} \cdot h ={\large |}\,\vec a\,{\large|} \cdot {\large |}\,\vec b\,{\large |} \cdot \sin\beta}$$ oder mithilfe des [[Vektorprodukts|Vektorprodukt]]:
$$\mathrm{ A_P = {\large |} \,\vec a \times \vec b \,{\large |} }$$
</html>

<<tiddler HideTiddlerSubtitle>>
<html>Eine [[Funktion]] $\mathrm{f}$ heißt periodisch mit Periode $\mathrm{p > 0}$, wenn gilt:
<p>$\hspace{5em}\mathrm{f(x) = f(x+p)} \ \$ für alle $\ \ \mathrm{x, \ x+p ∈ D_f}$
<p>Der Graph einer periodischen Funktion wiederholt sich somit im Abstand $\mathrm{p}$.
<p>\( \ \rightarrow \) [[Sinusfunktion]]
\( \ \rightarrow \) [[Kosinusfunktion ]]
</html>

<<tiddler HideTiddlerSubtitle>>
<html>Mithilfe der beiden Pfadregeln kann man aus einem [[Baumdiagramm]] [[Wahrscheinlichkeiten|Wahrscheinlichkeit]] berechnen.
!!!1. Pfadregel
Die 1. Pfadregel liefert die Wahrscheinlichkeit eines [[Ergebnisses|Ergebnis]] ([[Elementarereignisses|Elementarereignis]]). Sie ist das Produkt der Wahrscheinlichkeiten entlang des Pfades, der zu diesem Ergebnis führt.
!!!2. Pfadregel
Die 2. Pfadregel liefert die Wahrscheinlichkeit eines [[Ereignisses|Ereignis]]. Sie ist die Summe der Wahrscheinlichkeiten aller Pfade, die zu diesem Ereignis</span> führen.

<p>!!!Beispiel:
<div style="line-height:2;">Beim dreifachen Münzwurf seien die Ereignisse $\mathrm{A}$ und $\mathrm{B}$ wie folgt definiert:
$\mathrm{A = \{ZZZ\}, \ B = \{KZZ, ZKZ, ZZK\}}$, wobei $\mathrm{Z}$ für Zahl und $\mathrm{K}$ für Kopf steht.</div>
<p><img width="447" vspace="10" hspace="20" border="0" height="206" src="img_glossar/Pfadregel.png" alt="Pfadregel"  />
<p>Mithilfe der 1. Pfadregel erhält man:
<p>$$\mathrm{ P(A) = \frac{1}{2} \cdot \frac{1}{2} \cdot \frac{1}{2} = \frac{1}{8}}$$
Mithilfe der 2. Pfadregel erhält man:
<p>$$\mathrm{ P(B) = P(KZZ) + P(ZKZ) + P(ZZK) = \frac{1}{8} + \frac{1}{8} + \frac{1}{8} = \frac{3}{8}}$$
</html>

<<tiddler HideTiddlerSubtitle>>
Eine [[gebrochen-rationale Funktion|Gebrochen-rationale Funktion]]
$$\mathrm{f:\, x \ \mapsto \  \cfrac{g(x)}{h(x)}}$$
hat an der Stelle $\mathrm{ x_0}$ eine Polstelle, wenn
* $\mathrm{x_0}$ [[Nullstelle]] des Nenners $\mathrm{h(x)}$ ist und nicht zugleich Nullstelle des Zählers $\mathrm{g(x)}$.
* $\mathrm{x_0}$ zugleich eine Nullstelle des Zählers $\mathrm{g(x)}$ und des Nenners $\mathrm{h(x)}$ ist und die Vielfachheit der Nullstelle im Nenner größer ist als die Vielfachheit der Nullstelle im Zähler.

Bei Annäherung an die Polstelle $\mathrm{ x_0}$ von links bzw. rechts streben die Funktionswerte der gebrochen-rationalen Funktion $\mathrm{f(x)}$ gegen $\mathrm{+\infty}$ bzw. $\mathrm{ -\infty}$, d.h. für die einseitigen Grenzwerte gilt:
$$\mathrm{ \lim\limits_{x \rightarrow x_0^+}f(x) =  \pm\infty \ \ \ bzw. \ \ \ \lim\limits_{x \rightarrow x_0^-}f(x) = \pm\infty}$$
Ist $\mathrm{ x_0}$ eine Polstelle ungerader Ordnung, dann besitzen die einseitigen Grenzwerte unterschiedliche Vorzeichen. Ist $\mathrm{x_0}$ hingegen eine Polstelle gerader Ordnung, dann besitzen die einseitigen Grenzwerte das gleiche Vorzeichen. Insgesamt unterscheidet man vier Fälle:
!!!Beispiele:
|$\hspace{1em}$|$\mathrm{f(x) = \cfrac{1}{1 + x}}$ |$\hspace{1.5em}$|$\mathrm{ f(x) = \cfrac{-1}{1 + x}}$ |
|$\hspace{1em}$|[<img(80%, )[Polstelle_ungerade1|img_glossar/Polstelle(ungerade).1.png]] |$\hspace{1.5em}$|[<img(80%, )[Polstelle_ungerade2|img_glossar/Polstelle(ungerade).2.png]] |
|$\hspace{1em}$|$\mathrm{x_0 = -1}$ ist ungerade Polstelle |$\hspace{1.5em}$|$\mathrm{ x_0 = -1}$ ist ungerade Polstelle |
|$\hspace{1em}$|Nähert man sich von links der Polstelle, strebt der Funktionswert gegen $\mathrm{ -\infty}$. Nähert man sich von rechts, strebt er gegen $\mathrm{ +\infty:}$ |$\hspace{1.5em}$|Nähert man sich von links der Polstelle, strebt der Funktionswert gegen $\mathrm{ +\infty}$. Nähert man sich von rechts, strebt er gegen $\mathrm{ -\infty:}$ |
|$\hspace{1em}$|$\mathrm{\hspace{1.5em}\lim\limits_{x \rightarrow -1^-}f(x) =  -\infty}$ |$\hspace{1.5em}$|$\mathrm{\hspace{1.5em} \lim\limits_{x \rightarrow -1^-}f(x) =  +\infty}$ |
|$\hspace{1em}$|$\mathrm{\hspace{1.5em} \lim\limits_{x \rightarrow -1^+}f(x) =  +\infty}$ |$\hspace{1.5em}$|$\mathrm{\hspace{1.5em} \lim\limits_{x \rightarrow -1^+}f(x) =  -\infty}$ |
<script>place.lastChild.className="noBorderPolstelle"</script>
|$\hspace{1em}$|$\mathrm{f(x) = \cfrac{1}{(1 + x)^2}}$ |$\hspace{1.5em}$|$\mathrm{ f(x) = \cfrac{-1}{(1 + x)^2}}$ |
|$\hspace{1em}$|[<img(80%, )[Polstelle_gerade1|img_glossar/Polstelle(gerade).1.png]] |$\hspace{1.5em}$|[<img(80%, )[Polstelle_gerade2|img_glossar/Polstelle(gerade).2.png]] |
|$\hspace{1em}$|$\mathrm{x_0 = -1}$ ist gerade Polstelle |$\hspace{1.5em}$|$\mathrm{ x_0 = -1}$ ist gerade Polstelle |
|$\hspace{1em}$|Unabhängig von welcher Seite man sich der Polstelle nähert, strebt der Funktionswert gegen $\mathrm{ +\infty:}$ |$\hspace{1.5em}$|Unabhängig von welcher Seite man sich der Polstelle nähert, strebt der Funktionswert gegen $\mathrm{ -\infty:}$ |
|$\hspace{1em}$|$\mathrm{\hspace{1.5em}\lim\limits_{x \rightarrow -1^-}f(x) =  +\infty}$  |$\hspace{1.5em}$|$\mathrm{\hspace{1.5em} \lim\limits_{x \rightarrow -1^-}f(x) =  -\infty}$|
|$\hspace{1em}$|$\mathrm{\hspace{1.5em} \lim\limits_{x \rightarrow -1^+}f(x) =  +\infty}$  |$\hspace{1.5em}$|$\mathrm{\hspace{1.5em} \lim\limits_{x \rightarrow -1^+}f(x) =  -\infty}$|
<script>place.lastChild.className="noBorderPolstelle"</script>
\( \ \rightarrow \) [[Gebrochen-rationale Funktion]]

<<tiddler HideTiddlerSubtitle>>
<html>Die Polynomdivision ist ein Verfahren, um [[Nullstellen|Nullstelle]] von Polynomen zu berechnen. Kennt oder errät man eine Nullstelle $\mathrm{x_0}$ der [[ganzrationalen Funktion|Ganzrationale Funktion]]
$$\mathrm{ f(x) = a_n x^n + a_{n-1}x^{n-1} + \ldots + a_2 x^2 + a_1 x + a_0\,; \ \ \ a_i \in\mathbb{R}\,; \ \ i = 0 \ldots n\,; \ \ a_n &ne; 0}\,,$$
dann lässt sich der Funktionsterm durch den Faktor $\mathrm{(x − x_0)}$ dividieren und der Grad des Funktionsterms wird um 1 niedriger. Dieser Vorgang lässt sich fortsetzen, bis eine quadratische Gleichung vorliegt.

<p>!!!Beispiel:
$\hspace{0.8em}\mathrm{(x^3-7x^2-x+7) : (x-1) = \bf x^2-6x-7}$
$\mathrm{\underline{-(x^3-x^2)}}$
$\hspace{2.25em}\mathrm{-6x^2-x}$
$\hspace{1.15em}\mathrm{\underline{-(-6x^2+6x)}}$
$\hspace{4.6em}\mathrm{-7x+x}$
$\hspace{3.6em}\mathrm{\underline{-(-7x+7)}}$
$\hspace{7.6em}\mathrm{0}$
</html>

<<tiddler HideTiddlerSubtitle>>
<html>Eine [[Funktion]] mit der Variablen $\mathrm{x}$ als Basis nennt man Potenzfunktion. Allgemein kann man eine Potenzfunktion folgendermaßen definieren:
$$\hspace{5em} \mathrm{ f(x) = a \cdot x ^n \ \, ,\ \ \ n\in\mathbb{Z}; \ \ a\in\mathbb{R}  \backslash  \{0\}}$$

Für den Fall $\mathrm{n > 0}$ lassen sich für die Funktion $\mathrm{f}$ folgende Aussagen treffen:
<p style="margin-top:-5px";>*[[Definitionsmenge]]: $\mathrm{ D = \mathbb R}$
<p style="margin-top:-5px";>*[[Nullstellen|Nullstelle]]: $\mathrm{x = 0}$ (n-fache Nullstelle)
<p style="margin-top:-5px";>*[[Ableitung]]: $\mathrm{ f'(x) = n  \cdot a x^{n - 1}}$
<p style="margin-top:-5px";>*[[Stammfunktion]]: $\mathrm{ F(x) = \cfrac a {n + 1}\cdot x^{n+1}  +  C}$
<p style="margin-top:-5px";>*[[Symmetrie]]:
**punktsymmetrisch zum Ursprung für $\mathrm{n}$ ungerade
**achsensymmetrisch zur y-Achse für $\mathrm{n}$ gerade
<p>{{invisibletable{
| [img[Potenzfunktion1|img_glossar/Potenzfunktion1.png]] |$\hspace{1em}$| [img[Potenzfunktion2|img_glossar/Potenzfunktion2.png]] |
}}}
<p style="margin-top:-10px";>Für den Fall $\mathrm{n < 0}$ lassen sich für die Funktion $\mathrm{f}$ folgende Aussagen treffen:
<p style="margin-top:-5px";>*Definitionsmenge: $\mathrm{ D = \mathbb{R} \backslash \{0\}}$
<p style="margin-top:-5px";>*Nullstellen: keine
<p style="margin-top:-5px";>*Ableitung: $\mathrm{ f'(x) = n \cdot a x^{n-1}}$
<p style="margin-top:-5px";>*Stammfunktion: $\mathrm{F(x) = \left\{ \begin{array}{ll}
\mathrm{\cfrac{a}{n+1}\cdot x^{n+1} + C, }&\mathrm{ \ falls \ n &ne; -1} \\
\mathrm{a \cdot ln|\, x\, | + C, }&\mathrm{ \ falls \ n = -1} \end{array} \right. }$
<p style="margin-top:-5px";>*Symmetrie:
**punktsymmetrisch zum Ursprung für $\mathrm{n}$ ungerade
**achsensymmetrisch zur y-Achse für $\mathrm{n}$ gerade
<p>{{invisibletable{
| [img[Potenzfunktion3|img_glossar/Potenzfunktion3.png]] | | [img[Potenzfunktion4|img_glossar/Potenzfunktion4.png]] |
}}}</html>

<<tiddler HideTiddlerSubtitle>>
<html>Eine Pyramide ist ein Körper, der dadurch entsteht, dass die Eckpunkte eines Vielecks (der Grundfläche) mit einem nicht in der Grundflächenebene liegenden Punkt (der Spitze) verbunden werden. Die Seitenflächen einer Pyramide sind demnach stets [[Dreiecke|Dreieck]]; die Oberfläche besteht aus Grund- und Mantelfläche.

<img width="170" vspace="0" hspace="20" align="right" style="padding-bottom:20pt;"  height="176" src="img_glossar/Pyramide_dreiseitig.png" alt="Pyramide dreiseitg" /> Ist die Grundfläche ein Dreieck, so spricht man von einer dreiseitigen Pyramide (da die Mantelfläche der Pyramide in diesem Fall aus drei Seitenflächen besteht). Eine dreiseitige Pyramide wird auch Tetraeder genannt.
Das Volumen einer dreiseitigen Pyramide, die von den Vektoren $\mathrm{ \vec a, \ \vec b}$ und $\mathrm{ \vec c}$ aufgespannt wird (s. Skizze), lässt sich wie folgt berechnen:
$$\mathrm{ V  =  \cfrac13  \cdot  G  \cdot  h  =  \cfrac{1}{6}  \cdot  \left|\, \vec a  \circ (\vec b  \times  \vec c )\,\right|}$$

<img width="170" vspace="0" hspace="20" style="padding-bottom:20pt;"  align="right" height="177" src="img_glossar/Pyramide_vierseitig.png" alt="Pyramide vierseitig"  />Ist die Grundfläche ein Viereck, so spricht man von einer vierseitigen Pyramide (da die Mantelfläche der Pyramide in diesem Fall aus vier Seitenflächen besteht).
Das Volumen einer vierseitigen Pyramide, die von den Vektoren $\mathrm{ \vec a, \ \vec b}$ und $\mathrm{ \vec c}$ aufgespannt wird und deren Grundfläche ein [[Parallelogramm]] ist (s. Skizze), lässt sich wie folgt berechnen:
$$\mathrm{ V  =  \cfrac13  \cdot  G  \cdot  h  =  \cfrac{1}{3}  \cdot  \left|\,\vec a  \circ  (\vec b  \times  \vec c )\,\right|}$$
</html>

<html><div style="margin-left:25px; line-height: 1.5;">
*[[Quadrat]]
*[[Quadratische Funktion]]

</div></html>

<<tiddler HideTiddlerSubtitle>>
<html><img width="120" vspace="10" hspace="25"  border="0" align="right" height="116" src="img_glossar/Quadrat.png" alt="Quadrat" title="Quadrat"  />Ein Quadrat ist ein Viereck, bei dem alle vier Seiten gleich lang sind und einer der Innenwinkel 90° beträgt. Das Quadrat ist ein Spezialfall von [[Trapez]] und [[Drachenviereck]].
<p>Für das Quadrat ABCD, wie es in der Skizze gezeigt ist, gilt:
<p style="margin-top: -5px;">*Die Diagonalen sind gleich lang, stehen senkrecht aufeinander und halbieren sich gegenseitig. Sie sind zudem Symmetrieachsen des Quadrats.
<p style="margin-top: -5px;">*Die Innenwinkelsumme beträgt 360°.
<p style="margin-top: -5px;">*Alle Innenwinkel betragen 90°.
<p style="margin-top: -5px;">*Der Flächeninhalt berechnet sich zu:
<p style="margin-top: -10px;">$\hspace{3em}\mathrm{ A_Q = {\large|}\,\vec{AB}\,{\large|}^{\, 2}}$
</html>

<<tiddler HideTiddlerSubtitle>>
<html>Eine [[Funktion]] der Form
$$\mathrm{ f(x)= ax^2 + bx + c; \ \ \ a &ne; 0; \ \ b,\,c\in\mathbb R}$$
nennt man quadratische Funktion. Eine quadratische Funktion ist ein Spezialfall einer [[ganzrationalen Funktion|Ganzrationale Funktion]].

Die [[Nullstellen|Nullstelle]] einer quadratischen Funktion lassen sich mithilfe der allgemeinen [[Lösungsformel (Mitternachtsformel)|Lösungsformel für quadratische Gleichungen]] berechnen. Es gilt:
$$\mathrm{ x_{1/2} = \frac{-b \pm \sqrt{b^2 - 4ac}}{2a}}$$
Eine quadratische Funktion hat
<p style="margin-top:-5px";>*eine Nullstelle, wenn $\mathrm{ b^2-4ac=0,}$
<p style="margin-top:-5px";>*zwei Nullstellen, wenn $\mathrm{ b^2-4ac&gt;0,}$
<p style="margin-top:-5px";>*keine Nullstelle, wenn $\mathrm{ b^2-4ac&lt;0.}$
<p><img vspace="0" hspace="20" border="0"  alt="Quadratische Funktion" src="img_glossar/Quadratische-Funktion.png" />
</html>

<html><div style="margin-left:25px; line-height: 1.5;">
*[[Raute]]
*[[Rechenregeln für Integrale]]
*[[Rechnen mit Vektoren]]
*[[Rechteck]]

</div></html>

<<tiddler HideTiddlerSubtitle>>
<html><img width="130" vspace="0" hspace="20" border="0" align="right" height="203"  alt="Raute" src="img_glossar/Raute.png" /> Eine Raute ist ein Viereck, bei dem alle Seiten gleich lang sind. Ein Spezialfall der Raute ist das [[Quadrat]]. Die Raute ist ein Spezialfall von [[Trapez]] und [[Drachenviereck]].
<p>Für die Raute ABCD, wie sie in der Skizze zu sehen ist, gilt:
<p  style="margin-top:-5px;">*Die Diagonalen stehen senkrecht aufeinander und halbieren sich gegenseitig. Sie sind zudem Symmetrieachsen der Raute.
<p  style="margin-top:-5px;">*Die Innenwinkelsumme beträgt 360°.
<p  style="margin-top:-5px;">*Die Innenwinkel werden durch die Diagonalen halbiert.
<p  style="margin-top:-5px;">*Gegenüberliegende Winkel sind gleich groß.
<p  style="margin-top:-5px;">*Benachbarte Winkel ergänzen sich zu 180°.
<p  style="margin-top:-5px;">*Der Flächeninhalt berechnet sich wie folgt:
<p  style="margin-top:-5px;">$$ \mathrm{ A_{Ra} = \frac{{\large|}\,\vec{AC}\,{\large|} \, \cdot \, {\large|} \,\vec{BD} \, {\large|}}{2} = \frac{e \cdot f}{2} }$$
$\hspace{1.7em}$Oder alternativ mithilfe des [[Vektorprodukts|Vektorprodukt]]:
$$ \mathrm{ A_{Ra} = {\large|}\,\vec{AB}\,\times\,\vec{BC}\,{\large|}}$$
</html>

<<tiddler HideTiddlerSubtitle>>
<html>*Wenn bei einem bestimmten [[Integral]] die Integrationsgrenzen vertauscht werden, ändert sich das Vorzeichen des Integrals:
<p style="margin-top:-5pt;">$$\mathrm{\int\limits_a^b f(x) \:dx\,=\,-\int\limits_b^a f(x) \:dx}$$
*Ein Integral, bei dem untere und obere Integrationsgrenze gleich sind, ist immer gleich null:
<p style="margin-top:-5pt;">$$\mathrm{ \int\limits_a^a f(x) \:dx\,=\,0}$$
*Ein konstanter Faktor kann aus dem Integral herausgezogen werden:
<p style="margin-top:-5pt;">$$\mathrm{\int\limits_a^b k\,\cdot\, f(x) \:dx\,=\,k\,\cdot\,\int\limits_a^b f(x) \:dx, \ k\in\mathbb{R}}$$
*Das Integral über die Summe zweier Funktionen ist gleich der Summe über die Integrale der Funktionen:
<p style="margin-top:-5pt;">$$\mathrm{\int\limits_a^b f(x) \,\pm \, g(x) \:dx\,=\,\int\limits_a^b f(x) \:dx \ \pm \ \int\limits_a^b g(x) \:dx}$$
*Ein Integral kann in mehrere Integrale aufgespalten werden:
<p style="margin-top:-5pt;">$$\mathrm{\int\limits_a^b f(x) \:dx\,=\,\int\limits_a^c f(x)\:dx\ +\ \int\limits_c^b f(x) \:dx}$$
*Wenn eine Funktion $\mathrm{f(x)}$ für alle $\mathrm{x}$ kleiner ist als eine Funktion $\mathrm{g(x)}$, so ist auch das Integral über $\mathrm{f(x)}$ kleiner als das Integral über $\mathrm{g(x)}$:
<p style="margin-top:-5pt;">$$\mathrm{ f(x) \ < \ g(x) \ \ \ \Rightarrow \ \ \ \int\limits_a^b f(x) \:dx \ &lt; \ \int\limits_a^b g(x) \:dx}$$
</html>
!!!Wichtige unbestimmte Integrale sind:
|$$\mathrm{ \int x^r \ \, dx=\frac{x^{r+1}}{r+1} \ +\ C}$$ |$$\hspace{-3em}\mathrm{ \int \frac1x \ \, dx=\ln|x|\ +\ C}$$ |
|$$\mathrm{ \int \sin x \ \, dx=-\cos x\ + \ C}$$ |$$\hspace{-3em}\mathrm{ \int \cos x \ \, dx=\sin x\ + \ C}$$ |
|$$\mathrm{ \int e^x \ \, dx=e^x\ +\ C}$$ |$$\hspace{-3em}\mathrm{ \int \ln x \ \, dx=-x\ + \ x\ln x \ +\ C}$$ |
|$$\mathrm{ \int \frac{f'(x)}{f(x)} \ \, dx=\ln|f(x)|\ +\ C}$$ |$$\hspace{-3em}\mathrm{ \int f'(x)\cdot e^{f(x)} \ \, dx=e^{f(x)}\ +\ C}$$ |
|$$\mathrm{ \int f(ax+b) \ \, dx=\frac{1}{a}F(ax+b) \ +\ C}$$ | |
|$\hspace{4em}\mathrm{F(x)}$ stellt dabei eine Stammfunktion von $\mathrm{f(x)}$ dar. | |
<script>place.lastChild.className="noBorderPolstelle"</script>

<<tiddler HideTiddlerSubtitle>>
<html>Mit Vektoren lassen sich im Anschauungsraum verschiedene Operationen durchführen, z. B. kann ein Vektor an den Endpunkt eines anderen Vektors angetragen werden. Den einfachsten dieser Operationen entsprechen algebraische Rechenoperationen mit den in Koordinatenschreibweise dargestellten Vektoren. So kommt man auf drei Grundrechenarten, die für Vektoren gelten:
<p>\( \ \rightarrow \) [[Vektoraddition]]
\( \ \rightarrow \) [[Vektorsubtraktion]]
\( \ \rightarrow \) [[Skalarmultiplikation ]]
</html>

<<tiddler HideTiddlerSubtitle>>
<html><img width="200"; height="149"; vspace="0"; hspace="20"; align="right"; src="img_glossar/Rechteck.png"; alt="Rechteck" />Ein Rechteck ist ein Viereck, bei dem die gegenüberliegenden Seiten jeweils parallel sind und einer der Innenwinkel 90° beträgt.<html>
Ein Spezialfall des Rechtecks ist das [[Quadrat]]. Das Rechteck ist ein Spezialfall des [[Trapezes|Trapez]].
<p>Für das Rechteck ABCD, wie es die Skizze zeigt, gilt:
<p style="margin-top: -5px;">*Gegenüberliegende Seiten sind gleich lang.
<p style="margin-top: -5px;">*Die Diagonalen sind gleich lang und halbieren sich gegenseitig.
<p style="margin-top: -5px;">*Die Innenwinkelsumme beträgt 360°.
<p style="margin-top: -5px;">*Alle Innenwinkel betragen 90°.
<p style="margin-top: -5px;">*Der Flächeninhalt berechnet sich zu:
<p style="margin-top: -10px;">$$\mathrm{ A_R={\large|}\,\vec{AB}\,{\large|} \cdot {\large|}\,\vec{AD}\,{\large|}}$$
<p style="margin-top: -5px;">$\hspace{1.7em}$Oder mithilfe des [[Vektorprodukts|Vektorprodukt]]:
<p style="margin-top: -10px;">$$\mathrm{ A_R = {\large|}\,\vec{AB} \times \vec{AD}\,{\large|}}$$
</html>

Mit der [[RegExp Suche|RegExpSearch]] können Sie mit regulären Suchausdrücken flexible Suchanfragen vornehmen.

|<<tiddler S1>> |<<tiddler S2>> |
<script>place.lastChild.className="noBorderPolstelle"</script>

<html><div style="margin-left:25px; line-height: 1.5;">
*[[Sattelpunkt]]
*[[Satz von Bayes]]
*[[Säulendiagramm]]
*[[Schnittgerade]]
*[[Schnittpunkt]]
*[[Schnittpunkt mit der y-Achse]]
*[[Schnittpunkt von Gerade und Ebene]]
*[[Schnittpunkt zweier Geraden]]
*[[Schnittwinkel]]
*[[Schnittwinkel mit den Koordinatenachsen]]
*[[Schnittwinkel zweier Ebenen]]
*[[Schnittwinkel zweier Geraden]]
*[[Schnittwinkel zwischen Gerade und Ebene]]$\hspace{2em}$
*[[Schwerpunkt eines Dreiecks]]
*[[Sicheres Ereignis]]

</div></html>

<html><div style="margin-left:25px; line-height: 1.5;">
*[[Signifikanzniveau]]
*[[Signifikanztest]]
*[[Sinusfunktion]]
*[[Skalarmultiplikation]]
*[[Skalarprodukt]]
*[[Spat]]
*[[Stabdiagramm]]
*[[Stammfunktion]]
*[[Standardabweichung]]
*[[Steigungsverhalten]]
*[[Stetigkeit]]
*[[Stochastische Unabhängigkeit]]
*[[Strecken und Stauchen von Funktionsgraphen]]
*[[Symmetrie]]


</div></html>

<<tiddler HideTiddlerSubtitle>>
\( \ \rightarrow \) [[Terrassenpunkt]]

<<tiddler HideTiddlerSubtitle>>
<html>Für zwei [[Ereignisse|Ereignis]] $\mathrm{A, B \subseteq \Omega}$ mit $\mathrm{P(B) > 0}$ gilt:
$$\mathrm{ P_{B}(A) = \cfrac{ P_{A}(B)  \cdot P(A)}{P(B)} }$$
</html>

[[Backups speichern|SaveBackups]] ist eine Funktion, mit der automatisch bei jedem Abspeichern ein Backup erstellt wird.

Diese Funktion erwirkt, dass beim Abspeichern von Änderungen eine leere Vorlage von TiddlyWiki erzeugt wird. Dies ist als Hilfe gedacht für Entwickler, die Adaptionen von TiddlyWiki bereitstellen. Die Funktion ist nicht erforderlich, wenn Sie ein normaler Benutzer sind.

<<tiddler HideTiddlerSubtitle>>
<html>Zwei voneinander verschiedene [[Ebenen|Ebene]] können sich entweder in einer [[Geraden|Gerade]] oder gar nicht schneiden. Im letztgenannten Fall sind die beiden Ebenen (echt) parallel.
<p>Rechnerisch bestimmt man die Schnittgerade zweier Ebenen, indem man die Koordinaten des allgemeinen Ebenenpunktes der einen Ebene in die Normalenform der Ebenengleichung der anderen Ebene einsetzt und mithilfe des resultierenden Gleichungssystems (mit den Ebenenparametern der ersten Ebene als Unbekannten) den einen Parameter in Abhängigkeit des anderen Parameters darstellt. Durch Einsetzen in die Parameterform der entsprechenden Ebenengleichung erhält man die Gleichung der Schnittgeraden. (Ergibt sich aus dem Gleichungssystem ein Widerspruch, so sind die beiden Ebenen (echt) [[parallel|Parallelität]] zueinander.)
<p>Die Schnittgerade einer Ebene mit einer der drei Koordinatenebenen ergibt sich als Verbindungsgerade der [[Durchstoßpunkte|Durchstoßpunkt]] der entsprechenden Koordinatenachsen. Man nennt diese Geraden auch Spurgeraden.
</html>

<<tiddler HideTiddlerSubtitle>>
<html>Unter einem Schnittpunkt zweier geometrischer Objekte versteht man einen Punkt, an dem sich die beiden Objekte treffen; das heißt, ein Schnittpunkt zweier geometrischer Objekte ist ein Punkt, der zu beiden Objekten zugleich gehört.
<p>Um den Schnittpunkt zweier [[Geraden|Gerade]] oder einer Geraden und einer [[Ebene]] zu bestimmen, muss man in aller Regel ein Gleichungssystem oder eine Gleichung lösen.
<p>Schneiden sich zwei Ebenen, so haben sie (unendlich) viele Schnittpunkte, die alle auf einer Geraden, der sogenannten [[Schnittgeraden|Schnittgerade]] der beiden Ebenen, liegen.
<p>\( \ \rightarrow \) [[Schnittpunkt zweier Geraden]]
\( \ \rightarrow \) [[Schnittpunkt von Gerade und Ebene]]
</html>

<<tiddler HideTiddlerSubtitle>>
<html>Der [[Schnittpunkt]] des Graphen einer [[Funktion]] $\mathrm{f}$ mit der y-Achse hat die Koordinaten $\mathrm{(0\, |\, f(0))}$.
<p>\( \ \rightarrow \) [[ Nullstelle]]
</html>

<<tiddler HideTiddlerSubtitle>>
<html>Eine [[Ebene]] und eine nicht in der Ebene liegende [[Gerade]] können einen oder keinen Schnittpunkt besitzen. Im letzteren Fall ist die Gerade (echt) [[parallel|Parallelität]] zur Ebene.
<p>Den Schnittpunkt einer Geraden mit einer Ebene bestimmt man rechnerisch, indem man die Koordinaten des allgemeinen Geradenpunktes in die Normalenform der [[Ebenengleichung]] einsetzt und die entstehende Gleichung (mit dem Geradenparameter als Unbekannte) löst. Den so ermittelten Wert für den Geradenparameter setzt man in die Geradengleichung ein; das Ergebnis ist der [[Ortsvektor]] des [[Schnittpunktes|Schnittpunkt]]. (Hat die Gleichung keine Lösung, so ist die Gerade parallel zur Ebene.)
</html>

<<tiddler HideTiddlerSubtitle>>
<html>Zwei voneinander verschiedene [[Geraden|Gerade]] im Raum können entweder einen oder keinen [[Schnittpunkt]] besitzen. Im letztgenannten Fall sind die Geraden entweder (echt) [[parallel|Parallelität]] oder [[windschief|Gegenseitige Lage zweier Geraden]].
<p>Den Schnittpunkt zweier Geraden bestimmt man rechnerisch, indem man die Koordinaten der allgemeinen Geradenpunkte der beiden Geraden zeilenweise gleichsetzt und das daraus entstehende Gleichungssystem (mit den beiden Geradenparametern als Unbekannten) löst. Die so ermittelten Werte für die beiden Geradenparameter setzt man dann in die entsprechende [[Geradengleichung]] ein; das Ergebnis ist der [[Ortsvektor]] des Schnittpunktes. (Hat das Gleichungssystem keine Lösung, so schneiden sich die beiden Geraden nicht.)
</html>

<<tiddler HideTiddlerSubtitle>>
<html>Als Schnittwinkel zweier geometrischer Objekte bezeichnet man den spitzen (bzw. rechten) Winkel, den die beiden Objekte einschließen.
<p>Die Berechnung des Schnittwinkels von [[Geraden|Gerade]] und [[Ebenen|Ebene]] lässt sich stets auf die Berechnung des [[Winkels zwischen Vektoren|Winkel zwischen Vektoren]] zurückführen.
<p>\( \ \rightarrow \) [[Schnittwinkel zweier Geraden]]
\( \ \rightarrow \) [[Schnittwinkel zwischen Gerade und Ebene]]
\( \ \rightarrow \) [[Schnittwinkel zweier Ebenen]]
</html>

<<tiddler HideTiddlerSubtitle>>
<html>Um den Schnittwinkel einer Funktion mit der x-Achse zu bestimmen, berechnet man die [[Ableitung]] der Funktion an der [[Nullstelle]] $\mathrm{x_0}$. Für den Schnittwinkel $\mathrm{\alpha}$ (mit $\mathrm{0°<\alpha < 180°}$) gilt dann:
$$\mathrm{f '(x_0) = tan \alpha \ \ \ \Leftrightarrow \ \ \ \alpha = tan^{-1}(f '(x_0))}$$
Der Schnittwinkel $\mathrm{\beta}$ einer Kurve mit der y-Achse wird berechnet durch:
<p style="margin-top:-5pt;">*$\mathrm{\beta = 90° − \alpha}$, falls Ableitung positiv
<p style="margin-top:-5pt;">*$\mathrm{\beta = 90° − (180°− \alpha) = \alpha − 90°}$, falls Ableitung negativ
<img width="536" vspace="20" hspace="20" height="190" src="img_glossar/Schnittwinkel.Koordinatenachsen.png" alt="Schnittwinkel Koordinatenachsen" " />
</html>

<<tiddler HideTiddlerSubtitle>>
<html>Der Schnittwinkel $\mathrm{\alpha}$ zweier [[Ebenen|Ebene]] wird berechnet, indem man den spitzen (bzw. rechten) Winkel ermittelt, den ihre beiden [[Normalenvektoren|Normalenvektor]] einschließen. Dazu setzt man in der Formel für den [[Winkel zwischen zwei Vektoren|Winkel zwischen Vektoren]] den Betrag:
$$\mathrm{ \cos \alpha = \left| \,\cfrac{\vec n_1 \circ\,\vec n_2 }{{\large|}\,{\vec n_1}\,{\large|}\cdot {\large|}\,{\vec n_2}\,{\large|}}\,\right|}$$
<p>\( \ \rightarrow \) [[Winkel zwischen Vektoren]]
</html>

<<tiddler HideTiddlerSubtitle>>
<html>Um den Schnittwinkel $\mathrm{\alpha}$ zweier [[Geraden|Gerade]] zu berechnen, bestimmt man den Winkel zwischen den beiden Richtungsvektoren $\mathrm{\vec u}$ und $\mathrm{\vec v}$ der betreffenden Geraden. Damit man den spitzen bzw. rechten Winkel erhält, setzt man den Betrag:
$$\mathrm{ \cos \alpha = \left| \,\cfrac{\vec u \circ\,\vec v }{{\large|}\,{\vec u}\,{\large|}\cdot {\large|}\,{\vec v}\,{\large|}}\,\right|}$$
<p>\( \ \rightarrow \) [[Winkel zwischen Vektoren]]
</html>

<<tiddler HideTiddlerSubtitle>>
<html><img width="210" height="168" vspace="0" hspace="20"  align="right"  src="img_glossar/Schnittwinkel.Gerade.Ebene.png" alt="Schnittwinkel Gerade Ebene" /> Um den Schnittwinkel zwischen einer [[Geraden|Gerade]] und einer [[Ebene]] zu ermitteln, bestimmt man zunächst den Winkel $\mathrm{\varphi}$ zwischen dem Richtungsvektor $\mathrm{\vec u}$ der Geraden und dem [[Normalenvektor]] $\mathrm{\vec n}$ der Ebene. Der Schnittwinkel $\mathrm{\alpha}$ zwischen der Gerade und der Ebene ist dann der Komplementwinkel zu $\mathrm{\varphi}$ (s. Skizze), d. h. $\mathrm{ \alpha = 90^\circ - \varphi}$.
<p>Mit der Beziehung
<p style="margin-top:-5px";>$$\mathrm{ \cos \varphi = \cos\,(90^\circ - \alpha) = \sin \alpha}$$
<p style="margin-top:-5px";>ergibt sich somit folgende Gleichung zur Bestimmung des gesuchten Schnittwinkels $\mathrm{\alpha:}$
$$\mathrm{ \sin \alpha = \left| \,\cfrac{\vec n \circ\,\vec u }{{\large|}\,{\vec n}\,{\large|}\cdot {\large|}\,{\vec u}\,{\large|}}\,\right|}$$
<p>\( \ \rightarrow \) [[Winkel zwischen Vektoren]]
</html>

<<tiddler HideTiddlerSubtitle>>
\( \ \rightarrow \) [[Dreieck]]

<<tiddler HideTiddlerSubtitle>>
<html>Ein [[Ereignis]], das bei einem [[Zufallsexperiment]] eintreten muss, heißt sicheres Ereignis.
Die [[Wahrscheinlichkeit]] für ein sicheres Ereignis $\mathrm{A}$ beträgt $\mathrm{ P(A) = 1}$.

<p style="margin-top:-10px";>!!!Beispiel:
Beim Wurf eines Tetraeders mit den Seiten $\mathrm{1, 2, 3}$ und $\mathrm{4}$ ist $\mathrm{A = \{1, 2, 3, 4\} (= \Omega)}$ ein sicheres Ereignis, da der Tetraeder auf eine der vier Seiten fällt.
<p>\( \ \rightarrow \) [[Unmögliches Ereignis]]
</html>

<<tiddler HideTiddlerSubtitle>>
<html>Bei einem Signifikanztest wird die Entscheidungsregel durch das Signifikanzniveau $\mathrm{\alpha}$ bestimmt. Als Signifikanzniveau bezeichnet man die maximale Irrtumswahrscheinlichkeit, d.h. die [[Wahrscheinlichkeit]] für den Fehler, die [[Nullhypothese]] abzulehnen, obwohl sie zutrifft.
<p>\( \ \rightarrow \) [[Signifikanztest]]
</html>

<<tiddler HideTiddlerSubtitle>>
<html> Mithilfe eines Signifikanztests können Hypothesen anhand von beobachteten Werten beurteilt werden. Man bestimmt durch die Festlegung eines maximalen Fehlers eine Entscheidungsregel und erhält somit Annahme- und Ablehnungsbereich der [[Nullhypothese]] $\mathrm{H_0}$. Hierbei wird die [[Wahrscheinlichkeit]] für den Fehler, die Hypothese abzulehnen, obwohl sie zutrifft, als [[Signifikanzniveau]] $\mathrm{\alpha}$ bezeichnet.
<p>Wenn die Hypothese nur auf eine Seite beschränkt ist, heißt sie einseitig. Es existieren zwei Fälle:
<p>!!!Linksseitiger Signifikanztest
<p>*Nullhypothese: $\mathrm{H_0: p \geq p_0}$; mit $\mathrm{p_0}$ als Wahrscheinlichkeit, auf die getestet wird
<p style="margin-top:-5px";>*Annahmebereich: $\mathrm{A = \{k + 1,\, k + 2,\, \dots ,\, n\}}$
<p style="margin-top:-5px";>*Ablehnungsbereich: $\mathrm{\overline A = \{0,\, 1,\, \dots ,\, k\}}$ mit maximalem $\mathrm{k}$ aus $\mathrm{\sum_{i=0}^k B(n;\, p_0;\, i) \leq \alpha }$.
<img width="295" vspace="10" hspace="20"  height="90" src="img_glossar/Signifikanztest_linksseitig.png" alt="Signifikanztest links"/>
<p>!!!Rechtsseitiger Signifikanztest
<p>*Nullhypothese: $\mathrm{H_0: p \leq p_0}$; mit $\mathrm{p_0}$ als Wahrscheinlichkeit, auf die getestet wird
<p style="margin-top:-5px";>*Annahmebereich: $\mathrm{A = \{0,\, 1,\, \dots ,\, k\}}$
<p style="margin-top:-5px";>*Ablehnungsbereich: $\mathrm{\overline A = \{k + 1,\, k + 2,\, \dots ,\, n\}}$ mit minimalem $\mathrm{k}$ aus $\mathrm{\sum_{i=0}^k B(n;\, p_0;\, i) \geq 1-\alpha}$.
<img width="295" vspace="10" hspace="20" height="90" src="img_glossar/Signifikanztest_rechtsseitig.png" alt="Signifikanztest rechts"  />
</html>

<<tiddler HideTiddlerSubtitle>>
<html>Die Grundfunktion ist $\mathrm{f:\,x \mapsto \sin x}$.
<p>Für die [[Funktion]] $\mathrm{f}$ lassen sich folgende Aussagen treffen:
<p style="margin-top:-5px";>*[[Definitionsmenge]]:   $\mathrm{ D=\mathbb R}$
<p style="margin-top:-5px";>*[[Wertemenge]]:   $\mathrm{ W=[\,-1; \ 1\,]}$
<p style="margin-top:-5px";>*[[Nullstellen|Nullstelle]]:    $\mathrm{ \ldots,  - \pi , \ 0, \ \pi , \ 2 \pi ,\,  \ldots}$
<p style="margin-top:-5px";>*[[Ableitung]]:    $\mathrm{ f'(x)=\cos x}$
<p style="margin-top:-5px";>*[[Stammfunktion]]:    $\mathrm { F(x)=-\cos x+C}$
<p style="margin-top:-5px";>*[[Symmetrie]]: punktsymmetrisch zum Ursprung
<p style="margin-top:-5px";>*[[Periodizität]]: $\mathrm{ 2\pi}$ - periodisch
<p><img vspace="0" hspace="20" border="0"  alt="Sinusfunktion" src="img_glossar/Sinusfunktion.png" />
</html>

{{left{[<img[_PNGs/cdf01_always_621x51px.png]]}}}{{center{[<img(174px,51px)[_PNGs/cdf02_x-spacer-bottom_1x51px.png]]}}}{{right{[<img[_PNGs/cdf03_pearson_155x51px.png]]}}}

{{left{<html><img src="_PNGs/cd01_activebook_621x111px.png" alt="ActiveBook" usemap="#ActiveBook" style="border:0px;"></html>}}}
{{center{[<img(174px,111px)[_PNGs/cd02_x-spacer-top_1x111px.png]]}}}
{{right{[img[_PNGs/cd03_stark_155x111px.png]]}}}
{{kolumne{[img[_kolumnen/mathematisches-glossar.png]]}}}  STARK

http://www.stark-verlag.de

<<tiddler HideTiddlerSubtitle>>
<html><img width="220" vspace="0" hspace="20" align="right" height="148" alt="Skalarmultiplikation" src="img_glossar/Skalarmultiplikation.png" />Als algebraische Rechenoperation ist die Skalarmultiplikation eines Vektors $\mathrm{\vec a}$ mit einer reellen Zahl $\mathrm{\lambda}$ wie folgt definiert:
<p>$$\mathrm{\lambda \cdot \vec a = \lambda\cdot  \begin{pmatrix} a_1 \\ \mathrm{a_2}\\ \mathrm{a_3} \end{pmatrix} = \begin{pmatrix} \lambda  \cdot  a_1 \\ \mathrm{\lambda \cdot a_2}\\ \mathrm{\lambda \cdot a_3} \end{pmatrix}}$$

Im Anschauungsraum entspricht die Skalarmultiplikation eines Vektors $\mathrm{\vec a}$ (mit einer reellen Zahl $\mathrm{\lambda}$) dem Stauchen oder Strecken des Vektors $\mathrm{\vec a}$ bzw. des [[Gegenvektors|Gegenvektor]] $\mathrm{-\vec a}$:
<div style="line-height:2em;">*Gilt $\mathrm{0<\lambda<1}$, so wird der Vektor $\mathrm{\vec a}$ gestaucht. Ist $\mathrm{\lambda>1}$, so wird $\mathrm{\vec a}$ gestreckt.
*Gilt $\mathrm{-1<\lambda<0}$, so wird der Vektor $\mathrm{-\vec a}$ gestaucht. Ist $\mathrm{\lambda<-1}$, so wird $\mathrm{-\vec a}$ gestreckt.
*Im Falle $\mathrm{\lambda = 0}$ wird der Vektor $\mathrm{\vec a}$ (bzw. $\mathrm{-\vec a}$) „auf den Ursprung zusammengezogen".
*Ist $\mathrm{\lambda = 1}$, so bleibt die Länge des Vektors $\mathrm{\vec a}$ bzw. des Gegenvektors $\mathrm{-\vec a}$ unverändert.</div>
\( \ \rightarrow \) [[Rechnen mit Vektoren]]
</html>

<<tiddler HideTiddlerSubtitle>>
<html>Das Skalarprodukt ist eine Rechenoperation zwischen zwei Vektoren, deren Ergebnis eine Zahl ist.
<p>Berechnet wird das Skalarprodukt $\mathrm{\vec a \circ \vec b}$ zweier Vektoren $\mathrm{\vec a}$ und $\mathrm{\vec b}$ wie folgt:
$$\mathrm{ \vec a \circ \vec b = \begin{pmatrix} a_1 \\ \mathrm{a_2}\\ \mathrm{a_3} \end{pmatrix} \circ \begin{pmatrix} b_1 \\ \mathrm{b_2}\\ \mathrm{b_3} \end{pmatrix} = a_1b_1 + a_2b_2 + a_3b_3}$$
Das Skalarprodukt ist unter anderem hilfreich, wenn überprüft werden soll, ob zwei gegebene Vektoren $\mathrm{\vec a}$ und $\mathrm{\vec b}$ [[orthogonal|Orthogonalität]] zueinander sind, denn das Skalarprodukt $\mathrm{\vec a \circ \vec b}$ ist genau dann null, wenn $\mathrm{\vec a}$ und $\mathrm{\vec b}$ orthogonal zueinander sind.
<p>\( \ \rightarrow \) [[Winkel zwischen Vektoren]]
</html>

<<tiddler HideTiddlerSubtitle>>
<html><img width="200" height="150" vspace="0" hspace="20"  align="right"  src="img_glossar/Spat.png" alt="Spat"  /> Ein Spat ist ein Körper, der von sechs [[Parallelogrammen|Parallelogramm]] begrenzt wird. Gegenüberliegende Begrenzungsflächen sind kongruent und [[parallel|Parallelität]] zueinander. Im Allgemeinen ist ein Spat also ein „schiefer Quader".
<p>Das Volumen eines Spats lässt sich mithilfe des [[Vektorprodukts|Vektorprodukt]] und des [[Skalarprodukts|Skalarprodukt]] wie folgt berechnen:
$$\mathrm{ V_S = \left|\,\vec a \circ (\vec b \times \vec c)\,\right|}$$
Die Oberfläche eines Spats besteht aus den sechs Parallelogrammflächen:
$$\mathrm{ O_S = 2 \cdot |\,\vec a \times \vec b \,| + 2\cdot |\,\vec a \times \vec c\,| + 2 \cdot |\,\vec b \times \vec c\,| }$$
</html>

<<tiddler HideTiddlerSubtitle>>
\( \ \rightarrow \) [[Säulendiagramm]]

<<tiddler HideTiddlerSubtitle>>
<html>Eine [[Funktion]] $\mathrm{F(x)}$ heißt Stammfunktion von $\mathrm{f(x)}$, wenn gilt:
$$\mathrm{F'(x) = f(x)}$$
<p>Eine Funktion $\mathrm{f(x)}$ besitzt unendlich viele Stammfunktionen, die sich nur durch eine additive Konstante unterscheiden.
Wenn $\mathrm{F'(x) = f(x)}$ gilt, dann ist auch $\mathrm{F(x) + C}$ für jedes $\mathrm{C \in \mathbb R}$ Stammfunktion von $\mathrm{f(x)}$.
</html>

<<tiddler HideTiddlerSubtitle>>
<html>Die Standardabweichung einer [[Zufallsgröße]] Z ist die Wurzel aus der [[Varianz]]. Sie stellt ein Streuungsmaß dar und ist aufgrund ihrer Einheit besser zu interpretieren als die Varianz:
$$\mathrm{\sigma(Z) = \sqrt{Var(Z)}}$$
</html>

<<tiddler HideTiddlerSubtitle>>
\( \ \rightarrow \) [[Ableitung]]

<<tiddler HideTiddlerSubtitle>>
<html>Eine [[Funktion]] $\mathrm{f}$ ist stetig im Punkt $\mathrm{x_0}$, wenn der linksseitige und der rechtsseitige Grenzwert von $\mathrm{f}$ an $\mathrm{x_0}$ gleich dem Funktionswert $\mathrm{f(x_0)}$ sind.
$$\mathrm{ \lim_{x \rightarrow x_0^-} f(x) = f(x_0) = \lim_{x \rightarrow x_0^+}f(x) }$$
Anschaulich betrachtet ist eine Funktion stetig, wenn man ihren Graphen zeichnen kann, ohne den Stift abzusetzen.
</html>

<<tiddler HideTiddlerSubtitle>>
<html>Zwei [[Ereignisse|Ereignis]] $\mathrm{A, \, B \subseteq \Omega}$ heißen genau dann stochastisch unabhängig, wenn gilt:
$$\mathrm{P(A \cap B) = P(A) \cdot P(B)}$$
<p>Sind zwei Ereignisse stochastisch unabhängig, so hat das Eintreten des einen Ereignisses keinen Einfluss auf die [[Wahrscheinlichkeit]] für das Eintreten des anderen Ereignisses.
<p>Ist die Bedingung $\mathrm{P(A \cap B) = P(A) \cdot P(B)}$ nicht erfüllt, sind die Ereignisse $\mathrm{A}$ und $\mathrm{B}$ stochastisch abhängig.
</html>

<<tiddler HideTiddlerSubtitle>><html>!!!Streckung/Stauchung in y-Richtung
Der Graph der [[Funktion]] $\mathrm{f(x) = a \cdot g(x)}$ wird im Vergleich zum Graphen der Funktion $\mathrm{g(x)}$
<p style="margin-top:-5pt;">*in y-Richtung gestreckt, wenn $\mathrm{a > 1}$,
<p style="margin-top:-5pt;">*in y-Richtung gestaucht, wenn $\mathrm{0 < a < 1}$.
Ist $\mathrm{a<0}$, so wird die Funktion zusätzlich an der x-Achse gespiegelt.
<p><img vspace="0" hspace="20" border="0"  alt="" src="img_glossar/Streckung-Stauchung1.png" />

!!!Streckung/Stauchung in x-Richtung
Der Graph der Funktion $\mathrm{f(x) = g(b \cdot x)}$ wird im Vergleich zum Graphen der Funktion $\mathrm{g(x)}$
<p style="margin-top:-5pt;">*in x-Richtung gestaucht, wenn $\mathrm{b > 1}$,
<p style="margin-top:-5pt;">*in x-Richtung gestreckt, wenn $\mathrm{0 < b < 1}$.
Ist $\mathrm{b<0}$, so wird die Funktion zusätzlich an der y-Achse gespiegelt.
<p><img vspace="0" hspace="20" border="0"  alt="" src="img_glossar/Streckung-Stauchung2.png" />
</html>

/*{{{*/

/*Internet Explorer*/

body {position:static;}
.tagClear {margin-top:1em;clear:both;}
.tiddler {position:static;}

/*}}}*/

/*{{{*/

/*Opera*/

body {width:100%;} //fixed bug on Opera

/*}}}*/

[[StyleSheetLayout Adjustment]]
[[HorizontalMainMenuStyles]]
[[TABS Style]]
[[Tabellen]]
[[Style fixed for IE an Opera]]

/*{{{*/

/*TaggingStyle Test*/

.tagging {margin:0.5em 0.5em 0.5em 0; float:left; display:none;}
.isTag
.tagging {display:block;}
.tagged {font-size:0.9em; padding: 0.25em; margin-top:-2em; float:right; }
.tagging ul
.tagged ul {list-style:none; margin:0.25em; padding:0; }
.tagClear {clear:both; }

/*}}}*/

/*{{{*/
body {background:[[ColorPalette::Background]]; color:[[ColorPalette::Foreground]];}

a {color:[[ColorPalette::PrimaryMid]];}
a:hover {background-color:[[ColorPalette::PrimaryMid]]; color:[[ColorPalette::Background]];}
a img {border:0;}

h1,h2,h3,h4,h5,h6 {color:[[ColorPalette::SecondaryDark]]; background:transparent;}
h1 {border-bottom:2px solid [[ColorPalette::TertiaryLight]];}
h2,h3 {border-bottom:1px solid [[ColorPalette::TertiaryLight]];}

.button {color:[[ColorPalette::PrimaryDark]]; border:1px solid [[ColorPalette::Background]];}
.button:hover {color:[[ColorPalette::PrimaryDark]]; background:[[ColorPalette::SecondaryLight]]; border-color:[[ColorPalette::SecondaryMid]];}
.button:active {color:[[ColorPalette::Background]]; background:[[ColorPalette::SecondaryMid]]; border:1px solid [[ColorPalette::SecondaryDark]];}

.header {background:[[ColorPalette::PrimaryMid]];}
.headerShadow {color:[[ColorPalette::Foreground]];}
.headerShadow a {font-weight:normal; color:[[ColorPalette::Foreground]];}
.headerForeground {color:[[ColorPalette::Background]];}
.headerForeground a {font-weight:normal; color:[[ColorPalette::PrimaryPale]];}

.tabSelected {color:[[ColorPalette::PrimaryDark]];
	background:[[ColorPalette::TertiaryPale]];
	border-left:1px solid [[ColorPalette::TertiaryLight]];
	border-top:1px solid [[ColorPalette::TertiaryLight]];
	border-right:1px solid [[ColorPalette::TertiaryLight]];
}
.tabUnselected {color:[[ColorPalette::Background]]; background:[[ColorPalette::TertiaryMid]];}
.tabContents {color:[[ColorPalette::PrimaryDark]]; background:[[ColorPalette::TertiaryPale]]; border:1px solid [[ColorPalette::TertiaryLight]];}
.tabContents .button {border:0;}

#sidebar {}
#sidebarOptions input {border:1px solid [[ColorPalette::PrimaryMid]];}
#sidebarOptions .sliderPanel {background:[[ColorPalette::PrimaryPale]];}
#sidebarOptions .sliderPanel a {border:none;color:[[ColorPalette::PrimaryMid]];}
#sidebarOptions .sliderPanel a:hover {color:[[ColorPalette::Background]]; background:[[ColorPalette::PrimaryMid]];}
#sidebarOptions .sliderPanel a:active {color:[[ColorPalette::PrimaryMid]]; background:[[ColorPalette::Background]];}

.wizard {background:[[ColorPalette::PrimaryPale]]; border:1px solid [[ColorPalette::PrimaryMid]];}
.wizard h1 {color:[[ColorPalette::PrimaryDark]]; border:none;}
.wizard h2 {color:[[ColorPalette::Foreground]]; border:none;}
.wizardStep {background:[[ColorPalette::Background]]; color:[[ColorPalette::Foreground]];
	border:1px solid [[ColorPalette::PrimaryMid]];}
.wizardStep.wizardStepDone {background:[[ColorPalette::TertiaryLight]];}
.wizardFooter {background:[[ColorPalette::PrimaryPale]];}
.wizardFooter .status {background:[[ColorPalette::PrimaryDark]]; color:[[ColorPalette::Background]];}
.wizard .button {color:[[ColorPalette::Foreground]]; background:[[ColorPalette::SecondaryLight]]; border: 1px solid;
	border-color:[[ColorPalette::SecondaryPale]] [[ColorPalette::SecondaryDark]] [[ColorPalette::SecondaryDark]] [[ColorPalette::SecondaryPale]];}
.wizard .button:hover {color:[[ColorPalette::Foreground]]; background:[[ColorPalette::Background]];}
.wizard .button:active {color:[[ColorPalette::Background]]; background:[[ColorPalette::Foreground]]; border: 1px solid;
	border-color:[[ColorPalette::PrimaryDark]] [[ColorPalette::PrimaryPale]] [[ColorPalette::PrimaryPale]] [[ColorPalette::PrimaryDark]];}

.wizard .notChanged {background:transparent;}
.wizard .changedLocally {background:#80ff80;}
.wizard .changedServer {background:#8080ff;}
.wizard .changedBoth {background:#ff8080;}
.wizard .notFound {background:#ffff80;}
.wizard .putToServer {background:#ff80ff;}
.wizard .gotFromServer {background:#80ffff;}

#messageArea {border:1px solid [[ColorPalette::SecondaryMid]]; background:[[ColorPalette::SecondaryLight]]; color:[[ColorPalette::Foreground]];}
#messageArea .button {color:[[ColorPalette::PrimaryMid]]; background:[[ColorPalette::SecondaryPale]]; border:none;}

.popupTiddler {background:[[ColorPalette::TertiaryPale]]; border:2px solid [[ColorPalette::TertiaryMid]];}

.popup {background:[[ColorPalette::TertiaryPale]]; color:[[ColorPalette::TertiaryDark]]; border-left:1px solid [[ColorPalette::TertiaryMid]]; border-top:1px solid [[ColorPalette::TertiaryMid]]; border-right:2px solid [[ColorPalette::TertiaryDark]]; border-bottom:2px solid [[ColorPalette::TertiaryDark]];}
.popup hr {color:[[ColorPalette::PrimaryDark]]; background:[[ColorPalette::PrimaryDark]]; border-bottom:1px;}
.popup li.disabled {color:[[ColorPalette::TertiaryMid]];}
.popup li a, .popup li a:visited {color:[[ColorPalette::Foreground]]; border: none;}
.popup li a:hover {background:[[ColorPalette::SecondaryLight]]; color:[[ColorPalette::Foreground]]; border: none;}
.popup li a:active {background:[[ColorPalette::SecondaryPale]]; color:[[ColorPalette::Foreground]]; border: none;}
.popupHighlight {background:[[ColorPalette::Background]]; color:[[ColorPalette::Foreground]];}
.listBreak div {border-bottom:1px solid [[ColorPalette::TertiaryDark]];}

.tiddler .defaultCommand {font-weight:bold;}

.shadow .title {color:[[ColorPalette::TertiaryDark]];}

.title {color:[[ColorPalette::SecondaryDark]];}
.subtitle {color:[[ColorPalette::TertiaryDark]];}

.toolbar {color:[[ColorPalette::PrimaryMid]];}
.toolbar a {color:[[ColorPalette::TertiaryLight]];}
.selected .toolbar a {color:[[ColorPalette::TertiaryMid]];}
.selected .toolbar a:hover {color:[[ColorPalette::Foreground]];}

.tagging, .tagged {border:1px solid [[ColorPalette::TertiaryPale]]; background-color:[[ColorPalette::TertiaryPale]];}
.selected .tagging, .selected .tagged {background-color:[[ColorPalette::TertiaryLight]]; border:1px solid [[ColorPalette::TertiaryMid]];}
.tagging .listTitle, .tagged .listTitle {color:[[ColorPalette::PrimaryDark]];}
.tagging .button, .tagged .button {border:none;}

.footer {color:[[ColorPalette::TertiaryLight]];}
.selected .footer {color:[[ColorPalette::TertiaryMid]];}

.error, .errorButton {color:[[ColorPalette::Foreground]]; background:[[ColorPalette::Error]];}
.warning {color:[[ColorPalette::Foreground]]; background:[[ColorPalette::SecondaryPale]];}
.lowlight {background:[[ColorPalette::TertiaryLight]];}

.zoomer {background:none; color:[[ColorPalette::TertiaryMid]]; border:3px solid [[ColorPalette::TertiaryMid]];}

.imageLink, #displayArea .imageLink {background:transparent;}

.annotation {background:[[ColorPalette::SecondaryLight]]; color:[[ColorPalette::Foreground]]; border:2px solid [[ColorPalette::SecondaryMid]];}

.viewer .listTitle {list-style-type:none; margin-left:-2em;}
.viewer .button {border:1px solid [[ColorPalette::SecondaryMid]];}
.viewer blockquote {border-left:3px solid [[ColorPalette::TertiaryDark]];}

.viewer table, table.twtable {border:2px solid [[ColorPalette::TertiaryDark]];}
.viewer th, .viewer thead td, .twtable th, .twtable thead td {background:[[ColorPalette::SecondaryMid]]; border:1px solid [[ColorPalette::TertiaryDark]]; color:[[ColorPalette::Background]];}
.viewer td, .viewer tr, .twtable td, .twtable tr {border:1px solid [[ColorPalette::TertiaryDark]];}

.viewer pre {border:1px solid [[ColorPalette::SecondaryLight]]; background:[[ColorPalette::SecondaryPale]];}
.viewer code {color:[[ColorPalette::SecondaryDark]];}
.viewer hr {border:0; border-top:dashed 1px [[ColorPalette::TertiaryDark]]; color:[[ColorPalette::TertiaryDark]];}

.highlight, .marked {background:[[ColorPalette::SecondaryLight]];}

.editor input {border:1px solid [[ColorPalette::PrimaryMid]];}
.editor textarea {border:1px solid [[ColorPalette::PrimaryMid]]; width:100%;}
.editorFooter {color:[[ColorPalette::TertiaryMid]];}
.readOnly {background:[[ColorPalette::TertiaryPale]];}

#backstageArea {background:[[ColorPalette::Foreground]]; color:[[ColorPalette::TertiaryMid]];}
#backstageArea a {background:[[ColorPalette::Foreground]]; color:[[ColorPalette::Background]]; border:none;}
#backstageArea a:hover {background:[[ColorPalette::SecondaryLight]]; color:[[ColorPalette::Foreground]]; }
#backstageArea a.backstageSelTab {background:[[ColorPalette::Background]]; color:[[ColorPalette::Foreground]];}
#backstageButton a {background:none; color:[[ColorPalette::Background]]; border:none;}
#backstageButton a:hover {background:[[ColorPalette::Foreground]]; color:[[ColorPalette::Background]]; border:none;}
#backstagePanel {background:[[ColorPalette::Background]]; border-color: [[ColorPalette::Background]] [[ColorPalette::TertiaryDark]] [[ColorPalette::TertiaryDark]] [[ColorPalette::TertiaryDark]];}
.backstagePanelFooter .button {border:none; color:[[ColorPalette::Background]];}
.backstagePanelFooter .button:hover {color:[[ColorPalette::Foreground]];}
#backstageCloak {background:[[ColorPalette::Foreground]]; opacity:0.6; filter:alpha(opacity=60);}
/*}}}*/

/*{{{*/
* html .tiddler {height:1%;}

body {font-size:.75em; font-family:arial,helvetica; margin:0; padding:0;}

h1,h2,h3,h4,h5,h6 {font-weight:bold; text-decoration:none;}
h1,h2,h3 {padding-bottom:1px; margin-top:1.2em;margin-bottom:0.3em;}
h4,h5,h6 {margin-top:1em;}
h1 {font-size:1.35em;}
h2 {font-size:1.25em;}
h3 {font-size:1.1em;}
h4 {font-size:1em;}
h5 {font-size:.9em;}

hr {height:1px;}

a {text-decoration:none;}

dt {font-weight:bold;}

ol {list-style-type:decimal;}
ol ol {list-style-type:lower-alpha;}
ol ol ol {list-style-type:lower-roman;}
ol ol ol ol {list-style-type:decimal;}
ol ol ol ol ol {list-style-type:lower-alpha;}
ol ol ol ol ol ol {list-style-type:lower-roman;}
ol ol ol ol ol ol ol {list-style-type:decimal;}

.txtOptionInput {width:11em;}

#contentWrapper .chkOptionInput {border:0;}

.externalLink {text-decoration:underline;}

.indent {margin-left:3em;}
.outdent {margin-left:3em; text-indent:-3em;}
code.escaped {white-space:nowrap;}

.tiddlyLinkExisting {font-weight:bold;}
.tiddlyLinkNonExisting {font-style:italic;}

/* the 'a' is required for IE, otherwise it renders the whole tiddler in bold */
a.tiddlyLinkNonExisting.shadow {font-weight:bold;}

#mainMenu .tiddlyLinkExisting,
	#mainMenu .tiddlyLinkNonExisting,
	#sidebarTabs .tiddlyLinkNonExisting {font-weight:normal; font-style:normal;}
#sidebarTabs .tiddlyLinkExisting {font-weight:bold; font-style:normal;}

.header {position:relative;}
.header a:hover {background:transparent;}
.headerShadow {position:relative; padding:4.5em 0 1em 1em; left:-1px; top:-1px;}
.headerForeground {position:absolute; padding:4.5em 0 1em 1em; left:0; top:0;}

.siteTitle {font-size:3em;}
.siteSubtitle {font-size:1.2em;}

#mainMenu {position:absolute; left:0; width:10em; text-align:right; line-height:1.6em; padding:1.5em 0.5em 0.5em 0.5em; font-size:1.1em;}

#sidebar {position:absolute; right:3px; width:16em; font-size:.9em;}
#sidebarOptions {padding-top:0.3em;}
#sidebarOptions a {margin:0 0.2em; padding:0.2em 0.3em; display:block;}
#sidebarOptions input {margin:0.4em 0.5em;}
#sidebarOptions .sliderPanel {margin-left:1em; padding:0.5em; font-size:.85em;}
#sidebarOptions .sliderPanel a {font-weight:bold; display:inline; padding:0;}
#sidebarOptions .sliderPanel input {margin:0 0 0.3em 0;}
#sidebarTabs .tabContents {width:15em; overflow:hidden;}

.wizard {padding:0.1em 1em 0 2em;}
.wizard h1 {font-size:2em; font-weight:bold; background:none; padding:0; margin:0.4em 0 0.2em;}
.wizard h2 {font-size:1.2em; font-weight:bold; background:none; padding:0; margin:0.4em 0 0.2em;}
.wizardStep {padding:1em 1em 1em 1em;}
.wizard .button {margin:0.5em 0 0; font-size:1.2em;}
.wizardFooter {padding:0.8em 0.4em 0.8em 0;}
.wizardFooter .status {padding:0 0.4em; margin-left:1em;}
.wizard .button {padding:0.1em 0.2em;}

#messageArea {position:fixed; top:2em; right:0; margin:0.5em; padding:0.5em; z-index:2000; _position:absolute;}
.messageToolbar {display:block; text-align:right; padding:0.2em;}
#messageArea a {text-decoration:underline;}

.tiddlerPopupButton {padding:0.2em;}
.popupTiddler {position: absolute; z-index:300; padding:1em; margin:0;}

.popup {position:absolute; z-index:300; font-size:.9em; padding:0; list-style:none; margin:0;}
.popup .popupMessage {padding:0.4em;}
.popup hr {display:block; height:1px; width:auto; padding:0; margin:0.2em 0;}
.popup li.disabled {padding:0.4em;}
.popup li a {display:block; padding:0.4em; font-weight:normal; cursor:pointer;}
.listBreak {font-size:1px; line-height:1px;}
.listBreak div {margin:2px 0;}

.tabset {padding:1em 0 0 0.5em;}
.tab {margin:0 0 0 0.25em; padding:2px;}
.tabContents {padding:0.5em;}
.tabContents ul, .tabContents ol {margin:0; padding:0;}
.txtMainTab .tabContents li {list-style:none;}
.tabContents li.listLink { margin-left:.75em;}

#contentWrapper {display:block;}
#splashScreen {display:none;}

#displayArea {margin:1em 17em 0 14em;}

.toolbar {text-align:right; font-size:.9em;}

.tiddler {padding:1em 1em 0;}

.missing .viewer,.missing .title {font-style:italic;}

.title {font-size:1.6em; font-weight:bold;}

.missing .subtitle {display:none;}
.subtitle {font-size:1.1em;}

.tiddler .button {padding:0.2em 0.4em;}

.tagging {margin:0.5em 0.5em 0.5em 0; float:left; display:none;}
.isTag .tagging {display:block;}
.tagged {margin:0.5em; float:right;}
.tagging, .tagged {font-size:0.9em; padding:0.25em;}
.tagging ul, .tagged ul {list-style:none; margin:0.25em; padding:0;}
.tagClear {clear:both;}

.footer {font-size:.9em;}
.footer li {display:inline;}

.annotation {padding:0.5em; margin:0.5em;}

* html .viewer pre {width:99%; padding:0 0 1em 0;}
.viewer {line-height:1.4em; padding-top:0.5em;}
.viewer .button {margin:0 0.25em; padding:0 0.25em;}
.viewer blockquote {line-height:1.5em; padding-left:0.8em;margin-left:2.5em;}
.viewer ul, .viewer ol {margin-left:0.5em; padding-left:1.5em;}

.viewer table, table.twtable {border-collapse:collapse; margin:0.8em 1.0em;}
.viewer th, .viewer td, .viewer tr,.viewer caption,.twtable th, .twtable td, .twtable tr,.twtable caption {padding:3px;}
table.listView {font-size:0.85em; margin:0.8em 1.0em;}
table.listView th, table.listView td, table.listView tr {padding:0 3px 0 3px;}

.viewer pre {padding:0.5em; margin-left:0.5em; font-size:1.2em; line-height:1.4em; overflow:auto;}
.viewer code {font-size:1.2em; line-height:1.4em;}

.editor {font-size:1.1em;}
.editor input, .editor textarea {display:block; width:100%; font:inherit;}
.editorFooter {padding:0.25em 0; font-size:.9em;}
.editorFooter .button {padding-top:0; padding-bottom:0;}

.fieldsetFix {border:0; padding:0; margin:1px 0px;}

.zoomer {font-size:1.1em; position:absolute; overflow:hidden;}
.zoomer div {padding:1em;}

* html #backstage {width:99%;}
* html #backstageArea {width:99%;}
#backstageArea {display:none; position:relative; overflow: hidden; z-index:150; padding:0.3em 0.5em;}
#backstageToolbar {position:relative;}
#backstageArea a {font-weight:bold; margin-left:0.5em; padding:0.3em 0.5em;}
#backstageButton {display:none; position:absolute; z-index:175; top:0; right:0;}
#backstageButton a {padding:0.1em 0.4em; margin:0.1em;}
#backstage {position:relative; width:100%; z-index:50;}
#backstagePanel {display:none; z-index:100; position:absolute; width:90%; margin-left:3em; padding:1em;}
.backstagePanelFooter {padding-top:0.2em; float:right;}
.backstagePanelFooter a {padding:0.2em 0.4em;}
#backstageCloak {display:none; z-index:20; position:absolute; width:100%; height:100px;}

.whenBackstage {display:none;}
.backstageVisible .whenBackstage {display:block;}
/*}}}*/

/*{{{*/
#contentWrapper {
margin: 0 auto; width: 950px; padding:0;
background: white url(_PNGs/cdm_container_1x1.png) repeat; }

body {margin: 0; background: #BDBDBD url(_PNGs/bas02_hg-grau_1x1px.png) repeat; }

.header {height: 111px; }
.headerShadow {height: 111px; }
.headerShadow { left: 0px; top: 0px; }
.headerShadow .kolumne {position: absolute; top: 88px; left: 35px; }
.headerShadow .home {position: absolute; top: 37px; left: 900px; }
.headerShadow .left,
.headerShadow .right {position: absolute; top: 0; }
.headerShadow .center {position: absolute; top: 0; left: 621px; }
.headerShadow .left {left: 0; }
.headerShadow .right {right: 0;}
.headerForeground .left,
.headerForeground .center,
.headerForeground .right {display: none;}
.headerForeground .kolumne {display: none;}
.headerForeground .home {display: none;}


.siteTitle {font-size: 0em; }
.siteSubtitle { padding-left:1.5em; font-size: 0em; }

h1,h2,h3,h4,h5 { color: #000; background: transparent; }
.title {color:#0044BB; font-size:2em;}
.shadow .title {color:#999; }
.toolbar {text-align:right; font-size:.9em;}

#displayArea { margin: 1em 2em 2em 2em  !important;}; }
#sidebarOptions { border:1px #ccc solid; }

.viewer pre { background-color:#f8f8ff; border-color:#ddf;}


.tiddler {
  border-bottom:1px solid #ccc; border-right:1px solid #ccc; border-top:1px solid #ccc; border-left:1px solid #ccc; margin-bottom:1em;
  background:#fff; padding-right:1.5em; font-size:1.1em; font-family: Verdana;
}

/* .toolbar { float:right; } */

/*}}}*/

/*{{{*/
.headerShadow {padding: 2em 0em 0em 1em !important;}
.headerForeground {padding: 2em 0em 0em 1em !important;}

#sidebarOptions .sliderPanel {font-size: 1em !important;}
.subtitle {font-size: 0.9em !important;}

/*}}}*/

/*{{{*/

/* prefer monospace for editing */
.editor textarea, .editor input {
	font-family: 'Consolas', monospace;
	background-color:[[ColorPalette::TertiaryPale]];
}

/*}}}*/

/***
StyleSheet for use when a translation requires any css style changes.
This StyleSheet can be used directly by languages such as Chinese, Japanese and Korean which need larger font sizes.
***/
/*{{{*/
body {font-size:0.8em;}
#sidebarOptions {font-size:1.05em;}
#sidebarOptions a {font-style:normal;}
#sidebarOptions .sliderPanel {font-size:0.95em;}
.subtitle {font-size:0.8em;}
.viewer table.listView {font-size:0.95em;}
/*}}}*/

/*{{{*/
@media print {
#mainMenu, #sidebar, #messageArea, .toolbar, #backstageButton, #backstageArea {display: none !important;}
#displayArea {margin: 1em 1em 0em;}
noscript {display:none;} /* Fixes a feature in Firefox 1.5.0.2 where print preview displays the noscript content */
}
/*}}}*/

<<tiddler HideTiddlerSubtitle>>
<html>Um die Symmetrieeigenschaften einer [[Funktion]] zu untersuchen, bildet man den Funktionsterm $\mathrm{f(−﻿﻿x)}$.
<p>Eine Funktion $\mathrm{f}$ ist achsensymmetrisch zur y-Achse, wenn gilt: $\mathrm{f(-x) = f(x)}$
<img width="167" vspace="10" hspace="20" height="232" alt="Achsensymmetrie" src="img_glossar/Symmetrie_Achsensymmetrie.png" />
<p>Eine Funktion ist punktsymmetrisch zum Koordinatenursprung $\mathrm{(0\, |\, 0)}$, wenn gilt: $\mathrm{f(-x) = − f(x)}$
<img width="177" vspace="10" hspace="20" height="245" alt="Punktsymmetrie" src="img_glossar/Symmetrie_Punktsymmetrie.png" />
</html>

<<tiddler HideTiddlerSubtitle>>
Mithilfe eines Säulendiagramms lässt sich die [[Häufigkeitsverteilung|Häufigkeit]] einer [[Zufallsgröße]] darstellen. Hierbei wird auf der x-Achse für jedes eintretende Ergebnis eine Säule (Rechteck) mit jeweils gleicher beliebiger Breite eingetragen. Die Höhe der Säulen entspricht den [[absoluten bzw. relativen Häufigkeiten|Häufigkeit]].

!!!Beispiel:
Ein Tetraeder mit den Seiten 1, 2, 3 und 4 wird 20-mal geworfen. Aus den beobachteten Werten erhält man folgende Tabelle:
|Ergebnis | $\mathrm{1}$ | $\mathrm{2}$ | $\mathrm{3}$ | $\mathrm{4}$ |
|absolute Häufigkeit $\hspace{0.5em}$ | $\mathrm{10}$ | $\mathrm{2}$ | $\mathrm{5}$ | $\mathrm{3}$ |
|relative Häufigkeit | $\hspace{1em}\mathrm{\cfrac{10}{20}}\hspace{1em}$ | $\hspace{1em}\mathrm{\cfrac{2}{20}}\hspace{1em}$ | $\hspace{1em}\mathrm{\cfrac{5}{20}}\hspace{1em}$ | $\hspace{1em}\mathrm{\cfrac{3}{20}}\hspace{1em}$ |
<script>place.lastChild.className="noBorderHistogramm"</script>
<html>Zugehöriges Säulendiagramm relative Häufigkeiten:
<img width="286" height="306" vspace="10" hspace="20" src="img_glossar/Saeulendiagramm.png" alt="Saeulendiagramm"  />

Einen Spezialfall stellt das Stabdiagramm dar. Hierbei wird anstelle einer Säule nur eine Linie (mit entsprechender Höhe) parallel zur y-Achse angetragen.
<img width="268" height="306" vspace="10" hspace="20" src="img_glossar/Saeulendiagramm_Stabdiagramm.png" alt="Stabdiagramm" />
\( \ \rightarrow \) [[Kreisdiagramm]]
\( \ \rightarrow \) [[Histogramm]]
</html>

<html><div style="margin-left:25px; line-height: 1.5;">
*[[Tangente]]
*[[Terrassenpunkt]]
*[[Totale Wahrscheinlichkeit]]
*[[Trapez]]

</div></html>

/*{{{*/

.tab {white-space:pre-wrap;}

.tabContents {
background-color: #fff;
}

.tabSelected {
background-color: #fff;
font-weight:bold; font-size:140%;
padding: 2px 6px 2px 6px;
}

.tabUnselected {
background-color: #BDBDBD;
font-size:140%;
padding: 2px 6px 2px 6px;
}

/*}}}*/

/*{{{*/

/*Invisible table*/

.viewer .invisibletable table {border-color: white;}

.viewer .invisibletable table td {
font-size: 1em;
font-family: Verdana;
border-color: white;
padding: 10px 20px 10px 0px;
text-align: left;
vertical-align: top;
}

.viewer .invisibletable table th {
color: #005566;
background-color: white;
border-color: white;
font-family: Verdana;
font-size: 1em;
font-weight: bold;
padding: 10px 20px 10px 0px;
text-align: left;
vertical-align: top;
}


/*Anwendungsbeispiel

{{invisibletable{
|width:25em; ... | ... | ... |
| ... | ... | ... |
}}} */

/*}}}*/


/*{{{*/

/*Histogramm*/

.viewer .Histogramm table tbody {		/*Außenrahmen*/
border-style:solid; border-color: white;
}

.viewer .Histogramm table td {
border-style:solid;
}

.viewer .Histogramm table tr {
border-style:solid;
}

/*}}}*/


/*{{{*/

/*Tabelle Polstelle*/

.noBorderPolstelle tbody {border-style:solid; border-color: white;}  /*Außenrahmen*/
.noBorderPolstelle th {border-style:solid; border:0px} /*Hervorgehobene Zeile*/
.noBorderPolstelle td {border-style:solid; border:0px}
.noBorderPolstelle tr {border-style:solid; border:0px}

/*<script>place.lastChild.className="noBorderPolstelle"</script> hinter die entsprechende Tabelle Kopieren*/

/*}}}*/


/*{{{*/

/*Vierfeldertafel*/

.viewer .Vierfeldertafel table tbody {		/*Außenrahmen*/
border-style:solid; border-color: white;
}

.viewer .Vierfeldertafel table td {
border-style:solid;
}

.viewer .Vierfeldertafel table tr {
border-style:solid;
}

/*}}}*/


/*{{{*/

/*Zufallsexperiment*/

.viewer .Zufallsexperiment table td {
border-style:solid; border:0px;
font-size: 1em;
font-family: Verdana;
border-color: white;
padding: 10px 20px 10px 0px;
text-align: left;
vertical-align: top;
}

.viewer .Zufallsexperiment table tr {
border-style:solid; border:0px;
font-size: 1em;
font-family: Verdana;
border-color: white;
padding: 10px 20px 10px 0px;
text-align: left;
vertical-align: top;
}

/*}}}*/


/*{{{*/

/*Exponentielles Wachstum*/

.viewer .wachstum table {border-color: white; }

.viewer .wachstum table td {
border-color: white;
padding: 0px 0px 10px 0px;
}

.viewer .wachstum table th {
color: #005566;
background-color: white;
border-color: white;
padding: 0px 0px 10px 0px;
}

/*}}}*/

<<tiddler HideTiddlerSubtitle>>
<html>Die Tangente einer [[Funktion]] $\mathrm{f(x)}$ im Punkt $\mathrm{x_0}$ ist die Gerade, die dieselbe Steigung hat wie $\mathrm{f(x)}$ an der Stelle $\mathrm{x_0}$ und durch den Punkt $\mathrm{A(x_0\, |\, f(x_0))}$ geht. Die Tangente berührt den Graphen der Funktion $\mathrm{f}$ im Punkt $\mathrm{A(x_0\, |\, f(x_0))}$.

Man erhält die Steigung der Tangentengleichung $\mathrm{y = mx + t}$, indem man $\mathrm{m = f ′(x_0)}$ setzt. Die Konstante $\mathrm{t}$ berechnet man durch Einsetzen der Koordinaten von $\mathrm{A(x_0\, |\, f(x_0))}$ in die Tangentengleichung und anschließendes Auflösen nach $\mathrm{t}$.

<img vspace="0" hspace="20" border="0"  alt="Tangente" src="img_glossar/Tangente.png" />
</html>

<<tiddler HideTiddlerSubtitle>>
Ein Sattel- oder Terrassenpunkt einer [[Funktion]] ist ein [[Wendepunkt|Wendestelle]] mit waagrechter [[Tangente]].

Eine Funktion hat an der Stelle $\mathrm{x_0}$ einen Sattel- oder Terrassenpunkt, wenn $\mathrm{f'(x_0)=0}$ ist und $\mathrm{f'}$ an der Stelle $\mathrm{x_0}$ das Vorzeichen ''nicht'' wechselt.

$\hspace{10px}$[img(275px, )[Terrassenpunkt|img_glossar/Terrassenpunkt.png]]

/***
|Name|TiddlerTweakerPlugin|
|Source|http://www.TiddlyTools.com/#TiddlerTweakerPlugin|
|Version|2.4.5|
|Author|Eric Shulman|
|License|http://www.TiddlyTools.com/#LegalStatements|
|~CoreVersion|2.1|
|Type|plugin|
|Description|select multiple tiddlers and modify author, created, modified and/or tag values|
~TiddlerTweaker is a 'power tool' for TiddlyWiki authors.  Select multiple tiddlers from a listbox and 'bulk modify' the creator, author, created, modified and/or tag values of those tiddlers using a compact set of form fields.  The values you enter into the fields simultaneously overwrite the existing values in all tiddlers you have selected.
!!!!!Usage
<<<
{{{<<tiddlerTweaker>>}}}
{{smallform{<<tiddlerTweaker>>}}}
By default, any tags you enter into the TiddlerTweaker will //replace// the existing tags in all the tiddlers you have selected.  However, you can also use TiddlerTweaker to quickly filter specified tags from the selected tiddlers, while leaving any other tags assigned to those tiddlers unchanged:
>Any tag preceded by a '+' (plus) or '-' (minus), will be added or removed from the existing tags //instead of replacing the entire tag definition// of each tiddler (e.g., enter '-excludeLists' to remove that tag from all selected tiddlers.  When using this syntax, care should be taken to ensure that //every// tag is preceded by '+' or '-', to avoid inadvertently overwriting any other existing tags on the selected tiddlers.  (note: the '+' or '-' prefix on each tag value is NOT part of the tag value, and is only used by TiddlerTweaker to control how that tag value is processed)
Important Notes:
* TiddlerTweaker is a 'power user' tool that can make changes to many tiddlers at once.  ''You should always have a recent backup of your document (or 'save changes' just *before* tweaking the tiddlers), just in case you accidentally 'shoot yourself in the foot'.''
* The date and author information on any tiddlers you tweak will ONLY be updated if the corresponding checkboxes have been selected.  As a general rule, after using TiddlerTweaker, always ''//remember to save your document//'' when you are done, even though the tiddler timeline tab may not show any recently modified tiddlers.
* Selecting and updating all tiddlers in a document can take a while.  Your browser may warn about an 'unresponsive script'.  Usually, if you allow it to continue, it should complete the processing... eventually.  Nonetheless, be sure to save your work before you begin tweaking lots of tiddlers, just in case something does get stuck.
<<<
!!!!!Revisions
<<<
2011.01.21 2.4.5 auto-selection: use "-" for untagged tiddlers.  Also, added 'opened', 'invert'
2009.09.15 2.4.4 added 'edit' button. moved html definition to separate section
2009.09.13 2.4.3 in settiddlers(), convert backslashed chars (\n\b\s\t) in replacement text
2009.06.26 2.4.2 only add brackets around tags containing spaces
2009.06.22 2.4.1 in setFields(), add brackets around all tags shown tweaker edit field
2009.03.30 2.4.0 added 'sort by modifier'
2009.01.22 2.3.0 added support for text pattern find/replace
2008.10.27 2.2.3 in setTiddlers(), fixed Safari bug by replacing static Array.concat(...) with new Array().concat(...)
2008.09.07 2.2.2 added removeCookie() function for compatibility with [[CookieManagerPlugin]]
2008.05.12 2.2.1 replace built-in backstage tweak task with tiddler tweaker control panel (moved from BackstageTweaks)
2008.01.13 2.2.0 added 'auto-selection' links: all, changed, tags, title, text
2007.12.26 2.1.0 added support for managing 'creator' custom field (see [[CoreTweaks]])
2007.11.01 2.0.3 added config.options.txtTweakerSortBy for cookie-based persistence of list display order preference setting.
2007.09.28 2.0.2 in settiddlers() and deltiddlers(), added suspend/resume notification handling (improves performance when operating on multiple tiddlers)
2007.08.03 2.0.1 added shadow definition for [[TiddlerTweaker]] tiddler for use as parameter references with {{{<<tiddler>>, <<slider>> or <<tabs>>}}} macros.
2007.08.03 2.0.0 converted from inline script
2006.01.01 1.0.0 initial release
<<<
!!!!!Code
***/
//{{{
version.extensions.TiddlerTweakerPlugin= {major: 2, minor: 4, revision: 5, date: new Date(2011,1,21)};

// shadow tiddler
config.shadowTiddlers.TiddlerTweaker='<<tiddlerTweaker>>';

// defaults
if (config.options.txtTweakerSortBy==undefined) config.options.txtTweakerSortBy='modified';

// backstage task
if (config.tasks) { // for TW2.2b3 or above
	config.tasks.tweak.tooltip='review/modify tiddler internals: dates, authors, tags, etc.';
	config.tasks.tweak.content='{{smallform small groupbox{<<tiddlerTweaker>>}}}';
}

// if removeCookie() function is not defined by TW core, define it here.
if (window.removeCookie===undefined) {
	window.removeCookie=function(name) {
		document.cookie = name+'=; expires=Thu, 01-Jan-1970 00:00:01 UTC; path=/;';
	}
}

config.macros.tiddlerTweaker = {
	handler: function(place,macroName,params,wikifier,paramString,tiddler) {
		var span=createTiddlyElement(place,'span');
		span.innerHTML=store.getTiddlerText('TiddlerTweakerPlugin##html');
		this.init(span.getElementsByTagName('form')[0],config.options.txtTweakerSortBy);
	},
	init: function(f,sortby) { // set form controls
		if (!f) return; // form might not be rendered yet...
		while (f.list.options[0]) f.list.options[0]=null; // empty the list
		var tids=store.getTiddlers(sortby);
		if (sortby=='size') // descending order
			tids.sort(function(a,b) {return a.text.length > b.text.length ? -1 : (a.text.length == b.text.length ? 0 : +1);});
		var who='';
		for (i=0; i<tids.length; i++) { var t=tids[i];
			var label=t.title; var value=t.title;
			switch (sortby) {
				case 'modified':
				case 'created':
					var t=tids[tids.length-i-1]; // reverse order
					var when=t[sortby].formatString('YY.0MM.0DD 0hh:0mm ');
					label=when+t.title;
					value=t.title;
					break;
				case 'size':
					label='['+t.text.length+'] '+label;
					break;
				case 'modifier':
				case 'creator':
					if (who!=t[sortby]) {
						who=t[sortby];
						f.list.options[f.list.length]=new Option('by '+who+':','',false,false);
					}
					label='\xa0\xa0\xa0'+label; // indent
					break;
			}
			f.list.options[f.list.length]=new Option(label,value,false,false);
		}
		f.title.value=f.who.value=f.creator.value=f.tags.value='';
		f.cm.value=f.cd.value=f.cy.value=f.ch.value=f.cn.value='';
		f.mm.value=f.md.value=f.my.value=f.mh.value=f.mn.value='';
		f.stats.disabled=f.set.disabled=f.del.disabled=f.edit.disabled=f.display.disabled=true;
		f.settitle.disabled=false;
		config.options.txtTweakerSortBy=sortby;
		f.sortby.value=sortby; // sync droplist
		if (sortby!='modified') saveOptionCookie('txtTweakerSortBy');
		else removeCookie('txtTweakerSortBy');
	},
	enablefields: function(here) { // enables/disables inputs based on #items selected
		var f=here.form; var list=f.list;
		var c=0; for (i=0;i<list.length;i++) if (list.options[i].selected) c++;
		if (c>1) f.title.disabled=true;
		if (c>1) f.settitle.checked=false;
		f.set.disabled=(c==0);
		f.del.disabled=(c==0);
		f.edit.disabled=(c==0);
		f.display.disabled=(c==0);
		f.settitle.disabled=(c>1);
		f.stats.disabled=(c==0);
		var msg=(c==0)?'select tiddlers':(c+' tiddler'+(c!=1?'s':'')+' selected');
		here.previousSibling.firstChild.firstChild.nextSibling.innerHTML=msg;
		if (c) clearMessage(); else displayMessage('no tiddlers selected');
	},
	setfields: function(here) { // set fields from first selected tiddler
		var f=here.form;
		if (!here.value.length) {
			f.title.value=f.who.value=f.creator.value=f.tags.value='';
			f.cm.value=f.cd.value=f.cy.value=f.ch.value=f.cn.value='';
			f.mm.value=f.md.value=f.my.value=f.mh.value=f.mn.value='';
			return;
		}
		var tid=store.getTiddler(here.value); if (!tid) return;
		f.title.value=tid.title;
		f.who.value=tid.modifier;
		f.creator.value=tid.fields['creator']||''; // custom field - might not exist
		f.tags.value=tid.tags.map(function(t){return String.encodeTiddlyLink(t)}).join(' ');
		var c=tid.created; var m=tid.modified;
		f.cm.value=c.getMonth()+1;
		f.cd.value=c.getDate();
		f.cy.value=c.getFullYear();
		f.ch.value=c.getHours();
		f.cn.value=c.getMinutes();
		f.mm.value=m.getMonth()+1;
		f.md.value=m.getDate();
		f.my.value=m.getFullYear();
		f.mh.value=m.getHours();
		f.mn.value=m.getMinutes();
	},
	selecttiddlers: function(here,callback) {
		var f=here; while (f&&f.nodeName.toLowerCase()!='form')f=f.parentNode;
		for (var t=f.list.options.length-1; t>=0; t--)
			f.list.options[t].selected=callback(f.list.options[t]);
		config.macros.tiddlerTweaker.enablefields(f.list);
		return false;
	},
	settiddlers: function(here) {
		var f=here.form; var list=f.list;
		var tids=[];
		for (i=0;i<list.length;i++) if (list.options[i].selected) tids.push(list.options[i].value);
		if (!tids.length) { alert('please select at least one tiddler'); return; }
		var cdate=new Date(f.cy.value,f.cm.value-1,f.cd.value,f.ch.value,f.cn.value);
		var mdate=new Date(f.my.value,f.mm.value-1,f.md.value,f.mh.value,f.mn.value);
		if (tids.length>1 && !confirm('Are you sure you want to update these tiddlers:\n\n'+tids.join(', '))) return;
		store.suspendNotifications();
		for (t=0;t<tids.length;t++) {
			var tid=store.getTiddler(tids[t]); if (!tid) continue;
			var title=!f.settitle.checked?tid.title:f.title.value;
			var who=!f.setwho.checked?tid.modifier:f.who.value;
			var text=tid.text;
			if (f.replacetext.checked) {
				var r=f.replacement.value.replace(/\\t/mg,'\t').unescapeLineBreaks();
				text=text.replace(new RegExp(f.pattern.value,'mg'),r);
			}
			var tags=tid.tags;
			if (f.settags.checked) {
				var intags=f.tags.value.readBracketedList();
				var addtags=[]; var deltags=[]; var reptags=[];
				for (i=0;i<intags.length;i++) {
					if (intags[i].substr(0,1)=='+')
						addtags.push(intags[i].substr(1));
					else if (intags[i].substr(0,1)=='-')
						deltags.push(intags[i].substr(1));
					else
						reptags.push(intags[i]);
				}
				if (reptags.length)
					tags=reptags;
				if (addtags.length)
					tags=new Array().concat(tags,addtags);
				if (deltags.length)
					for (i=0;i<deltags.length;i++)
						{ var pos=tags.indexOf(deltags[i]); if (pos!=-1) tags.splice(pos,1); }
			}
			if (!f.setcdate.checked) cdate=tid.created;
			if (!f.setmdate.checked) mdate=tid.modified;
			store.saveTiddler(tid.title,title,text,who,mdate,tags,tid.fields);
			if (f.setcreator.checked) store.setValue(tid.title,'creator',f.creator.value); // set creator
			if (f.setcdate.checked) tid.assign(null,null,null,null,null,cdate); // set create date
		}
		store.resumeNotifications();
		this.init(f,f.sortby.value);
	},
	displaytiddlers: function(here,edit) {
		var f=here.form; var list=f.list;
		var tids=[];
		for (i=0; i<list.length;i++) if (list.options[i].selected) tids.push(list.options[i].value);
		if (!tids.length) { alert('please select at least one tiddler'); return; }
		story.displayTiddlers(story.findContainingTiddler(f),tids,edit?DEFAULT_EDIT_TEMPLATE:null);
	},
	deltiddlers: function(here) {
		var f=here.form; var list=f.list;
		var tids=[];
		for (i=0;i<list.length;i++) if (list.options[i].selected) tids.push(list.options[i].value);
		if (!tids.length) { alert('please select at least one tiddler'); return; }
		if (!confirm('Are you sure you want to delete these tiddlers:\n\n'+tids.join(', '))) return;
		store.suspendNotifications();
		for (t=0;t<tids.length;t++) {
			var tid=store.getTiddler(tids[t]); if (!tid) continue;
			if (tid.tags.contains('systemConfig')) {
				var msg=tid.title+' is tagged with systemConfig.'
					+'\n\nRemoving this tiddler may cause unexpected results.  Are you sure?';
				if (!confirm(msg)) continue;
			}
			store.removeTiddler(tid.title);
			story.closeTiddler(tid.title);
		}
		store.resumeNotifications();
		this.init(f,f.sortby.value);
	},
	stats: function(here) {
		var f=here.form; var list=f.list; var tids=[]; var out=''; var tot=0;
		var target=f.nextSibling;
		for (i=0;i<list.length;i++) if (list.options[i].selected) tids.push(list.options[i].value);
		if (!tids.length) { alert('please select at least one tiddler'); return; }
		for (t=0;t<tids.length;t++) {
			var tid=store.getTiddler(tids[t]); if (!tid) continue;
			out+='[['+tid.title+']] '+tid.text.length+'\n'; tot+=tid.text.length;
		}
		var avg=tot/tids.length;
		out=tot+' bytes in '+tids.length+' selected tiddlers ('+avg+' bytes/tiddler)\n<<<\n'+out+'<<<\n';
		removeChildren(target);
		target.innerHTML="<hr><font size=-2><a href='javascript:;' style='float:right' "
			+"onclick='this.parentNode.parentNode.style.display=\"none\"'>close</a></font>";
		wikify(out,target);
		target.style.display='block';
	}
};
//}}}
/***
//{{{
!html
<style>
.tiddlerTweaker table,
.tiddlerTweaker table tr,
.tiddlerTweaker table td
	{ padding:0;margin:0;border:0;white-space:nowrap; }
</style><form class='tiddlerTweaker'><!--
--><table style="width:100%"><tr valign="top"><!--
--><td style="text-align:center;width:99%;"><!--
	--><font size=-2><div style="text-align:left;"><span style="float:right"><!--
	-->&nbsp; <a href="javascript:;"
		title="select all tiddlers"
		onclick="return config.macros.tiddlerTweaker.selecttiddlers(this,function(opt){
			return opt.value.length;
		});">all</a><!--
	-->&nbsp; <a href="javascript:;"
		title="select tiddlers currently displayed in the story column"
		onclick="return config.macros.tiddlerTweaker.selecttiddlers(this,function(opt){
			return story.getTiddler(opt.value);
		});">opened</a><!--
	-->&nbsp; <a href="javascript:;"
		title="select tiddlers that are new/changed since the last file save"
		onclick="var lastmod=new Date(document.lastModified);
			return config.macros.tiddlerTweaker.selecttiddlers(this,function(opt){
				var tid=store.getTiddler(opt.value);
				return tid&&tid.modified>lastmod;
			});
		">changed</a><!--
	-->&nbsp; <a href="javascript:;"
		title="select tiddlers with at least one matching tag"
		onclick="var t=prompt('Enter space-separated tags (match one or more).  Use \x22-\x22 to match untagged tiddlers');
			if (!t||!t.length) return false;
			var tags=t.readBracketedList();
			return config.macros.tiddlerTweaker.selecttiddlers(this,function(opt){
				var tid=store.getTiddler(opt.value);
				return tid&&tags[0]=='-'?!tid.tags.length:tid.tags.containsAny(tags);
			});
		">tags</a><!--
	-->&nbsp; <a href="javascript:;"
		title="select tiddlers whose titles include matching text"
		onclick="var t=prompt('Enter a title (or portion of a title) to match');
			if (!t||!t.length) return false;
			return config.macros.tiddlerTweaker.selecttiddlers(this,function(opt){
				return opt.value.indexOf(t)!=-1;
			});
		">titles</a><!--
	-->&nbsp; <a href="javascript:;"
		title="select tiddlers containing matching text"
		onclick="var t=prompt('Enter tiddler text (content) to match');
			if (!t||!t.length) return false;
			return config.macros.tiddlerTweaker.selecttiddlers(this,function(opt){
				var tt=store.getTiddlerText(opt.value,'');
				return tt.indexOf(t)!=-1;
			});
		">text</a><!--
	-->&nbsp; <a href="javascript:;"
		title="reverse selection of all list items"
		onclick="return config.macros.tiddlerTweaker.selecttiddlers(this,function(opt){
			return !opt.selected;
		});">invert</a><!--
	--></span><span>select tiddlers</span><!--
	--></div><!--
	--></font><select multiple name=list size="11" style="width:99.99%"
		title="use click, shift-click and/or ctrl-click to select multiple tiddler titles"
		onclick="config.macros.tiddlerTweaker.enablefields(this)"
		onchange="config.macros.tiddlerTweaker.setfields(this)"><!--
	--></select><br><!--
	-->show<input type=text size=1 value="11"
		onchange="this.form.list.size=this.value; this.form.list.multiple=(this.value>1);"><!--
	-->by<!--
	--><select name=sortby size=1
		onchange="config.macros.tiddlerTweaker.init(this.form,this.value)"><!--
	--><option value="title">title</option><!--
	--><option value="size">size</option><!--
	--><option value="modified">modified</option><!--
	--><option value="created">created</option><!--
	--><option value="modifier">modifier</option><!--
	--></select><!--
	--><input type="button" value="refresh"
		onclick="config.macros.tiddlerTweaker.init(this.form,this.form.sortby.value)"<!--
	--> <input type="button" name="stats" disabled value="totals..."
		onclick="config.macros.tiddlerTweaker.stats(this)"><!--
--></td><td style="width:1%"><!--
	--><div style="text-align:left"><font size=-2>&nbsp;modify values</font></div><!--
	--><table style="width:100%;"><tr><!--
	--><td style="padding:1px"><!--
		--><input type=checkbox name=settitle unchecked
			title="allow changes to tiddler title (rename tiddler)"
			onclick="this.form.title.disabled=!this.checked">title<!--
	--></td><td style="padding:1px"><!--
		--><input type=text name=title size=35 style="width:98%" disabled><!--
	--></td></tr><tr><td style="padding:1px"><!--
		--><input type=checkbox name=setcreator unchecked
			title="allow changes to tiddler creator"
			onclick="this.form.creator.disabled=!this.checked">created by<!--
	--></td><td style="padding:1px;"><!--
		--><input type=text name=creator size=35 style="width:98%" disabled><!--
	--></td></tr><tr><td style="padding:1px"><!--
		--><input type=checkbox name=setwho unchecked
			title="allow changes to tiddler author"
			onclick="this.form.who.disabled=!this.checked">modified by<!--
	--></td><td style="padding:1px"><!--
		--><input type=text name=who size=35 style="width:98%" disabled><!--
	--></td></tr><tr><td style="padding:1px"><!--
		--><input type=checkbox name=setcdate unchecked
			title="allow changes to created date"
			onclick="var f=this.form;
				f.cm.disabled=f.cd.disabled=f.cy.disabled=f.ch.disabled=f.cn.disabled=!this.checked"><!--
		-->created on<!--
	--></td><td style="padding:1px"><!--
		--><input type=text name=cm size=2 style="width:2em;padding:0;text-align:center" disabled><!--
		--> / <input type=text name=cd size=2 style="width:2em;padding:0;text-align:center" disabled><!--
		--> / <input type=text name=cy size=4 style="width:3em;padding:0;text-align:center" disabled><!--
		--> at <input type=text name=ch size=2 style="width:2em;padding:0;text-align:center" disabled><!--
		--> : <input type=text name=cn size=2 style="width:2em;padding:0;text-align:center" disabled><!--
	--></td></tr><tr><td style="padding:1px"><!--
		--><input type=checkbox name=setmdate unchecked
			title="allow changes to modified date"
			onclick="var f=this.form;
				f.mm.disabled=f.md.disabled=f.my.disabled=f.mh.disabled=f.mn.disabled=!this.checked"><!--
		-->modified on<!--
	--></td><td style="padding:1px"><!--
		--><input type=text name=mm size=2 style="width:2em;padding:0;text-align:center" disabled><!--
		--> / <input type=text name=md size=2 style="width:2em;padding:0;text-align:center" disabled><!--
		--> / <input type=text name=my size=4 style="width:3em;padding:0;text-align:center" disabled><!--
		--> at <input type=text name=mh size=2 style="width:2em;padding:0;text-align:center" disabled><!--
		--> : <input type=text name=mn size=2 style="width:2em;padding:0;text-align:center" disabled><!--
	--></td></tr><tr><td style="padding:1px"><!--
		--><input type=checkbox name=replacetext unchecked
			title="find/replace matching text"
			onclick="this.form.pattern.disabled=this.form.replacement.disabled=!this.checked">replace text<!--
	--></td><td style="padding:1px"><!--
		--><input type=text name=pattern size=15 value="" style="width:40%" disabled
			title="enter TEXT PATTERN (regular expression)"> with<!--
		--><input type=text name=replacement size=15 value="" style="width:40%" disabled
			title="enter REPLACEMENT TEXT"><!--
	--></td></tr><tr><td style="padding:1px"><!--
		--><input type=checkbox name=settags checked
			title="allow changes to tiddler tags"
			onclick="this.form.tags.disabled=!this.checked">tags<!--
	--></td><td style="padding:1px"><!--
		--><input type=text name=tags size=35 value="" style="width:98%"
			title="enter new tags or use '+tag' and '-tag' to add/remove tags from existing tags"><!--
	--></td></tr></table><!--
	--><div style="text-align:center"><!--
	--><nobr><input type=button name=display disabled style="width:24%" value="display"
		title="show selected tiddlers"
		onclick="config.macros.tiddlerTweaker.displaytiddlers(this,false)"><!--
	--> <input type=button name=edit disabled style="width:23%" value="edit"
		title="edit selected tiddlers"
		onclick="config.macros.tiddlerTweaker.displaytiddlers(this,true)"><!--
	--> <input type=button name=del disabled style="width:24%" value="delete"
		title="remove selected tiddlers"
		onclick="config.macros.tiddlerTweaker.deltiddlers(this)"><!--
	--> <input type=button name=set disabled style="width:24%" value="update"
		title="update selected tiddlers"
		onclick="config.macros.tiddlerTweaker.settiddlers(this)"></nobr><!--
	--></div><!--
--></td></tr></table><!--
--></form><span style="display:none"><!--content replaced by tiddler "stats"--></span>
!end
//}}}<<tiddler HideTiddlerTags>><<tiddler HideTiddlerSubtitle>><<tiddler HideTiddlerSubtitle with: TiddlerTitle>>
***/

/*{{{ Funktioniert nur, falls ~LeftSidebar aktiviert }}}*/

/%
|Name|ToggleLeftSidebar|
|Source|http://www.TiddlyTools.com/#ToggleLeftSidebar|
|Version|2.0.0|
|Author|Eric Shulman - ELS Design Studios|
|License|http://www.TiddlyTools.com/#LegalStatements <br>and [[Creative Commons Attribution-ShareAlike 2.5 License|http://creativecommons.org/licenses/by-sa/2.5/]]|
|~CoreVersion|2.1|
|Type|script|
|Requires|InlineJavascriptPlugin|
|Overrides||
|Description|show/hide left sidebar (MainMenu)|

Usage: <<tiddler ToggleLeftSidebar with: "label">>

Config settings:
	config.options.chkShowLeftSidebar (true)
	config.options.txtToggleLeftSideBarLabelShow (►)
	config.options.txtToggleLeftSideBarLabelHide (◄)

%/<script label="$1" title="show/hide MainMenu content">
	var co=config.options;
	if (co.chkShowLeftSidebar=='undefined') co.chkShowLeftSidebar=true;
	co.chkShowLeftSidebar=!co.chkShowLeftSidebar;
	var mm=document.getElementById('mainMenu'); if (!mm) return;
	mm.style.display=co.chkShowLeftSidebar?'block':'none';
	document.getElementById('displayArea').style.marginLeft=co.chkShowLeftSidebar?'':'1em';
	saveOptionCookie('chkShowLeftSidebar');
	var labelShow=co.txtToggleLeftSideBarLabelShow||'&#x25BA;';
	var labelHide=co.txtToggleLeftSideBarLabelHide||'&#x25C4;';
	if (typeof(place)!='undefined' && '$1'=='$'+'1') {
		place.innerHTML=co.chkShowLeftSidebar?labelHide:labelShow;
		place.title=(co.chkShowLeftSidebar?'hide':'show')+' left sidebar';
	}
	var sm=document.getElementById('storyMenu'); if (sm) config.refreshers.content(sm);
</script><script>
	var co=config.options;
	if (co.chkShowLeftSidebar=='undefined') co.chkShowLeftSidebar=true;
	var mm=document.getElementById('mainMenu'); if (!mm) return;
	mm.style.display=co.chkShowLeftSidebar?'block':'none';
	document.getElementById('displayArea').style.marginLeft=co.chkShowLeftSidebar?'':'1em';
	if ('$1'=='$'+'1') {
		var labelShow=co.txtToggleLeftSideBarLabelShow||'&#x25BA;';
		var labelHide=co.txtToggleLeftSideBarLabelHide||'&#x25C4;';
		place.lastChild.innerHTML=co.chkShowLeftSidebar?labelHide:labelShow;
		place.lastChild.title=(co.chkShowLeftSidebar?'hide':'show')+' left sidebar';
	}
</script>

/%
|Name|ToggleRightSidebar|
|Source|http://www.TiddlyTools.com/#ToggleRightSidebar|
|Version|2.0.0|
|Author|Eric Shulman - ELS Design Studios|
|License|http://www.TiddlyTools.com/#LegalStatements <br>and [[Creative Commons Attribution-ShareAlike 2.5 License|http://creativecommons.org/licenses/by-sa/2.5/]]|
|~CoreVersion|2.1|
|Type|script|
|Requires|InlineJavascriptPlugin|
|Overrides||
|Description|show/hide right sidebar (MainMenu)|

Usage: <<tiddler ToggleRightSidebar with: "label">>

Config settings:
	config.options.chkShowRightSidebar (true)
	config.options.txtToggleRightSideBarLabelShow (◄)
	config.options.txtToggleRightSideBarLabelHide (►)

%/<script label="$1" title="show/hide right sidebar content">
	var co=config.options;
	if (co.chkShowRightSidebar=='undefined') co.chkShowRightSidebar=true;
	co.chkShowRightSidebar=!co.chkShowRightSidebar;
	var sb=document.getElementById('sidebar'); if (!sb) return;
	sb.style.display=co.chkShowRightSidebar?'block':'none';
	document.getElementById('displayArea').style.marginRight=co.chkShowRightSidebar?'':'1em';
	saveOptionCookie('chkShowRightSidebar');
	var labelShow=co.txtToggleRightSideBarLabelShow||'&#x25C4;';
	var labelHide=co.txtToggleRightSideBarLabelHide||'&#x25BA;';
	if (typeof(place)!='undefined' && '$1'=='$'+'1') {
		place.innerHTML=co.chkShowRightSidebar?labelHide:labelShow;
		place.title=(co.chkShowRightSidebar?'hide':'show')+' right sidebar';
	}
	var sm=document.getElementById('storyMenu'); if (sm) config.refreshers.content(sm);
</script><script>
	var co=config.options;
	if (co.chkShowRightSidebar=='undefined') co.chkShowRightSidebar=true;
	var sb=document.getElementById('sidebar'); if (!sb) return;
	sb.style.display=co.chkShowRightSidebar?'block':'none';
	document.getElementById('displayArea').style.marginRight=co.chkShowRightSidebar?'':'1em';
	if ('$1'=='$'+'1') {
		var labelShow=co.txtToggleRightSideBarLabelShow||'&#x25C4;';
		var labelHide=co.txtToggleRightSideBarLabelHide||'&#x25BA;';
		place.lastChild.innerHTML=co.chkShowRightSidebar?labelHide:labelShow;
		place.lastChild.title=(co.chkShowRightSidebar?'hide':'show')+' right sidebar';
	}
</script>

|~ViewToolbar|closeTiddler closeOthers|
|~EditToolbar|+saveTiddler -cancelTiddler deleteTiddler|

<html></html>
&nbsp; &nbsp; <<search>> &nbsp; <<closeAll>>
<<tabs txtNavi
A  "" [[A]]
B "" [[B]]
C "" [[C]]
D "" [[D]]
E "" [[E]]
F "" [[F]]
G "" [[G]]
H "" [[H]]
I "" [[I]]
J "" [[J]]
K "" [[K]]
L "" [[L]]
M "" [[M]]
N "" [[N]]
O "" [[O]]
P "" [[P]]
Q "" [[Q]]
R "" [[R]]
S "" [[S]]
T "" [[T]]
U "" [[U]]
V "" [[V]]
W "" [[W]]
X "" [[X]]
Y "" [[Y]]
Z "" [[Z]]
>>

<<tiddler HideTiddlerSubtitle>>
<html>Der Satz der totalen Wahrscheinlichkeit liefert die [[Wahrscheinlichkeit]] des [[Ereignisses|Ereignis]] $\mathrm{A:}$
$$\mathrm{ P(A) = P(B) \cdot P_{B}(A) + P( \overline{B} ) \cdot P_{ \overline{B} }(A)}$$
<img width="401" vspace="10" hspace="20" height="212" src="img_glossar/Totale.Wahrscheinlichkeit.png" alt="Totale Wahrscheinlichkeit"/>
<p>\( \ \rightarrow \) [[Baumdiagramm]]
\( \ \rightarrow \) [[Pfadregeln]]
</html>

<<tiddler HideTiddlerSubtitle>>
<html><img width="200" vspace="0" hspace="20"  align="right" height="152" alt="Trapez" src="img_glossar/Trapez.png" /> Ein Trapez ist ein Viereck mit einem Paar [[paralleler|Parallelität]] Seiten. Ein Spezialfall des Trapezes ist das [[Parallelogramm]].
<p>Die beiden zueinander parallelen Seiten (in der Skizze sind dies die Seiten $\mathrm{a}$ und $\mathrm{c}$) nennt man Grundseiten, die beiden anderen Seiten (in der Skizze $\mathrm{b}$ und $\mathrm{d}$) nennt man Schenkel. Zumeist wird die längere der beiden Grundseiten als Basis bezeichnet (in der Skizze ist dies Seite $\mathrm{a}$).
<p>Für das Trapez $\mathrm{ABCD}$, wie es die Skizze zeigt, gilt:
<p style="margin-top: -5px;">*Die an den beiden Schenkeln benachbarten Winkel ergänzen sich jeweils zu 180°.
<p style="margin-top: -5px;">*Die Innenwinkelsumme beträgt 360°.
<p style="margin-top: -5px;">*Der Flächeninhalt des Trapezes lässt sich wie folgt berechnen:
$$\mathrm{ A_T = \frac{ {\large|}\,\vec{AB}\,{\large|} + {\large|}\,\vec{CD}\,{\large|} }{2} \cdot  h}$$
</html>

<html><div style="margin-left:25px; line-height: 1.5;">
*[[Umkehrbarkeit von Funktionen]]
*[[Unbestimmtes Integral]]
*[[Uneigentliches Integral]]
*[[Unmögliches Ereignis]]
*[[Unvereinbare Ereignisse]]

</div></html>

<<tiddler HideTiddlerSubtitle>>
<html>Eine [[Funktion]] $\mathrm{f(x)}$ ist umkehrbar, wenn es zu jedem $\mathrm{y}$ aus der [[Wertemenge]] genau ein $\mathrm{x}$ aus der [[Definitionsmenge]] mit $\mathrm{f(x) = y}$ gibt.
Alternativ gilt: Eine Funktion $\mathrm{f(x)}$ ist auf ihrem Definitionsbereich bzw. einem Teilintervall des Definitionsbereichs umkehrbar, wenn sie dort entweder nur streng [[monoton steigt|Monotonie]] oder nur streng [[monoton fällt|Monotonie]].
<p>Die Definitionsmenge der Umkehrfunktion $\mathrm{f^{-1}(x)}$ entspricht der Wertemenge der ursprünglichen Funktion und ihre Wertemenge der Definitionsmenge von $\mathrm{ f(x)}$, d.h. es gilt:
<p style="margin-top: -5px;">$\hspace{4em}\mathrm{D_{f^{-1}} = W_f}$ und $\mathrm{W_{f^{-1}}=D_f}$.
<p>Der Graph der Umkehrfunktion $\mathrm{f^{-1}(x)}$ entsteht durch Spiegelung des Graphen von $\mathrm{f(x)}$ an der Winkelhalbierenden des ersten und dritten Quadranten, also an der Geraden $\mathrm{h: \  y = x}$.

<p>!!!Beispiele:
Ein typisches Umkehrfunktionenpaar bilden [[Logarithmus-|Logarithmusfunktion]] und [[Exponentialfunktion]]:
<img  width="369" height="431" vspace="10" hspace="20" alt="Umkehrfunktion" src="img_glossar/Umkehrfunktion.png" />
<div style="line-height:2";>Dies kann auch rechnerisch nachgewiesen werden:
Ist $\mathrm{f(x)=e^x}$, mit  $\mathrm{D_f=\mathbb R}$ und $\mathrm{W_f=\mathbb R^{+}}$, so folgt:
$$\begin{array}{lrll} & \mathrm{y} & \mathrm{\hspace{-0.6em}= e^x} & \\ \mathrm{\Leftrightarrow} & \mathrm{\ln y} & \mathrm{\hspace{-0.6em}= x}  & \\  & \mathrm{y} & \mathrm{\hspace{-0.6em}=\ln x} & \ \ \mathrm{{\large |}\text{  x und y vertauschen}} \end{array}$$ Für die Umkehrfunktion $\mathrm{f^{-1}}$ folgt somit:
$\mathrm{f^{-1}(x)=\ln x}$ , mit $\mathrm{D_{f^{-1}}=W_f=\mathbb R^{+}}$ und $\mathrm{W_{f^{-1}}=D_f=\mathbb R}$</div>
</html>

<<tiddler HideTiddlerSubtitle>>
<html>Die Menge aller [[Stammfunktionen|Stammfunktion]] einer [[Funktion]] $\mathrm{f(x)}$ wird durch das unbestimmte Integral beschrieben:
$$\mathrm{\int \,f(x) \ dx = F(x) + C \, ; \ C\in\mathbb R }$$
</html>

<<tiddler HideTiddlerSubtitle>>
<html>Bei der Berechnung von Flächen, die ins Unendliche reichen, sind eine oder beide Integrationsgrenzen des Integrals Ränder des Definitionsbereichs. Man spricht von einem uneigentlichen Integral. In diesem Fall muss mit dem Grenzwert gerechnet werden:
<p>''1. Fall:'' Unendliche Integrationsgrenze
$$\mathrm{\int\limits_a^\infty \,f(x) \ dx = \lim_{b\rightarrow\infty}\,\int\limits_a^b f(x) \ dx = \lim_{b\rightarrow\infty}\,[F(x)]_a^b}$$

''2. Fall:'' Definitionslücke $\mathrm{e}$ von $\mathrm{f(x)}$ als Integrationsgrenze
$$\mathrm{\int\limits_a^e \,f(x) \ dx = \lim_{b\rightarrow e}\,\int\limits_a^b f(x) \ dx = \lim_{b\rightarrow e}\,[F(x)]_a^b }$$
</html>

<<tiddler HideTiddlerSubtitle>>
<html>Ein [[Ereignis]], das beim [[Zufallsexperiment]] nicht eintreten kann, heißt unmögliches Ereignis.
Die [[Wahrscheinlichkeit]] für ein unmögliches Ereignis $\mathrm{A}$ beträgt $\mathrm{P(A) = 0}$.

<p style="margin-top: -5px;">!!!Beispiel:
Beim Würfelwurf ist das Ereignis $\mathrm{A = \{7\}}$ ein unmögliches Ereignis, da nur Zahlen zwischen $\mathrm{1}$ und $\mathrm{6}$ gewürfelt werden können.
<p>\( \ \rightarrow \) [[Sicheres Ereignis]]
</html>

<<tiddler HideTiddlerSubtitle>>
<html><div style="line-height:2";>Zwei [[Ereignisse|Ereignis]] heißen genau dann unvereinbar, wenn sie kein [[Ergebnis]] gemeinsam haben.
In der Mengenschreibweise bedeutet dies: $\mathrm{A \cap B = \{ \ \}}$
Für die [[Wahrscheinlichkeit]] gilt: $\mathrm{P (A \cap B) = 0}$</div>
!!!Beispiel:
Beim Würfelwurf sind die beiden Ereignisse $\mathrm{A = \{2,\, 4,\, 6\}}$ (in Worten: "Es wird eine gerade Zahl gewürfelt") und $\mathrm{B = \{3\}}$ („Es wird 3 gewürfelt") unvereinbar.

Begründung: Das Ereignis $\mathrm{A \cap B = \{ \ \}}$ („Es wird eine gerade Zahl gewürfelt und es wird 3 gewürfelt") ist ein [[unmögliches Ereignis|Unmögliches Ereignis]].
</html>

<html><div style="margin-left:25px; line-height: 1.5;">
*[[Varianz]]
*[[Vektoraddition]]
*[[Vektorprodukt]]
*[[Vektorsubtraktion]]
*[[Verbindungsvektor]]
*[[Verhalten an den Rändern des Definitionsbereichs]]
*[[Verketten von Funktionen]]
*[[Verschieben von Funktionen]]
*[[Vierfeldertafel]]

</div></html>

<<tiddler HideTiddlerSubtitle>>
<html>Die Varianz ist ein Maß für die Streuung einer [[Zufallsgröße]] $\mathrm{Z}$. Sie misst die quadrierten Abstände der einzelnen Werte $\mathrm{z_i}$ zum [[Erwartungswert]] $\mathrm{E(Z) = \mu}$. Dabei werden die einzelnen quadrierten Abstände mit den jeweiligen Einzelwahrscheinlichkeiten gewichtet und aufsummiert:
$$\begin{array}{lll}\mathrm{Var(Z)}  & \mathrm{=} & \mathrm{(z_{1} - \mu)^{2} \cdot P(Z = z_{1} ) + \, \dots \, + (z_{n} - \mu)^{2} \cdot P(Z = z_{n} )} \\
 & \mathrm{=} & \mathrm{\sum\limits_{i\ =\ 1}^{n} (z_{i} - \mu)^{2} \cdot  P(Z = z_{i})}  \end{array}$$
Da die Varianz durch die Quadrierung eine schlecht interpretierbare Einheit (z.B. $\mathrm{€^{\,2}}$) besitzt, wird die Standardabweichung $\mathrm{\sigma(Z)}$ als ihre positive Wurzel definiert:
$$\mathrm{\sigma (Z) = \sqrt{Var(Z)}}$$

!!!Beispiel:
<p style="margin-top:5pt;">Für den fairen Würfelwurf ergeben sich aus dem Erwartungswert $\mathrm{E(Z) = 3,5}$ folgende Streuungsmaße:
$$\mathrm{ Var(Z) = \left[(1-3,5)^{2} + (2-3,5)^{2} + (3-3,5)^{2} + (4-3,5)^{2} + (5-3,5)^{2} + (6-3,5)^{2}\right] \cdot \frac{1}{6}=\frac{35}{12} }$$
</html>

<<tiddler HideTiddlerSubtitle>>
<html><img width="110" vspace="0" hspace="20" align="right" height="124" alt="Vektoraddition" src="img_glossar/Vektoraddition.png" /> Im Anschauungsraum entspricht die Addition zweier Vektoren $\mathrm{ \vec a}$ und $\mathrm{ \vec b}$ der folgenden Operation: Man trägt den Vektor $\mathrm{ \vec b}$ an den Endpunkt des Vektors $\mathrm{ \vec a}$ an. Der Summenvektor ist dann der Verbindungsvektor des Anfangspunktes von $\mathrm{ \vec a}$ mit dem Endpunkt des an den Endpunkt von $\mathrm{ \vec a}$ angetragenen Vektors $\mathrm{ \vec b}$ (s. Skizze).
<p>Für die Vektoraddition als algebraische Rechenoperation zwischen Vektoren gilt folgende Regel:
Zwei Vektoren  $\mathrm{ \vec a = \begin{pmatrix} \mathrm{a_1} \\ \mathrm{a_2}\\ \mathrm{a_3} \end{pmatrix}} \$ und $\ \mathrm{ \vec b = \begin{pmatrix} \mathrm{b_1} \\ \mathrm{b_2} \\ \mathrm{b_3} \end{pmatrix} }$ werden addiert, indem man ihre Einträge zeilenweise addiert.
<p>Für den Summenvektor $\mathrm{\vec a + \vec b}$ gilt somit:
$$\mathrm{ \vec a + \vec b = \begin{pmatrix} \mathrm{a_1 + b_1} \\ \mathrm{a_2 + b_2}\\ \mathrm{a_3 + b_3} \end{pmatrix}}$$
<p>\( \ \rightarrow \) [[Rechnen mit Vektoren]]
</html>

<<tiddler HideTiddlerSubtitle>>
<html><img width="170" vspace="0" hspace="20" align="right" height="165" alt="Vektorprodukt" src="img_glossar/Vektorprodukt.png" /> Das Vektorprodukt (auch [[Kreuzprodukt]] genannt) ist eine Rechenoperation zwischen zwei Vektoren, deren Ergebnis wieder ein Vektor ist.
<p>Berechnet wird das Vektorprodukt $\mathrm{\vec a \times \vec b}$ zweier Vektoren $\mathrm{ \vec a}$ und $\mathrm{ \vec b}$ wie folgt:
$$\mathrm{ \vec a \times \vec b = \begin{pmatrix} \mathrm{a_1} \\ \mathrm{a_2}\\ \mathrm{a_3} \end{pmatrix} \times \begin{pmatrix} \mathrm{b_1} \\ \mathrm{b_2}\\ \mathrm{b_3}\\ \end{pmatrix} = \begin{pmatrix} \mathrm{a_2b_3 - a_3b_2} \\ \mathrm{a_3b_1 - a_1b_3} \\ \mathrm{a_1b_2 - a_2b_1} \end{pmatrix} }$$
Das Vektorprodukt ist unter anderem hilfreich, wenn ein zu zwei gegebenen Vektoren $\mathrm{ \vec a}$ und $\mathrm{ \vec b}$ [[orthogonaler|Orthogonalität]] Vektor bestimmt werden soll, denn das Vektorprodukt $\mathrm{\vec a \times \vec b}$ ist sowohl orthogonal zu $\mathrm{ \vec a}$ als auch orthogonal zu $\mathrm{ \vec b}$ (vgl. Skizze).
<p>\( \ \rightarrow \) [[Normalenvektor]]
</html>

<<tiddler HideTiddlerSubtitle>>
<html><img width="130" vspace="0" hspace="20" align="right" height="152" src="img_glossar/Vektorsubtraktion.png" alt="Vektorsubtraktion"  /> Im Anschauungsraum entspricht die Subtraktion zweier Vektoren $\mathrm{ \vec a}$ und $\mathrm{ \vec b}$ der folgenden Operation: Man trägt an den Endpunkt des Vektors $\mathrm{ \vec a}$ den Gegenvektor des Vektors $\mathrm{ \vec b}$ an. Der Differenzvektor ist dann der [[Verbindungsvektor]] des Anfangspunktes von $\mathrm{ \vec a}$ mit dem Endpunkt des an den Endpunkt von $\mathrm{ \vec a}$ angetragenen Vektors $\mathrm{ -\vec b}$ (s. Skizze).
<p>Für die Vektorsubtraktion als algebraische Rechenoperation zwischen Vektoren gilt folgende Regel:
Zwei Vektoren $\mathrm{ \vec a = \begin{pmatrix} \mathrm{a_1} \\ \mathrm{a_2}\\ \mathrm{a_3} \end{pmatrix}} \$ und $\ \mathrm{ \vec b = \begin{pmatrix} \mathrm{b_1} \\ \mathrm{b_2} \\ \mathrm{b_3} \end{pmatrix} }$ werden subtrahiert, indem man ihre Einträge zeilenweise subtrahiert. <p>Für den Differenzvektor $\mathrm{\vec a - \vec b}$ gilt somit:
$$\mathrm{ \vec a - \vec b = \begin{pmatrix} \mathrm{a_1 - b_1} \\ \mathrm{a_2 - b_2}\\ \mathrm{a_3 - b_3} \end{pmatrix}}$$
<p>\( \ \rightarrow \) [[Rechnen mit Vektoren]]
</html>

<<tiddler HideTiddlerSubtitle>>
<html>Der Verbindungsvektor $\mathrm{\vec{AB}}$ zweier Punkte $\mathrm{A}$ und $\mathrm{B}$ ist anschaulich gesprochen derjenige Vektor, der vom Punkt $\mathrm{A}$ aus zum Punkt $\mathrm{B}$ zeigt.
Rechnerisch kann man $\mathrm{\vec{AB}}$ ermitteln, indem man den Ortsvektor des Anfangspunktes $\mathrm{A}$ vom Ortsvektor des Endpunktes $\mathrm{B}$ subtrahiert:
$$\mathrm{ \vec{AB} = \vec B - \vec A = \begin{pmatrix} \mathrm{b_1 - a_1} \\ \mathrm{b_2 - a_2}\\ \mathrm{b_3 - a_3} \end{pmatrix}}$$
</html>

<<tiddler HideTiddlerSubtitle>>
<html>Um das Verhalten einer [[Funktion]] an den Rändern des [[Definitionsbereichs|Definitionsmenge]] zu untersuchen, müssen [[Grenzwerte|Grenzwert]] berechnet werden. Dabei ist zu unterscheiden, ob ein Rand eine reelle Zahl ist oder im Unendlichen liegt. Für die verschiedenen Grundfunktionen gilt:

!!![[Betragsfunktion]] $\hspace{0.75em} \mathrm{f:\,x \mapsto |\,x\,|}$
$${\lim_{x\to\pm\infty}|x|=\infty}$$

!!![[Natürliche Exponentialfunktion|Exponentialfunktion]]  $\hspace{0.75em} \mathrm{f:x \mapsto e^x}$
$$\mathrm{\lim_{x\to-\infty}e^x=0}$$
$$\mathrm{\lim_{x\to\infty}e^x=\infty}$$

!!![[Natürliche Logarithmusfunktion|Logarithmusfunktion]]  $\hspace{0.75em} \mathrm{f:x \mapsto\ln x}$
$$\mathrm{\lim_{x\to 0^+}\ln x=-\infty}$$
$$\mathrm{\lim_{x\to\infty}\ln x=\infty}$$

!!![[Potenzfunktion]]  $\hspace{0.75em} \mathrm{f:x \mapsto x^z}$
$$\mathrm{\lim_{x\to -\infty} x^z= \left\{\begin{array}{rl}\mathrm{-\infty,} & \mathrm{falls\ z>0\ und\ ungerade}\\ \mathrm{\infty,} & \mathrm{falls\ z>0\ und\ gerade}\\ \mathrm{0,} & \mathrm{falls\ z&lt;0} \end{array}\right.}$$
$$\mathrm{\lim_{x\to \infty} x^z=\left\{\begin{array}{rl} \mathrm{\infty,} &\mathrm{falls\ z>0}\\ \mathrm{0,} & \mathrm{falls\ z<0} \end{array}\right.}$$
Im Fall $\mathrm{z < 0}$ hat $\mathrm{f(x)}$ bei $\mathrm{x = 0}$ eine Definitionslücke, für die gilt:
$$\mathrm{\lim_{x\to 0^-} x^z=\left\{\begin{array}{rl} \mathrm{-\infty,} & \mathrm{falls\ z\ ungerade}\\ \mathrm{ \infty,} & \mathrm{falls\ z\ gerade} \end{array}\right.}$$
$$\mathrm{\lim_{x\to 0^+} x^z=\infty}$$

!!![[Wurzelfunktion]] $\hspace{0.75em} \mathrm{f:x \mapsto\sqrt x}$
$$\mathrm{\lim_{x\to 0^+}\sqrt x=0}$$
$$\mathrm{\lim_{x\to\infty}\sqrt x=\infty}$$

!!!Trigonometrische Funktionen ([[Sinus-|Sinusfunktion]] und [[Kosinusfunktion]])
<p>Grenzwerte im Unendlichen existieren nicht.

!!!Regeln für zusammengesetzte Funktionen
<p>Für $\mathrm{r > 0}$ gilt:
$$\mathrm{\lim_{x\to \infty} \ \frac{x^r}{e^x}=0}$$
$$\mathrm{\lim_{x\to \infty} \ \frac{\ln x}{x^r}=0}$$
$$\mathrm{\lim_{x\to 0} \ x^r\ln x=0 }$$
</html>

<<tiddler HideTiddlerSubtitle>>
<html>Unter einer Verkettung von [[Funktionen|Funktion]] versteht man das nacheinander Ausführen von Funktionen.
<p>Bei der Funktion $\mathrm{f(x) = g(h(x))}$ erhält man den Funktionswert von $\mathrm{x_0}$, indem man zuerst $\mathrm{h(x_0)}$ berechnet und diesen Wert in $\mathrm{g(x)}$ einsetzt. $\mathrm{g(x)}$ heißt äußere, $\mathrm{h(x)}$ innere Funktion.
<p>Im Allgemeinen gilt: $\mathrm{g(h(x)) &ne; h(g(x))}$
</html>

<<tiddler HideTiddlerSubtitle>><html>!!!Verschiebung in x-Richtung
Der Graph einer [[Funktion]] $\mathrm{f}$ wird um $\mathrm{c}$ entlang der x-Achse verschoben, indem man $\mathrm{−c}$ zum Argument der Funktion addiert:
Der Graph von $\mathrm{g(x) = f(x − c)}$ ist dann im Vergleich zum Graphen von $\mathrm{f(x)}$ um $\mathrm{c}$ nach rechts verschoben.
<p><img vspace="0" hspace="20" border="0"  alt="Verschiebung1" src="img_glossar/Verschiebung1.png" />

!!!Verschiebung in y-Richtung
Der Graph einer Funktion $\mathrm{f}$ wird um $\mathrm{d}$ in y-Richtung verschoben, indem man zum Funktionsterm $\mathrm{d}$ addiert:
Der Graph von $\mathrm{h(x) = f(x) + d}$ ist dann im Vergleich zum Graphen von $\mathrm{f(x)}$ um $\mathrm{d}$ nach oben verschoben.
<p><img vspace="0" hspace="20" border="0"  alt="Verschiebung2" src="img_glossar/Verschiebung2.png" />
</html>

<<tiddler HideTiddlerSubtitle>>
<html>In eine Vierfeldertafel lassen sich verschiedene gemeinsame Größen (z.B. zwei verschiedene [[Ereignisse|Ereignis]] $\mathrm{A,\, B \subseteq \Omega)}$ eintragen, die durch Randsummen ergänzt werden: Je nach Problemfall werden entweder absolute bzw. relative [[Häufigkeiten|Häufigkeit]] oder (wie hier im Beispiel) die [[Wahrscheinlichkeiten|Wahrscheinlichkeit]] aufgeführt.
{{Vierfeldertafel{
| | $\mathrm{B}$ | $\mathrm{\overline{B}}$ | |
| $\hspace{0.5em}$$\mathrm{A}$$\hspace{0.5em}$ | $\hspace{0.5em}$$\mathrm{P(A\cap B)}$$\hspace{0.5em}$ | $\hspace{0.5em}$$\mathrm{P(A\cap\overline{B})}$$\hspace{0.5em}$ | $\hspace{0.5em}$$\mathrm{P(A)}$$\hspace{0.5em}$ |
| $\mathrm{\overline{A}}$ | $\mathrm{P(\overline{A}\cap B)}$ | $\mathrm{P(\overline{A}\cap\overline{B})}$ | $\mathrm{P(\overline A)}$ |
| | $\mathrm{P(B)}$ | $\mathrm{P(\overline{B})}$ | $\mathrm{1}$ |
}}}
Oftmals sind einige Werte der Tabelle gegeben, die restlichen können durch Zeilen- bzw. Spaltensummierung berechnet werden. Bei Wahrscheinlichkeiten und relativen Häufigkeiten steht im Feld rechts unten stets die 1, bei absoluten Häufigkeiten die Anzahl der beobachteten Werte.
</html>

<html><div style="margin-left:25px; line-height: 1.5;">
*[[Wahrscheinlichkeit]]
*[[Wahrscheinlichkeitsverteilung]]
*[[Wendestelle]]
*[[Wertemenge]]
*[[Winkel zwischen Vektoren]]
*[[Wurzelfunktion]]

</div></html>

<<tiddler HideTiddlerSubtitle>>
<html>Nach dem Gesetz der großen Zahlen stellt die [[Wahrscheinlichkeit]] eines [[Ergebnisses|Ereignis]] genau dessen relative [[Häufigkeit]] bei einem unendlich oft wiederholten [[Zufallsexperiment]] dar.
Zudem gelten für beliebige Ereignisse $\mathrm{A}$ und $\mathrm{B}$ aus der [[Ereignismenge]] $\mathcal{P(\Omega)}$ die drei Axiome von Kolmogorov:
{{invisibletable{
|1. Nichtnegativität: | $\mathrm{P(A) \geq 0}$ |
|2. Normiertheit: | $\mathrm{P(\Omega) = 1}$ |
|3. Additivität: | $\mathrm{A \cap B = \{ \ \} \ \ \ \Rightarrow \ \ \ P(A \cup B) = P(A) + P(B) }$ |
}}}
</html>

<<tiddler HideTiddlerSubtitle>>
<html>Eine Funktion, die jeder Ausprägung einer Zufallsgröße eine Wahrscheinlichkeit zuordnet, heißt Wahrscheinlichkeitsverteilung:
$$\mathrm{ P: \ z_{i} \ \mapsto \ P(Z = z_{i})}$$
Die Summe aller Einzelwahrscheinlichkeiten einer Verteilungsfunktion ergibt $\mathrm{1}$, d.h.:
$$\mathrm{\sum\limits_{i =1}^n P(Z = z_{i}) = 1 }$$

!!!Beispiel:
Beim Würfelwurf erhält man folgende Wahrscheinlichkeitsverteilung:
{{Histogramm{
| $\mathrm{z_i}$ | $\mathrm{1}$ | $\mathrm{2}$ | $\mathrm{3}$ | $\mathrm{4}$ | $\mathrm{5}$ | $\mathrm{6}$ |
|$\mathrm{P(Z=z_i)}\hspace{0.5em}$ | $\hspace{1em}\mathrm{\cfrac{1}{6}}\hspace{1em}$ | $\hspace{1em}\mathrm{\cfrac{1}{6}}\hspace{1em}$ | $\hspace{1em}\mathrm{\cfrac{1}{6}}\hspace{1em}$ | $\hspace{1em}\mathrm{\cfrac{1}{6}}\hspace{1em}$ | $\hspace{1em}\mathrm{\cfrac{1}{6}}\hspace{1em}$ | $\hspace{1em}\mathrm{\cfrac{1}{6}}\hspace{1em}$ |
}}}</html>

<<tiddler HideTiddlerSubtitle>>
<html>Eine [[Funktion]] $\mathrm{f}$ besitzt eine Wendestelle in $\mathrm{x_0}$, wenn sich ihr [[Krümmungsverhalten|Krümmung]] an dieser Stelle ändert. Die 2. [[Ableitung]] ist ein Maß für die [[Krümmung]] einer Funktion.

$\mathrm{x_0}$ ist Wendestelle, wenn gilt: $\mathrm{f''(x_0) = 0}$ und $\mathrm{ f ''}$ hat an der Stelle $\mathrm{x_0}$ einen Vorzeichenwechsel.
</html>

<<tiddler HideTiddlerSubtitle>>
<html>Die Wertemenge $\mathrm{W_f}$ einer [[Funktion]] $\mathrm{f}$ ist die Menge aller $\mathrm{y}$, zu denen es ein $\mathrm{x}$ aus der [[Definitionsmenge]] $\mathrm{D_f}$ mit $\mathrm{f(x) = y}$ gibt. Sie ist also die Menge aller Werte, die die Funktion annimmt.
<p>Die Wertemenge ist immer eine Teilmenge der reellen Zahlen oder gleich der reellen Zahlen.
<p>\( \ \rightarrow \) [[Definitionsmenge ]]
</html>

Ein WikiWord ist ein Wort, das aus mehreren einzelnen Wörtern zusammengesetzt ist, in dem jedes Wort mit einem Großbuchstaben beginnt und eine individuelle Seite bezeichnet.

<<tiddler HideTiddlerSubtitle>>
<html><img width="120" vspace="0" hspace="20" align="right" height="199" src="img_glossar/Winkel.png" alt="Winkel zwischen Vektoren" /> Der Winkel $\mathrm{\alpha}$, den zwei Vektoren $\mathrm{\vec a}$ und $\mathrm{\vec b}$ einschließen, kann mithilfe des [[Skalarprodukts|Skalarprodukt]] berechnet werden:
$$\mathrm{ \cos \alpha = \frac {\vec a \circ \vec b }{{\large|}\, \vec a \,{\large|} \cdot{\large|}\,\vec b\,{\large|} }}$$
Die Größe des eingeschlossenen Winkels hängt auch von der Richtung der Vektoren ab; der Winkel kann spitz oder stumpf (oder sogar ein rechter bzw. gestreckter Winkel) sein, d. h., es gilt:
$$\mathrm{ 0^{\circ} \leq \alpha \leq 180\,^{\circ}}$$
Da $\mathrm{\cos 90° = 0}$, gilt für zwei Vektoren $\mathrm{\vec a}$ und $\mathrm{\vec b}$ stets die folgende [[Orthogonalitätsbedingung|Orthogonalität]]:
$$\mathrm{ \vec a \perp \vec b \ \ \ \Leftrightarrow \ \ \ \vec a \circ \vec b = 0 }$$
</html>

<<tiddler HideTiddlerSubtitle>>
<html>Die Grundfunktion ist $\mathrm{f:\,x \mapsto\sqrt{x}}$.
<p>Für die [[Funktion]] $\mathrm{f}$ lassen sich folgende Aussagen treffen:
<p style="margin-top:-5px";>*[[Definitionsmenge]]:    $\mathrm{ D=\mathbb{R}_0^+}$
<p style="margin-top:-5px";>*[[Wertemenge]]: $\mathrm{ W=\mathbb{R}_0^+}$
<p style="margin-top:-5px";>*[[Nullstelle]]: $\mathrm{x = 0}$
<p style="margin-top:-5px";>*Verhalten im Unendlichen: $\mathrm{\underset{x \rightarrow \infty}{lim}\sqrt x=\infty}$
<p style="margin-top:-10px";>*[[Ableitung]]: $\mathrm{ f'(x)=\cfrac{1}{2\sqrt x}}$
<p style="margin-top:-5px";>*[[Stammfunktion]]: $\mathrm{ F(x)=\cfrac23 x^{{\large^3/_2}}+C}$
<p><img vspace="0" hspace="20" border="0"  alt="Wurzelfunktion" src="img_glossar/Wurzelfunktion.png" />
</html>

<html><div style="margin-left:25px; line-height: 1.5;">
*[[Zählprinzip]]
*[[Ziehen mit Zurücklegen]]
*[[Ziehen ohne Zurücklegen]]
*[[Zufallsexperiment]]
*[[Zufallsgröße]]

</div></html>

<<tiddler HideTiddlerSubtitle>>
<html>Das Ziehen von Kugeln aus einer Urne ist ein [[Zufallsexperiment]]. Legt man nach jedem Zug die gezogene Kugel wieder in die Urne zurück, so spricht man vom Modell „Ziehen mit Zurücklegen".
<p>Befinden sich in der Urne $\mathrm{K}$ weiße und $\mathrm{N - K}$ schwarze Kugeln, so enthält die Urne insgesamt $\mathrm{N}$ Kugeln. Die [[Wahrscheinlichkeit]], beim einmaligen Ziehen eine weiße Kugel zu erhalten, beträgt $\mathrm{ p = {\large\frac{K}{N}}}$. Zieht man nun $\mathrm{n}$ Kugeln aus der Urne „mit Zurücklegen", so ist die Anzahl der gezogenen weißen Kugeln eine binomialverteilte [[Zufallsgröße]] $\mathrm{Z}$ und es gilt:
$$\mathrm{ P(Z = k) = {n \choose k} \cdot p^k \cdot (1-p)^{n-k}}$$
<p>\( \ \rightarrow \) [[Ziehen ohne Zurücklegen]]
\( \ \rightarrow \) [[Binomialverteilung ]]
</html>

<<tiddler HideTiddlerSubtitle>>
<html>Das Ziehen von Kugeln aus einer Urne ist ein [[Zufallsexperiment]]. (Vorausgesetzt, es befinden sich mindestens zwei unterscheidbare Kugeln in der Urne.) Legt man nach jedem Zug die gezogene Kugel nicht in die Urne zurück, so spricht man vom Modell „Ziehen ohne Zurücklegen".
<p>Befinden sich in der Urne $\mathrm{K}$ weiße und $\mathrm{N - K}$ schwarze Kugeln, so enthält die Urne insgesamt $\mathrm{N}$ Kugeln. Zieht man nun $\mathrm{n}$ Kugeln aus der Urne „ohne Zurücklegen", so ist die Anzahl der gezogenen weißen Kugeln eine Zufallsgröße $\mathrm{Z}$ mit folgender Verteilungsfunktion:
$$\mathrm{ P(Z = k) = \frac{ {\large{K \choose k}} \cdot {\large{N-K \choose n-k}}}{ {\large{N \choose n}}}}$$
<p>\( \ \rightarrow \) [[Ziehen mit Zurücklegen]]
</html>

<<tiddler HideTiddlerSubtitle>>
<html>In der Stochastik heißt ein Experiment, bei dem der Ausgang nicht vorhersagbar ist, Zufallsexperiment. Ein Zufallsexperiment heißt zusammengesetztes Zufallsexperiment, wenn das Experiment aus mehreren Stufen besteht. Sie können mithilfe von [[Baumdiagrammen|Baumdiagramm]] dargestellt werden.
<p>Um ein Zufallsexperiment zu beschreiben, helfen folgende Begriffe:
{{Zufallsexperiment{
|$\hspace{1em}$[[Ergebnis]] $\mathrm{\omega}$ ||Möglicher Ausgang des Zufallsexperiments |
|$\hspace{1em}$[[Ergebnismenge]] $\mathrm{\Omega}$ ||Menge aller Ergebnisse eines Zufallsexperiments |
|$\hspace{1em}$[[Mächtigkeit]] der Ergebnismenge $\mathrm{{\large|}\,\Omega\,{\large|}}$ |$\hspace{1em}$|Anzahl der möglichen Ergebnisse in $\mathrm{\Omega}$ |
|$\hspace{1em}$[[Ereignis]] $\mathrm{A}$ ||Teilmenge der Ergebnismenge |
|$\hspace{1em}$[[Ergebnismenge]] $\mathcal{P(A)}$ ||Menge aller Ereignisse |
|$\hspace{1em}$[[Mächtigkeit]] der Ereignismenge ||$\mathrm{{\large|}\,\mathcal{P}(\Omega)\,{\large|}=2^{\ {\large|}\,\Omega\,{\large|}} }$ |
|$\hspace{1em}$[[Elementarereignis]] ||$\mathrm{A=\{\omega\}}$ |
|$\hspace{1em}$[[Unmögliches Ereignis]] ||$\mathrm{A=\{ \ \}}$ |
|$\hspace{1em}$[[Sicheres Ereignis]] ||$\mathrm{A=\Omega}$ |
|$\hspace{1em}$[[Gegenereignis]] ||$\mathrm{\overline{A}=\Omega\backslash A}$ |
|$\hspace{1em}$[[Unvereinbare Ereignisse]] ||$\mathrm{A\cap B=\{ \ \}}$ |
}}}
!!!Beispiel:
Der Wurf einer Münze ist ein Zufallsexperiment, da man den Ausgang eines Wurfes nicht vorhersagen kann. Man weiß nur, dass entweder Kopf oder Zahl geworfen wird. Der zweifache Wurf einer Münze ist ein zusammengesetztes Zufallsexperiment.
</html>

<<tiddler HideTiddlerSubtitle>>
<html>Eine Zufallsgröße, auch Zufallsvariable genannt, ordnet jedem [[Ergebnis]] eines [[Zufallsexperiments|Zufallsexperiment]] einen reellen Wert zu. Daher bezeichnet die Zufallsgröße $\mathrm{Z}$ eine Abbildung:
$$\mathrm{ Z: \ \ \Omega \ \to \ \mathbb R}$$
</html>

<<tiddler HideTiddlerSubtitle>>
<html>Mit dem Zählprinzip erhält man in der Stochastik die Anzahl der Möglichkeiten, die bei einem zusammengesetzten [[Zufallsexperiment]] eintreten können. Diese Anzahl berechnet man, indem man im [[Baumdiagramm]] die Anzahl der Möglichkeiten pro Stufe multipliziert. Betrachtet man ein bestimmtes [[Ereignis]] $\mathrm{A \subseteq \Omega}$, so zählt man die zum Ereignis führenden Pfade zusammen.

!!!Beispiel:
<div style="line-height:2;">In einem zweistufigen Zufallsexperiment wird zunächst eine Münze und anschließend ein Würfel geworfen.
Die Anzahl der möglichen [[Ergebnisse|Ergebnis]] beträgt nach dem Zählprinzip:
$\mathrm{{\large|}\,\Omega\,{\large|} =}$ Anzahl der Möglichkeiten beim Münzwurf $\mathrm{\cdot}$ Anzahl der Möglichkeiten beim Würfelwurf $= \mathrm{2\cdot 6 = 12}$</div>
<img width="482" vspace="20" hspace="20" height="175" src="img_glossar/Zaehlprinzip.png" alt="Zaehlprinzip" title="Zaehlprinzip" />
<p>\( \ \rightarrow \) [[Fakultät]]
</html>

# data[].attributes.attachment_link.description
Ableitung]] *[[Ableitungsregeln]] *[[Abstand]] *[[Abstand zweier Ebenen]] *[[Abstand zweier Geraden]] *[[Abstand zwischen Gerade und Ebene]] *[[Abstand zwischen Punkt und Ebene]] *[[Abstand zwischen Punkt und Gerade]] *[[Achsenabschnittsform]] *[[Additionsregel]] *[[Arithmetisches Mittel]] *[[Asymptote]] > Die Ableitung \(\mathrm{ f'(x)}\) einer [[Funktion]] \(\mathrm{ f(x)}\) gibt das [[Steigungsverhalten]] der Funktion \(\mathrm{f(x)}\) an.

# data[].attributes.attachment_link.readable_text
wird aktuell überarbeitet

Inhalt des Kurses

Dieser Kurs dient der Abiturvorbereitung im Themengebiet Stochastik.

Er gibt einen zusammenfassenden Überblick über die wichtigsten Inhalte der gymnasialen Oberstufe:

Dabei sind Begriffe und Inhalte aus früheren Klassenstufen entsprechend verlinkt, sodass sie bei Bedarf wiederholt werden können.

Vorkenntnisse

Du solltest die oben genannten Inhalte bereits kennengelernt haben, sodass sie dir zumindest grob vertraut sind.

Außerdem ist es hilfreich, wenn du die Stochastik der Unter- und Mittelstufe einigermaßen beherrschst.

# data[].attributes.attachment_link.description
wird aktuell überarbeitet Dieser Kurs dient der Abiturvorbereitung im Themengebiet Stochastik. Er gibt einen zusammenfassenden Überblick über die wichtigsten Inhalte der gymnasialen Oberstufe: Dabei sind Begriffe und Inhalte aus früheren Klassenstufen entsprechend verlinkt, sodass sie bei Bedarf wiederholt werden können. Du solltest die oben genannten Inhalte bereits kennengelernt haben, sodass sie dir zumindest grob vertraut sind.

# data[].attributes.body
Übungen bei Serlo

# data[].attributes.body
Übungen bei Serlo

# data[].attributes.body
Übungen zum Erwartungswert bei Serlo

Übungen zur Standardabweichung bei Serlo

# data[].attributes.body
Übungen bei Serlo

# data[].attributes.body
Übungen bei Serlo

Weitere Übungen bei Serlo

# data[].attributes.body
Übungen bei Serlo

# data[].attributes.body
Übungen bei Serlo

# data[].attributes.attachment_link.description
Bei der Einführung eines neuen Marktartikels nimmt der Anteil der Personen, die diesen Artikel besitzen, solange zu, bis eine Sättigung des Marktes erreicht ist. Die folgende Skizze soll diesen Verlauf veranschaulichen. Darin ist t die Zeit, N(t) die Anzahl der verkauften Geräte, S der Sättigungswert, d.h.

# data[].attributes.body
Übungen bei Serlo

# data[].attributes.headline
Addition, Subtraktion, skalare Multiplikation von Vektoren

# data[].attributes.subject
Addition, Subtraktion, skalare Multiplikation von Vektoren

# data[].attributes.body
Übungen bei Serlo

# data[].attributes.body
Übungen bei Serlo

# data[].attributes.body
Gerne rückmelden, wenn Gebärden falsch oder veraltet sind.

# data[].attributes.attachment_link.title
Analysis Fachbegriffe und Fachgebärden Gesamt VS bis S4

# data[].attributes.body
Gerne rückmelden, wenn Gebärden falsch oder veraltet sind.

# data[].attributes.attachment_link.title
Stochastik Fachbegriffe und Fachgebärden Gesamt VS bis S4

# data[].attributes.body
Gerne rückmelden, wenn Gebärden falsch oder veraltet sind.

# data[].attributes.attachment_link.title
Vektorrechnung I Fachbegriffe und Fachgebärden

# data[].attributes.body
Gerne rückmelden, wenn Gebärden falsch oder veraltet sind.

# data[].attributes.attachment_link.title
Vektorrechnung II Fachbegriffe und Fachgebärden

# data[].attributes.body
Übungen bei Serlo

# data[].attributes.body
Übungen bei Serlo

# data[].attributes.body
Abiweb

# data[].attributes.body
Abiweb

# data[].attributes.body
Übungen bei Serlo

# data[].attributes.body
Übungen bei Serlo

# data[].attributes.body
Übungen bei Serlo

# data[].attributes.body
Abiweb