Skip to article frontmatterSkip to article content

Dit is een testbook

Source
%pip install ipywidgets
Requirement already satisfied: ipywidgets in c:\users\youri\anaconda3\lib\site-packages (8.1.7)
Requirement already satisfied: comm>=0.1.3 in c:\users\youri\anaconda3\lib\site-packages (from ipywidgets) (0.2.2)
Requirement already satisfied: widgetsnbextension~=4.0.14 in c:\users\youri\anaconda3\lib\site-packages (from ipywidgets) (4.0.14)
Requirement already satisfied: ipython>=6.1.0 in c:\users\youri\anaconda3\lib\site-packages (from ipywidgets) (7.31.1)
Requirement already satisfied: jupyterlab_widgets~=3.0.15 in c:\users\youri\anaconda3\lib\site-packages (from ipywidgets) (3.0.15)
Requirement already satisfied: traitlets>=4.3.1 in c:\users\youri\anaconda3\lib\site-packages (from ipywidgets) (5.14.3)
Requirement already satisfied: backcall in c:\users\youri\anaconda3\lib\site-packages (from ipython>=6.1.0->ipywidgets) (0.2.0)
Requirement already satisfied: prompt-toolkit!=3.0.0,!=3.0.1,<3.1.0,>=2.0.0 in c:\users\youri\anaconda3\lib\site-packages (from ipython>=6.1.0->ipywidgets) (3.0.20)
Requirement already satisfied: jedi>=0.16 in c:\users\youri\anaconda3\lib\site-packages (from ipython>=6.1.0->ipywidgets) (0.18.1)
Requirement already satisfied: pickleshare in c:\users\youri\anaconda3\lib\site-packages (from ipython>=6.1.0->ipywidgets) (0.7.5)
Requirement already satisfied: setuptools>=18.5 in c:\users\youri\anaconda3\lib\site-packages (from ipython>=6.1.0->ipywidgets) (63.4.1)
Requirement already satisfied: pygments in c:\users\youri\anaconda3\lib\site-packages (from ipython>=6.1.0->ipywidgets) (2.11.2)
Requirement already satisfied: decorator in c:\users\youri\anaconda3\lib\site-packages (from ipython>=6.1.0->ipywidgets) (5.1.1)
Requirement already satisfied: matplotlib-inline in c:\users\youri\anaconda3\lib\site-packages (from ipython>=6.1.0->ipywidgets) (0.1.6)
Requirement already satisfied: colorama in c:\users\youri\anaconda3\lib\site-packages (from ipython>=6.1.0->ipywidgets) (0.4.5)
Requirement already satisfied: parso<0.9.0,>=0.8.0 in c:\users\youri\anaconda3\lib\site-packages (from jedi>=0.16->ipython>=6.1.0->ipywidgets) (0.8.3)
Requirement already satisfied: wcwidth in c:\users\youri\anaconda3\lib\site-packages (from prompt-toolkit!=3.0.0,!=3.0.1,<3.1.0,>=2.0.0->ipython>=6.1.0->ipywidgets) (0.2.5)
Note: you may need to restart the kernel to use updated packages.

1. Introductie: Waarom goniometrie?

Waarom zou je je überhaupt bezighouden met iets als sinus en cosinus? Het klinkt als iets uit een stoffig wiskundeboek, maar de kans is groot dat je vandaag al tientallen keren in aanraking bent gekomen met goniometrie — zonder dat je het wist.

Denk eens aan een schommel op een speeltuin. Of aan het kloppende ritme van je hart. Misschien luister je nu naar muziek — ook dat is in essentie niets anders dan een opeenvolging van geluidsgolven. Golven, trillingen, herhalingen — ze zijn overal. En of je nu natuurkunde, economie, scheikunde of muziek studeert: periodieke bewegingen zijn fundamenteel.

In de natuurkunde beschrijven we een trillende veer of een slinger met een sinusfunctie. In de scheikunde zie je golven in reactiemechanismen of spectroscopie. In de economie verschijnen cycli in marktbewegingen — ook dat zijn patronen die je kunt benaderen met goniometrie. Zelfs in animatie en gaming worden rotaties van objecten wiskundig uitgedrukt met sinus en cosinus.

Maar waar komt dat allemaal vandaan? Hoe kan een ronddraaiend punt op een cirkel ineens de sleutel zijn tot het beschrijven van een golf? Dat is waar deze notebook over gaat. We beginnen met iets intuïtiefs: een veer met een blokje eraan. Daarmee bouwen we het begrip op van harmonische beweging, en zien we hoe de cirkelbeweging en de golfbeweging uiteindelijk één en hetzelfde verhaal vertellen — in de taal van de wiskunde: goniometrie.

2. Radialen vs. Graden

Een hoek kun je meten in graden, maar ook in radialen. Beide zijn maatvoeringen voor dezelfde eigenschap: de grootte van een hoek.
Waarbij:

  • ** 360° 360° ** staat voor een volledige cirkel
  • ** 2π radialen ** ook staat voor een volledige cirkel

2.1 Wat is een radiaal?

De omtrek van een cirkel is:

C=2πrC = 2\pi r

Stel dat je maar een deel van een cirkel hebt — een “taartpunt”. dan kun je de booglengte s s berekenen met:

s=θ3602πrs = \frac{\theta}{360^\circ} \cdot 2\pi r

Hierin is:

  • θ \theta : de hoek in graden
  • r r : de straal van de cirkel

Analogie: Pizza

Stel je voor: een pizza van 360°, netjes in 8 stukken gesneden, dus 45° per stuk. Als je 3 stukken eet, heb je 345°360°=38\frac{3 \cdot 45°}{360°} = \frac{3}{8} van de hele pizza.
Zo werkt het ook met hoeken. Een hoek van 90° is 14 \frac{1}{4} van een cirkel, dus:

θ=90s=142πr=π2r\theta = 90^\circ \Rightarrow s = \frac{1}{4} \cdot 2\pi r = \frac{\pi}{2} r

Als de straal r=1 r = 1 is (de eenheidscirkel), dan wordt dit:

s=θ3602πs = \frac{\theta}{360^\circ} \cdot 2\pi
s=π180θs = \frac{\pi}{180^\circ} \cdot \theta

Deze booglengte s s is gelijk aan de hoek in radialen, er onstaat dus een evenredigverband/ verhouding tussen graden en radialen:

θrad=π180θdeg\theta_{\text{rad}} = \frac{\pi}{180^\circ} \cdot \theta_{\text{deg}} \cdot

2.4 Visualisatie

Gebruik hieronder de interactieve eenheidscirkel om te zien hoe de booglengte (in radialen) overeenkomt met de hoek (in graden).

  • De blauwe straal geeft de hoek aan.
  • De rode boog toont de bijbehorende radiaalwaarde.
  • De radiaalwaarde verandert live mee met de schuifregelaar.
Source
import numpy as np
import matplotlib.pyplot as plt
from ipywidgets import IntSlider, interact
from matplotlib.lines import Line2D




# Updatefunctie
def update(theta_deg):
    
    # Voorbereiding van figuur en plots
    plt.figure(figsize=(6, 6))
    plt.xlim(-1.2, 1.2)
    plt.ylim(-1.2, 1.2)
    plt.title("Eenheidscirkel met hoek θ")
    plt.grid(True)
    plt.axhline(0, color='black', linewidth=0.5)
    plt.axvline(0, color='black', linewidth=0.5)

    # Eenheidscirkel
    circle_theta = np.linspace(0, 2 * np.pi, 1000)
    circle_x = np.cos(circle_theta)
    circle_y = np.sin(circle_theta)
    plt.plot(circle_x, circle_y, 'lightgray')


    # Lijnen en objecten die we gaan updaten
    line_OP, = plt.plot([], [], 'r-', linewidth=2)
    arc_line, = plt.plot([], [], 'b--', linewidth=2)
    angle_arc, = plt.plot([], [], 'g-', linewidth=1.5)
    point_P, = plt.plot([], [], 'ro')

    # Teksten die we updaten
    text_P = plt.text(0, 0, '', fontsize=12, color='red')
    text_deg = plt.text(0, 0, '', fontsize=10, color='green', ha='center')
    text_rad = plt.text(0, 0, '', fontsize=10, color='blue', ha='center')

    # Extra vaste labels
    plt.text(1.05, 0, 'x', fontsize=12)
    plt.text(0, 1.05, 'y', fontsize=12)
    plt.text(-0.1, -0.1, 'O', fontsize=12)


    theta_rad = np.radians(theta_deg)
    x = np.cos(theta_rad)
    y = np.sin(theta_rad)

    # Update lijn OP
    line_OP.set_data([0, x], [0, y])

    # Update boog
    arc_theta = np.linspace(0, theta_rad, 300)
    arc_line.set_data(np.cos(arc_theta), np.sin(arc_theta))

    # Hoekboogje
    angle_arc_theta = np.linspace(0, theta_rad, 100)
    angle_arc_r = 0.3
    angle_arc.set_data(angle_arc_r * np.cos(angle_arc_theta),
                       angle_arc_r * np.sin(angle_arc_theta))

    # Punt P
    point_P.set_data([x], [y])
    text_P.set_position((x + 0.05 * np.sign(x), y + 0.05 * np.sign(y)))
    text_P.set_text("P")

    # Hoeklabels
    text_deg.set_position((0.35 * np.cos(theta_rad / 2), 0.35 * np.sin(theta_rad / 2)))
    text_deg.set_text(f"θ = {theta_deg}°")

    text_rad.set_position((0.5 * np.cos(theta_rad / 2), 0.5 * np.sin(theta_rad / 2)))
    text_rad.set_text(f"{round(theta_rad, 2)} rad")

    # Titel
    plt.title(f"θ = {theta_deg}° = {round(theta_rad, 2)} rad")

 

# Interactieve slider
interact(update, theta_deg=IntSlider(min=0, max=360, step=1, value=0, description="Hoek θ (°)"));
Loading...
Tabel: graden vs. radialen

De meest voorkomende hoeken zijn in de onsterstaande tabel weergeven.

Hoek in graden (°)Hoek in radialen (rad)
0
30°16π \frac{1}{6} \pi
45°14π \frac{1}{4} \pi
60°13π \frac{1}{3} \pi
90°12π \frac{1}{2} \pi
180°π \pi
270°32π \frac{3}{2} \pi
360°2π 2\pi

2.2 Omrekenen tussen graden en radialen

Rekenen met een verhoudingsfactor

We kunnen de relatie tussen graden en radialen als een formule opschrijven:

  • Van graden naar radialen:
θrad=θdegπ180\theta_{\text{rad}} = \theta_{\text{deg}} \cdot \frac{\pi}{180^\circ}
  • Van radialen naar graden:
θdeg=θrad180π\theta_{\text{deg}} = \theta_{\text{rad}} \cdot \frac{180^\circ}{\pi}

Zo kunnen we bijvoorbeeld berekenen dat: 1 radiaal ≈ 57,3°


Rekenen met een verhoudingstabel

Je kunt ook gebruik maken van een kruistabel:

Hele cirkel C C Deel van de cirkel s s
Graden360°90°
Radialen2π 2\pi ?

Kruisproduct:

360θ=2π90θ=2π90360=π2360^\circ \cdot \theta = 2\pi \cdot 90^\circ \Rightarrow \theta = \frac{2\pi \cdot 90^\circ}{360^\circ}= \frac{\pi}{2}

3. De eenheidscirkel en goniometrische functies

De eenheidscirkel is een cirkel met straal r=1r = 1 en het middelpunt in de oorsprong (0,0)(0,0).
Voor elke hoek θ\theta kun je een punt P(x,y)P(x, y) op de cirkel aangeven. Dat punt ligt op de rand van de cirkel, op een afstand van 1 vanaf het middelpunt.

We zijn geïnteresseerd in de vraag:

“Hoe hangen de coördinaten xx en yy van het punt PP samen met de hoek θ\theta?”


3.1 Van een hoek naar coördinaten

Teken een straal van het middelpunt (0,0)(0,0) naar het punt P(x,y)P(x,y) op de cirkel. Dit vormt een rechthoekige driehoek als je een lijn tekent van PP loodrecht naar de xx-as.

We kunnen deze driehoek analyseren met behulp van goniometrische verhoudingen:

  • Sinus (SOS):

    sin(θ)=overstaandeschuine zijde=y1y=sin(θ)\sin(\theta) = \frac{\text{overstaande}}{\text{schuine zijde}} = \frac{y}{1} \Rightarrow y = \sin(\theta)
  • Cosinus (CAS):

    cos(θ)=aanliggendeschuine zijde=x1x=cos(θ)\cos(\theta) = \frac{\text{aanliggende}}{\text{schuine zijde}} = \frac{x}{1} \Rightarrow x = \cos(\theta)
  • Tangens (TOA):

    tan(θ)=yx\tan(\theta) = \frac{y}{x}

Dus het punt PP op de eenheidscirkel kan worden uitgedrukt als:

P(x,y)=(cos(θ),sin(θ))P(x, y) = (\cos(\theta), \sin(\theta))

Visualisatie

In de grafiek hieronder zie je de eenheidscirkel.
Met de schuifregelaar kun je de hoek θ\theta aanpassen. Het bijbehorende punt PP verschuift over de cirkel, en je ziet hoe de x- en y-waarden veranderen.

  • De rode lijn volgt de xx-waarde: cos(θ)\cos(\theta)
  • De blauwe lijn volgt de yy-waarde: sin(θ)\sin(\theta)

Source
import numpy as np
import matplotlib.pyplot as plt
from ipywidgets import IntSlider, interact
import matplotlib.gridspec as gridspec

def plot_figure(theta):
    # Zet figuur opnieuw op bij elke update
    fig = plt.figure(figsize=(10, 12))
    gs = gridspec.GridSpec(3, 1, height_ratios=[2, 1, 1])
    ax_circle = plt.subplot(gs[0])
    ax_cos = plt.subplot(gs[1])
    ax_sin = plt.subplot(gs[2])
    plt.subplots_adjust(left=0.1, bottom=0.15, hspace=0.4)

    # Eenheidscirkel
    circle = plt.Circle((0, 0), 1, color='purple', fill=False)
    ax_circle.add_artist(circle)
    ax_circle.set_xlim(-1.2, 1.2)
    ax_circle.set_ylim(-1.2, 1.2)
    ax_circle.set_aspect('equal')
    ax_circle.grid(True)
    ax_circle.set_title("Eenheidscirkel en Rechthoekige Driehoek")

    # Assen door oorsprong
    ax_circle.spines['left'].set_position('zero')
    ax_circle.spines['bottom'].set_position('zero')
    ax_circle.spines['right'].set_color('none')
    ax_circle.spines['top'].set_color('none')
    ax_circle.xaxis.set_ticks([-1, 1])
    ax_circle.yaxis.set_ticks([-1, 1])
    ax_circle.text(1.05, 0, 'x', fontsize=12)
    ax_circle.text(0, 1.05, 'y', fontsize=12)
    ax_circle.text(-0.15, -0.15, 'O', fontsize=12)

    # Hoek en coördinaten
    theta_rad = np.deg2rad(theta)
    x = np.cos(theta_rad)
    y = np.sin(theta_rad)

    # Rechthoekige driehoek
    ax_circle.plot([0, x], [0, y], color='black')  # Hypotenusa
    ax_circle.plot([0, x], [0, 0], color='red')     # x-component
    ax_circle.plot([x, x], [0, y], color='blue')    # y-component
    ax_circle.plot(x, y, 'ko')                      # Punt P
    ax_circle.text(x + 0.05, y, f'P(', fontsize=10)
    ax_circle.text(x + 0.15, y, f'{x:.2f}', fontsize=10, color='red')
    ax_circle.text(x + 0.35, y, f', {y:.2f})', fontsize=10, color='blue')

    # Hoekboog
    arc_radius = 0.25
    arc_angle = np.linspace(0, theta_rad, 100)
    arc_x = arc_radius * np.cos(arc_angle)
    arc_y = arc_radius * np.sin(arc_angle)
    ax_circle.plot(arc_x, arc_y, 'gray')
    ax_circle.text(
        arc_radius * np.cos(theta_rad / 2),
        arc_radius * np.sin(theta_rad / 2),
        f'θ = {int(theta)}°',
        fontsize=10
    )

    # Cos/Sin-grafieken
    theta_deg = np.linspace(0, 360, 1000)
    theta_rad_all = np.deg2rad(theta_deg)
    cos_vals = np.cos(theta_rad_all)
    sin_vals = np.sin(theta_rad_all)

    ax_cos.plot(theta_deg, cos_vals, label='x(θ) = cos(θ)', color='red')
    ax_cos.plot(theta, np.cos(theta_rad), 'ko')
    ax_cos.text(theta + 5, np.cos(theta_rad), f'({int(theta)}°, {np.cos(theta_rad):.3f})', fontsize=9)

    ax_sin.plot(theta_deg, sin_vals, label='y(θ) = sin(θ)', color='blue')
    ax_sin.plot(theta, np.sin(theta_rad), 'ko')
    ax_sin.text(theta + 5, np.sin(theta_rad), f'({int(theta)}°, {np.sin(theta_rad):.3f})', fontsize=9)

    for ax, ylabel in zip([ax_cos, ax_sin], ['cos(θ)', 'sin(θ)']):
        ax.set_xlim(0, 360)
        ax.set_ylim(-1.2, 1.2)
        ax.grid(True)
        ax.axhline(0, color='black', linewidth=0.8)
        ax.axvline(0, color='black', linewidth=0.8)
        ax.set_ylabel(ylabel)
        ax.set_xlabel('θ (graden)')
        ax.spines['left'].set_position('zero')
        ax.spines['bottom'].set_position('zero')
        ax.spines['right'].set_color('none')
        ax.spines['top'].set_color('none')
        ax.set_xticks([0, 180, 360])
        ax.set_yticks([-1, 1])
        ax.legend()

    plt.show()

# Interactieve slider
interact(plot_figure, theta=IntSlider(min=0, max=360, step=1, value=60, description='θ (graden)'));
Loading...

3.2 Samenhang van eenheidscirkel en sinusgolf

Wanneer we een volledige omwenteling maken (van 00^\circ tot 360360^\circ), verandert het teken van sin(θ)\sin(\theta) en cos(θ)\cos(\theta) afhankelijk van het kwadrant waarin punt PP ligt:

Kwadrantθ\theta-bereikTeken van cos(θ)\cos(\theta)Teken van sin(θ)\sin(\theta)Coördinaat P(x,y)P(x, y)
1e kwadrant00^\circ9090^\circ++(+,+)(+,+)
2e kwadrant9090^\circ180180^\circ+(,+)(–,+)
3e kwadrant180180^\circ270270^\circ(,)(–,–)
4e kwadrant270270^\circ360360^\circ+(+,)(+,–)

De eenheidscirkel helpt je om goniometrische functies beter te begrijpen. Elk punt op de cirkel komt overeen met:

  • x=cos(θ)x = \cos(\theta)
  • y=sin(θ)y = \sin(\theta)

Zo zie je dus dat een cirkel beweging in verband staat met een golf beweging.

4. Periodieke functies en hun eigenschappen

Goniometrische functies zoals sin(x)\sin(x) en cos(x)\cos(x) ontstaan uit de eenheidscirkel. Ze zien eruit als golven: ze herhalen zich, hebben pieken en dalen, en bewegen rond een gemiddelde lijn. Dit noemen we periodieke functies. In dit hoofdstuk leer je hoe deze grafieken worden gevormd én hoe je aan de hand van de grafiek het functievoorschrift kunt bepalen.


4.1 Transformaties van de standaardfunctie y=sin(x)y = \sin(x)

De standaard sinusfunctie y=sin(x)y = \sin(x) is een golffunctie met de volgende eigenschappen:

  • Evenwichtsstand: y=0y = 0
  • Amplitude: 1
  • Periode: 2π2\pi
  • Startpunt: (0,0)(0, 0)

We kunnen deze functie aanpassen met vier parameters: aa, bb, cc, en dd:

y=a+bsin(c(xd))y = a + b \cdot \sin(c(x - d))

Elke parameter heeft een specifieke invloed. Hieronder leggen we precies uit wat elke transformatie doet én waarom.


4.1.1 De evenwichtsstand — parameter aa

De evenwichtsstand is het horizontale middelpunt tussen de toppen en dalen van de golf.
Bij y=sin(x)y = \sin(x) ligt deze op de xx-as: y=0y = 0.

Als we de hele grafiek omhoog of omlaag willen verschuiven, doen we een verticale translatie:

  • Omhoog: y=sin(x)+ay = \sin(x) + a
  • Omlaag: y=sin(x)ay = \sin(x) - a

We voegen simpelweg aa toe aan elke yy-waarde van de grafiek.
Dit verandert niets aan de vorm of periode van de golf, enkel de positie op de yy-as.

Voorbeeldtransformatie:

f(x)verticale translatief(x)+af(x) \xrightarrow{\text{verticale translatie}} f(x) + a

Resultaat:

y=a+sin(x)y = a + \sin(x)

🔎 In de figuur zie je y=sin(x)y = \sin(x) (grijs) en y=a+sin(x)y = a + \sin(x) (blauw).
De verticale pijl geeft de verschuiving van elk punt met aa aan.


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

# Data
x = np.linspace(-np.pi, 2*np.pi, 500)

def plot_translatie(a):
    plt.figure(figsize=(10, 4))
    plt.xlim(-np.pi, 2*np.pi)
    plt.ylim(-3.5, 3.5)
    plt.title("Verticale translatie: y = sin(x) → y = a + sin(x)")
    plt.xlabel("x")
    plt.ylabel("y")

    # Assen
    ax = plt.gca()
    ax.spines['bottom'].set_position('zero')
    ax.spines['left'].set_position('zero')
    ax.spines['top'].set_visible(False)
    ax.spines['right'].set_visible(False)

    # Lijnen
    plt.axhline(0, color='gray', linestyle='--', linewidth=1)
    plt.axhline(a, color='blue', linestyle='--', linewidth=1)
    plt.plot(x, np.sin(x), color='gray', alpha=0.9, linewidth=1.5, label="y = sin(x)")
    plt.plot(x, a + np.sin(x), color='blue', linewidth=2, label="y = a + sin(x)")

    # Pijltjes tekenen
    for xi in np.linspace(-np.pi, 2*np.pi, 9):
        y1 = np.sin(xi)
        y2 = a + y1
        plt.arrow(xi, y1, 0, y2 - y1, head_width=0.1, head_length=0.1, fc='red', ec='red')

    plt.legend()
    plt.grid(True)
    plt.show()

# Slider toevoegen
interact(plot_translatie, a=FloatSlider(min=-2.0, max=2.0, step=0.1, value=0.0, description='a'));
Loading...

4.1.2 De amplitude — parameter bb

De amplitude is de maximale afwijking vanaf de evenwichtsstand.
Bij y=sin(x)y = \sin(x) is de amplitude 1.

Als we de pieken en dalen hoger of lager willen maken, vermenigvuldigen we de functie met bb:

  • y=bsin(x)y = b \cdot \sin(x)

Hiermee doen we een vermenigvuldiging ten opzichte van de xx-as.
Elke yy-waarde wordt bb-maal zo groot — dus:

  • Positieve toppen worden bb
  • Negatieve dalen worden b-b

Voorbeeldtransformatie:

f(x)vermenigvuldiging t.o.v. x-asbf(x)f(x) \xrightarrow{\text{vermenigvuldiging t.o.v. } x\text{-as}} b \cdot f(x)

Resultaat:

y=bsin(x)y = b \cdot \sin(x)

🔎 In de grafiek zie je y=sin(x)y = \sin(x) (grijs) en y=bsin(x)y = b \cdot \sin(x) (blauw).
Merk op hoe er bij een negatieve waarde een spiegeling plaatsvind.


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

x = np.linspace(-np.pi, 2*np.pi, 500)

def plot_amplitude(b):
    plt.figure(figsize=(10, 4))
    plt.xlim(-np.pi, 2*np.pi)
    plt.ylim(-2.5, 2.5)
    plt.title("Amplitude: y = sin(x) → y = b·sin(x)")
    plt.xlabel("x")
    plt.ylabel("y")

    ax = plt.gca()
    ax.spines['bottom'].set_position('zero')
    ax.spines['left'].set_position('zero')
    ax.spines['top'].set_visible(False)
    ax.spines['right'].set_visible(False)

    plt.plot(x, np.sin(x), color='gray', alpha=0.6, label="y = sin(x)")
    plt.plot(x, b * np.sin(x), color='blue', label="y = b·sin(x)")

    for xi in np.linspace(-np.pi, 2*np.pi, 9):
        y1 = np.sin(xi)
        y2 = b * y1
        plt.arrow(xi, y1, 0, y2 - y1, head_width=0.1, head_length=0.1, fc='red', ec='red')

    plt.legend()
    plt.grid(True)
    plt.show()

interact(plot_amplitude, b=FloatSlider(min=-2.0, max=2.0, step=0.1, value=1.0, description='b'));
Loading...

4.1.3 De hoeksnelheid en periode — parameter cc

De periode is de lengte van één volledige golf.
Voor y=sin(x)y = \sin(x) is deze standaard T=2πT = 2\pi.

Als we de periode willen veranderen, moeten we een vermenigvuldiging t.o.v. de yy-as uitvoeren.
In tegenstelling tot vermenigvuldiging t.o.v. de xx-as waarbij we yy vermengivuldigen met de vergroting, gaan we nu juist xx delen met de vergroting.

Bijvoorbeeld: Als ik een periode van 1 wil vermenigvuldig ik de periode eigenlijk met 12π\frac{1}{2\pi}, als ik een een periode TT wil moet ik dus vermenigvuldigen met T2π\frac{T}{2\pi}.

  • Een nieuwe periode TT vereist een schaalverandering met factor T2π\frac{T}{2\pi}
  • Dus: x2πTxx \rightarrow \frac{2\pi}{T}x

Voorbeeldtransformatie:

f(x)Vermenigvuldiging t.o.v. de y-asf(1T2πx)f(x) \xrightarrow{\text{Vermenigvuldiging t.o.v. de y-as}} f(\frac{1}{\frac{T}{2\pi}} \cdot x)

Resultaat:

y=sin(1T2πx)y = \sin(\frac{1}{\frac{T}{2\pi}} \cdot x)

De nieuwe functie wordt dan:

y=sin(2πTx)=sin(cx)y = \sin\left( \frac{2\pi}{T} \cdot x \right) = \sin(c \cdot x)

waar c=2πTc = \frac{2\pi}{T} de hoeksnelheid is: het aantal radialen per eenheid tijd.

🔎 In de figuur zie je y=sin(x)y = \sin(x) (grijs) en y=sin(cx)y = \sin(c \cdot x) (blauw).
De blauwe golf heeft een kleinere of grotere periode dan de standaardgrafiek.
Er zijn 6 horizontale pijlen zichtbaar tussen corresponderende punten.


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

x = np.linspace(-3*np.pi, 5*np.pi, 1000)

def plot_periode(c):
    plt.figure(figsize=(10, 4))
    plt.xlim(-3*np.pi, 5*np.pi)
    plt.ylim(-1.5, 1.5)
    plt.title("Periode: y = sin(x) → y = sin(c·x)")
    plt.xlabel("x")
    plt.ylabel("y")

    ax = plt.gca()
    ax.spines['bottom'].set_position('zero')
    ax.spines['left'].set_position('zero')
    ax.spines['top'].set_visible(False)
    ax.spines['right'].set_visible(False)

    plt.plot(x, np.sin(x), color='gray', alpha=0.6, label="y = sin(x)")
    plt.plot(x, np.sin(c * x), color='blue', label="y = sin(c·x)")

    x_samples = np.linspace(-0.5*np.pi, 0.5*np.pi, 6)
    for xi in x_samples:
        y = np.sin(xi)
        x_orig = xi / c
        dx = xi - x_orig
        plt.arrow(x_orig, y, dx, 0, head_width=0.05, head_length=0.2, fc='red', ec='red')

    plt.legend()
    plt.grid(True)
    plt.show()

interact(plot_periode, c=FloatSlider(min=0.25, max=2.0, step=0.05, value=1.0, description='c'));
Loading...

4.1.4 De faseverschuiving — parameter dd

De faseverschuiving bepaalt waar de golf start op de xx-as.

Bij y=sin(x)y = \sin(x) begint de golf bij x=0x = 0 en bij y=cos(x)y = \cos(x) begint de golf bij x=1x = 1. Als we willen dat de golf start bij x=dx = d, dan moeten we de invoer verschuiven naar rechts met dd:

  • y=sin(xd)y = \sin(x - d)

BIj verticale tranlaties tellen we de verschuiving op ++ bij het yy-coordinaat. Bij horizontale translaties trekken we de verschuiving er af xdx - d

  • xdx - d: naar rechts met dd
  • x+dx + d: naar links met dd

Voorbeeldtransformatie:

f(x)horizontale verschuivingf(xd)f(x) \xrightarrow{\text{horizontale verschuiving}} f(x - d)

Resultaat:

y=sin(xd)y = \sin(x - d)

🔎 In de grafiek zie je y=sin(x)y = \sin(x) (grijs) en y=sin(xd)y = \sin(x - d) (blauw).
Een horizontale pijl toont hoe het startpunt verschuift van x=0x = 0 naar x=dx = d.


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

x = np.linspace(-2*np.pi, 4*np.pi, 1000)

def plot_horizontale_translatie(d):
    plt.figure(figsize=(10, 4))
    plt.xlim(-2*np.pi, 4*np.pi)
    plt.ylim(-1.5, 1.5)
    plt.title("Horizontale translatie: y = sin(x) → y = sin(x - d)")
    plt.xlabel("x")
    plt.ylabel("y")

    ax = plt.gca()
    ax.spines['bottom'].set_position('zero')
    ax.spines['left'].set_position('zero')
    ax.spines['top'].set_visible(False)
    ax.spines['right'].set_visible(False)

    plt.plot(x, np.sin(x), color='gray', alpha=0.6, label="y = sin(x)")
    plt.plot(x, np.sin(x - d), color='blue', label="y = sin(x - d)")
    plt.arrow(0, 0, d, 0, head_width=0.1, head_length=0.2, fc='red', ec='red')

    plt.legend()
    plt.grid(True)
    plt.show()

interact(plot_horizontale_translatie, d=FloatSlider(min=-5.0, max=5.0, step=0.1, value=0.0, description='d'));
Loading...

4.1.5 De complete transformatie

Door alle parameters tegelijk toe te passen, ontstaat de algemene vorm:

y=a+bsin(c(xd))y = a + b \cdot \sin(c(x - d))

🔎 In de grafiek hieronder zie je y=sin(x)y = \sin(x) (grijs) en y=a+bsin(c(xd))y = a + b \cdot \sin(c(x - d)) (blauw).
Je herkent de effecten van aa, bb, cc en dd afzonderlijk terug in deze totale transformatie.

4.2 Van grafiek naar functievoorschrift

Nu je weet wat elke parameter doet, kun je ook van een grafiek terug naar de formule.

Stappenplan:

  1. Evenwichtsstand aa
    Bepaal de horizontale lijn tussen pieken en dalen:

    a=ymax+ymin2a = \frac{y_\text{max} + y_\text{min}}{2}
  2. Amplitude bb
    Bepaal de afstand van evenwicht naar piek:

    b=ymaxymin2b = \frac{y_\text{max} - y_\text{min}}{2}
  3. Periode TT en hoeksnelheid cc
    Meet de afstand tussen twee opeenvolgende toppen of dalen:

    T=xtop2xtop1,c=2πTT = x_{\text{top2}} - x_{\text{top1}}, \quad c = \frac{2\pi}{T}
  4. Faseverschuiving dd
    Bepaal waar de karakteristieke startpositie zich bevindt (bijv. start van stijgende sinus):

    d=horizontale afstand tot startpuntd = \text{horizontale afstand tot startpunt}

Voorbeeld:
Stel je leest uit een grafiek:

  • ymax=3y_{\text{max}} = 3, ymin=1y_{\text{min}} = -1
  • De toppen liggen op x=1x = 1 en x=5x = 5
  • Het stijgend snijpunt met de evenwichtslijn ligt op x=0.5x = 0.5

Dan krijg je:

  • a=(3+(1))/2=1a = (3 + (-1)) / 2 = 1
  • b=(3(1))/2=2b = (3 - (-1)) / 2 = 2
  • T=51=4T = 5 - 1 = 4, dus c=2π4=π2c = \frac{2\pi}{4} = \frac{\pi}{2}
  • d=0.5d = 0.5

Dus de functie is:

y=1+2sin(π2(x0.5))y = 1 + 2 \cdot \sin\left(\frac{\pi}{2}(x - 0.5)\right)

Met deze kennis kun je nu zowel een functie tekenen als een functievoorschrift afleiden uit een grafiek!

5. Oplossen van goniometrische vergelijkingen en exacte waarden van sin(θ)\sin(\theta) en cos(θ)\cos(\theta)

Bij de vergelijking x2=9x^2 = 9 levert de balansmethode x=9=3x = \sqrt{9} = 3 op, maar ook x=3x = -3 is een oplossing.
Dus:

x1=9,x2=x1x_1 = \sqrt{9}, \quad x_2 = -x_1

Dit komt omdat er een symetrie as aanwezig is in x=0 x=0 bij de functie f(x)=x2 f(x)=x^2 . Bij de goniometrische sin(θ)=c\sin(\theta) =c en cos(θ)=c\cos(\theta) = c met c c een constante, is er ook sprake van meerdere oplossingen door symetrie. Dit gaan we per functie uitzoeken.

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

def plot_x2_symmetry(c):
    x_vals = np.linspace(-4, 4, 1000)
    y_vals = x_vals**2

    fig, ax = plt.subplots(figsize=(10, 6))
    ax.set_xlim(-4, 4)
    ax.set_ylim(-1, 17)
    ax.axhline(0, color='black')
    ax.axvline(0, color='black')

    # Plot parabool
    ax.plot(x_vals, y_vals, color='blue', label=r'$f(x) = x^2$')

    # Plot horizontale lijn y = c
    ax.axhline(c, color='red', linestyle='--', label=rf'$y = {c:.2f}$')

    if c >= 0:
        x1 = np.sqrt(c)
        x2 = -np.sqrt(c)

        # Visualisatie van de snijpunten
        ax.plot([x1, x2], [c, c], 'ko')  # punten op de parabool
        ax.plot([x1, x1], [0, c], color='green', linestyle='--')
        ax.plot([x2, x2], [0, c], color='orange', linestyle='--')
        ax.plot([x2, x1], [c, c], 'k--', lw=1)

        ax.text(x1 + 0.1, c + 0.3, rf"$x_1 = {x1:.2f}$", color='green')
        ax.text(x2 - 0.9, c + 0.3, rf"$x_2 = {x2:.2f}$", color='orange')
    
    else:
        ax.text(0, 1, "Geen oplossing voor $x^2 = c$ als $c < 0$", color='red', ha='center', fontsize=12)

    ax.set_title(r"Symmetrie in de vergelijking $x^2 = c$")
    ax.set_xlabel("x")
    ax.set_ylabel("y")
    ax.grid(True)
    ax.legend()
    plt.show()

# Interactieve slider
interact(plot_x2_symmetry, c=FloatSlider(value=4.0, min=-1.0, max=16.0, step=0.1, description='c'));
Loading...

5.1 Oplossen van sin(x)=c\sin(x) = c

Stel dat je de vergelijking sin(x)=12\sin(x) = \frac{1}{2} moet oplossen.

We starten met het idee van de eenheidscirkel.
De sinus van een hoek θ\theta is de yy-coördinaat van het bijbehorende punt op de eenheidscirkel.

Dus we stellen de vraag:

Voor welke hoek θ\theta is sin(θ)=12\sin(\theta) = \frac{1}{2}?

Controle via de eenheidscirkel

In de interactieve figuur zie je een horizontale lijn op y=12y = \frac{1}{2} en twee snijpunten met de eenheidscirkel:

  • Het eerste snijpunt levert een scherpe hoek op:

    θ1=arcsin(12)=30=16π\theta_1 = \arcsin\left(\frac{1}{2}\right) = 30^\circ = \frac{1}{6}\pi
  • Het tweede snijpunt ligt in het tweede kwadrant. De hoek bij dit snijpunt is stomp, maar samen met de scherpe hoek vormt deze een halve cirkel. Door symetrie in de x-as kunnen zien we dat θ2 \theta_2 eigenlijk de stompe hoek is in het linker figuur en θ1 \theta_1 eigenlijk de scherpe hoek is in het rechter figuur. We kunnen dus stellen dat :

    θ1+θ2=180θ2=180θ1=18030=150\theta_1 + \theta_2 = 180^\circ \quad \Rightarrow \quad \theta_2 = 180^\circ - \theta_1 = 180^\circ - 30^\circ = 150^\circ

Met het schuiven zie je dat dit klopt voor elke waarde van c dus,voor elke hoek θ \theta klop dus dat:

sin(θ)=sin(180θ)\sin(\theta) = \sin(180^\circ - \theta)
Source
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.patches import Arc
from ipywidgets import interact, FloatSlider

# Tekenfunctie
def draw_unit_circle_sin(c):
    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 6))
    
    def configure_axes(ax):
        ax.set_aspect('equal')
        ax.set_xlim(-1.2, 1.2)
        ax.set_ylim(-1.2, 1.2)
        ax.axhline(0, color='black', lw=1)
        ax.axvline(0, color='black', lw=1)
        ax.set_xticks([-1, 0, 1])
        ax.set_yticks([-1, 0, 1])
        ax.set_title("Eenheidscirkel")

    for ax in (ax1, ax2):
        configure_axes(ax)
        # Paarse eenheidscirkel
        t = np.linspace(0, 2*np.pi, 300)
        ax.plot(np.cos(t), np.sin(t), color='purple')
        ax.axhline(c, color='gray', linestyle='--')

    # Eerste oplossing θ₁ = arcsin(c)
    theta1 = np.arcsin(c)
    x1, y1 = np.cos(theta1), np.sin(theta1)
    ax1.plot([0, x1], [0, y1], color='black')
    arc1 = Arc((0, 0), 0.4, 0.4, angle=0, theta1=0, theta2=np.degrees(theta1), color='black')
    ax1.add_patch(arc1)
    label1 = theta1 / 2
    ax1.text(0.5 * np.cos(label1), 0.5 * np.sin(label1), f'θ₁ = {np.degrees(theta1):.1f}°', ha='center')

    # Tweede oplossing θ₂ = π - θ₁
    theta2 = np.pi - theta1
    x2, y2 = np.cos(theta2), np.sin(theta2)
    ax2.plot([0, x2], [0, y2], color='black')
    arc2 = Arc((0, 0), 0.4, 0.4, angle=0, theta1=0, theta2=np.degrees(theta2), color='black')
    ax2.add_patch(arc2)
    label2 = theta2 / 2
    ax2.text(0.5 * np.cos(label2), 0.5 * np.sin(label2), f'θ₂ = {np.degrees(theta2):.1f}°', ha='center')

    ax1.text(-1.1, -1.1, r"$\sin(\theta) = y = $" + f"{y1:.2f}", fontsize=11)
    ax2.text(-1.1, -1.1, r"$\sin(\pi - \theta) = y = $" + f"{y2:.2f}", fontsize=11)

    plt.show()

# Interactie
interact(draw_unit_circle_sin, c=FloatSlider(min=-1.0, max=1.0, step=0.01, value=0.5, description='c'));
Loading...

Controle via de grafiek van sin(x)\sin(x)

In de interactieve sinusgrafiek zie je de horizontale lijn y=12y = \frac{1}{2} snijden met de sinuscurve op twee plekken:

  • Het eerste snijpunt bij x1=π6x_1 = \frac{\pi}{6}
  • Het tweede snijpunt symmetrisch ten opzichte van π2\frac{\pi}{2}:
    x2=πx1=56πx_2 = \pi - x_1 = \frac{5}{6}\pi

Deze symmetrie rond x=π2x = \frac{\pi}{2} is typisch voor de sinusfunctie. We kunnen weer hetzelfde stellen als bij de eenheidcirkel:

sin(θ)=sin(πθ)\sin(\theta) = \sin(\pi - \theta)

Voor het oplossen van sin(x)=c\sin(x) = c van de eerste golf gebruiken we dus: Uit de symmetrie van de sinusfunctie blijkt:

x1=arcsin(c),x2=πarcsin(c)x_1 = \arcsin(c), \quad x_2 = \pi - \arcsin(c)

Netzoals hoe je x2=cx^2 = c oplost als:

x1=9,x2=x1x_1 = \sqrt{9}, \quad x_2 = -x_1
Source
import numpy as np
import matplotlib.pyplot as plt
from ipywidgets import interact, FloatSlider

def plot_sin_symmetry(c):
    # Setup x-range
    x_vals = np.linspace(-0.5 * np.pi, 1.5 * np.pi, 1000)
    y_vals = np.sin(x_vals)

    # Plot setup
    fig, ax = plt.subplots(figsize=(12, 6))
    ax.set_xlim(-0.5 * np.pi, 1.5 * np.pi)
    ax.set_ylim(-1.2, 1.2)
    ax.axhline(0, color='black', lw=1)
    ax.axvline(0, color='black', lw=1)
    ax.set_xticks([n * np.pi / 4 for n in range(-2, 7)])
    ax.set_xticklabels(
        [r"$-\frac{\pi}{2}$", r"$-\frac{\pi}{4}$", "0", r"$\frac{\pi}{4}$", r"$\frac{\pi}{2}$",
         r"$\frac{3\pi}{4}$", r"$\pi$", r"$\frac{5\pi}{4}$", r"$\frac{3\pi}{2}$"]
    )
    ax.set_yticks([-1, -0.5, 0, 0.5, 1])
    ax.text(1.5 * np.pi, -0.05, 'x', ha='right', va='top')
    ax.text(-0.05, 1.2, 'y', ha='right', va='top')

    ax.plot(x_vals, y_vals, color='blue', label=r'$\sin(x)$')
    ax.axhline(c, color='blue', linestyle='--', label=rf'$y = {c:.2f}$')
    ax.axvline(np.pi / 2, color='black', linestyle='--', label=r'$x = \frac{\pi}{2}$')

    if abs(c) <= 1:
        theta = np.arcsin(c)
        x1 = theta
        x2 = np.pi - theta

        ax.plot([x1, x1], [0, c], color='green')
        ax.plot([x2, x2], [0, c], color='orange')
        ax.plot([0, x1], [c, c], color='green')
        ax.plot([x2, np.pi], [c, c], color='green')
        ax.plot([x2, np.pi], [0, 0], color='green')
        ax.plot([0, x2], [0, 0], color='orange')
        ax.plot([x1], [c], 'ko')
        ax.plot([x2], [c], 'ko')
        ax.text(x1 + 0.05, c / 2, rf"$x_1 = {x1:.2f}$", color='green')
        ax.text(x2 + 0.05, c / 2, rf"$x_2 = {x2:.2f}$", color='orange')

    ax.set_title(r'Interactieve visualisatie van $\sin(x) = \sin(\pi - x)$')
    ax.set_xlabel('x')
    ax.set_ylabel('y')
    ax.grid(True)
    ax.legend()
    plt.show()

interact(plot_sin_symmetry, c=FloatSlider(value=0.5, min=-1.0, max=1.0, step=0.01))
Loading...

Periodiciteit

De sinusfunctie is periodiek (herhalend) met een periode van 2π2\pi.
Dus dezelfde waarden komen telkens terug bij een verschuiving van 2π2\pi.

In de interactieve grafiek zie je dat:

  • op x12πx_1 - 2\pi
  • en op x1+2πx_1 + 2\pi

Daarom geldt algemeen:

x1,k=x1+k2πofx2,k=x2+k2π,waarbij kZx_{1,k} = x_1 + k \cdot 2\pi \quad \text{of} \quad x_{2,k} = x_2 + k \cdot 2\pi, \quad \text{waarbij } k \in \mathbb{Z} \cdot

met Z \mathbb{Z} bedoelen we dat k k een positief geheel getal, negatief geheel getal of gelijk aan 0 is.

5.2 Oplossen van cos(x)=c\cos(x) = c

Stel dat je de vergelijking cos(x)=12\cos(x) = \frac{1}{2} moet oplossen.

We starten opnieuw met het idee van de eenheidscirkel.
De cosinus van een hoek θ\theta is de xx-coördinaat van het bijbehorende punt op de eenheidscirkel.

Dus we stellen de vraag:

Voor welke hoek θ\theta is het xx-coördinaat gelijk aan 12\frac{1}{2}?


Controle via de eenheidscirkel

In de interactieve figuur zie je een verticale lijn op x=12x = \frac{1}{2} die de eenheidscirkel op twee punten snijdt:

  • Het eerste snijpunt levert een scherpe hoek op in het eerste kwadrant:

    θ1=arccos(12)=60=13π\theta_1 = \arccos\left(\frac{1}{2}\right) = 60^\circ = \frac{1}{3}\pi
  • Het tweede snijpunt ligt in het vierde kwadrant en is de gespiegelde hoek ten opzichte van de xx-as. Deze hoek noemen we:

    θ2=θ1=60=13π\theta_2 = -\theta_1 = -60^\circ = -\frac{1}{3}\pi

In de interactieve figuur zie je duidelijk dat deze twee hoeken een xx-coördinaat van 12\frac{1}{2} hebben.
Dus geldt algemeen:

cos(θ)=cos(θ)\cos(\theta) = \cos(-\theta)

Source
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.patches import Arc
from ipywidgets import interact, FloatSlider

# Tekenfunctie
def draw_unit_circle_cos(c):
    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 6))
    
    def configure_axes(ax):
        ax.set_aspect('equal')
        ax.set_xlim(-1.2, 1.2)
        ax.set_ylim(-1.2, 1.2)
        ax.axhline(0, color='black', lw=1)
        ax.axvline(0, color='black', lw=1)
        ax.set_xticks([-1, 0, 1])
        ax.set_yticks([-1, 0, 1])
        ax.set_title("Eenheidscirkel")

    for ax in (ax1, ax2):
        configure_axes(ax)
        t = np.linspace(0, 2*np.pi, 300)
        ax.plot(np.cos(t), np.sin(t), color='purple')
        ax.axvline(c, color='gray', linestyle='--')

    # Eerste oplossing θ₁ = arccos(c)
    theta1 = np.arccos(c)
    x1, y1 = np.cos(theta1), np.sin(theta1)
    ax1.plot([0, x1], [0, y1], color='black')
    arc1 = Arc((0, 0), 0.4, 0.4, angle=0, theta1=0, theta2=np.degrees(theta1), color='black')
    ax1.add_patch(arc1)
    label1 = theta1 / 2
    ax1.text(0.5 * np.cos(label1), 0.5 * np.sin(label1), f'θ₁ = {np.degrees(theta1):.1f}°', ha='center')
    ax1.text(x1 + 0.05, y1, f'({x1:.2f}, {y1:.2f})', fontsize=9)

    # Tweede oplossing θ₂ = -θ₁
    theta2 = -theta1
    x2, y2 = np.cos(theta2), np.sin(theta2)
    ax2.plot([0, x2], [0, y2], color='black')
    arc2 = Arc((0, 0), 0.4, 0.4, angle=0, theta1=0, theta2=np.degrees(theta2), color='black')
    ax2.add_patch(arc2)
    label2 = theta2 / 2
    ax2.text(0.5 * np.cos(label2), 0.5 * np.sin(label2), f'θ₂ = {np.degrees(theta2):.1f}°', ha='center')
    ax2.text(x2 + 0.05, y2, f'({x2:.2f}, {y2:.2f})', fontsize=9)

    ax1.text(-1.1, -1.1, r"$\cos(\theta) = x = $" + f"{x1:.2f}", fontsize=11)
    ax2.text(-1.1, -1.1, r"$\cos(-\theta) = x = $" + f"{x2:.2f}", fontsize=11)

    plt.show()

# Interactie
interact(draw_unit_circle_cos, c=FloatSlider(min=-1.0, max=1.0, step=0.01, value=0.5, description='c'));
Loading...

Controle via de grafiek van cos(x)\cos(x)

In de interactieve grafiek zie je de horizontale lijn y=12y = \frac{1}{2} snijden met de cosinusgrafiek op twee plekken:

  • Het eerste snijpunt bij x1=π3x_1 = \frac{\pi}{3}
  • Het tweede snijpunt bij x2=π3x_2 = -\frac{\pi}{3}

Deze symmetrie rond de yy-as is typerend voor de cosinusfunctie.

We kunnen stellen:

cos(x)=cos(x)\cos(x) = \cos(-x)

Dus als x1=arccos(c)x_1 = \arccos(c), dan is de tweede oplossing x2=x1x_2 = -x_1.

Periodiciteit

De cosinusfunctie is periodiek met een periode van 2π2\pi.

Daarom geldt algemeen:

x1,k=x1+k2πenx2,k=x2+k2π,waarbij kZx_{1,k} = x_1 + k \cdot 2\pi \quad \text{en} \quad x_{2,k} = x_2 + k \cdot 2\pi, \quad \text{waarbij } k \in \mathbb{Z}
Source
import numpy as np
import matplotlib.pyplot as plt
from ipywidgets import interact, FloatSlider

def plot_cos_symmetry(c):
    # Setup x-range
    x_vals = np.linspace(-1.5 * np.pi, 1.5 * np.pi, 1000)
    y_vals = np.cos(x_vals)

    # Plot setup
    fig, ax = plt.subplots(figsize=(12, 6))
    ax.set_xlim(-1.5 * np.pi, 1.5 * np.pi)
    ax.set_ylim(-1.2, 1.2)
    ax.axhline(0, color='black', lw=1)
    ax.axvline(0, color='black', lw=1)
    ax.set_xticks([n * np.pi / 2 for n in range(-3, 4)])
    ax.set_xticklabels(
        [r"$-\frac{3\pi}{2}$", r"$-\pi$", r"$-\frac{\pi}{2}$", "0", r"$\frac{\pi}{2}$", r"$\pi$", r"$\frac{3\pi}{2}$"]
    )
    ax.set_yticks([-1, -0.5, 0, 0.5, 1])
    ax.text(1.5 * np.pi, -0.05, 'x', ha='right', va='top')
    ax.text(-0.05, 1.2, 'y', ha='right', va='top')

    ax.plot(x_vals, y_vals, color='blue', label=r'$\cos(x)$')
    ax.axhline(c, color='blue', linestyle='--', label=rf'$y = {c:.2f}$')
    ax.axvline(0, color='black', linestyle='--', label=r'$x = 0$')

    if abs(c) <= 1:
        theta = np.arccos(c)
        x1, x2 = theta, -theta

        ax.plot([x1, x1], [0, c], color='green')
        ax.plot([x2, x2], [0, c], color='orange')
        ax.plot([0, x1], [c, c], color='green')
        ax.plot([x2, 0], [c, c], color='orange')
        ax.plot([x1], [c], 'ko')
        ax.plot([x2], [c], 'ko')
        ax.text(x1 + 0.1, c + 0.05, rf"$x_1 = {x1:.2f}$", color='green')
        ax.text(x2 - 0.1, c + 0.05, rf"$x_2 = {x2:.2f}$", color='orange')

    ax.set_title(r'Interactieve visualisatie van $\cos(x) = \cos(-x)$')
    ax.set_xlabel('x')
    ax.set_ylabel('y')
    ax.grid(True)
    ax.legend()
    plt.show()

interact(plot_cos_symmetry, c=FloatSlider(value=0.5, min=-1.0, max=1.0, step=0.01))
Loading...

5.3 Algemeen stappenplan voor het oplossen van goniometrische vergelijkingen

Het oplossen van sin(x)=c\sin(x) = c en cos(x)=c\cos(x) = c gebeurt altijd in dezelfde drie stappen:


Voor sin(x)=c\sin(x) = c

  1. Gebruik de inverse sinus om de eerste oplossing te vinden:

    x1=arcsin(c)x_1 = \arcsin(c)
  2. Gebruik symmetrie om de tweede oplossing te bepalen:

    x2=πx1x_2 = \pi - x_1

    Dit volgt uit het feit dat:

    sin(x)=sin(πx)\sin(x) = \sin(\pi - x)

💡 Denk aan de eenheidscirkel: arcsin(c)\arcsin(c) geeft de scherpe hoek in het eerste kwadrant, en πx1\pi - x_1 de bijbehorende stompe hoek in het tweede kwadrant.

  1. Gebruik periodiciteit om alle oplossingen te noteren:
    x=x1+2kπofx=x2+2kπ,met kZx = x_1 + 2k\pi \quad \text{of} \quad x = x_2 + 2k\pi, \quad \text{met } k \in \mathbb{Z}

waarbij kZk \in \mathbb{Z} (dus: k=0,±1,±2,k = 0, \pm1, \pm2, \dots)


Voor cos(x)=c\cos(x) = c

  1. Gebruik de inverse cosinus om de eerste oplossing te vinden:

    x1=arccos(c)x_1 = \arccos(c)
  2. Gebruik symmetrie om de tweede oplossing te bepalen:

    x2=x1x_2 = -x_1

    Dit volgt uit het feit dat:

    cos(x)=cos(x)\cos(x) = \cos(-x)

💡 Denk aan de eenheidscirkel: arccos(c)\arccos(c) geeft de hoek in het eerste kwadrant, en x1-x_1 de spiegeling in de x-as naar het vierde kwadrant.

  1. Gebruik periodiciteit om alle oplossingen te noteren:
    x=x1+2kπofx=x2+2kπ,met kZx = x_1 + 2k\pi \quad \text{of} \quad x = x_2 + 2k\pi, \quad \text{met } k \in \mathbb{Z}

waarbij kZk \in \mathbb{Z} (dus: k=0,±1,±2,k = 0, \pm1, \pm2, \dots)


Opvallende overeenkomst

Bij beide vergelijkingen gebruik je steeds dezelfde stappen:

  • Stap 1: trek arcsin(c)\arcsin(c) of arccos(c)\arccos(c)
  • Stap 2: gebruik symmetrie — bij sinus: πx1\pi - x_1, bij cosinus: x1-x_1
  • Stap 3: voeg 2kπ2k\pi toe om alle oplossingen te vinden

6. Wiskunde als gereedschap voor natuurkunde

Goniometrie, ook wel bekend als de studie van hoeken en cirkelfuncties (zoals sinus en cosinus), dient als handig gereedschap voor natuurkunde. In dit hoofdstuk koppelen we de wiskundige concepten van de goniometrie aan natuurkundige toepassingen, met name binnen het subdomein B1: Informatieoverdracht. We laten zien hoe sinus- en cosinusfuncties de basis vormen voor het beschrijven van trillingen en golven, en hoe dit inzicht ons helpt bij het begrijpen van onder andere geluid, muziek en radiotechnologie.

6.1 De harmonische trilling

Een harmonische trilling is een beweging waarbij de uitwijking uu van een punt uit evenwicht beschreven wordt door een sinus- of cosinusfunctie. De mate van maximale afwijking noemen we de amplitude AA, het startpunt noemen we de fase ϕ\phi. De tijd waarin de beweging op en neer gaat noemen we de periode TT, en hoe vaak die beweging per seconde plaatsvindt, is de frequentie ff:

f=1Tf = \frac{1}{T}
u(t)=Asin(2πft+ϕ)u(t) = A \cdot \sin(2\pi f t + \phi)

Met:

GrootheidSymboolEenheid
FrequentieffHz
PeriodeTTs
Uitwijkinguum
Tijdstiptts
AmplitudeAAm
Faseϕ\phi-

Een klassiek voorbeeld van een harmonische trilling is het massa-veersysteem. De eigenfrequentie van dit systeem wordt bepaald door de massa m m en de stugheid (veerconstante C C ) van de veer:

T=2πmCT = 2\pi \sqrt{\frac{m}{C}}
Source
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.patches import Rectangle
from matplotlib.animation import FuncAnimation
from IPython.display import HTML, display
from ipywidgets import FloatSlider, VBox, interactive_output

# Constantes
A = 0.5
t_max = 10
fps = 60
y_plafond = 2.0
y_eq = 1.0
block_height = 0.4
zigzag_segments = 20

def create_zigzag(y_top, y_bottom, width=0.05, segments=20):
    ys = np.linspace(y_top, y_bottom, segments + 1)
    xs = [width if i % 2 == 0 else -width for i in range(segments + 1)]
    xs[0] = xs[-1] = 0
    return xs, ys

def animate_system(m=1.0, C=8.0):
    omega = np.sqrt(C / m)
    T = 2 * np.pi / omega
    t_vals = np.linspace(0, t_max, int(t_max * fps))
    u_vals = A * np.cos(omega * t_vals)

    fig, (ax_sys, ax_graph) = plt.subplots(1, 2, figsize=(13, 6))
    fig.suptitle(f"Massa-veersysteem met m = {m:.2f} kg en C = {C:.2f} N/m", fontsize=14)
    plt.subplots_adjust(bottom=0.25)

    # Systeem
    ax_sys.set_xlim(-1, 1)
    ax_sys.set_ylim(-0.2, 2.4)
    ax_sys.set_aspect('equal')
    ax_sys.axis('off')
    ax_sys.plot([-0.5, 0.5], [y_plafond, y_plafond], color='black', lw=3)
    mass_rect = Rectangle((-0.2, y_eq - block_height / 2), 0.4, block_height, color='red')
    ax_sys.add_patch(mass_rect)
    zigzag_line, = ax_sys.plot([], [], color='black', lw=2)

    # u(t)-grafiek
    ax_graph.set_xlim(0, t_max)
    ax_graph.set_ylim(-1.5, 1.5)
    ax_graph.set_xlabel('tijd (s)')
    ax_graph.set_ylabel('uitwijking u(t) (m)')
    ax_graph.set_title('u(t) versus tijd')
    ax_graph.grid(True)
    line_u, = ax_graph.plot(t_vals, u_vals, label='u(t)')
    dot_u, = ax_graph.plot([], [], 'ro')
    ax_graph.legend()

    def init():
        dot_u.set_data([], [])
        return mass_rect, zigzag_line, dot_u

    def update(frame):
        t = t_vals[frame]
        u = u_vals[frame]
        y_center = y_eq + u
        y_mass_top = y_center - block_height / 2
        mass_rect.set_y(y_mass_top)

        zigzag_width = 0.03 + 0.1 * (u / A)
        xs, ys = create_zigzag(y_plafond, y_center, width=zigzag_width, segments=zigzag_segments)
        zigzag_line.set_data(xs, ys)

        dot_u.set_data(t, u)
        return mass_rect, zigzag_line, dot_u

    ani = FuncAnimation(fig, update, frames=len(t_vals), init_func=init, interval=1000 / fps, blit=True)
    plt.close(fig)  # Voorkomt dubbele output in Jupyter
    display(HTML(ani.to_jshtml()))

# Sliders
m_slider = FloatSlider(min=0.25, max=4.0, step=0.05, value=1.0, description='massa m (kg)')
C_slider = FloatSlider(min=5.0, max=10.0, step=0.1, value=8.0, description='veerconstante C (N/m)')

ui = VBox([m_slider, C_slider])
out = interactive_output(animate_system, {'m': m_slider, 'C': C_slider})

display(ui, out)
Loading...

6.2 Lopende golven

Tot nu toe beschouwden we trillingen op één plek in de ruimte. Maar een golf kan zich ook verplaatsen. Neem bijvoorbeeld een transversale golf. Deze heeft een golflengte λ\lambda en verplaatst zich in de tijd. Zoals te zien is in de grafiek hieronder, verplaatst de golf zich sneller bij een hogere frequentie: de golflengte wordt in een kortere tijd TT afgelegd.

v=λT=λfv = \frac{\lambda}{T} = \lambda f

De golfsnelheid vv is dus het product van de golflengte en frequentie.

6.3 Staande golven

Een bijzonder type golf is de staande golf. Hierbij oscilleert de golf, maar het geheel beweegt niet door de ruimte. Een bekend voorbeeld zijn muziekinstrumenten zoals een snaar die aan beide uiteinden is ingeklemd.

Voor een snaar van lengte ll, die op beide uiteinden vastzit, geldt:

l=n12λenv=λfl = n \cdot \frac{1}{2} \lambda \qquad \text{en} \qquad v = \lambda f

Waarbij nn het aantal buikgolven of modusnummer is. In de onderstaande interactieve visualisatie zie je links de eerste drie trillingsmodi (n=1n = 1 t/m 3) van een snaar:

  • Bij n=1n = 1 is een halve golflengte zichtbaar (12λ\frac{1}{2} \lambda)
  • Bij n=2n = 2 een hele (λ\lambda)
  • Bij n=3n = 3 anderhalf (32λ\frac{3}{2} \lambda)

Deze worden weergegeven als sinusvormige lijnen tussen twee vaste punten (de muren).

Rechts zie je een frequentiespectrum met staven voor elk nn. Met de slider kun je de lengte ll van de snaar aanpassen. Dit beïnvloedt:

  • De golflengte: λ=2ln\lambda = \frac{2l}{n}
  • De frequentie: f=vλf = \frac{v}{\lambda}

Een grotere snaarlengte ll betekent een langere golflengte λ\lambda en dus een lagere frequentie ff. De staven in het spectrum bewegen dan naar links (lagere frequentie) bij toenemende lengte.