20TD02U Tilnærmede verdier for den deriverte med programmering - itnett/FTD02H-N GitHub Wiki
https://trinket.io/python3/387fb75e30
This is a Python 3 trinket. It includes everything in Python 3.9.6 as well as scientific libraries like Numpy and SciPy and matplotlib , with more on the way.
[python] La oss først lage et program som kan regne ut tilnærmede verdier for den deriverte til en funksjon ved å bruke numerisk differensiering. Deretter vil vi lage et program som tegner grafen til en vilkårlig tredjegradsfunksjon og beregner den deriverte ved hjelp av numerisk differensiering.
Tilnærmede verdier for den deriverte
Vi starter med å lage et program som beregner tilnærmede verdier for den deriverte av en funksjon.
a) Spørsmål
Hva betyr det at ( f'(0.5) = 1 )? Svar: At ( f'(0.5) = 1 ) betyr at stigningstallet til tangenten til grafen når ( x = 0.5 ) er 1. Det betyr også at den momentane vekstfarten til funksjonen når ( x = 0.5 ) er 1.
b) Spørsmål
Hvorfor kan vi ikke sette ( \Delta x = 0 ) direkte i uttrykket? Svar: Dersom vi prøver å sette ( \Delta x = 0 ) rett inn i uttrykket, får vi 0 i nevneren på brøken.
Algoritme og koding for numerisk derivasjon
Vi lager et program som finner den deriverte ved å bruke en liten verdi for ( \Delta x ) og iterativt redusere ( \Delta x ) for å få en bedre tilnærming.
def f(x):
return x**2 + 2
def derivative_approximation(f, x, delta_x):
return (f(x + delta_x) - f(x)) / delta_x
x_value = 0.5
delta_x = 0.1
tolerance = 0.00001
previous_derivative = derivative_approximation(f, x_value, delta_x)
delta_x /= 10
current_derivative = derivative_approximation(f, x_value, delta_x)
while abs(current_derivative - previous_derivative) > tolerance:
previous_derivative = current_derivative
delta_x /= 10
current_derivative = derivative_approximation(f, x_value, delta_x)
print(f"Den deriverte til funksjonen i x = {x_value} er tilnærmet {current_derivative:.5f}")
Testing og forbedring av programmet for tilnærmet derivasjon
Nå skal vi teste programmet med ulike verdier for ( \Delta x ) og se hvordan nøyaktigheten forbedres.
# Testing med delta_x = 0.01 og delta_x = 0.001
x_value = 0.5
delta_x_values = [0.01, 0.001]
for delta_x in delta_x_values:
approx_derivative = derivative_approximation(f, x_value, delta_x)
print(f"Tilnærmet verdi for den deriverte ved delta_x = {delta_x}: {approx_derivative:.5f}")
Implementere programmet for vilkårlige tredjegradsfunksjoner
Til slutt lager vi et program som tar imot en vilkårlig tredjegradsfunksjon fra brukeren, tegner grafen, og beregner den deriverte ved hjelp av numerisk differensiering.
a) Vurdering
Brukeren kan skrive inn tredjegradsfunksjonen ved å angi konstantene ( a ), ( b ), ( c ), og ( d ).
b) Algoritme
- Be brukeren om å skrive inn verdiene for konstantene ( a ), ( b ), ( c ), ( d ), samt intervallet ( s ) og ( t ).
- Lag en liste ( x ) med 100 verdier fra ( s ) til ( t ).
- Lag en liste ( y ) ved å evaluere funksjonen ( f(x) = ax^3 + bx^2 + cx + d ) for hver verdi i ( x )-listen.
- Tegn grafen for funksjonen.
- Beregn den deriverte ved ( x )-verdier ved hjelp av numerisk differensiering.
c) Koding
La oss implementere dette i et program.
import numpy as np
import matplotlib.pyplot as plt
def cubic_function(x, a, b, c, d):
return a*x**3 + b*x**2 + c*x + d
def derivative_approximation(f, x, delta_x):
return (f(x + delta_x) - f(x)) / delta_x
def plot_cubic_function_and_derivative():
print("Dette programmet tegner en vilkårlig tredjegradsfunksjon og beregner den deriverte ved x-verdier i et gitt intervall.")
user_input = input("Skriv inn verdiene for a, b, c, d, s og t separert med mellomrom: ")
a, b, c, d, s, t = map(float, user_input.split())
x = np.linspace(s, t, 100)
y = cubic_function(x, a, b, c, 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()
x_value = float(input("Skriv inn verdien for x hvor du vil beregne den deriverte: "))
delta_x = 0.1
tolerance = 0.00001
previous_derivative = derivative_approximation(lambda x: cubic_function(x, a, b, c, d), x_value, delta_x)
delta_x /= 10
current_derivative = derivative_approximation(lambda x: cubic_function(x, a, b, c, d), x_value, delta_x)
while abs(current_derivative - previous_derivative) > tolerance:
previous_derivative = current_derivative
delta_x /= 10
current_derivative = derivative_approximation(lambda x: cubic_function(x, a, b, c, d), x_value, delta_x)
print(f"Den deriverte til funksjonen ved x = {x_value} er tilnærmet {current_derivative:.5f}")
plot_cubic_function_and_derivative()
d) Spørsmål
Kan programmet brukes til å tegne andregradsfunksjoner eller rette linjer? Svar: Ja, ved å sette noen av konstantene ( a ), ( b ), eller ( c ) til null, kan programmet også brukes til å tegne andregradsfunksjoner eller rette linjer.
Programmet kan utvides med flere funksjoner og forbedringer basert på dine behov. La meg vite om du trenger ytterligere tilpasninger eller flere funksjoner!
[python] For å hjelpe elevene med å oppfylle kompetansemålene KM401 og KM403, samt kjerneelementene KE30 og KE33, kan vi lage interaktive Jupyter-notatbøker og programmer som fokuserer på gjennomsnittlig og momentan vekstfart, samt problemløsning med algoritmisk tenkning og programmering.
1. Beregning av gjennomsnittlig og momentan vekstfart
Jupyter Notebook for gjennomsnittlig og momentan vekstfart
Denne notatboken vil hjelpe 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. Problemløsing med algoritmisk tenkning og programmering
Jupyter Notebook for problemløsing med algoritmisk tenkning
Denne notatboken vil veilede elevene i å bruke algoritmisk tenkning for å løse matematiske problemer.
# Importere nødvendige biblioteker
import numpy as np
import matplotlib.pyplot as plt
import sympy as sp
# Definere funksjonen f(x)
def f(x):
return x**3 - 2*x**2 + x - 3
# Finne røttene til funksjonen f(x)
def find_roots(f):
x = sp.symbols('x')
roots = sp.solve(f(x), x)
return roots
# Plot funksjonen og markere røttene
def plot_function_and_roots(f):
x_vals = np.linspace(-3, 3, 400)
y_vals = f(x_vals)
roots = find_roots(f)
plt.plot(x_vals, y_vals, label='f(x)')
for root in roots:
plt.plot(root, f(root), 'ro')
plt.text(root, f(root), f' x = {root:.2f}', ha='left')
plt.axhline(0, color='black', linewidth=0.5)
plt.axvline(0, color='black', linewidth=0.5)
plt.legend()
plt.title('Graf av funksjonen f(x) og dens røtter')
plt.xlabel('x')
plt.ylabel('f(x)')
plt.grid(True)
plt.show()
# Kjøre plot funksjonen
plot_function_and_roots(f)
3. Representasjon og kommunikasjon i matematikk
Jupyter Notebook for representasjon og kommunikasjon
Denne notatboken hjelper elevene med å bruke matematiske representasjoner og kommunikasjon effektivt.
# Importere nødvendige biblioteker
import matplotlib.pyplot as plt
import numpy as np
import sympy as sp
# Definere en funksjon
def f(x):
return x**3 - 3*x**2 + 2*x
# Plot funksjonen og dens deriverte
def plot_function_and_derivative(f):
x_vals = np.linspace(-1, 3, 400)
y_vals = f(x_vals)
# Beregne den deriverte symbolsk
x = sp.symbols('x')
f_expr = f(x)
f_prime_expr = sp.diff(f_expr, x)
f_prime = sp.lambdify(x, f_prime_expr, 'numpy')
y_prime_vals = f_prime(x_vals)
plt.figure(figsize=(10, 6))
plt.plot(x_vals, y_vals, label='f(x)')
plt.plot(x_vals, y_prime_vals, label="f'(x)", linestyle='--')
plt.axhline(0, color='black', linewidth=0.5)
plt.axvline(0, color='black', linewidth=0.5)
plt.legend()
plt.title('Funksjon og dens deriverte')
plt.xlabel('x')
plt.ylabel('y')
plt.grid(True)
plt.show()
plot_function_and_derivative(f)
Disse notatbøkene hjelper elevene med å oppfylle kompetansemålene ved å:
- Beregne og forstå gjennomsnittlig og momentan vekstfart (KM401).
- Bruke algoritmisk tenkning og digitale verktøy for problemløsning (KM403).
- Utforske mønstre og sammenhenger i matematiske representasjoner (KE30).
- Kommunisere matematiske konsepter og resultater ved hjelp av visuelle og symbolske representasjoner (KE33).
La meg vite om du trenger ytterligere tilpasninger eller flere ressurser!