Sven/maing01_06
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Band1 und Band2 Änderungen, speziell Band2 Grafiken

Browse Source
This commit is contained in:
Sven Riwoldt
2026-03-22 09:12:25 +01:00
parent 240f75dddc
commit 0b943f4e84
8 changed files with 2359 additions and 193 deletions
Download Patch File Download Diff File Expand all files Collapse all files

797
Band2/Band2.typ Normal file
View File

@@ -0,0 +1,797 @@
#import "@preview/cetz:0.4.2": * //Grafiken
#import "@preview/fletcher:0.5.8" as fletcher: diagram, node, edge
#import "@preview/marge:0.1.0": sidenote
#import "@preview/itemize:0.2.0" as el
#import "@preview/eqalc:0.1.3": *
#import "deckblatt.typ": deckblatt
//#import "abhaengigkeit.typ": abhaengigkeit
#let einruecken(abstand, inhalt) = pad(left: abstand, inhalt)
#let def-counter = counter("definition")
// Zähler bei jedem neuen Kapitel (Ebene 1) zurücksetzen
#let def-counter = counter("definition")
// Zähler bei jedem neuen Kapitel zurücksetzen
#show heading.where(level: 1): it => {
it
def-counter.update(0)
}
#let definition(title: none, body, label: none) = context {
def-counter.step()
let h1-num = counter(heading).at(here()).first()
let d-num = def-counter.at(here()).first()
let full-num = [#h1-num.#d-num]
// Die Figure wird erstellt und das Label direkt angehängt
[
#figure(
block(width: 100%, align(left)[
*Definition #full-num*: #if title != none [(#title)] #body
]),
kind: "definition",
supplement: [D.],
numbering: _ => full-num,
) #label
]
}
// Zähler bei jedem neuen Kapitel (Ebene 1) zurücksetzen
#show heading.where(level: 1): it => {
it
def-counter.update(1)
}
#let sn-base = sidenote
#let snr(it) = sn-base(side: right, padding: 1em)[
#set text(size: 1.3em, weight: "bold")
#it
]
#let snl(it) = sn-base(side: left, padding: 1em)[
#set text(size: 1.3em, weight: "bold")
#it
]
//#import "definitionen.typ": *
#set text(
font: "Lato", //Serifenlose Schrift
size: 8.5pt,
lang: "de", //Deutsche Spracheinstellungen
)
#set page(
width:162mm,
height: 230mm,
margin: 20mm,
)
#set par(
justify: true, //Blocksatz
leading: 0.55em,
)
#let tt = "PFORR \u{2219} SCHIROTZEK"
#let meinContent = [*Band 7* #sym.dot.c _Grundlagen_]
// Einfach die Funktion aufrufen
#deckblatt(bandnr: "2", autor: tt, titel: "Differential- und Integralrechnung\nfür Funktionen\nmit einer Variablen")
#pagebreak()
#set page(
width:162mm,
height: 230mm,
margin: 20mm,
)
#set par(
justify: true, //Blocksatz
leading: 0.55em,
)
#set page(
//background: grid(columns: (1mm,) * 162, rows: (1mm,) * 230, stroke: 0.1mm),
margin: (
top: 2mm,
bottom: 2mm,
x: 10mm,
),
width:162mm,
height: 230mm,
)
#heading(outlined: false)[Abhängigkeitsgraph]
/* #let mynode(pos, text1, text2, name) = {
node(pos, [#text( size:1.7em, text2) \ #text1], name:name, stroke: 1pt, corner-radius: 0mm,
height: 3.5em, width:10em)
/* Dashed separator from east to west */
//edge(label(str(name)+".west"), label(str(name)+".east"),"-", stroke: 0.2mm, dash:(1mm, 0.8mm))
} */
#let mynode(pos, zahl, inhalt, name) = {
node(
pos,
name: name,
shape: rect, // 1. Zwingt Fletcher zum Rechteck
corner-radius: 0pt, // 2. Verhindert abgerundete Ecken
fill: white, // Optional: Hintergrund füllen
stroke: 1.25pt,
// 3. WICHTIG: Festlegen einer Mindestgröße, damit alle gleich starten
// Anstatt extrude nutzen wir feste Maße, die sich aber am Gitter ausrichten
width: 12em,
height: 5.8em,
{
// Dein Layout-Block
set align(top + right)
text(2.5em, fill: gray.darken(90%))[#zahl]
place(bottom + left, inhalt)
}
)}
#let myedge(start, end, type, ) = {
let sep = 0.15em
edge(start, end, type)
edge(start, end)
}
#diagram(
spacing: (11mm, 7mm),
//debug: 3,
edge-stroke: 1.25pt,
mark-scale: 55%,
mynode((0,0),"",[Vorbereitungsband], <A0>),
mynode((1,0),"1", [Grundlagen], <A1>),
mynode((2,0), "13",[Lineare Algebra], <A13>),
mynode((0,1),"3",[Unendliche Reihen], <A3>),
mynode((1,1), "2",[Differential- und Integralrechnung], <A2>),
mynode((2,1), "14",[Lineare Optimierung], <A14>),
mynode((0,2), [7$#sub(text(0.5em)[1])$],[Gewöhnliche Differentialgleichungen], <A7_1>),
mynode((1,2), "4",[Differentialrechnung mit mehreren Variablen], <A4>),
mynode((2,2), "15",[Nichtlineare Optimierung], <A15>),
mynode((0,3), [7$#sub(text(0.5em)[2])$],[Gewöhnliche Differentialgleichungen], <A7_2>),
mynode((1,3.), "5",[Integralrechnung mit mehreren Variablen], <A5>),
mynode((2,3), "16",[Optimale Prozesse und Systeme], <A16>),
mynode((0,4), "8",[Partielle Differentialgleichungen], <A8>),
mynode((1,4), "6",[Differentialgeometrie], <A6>),
mynode((2,4), "17",[Wahrscheinlichkeitsrechnung, math.Statistik], <A17>),
mynode((0,5), "9",[Komplexe Funktionen], <A9>),
mynode((1,5), "10",[Operatorenrechnung], <A10>),
mynode((2,5), [21$#sub(text(0.5em)[1])$],[Spieltheorie], <A21_1>),
mynode((0,6), "12",[Spezielle Funktionen], <A12>),
mynode((1,6), "11",[Tensoralgebra und -analysis], <A11>),
mynode((2,6), [21$#sub(text(0.5em)[2])$],[Graphentheorie], <A21_2>),
mynode((0,7), [18],[Numerische Methoden], <A18>),
mynode((1,7), [20],[Simulation], <A20>),
mynode((2,7), [19$#sub(text(0.5em)[1])$],[Stochastische Prozesse und Modelle], <A19_1>),
mynode((0,8), [22],[Funktionalanalysis], <A22>),
mynode((1,8), [23],[Symmetriegruppen], <A23>),
mynode((2,8), [19$#sub(text(0.5em)[2])$],[Statistische Versuchsplanung], <A19_2>),
myedge(<A0.east>,<A1.west>,"-|>"),
myedge(<A1.south>,<A2.north>,"-|>"),
myedge(<A2.west>,<A3.east>,"-|>"),
myedge(<A13.south>,<A14.north>,"-|>"),
myedge(<A2.south>,<A4.north>,"-|>"),
myedge(<A4.south>,<A5.north>,"-|>"),
myedge(<A5.south>,<A6.north>,"-|>"),
myedge(<A14.south>,<A15.north>,"-|>"),
myedge(<A7_1.south>,<A7_2.north>,"-|>"),
myedge(<A7_2.south>,<A8.north>,"-|>"),
myedge(<A8.south>,<A9.north>,"-|>"),
myedge(<A9.south>,<A12.north>,"-|>"),
myedge(<A12.south>,<A18.north>,"-|>"),
myedge(<A10.south>,<A11.north>,"-|>"),
myedge(<A15.south>,<A16.north>,"-|>"),
myedge(<A17.south>,<A21_1.north>,"-|>"),
myedge(<A19_1.south>,<A19_2.north>,"-|>"),
// NEUES Edge: 1,3 (n3_1) → 3,2 (n2_3)
// Verlauf: rechts von n3_1 nach rechts, runter auf Höhe von n2_3, dann links zur Node
//9 → 22
edge(
vertices: (
<A9.east>,
(0, 5.2), // deutlich nach rechts → sichtbarer Knick
(0.5, 5.2), // dann nach links
(0.5, 8), // runter
<A22.east>,
),
corner: right,
corner-radius: 0pt, // abgerundete Ecken!
stroke: orange + 1.25pt,
marks: "-|>",
shift: (1pt, 1pt),
),
//10 → 22
edge(
vertices: (
<A10.west>,
(1, 5.2), // deutlich nach rechts → sichtbarer Knick
(0.5, 5.2), // dann nach links
(0.5, 8), // runter
<A22.east>,
),
corner: left,
corner-radius: 0pt, // abgerundete Ecken!
stroke: orange + 1.25pt,
marks: "-|>",
shift: (1pt, 1pt),
),
//3 → 7.2
edge(
vertices: (
<A3.west>,
(-0.85, 1), // deutlich nach rechts → sichtbarer Knick
(-0.85, 1), // dann nach links
(-0.85, 3), // runter
<A7_2.west>,
),
corner: left,
corner-radius: 0pt, // abgerundete Ecken!
stroke: red + 1.25pt,
marks: "-|>",
shift: (1pt, 1pt),
),
//13 → 4
edge(
vertices: (
<A13.west>,
(2, 0.18), // deutlich nach rechts → sichtbarer Knick
(1.5, 0.2), // dann nach links
(1.5, 2), // runter
<A4.east>,
),
corner: left,
corner-radius: 0pt, // abgerundete Ecken!
stroke: green + 1.25pt,
marks: "-|>",
shift: (2pt, 2pt),
),
//1 → 13
edge(
(rel: (0pt, 5mm), to: <A1.east>),
(rel: (0.1, 0.)),
(rel: (0pt, 5mm), to: <A13.west>),
"-|>",
corner-radius: 0pt ,
stroke: green.darken(30%) + 1.25pt,
),
//5 → 8
edge(
(rel: (0pt, 0mm), to: <A5.west>),
(rel: (-0.15, 0.)),
(rel: (0.08,0), to: <A8.east>),
(rel: (0.,0), to: <A8.east>),
"-|>",
corner-radius: 0pt ,
stroke: 1.25pt + olive,
),
//7_1 → 6
edge(
vertices: (
(rel: (0pt, -2pt), to: <A7_1.east>),
(0.25, 2.2),
(0.52, 2.2),
(0.52,4),
(rel: (0pt, 0pt), to: <A6.west>)
),
corner-radius: 0pt,
stroke: gray + 1.25pt,
marks: "-|>",
),
//4 → 7_1
edge(
(rel: (0pt, 5mm), to: <A4.west>),
(rel: (-0.1, 0.)),
(rel: (0pt, 5mm), to: <A7_1.east>),
"-|>",
corner-radius: 0pt ,
stroke: 1.25pt ,
),
//9 → 10
edge(
(rel: (0pt, 5mm), to: <A9.east>),
(rel: (0.1, 0.)),
(rel: (0pt, 5mm), to: <A10.west>),
"-|>",
corner-radius: 0pt ,
stroke: 1.25pt ,
),
//5 → 17
edge(
<A5.east>,
(rel: (0.07, 0.)),
(rel: (0, 0.5)),
(rel: (0pt, 10pt), to: <A17.north>),
<A17.north>,
"-|>",
corner-radius: 0pt ,
stroke: blue.lighten(20%) +1.25pt ,
),
//4 → 15
edge(
(rel: (0pt, -5mm), to: <A4.east>),
(rel: (0.1, 0.)),
(rel: (0pt, -5mm), to: <A15.west>),
"-|>",
corner-radius: 0pt ,
stroke: 1.25pt ,
),
//8 → 16
edge(
(rel: (0.2,0), to: <A8.south>),
(rel: (0., 0.1)),
(rel: (1.3, 0.)),
(rel: (-0.115, 0), to: <A16.west>),
<A16.west>,
"-|>",
corner-radius: 0pt ,
stroke: 1.25pt + yellow.darken(20%),
),
//6 → 11
edge(
(rel: (0pt, -5mm), to: <A6.east>),
(rel: (0.065, 0.)),
(rel: (0.065,0), to: <A11.east>),
(rel: (0.,0), to: <A11.east>),
"-|>",
corner-radius: 0pt ,
stroke: 1.25pt + purple.lighten(20%),
),
//13 → 23
edge(
(<A13.east>),
(rel:(0.75,0)),
(rel:(0, 9.8)),// <----
(rel:(-3.38, 0)),
//(rel: (0.6, 0.), to: <A21_2.east>),
<A23.south>,
"-|>",
corner-radius: 0pt ,
stroke: 1.25pt + orange.darken(10%),
),
//15 → 21_1 21_2
edge(
(<A15.east>),
// Startpunkt
(rel: (0.5, 0)),
(rel: (0.5, 0.), to: <A21_1.east>),
<A21_1.east>,
"-|>",
corner-radius: 0pt ,
stroke: 1.25pt + blue,
),
edge(
(<A15.east>),
// Startpunkt
(rel: (0.5, 0)),
(rel: (0.5, 0.), to: <A21_2.east>),
<A21_2.east>,
"-|>",
corner-radius: 0pt ,
stroke: 1.25pt + blue,
),
//16 → 19_1 19_2
edge(
(<A16.east>),
(rel: (0.3, 0)),
(rel: (0.3, 0.), to: <A19_1.east>),
<A19_1.east>,
"-|>",
corner-radius: 0pt ,
stroke: 1.25pt + purple,
),
edge(
(<A16.east>),
(rel: (0.3, 0)),
(rel: (0.3, 0.), to: <A19_2.east>),
<A19_2.east>,
"-|>",
corner-radius: 0pt ,
stroke: 1.25pt + purple,
),
//17 → 21_2
edge(
(rel: (-0.2,0), to: <A17.south>),
(rel: (0, 0.2)),
(rel: (-.325, 0.)),
(rel: (-0.14, 0), to: <A21_2.west>),
<A21_2.west>,
"-|>",
corner-radius: 0pt ,
stroke: 1.25pt + red,
),
//17 → 19_1, 19_2
edge(
(<A17.west>),
(rel: (-0.075, 0)),
(rel: (-0.075,-0.20), to: <A19_1.west>),
(rel: (0.,-0.2), to: <A19_1.west>),
"-|>",
corner-radius: 0pt ,
stroke: 1.25pt + green,
),
edge(
(<A17.west>),
(rel: (-0.075, 0)),
(rel: (-0.075, 0.), to: <A19_2.west>),
<A19_2.west>,
"-|>",
corner-radius: 0pt ,
stroke: 1.25pt + green,
),
//19_2 → 20
edge(
(<A19_2.north>),
(rel: (-0.2, 0)),
(rel: (0, -0.1)),
(rel: (-0, 0.18), to: <A20.south>),
<A20.south>,
"-|>",
corner-radius: 0pt ,
stroke: 1.25pt + blue,
),
)
#show heading: it => {
set block(below: if it.level == 1 { 2em } else { 1em })
it
}
#counter(page).update(1)
#pagebreak()
#set text(font: "Atkinson Hyperlegible Next")
#set text(
font: "Atkinson Hyperlegible Next", //Serifenlose Schrift
size: 9pt,
lang: "de", //Deutsche Spracheinstellungen
)
#set par(
justify: true,
leading: 0.55em,
)
#set page(
//background: grid(columns: (1mm,) * 162, rows: (1mm,) * 230, stroke: 0.1mm),
margin: (
top: 18mm,
bottom: 20mm,
x: 15mm,
),
width:162mm,
height: 230mm,
)
//#set heading(numbering: "1.1.")
#set outline(indent: auto)
#set page(
header: context {
// 1. Kapitelstart-Check (wie zuvor)
let h1_on_page = query(heading.where(level: 1))
.any(it => it.location().page() == here().page())
if h1_on_page { return none }
let page_num = here().page()
// 2. Aktuelle Überschriften finden
let h1_current = query(heading.where(level: 1))
.filter(it => it.location().page() <= page_num).at(-1, default: none)
let h2_current = query(heading.where(level: 2))
.filter(it => it.location().page() <= page_num).at(-1, default: none)
// Hilfsfunktion: Nummer + Text zusammenfügen
let format-head(h) = {
if h != none {
// Falls die Überschrift eine Nummerierung hat, diese anzeigen
if h.numbering != none {
numbering(h.numbering, ..counter(heading).at(h.location()))
[ ] // Kleiner Abstand
}
h.body
}
}
// 3. Layout (Zahlen außen, Text innen oder wie gewünscht)
set text(size: 9pt, style: "italic") // Header dezent formatieren
if calc.even(page_num) {
// Gerade Seite: [Seite] [Kapitelnummer Text]
grid(
columns: (20pt, 1fr),
align(left)[#page_num],
align(right)[#format-head(h1_current)]
)
} else {
// Ungerade Seite: [Unterkapitelnummer Text] [Seite]
grid(
columns: (1fr, 20pt),
align(left)[#format-head(h2_current)],
align(right)[#page_num]
)
}
}
)
#show selector(<nonumber>): set heading(numbering: none)
= Vorwort <nonumber>
Dem vorliegenden Band 2 dieser Lehrbuchreihe kommt ebenso wie dem Band 1 insofern eine besondere Bedeutung innerhalb des gesamten Lehrwerkes zu, als nahezu alle anderen Bände darauf aufbauen.
Ein Teil der in diesem Buch behandelten Gegenstände ist auch im Lehrplan unserer Oberschulen enthalten. Ein Weglassen des dort bereits Dargebotenen hätte aber zu einer unzusammenhängenden Darstellung des Gebietes geführt; außerdem wäre nicht gewährleistet, daß alle Leser mit den gleichen Voraussetzungen die weiteren Bände studieren können.
Eine korrekte Anwendung mathematischer Methoden setzt die genaue Kenntnis der zugrunde liegenden Begriffe voraus. Es muß dem Leser daher dringend nahegelegt werden, sich um ein volles Verständnis der eingeführten Begriffe zu bemühen. Anhand von vielen Beispielen wird gezeigt, wie mathematische Begriffe in den Anwendungen zu interpretieren sind. Ein gründliches Studium des Textes und das selbständige Lösen der über 100 Übungsaufgaben sollte den Leser in die Lage versetzen, die spezifische Anwendbarkeit der behandelten Begriffe und Methoden in seinem Fachgebiet selbst zu erkennen.
Im Interesse einer straffen Darstellung mußte auf eine Reihe von Beweisen verzichtet werden. Alle Aussagen werden aber erläutert und - soweit möglich - geometrisch interpretiert.
Für wertvolle Hinweise danken wir vor allem dem Herausgeber, Herrn Prof. Dr. O. Greuel (Mittweida), den Gutachtern, Herrn Prof. Dr. W. Dück (Berlin) und Herrn Prof. Dr. H. Goering (Magdeburg), sowie Herrn Prof. Dr. G. Opitz (Dresden). Besonderer Dank gebührt Frau I. Kamenz für das sorgfältige Schreiben des Manuskripts. Dem Verlag sei für die gute Zusammenarbeit herzlich gedankt.
Dresden, Januar 1973 #h(1fr) E. A. Pforr
#h(1fr) W. Schirotzek
= Vorwort zur 6. Auflage <nonumber>
In dieser Auflage wurden gegenüber der vorangegangenen an zwei Stellen inhaltliche Veränderungen größeren Umfangs vorgenommen. Im Hinblick auf den Einsatz von elektronischen Rechnern, insbesondere auch von Taschenrechnern, war die Darstellung der Näherungsverfahren (Abschnitt 7.7.) zu überarbeiten. Der algorithmische Aspekt wurde stärker herausgearbeitet, auf die Formulierung von Algorithmen in einer Programmiersprache jedoch verzichtet. Außerdem wurde der Abschnitt über elliptische Integrale (9.3.5.) erweitert.
Für die wertvolle Unterstützung bei der Überarbeitung von Abschnitt 7.7. sei Herrn Dr. sc. nat. S. Dietze (Dresden) herzlich gedankt.
Dresden, Juli 1985 #h(1fr) E. A. Pforr
#h(1fr)W. Schirotzek
#pagebreak()
#outline()
#pagebreak()
#set heading(numbering: "1.1.1.")
TEIL 1: DIFFERENTIALRECHNUNG
= Problemstellung und Historisches
Zur mathematischen Beschreibung von Naturvorgängen, aber auch von technischen und ökonomischen Prozessen ist die Differentialrechnung ein unentbehrliches Hilfsmittel. Es ist daher nicht verwunderlich, daß gerade von Naturforschern entscheidende Anstöße zu ihrer Entwicklung ausgingen. Wichtige Vorarbeiten wurden im 16. und 17. Jahrhundert geleistet. Die eigentlichen Urheber dieser Disziplin sind aber Isaac Newton (1643-1727) und Gottfried Wilhelm Leibniz (1646-1716), die die Differential- (und Integral-) Rechnung etwa gleichzeitig und voneinander unabhängig zu einem Kalkül entwickelten. Newton schuf seine "Fluxionsrechnung“ bei der Ableitung des Gravitationsgesetzes aus den Keplerschen Gesetzen der Planetenbewegung. Leibniz, der auch das Symbol ${d y}/{d x}$ einführte, ging von dem Problem aus, an eine Kurve in einem vorgegebenen Kurvenpunkt die Tangente zu legen ("Tangentenproblem“). Die Arbeiten dieser genialen Forscher lösten eine außerordentlich rasche Entwicklung der Mathematik aus, die ihrerseits in hohem Maße befruchtend auf andere Wissenschaften wirkte. Entscheidenden Anteil an dieser Entwicklung hatten die Brüder Jakob und Johann Bernoulli (1654-1705 bzw. 1667-1748), auf deren Vorlesungen auch das erste, 1696 erschienene Lehrbuch der Differential- und Integralrechnung des Marquis de l'Hospital (1661-1704) basiert.
Wie wir noch sehen werden, beruht die Differentialrechnung, ebenso wie die Integralrechnung, auf dem Begriff des _Grenzwertes_. Zeitlich ging jedoch die kalkülmäßige Entwicklung der Differential- und Integralrechnung der strengen Begriffsdefinition voran. Daraus entstanden immer häufiger Schwierigkeiten und Unstimmigkeiten, die sich zunächst nicht überwinden ließen. Schließlich führte Jean le Rond d'Alembert (1717-1783) den Grenzwertbegriff in die Mathematik ein. Doch erst Bernard Bolzano (1781-1848) und Augustin Louis Cauchy (1789-1857) wendeten diesen Begriff konsequent an und stellten damit die Infinitesimalrechnung (zu der man neben der Differential- und Integralrechnung auch die Theorie der unendlichen Reihen zählt) auf ein solides Fundament.
Vor einem Aufbau der Differentialrechnung ist also der Grenzwertbegriff für Funktionen zu behandeln. Zwangsläufig wird man damit zum Begriff der _Stetigkeit_ geführt. Die eigentliche Differentialrechnung beginnt mit der Definition der _Ableitung_ einer Funktion.
Alle drei Begriffe werden zur exakten Beschreibung bestimmter Sachverhalte in den unterschiedlichsten Gebieten herangezogen. So kann man mit dem Grenzwertbegriff z. B. das Verhalten einer zeitabhängigen Größe, "nach sehr langer Zeit“ charakterisieren, mit dem Begriff der Stetigkeit bzw. Unstetigkeit den "kontinuierlichen“ bzw. "sprunghaften“ Ablauf eines Vorgangs erfassen und mit der Ableitung die "Änderungsgeschwindigkeit" eines Prożesses beschreiben.
Die mathematischen Möglichkeiten reichen jedoch über die unmittelbare Anwendbarkeit dieser Begriffe weit hinaus. So werden wir unter Verwendung der Differentialrechnung u.a. Näherungsformeln für (nichtrationale) Funktionen herleiten, Methoden zur Ermittlung von Extremwerten angeben und Verfahren zur numerischen Lösung von Gleichungen behandeln. Dem "Praktiker“ werden damit Hilfsmittel zur Verfügung gestellt, auf die er fortlaufend zurückgreifen muß.
#pagebreak()
= Grenzwerte
//== Grenzwert einer Funktion für $\boldsymbol{x} \rightarrow \boldsymbol{x}_0$
// 2.1.1. Definition des Grenzwertes einer Funktion für $\boldsymbol{x} \rightarrow \boldsymbol{x}_0$
// Im folgenden bedeutet „Funktion“ stets „reellwertige Funktion einer reellen Variablen".
// Als Vorbereitung auf den Grenzwertbegriff für Funktionen behandeln wir das
// Beispiel 2.1: An die Parabel $y=x^2$ werde die Sekante durch den festen Kurvenpunkt $P_0\left(\frac{1}{2}, \frac{1}{4}\right)$ und den variablen Kurvenpunkt $P\left(x, x^2\right)$ gelegt (s. Bild 2.1). Der Anstieg der Sekante ist eine Funktion $f$ von $x$ :
// $$
// f(x)=\frac{x^2-\frac{1}{4}}{x-\frac{1}{2}} \quad\left(x \neq \frac{1}{2}\right) .
// $$
$x arrow.r x_0$
#import "@preview/cetz-plot:0.1.3": plot
#let intersection(plotA, plotB, style: (stroke: red + 2pt)) = {
let dataA = plotA.first().data
let dataB = plotB.first().data
let points = dataA.filter(x => x in dataB)
for ((i, point)) in points.enumerate() {
plot.add-anchor("i_" + str(i),point )
}
plotA
plotB
}
#canvas(
length: 1cm,
{
import draw: *
plot.plot(
name: "my_plot",
size: (5, 5),
axis-style: "school-book",
x-label: [$x$],
y-label: [$y$],
{
intersection(
plot.add(
style: (stroke: black + 1.5pt),
domain: (-1, 1),
x => calc.pow(x, 4) - 2 * calc.pow(x, 2) + 1,
),
plot.add(
style: (stroke: black + 1.5pt),
domain: (-1, 1),
x => -(calc.pow(x, 4) - 2 * calc.pow(x, 2) + 1),
)
)
}
)
// reference the point with {plot name}.i_{number}
line("my_plot.i_1", ((), "|-", (0,3.5)), mark: (start: ">"), name: "line")
content("line.end", [Here], anchor: "south", padding: .1)
},
)
#let intersection(plotA, plotB, style: (stroke: red + 2pt)) = {
import draw: *
let dataA = plotA.first().data
let dataB = plotB.first().data
plot.annotate({
hide({
intersections("i", line(..plotA.first().data), line(..plotB.first().data))
})
for-each-anchor("i", (name) => {
circle("i." + name, radius: 0.05, fill: red)
})
})
plotA
plotB
}
#canvas(
length: 1cm,
{
import draw: *
plot.plot(
name: "plot",
size: (10, 10),
axis-style: "school-book",
x-label: [$x$],
y-label: [$y$],
{
intersection(
plot.add(
style: (stroke: black + 1.5pt),
domain: (-1, 1),
x => calc.pow(x, 4) - 2 * calc.pow(x, 2) + 1,
),
plot.add(
style: (stroke: black + 1.5pt),
domain: (-1, 1),
x => -(calc.pow(x, 4) - 2 * calc.pow(x, 2) + 0.5),
),
)
},
)
},
)
#import "@preview/cetz:0.4.0"
#import "@preview/cetz-plot:0.1.2"
#let my-plot = cetz-plot.plot.plot.with(axis-style: "school-book")
#cetz.canvas({
import cetz.draw: *
import cetz-plot: *
set-style(
axes: (
stroke: (dash: "dotted", paint: gray),
x: (mark: (start: ">", end: ">"), padding: 1),
y: (mark: none),
tick: (stroke: gray + .5pt),
),
)
my-plot(
size: (5, 4),
y-tick-step: none,
{
plot.add(calc.sin, domain: (0, calc.pi * 2))
},
)
})
#let plot-cfg = (size: (5, 4), axis-style: "school-book")
#cetz.canvas({
import cetz.draw: *
import cetz-plot: *
plot.plot(..plot-cfg, {
plot.add(calc.sin, domain: (0, calc.pi * 2))
})
})
#import "@preview/simple-plot:0.3.0": plot
//#set page(width: auto, height: auto, margin: 0.5cm)
// Showcases: major grid only, grid-label-break, axis extension, integer ticks
#plot(
xmin: -3.1, xmax: 3.1,
ymin: -1, ymax: 9,
xlabel: $x$,
ylabel: $y$,
//show-grid: "major",
(fn: x => calc.pow(x, 2), stroke: blue + 1.5pt, label: $x^2$, label-pos: 0.7, label-side: "below-right"),
)
#plot(
xmin: -2 * calc.pi, xmax: 2 * calc.pi,
ymin: -2, ymax: 2,
width: 10, height: 5,
show-grid: "major",
xtick: (-2*calc.pi, -calc.pi, 0, calc.pi, 2*calc.pi),
xtick-labels: ($-2pi$, $-pi$, $0$, $pi$, $2pi$),
(fn: x => calc.sin(x), stroke: blue + 1.2pt),
(fn: x => calc.cos(x), stroke: red + 1.2pt),
)
#plot(
xmin: -2, xmax: 5,
ymin: 0, ymax: 32,
show-grid: true,
(fn: x => calc.pow(2, x), stroke: blue + 1.5pt, label: $2^x$),
(fn: x => calc.pow(3, x), stroke: red + 1.5pt, label: $3^x$),
)

0
Band2/Grafiken/B2.1.typ Normal file
View File

0
Band2/Grafiken/B2.2.typ Normal file
View File

0
Band2/Grafiken/B2.3.typ Normal file
View File

637
Band2/Grafiken/Grafiken.typ Normal file
View File

@@ -0,0 +1,637 @@
// #import "@preview/cetz:0.4.0": canvas
// #import "@preview/cetz-plot:0.1.2": plot
// #canvas({
// plot.plot(
// size: (8, 8),
// axis-style: "school-book", // nur Achsen, kein Rahmen[web:17]
// x-min: -2, x-max: 2, // negativer und positiver x-Bereich[web:27]
// y-min: -1, y-max: 3.5,
// x-tick-step: none, // automatische Ticks aus[web:24]
// y-tick-step: none,
// // nur 1/2 und x auf der x-Achse:
// x-ticks: (
// (0.5, $1/2$),
// (1.25, $x$),
// ),
// // z.B. ein paar y-Ticks, falls gewünscht:
// y-ticks: (
// (0.25, $1/4$),
// (1.5625, $x^2$),
// ),
// shared-zero: false, // optional: 0 am Ursprung ausblenden[web:16]
// // Parabel: y = x^2 auf [-2,2]
// plot.add(
// domain: (-3, 3),
// (x) => x * x,
// )
// )
// })
// #import "@preview/cetz:0.4.2"
// #import "@preview/cetz-plot:0.1.3": plot
// #cetz.canvas({
// //import cetz.plot
// //import cetz.palette
// import cetz.draw: *
// plot.plot(
// size: (6, 6),
// x-tick-step: none,
// y-tick-step: none,
// axis-style: "school-book",
// x-label: $x$,
// y-label: $y$,
// x-ticks: (
// (0.5, $1/2$),
// (1.25, $x$),
// ),
// y-ticks: (
// (0.25, $1/4$),
// (1.5625, $x^2$),
// ),
// {
// let f = x => calc.pow(x, 2)
// // Definition der Punkte
// let x0 = 0.5
// let y0 = f(x0)
// let x1 = 1.25
// let y1 = f(x1)
// // Berechnung der Steigung m = (y1 - y0) / (x1 - x0)
// let m = (y1 - y0) / (x1 - x0)
// // Sekantenfunktion: s(x) = m * (x - x0) + y0
// let s = x => m * (x - x0) + y0
// // 1. Die Parabel
// plot.add(f, domain: (-1.3, 1.8), label: $f(x) = x^2$)
// // 2. Die Sekante (etwas weiter gezeichnet für die Optik)
// plot.add(s, domain: (0, 2), style: (stroke: blue))
// // 3. Die Punkte markieren
// plot.add(((x0, y0),), mark: "o", label: $P_0$)
// plot.add(((x1, y1),), mark: "o", label: $P$)
// // 4. Hilfslinien (gestrichelt)
// plot.add(((x0, 0), (x0, y0)), style: (stroke: (dash: "dashed", paint: gray, thickness: 0.5pt)))
// plot.add(((x1, 0), (x1, y1)), style: (stroke: (dash: "dashed", paint: gray, thickness: 0.5pt)))
// plot.add(((x0, y0), (x1, y0)), style: (stroke: ( paint: gray.darken(80%), thickness: 0.5pt)))
// plot.add-anchor("pt1", (2,5))
// }
// )
// // content("plot.x", [asdf])
// })
// #import "@preview/cetz:0.4.2"
// #import "@preview/cetz-plot:0.1.2": plot
// #cetz.canvas({
// plot.plot(
// size: (6, 6),
// x-tick-step: 1,
// y-tick-step: 1,
// axis-style: "school-book",
// x-label: $x$,
// y-label: $y$,
// {
// let f = x => calc.pow(x, 2)
// let x0 = 0.5
// let x1 = 1.5
// // 1. Die Parabel
// plot.add(f, domain: (-1.3, 1.8), label: $f(x)$)
// // 2. Die Sekante
// let m = (f(x1) - f(x0)) / (x1 - x0)
// plot.add(x => m * (x - x0) + f(x0), domain: (0, 2), style: (stroke: blue))
// // 3. Hilfslinien
// plot.add(((x0, 0), (x0, f(x0))), style: (stroke: (dash: "dashed", paint: gray)))
// plot.add(((x1, 0), (x1, f(x1))), style: (stroke: (dash: "dashed", paint: gray)))
// // 4. Beschriftungen OHNE den "bounds" Fehler
// // Wir nutzen plot.add mit leeren Markern oder speziellen Labels
// // Punkte markieren und direkt beschriften
// plot.add(((x0, f(x0)),), mark: "o", label: $P_0$)
// plot.add(((x1, f(x1)),), mark: "o", label: $P$)
// // Beschriftung an der x-Achse
// // Trick: Wir addieren einen "unsichtbaren" Punkt an der Achse mit Label
// plot.add(((x0, 0),), label: $x_0$, mark: none)
// plot.add(((x1, 0),), label: $x$, mark: none)
// }
// )
// })
// #import "@preview/cetz:0.4.2"
// #import "@preview/cetz-plot:0.1.2" as cetz_plot
// #cetz.canvas({
// let cp = cetz_plot.plot
// let x0 = 0.5
// let x1 = 1.5
// let f = x => calc.pow(x, 2)
// let y0 = f(x0)
// let y1 = f(x1)
// cp.plot(
// size: (6, 6),
// x-tick-step: 1,
// y-tick-step: 1,
// axis-style: "school-book",
// x-label: $x$,
// y-label: $y$,
// {
// // 1. Die Graphen
// cp.add(f, domain: (-1.3, 1.8))
// let m = (y1 - y0) / (x1 - x0)
// cp.add(x => m * (x - x0) + y0, domain: (-0.2, 2.2), style: (stroke: blue))
// // 2. Hilfslinien
// cp.add(((x0, 0), (x0, y0)), style: (stroke: (dash: "dashed", paint: gray)))
// cp.add(((x1, 0), (x1, y1)), style: (stroke: (dash: "dashed", paint: gray)))
// // 3. Punkte P0 und P
// cp.add(((x0, y0),), mark: "o")
// cp.add(((x1, y1),), mark: "o")
// // 4. BESCHRIFTUNG (Der Trick: add mit mark: none)
// // Wir setzen die Labels direkt an die Koordinaten
// // x-Achse Beschriftung (leicht unter y=0 verschoben mit 'label-offset')
// cp.add(((x0, 0),), label: $x_0$, mark: none)
// cp.add(((x1, 0),), label: $x$, mark: none)
// // Punkte beschriften
// cp.add(((x0 - 0.1, y0 + 0.3),), label: $P_0$, mark: none)
// cp.add(((x1 + 0.2, y1),), label: $P$, mark: none)
// // Funktionsnamen
// cp.add(((1.6, 3.2),), label: $f(x)$, mark: none)
// }
// )
// })
// #import "@preview/cetz:0.4.2"
// #import "@preview/cetz-plot:0.1.2" as cetz_plot
// #cetz.canvas({
// import cetz.draw: *
// let cp = cetz_plot.plot
// // 1. Parameter festlegen
// let (w, h) = (6, 6) // Größe des Plots
// let x-min = -1.5
// let x-max = 2.5
// let y-min = -1.0
// let y-max = 4.0
// let x0 = 0.5
// let x1 = 1.5
// let f = x => calc.pow(x, 2)
// let y0 = f(x0)
// let y1 = f(x1)
// // 2. Den Plot zeichnen (als Basis)
// cp.plot(
// size: (w, h),
// x-tick-step: 1,
// y-tick-step: 1,
// axis-style: "school-book",
// x-label: $x$,
// y-label: $y$,
// x-domain: (x-min, x-max),
// y-domain: (y-min, y-max),
// name: "p",
// {
// cp.add(f, domain: (x-min, x-max))
// let m = (y1 - y0) / (x1 - x0)
// cp.add(x => m * (x - x0) + y0, domain: (x-min, x-max), style: (stroke: blue))
// cp.add(((x0, 0), (x0, y0)), style: (stroke: (dash: "dashed", paint: gray)))
// cp.add(((x1, 0), (x1, y1)), style: (stroke: (dash: "dashed", paint: gray)))
// cp.add(((x0, y0),), mark: "o")
// cp.add(((x1, y1),), mark: "o")
// }
// )
// // 3. DER FIX: Manuelle Beschriftung über das "p.origin"
// // Wir nutzen die Größe des Plots, um die Koordinaten selbst zu setzen.
// // Da der Ursprung im school-book Stil bei (0,0) liegt:
// let plot-coords(x, y) = {
// let px = (x / (x-max - x-min)) * w
// let py = (y / (y-max - y-min)) * h
// return (rel: (px, py), to: "p.origin")
// }
// // Beschriftungen (Diese liegen nun außerhalb des Plot-Berechnungs-Logik)
// content(plot-coords(x0, -0.4), $x_0$)
// content(plot-coords(x1, -0.4), $x$)
// content(plot-coords(x0 - 0.3, y0 + 0.3), $P_0$)
// content(plot-coords(x1 + 0.3, y1), $P$)
// content(plot-coords(1.6, 3.2), $f(x)$)
// })
// #import "@preview/cetz:0.4.2"
// #cetz.canvas({
// import cetz.draw: *
// // 1. Koordinatensystem manuell skalieren (1 Einheit = 1.5cm)
// scale(1.5)
// // Parameter
// let x0 = 0.5
// let x1 = 1.5
// let f(x) = calc.pow(x, 2)
// let y0 = f(x0)
// let y1 = f(x1)
// // 2. Achsen zeichnen (School-Book)
// line((-1.5, 0), (2.5, 0), mark: (end: ">"), name: "xaxis")
// line((0, -1), (0, 4), mark: (end: ">"), name: "yaxis")
// content((2.5, -0.3), $x$)
// content((-0.3, 4), $y$)
// // 3. Parabel zeichnen (Sampling-Methode: Sicherster Weg ohne Extra-Module)
// let points = ()
// for i in range(-13, 19) {
// let x = i / 10
// points.push((x, f(x)))
// }
// line(..points, stroke: black)
// // 4. Sekante zeichnen
// let m = (y1 - y0) / (x1 - x0)
// // Gerade: y = m*(x - x0) + y0
// line((-0.5, m * (-0.5 - x0) + y0), (2.2, m * (2.2 - x0) + y0), stroke: blue)
// // 5. Hilfslinien & Punkte
// line((x0, 0), (x0, y0), stroke: (dash: "dashed", paint: gray))
// line((x1, 0), (x1, y1), stroke: (dash: "dashed", paint: gray))
// circle((x0, y0), radius: 0.05, fill: black)
// circle((x1, y1), radius: 0.05, fill: black)
// // 6. BESCHRIFTUNGEN (Direkt an den Objekten)
// content((x0, -0.4), $x_0$)
// content((x1, -0.4), $x$)
// content((x0 - 0.3, y0 + 0.2), $P_0$)
// content((x1 + 0.3, y1), $P$)
// content((1.8, f(1.8)), $f(x)$, anchor: "west", padding: .1)
// content((2.1, 3.5), [Sekante], fill: white, padding: .1)
// })
// #import "@preview/cetz:0.4.2"
// #cetz.canvas({
// import cetz.draw: *
// // 1. Koordinatensystem manuell skalieren (1 Einheit = 1.5cm)
// scale(1.5)
// // Parameter
// let x0 = 0.5
// let x1 = 1.5
// let f(x) = calc.pow(x, 2)
// let y0 = f(x0)
// let y1 = f(x1)
// // 2. Achsen zeichnen (School-Book)
// line((-1.5, 0), (2.5, 0), mark: (end: ">"), name: "xaxis")
// line((0, -1), (0, 4), mark: (end: ">"), name: "yaxis")
// content((2.5, -0.3), $x$)
// content((-0.3, 4), $y$)
// // 3. Parabel zeichnen (Sampling-Methode: Sicherster Weg ohne Extra-Module)
// let points = ()
// for i in range(-13, 19) {
// let x = i / 10
// points.push((x, f(x)))
// }
// line(..points, stroke: black)
// // 4. Sekante zeichnen
// let m = (y1 - y0) / (x1 - x0)
// // Gerade: y = m*(x - x0) + y0
// line((-0.5, m * (-0.5 - x0) + y0), (2.2, m * (2.2 - x0) + y0), stroke: blue)
// // 5. Hilfslinien & Punkte
// line((x0, 0), (x0, y0), stroke: (dash: "dashed", paint: gray))
// line((x1, 0), (x1, y1), stroke: (dash: "dashed", paint: gray))
// circle((x0, y0), radius: 0.05, fill: black)
// circle((x1, y1), radius: 0.05, fill: black)
// // 6. BESCHRIFTUNGEN (Direkt an den Objekten)
// content((x0, -0.4), $x_0$)
// content((x1, -0.4), $x$)
// content((x0 - 0.3, y0 + 0.2), $P_0$)
// content((x1 + 0.3, y1), $P$)
// content((1.8, f(1.8)), $f(x)$, anchor: "west", padding: .1)
// content((2.1, 3.5), [Sekante], fill: white, padding: .1)
// })
// #import "@preview/cetz:0.4.2"
// #align(center,
// cetz.canvas({
// // import cetz.plot
// import cetz.palette
// import cetz.draw: *
// plot.plot(size: (5,5),
// name: "plot",
// x-tick-step: 2,
// x-minor-tick-step: 1,
// y-tick-step: 6,
// y-minor-tick-step: 1,
// axis-style: "school-book", {
// plot.add(domain: (-2.5, 2.5),
// x => (4-calc.pow(x, 2)),
// style: palette.tango-light)
// plot.add(domain: (-2.5, 2.5),
// x => (4-2*x),
// style: palette.tango-light)
// plot.add-fill-between(domain: (0, 2),
// x => (4-calc.pow(x, 2)),
// x => (4-2*x),
// style: palette.tango-light)
// plot.add(((0,4), (2,0)),
// mark: "o",
// mark-style: (stroke: none, fill: black),
// style: (stroke: none))
// plot.add-anchor("pt1", (2,5))
// plot.add-anchor("pt2", (-2,5.5))
// plot.add-anchor("parab", (1, 4-calc.pow(1, 2)+0.2))
// plot.add-anchor("rline", (-1.5, 4-2*(-1.5)-0.2))
// })
// content("plot.pt1", [$y=4-2x^2$], anchor: "south", name: "prb")
// line("plot.parab", "prb", mark: (start: ">"))
// content("plot.pt2", [$y=4-2x$], anchor: "north", name: "curve2")
// line("plot.rline", "curve2", mark: (start: ">"))
// })
// )
// #align(center,
// cetz.canvas({
// // import cetz.plot
// // import cetz.palette
// import cetz.draw: *
// plot.plot(
// size: (6,6),
// name: "plot",
// x-tick-step: none,
// y-tick-step: none,
// x-label: $x$,
// y-label: $y$,
// x-ticks: ((0.5, $1/2$),(1.25, $x$),),
// y-ticks: ((0.25, $1/4$),(1.5625, $x^2$),),
// axis-style: "school-book",
// plot.add(
// domain: (-1.3, 1.8),
// x => (calc.pow(x, 2)),
// )
// )}))
// #import "@preview/cetz:0.4.2"
// #import "@preview/cetz-plot:0.1.3": plot
// #cetz.canvas({
// //import cetz.plot
// //import cetz.palette
// import cetz.draw: *
// plot.plot(
// size: (6, 6),
// x-tick-step: none,
// y-tick-step: none,
// axis-style: "school-book",
// x-label: $x$,
// y-label: $y$,
// x-ticks: (
// (0.5, $1/2$),
// (1.25, $x$),
// ),
// y-ticks: (
// (0.25, $1/4$),
// (1.5625, $x^2$),
// ),
// {
// let f = x => calc.pow(x, 2)
// // Definition der Punkte
// let x0 = 0.5
// let y0 = f(x0)
// let x1 = 1.25
// let y1 = f(x1)
// // Berechnung der Steigung m = (y1 - y0) / (x1 - x0)
// let m = (y1 - y0) / (x1 - x0)
// // Sekantenfunktion: s(x) = m * (x - x0) + y0
// let s = x => m * (x - x0) + y0
// // 1. Die Parabel
// plot.add(f, domain: (-1.3, 1.8), label: $f(x) = x^2$)
// // 2. Die Sekante (etwas weiter gezeichnet für die Optik)
// plot.add(s, domain: (0, 2), style: (stroke: blue))
// // 3. Die Punkte markieren
// plot.add(((x0, y0),), mark: "o", label: $P_0$)
// plot.add(((x1, y1),), mark: "o", label: $P$)
// // 4. Hilfslinien (gestrichelt)
// plot.add(((x0, 0), (x0, y0)), style: (stroke: (dash: "dashed", paint: gray, thickness: 0.5pt)))
// plot.add(((x1, 0), (x1, y1)), style: (stroke: (dash: "dashed", paint: gray, thickness: 0.5pt)))
// plot.add(((x0, y0), (x1, y0)), style: (stroke: ( paint: gray.darken(80%), thickness: 0.5pt)))
// plot.add-anchor("pt1", (2,5))
// }
// )
// // content("plot.x", [asdf])
// })
#import "@preview/cetz:0.4.2"
#import "@preview/cetz-plot:0.1.3": plot
#cetz.canvas({
import cetz.draw: *
plot.plot(
//definitionen
{
//berechnungen und plot
}
)
})
#import "@preview/cetz:0.4.2"
#import "@preview/cetz-plot:0.1.3": plot
#cetz.canvas(length: 1.25cm,{
import cetz.draw: *
set-style(
axes: (
// Basisstil beibehalten
stroke: (thickness: 0.5pt),
// x-Achse: stealth-Pfeil am Ende
x: (mark: (end: "stealth", fill: black)),
// y-Achse: stealth-Pfeil am Ende
y: (mark: (end: "stealth", fill: black)),
),
)
plot.plot(
//definitionen
name: "plot",
size: (6, 6),
x-tick-step: none,
y-tick-step: none,
axis-style: "school-book",
x-label: $x$,
y-label: $y$,
x-ticks: ((0.5, $1/2$),(1.25, $x$),),
y-ticks: ((0.25, $1/4$),(1.5625, $x^2$),),
{
//berechnungen und plot
let f = x => calc.pow(x, 2)
let x0 = 0.5
let y0 = f(x0)
let x1 = 1.25
let y1 = f(x1)
// Berechnung der Steigung m = (y1 - y0) / (x1 - x0)
let m = (y1 - y0) / (x1 - x0)
// Sekantenfunktion: s(x) = m * (x - x0) + y0
let s = x => m * (x - x0) + y0
let x1_1 = x1 + 0.1
let x0_1 = x0 - 0.2
let y0_1 = y0 + 0.2
let x2 = ((x1 - x0)/2) + x0
let y3 = ((y1 - y0)/2) +y0
plot.add(x => calc.pow(x, 2), domain: (-1.4, 1.8))
//Sekante
plot.add(s, domain: (0.3, 1.7), style: (stroke: red))
plot.add-anchor("pt1", (-1.4,y1))
plot.add-anchor("P", (x1_1,y1))
plot.add-anchor("P0", (x0_1,y0_1))
plot.add-anchor("F1", (x2,0.14))
plot.add-anchor("F2", (x1+0.1,y3))
plot.add(((x0, 0), (x0, y0)), style: (stroke: (dash: "dashed", paint: gray, thickness: 0.75pt)))
plot.add(((x1, 0), (x1, y1)), style: (stroke: (dash: "dashed", paint: gray, thickness: 0.75pt)))
plot.add(((0, y1), (x1, y1)), style: (stroke: (dash: "dashed", paint: gray, thickness: 0.75pt)))
plot.add(((0, y0), (x0, y0)), style: (stroke: (dash: "dashed", paint: gray, thickness: 0.75pt)))
plot.add(((x0, y0), (x1, y0)), style: (stroke: ( paint: gray.darken(80%), thickness: 0.5pt)))
plot.add(((x1, y0), (x1, y1)), style: (stroke: ( paint: gray.darken(80%), thickness: 0.5pt)))
plot.add(((x0, y0),), mark: "o")
plot.add(((x1, y1),), mark: "o")
}
)
//Der Plot muss einen Namen haben
content("plot.pt1", text(0.85em)[$y=x^2$], anchor: "east", name: "pt")
content("plot.P", text(0.75em)[$P$], anchor: "west", name: "p")
content("plot.P0", text(0.75em)[$P_0$], anchor: "west", name: "p0")
content("plot.F1", text(0.75em)[$x- 1/2$], anchor: "center", name: "f1")
content("plot.F2", text(0.75em)[$x^2- 1/4$], anchor: "west", name: "f2")
})
#import "@preview/cetz:0.4.2"
#import "@preview/cetz-plot:0.1.3": plot
#cetz.canvas({
import cetz.draw: *
set-style(
axes: (
// Basisstil beibehalten
stroke: (thickness: 0.5pt),
// x-Achse: stealth-Pfeil am Ende
x: (mark: (end: "stealth", fill: black)),
// y-Achse: stealth-Pfeil am Ende
y: (mark: (end: "stealth", fill: black)),
),
)
plot.plot(
name: "plot",
size: (5, 5),
x-tick-step: none,
y-tick-step: none,
axis-style: "school-book",
x-label: $x$,
y-label: $y$,
x-ticks: ((0.5, $1/2$),),
y-ticks: ((1, $1$),),
//definitionen
{
let f = x => if x != 0.5 { (calc.pow(x, 2) - 0.25) / (x - 0.5) } else { none }
let x0 = 0.5
let y0 = 1
plot.add(f, domain: (-0.6, 0.75), style: (stroke: blue))
plot.add(((x0, 0), (x0, y0)), style: (stroke: (dash: "dashed", paint: gray, thickness: 0.75pt)))
plot.add(((0, y0), (x0, y0)), style: (stroke: (dash: "dashed", paint: gray, thickness: 0.75pt)))
plot.add(((x0, y0),), mark: "o")
plot.add-anchor("F1", (-.7,0.5))
plot.add-anchor("F2", (-.7,0.35))
}
)
content("plot.F1", text(0.85em)[$y=(x^2-1/4)/(x-1/2)$], anchor: "west", name: "pt")
content("plot.F2", text(0.85em)[$(x eq.not 1/2)$], anchor: "west", name: "pt")
})

250
Band2/deckblatt.typ Normal file
View File

@@ -0,0 +1,250 @@
#let deckblatt(bandnr: "", autor: "", titel: "") = {
place(
top + left,
dx: -20mm, // Hebt den linken Rand auf
dy: -20mm, // Abstand von der Oberkante des Blattes
rect(
width: 163mm, // Exakte Breite A4
height: 230mm,
fill: rgb(52.2%, 87.8%, 78.4%),
inset: (right: 1cm, left: 7mm, top: 1cm),
//stroke: 0.5pt + red,
))
place(
top + left,
dx: -20mm,
dy: 12mm,
//Linie
rect(
width: 162mm,
height: 2mm,
fill: rgb(100%, 100%, 87.1%),
inset: (right: 1cm, left: 7mm, top: 1cm),
))
place(
top + left,
dx: -2.5cm,
dy: 1.4cm,
rect(
width: 27cm, height: 2mm,
fill: rgb(17.3%, 19.6%, 36.1%),
inset: (right: 1cm, left: 7mm, top: 1cm),
))
place(
top + left,
dx: -2.5cm,
dy: 1.6cm,
rect(
width: 27cm, // Exakte Breite A4
height: 2mm,
fill: rgb(100%, 100%, 87.1%),
inset: (right: 1cm, left: 7mm, top: 1cm),
//stroke: 0.5pt + red,
))
place(
top + left,
dx: -2.5cm,
dy: 1.8cm,
rect(
width: 27cm, // Exakte Breite A4
height: 2mm,
fill: rgb(17.3%, 19.6%, 36.1%),
inset: (right: 1cm, left: 7mm, top: 1cm),
//stroke: 0.5pt + red,
))
place(
top + left,
dx: -2.5cm, // Hebt den linken Rand auf
dy: 2cm, // Abstand von der Oberkante des Blattes
rect(
width: 27cm, // Exakte Breite A4
height: 2mm,
fill: rgb(100%, 100%, 87.1%),
inset: (right: 1cm, left: 7mm, top: 1cm),
//stroke: 0.5pt + red,
))
place(
top + left, // Wo auf der Seite (oder im Absatz)
dx: 94mm, // Versatz von links
dy: 85mm, // Versatz von oben
{
import "@preview/cetz:0.3.1"
cetz.canvas({
import cetz.draw: *
// Halbkreis
arc((x:0,y:0), start: 0deg, stop: -180deg, radius: 17mm, fill: rgb(100%, 100%, 87.1%), stroke: none)
})
}
)
place(
top + left,
dx: -2.5cm, // Hebt den linken Rand auf
dy: 2.2cm, // Abstand von der Oberkante des Blattes
rect(
width: 230cm, // Exakte Breite A4
height: 58mm,
fill: rgb(12.9%, 18%, 32.9%),
inset: (right: 1cm, left: 7mm, top: 1cm),
//stroke: 0.5pt + red,
))
place(
top + left,
dx: -2.5cm, // Hebt den linken Rand auf
dy: 80mm,
rect(
width: 27cm,
height: 2mm,
fill: rgb(100%, 100%, 87.1%),
inset: (right: 1cm, left: 7mm, top: 1cm),
))
place(
top + left,
dx: -2.5cm,
dy: 82mm,
rect(
width: 27cm,
height: 2mm,
fill: rgb(17.3%, 19.6%, 36.1%),
inset: (right: 1cm, left: 7mm, top: 1cm),
))
place(
top + left,
dx: -2.5cm,
dy: 84mm,
rect(
width: 27cm,
height: 2mm,
fill: rgb(100%, 100%, 87.1%),
inset: (right: 1cm, left: 7mm, top: 1cm),
))
place(
top + left,
dx: -2.5cm,
dy: 86mm,
rect(
width: 27cm,
height: 2mm,
fill: rgb(17.3%, 19.6%, 36.1%),
inset: (right: 1cm, left: 7mm, top: 1cm),
))
place(
top + left,
dx: -2.5cm, // Hebt den linken Rand auf
dy: 88mm,
rect(
width: 27cm,
height: 2mm,
fill: rgb(100%, 100%, 87.1%),
inset: (right: 1cm, left: 7mm, top: 1cm),
))
/* place(
top + left,
dx: 7.5cm, // Hebt den linken Rand auf
dy: 62mm,
circle( radius: 15mm, fill: rgb(100%, 32.2%, 18.8%)),
//height: 2mm,
//fill: rgb(100%, 100%, 87.1%),
//inset: (right: 1cm, left: 7mm, top: 1cm),
) */
place(
top + left,
dx: 95mm,
dy: 68mm,
box(width: 30mm, height: 30mm)[
#circle(radius: 16mm, fill: rgb(100%, 32.2%, 18.8%), stroke: none)
#place(center + horizon)[
// Wir erzwingen hier ALLES neu
#set text(font: "Fira Math", size: 48pt, fill: black)
#bandnr
]
]
/* {
set align(center + horizon)
text(weight: "bold",fill: black, size: 45pt)[$1$]
}*/
)
// Text
place(
top + left,
dx: -12mm,
dy: 2.6cm,
// box mit width: auto erlaubt der Zeile, beliebig lang zu werden
box(width: 150%, {
text(7.5em, fill: rgb(100%, 32.2%, 18.8%), weight: "bold",style: "italic", tracking: 0.06em, font: "Lato")[MATHEMATIK]
})
)
place(
top + left,
dx: -12mm,
dy: 4.7cm,
// box mit width: auto erlaubt der Zeile, beliebig lang zu werden
box(width: 150%, {
text(2em, fill: rgb(100%, 100%, 87.1%), weight: "bold", tracking: 0em, font: "Lato")[FÜR INGENIEURE]
})
)
place(
top + left,
dx: -0.7cm,
dy: 5.4cm,
// box mit width: auto erlaubt der Zeile, beliebig lang zu werden
box(width: 150%, {
text(2em, fill: rgb(100%, 100%, 87.1%), weight: "bold", tracking: 0em, font: "Lato")[NATURWISSENSCHAFTLER]
})
)
place(
top + left,
dx: -0.7cm,
dy: 6.1cm,
// box mit width: auto erlaubt der Zeile, beliebig lang zu werden
box(width: 150%, {
text(2em, fill: rgb(100%, 100%, 87.1%), weight: "bold", tracking: 0em, font: "Lato")[ÖKONOMEN]
}))
place(
top + left,
dx: -0.7cm,
dy: 6.8cm,
// box mit width: auto erlaubt der Zeile, beliebig lang zu werden
box(width: 150%, {
text(2em, fill: rgb(100%, 100%, 87.1%), weight: "bold", tracking: 0em, font: "Lato")[LANDWIRTE]
}))
place(
top + left,
dx: -0.7cm,
dy: 10cm,
// box mit width: auto erlaubt der Zeile, beliebig lang zu werden
box(width: 150%, {
text(1.25em, fill: rgb(3.1%, 20%, 29%), weight: "bold", tracking: 0.05em, font: "Lato")[#autor]
}))
place(
top + left,
dx: -0.7cm,
dy: 11.5cm,
// box mit width: auto erlaubt der Zeile, beliebig lang zu werden
box(width: 150%, {
set par(leading: 1em)
text(1.9em, fill: rgb(3.1%, 20%, 29%),weight: "bold", tracking: 0.0em, font: "Lato")[#titel]
}))
}