20TD02U Programmer som løser andregradslikninger - itnett/FTD02H-N GitHub Wiki
[python] La oss gå gjennom hvert punkt og utarbeide løsninger for hver del av oppgaven.
a) Spørsmål
Spørsmålet er hvilken metode som er enklest å bruke i et program: faktorisering eller bruk av abc-formelen.
Svar: Når det gjelder programmering, er bruk av abc-formelen enklere og mer direkte å implementere. Dette skyldes at abc-formelen gir en direkte måte å beregne røttene på ved å bruke en enkel matematisk formel.
b) Vurdering
Brukeren kan skrive inn konstantene (a), (b) og (c), og programmet kan bruke abc-formelen direkte.
c) Algoritme
Vi lager en algoritme som beskriver hvordan programmet skal fungere.
- Skriv til skjermen "Dette programmet løser andregradslikningen ax^2 + bx + c = 0."
- Skriv til skjermen "Skriv inn konstanten a:"
- Ta imot tallet fra brukeren, konverter det til et ekte tall, og sett det lik variabelen (a).
- Skriv til skjermen "Skriv inn konstanten b:"
- Ta imot tallet fra brukeren, konverter det til et ekte tall, og sett det lik variabelen (b).
- Skriv til skjermen "Skriv inn konstanten c:"
- Ta imot tallet fra brukeren, konverter det til et ekte tall, og sett det lik variabelen (c).
- Beregn diskriminanten (D = b^2 - 4ac).
- Hvis (D > 0), beregn røttene (x_1 = \frac{-b + \sqrt{D}}{2a}) og (x_2 = \frac{-b - \sqrt{D}}{2a}).
- Hvis (D = 0), beregn roten (x_1 = x_2 = \frac{-b}{2a}).
- Hvis (D < 0), skriv til skjermen "Ingen reelle løsninger."
- Skriv til skjermen "Løsningene er x1 = og x2 = ."
d) Koding
La oss kode programmet basert på algoritmen.
import math
def solve_quadratic():
print("Dette programmet løser andregradslikningen ax^2 + bx + c = 0.")
a = float(input("Skriv inn konstanten a: "))
b = float(input("Skriv inn konstanten b: "))
c = float(input("Skriv inn konstanten c: "))
D = b**2 - 4*a*c
if D > 0:
x1 = (-b + math.sqrt(D)) / (2*a)
x2 = (-b - math.sqrt(D)) / (2*a)
print(f"Løsningene er x1 = {x1} og x2 = {x2}.")
elif D == 0:
x1 = x2 = -b / (2*a)
print(f"Løsningen er x1 = x2 = {x1}.")
else:
print("Ingen reelle løsninger.")
solve_quadratic()
e) Diskusjon
Programmet vil fungere for de fleste andregradslikninger, men det må håndtere tilfeller der (a = 0) (da det ikke er en andregradslikning) og der diskriminanten (D) er negativ.
f) Testing
Prøv programmet med likningen (x^2 + 4x + 4 = 0) (som har dobbel rot).
g) Testing
Prøv deretter programmet med likningen (x^2 + x + 1 = 0) (som har komplekse røtter).
h) Algoritme
Endre algoritmen til å inkludere sjekk for (a = 0) og komplekse røtter.
i) Koding
Oppdatert program med forbedringer:
import math
def solve_quadratic():
print("Dette programmet løser andregradslikningen ax^2 + bx + c = 0.")
a = float(input("Skriv inn konstanten a: "))
b = float(input("Skriv inn konstanten b: "))
c = float(input("Skriv inn konstanten c: "))
if a == 0:
if b != 0:
x = -c / b
print(f"Løsningen er x = {x}.")
else:
print("Dette er ikke en gyldig likning.")
return
D = b**2 - 4*a*c
if D > 0:
x1 = (-b + math.sqrt(D)) / (2*a)
x2 = (-b - math.sqrt(D)) / (2*a)
print(f"Løsningene er x1 = {x1} og x2 = {x2}.")
elif D == 0:
x1 = x2 = -b / (2*a)
print(f"Løsningen er x1 = x2 = {x1}.")
else:
real_part = -b / (2*a)
imaginary_part = math.sqrt(-D) / (2*a)
print(f"Løsningene er x1 = {real_part} + {imaginary_part}i og x2 = {real_part} - {imaginary_part}i.")
solve_quadratic()
Dette programmet bør nå kunne håndtere alle tilfeller av andregradslikninger og gi riktige utskrifter av løsningene.
[python] For å dekke de ulike kompetansemålene for å løse ligninger, ligningssystemer og ulikheter, samt å utforske sammenhenger mellom andregradsligninger og andregradsulikheter, andregradsfunksjoner og kvadratsetningene, vil jeg lage en serie med Python-programmer og ressurser som illustrerer disse konseptene.
Kompetansemål og programforslag:
1. Løse Ligninger, Ligningssystemer og Ulikheter
Kompetansemål: KM391, KM378, KM384, KM410, KM413, KM429, KM404, KM425, KM433, KM426
Programforslag:
- Løsning av enkle ligninger:
- Program som tar inn en lineær ligning på formen (ax + b = 0) og løser den.
- Løsning av ligningssystemer:
- Program som tar inn et system av lineære ligninger og bruker matriseinvers eller Gauss-eliminasjon for å finne løsningen.
- Løsning av ulikheter:
- Program som tar inn en ulikhet og løser den ved å finne kritiske punkter og teste intervaller.
2. Utforske Sammenhenger Mellom Andregradsligninger og Andregradsulikheter, Andregradsfunksjoner og Kvadratsetningene
Kompetansemål: KM392, KM377, KM383, KM408, KM412, KM438, KM444, KM400, KM424, KM432, KM419
Programforslag:
- Løsning av andregradsligninger:
- Programmet som ble utviklet tidligere for å løse andregradsligninger ved bruk av abc-formelen.
- Utforskning av andregradsulikheter:
- Program som grafisk illustrerer løsningen av andregradsulikheter ved å plotte funksjonen og finne nullpunktene.
- Sammenhenger med kvadratsetningene:
- Program som viser hvordan fullføring av kvadrat kan brukes til å løse andregradsligninger og ulikheter, og illustrerer dette grafisk.
Eksempler på programmer:
Program for å løse enkle lineære ligninger:
def solve_linear():
print("Dette programmet løser lineære ligninger på formen ax + b = 0.")
a = float(input("Skriv inn konstanten a: "))
b = float(input("Skriv inn konstanten b: "))
if a != 0:
x = -b / a
print(f"Løsningen er x = {x}.")
else:
if b == 0:
print("Uendelig mange løsninger.")
else:
print("Ingen løsninger.")
solve_linear()
Program for å løse ligningssystemer med to ligninger:
import numpy as np
def solve_linear_system():
print("Dette programmet løser et system av to lineære ligninger:")
print("ax + by = e")
print("cx + dy = f")
a = float(input("Skriv inn konstanten a: "))
b = float(input("Skriv inn konstanten b: "))
e = float(input("Skriv inn konstanten e: "))
c = float(input("Skriv inn konstanten c: "))
d = float(input("Skriv inn konstanten d: "))
f = float(input("Skriv inn konstanten f: "))
A = np.array([a, b], [c, d](/itnett/FTD02H-N/wiki/a,-b],-[c,-d))
B = np.array([e, f])
try:
solution = np.linalg.solve(A, B)
print(f"Løsningen er x = {solution[0]}, y = {solution[1]}")
except np.linalg.LinAlgError:
print("Ligningssystemet har ingen unik løsning.")
solve_linear_system()
Program for å utforske andregradsulikheter grafisk:
import numpy as np
import matplotlib.pyplot as plt
def plot_quadratic_inequality():
print("Dette programmet løser og illustrerer andregradsulikheter på formen ax^2 + bx + c < 0.")
a = float(input("Skriv inn konstanten a: "))
b = float(input("Skriv inn konstanten b: "))
c = float(input("Skriv inn konstanten c: "))
D = b**2 - 4*a*c
if D < 0:
print("Ingen reelle røtter. Hvis a > 0, er funksjonen alltid større enn 0. Hvis a < 0, er funksjonen alltid mindre enn 0.")
else:
x1 = (-b + np.sqrt(D)) / (2*a)
x2 = (-b - np.sqrt(D)) / (2*a)
print(f"Nullpunktene er x1 = {x1} og x2 = {x2}")
x = np.linspace(x1-1, x2+1, 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(x1, color='red', linestyle='--')
plt.axvline(x2, color='red', linestyle='--')
plt.fill_between(x, y, where=(y < 0), color='gray', alpha=0.5)
plt.legend()
plt.title('Løsning av andregradsulikheter')
plt.xlabel('x')
plt.ylabel('y')
plt.grid(True)
plt.show()
plot_quadratic_inequality()
Ressurser
For hver av de foreslåtte programmene, kan vi lage interaktive Jupyter-notatbøker som gir elevene mulighet til å eksperimentere med forskjellige verdier og observere resultatene. Videre kan vi inkludere teoretiske bakgrunner og eksempler som hjelper elevene å forstå konseptene bak ligningene og ulikhetene.
La meg vite om det er spesifikke kompetansemål eller konsepter du ønsker å fokusere mer på, eller om du trenger ytterligere programmer og ressurser.
[python] La oss lage interaktive Jupyter-notatbøker for hvert av de foreslåtte programmene. Jeg vil lage eksempler på notatbøker som du kan bruke direkte eller tilpasse etter behov.
1. Løsning av enkle lineære ligninger
Jupyter Notebook
# Løse lineære ligninger på formen ax + b = 0
# Importere nødvendige bibliotek
import ipywidgets as widgets
from IPython.display import display
def solve_linear(a, b):
if a != 0:
x = -b / a
return f"Løsningen er x = {x}."
else:
if b == 0:
return "Uendelig mange løsninger."
else:
return "Ingen løsninger."
# Interaktive widgets for input
a_slider = widgets.FloatText(description='Konstant a:', value=1)
b_slider = widgets.FloatText(description='Konstant b:', value=0)
output = widgets.Output()
def on_value_change(change):
with output:
output.clear_output()
a = a_slider.value
b = b_slider.value
result = solve_linear(a, b)
print(result)
a_slider.observe(on_value_change, names='value')
b_slider.observe(on_value_change, names='value')
display(a_slider, b_slider, output)
2. Løsning av ligningssystemer med to ligninger
Jupyter Notebook
# Løse et system av to lineære ligninger
import numpy as np
import ipywidgets as widgets
from IPython.display import display
def solve_linear_system(a, b, e, c, d, f):
A = np.array([a, b], [c, d](/itnett/FTD02H-N/wiki/a,-b],-[c,-d))
B = np.array([e, f])
try:
solution = np.linalg.solve(A, B)
return f"Løsningen er x = {solution[0]}, y = {solution[1]}"
except np.linalg.LinAlgError:
return "Ligningssystemet har ingen unik løsning."
# Interaktive widgets for input
a_slider = widgets.FloatText(description='Konstant a:', value=1)
b_slider = widgets.FloatText(description='Konstant b:', value=1)
e_slider = widgets.FloatText(description='Konstant e:', value=1)
c_slider = widgets.FloatText(description='Konstant c:', value=1)
d_slider = widgets.FloatText(description='Konstant d:', value=1)
f_slider = widgets.FloatText(description='Konstant f:', value=1)
output = widgets.Output()
def on_value_change(change):
with output:
output.clear_output()
a = a_slider.value
b = b_slider.value
e = e_slider.value
c = c_slider.value
d = d_slider.value
f = f_slider.value
result = solve_linear_system(a, b, e, c, d, f)
print(result)
a_slider.observe(on_value_change, names='value')
b_slider.observe(on_value_change, names='value')
e_slider.observe(on_value_change, names='value')
c_slider.observe(on_value_change, names='value')
d_slider.observe(on_value_change, names='value')
f_slider.observe(on_value_change, names='value')
display(a_slider, b_slider, e_slider, c_slider, d_slider, f_slider, output)
3. Utforskning av andregradsulikheter grafisk
Jupyter Notebook
# Utforske andregradsulikheter grafisk
import numpy as np
import matplotlib.pyplot as plt
import ipywidgets as widgets
from IPython.display import display
def plot_quadratic_inequality(a, b, c):
D = b**2 - 4*a*c
x1 = (-b + np.sqrt(D)) / (2*a) if D >= 0 else None
x2 = (-b - np.sqrt(D)) / (2*a) if D >= 0 else None
x = np.linspace(-10, 10, 400)
y = a*x**2 + b*x + c
plt.figure(figsize=(8, 6))
plt.plot(x, y, label=f'{a}x^2 + {b}x + {c}')
plt.axhline(0, color='black', linewidth=0.5)
if x1 is not None and x2 is not None:
plt.axvline(x1, color='red', linestyle='--')
plt.axvline(x2, color='red', linestyle='--')
plt.fill_between(x, y, where=(y < 0), color='gray', alpha=0.5)
plt.legend()
plt.title('Løsning av andregradsulikheter')
plt.xlabel('x')
plt.ylabel('y')
plt.grid(True)
plt.show()
# Interaktive widgets for input
a_slider = widgets.FloatText(description='Konstant a:', value=1)
b_slider = widgets.FloatText(description='Konstant b:', value=0)
c_slider = widgets.FloatText(description='Konstant c:', value=0)
output = widgets.Output()
def on_value_change(change):
with output:
output.clear_output(wait=True)
a = a_slider.value
b = b_slider.value
c = c_slider.value
plot_quadratic_inequality(a, b, c)
a_slider.observe(on_value_change, names='value')
b_slider.observe(on_value_change, names='value')
c_slider.observe(on_value_change, names='value')
display(a_slider, b_slider, c_slider, output)
Disse interaktive notatbøkene gir elever mulighet til å eksperimentere med forskjellige verdier for (a), (b) og (c), og se hvordan løsninger endres i sanntid. De kan brukes til å utforske konseptene mer dyptgående og se visuelle representasjoner av matematiske løsninger.
La meg vite om du trenger noen spesifikke justeringer eller ytterligere ressurser!
[python] For å hjelpe elevene med å utforske, løse problemer og generalisere i henhold til læreplanen i matematikk T, kan vi lage interaktive Jupyter-notatbøker som fokuserer på disse kjerneelementene. Hver notatbok vil inneholde aktiviteter og ressurser som hjelper elevene med å utvikle sine ferdigheter innen utforskning, abstraksjon, generalisering og matematiske kunnskapsområder.
Interaktive Jupyter-notatbøker for kjerneelementer KE30, KE34 og KE35
1. Utforskning og problemløsing (KE30)
Denne notatboken vil fokusere på å utforske matematiske mønstre og løse problemer ved hjelp av algoritmisk tenkning.
# KE30: Utforskning og problemløsing
import ipywidgets as widgets
from IPython.display import display
def find_pattern(sequence):
differences = [sequence[i+1] - sequence[i] for i in range(len(sequence)-1)]
return differences
# Widget for sekvensinnputt
sequence_input = widgets.Text(description='Sekvens:', placeholder='Skriv inn tall adskilt med komma')
output = widgets.Output()
def on_sequence_change(change):
with output:
output.clear_output()
sequence = list(map(int, sequence_input.value.split(',')))
differences = find_pattern(sequence)
print(f"Differanser: {differences}")
sequence_input.observe(on_sequence_change, names='value')
display(sequence_input, output)
2. Abstraksjon og generalisering (KE34)
Denne notatboken vil hjelpe elevene med å bruke algebraiske representasjoner for å uttrykke resultater og sammenhenger.
# KE34: Abstraksjon og generalisering
import sympy as sp
import ipywidgets as widgets
from IPython.display import display
x = sp.symbols('x')
def generalize_expression(expression_str):
expression = sp.sympify(expression_str)
expanded_expr = sp.expand(expression)
factored_expr = sp.factor(expression)
return expanded_expr, factored_expr
# Widget for uttrykkinnputt
expression_input = widgets.Text(description='Uttrykk:', placeholder='Skriv inn et algebraisk uttrykk')
output = widgets.Output()
def on_expression_change(change):
with output:
output.clear_output()
expression_str = expression_input.value
expanded_expr, factored_expr = generalize_expression(expression_str)
print(f"Utvidet uttrykk: {expanded_expr}")
print(f"Faktorisert uttrykk: {factored_expr}")
expression_input.observe(on_expression_change, names='value')
display(expression_input, output)
3. Matematisk teori og kunnskapsområder (KE35)
Denne notatboken vil gi elevene en dypere forståelse av matematiske teorier og sammenhenger mellom kunnskapsområdene.
# KE35: Matematisk teori og kunnskapsområder
import sympy as sp
import numpy as np
import matplotlib.pyplot as plt
import ipywidgets as widgets
from IPython.display import display
x = sp.symbols('x')
def plot_function(expression_str):
expression = sp.sympify(expression_str)
f = sp.lambdify(x, expression, 'numpy')
x_vals = np.linspace(-10, 10, 400)
y_vals = f(x_vals)
plt.figure(figsize=(8, 6))
plt.plot(x_vals, y_vals, label=f'f(x) = {expression}')
plt.axhline(0, color='black', linewidth=0.5)
plt.axvline(0, color='black', linewidth=0.5)
plt.legend()
plt.title('Plot av funksjonen')
plt.xlabel('x')
plt.ylabel('f(x)')
plt.grid(True)
plt.show()
# Widget for funksjonsinnputt
function_input = widgets.Text(description='Funksjon:', placeholder='Skriv inn en funksjon av x')
output = widgets.Output()
def on_function_change(change):
with output:
output.clear_output(wait=True)
expression_str = function_input.value
plot_function(expression_str)
function_input.observe(on_function_change, names='value')
display(function_input, output)
Oppsummering
Disse interaktive Jupyter-notatbøkene gir elevene mulighet til å:
- Utforske matematiske mønstre og diskutere strategier for problemløsing (KE30).
- Bruke algebraiske uttrykk for å uttrykke og generalisere matematiske sammenhenger (KE34).
- Utforske matematiske teorier og visualisere funksjoner og deres egenskaper (KE35).
Ved å bruke disse notatbøkene kan elevene utvikle en dypere forståelse av matematikk og forbedre sine ferdigheter i å løse problemer og oppdage sammenhenger. La meg vite om du trenger ytterligere tilpasninger eller flere ressurser!