20TD02U Programmering og funksjonsdrøfting - itnett/FTD02H-N GitHub Wiki

https://ndla.no/subject:1:5a5cac3f-46ff-4f4d-ba95-b256a706ec48/topic:c7111b35-0621-4977-8a31-fe41e8e4a34d/topic:b4ba45c3-b084-45a1-994c-c85eb755ee54/resource:a576f6e0-3a73-45d7-948e-4a44e9da13f2

https://ndla.no/article-iframe/nb/article/23308

[python] For å oppfylle kompetansemålene 3.4.50 og 3.4.51, skal vi lage programmer som kan gjøre funksjonsdrøfting av vilkårlige andregrads- og tredjegradsfunksjoner. Vi vil implementere begge programmene trinn for trinn, og hver del av programmet vil bli forklart med tilhørende algoritmer og koding.

Funksjonsdrøfting av andregradsfunksjoner

Vi begynner med andregradsfunksjoner og lager et program som kan gjøre følgende:

1. Skrive ut den deriverte funksjonen.
2. Drøfte monotoniegenskapene til funksjonen.
3. Finne eventuelle nullpunkter til funksjonen.
4. Finne toppunktet (eller bunnpunktet).
5. Finne skjæringspunktet med andreaksen.
6. Tegne grafen.

Algoritme for funksjonsdrøfting av andregradsfunksjoner

1. Ta imot verdiene for konstantene (a), (b) og (c).
2. Definer funksjonen (f(x) = ax^2 + bx + c).
3. Beregn den deriverte funksjonen (f'(x) = 2ax + b).
4. Drøft monotoniegenskapene ved å analysere fortegnet til (f'(x)).
5. Finn nullpunktene ved å løse (f(x) = 0).
6. Finn toppunktet eller bunnpunktet ved å finne nullpunktet til (f'(x)).
7. Finn skjæringspunktet med andreaksen ved å sette (x = 0).
8. Tegn grafen til funksjonen (f(x)).

Koding

Her er Python-koden som implementerer algoritmen:

import numpy as np
import matplotlib.pyplot as plt
from sympy import symbols, Eq, solve, diff

# Definere funksjonen og den deriverte
def quadratic_function(a, b, c):
    x = symbols('x')
    f = a*x**2 + b*x + c
    f_prime = diff(f, x)
    return f, f_prime

# Drøfte monotoniegenskaper
def monotonicity(f_prime):
    x = symbols('x')
    critical_points = solve(Eq(f_prime, 0), x)
    return critical_points

# Finne nullpunkter
def find_roots(a, b, c):
    x = symbols('x')
    f = a*x**2 + b*x + c
    roots = solve(Eq(f, 0), x)
    return roots

# Finne toppunkt/bunnpunkt
def find_extremum(f_prime):
    x = symbols('x')
    critical_points = solve(Eq(f_prime, 0), x)
    return critical_points

# Finne skjæringspunkt med y-aksen
def y_intercept(a, b, c):
    return c

# Tegne grafen
def plot_quadratic(a, b, c):
    x = np.linspace(-10, 10, 400)
    y = a*x**2 + b*x + c
    plt.plot(x, y, label=f'{a}x^2 + {b}x + {c}')
    plt.axhline(0, color='black', linewidth=0.5)
    plt.axvline(0, color='black', linewidth=0.5)
    plt.legend()
    plt.title('Andregradsfunksjon')
    plt.xlabel('x')
    plt.ylabel('f(x)')
    plt.grid(True)
    plt.show()

# Hovedprogram
def main():
    print("Dette programmet gjør funksjonsdrøfting av en vilkårlig andregradsfunksjon.")
    
    user_input = input("Skriv inn verdiene for a, b og c separert med mellomrom: ")
    a, b, c = map(float, user_input.split())
    
    f, f_prime = quadratic_function(a, b, c)
    print(f"Den deriverte funksjonen: f'(x) = {f_prime}")
    
    critical_points = monotonicity(f_prime)
    print(f"Monotoniegenskaper: Kritiske punkter: {critical_points}")
    
    roots = find_roots(a, b, c)
    print(f"Nullpunkter: {roots}")
    
    extremum = find_extremum(f_prime)
    print(f"Toppunkt/bunnpunkt: {extremum}")
    
    y_int = y_intercept(a, b, c)
    print(f"Skjæringspunkt med y-aksen: (0, {y_int})")
    
    plot_quadratic(a, b, c)

main()

Funksjonsdrøfting av tredjegradsfunksjoner

Vi utvider nå programmet for å gjøre funksjonsdrøfting av vilkårlige tredjegradsfunksjoner.

Algoritme for funksjonsdrøfting av tredjegradsfunksjoner

1. Ta imot verdiene for konstantene (a), (b), (c), og (d).
2. Definer funksjonen (f(x) = ax^3 + bx^2 + cx + d).
3. Beregn den deriverte funksjonen (f'(x)).
4. Drøft monotoniegenskapene ved å analysere fortegnet til (f'(x)).
5. Finn nullpunktene ved å løse (f(x) = 0).
6. Finn toppunktet eller bunnpunktet ved å finne nullpunktene til (f'(x)).
7. Finn skjæringspunktet med andreaksen ved å sette (x = 0).
8. Tegn grafen til funksjonen (f(x)).

Koding

Her er Python-koden som implementerer algoritmen for tredjegradsfunksjoner:

import numpy as np
import matplotlib.pyplot as plt
from sympy import symbols, Eq, solve, diff

# Definere funksjonen og den deriverte
def cubic_function(a, b, c, d):
    x = symbols('x')
    f = a*x**3 + b*x**2 + c*x + d
    f_prime = diff(f, x)
    return f, f_prime

# Drøfte monotoniegenskaper
def monotonicity(f_prime):
    x = symbols('x')
    critical_points = solve(Eq(f_prime, 0), x)
    return critical_points

# Finne nullpunkter
def find_roots(a, b, c, d):
    x = symbols('x')
    f = a*x**3 + b*x**2 + c*x + d
    roots = solve(Eq(f, 0), x)
    return roots

# Finne toppunkt/bunnpunkt
def find_extremum(f_prime):
    x = symbols('x')
    critical_points = solve(Eq(f_prime, 0), x)
    return critical_points

# Finne skjæringspunkt med y-aksen
def y_intercept(d):
    return d

# Tegne grafen
def plot_cubic(a, b, c, d):
    x = np.linspace(-10, 10, 400)
    y = a*x**3 + b*x**2 + c*x + d
    plt.plot(x, y, label=f'{a}x^3 + {b}x^2 + {c}x + {d}')
    plt.axhline(0, color='black', linewidth=0.5)
    plt.axvline(0, color='black', linewidth=0.5)
    plt.legend()
    plt.title('Tredjegradsfunksjon')
    plt.xlabel('x')
    plt.ylabel('f(x)')
    plt.grid(True)
    plt.show()

# Hovedprogram
def main():
    print("Dette programmet gjør funksjonsdrøfting av en vilkårlig tredjegradsfunksjon.")
    
    user_input = input("Skriv inn verdiene for a, b, c og d separert med mellomrom: ")
    a, b, c, d = map(float, user_input.split())
    
    f, f_prime = cubic_function(a, b, c, d)
    print(f"Den deriverte funksjonen: f'(x) = {f_prime}")
    
    critical_points = monotonicity(f_prime)
    print(f"Monotoniegenskaper: Kritiske punkter: {critical_points}")
    
    roots = find_roots(a, b, c, d)
    print(f"Nullpunkter: {roots}")
    
    extremum = find_extremum(f_prime)
    print(f"Toppunkt/bunnpunkt: {extremum}")
    
    y_int = y_intercept(d)
    print(f"Skjæringspunkt med y-aksen: (0, {y_int})")
    
    plot_cubic(a, b, c, d)

main()

Disse programmene dekker funksjonsdrøfting for både andregrads- og tredjegradsfunksjoner, inkludert å finne den deriverte funksjonen, drøfte monotoniegenskaper, finne nullpunkter, finne toppunkt/bunnpunkt, finne skjæringspunkt med y-aksen, og tegne grafen for å verifisere resultatene. Elevene kan bruke disse verktøyene til å utforske og forstå egenskapene til ulike polynomfunksjoner.

For å hjelpe elevene med å oppfylle kompetansemålene KM401, KM403, og KM446, samt kjerneelementene KE30 og KE33, kan vi utvikle interaktive Jupyter-notatbøker og programmer som dekker bruk av gjennomsnittlig og momentan vekstfart, utforsking av egenskaper ved polynomfunksjoner, og problemløsning ved hjelp av algoritmisk tenkning og programmering. La oss starte med funksjonsdrøfting og utforskning av ulike funksjoner.

1. Bruke gjennomsnittlig og momentan vekstfart

Jupyter Notebook for gjennomsnittlig og momentan vekstfart

Denne notatboken hjelper elevene med å beregne gjennomsnittlig og momentan vekstfart for en funksjon.

# Importere nødvendige biblioteker
import numpy as np
import matplotlib.pyplot as plt
import ipywidgets as widgets
from IPython.display import display

# Definere funksjonen f(x)
def f(x):
    return x**2 + 2

# Beregne gjennomsnittlig vekstfart
def average_rate_of_change(f, x1, x2):
    return (f(x2) - f(x1)) / (x2 - x1)

# Beregne momentan vekstfart ved numerisk derivasjon
def instantaneous_rate_of_change(f, x, delta_x):
    return (f(x + delta_x) - f(x)) / delta_x

# Widgets for brukerinput
x1_input = widgets.FloatText(description='x1:', value=0)
x2_input = widgets.FloatText(description='x2:', value=1)
x_input = widgets.FloatText(description='x:', value=0.5)
delta_x_input = widgets.FloatText(description='Delta x:', value=0.1)
output = widgets.Output()

def on_value_change(change):
    with output:
        output.clear_output()
        x1 = x1_input.value
        x2 = x2_input.value
        x = x_input.value
        delta_x = delta_x_input.value
        avg_rate = average_rate_of_change(f, x1, x2)
        inst_rate = instantaneous_rate_of_change(f, x, delta_x)
        print(f"Gjennomsnittlig vekstfart mellom x = {x1} og x = {x2}: {avg_rate:.5f}")
        print(f"Momentan vekstfart ved x = {x} (delta x = {delta_x}): {inst_rate:.5f}")

x1_input.observe(on_value_change, names='value')
x2_input.observe(on_value_change, names='value')
x_input.observe(on_value_change, names='value')
delta_x_input.observe(on_value_change, names='value')

display(x1_input, x2_input, x_input, delta_x_input, output)

2. Utforske egenskaper ved polynomfunksjoner

Jupyter Notebook for funksjonsdrøfting av polynomfunksjoner

Denne notatboken hjelper elevene med å utforske egenskapene til polynomfunksjoner, inkludert drøfting av monotoniegenskaper, nullpunkter, ekstremalpunkter og skjæringspunkter med aksene.

import numpy as np
import matplotlib.pyplot as plt
from sympy import symbols, Eq, solve, diff

# Funksjon for andregradsfunksjoner
def quadratic_function(a, b, c):
    x = symbols('x')
    f = a*x**2 + b*x + c
    f_prime = diff(f, x)
    return f, f_prime

# Funksjon for tredjegradsfunksjoner
def cubic_function(a, b, c, d):
    x = symbols('x')
    f = a*x**3 + b*x**2 + c*x + d
    f_prime = diff(f, x)
    return f, f_prime

# Drøfte monotoniegenskaper
def monotonicity(f_prime):
    x = symbols('x')
    critical_points = solve(Eq(f_prime, 0), x)
    return critical_points

# Finne nullpunkter
def find_roots(f):
    x = symbols('x')
    roots = solve(Eq(f, 0), x)
    return roots

# Finne toppunkt/bunnpunkt
def find_extremum(f_prime):
    x = symbols('x')
    critical_points = solve(Eq(f_prime, 0), x)
    return critical_points

# Finne skjæringspunkt med y-aksen
def y_intercept(f):
    x = symbols('x')
    return f.subs(x, 0)

# Tegne grafen for andregradsfunksjoner
def plot_quadratic(a, b, c):
    x = np.linspace(-10, 10, 400)
    y = a*x**2 + b*x + c
    plt.plot(x, y, label=f'{a}x^2 + {b}x + {c}')
    plt.axhline(0, color='black', linewidth=0.5)
    plt.axvline(0, color='black', linewidth=0.5)
    plt.legend()
    plt.title('Andregradsfunksjon')
    plt.xlabel('x')
    plt.ylabel('f(x)')
    plt.grid(True)
    plt.show()

# Tegne grafen for tredjegradsfunksjoner
def plot_cubic(a, b, c, d):
    x = np.linspace(-10, 10, 400)
    y = a*x**3 + b*x**2 + c*x + d
    plt.plot(x, y, label=f'{a}x^3 + {b}x**2 + {c}x + {d}')
    plt.axhline(0, color='black', linewidth=0.5)
    plt.axvline(0, color='black', linewidth=0.5)
    plt.legend()
    plt.title('Tredjegradsfunksjon')
    plt.xlabel('x')
    plt.ylabel('f(x)')
    plt.grid(True)
    plt.show()

# Hovedprogram for andregradsfunksjoner
def quadratic_main():
    print("Dette programmet gjør funksjonsdrøfting av en vilkårlig andregradsfunksjon.")
    
    user_input = input("Skriv inn verdiene for a, b og c separert med mellomrom: ")
    a, b, c = map(float, user_input.split())
    
    f, f_prime = quadratic_function(a, b, c)
    print(f"Den deriverte funksjonen: f'(x) = {f_prime}")
    
    critical_points = monotonicity(f_prime)
    print(f"Monotoniegenskaper: Kritiske punkter: {critical_points}")
    
    roots = find_roots(f)
    print(f"Nullpunkter: {roots}")
    
    extremum = find_extremum(f_prime)
    print(f"Toppunkt/bunnpunkt: {extremum}")
    
    y_int = y_intercept(f)
    print(f"Skjæringspunkt med y-aksen: (0, {y_int})")
    
    plot_quadratic(a, b, c)

# Hovedprogram for tredjegradsfunksjoner
def cubic_main():
    print("Dette programmet gjør funksjonsdrøfting av en vilkårlig tredjegradsfunksjon.")
    
    user_input = input("Skriv inn verdiene for a, b, c og d separert med mellomrom: ")
    a, b, c, d = map(float, user_input.split())
    
    f, f_prime = cubic_function(a, b, c, d)
    print(f"Den deriverte funksjonen: f'(x) = {f_prime}")
    
    critical_points = monotonicity(f_prime)
    print(f"Monotoniegenskaper: Kritiske punkter: {critical_points}")
    
    roots = find_roots(f)
    print(f"Nullpunkter: {roots}")
    
    extremum = find_extremum(f_prime)
    print(f"Toppunkt/bunnpunkt: {extremum}")
    
    y_int = y_intercept(f)
    print(f"Skjæringspunkt med y-aksen: (0, {y_int})")
    
    plot_cubic(a, b, c, d)

# Kjøre hovedprogrammet
quadratic_main()
cubic_main()

3. Formulere og løse problemer ved hjelp av algoritmisk tenkning

Jupyter Notebook for problemløsing med algoritmisk tenkning

Denne notatboken veileder elevene i å bruke algoritmisk tenkning for å løse matematiske problemer ved å bryte ned problemer i delproblemer og bruke digitale verktøy.

# Importere nødvendige biblioteker
import numpy as np
import matplotlib.pyplot as plt
import sympy as sp

# Definere en funksjon for et polynom
def polynomial_function(coefficients):
    x = sp.symbols('x')
    f = sum(c*x**i for i, c in enumerate(coefficients))
    return f

# Finne røttene til funksjonen
def find_roots(f):
    x = sp.symbols('x')
    roots = sp.solve(f, x)
    return roots

# Finne ekstremalpunkter
def find_extrema(f):
    x = sp.symbols('x')
    f_prime = sp.diff(f, x)
    critical

_points = sp.solve(f_prime, x)
    return critical_points, f_prime

# Tegne grafen til funksjonen
def plot_polynomial(coefficients):
    x_vals = np.linspace(-10, 10, 400)
    x = sp.symbols('x')
    f = polynomial_function(coefficients)
    f_lambdified = sp.lambdify(x, f, 'numpy')
    y_vals = f_lambdified(x_vals)
    
    roots = find_roots(f)
    critical_points, f_prime = find_extrema(f)
    f_prime_lambdified = sp.lambdify(x, f_prime, 'numpy')
    y_prime_vals = f_prime_lambdified(x_vals)
    
    plt.plot(x_vals, y_vals, label='f(x)')
    plt.plot(x_vals, y_prime_vals, label="f'(x)", linestyle='--')
    for root in roots:
        plt.plot(root, f_lambdified(root), 'ro', label=f'Root: x={root:.2f}')
    for cp in critical_points:
        plt.plot(cp, f_lambdified(cp), 'go', label=f'Critical Point: x={cp:.2f}')
    
    plt.axhline(0, color='black', linewidth=0.5)
    plt.axvline(0, color='black', linewidth=0.5)
    plt.legend()
    plt.title('Polynomfunksjon og dens deriverte')
    plt.xlabel('x')
    plt.ylabel('y')
    plt.grid(True)
    plt.show()

# Hovedprogram for polynomfunksjoner
def polynomial_main():
    print("Dette programmet drøfter en vilkårlig polynomfunksjon av valgfri grad.")
    
    user_input = input("Skriv inn koeffisientene til polynomfunksjonen separert med mellomrom (start med den laveste graden): ")
    coefficients = list(map(float, user_input.split()))
    
    plot_polynomial(coefficients)

# Kjøre hovedprogrammet
polynomial_main()

Disse notatbøkene hjelper elevene med å:

• Beregne og forstå gjennomsnittlig og momentan vekstfart (KM401).
• Utforske egenskapene til polynomfunksjoner, rasjonale funksjoner, eksponentialfunksjoner og potensfunksjoner (KM446).
• Formulere og løse problemer ved hjelp av algoritmisk tenkning og digitale verktøy (KM403).
• Bruke matematiske representasjoner og kommunisere resultater (KE30 og KE33).

La meg vite om du trenger ytterligere tilpasninger eller flere ressurser!