# Kombinierte Funktionstransformationen

> For AI agents: use [llms.txt](https://nakafa.com/llms.txt) for the site index. Markdown versions are available by appending `.md` to content URLs or sending `Accept: text/markdown`.

URL: https://nakafa.com/de/faecher/mathematik/funktionstransformationen/kombinierte-funktionstransformationen
Source: https://raw.githubusercontent.com/nakafaai/aksara/16d6b8e869d1a277313c65bbfc4b4a83efe77a46/packages/corpus/material/lesson/mathematics/function-transformation/combined-transformation-function/de.mdx

Verstehe mit Graphen und vollständig gelösten Beispielen, wie mehrere Funktionstransformationen zusammenwirken und warum ihre Reihenfolge entscheidend ist.

---

## Mehrere Transformationen nacheinander

Bei einer kombinierten Transformation werden zwei oder mehr Veränderungen nacheinander auf dieselbe Funktion angewendet. Das ähnelt einem Kochrezept: Schneiden, anbraten und würzen verändern dieselben Zutaten Schritt für Schritt, und eine andere Reihenfolge kann zu einem anderen Ergebnis führen.

In der Mathematik lassen sich Verschiebung, Spiegelung, Drehung und Skalierung miteinander verbinden. Dabei muss jeder Zwischenschritt erhalten bleiben, denn die Reihenfolge bestimmt häufig das Endergebnis.

## Vertikale und horizontale Kombinationen

### Vertikale kombinierte Transformationen

Vertikale Transformationen verändern die Lage oder Größe entlang der $$y$$-Achse. Eine häufige Kombination ist eine vertikale Verschiebung, gefolgt von einer vertikalen Skalierung.

Visible text: Vertikale Transformationen verändern die Lage oder Größe entlang der -Achse. Eine häufige Kombination ist eine vertikale Verschiebung, gefolgt von einer vertikalen Skalierung.

Wird $$f(x)$$ zuerst um $$b$$ vertikal verschoben und danach mit dem Faktor $$k$$ vertikal skaliert, lautet die neue Funktion:

Visible text: Wird zuerst um vertikal verschoben und danach mit dem Faktor vertikal skaliert, lautet die neue Funktion:

```math
g(x) = k \cdot (f(x) + b)
```

### Horizontale kombinierte Transformationen

Horizontale Transformationen verändern die Lage oder Größe entlang der $$x$$-Achse. Ein Beispiel ist die Spiegelung an der $$y$$-Achse mit anschließender horizontaler Verschiebung.

Visible text: Horizontale Transformationen verändern die Lage oder Größe entlang der -Achse. Ein Beispiel ist die Spiegelung an der -Achse mit anschließender horizontaler Verschiebung.

Wird $$f(x)$$ an der $$y$$-Achse gespiegelt und danach horizontal um $$a$$ verschoben, gilt:

Visible text: Wird an der -Achse gespiegelt und danach horizontal um verschoben, gilt:

```math
g(x) = f(-(x - a))
```

## Beispiel: erst verschieben, dann skalieren

Wir wenden zwei Transformationen nacheinander auf $$f(x) = x^2$$ an:

Visible text: Wir wenden zwei Transformationen nacheinander auf an:

**Rechenweg:**

1. **Ausgangsfunktion**: $$f(x) = x^2$$

2. **Schritt** $$1$$ **- Vertikale Verschiebung**: um $$2 \text{Einheiten}$$ nach oben

   
   
   ```math
   f_1(x) = f(x) + 2 = x^2 + 2
   ```

3. **Schritt** $$2$$ **- Vertikale Skalierung**: mit dem Faktor $$0{,}5$$ multiplizieren

   
   
   ```math
   g(x) = 0{,}5 \cdot f_1(x) = 0{,}5(x^2 + 2) = 0{,}5x^2 + 1
   ```

Visible text: 1. **Ausgangsfunktion**: 

2. **Schritt** **- Vertikale Verschiebung**: um nach oben

 
 

3. **Schritt** **- Vertikale Skalierung**: mit dem Faktor multiplizieren

**Beispielrechnung für $$x = 2$$:**

Visible text: **Beispielrechnung für :**

- Ausgangsfunktion: $$f(2) = 2^2 = 4$$
- Nach der Verschiebung: $$f_1(2) = 4 + 2 = 6$$
- Nach der Skalierung: $$g(2) = 0{,}5 \times 6 = 3$$

Visible text: - Ausgangsfunktion: 
- Nach der Verschiebung: 
- Nach der Skalierung:

Der Graph zeigt jeden Zwischenschritt:

Component: LineEquation
Props:
- title: Vertikale Verschiebung und anschließende Skalierung
- description: Die quadratische Funktion wird zuerst um $$2 \\text{ Einheiten}$$ nach oben verschoben und danach mit $$0{,}5$$ vertikal skaliert.
  Visible text: Die quadratische Funktion wird zuerst um nach oben verschoben und danach mit vertikal skaliert.
- data: [
{
points: Array.from({ length: 21 }, (_, i) => {
const x = (i - 10) * 0.4;
const y = x * x;
return { x, y, z: 0 };
}),
color: "#9333ea",
showPoints: false,
labels: [
{
text: $$f(x)=x^2$$,
at: 12,
offset: [1, 0, 0],
},
],
},
{
points: Array.from({ length: 21 }, (_, i) => {
const x = (i - 10) * 0.4;
const y = x * x + 2;
return { x, y: y, z: 0 };
}),
color: "#0d9488",
showPoints: false,
labels: [
{
text: $$f_1(x)=x^2 + 2$$,
at: 12,
offset: [0.5, 0.5, 0],
},
],
},
{
points: Array.from({ length: 21 }, (_, i) => {
const x = (i - 10) * 0.4;
const y = 0.5 * (x * x + 2);
return { x, y, z: 0 };
}),
color: "#ea580c",
showPoints: false,
labels: [
{
text: $$g(x)=0{,}5(x^2 + 2)$$,
at: 12,
offset: [1.5, 0.5, 0],
},
],
},
]
  Visible text: [
{
points: Array.from({ length: 21 }, (_, i) => {
const x = (i - 10) * 0.4;
const y = x * x;
return { x, y, z: 0 };
}),
color: "#9333ea",
showPoints: false,
labels: [
{
text: ,
at: 12,
offset: [1, 0, 0],
},
],
},
{
points: Array.from({ length: 21 }, (_, i) => {
const x = (i - 10) * 0.4;
const y = x * x + 2;
return { x, y: y, z: 0 };
}),
color: "#0d9488",
showPoints: false,
labels: [
{
text: ,
at: 12,
offset: [0.5, 0.5, 0],
},
],
},
{
points: Array.from({ length: 21 }, (_, i) => {
const x = (i - 10) * 0.4;
const y = 0.5 * (x * x + 2);
return { x, y, z: 0 };
}),
color: "#ea580c",
showPoints: false,
labels: [
{
text: ,
at: 12,
offset: [1.5, 0.5, 0],
},
],
},
]

## Reihenfolge der Transformationen

Die Reihenfolge der Transformationen kann das Ergebnis verändern. Wir vergleichen deshalb zwei Varianten:

**Vergleich der Reihenfolgen:**

**Reihenfolge A: erst skalieren, dann verschieben**

1. Ausgangsfunktion: $$f(x) = x^2$$
2. Vertikale Skalierung mit Faktor $$2$$: $$h_1(x) = 2 \cdot f(x) = 2x^2$$
3. Vertikale Verschiebung um $$+1$$: $$h_A(x) = h_1(x) + 1 = 2x^2 + 1$$

Visible text: 1. Ausgangsfunktion: 
2. Vertikale Skalierung mit Faktor : 
3. Vertikale Verschiebung um :

**Reihenfolge B: erst verschieben, dann skalieren**

1. Ausgangsfunktion: $$f(x) = x^2$$
2. Vertikale Verschiebung um $$+1$$: $$h_2(x) = f(x) + 1 = x^2 + 1$$
3. Vertikale Skalierung mit Faktor $$2$$: $$h_B(x) = 2 \cdot h_2(x) = 2(x^2 + 1) = 2x^2 + 2$$

Visible text: 1. Ausgangsfunktion: 
2. Vertikale Verschiebung um : 
3. Vertikale Skalierung mit Faktor :

**Beispielrechnung für $$x = 1$$:**

Visible text: **Beispielrechnung für :**

*Reihenfolge A:*

- Ausgangsfunktion: $$f(1) = 1^2 = 1$$
- Nach der Skalierung: $$h_1(1) = 2 \times 1 = 2$$
- Nach der Verschiebung: $$h_A(1) = 2 + 1 = 3$$

Visible text: - Ausgangsfunktion: 
- Nach der Skalierung: 
- Nach der Verschiebung:

*Reihenfolge B:*

- Ausgangsfunktion: $$f(1) = 1^2 = 1$$
- Nach der Verschiebung: $$h_2(1) = 1 + 1 = 2$$
- Nach der Skalierung: $$h_B(1) = 2 \times 2 = 4$$

Visible text: - Ausgangsfunktion: 
- Nach der Verschiebung: 
- Nach der Skalierung:

Die Ergebnisse sind verschieden: $$h_A(1) = 3$$ und $$h_B(1) = 4$$. Beim zweiten Weg wird die Verschiebung ebenfalls mit dem Faktor zwei multipliziert.

Visible text: Die Ergebnisse sind verschieden: und . Beim zweiten Weg wird die Verschiebung ebenfalls mit dem Faktor zwei multipliziert.

Component: LineEquation
Props:
- title: Vergleich zweier Transformationsreihenfolgen
- description: Der Graph macht sichtbar, warum Skalieren und Verschieben nicht beliebig vertauscht werden können.
- cameraPosition: [10, 6, 10]
- data: [
{
points: Array.from({ length: 21 }, (_, i) => {
const x = (i - 10) * 0.3;
const y = x * x;
return { x, y, z: 0 };
}),
color: "#7c3aed",
showPoints: false,
labels: [
{
text: $$f(x)=x^2$$,
at: 12,
offset: [0.5, 0.3, 0],
},
],
},
{
points: Array.from({ length: 21 }, (_, i) => {
const x = (i - 10) * 0.3;
const y = 2 * x * x + 1;
return { x, y, z: 0 };
}),
color: "#059669",
showPoints: false,
labels: [
{
text: $$2x^2 + 1$$,
at: 12,
offset: [0.5, 0.5, 0],
},
],
},
{
points: Array.from({ length: 21 }, (_, i) => {
const x = (i - 10) * 0.3;
const y = 2 * (x * x + 1);
return { x, y, z: 0 };
}),
color: "#d97706",
showPoints: false,
labels: [
{
text: $$2(x^2 + 1)$$,
at: 12,
offset: [0.5, 0.8, 0],
},
],
},
]
  Visible text: [
{
points: Array.from({ length: 21 }, (_, i) => {
const x = (i - 10) * 0.3;
const y = x * x;
return { x, y, z: 0 };
}),
color: "#7c3aed",
showPoints: false,
labels: [
{
text: ,
at: 12,
offset: [0.5, 0.3, 0],
},
],
},
{
points: Array.from({ length: 21 }, (_, i) => {
const x = (i - 10) * 0.3;
const y = 2 * x * x + 1;
return { x, y, z: 0 };
}),
color: "#059669",
showPoints: false,
labels: [
{
text: ,
at: 12,
offset: [0.5, 0.5, 0],
},
],
},
{
points: Array.from({ length: 21 }, (_, i) => {
const x = (i - 10) * 0.3;
const y = 2 * (x * x + 1);
return { x, y, z: 0 };
}),
color: "#d97706",
showPoints: false,
labels: [
{
text: ,
at: 12,
offset: [0.5, 0.8, 0],
},
],
},
]

## Kombinierte horizontale Transformationen

Auch Spiegelung und horizontale Verschiebung lassen sich kombinieren:

**Rechenweg:**

1. **Ausgangsfunktion**: $$f(x) = 1{,}5^x$$

2. **Schritt** $$1$$ **- Spiegelung an der $$y$$-Achse**: Ersetze $$x$$ durch $$-x$$

   
   
   ```math
   f_1(x) = f(-x) = 1{,}5^{-x}
   ```

3. **Schritt** $$2$$ **- Horizontale Verschiebung**: um $$2 \text{Einheiten}$$ nach rechts

   
   
   ```math
   g(x) = f_1(x-2) = 1{,}5^{-(x-2)} = 1{,}5^{-x+2}
   ```

Visible text: 1. **Ausgangsfunktion**: 

2. **Schritt** **- Spiegelung an der -Achse**: Ersetze durch 

 
 

3. **Schritt** **- Horizontale Verschiebung**: um nach rechts

**Beispielrechnung für $$x = 3$$:**

Visible text: **Beispielrechnung für :**

- Ausgangsfunktion: $$f(3) = 1{,}5^3 = 3{,}375$$
- Nach der Spiegelung: $$f_1(3) = 1{,}5^{-3} = \frac{1}{3{,}375} \approx 0{,}296$$
- Nach der Verschiebung: $$g(3) = 1{,}5^{-(3-2)} = 1{,}5^{-1} = \frac{1}{1{,}5} \approx 0{,}667$$

Visible text: - Ausgangsfunktion: 
- Nach der Spiegelung: 
- Nach der Verschiebung:

Der Graph zeigt wieder beide Zwischenschritte:

Component: LineEquation
Props:
- title: Spiegelung und anschließende horizontale Verschiebung
- description: Die Exponentialfunktion wird zuerst an der $$y$$-Achse gespiegelt und danach nach rechts verschoben.
  Visible text: Die Exponentialfunktion wird zuerst an der -Achse gespiegelt und danach nach rechts verschoben.
- cameraPosition: [8, 6, 8]
- data: [
{
points: Array.from({ length: 15 }, (_, i) => {
const x = (i - 7) * 0.4;
const y = Math.pow(1.5, x);
return { x, y, z: 0 };
}),
color: "#0891b2",
showPoints: false,
labels: [
{
text: $$f(x)=1{,}5^x$$,
at: 12,
offset: [0.5, 1.5, 0],
},
],
},
{
points: Array.from({ length: 15 }, (_, i) => {
const x = (i - 7) * 0.4;
const y = Math.pow(1.5, -x);
return { x, y, z: 0 };
}),
color: "#db2777",
showPoints: false,
labels: [
{
text: $$f(-x)=1{,}5^{-x}$$,
at: 3,
offset: [-2, -0.5, 0],
},
],
},
{
points: Array.from({ length: 15 }, (_, i) => {
const x = (i - 7) * 0.4;
const y = Math.pow(1.5, -(x - 2));
return { x, y, z: 0 };
}),
color: "#65a30d",
showPoints: false,
labels: [
{
text: $$f(-(x-2))$$,
at: 8,
offset: [1, 0.8, 0],
},
],
},
]
  Visible text: [
{
points: Array.from({ length: 15 }, (_, i) => {
const x = (i - 7) * 0.4;
const y = Math.pow(1.5, x);
return { x, y, z: 0 };
}),
color: "#0891b2",
showPoints: false,
labels: [
{
text: ,
at: 12,
offset: [0.5, 1.5, 0],
},
],
},
{
points: Array.from({ length: 15 }, (_, i) => {
const x = (i - 7) * 0.4;
const y = Math.pow(1.5, -x);
return { x, y, z: 0 };
}),
color: "#db2777",
showPoints: false,
labels: [
{
text: ,
at: 3,
offset: [-2, -0.5, 0],
},
],
},
{
points: Array.from({ length: 15 }, (_, i) => {
const x = (i - 7) * 0.4;
const y = Math.pow(1.5, -(x - 2));
return { x, y, z: 0 };
}),
color: "#65a30d",
showPoints: false,
labels: [
{
text: ,
at: 8,
offset: [1, 0.8, 0],
},
],
},
]

## Eigenschaften kombinierter Transformationen

Für kombinierte Transformationen gilt:

- **Reihenfolgeabhängig**: Manche Transformationen sind nicht kommutativ, sodass eine andere Reihenfolge das Ergebnis verändert. Unabhängige horizontale und vertikale Transformationen können dagegen in beliebiger Reihenfolge ausgeführt werden
- **Algebraisch vereinfachbar**: Mehrere Schritte lassen sich oft zu einer Formel zusammenfassen
- **Stetigkeit bleibt erhalten**: Ist die Ausgangsfunktion stetig, bleibt auch das transformierte Ergebnis stetig

## Übungen

1. Verschiebe die Funktion $$f(x) = x^2$$ um $$3 \text{Einheiten}$$ nach oben und skaliere sie danach vertikal mit $$\frac{1}{2}$$. Bestimme die neue Funktionsgleichung.

2. Spiegle die Funktion $$g(x) = 2^x$$ an der $$y$$-Achse und verschiebe sie danach um $$1 \text{ Einheit}$$ nach rechts. Gib die neue Funktionsgleichung an.

3. Vergleiche für die Funktion $$h(x) = x^2$$ zwei verschiedene Reihenfolgen:
   - Reihenfolge A: vertikale Skalierung mit $$3$$, danach Verschiebung um $$2 \text{Einheiten}$$ nach oben
   - Reihenfolge B: Verschiebung um $$2 \text{Einheiten}$$ nach oben, danach vertikale Skalierung mit $$3$$

4. Die Funktion $$f(x) = \sqrt{x}$$ wird in $$g(x) = 2\sqrt{x + 3} - 1$$ überführt. Nenne alle Transformationen in der richtigen Reihenfolge.

5. Bestimme die neue Funktionsgleichung, wenn $$f(x) = |x|$$ um $$2 \text{Einheiten}$$ nach links verschoben, an der $$x$$-Achse gespiegelt und danach vertikal mit dem Faktor $$3$$ gestreckt wird.

Visible text: 1. Verschiebe die Funktion um nach oben und skaliere sie danach vertikal mit . Bestimme die neue Funktionsgleichung.

2. Spiegle die Funktion an der -Achse und verschiebe sie danach um nach rechts. Gib die neue Funktionsgleichung an.

3. Vergleiche für die Funktion zwei verschiedene Reihenfolgen:
 - Reihenfolge A: vertikale Skalierung mit , danach Verschiebung um nach oben
 - Reihenfolge B: Verschiebung um nach oben, danach vertikale Skalierung mit 

4. Die Funktion wird in überführt. Nenne alle Transformationen in der richtigen Reihenfolge.

5. Bestimme die neue Funktionsgleichung, wenn um nach links verschoben, an der -Achse gespiegelt und danach vertikal mit dem Faktor gestreckt wird.

### Lösungen

1. Schrittweise Transformation von $$f(x) = x^2$$:

   Schritt $$1$$: vertikale Verschiebung um $$+3$$

   
   
   ```math
   f_1(x) = x^2 + 3
   ```

   Schritt $$2$$: vertikale Skalierung mit Faktor $$\frac{1}{2}$$

   
   
   ```math
   g(x) = \frac{1}{2}(x^2 + 3) = \frac{1}{2}x^2 + \frac{3}{2}
   ```

   Die neue Funktionsgleichung lautet damit $$g(x) = \frac{1}{2}x^2 + \frac{3}{2}$$.

   <LineEquation
     title={<>Schritt für Schritt: erst verschieben, dann skalieren</>}
     description="Ausgangsgraph und Endergebnis der quadratischen Funktion im Vergleich."
     cameraPosition={[0, 0, 12]}
     data={[
       {
         points: Array.from({ length: 21 }, (_, i) => {
           const x = (i - 10) * 0.3;
           const y = x * x;
           return { x, y, z: 0 };
         }),
         color: "#9333ea",
         showPoints: false,
         labels: [
           {
             text: $$f(x)=x^2$$,
             at: 12,
             offset: [0.5, 0.3, 0],
           },
         ],
       },
       {
         points: Array.from({ length: 21 }, (_, i) => {
           const x = (i - 10) * 0.3;
           const y = 0.5 * (x * x + 3);
           return { x, y, z: 0 };
         }),
         color: "#ea580c",
         showPoints: false,
         labels: [
           {
             text: $$g(x)=\frac{1}{2}x^2+\frac{3}{2}$$,
             at: 12,
             offset: [0.5, 0.8, 0],
           },
         ],
       },
     ]}
   />

2. Schrittweise Transformation von $$g(x) = 2^x$$:

   Schritt $$1$$: Spiegelung an der $$y$$-Achse

   
   
   ```math
   g_1(x) = 2^{-x}
   ```

   Schritt $$2$$: horizontale Verschiebung um $$1 \text{ Einheit}$$ nach rechts

   
   
   ```math
   h(x) = 2^{-(x-1)} = 2^{-x+1} = 2 \cdot 2^{-x}
   ```

   Die neue Funktionsgleichung lautet damit $$h(x) = 2^{1-x}$$.

   <LineEquation
     title={<>Spiegelung und Verschiebung der Exponentialfunktion</>}
     description="Ausgangsgraph und Ergebnis nach beiden Transformationen."
     cameraPosition={[8, 6, 8]}
     data={[
       {
         points: Array.from({ length: 15 }, (_, i) => {
           const x = (i - 7) * 0.4;
           const y = Math.pow(2, x);
           return { x, y, z: 0 };
         }),
         color: "#0d9488",
         showPoints: false,
         labels: [
           {
             text: $$g(x)=2^x$$,
             at: 12,
             offset: [0.5, 0.5, 0],
           },
         ],
       },
       {
         points: Array.from({ length: 15 }, (_, i) => {
           const x = (i - 7) * 0.4;
           const y = Math.pow(2, 1 - x);
           return { x, y, z: 0 };
         }),
         color: "#7c3aed",
         showPoints: false,
         labels: [
           {
             text: $$h(x)=2^{1-x}$$,
             at: 6,
             offset: [-0.8, 0.5, 0],
           },
         ],
       },
     ]}
   />

3. Vergleich zweier Transformationsordnungen:

   **Reihenfolge A**: zuerst skalieren, dann verschieben

   <MathContainer>
   
   
   ```math
   h_1(x) = 3x^2
   ```

   
   
   ```math
   h_A(x) = 3x^2 + 2
   ```

   </MathContainer>

   **Reihenfolge B**: zuerst verschieben, dann skalieren

   <MathContainer>
   
   
   ```math
   h_2(x) = x^2 + 2
   ```

   
   
   ```math
   h_B(x) = 3(x^2 + 2) = 3x^2 + 6
   ```

   </MathContainer>

   Die Ergebnisse sind verschieden: $$h_A(x) = 3x^2 + 2$$ und $$h_B(x) = 3x^2 + 6$$.

   <LineEquation
     title={<>Einfluss der Reihenfolge auf das Ergebnis</>}
     description="Die beiden Reihenfolgen führen zu unterschiedlichen vertikalen Lagen."
     data={[
       {
         points: Array.from({ length: 21 }, (_, i) => {
           const x = (i - 10) * 0.3;
           const y = x * x;
           return { x, y, z: 0 };
         }),
         color: "#9333ea",
         showPoints: false,
         labels: [
           {
             text: $$h(x)=x^2$$,
             at: 12,
             offset: [0.5, 0.3, 0],
           },
         ],
       },
       {
         points: Array.from({ length: 21 }, (_, i) => {
           const x = (i - 10) * 0.3;
           const y = 3 * x * x + 2;
           return { x, y, z: 0 };
         }),
         color: "#059669",
         showPoints: false,
         labels: [
           {
             text: <>Reihenfolge A: $$3x^2+2$$</>,
             at: 12,
             offset: [0.5, 0.8, 0],
           },
         ],
       },
       {
         points: Array.from({ length: 21 }, (_, i) => {
           const x = (i - 10) * 0.3;
           const y = 3 * (x * x + 2);
           return { x, y, z: 0 };
         }),
         color: "#d97706",
         showPoints: false,
         labels: [
           {
             text: <>Reihenfolge B: $$3x^2+6$$</>,
             at: 10,
             offset: [0.5, -0.8, 0],
           },
         ],
       },
     ]}
   />

4. Analyse der Transformation $$g(x) = 2\sqrt{x + 3} - 1$$ aus $$f(x) = \sqrt{x}$$:

   Die Transformationen erfolgen nacheinander:
   - Verschiebung um $$3 \text{Einheiten}$$ nach links: $$f(x + 3) = \sqrt{x + 3}$$
   - Vertikale Skalierung mit Faktor $$2$$: $$2\sqrt{x + 3}$$
   - Verschiebung um $$1 \text{ Einheit}$$ nach unten: $$2\sqrt{x + 3} - 1$$

5. Schrittweise Transformation von $$f(x) = |x|$$:

   <MathContainer>
   
   
   ```math
   f_1(x) = |x + 2|
   ```

   
   
   ```math
   f_2(x) = -|x + 2|
   ```

   
   
   ```math
   g(x) = -3|x + 2|
   ```

   </MathContainer>

   Die neue Funktionsgleichung lautet damit $$g(x) = -3|x + 2|$$.

   <LineEquation
     title={<>Verschiebung, Spiegelung und Skalierung der Betragsfunktion</>}
     description="Ausgangsgraph und Ergebnis nach allen drei Transformationen."
     cameraPosition={[0, 0, 12]}
     data={[
       {
         points: Array.from({ length: 21 }, (_, i) => {
           const x = (i - 10) * 0.3;
           const y = Math.abs(x);
           return { x, y, z: 0 };
         }),
         color: "#0891b2",
         showPoints: false,
         labels: [
           {
             text: $$f(x)=|x|$$,
             at: 15,
             offset: [0.5, 0.3, 0],
           },
         ],
       },
       {
         points: Array.from({ length: 21 }, (_, i) => {
           const x = (i - 10) * 0.3;
           const y = -3 * Math.abs(x + 2);
           return { x, y, z: 0 };
         }),
         color: "#db2777",
         showPoints: false,
         labels: [
           {
             text: $$g(x)=-3|x + 2|$$,
             at: 5,
             offset: [-0.8, -0.5, 0],
           },
         ],
       },
     ]}
   />

Visible text: 1. Schrittweise Transformation von :

 Schritt : vertikale Verschiebung um 

 
 

 Schritt : vertikale Skalierung mit Faktor 

 
 

 Die neue Funktionsgleichung lautet damit .

 <LineEquation
 title={<>Schritt für Schritt: erst verschieben, dann skalieren</>}
 description="Ausgangsgraph und Endergebnis der quadratischen Funktion im Vergleich."
 cameraPosition={[0, 0, 12]}
 data={[
 {
 points: Array.from({ length: 21 }, (_, i) => {
 const x = (i - 10) * 0.3;
 const y = x * x;
 return { x, y, z: 0 };
 }),
 color: "#9333ea",
 showPoints: false,
 labels: [
 {
 text: ,
 at: 12,
 offset: [0.5, 0.3, 0],
 },
 ],
 },
 {
 points: Array.from({ length: 21 }, (_, i) => {
 const x = (i - 10) * 0.3;
 const y = 0.5 * (x * x + 3);
 return { x, y, z: 0 };
 }),
 color: "#ea580c",
 showPoints: false,
 labels: [
 {
 text: ,
 at: 12,
 offset: [0.5, 0.8, 0],
 },
 ],
 },
 ]}
 />

2. Schrittweise Transformation von :

 Schritt : Spiegelung an der -Achse

 
 

 Schritt : horizontale Verschiebung um nach rechts

 
 

 Die neue Funktionsgleichung lautet damit .

 <LineEquation
 title={<>Spiegelung und Verschiebung der Exponentialfunktion</>}
 description="Ausgangsgraph und Ergebnis nach beiden Transformationen."
 cameraPosition={[8, 6, 8]}
 data={[
 {
 points: Array.from({ length: 15 }, (_, i) => {
 const x = (i - 7) * 0.4;
 const y = Math.pow(2, x);
 return { x, y, z: 0 };
 }),
 color: "#0d9488",
 showPoints: false,
 labels: [
 {
 text: ,
 at: 12,
 offset: [0.5, 0.5, 0],
 },
 ],
 },
 {
 points: Array.from({ length: 15 }, (_, i) => {
 const x = (i - 7) * 0.4;
 const y = Math.pow(2, 1 - x);
 return { x, y, z: 0 };
 }),
 color: "#7c3aed",
 showPoints: false,
 labels: [
 {
 text: ,
 at: 6,
 offset: [-0.8, 0.5, 0],
 },
 ],
 },
 ]}
 />

3. Vergleich zweier Transformationsordnungen:

 **Reihenfolge A**: zuerst skalieren, dann verschieben

 <MathContainer>
 
 

 
 

 </MathContainer>

 **Reihenfolge B**: zuerst verschieben, dann skalieren

 <MathContainer>
 
 

 
 

 </MathContainer>

 Die Ergebnisse sind verschieden: und .

 <LineEquation
 title={<>Einfluss der Reihenfolge auf das Ergebnis</>}
 description="Die beiden Reihenfolgen führen zu unterschiedlichen vertikalen Lagen."
 data={[
 {
 points: Array.from({ length: 21 }, (_, i) => {
 const x = (i - 10) * 0.3;
 const y = x * x;
 return { x, y, z: 0 };
 }),
 color: "#9333ea",
 showPoints: false,
 labels: [
 {
 text: ,
 at: 12,
 offset: [0.5, 0.3, 0],
 },
 ],
 },
 {
 points: Array.from({ length: 21 }, (_, i) => {
 const x = (i - 10) * 0.3;
 const y = 3 * x * x + 2;
 return { x, y, z: 0 };
 }),
 color: "#059669",
 showPoints: false,
 labels: [
 {
 text: <>Reihenfolge A: </>,
 at: 12,
 offset: [0.5, 0.8, 0],
 },
 ],
 },
 {
 points: Array.from({ length: 21 }, (_, i) => {
 const x = (i - 10) * 0.3;
 const y = 3 * (x * x + 2);
 return { x, y, z: 0 };
 }),
 color: "#d97706",
 showPoints: false,
 labels: [
 {
 text: <>Reihenfolge B: </>,
 at: 10,
 offset: [0.5, -0.8, 0],
 },
 ],
 },
 ]}
 />

4. Analyse der Transformation aus :

 Die Transformationen erfolgen nacheinander:
 - Verschiebung um nach links: 
 - Vertikale Skalierung mit Faktor : 
 - Verschiebung um nach unten: 

5. Schrittweise Transformation von :

 <MathContainer>
 
 

 
 

 
 

 </MathContainer>

 Die neue Funktionsgleichung lautet damit .

 <LineEquation
 title={<>Verschiebung, Spiegelung und Skalierung der Betragsfunktion</>}
 description="Ausgangsgraph und Ergebnis nach allen drei Transformationen."
 cameraPosition={[0, 0, 12]}
 data={[
 {
 points: Array.from({ length: 21 }, (_, i) => {
 const x = (i - 10) * 0.3;
 const y = Math.abs(x);
 return { x, y, z: 0 };
 }),
 color: "#0891b2",
 showPoints: false,
 labels: [
 {
 text: ,
 at: 15,
 offset: [0.5, 0.3, 0],
 },
 ],
 },
 {
 points: Array.from({ length: 21 }, (_, i) => {
 const x = (i - 10) * 0.3;
 const y = -3 * Math.abs(x + 2);
 return { x, y, z: 0 };
 }),
 color: "#db2777",
 showPoints: false,
 labels: [
 {
 text: ,
 at: 5,
 offset: [-0.8, -0.5, 0],
 },
 ],
 },
 ]}
 />