La Tabella Master delle Trasformazioni

Per evitare ogni confusione, ecco lo schema definitivo da stampare nella mente.

Consideriamo [math]c[/math], [math]k[/math], [math]a[/math], [math]b[/math] come numeri positivi ([math]>0[/math]):

⚠️ I 3 Errori Tipici nei Test (e come evitarli)

Quando ci si ritrova davanti al grafico di una funzione trasformata durante un compito in classe o un test di ammissione, la fretta può giocare brutti scherzi.

Ecco i tre scivoloni più frequenti che costano caro in termini di punteggio, spiegati dettagliatamente per non cascarci mai più.

1. Confondere il segno interno (Il miraggio della destra/sinistra)

L’errore: Vedere l’espressione [math]f(x + 4)[/math] e traslare il grafico verso destra di 4 unità, pensando che il segno “+” corrisponda automaticamente alla direzione dei numeri positivi sull’asse [math]x[/math].

La realtà: Tutto ciò che accade dentro l’argomento della funzione si comporta in modo opposto all’intuito algebrico. Aggiungere 4 significa “anticipare” i tempi della funzione, quindi il grafico si sposta a sinistra. Viceversa, [math]f(x – 4)[/math] si sposta a destra.

Come salvarsi: Ricorda la domanda chiave: “Quale valore di [math]x[/math] annulla questo termine?” Per azzerare l’argomento di [math]f(x+4)[/math] ti serve [math]x = -4[/math] (che si trova a sinistra). Per azzerare [math]f(x-4)[/math] ti serve [math]x = 4[/math] (che si trova a destra).

2. Dimenticare il factoring (Il coefficiente parassita)

L’errore: Davanti a una funzione come [math]f(2x – 6)[/math], dedurre che il grafico subisce una compressione di fattore 2 e una traslazione a destra di 6 unità.

La realtà: La traslazione orizzontale non è mai quella “visibile” se la [math]x[/math] è accompagnata da un coefficiente moltiplicativo. Il coefficiente altera la lettura dello spostamento.

Come salvarsi: Prima di decretare di quante unità si sposta il grafico, devi obbligatoriamente raccogliere a fattor comune il coefficiente della [math]x[/math] dentro l’argomento.

Trasformiamo [math]f(2x – 6)[/math] in [math]f(2(x – 3))[/math].

Ora la lettura è corretta: la funzione è compressa di un fattore 2, ma lo spostamento reale a destra è di 3 unità, non di 6!

3. Invertire compressione e dilatazione orizzontale

L’errore: Pensare che moltiplicare la [math]x[/math] per un numero grande “allarghi” il grafico e che dividerla lo “restringa”. Ad esempio, disegnare [math]f(3x)[/math] tre volte più larga della funzione base.

La realtà: Anche in questo caso, l’argomento interno lavora al contrario. Moltiplicare per 3 accelera la funzione, costringendola a compiere le sue evoluzioni in un terzo dello spazio: il grafico si comprime verso l’asse [math]y[/math].

Come salvarsi: Associa l’operazione al concetto di velocità:

• Coefficiente maggiore di 1 (es. [math]f(2x)[/math]) [math]\rightarrow[/math] La funzione va al doppio della velocità [math]\rightarrow[/math] Il grafico si stringe (compressione).
• Coefficiente compreso tra 0 e 1 (es. [math]f(x/2)[/math]) [math]\rightarrow[/math] La funzione va a metà della velocità [math]\rightarrow[/math] Il grafico si dilata (stretching).

Passare dalla teoria algebrica alla visualizzazione geometrica

Passare dalla teoria algebrica alla visualizzazione geometrica è il momento in cui la matematica “prende vita”. Questo script Python è progettato specificamente per l’ambiente Google Colab e si propone come un laboratorio interattivo per esplorare le trasformazioni geometriche delle funzioni.

Sfruttando l’ecosistema ipywidgets per l’interfaccia utente e matplotlib per il motore grafico, il codice elimina la necessità di tracciare decine di grafici statici su carta. Permette invece di manipolare i parametri in tempo reale, offrendo un feedback visivo istantaneo.

L’Obiettivo Didattico

L’obiettivo principale dello script è far comprendere l’effetto dei quattro parametri fondamentali della trasformazione generale:

[math]\displaystyle y = a \cdot f(b(x – c)) + d[/math]

In particolare, lo script mira a:

• Isolare l’effetto di ogni variabile: Permettere al lettore di muovere un solo slider alla volta per capire cosa facciano esattamente [math]a[/math], [math]b[/math], [math]c[/math] e [math]d[/math>.
• Sfatare i nodi controintuitivi: Mostrare visivamente perché un segno “meno” dentro l’argomento sposti il grafico verso destra e perché un moltiplicatore maggiore di 1 lo comprima anziché dilatarlo.
• Gestire i domini critici: Dimostrare come le trasformazioni influenzino non solo la posizione, ma anche il dominio di funzioni reali (come la radice quadrata), nascondendo automaticamente le zone in cui la funzione non è definita.

Il Codice

Ecco il codice completo per il laboratorio interattivo.

Puoi eseguirlo direttamente su Google Colab.

# Trasformazioni Geometriche - Laboratorio Interattivo
# Esegui questo script in Google Colab

import numpy as np
import matplotlib.pyplot as plt
from ipywidgets import interact, FloatSlider, Dropdown
import ipywidgets as widgets

# Funzione base selezionabile dall'utente
def funzione_base(x, scelta):
    if scelta == "Quadratica (x^2)":
        return x**2
    elif scelta == "Radice Quadrata (sqrt(x))":
        # Maschera i valori negativi per evitare errori
        return np.sqrt(np.maximum(x, 0))
    elif scelta == "Seno (sin(x))":
        return np.sin(x)
    elif scelta == "Esponenziale (e^x)":
        return np.exp(x)
    else:
        return x**2  # default

# Funzione trasformata: y = a * f(b(x - c)) + d
def funzione_trasformata(x, a, b, c, d, scelta):
    # Calcolo dell'argomento interno: b*(x - c)
    arg_interno = b * (x - c)
    # Calcolo della funzione base sull'argomento trasformato
    f_base = funzione_base(arg_interno, scelta)
    # Applicazione della dilatazione verticale e traslazione verticale
    y = a * f_base + d
    # Maschera per gestire domini non reali (es. radice di negativo)
    if scelta == "Radice Quadrata (sqrt(x))":
        # Laddove l'argomento è negativo, mette NaN per non visualizzare
        y = np.where(arg_interno >= 0, y, np.nan)
    return y

# Funzione per tracciare il grafico
def plot_trascinamenti(a, b, c, d, scelta):
    # Generazione del dominio x
    x = np.linspace(-10, 10, 1000)

    # Calcolo della funzione base (riferimento) e di quella trasformata
    y_base = funzione_base(x, scelta)
    y_trans = funzione_trasformata(x, a, b, c, d, scelta)

    # Creazione della figura
    plt.figure(figsize=(12, 6))

    # Grafico della funzione base
    plt.plot(x, y_base, label='Funzione Base', color='gray', linestyle='--', linewidth=1.5)

    # Grafico della funzione trasformata
    plt.plot(x, y_trans, label='Funzione Trasformata', color='blue', linewidth=2.5)

    # Aggiunta della griglia e degli assi
    plt.axhline(0, color='black', linewidth=0.8)
    plt.axvline(0, color='black', linewidth=0.8)
    plt.grid(True, linestyle=':', alpha=0.6)

    # Titolo e legenda
    plt.title(f'Trasformazione: y = {a:.1f} * f({b:.1f}(x - {c:.1f})) + {d:.1f}')
    plt.xlabel('x')
    plt.ylabel('y')
    plt.legend()
    plt.xlim(-10, 10)

    # Gestione automatica del limite y per evitare schiacciamenti
    y_min, y_max = np.nanmin(y_trans), np.nanmax(y_trans)
    if not np.isnan(y_min) and not np.isnan(y_max):
        margine = (y_max - y_min) * 0.2 if y_max > y_min else 2
        plt.ylim(y_min - margine, y_max + margine)

    plt.show()

# Creazione dell'interfaccia interattiva
interact(plot_trascinamenti,
    a=FloatSlider(value=1.0, min=-3.0, max=3.0, step=0.1, description='a (Verticale)'),
    b=FloatSlider(value=1.0, min=-3.0, max=3.0, step=0.1, description='b (Orizzontale)'),
    c=FloatSlider(value=0.0, min=-5.0, max=5.0, step=0.1, description='c (Trasl. H)'),
    d=FloatSlider(value=0.0, min=-5.0, max=5.0, step=0.1, description='d (Trasl. V)'),
    scelta=Dropdown(options=['Quadratica (x^2)', 'Radice Quadrata (sqrt(x))', 'Seno (sin(x))', 'Esponenziale (e^x)'],
                    value='Quadratica (x^2)',
                    description='Funzione Base:')
)

print("\n✅ Laboratorio interattivo avviato con successo!")
print("🎯 Muovi gli slider per esplorare l'effetto di ogni parametro sulla curva.")
    

Come utilizzare il laboratorio

Una volta eseguito lo script, appariranno degli slider interattivi e un menu a tendina. Ecco come interpretare i parametri:

• a (Verticale): Modifica l’altezza della curva. Valori negativi ribaltano il grafico.
• b (Orizzontale): Comprime (|b| > 1) o dilata (|b| < 1) il grafico. Valori negativi riflettono l’immagine.
• c (Traslazione Orizzontale): Sposta il grafico a destra (c > 0) o a sinistra (c < 0).
• d (Traslazione Verticale): Sposta il grafico verso l’alto (d > 0) o il basso (d < 0).
• Funzione Base: Scegli tra le quattro funzioni per vedere come le trasformazioni agiscono su forme diverse.

💡 Suggerimento:

Inizia tenendo [math]a=1[/math], [math]b=1[/math], [math]c=0[/math], [math]d=0[/math] e muovi un parametro alla volta per isolarne l’effetto. La linea tratteggiata grigia rappresenta la funzione base, mentre la linea blu è la curva trasformata.