Hva spør oppgaven om? Vi skal derivere et produkt. Den trigonometriske faktoren er dessuten sammensatt, så vi trenger både produktregelen og kjerneregelen.

Steg 1 — Del funksjonen i to faktorer

Steg 2 — Skriv produktregelen

Steg 3 — Deriver polynomfaktoren

Steg 4 — Deriver cosinusfaktoren med kjerneregelen

Steg 5 — Sett inn i produktregelen

Steg 6 — Forenkle svaret

from sympy import symbols, cos, sin, diff, simplify

x = symbols('x', real=True)
f = x**2*cos(3*x)
f_prime = diff(f, x)
expected = 2*x*cos(3*x) - 3*x**2*sin(3*x)
control = simplify(f_prime - expected)

print("f(x) =", f)
print("f'(x) =", f_prime)
print("Forventet uttrykk =", expected)
print("Differanse etter forenkling =", control)

f(x) = x**2*cos(3*x)
f'(x) = -3*x**2*sin(3*x) + 2*x*cos(3*x)
Forventet uttrykk = -3*x**2*sin(3*x) + 2*x*cos(3*x)
Differanse etter forenkling = 0

Fasit: \(f\prime(x)=2x\cos(3x)-3x^2\sin(3x)\).

Hva spør oppgaven om? Integranden er et produkt av et polynom og en eksponentialfunksjon. Delvis integrasjon reduserer graden til polynomet og er derfor den naturlige metoden.

Steg 1 — Trekk fram konstanten

Steg 2 — Velg \(u\) og \(dv\)

Steg 3 — Finn \(du\) og \(v\)

Steg 4 — Bruk formelen for delvis integrasjon

Steg 5 — Sett inn

Steg 6 — Regn det siste integralet

Steg 7 — Faktoriser

from sympy import symbols, exp, integrate, diff, simplify

x = symbols('x', real=True)
integrand = 5*x*exp(2*x)
primitive = integrate(integrand, x)
control = simplify(diff(primitive, x) - integrand)

print("Integrand =", integrand)
print("Stamfunksjon fra SymPy =", primitive)
print("Derivert minus integrand =", control)
print("Faktorisert stamfunksjon =", simplify(5*exp(2*x)*(2*x - 1)/4))

Integrand = 5*x*exp(2*x)
Stamfunksjon fra SymPy = (10*x - 5)*exp(2*x)/4
Derivert minus integrand = 0
Faktorisert stamfunksjon = 5*(2*x - 1)*exp(2*x)/4

Fasit: \(\displaystyle \int 5x e^{2x}dx=\frac54e^{2x}(2x-1)+C\).

Hva spør oppgaven om? Nevneren er en sammensatt funksjon, og den deriverte \(2x\) finnes i telleren. Derfor bruker vi substitusjon.

Steg 1 — Velg substitusjon

Steg 2 — Deriver substitusjonen

Steg 3 — Tilpass telleren

Steg 4 — Skriv integralet i \(u\)

Steg 5 — Integrer logaritmeformen

Steg 6 — Sett tilbake \(u=x^2-1\)

from sympy import symbols, integrate, diff, log, Abs, simplify

x = symbols('x', real=True)
integrand = 6*x/(x**2 - 1)
primitive = 3*log(Abs(x**2 - 1))
control = simplify(diff(primitive, x) - integrand)

print("Integrand =", integrand)
print("Valgt stamfunksjon =", primitive)
print("Derivert minus integrand =", control)
print("Definisjonsbegrensning: x != -1 og x != 1")

Integrand = 6*x/(x**2 - 1)
Valgt stamfunksjon = 3*log(Abs(x**2 - 1))
Derivert minus integrand = Piecewise((-6*x/(x**2 - 1), Eq(x**2, 1)), (0, True))
Definisjonsbegrensning: x != -1 og x != 1

Fasit: \(\displaystyle \int\frac{6x}{x^2-1}dx=3\ln|x^2-1|+C\), for \(x\neq\pm1\).

Hva spør oppgaven om? Likningen er lineær med konstante koeffisienter. Vi finner først homogen løsning, deretter en konstant partikulær løsning og bruker initialbetingelsen.

Steg 1 — Løs den homogene likningen

Steg 2 — Velg en partikulær prøvefunksjon

Steg 3 — Sett prøvefunksjonen inn

Steg 4 — Skriv den generelle løsningen

Steg 5 — Bruk initialbetingelsen

Steg 6 — Skriv den bestemte løsningen

Steg 7 — Kontroller initialverdien

from sympy import symbols, Function, Eq, dsolve, diff, exp, simplify

x = symbols('x', real=True)
y = Function('y')
solution = dsolve(Eq(diff(y(x), x) - 2*y(x), 3), ics={y(0): 2})
right_side = solution.rhs
ode_control = simplify(diff(right_side, x) - 2*right_side - 3)
initial_control = simplify(right_side.subs(x, 0))

print("SymPy-løsning =", solution)
print("Kontroll av differensiallikningen =", ode_control)
print("Kontroll av y(0) =", initial_control)

SymPy-løsning = Eq(y(x), 7*exp(2*x)/2 - 3/2)
Kontroll av differensiallikningen = 0
Kontroll av y(0) = 2

Fasit: \(\displaystyle y(x)=\frac72e^{2x}-\frac32\).

Hva spør oppgaven om? Vi skal kombinere de to oppgitte addisjonsformlene slik at sinusleddene kanselleres.

Steg 1 — Skriv de to identitetene under hverandre

Steg 2 — Legg venstresidene sammen

Steg 3 — Legg høyresidene sammen

Steg 4 — Kanseller sinusleddene

Steg 5 — Samle cosinusproduktene

Steg 6 — Divider med 2

from sympy import symbols, cos, simplify, trigsimp

u, v = symbols('u v', real=True)
left = cos(u)*cos(v)
right = (cos(u - v) + cos(u + v))/2
control = trigsimp(left - right)

print("Venstreside =", left)
print("Høyreside =", right)
print("Trigonometrisk forenklet differanse =", control)

Venstreside = cos(u)*cos(v)
Høyreside = cos(u - v)/2 + cos(u + v)/2
Trigonometrisk forenklet differanse = 0

Fasit: Identiteten er bevist.

Hva spør oppgaven om? Vi setter \(u=v=x\) i produkt-til-sum-formelen. Dermed omskrives kvadratet til en sum som kan integreres direkte.

Steg 1 — Sett \(u=x\) og \(v=x\)

Steg 2 — Forenkle vinklene

Steg 3 — Bruk \(\cos0=1\)

Steg 4 — Sett identiteten inn i integralet

Steg 5 — Integrer hvert ledd

Steg 6 — Skriv ferdig svar

from sympy import symbols, cos, sin, integrate, diff, simplify, trigsimp

x = symbols('x', real=True)
identity_right = (1 + cos(2*x))/2
identity_control = trigsimp(cos(x)**2 - identity_right)
primitive = x/2 + sin(2*x)/4
integral_control = trigsimp(diff(primitive, x) - cos(x)**2)

print("Halvvinkeluttrykk =", identity_right)
print("Kontroll av identiteten =", identity_control)
print("Stamfunksjon =", primitive)
print("Derivert minus integrand =", integral_control)

Halvvinkeluttrykk = cos(2*x)/2 + 1/2
Kontroll av identiteten = 0
Stamfunksjon = x/2 + sin(2*x)/4
Derivert minus integrand = 0

Fasit: \(\cos^2x=\frac{1+\cos2x}{2}\), og \(\displaystyle\int\cos^2x\,dx=\frac{x}{2}+\frac14\sin2x+C\).

Hva spør oppgaven om? Vi bruker fundamentalteoremet direkte fordi integranden er den deriverte av en funksjon som vi kjenner endepunktsverdiene til.

Steg 1 — Bruk tilleggsopplysningen

Steg 2 — Bytt integrand

Steg 3 — Bruk fundamentalteoremet

Steg 4 — Sett inn grensene

Steg 5 — Les verdiene fra tabellen

Steg 6 — Regn differansen

from sympy import Integer

g_at_2 = Integer(28)
g_at_minus_3 = Integer(6)
integral_value = g_at_2 - g_at_minus_3

print("g(2) =", g_at_2)
print("g(-3) =", g_at_minus_3)
print("Integralverdi = g(2) - g(-3) =", integral_value)

g(2) = 28
g(-3) = 6
Integralverdi = g(2) - g(-3) = 22

Fasit: \(\displaystyle\int_{-3}^{2}f(x)dx=22\).

Hva spør oppgaven om? Fordi \(h=g\prime\prime\), er \(g\prime=f\) en stamfunksjon til \(h\). Vi bruker derfor endepunktsverdiene til \(f\).

Steg 1 — Bruk opplysningen om \(h\)

Steg 2 — Finn en stamfunksjon til \(h\)

Steg 3 — Koble til tabellfunksjonen \(f\)

Steg 4 — Bruk fundamentalteoremet

Steg 5 — Erstatt \(g\prime\) med \(f\)

Steg 6 — Les av og regn

from sympy import Integer

f_at_1 = Integer(-2)
f_at_minus_3 = Integer(0)
integral_value = f_at_1 - f_at_minus_3

print("f(1) =", f_at_1)
print("f(-3) =", f_at_minus_3)
print("Integralverdi = f(1) - f(-3) =", integral_value)

f(1) = -2
f(-3) = 0
Integralverdi = f(1) - f(-3) = -2

Fasit: \(\displaystyle\int_{-3}^{1}h(x)dx=-2\).

Hva spør oppgaven om? Vi finner først retningsvektorene ved å trekke koordinater og bruker deretter definisjonen av skalarprodukt.

Steg 1 — Finn \(\overrightarrow{AB}\)

Steg 2 — Finn \(\overrightarrow{AC}\)

Steg 3 — Skriv formelen for skalarprodukt

Steg 4 — Sett inn koordinatene

Steg 5 — Regn hvert ledd

Steg 6 — Summer

from sympy import Matrix

A = Matrix([3, 0, -2])
B = Matrix([0, 2, 0])
C = Matrix([1, -1, 4])
AB = B - A
AC = C - A
dot_product = AB.dot(AC)

print("AB =", AB.T)
print("AC =", AC.T)
print("AB dot AC =", dot_product)

AB = Matrix([[-3, 2, 2]])
AC = Matrix([[-2, -1, 6]])
AB dot AC = 16

Fasit: \(\overrightarrow{AB}\cdot\overrightarrow{AC}=16\).

Hva spør oppgaven om? Et plan bestemmes av et punkt og en normalvektor. Vi finner normalen med kryssproduktet av to ikke-parallelle vektorer i planet.

Steg 1 — Bruk vektorene fra punkt a

Steg 2 — Finn kryssproduktet

Steg 3 — Regn komponentene

Steg 4 — Forenkle normalvektoren

Steg 5 — Bruk punkt-normal-formen gjennom A

Steg 6 — Forenkle planlikningen

Steg 7 — Kontroller de tre punktene

from sympy import Matrix, symbols, simplify

x, y, z = symbols('x y z', real=True)
A = Matrix([3, 0, -2])
B = Matrix([0, 2, 0])
C = Matrix([1, -1, 4])
AB = B - A
AC = C - A
normal = AB.cross(AC)
reduced_normal = normal/7
plane_expression = 2*x + 2*y + z - 4

print("AB x AC =", normal.T)
print("Forenklet normalvektor =", reduced_normal.T)
print("Planuttrykk =", plane_expression)
for name, point in [("A", A), ("B", B), ("C", C)]:
    value = plane_expression.subs({x: point[0], y: point[1], z: point[2]})
    print(f"Kontroll i {name} =", simplify(value))

AB x AC = Matrix([[14, 14, 7]])
Forenklet normalvektor = Matrix([[2, 2, 1]])
Planuttrykk = 2*x + 2*y + z - 4
Kontroll i A = 0
Kontroll i B = 0
Kontroll i C = 0

Fasit: \(\alpha:\;2x+2y+z-4=0\).

Hva spør oppgaven om? En linje vinkelrett på et plan har samme retning som en normalvektor til planet. Deretter bruker vi at \(xz\)-planet har likningen \(y=0\).

Steg 1 — Hent normalvektoren til planet

Steg 2 — Bruk normalen som retningsvektor

Steg 3 — Bruk punktet P

Steg 4 — Skriv komponentvis

Steg 5 — Bruk likningen for \(xz\)-planet

Steg 6 — Finn parameterverdien

Steg 7 — Finn de andre koordinatene

from sympy import symbols, solve, Matrix

t = symbols('t', real=True)
P = Matrix([5, 4, 4])
direction = Matrix([2, 2, 1])
Q = P + t*direction
t_intersection = solve(Q[1], t)[0]
intersection = Q.subs(t, t_intersection)

print("Linjen som vektor =", Q.T)
print("Likningen y(t) =", Q[1])
print("Parameter ved y=0 =", t_intersection)
print("Skjæringspunkt =", intersection.T)

Linjen som vektor = Matrix([[2*t + 5, 2*t + 4, t + 4]])
Likningen y(t) = 2*t + 4
Parameter ved y=0 = -2
Skjæringspunkt = Matrix([[1, 0, 2]])

Fasit: Parameterframstillingen er som oppgitt, og skjæringspunktet med \(xz\)-planet er \((1,0,2)\).

Hva spør oppgaven om? Volumet av en trekantet pyramide kan beregnes med absoluttverdien av et skalartrippelprodukt dividert med 6.

Steg 1 — Skriv koordinatene til Q

Steg 2 — Finn vektoren fra A til Q

Steg 3 — Bruk kryssproduktet fra punkt b

Steg 4 — Skriv volumformelen

Steg 5 — Regn skalartrippelproduktet

Steg 6 — Divider med 6

Steg 7 — Forenkle

from sympy import Matrix, symbols, simplify, Abs

t = symbols('t', real=True)
A = Matrix([3, 0, -2])
B = Matrix([0, 2, 0])
C = Matrix([1, -1, 4])
Q = Matrix([5 + 2*t, 4 + 2*t, 4 + t])
AB = B - A
AC = C - A
AQ = Q - A
triple_product = simplify(AB.cross(AC).dot(AQ))
volume = simplify(Abs(triple_product)/6)

print("AB x AC =", AB.cross(AC).T)
print("AQ =", AQ.T)
print("Skalartrippelprodukt =", triple_product)
print("Volum =", volume)
print("Kontroll ved t=-2 =", volume.subs(t, -2))

AB x AC = Matrix([[14, 14, 7]])
AQ = Matrix([[2*t + 2, 2*t + 4, t + 6]])
Skalartrippelprodukt = 63*t + 126
Volum = 21*Abs(t + 2)/2
Kontroll ved t=-2 = 0

Fasit: \(\displaystyle V(t)=\frac{21}{2}|t+2|\) volumenheter.

Hva spør oppgaven om? Vi setter volumuttrykket lik 42. Absoluttverdien gir to mulige parameterverdier, én på hver side av planet.

Steg 1 — Bruk volumfunksjonen

Steg 2 — Sett volumet lik 42

Steg 3 — Isoler absoluttverdien

Steg 4 — Løs de to tilfellene

Steg 5 — Finn parameterverdiene

Steg 6 — Sett \(t=2\) inn i linjen

Steg 7 — Sett \(t=-6\) inn i linjen

from sympy import symbols, Eq, solve, Abs, Matrix

t = symbols('t', real=True)
solutions = solve(Eq(21*Abs(t + 2)/2, 42), t)
Q = Matrix([5 + 2*t, 4 + 2*t, 4 + t])

print("Løsninger for t =", solutions)
for value in solutions:
    point = Q.subs(t, value)
    volume = 21*Abs(value + 2)/2
    print(f"t = {value}: Q =", point.T, "og V =", volume)

Løsninger for t = [-6, 2]
t = -6: Q = Matrix([[-7, -8, -2]]) og V = 42
t = 2: Q = Matrix([[9, 8, 6]]) og V = 42

Fasit: \(Q=(9,8,6)\) eller \(Q=(-7,-8,-2)\).

Hva spør oppgaven om? Vi løser den karakteristiske andregradslikningen. Komplekse konjugerte røtter gir en dempet kombinasjon av sinus og cosinus.

Steg 1 — Sett opp den karakteristiske likningen

Steg 2 — Bruk andregradsformelen

Steg 3 — Regn diskriminanten

Steg 4 — Ta kvadratroten av den negative diskriminanten

Steg 5 — Finn røttene

Steg 6 — Bruk standardformen for komplekse røtter

Steg 7 — Sett inn \(a=-0,2\) og \(b=1\)

Steg 8 — Bytt navn på konstantene

from sympy import symbols, Function, Eq, solve, dsolve, diff, Rational, simplify

r, x = symbols('r x', real=True)
y = Function('y')
characteristic = Eq(r**2 + Rational(2, 5)*r + Rational(26, 25), 0)
roots = solve(characteristic, r)
solution = dsolve(Eq(diff(y(x), x, 2) + Rational(2, 5)*diff(y(x), x) + Rational(26, 25)*y(x), 0))

print("Karakteristisk likning =", characteristic)
print("Karakteristiske røtter =", roots)
print("Generell løsning fra SymPy =", solution)

Karakteristisk likning = Eq(r**2 + 2*r/5 + 26/25, 0)
Karakteristiske røtter = []
Generell løsning fra SymPy = Eq(y(x), (C1*sin(x) + C2*cos(x))*exp(-x/5))

Fasit: \(\displaystyle y=e^{-0,2x}(C\sin x+D\cos x)\).

Hva spør oppgaven om? Vi setter de to oppgitte funksjonsverdiene inn i den generelle løsningen for å bestemme konstantene C og D.

Steg 1 — Start med den generelle løsningen

Steg 2 — Bruk \(y(0)=5\)

Steg 3 — Konkluder for D

Steg 4 — Bruk den andre betingelsen

Steg 5 — Fjern eksponentialfaktoren

Steg 6 — Sett inn eksakte trigonometriske verdier

Steg 7 — Løs for C

Steg 8 — Sett konstantene inn

from sympy import symbols, exp, sin, cos, pi, solve, Eq, simplify, Rational

x, C, D = symbols('x C D', real=True)
y_general = exp(-x/5)*(C*sin(x) + D*cos(x))
constants = solve([
    Eq(y_general.subs(x, 0), 5),
    Eq(y_general.subs(x, 3*pi/4), 0)
], [C, D], dict=True)[0]
y_solution = simplify(y_general.subs(constants))

print("Bestemte konstanter =", constants)
print("Løsning =", y_solution)
print("Kontroll y(0) =", simplify(y_solution.subs(x, 0)))
print("Kontroll y(3*pi/4) =", simplify(y_solution.subs(x, 3*pi/4)))

Bestemte konstanter = {C: 5, D: 5}
Løsning = 5*sqrt(2)*exp(-x/5)*sin(x + pi/4)
Kontroll y(0) = 5
Kontroll y(3*pi/4) = 0

Fasit: \(\displaystyle y=5e^{-0,2x}(\sin x+\cos x)\).

Hva spør oppgaven om? Vi tegner en dempet svingning: sinus- og cosinusleddet gir periodisk bevegelse, mens eksponentialfaktoren reduserer amplituden når x øker.

Steg 1 — Identifiser svingningsdelen

Steg 2 — Identifiser dempingen

Steg 3 — Finn startverdien

Steg 4 — Beskriv nullpunktene kvalitativt

Steg 5 — Velg digitalt vindu

Steg 6 — Kontroller grafens form

from sympy import symbols, exp, sin, cos, pi, N

x = symbols('x', real=True)
f = 5*exp(-x/5)*(sin(x) + cos(x))
check_points = [0, 3*pi/4, 7*pi/4, 15]

print("f(x) =", f)
for point in check_points:
    print(f"f({point}) =", N(f.subs(x, point), 12))
print("Startverdi f(0) =", f.subs(x, 0))

f(x) = 5*(sin(x) + cos(x))*exp(-x/5)
f(0) = 5.00000000000
f(3*pi/4) = 0
f(7*pi/4) = 0
f(15) = -0.0272335444952
Startverdi f(0) = 5

Fasit: Grafen er den viste dempede svingningen på \([0,15]\).

Hva spør oppgaven om? Produktet er null bare når trigonometridelen er null, fordi konstanten 5 og eksponentialfaktoren aldri er null.

Steg 1 — Sett funksjonen lik null

Steg 2 — Bruk at eksponentialfaktoren er positiv

Steg 3 — Flytt cosinusleddet

Steg 4 — Divider med \(\cos x\)

Steg 5 — Skriv den generelle løsningen

Steg 6 — Avgrens til intervallet

Steg 7 — Oppgi eksakte nullpunkter

Steg 8 — Oppgi desimaltall

from sympy import pi, N

zeros = [3*pi/4 + k*pi for k in range(5)]
print("Eksakte nullpunkter:")
for value in zeros:
    print(value)
print("\nDesimalverdier:")
for value in zeros:
    print(N(value, 12))
print("Siste nullpunkt er mindre enn 15:", bool(zeros[-1] < 15))
print("Neste nullpunkt er større enn 15:", bool(3*pi/4 + 5*pi > 15))

Eksakte nullpunkter:
3*pi/4
7*pi/4
11*pi/4
15*pi/4
19*pi/4

Desimalverdier:
2.35619449019
5.49778714378
8.63937979737
11.7809724510
14.9225651046
Siste nullpunkt er mindre enn 15: True
Neste nullpunkt er større enn 15: True

Fasit: Nullpunktene er \(x=\frac{3\pi}{4}+k\pi\) for \(k=0,1,2,3,4\).

Hva spør oppgaven om? Funksjonen er et produkt av en eksponentialfunksjon og en trigonometrisk sum. Vi bruker produktregelen og faktoriserer til ønsket form.

Steg 1 — Definer faktorene

Steg 2 — Deriver den første faktoren

Steg 3 — Deriver den andre faktoren

Steg 4 — Bruk produktregelen

Steg 5 — Sett inn

Steg 6 — Faktoriser eksponentialfaktoren

Steg 7 — Samle like ledd

Steg 8 — Faktoriser 2

from sympy import symbols, exp, sin, cos, diff, factor, simplify

x = symbols('x', real=True)
f = 5*exp(-x/5)*(sin(x) + cos(x))
f_prime = diff(f, x)
target = 2*exp(-x/5)*(2*cos(x) - 3*sin(x))

print("Direkte derivert =", f_prime)
print("Faktorisert derivert =", factor(f_prime))
print("Måluttrykk =", target)
print("Differanse etter forenkling =", simplify(f_prime - target))

Direkte derivert = 5*(-sin(x) + cos(x))*exp(-x/5) - (sin(x) + cos(x))*exp(-x/5)
Faktorisert derivert = 2*(-3*sin(x) + 2*cos(x))*exp(-x/5)
Måluttrykk = 2*(-3*sin(x) + 2*cos(x))*exp(-x/5)
Differanse etter forenkling = 0

Fasit: \(\displaystyle f\prime(x)=2e^{-0,2x}(2\cos x-3\sin x)\).

Hva spør oppgaven om? Vi løser \(f\prime(x)=0\), bestemmer fortegnsskiftet og evaluerer funksjonen i de kritiske punktene som er lokale toppunkter.

Steg 1 — Sett den deriverte lik null

Steg 2 — Fjern positive faktorer

Steg 3 — Løs trigonometrisk likning

Steg 4 — Skriv kritiske punkter

Steg 5 — Finn hvilke som er toppunkter

Steg 6 — Finn første toppverdi eksakt

Steg 7 — Evaluer første topp

Steg 8 — Evaluer de neste toppene

Her er \(\alpha=\arctan(2/3)\approx0,588\). Fortegnet veksler fordi faktoren \(2\cos x-3\sin x\) skifter fortegn ved hvert kritisk punkt.

from sympy import symbols, atan, pi, exp, sin, cos, N

x = symbols('x', real=True)
alpha = atan(2/3)
f = 5*exp(-x/5)*(sin(x) + cos(x))
top_x = [alpha + 2*k*pi for k in range(3)]

print("alpha =", N(alpha, 15))
for index, point in enumerate(top_x, start=1):
    value = N(f.subs(x, point), 15)
    print(f"Topp {index}: x = {N(point, 15)}, f(x) = {value}")
print("Fortegn rett før første kritiske punkt er positivt.")
print("Fortegn rett etter første kritiske punkt er negativt.")

alpha = 0.588002603547568
Topp 1: x = 0.588002603547568, f(x) = 6.16446051712932
Topp 2: x = 6.87118791072715, f(x) = 1.75446429269316
Topp 3: x = 13.1543732179067, f(x) = 0.499337281142770
Fortegn rett før første kritiske punkt er positivt.
Fortegn rett etter første kritiske punkt er negativt.

Fasit: Toppverdiene er omtrent \(6,164\), \(1,754\) og \(0,499\).

Hva spør oppgaven om? Vi bruker formelen for sinus av en sum og sammenligner koeffisientene foran sinus og cosinus.

Steg 1 — Start med ønsket form

Steg 2 — Utvid sinus av en sum

Steg 3 — Sett inn i ønsket form

Steg 4 — Sammenlign med originalfunksjonen

Steg 5 — Sammenlign koeffisientene

Steg 6 — Finn fasen

Steg 7 — Finn amplituden

Steg 8 — Skriv om funksjonen

from sympy import symbols, sqrt, pi, sin, cos, trigsimp

x = symbols('x', real=True)
original = 5*(sin(x) + cos(x))
combined = 5*sqrt(2)*sin(x + pi/4)
control = trigsimp(original - combined)

print("Original trigonometrisk del =", original)
print("Omskrevet trigonometrisk del =", combined)
print("A =", 5*sqrt(2))
print("phi =", pi/4)
print("Differanse etter trigonometrisk forenkling =", control)

Original trigonometrisk del = 5*sin(x) + 5*cos(x)
Omskrevet trigonometrisk del = 5*sqrt(2)*sin(x + pi/4)
A = 5*sqrt(2)
phi = pi/4
Differanse etter trigonometrisk forenkling = 0

Fasit: \(A=5\sqrt2\), \(\varphi=\frac\pi4\), og \(\displaystyle f(x)=5\sqrt2e^{-0,2x}\sin(x+\pi/4)\).

Hva spør oppgaven om? Den sammensatte sinusfunksjonen ligger alltid mellom -1 og 1. Multiplikasjon med den positive amplituden gir øvre og nedre konvolutt.

Steg 1 — Bruk formen fra punkt e

Steg 2 — Bruk verdiområdet til sinus

Steg 3 — Kontroller fortegnet til faktoren

Steg 4 — Multipliser ulikheten

Steg 5 — Gjenkjenn funksjonene

Steg 6 — Tolk grafisk

from sympy import symbols, sqrt, exp, sin, pi, N

x = symbols('x', real=True)
A = 5*sqrt(2)
f = A*exp(-x/5)*sin(x + pi/4)
p = A*exp(-x/5)
q = -A*exp(-x/5)

print("A =", A)
print("f(x) =", f)
print("p(x) =", p)
print("q(x) =", q)
for value in [0, 1, 5, 10, 15]:
    fv = N(f.subs(x, value), 10)
    pv = N(p.subs(x, value), 10)
    qv = N(q.subs(x, value), 10)
    print(f"x={value}: q={qv}, f={fv}, p={pv}, kontroll={qv <= fv <= pv}")

A = 5*sqrt(2)
f(x) = 5*sqrt(2)*exp(-x/5)*sin(x + pi/4)
p(x) = 5*sqrt(2)*exp(-x/5)
q(x) = -5*sqrt(2)*exp(-x/5)
x=0: q=-7.071067812, f=5.000000000, p=7.071067812, kontroll=True
x=1: q=-5.789300675, f=5.656501434, p=5.789300675, kontroll=True
x=5: q=-2.601300475, f=-1.242075200, p=2.601300475, kontroll=True
x=10: q=-0.9569649651, f=-0.9359061709, p=0.9569649651, kontroll=True
x=15: q=-0.3520477366, f=-0.02723354450, p=0.3520477366, kontroll=True

Fasit: \(q(x)\le f(x)\le p(x)\) for alle \(x\ge0\), med \(A=5\sqrt2\).

Hva spør oppgaven om? Nullpunktene er løsningene til samme trigonometriske likning som i oppgave 4b. Vi nummererer dem fra det første positive nullpunktet.

Steg 1 — Bruk nullpunktslikningen

Steg 2 — Løs likningen generelt

Steg 3 — Nummerer første nullpunkt med \(n=1\)

Steg 4 — Skriv følgeformelen eksakt

Steg 5 — Finn desimalverdien til første ledd

Steg 6 — Rund som i oppgaven

from sympy import symbols, pi, N

n = symbols('n', integer=True, positive=True)
x_n = 3*pi/4 + (n - 1)*pi

print("Eksakt følgeformel x_n =", x_n)
print("Første nullpunkt =", N(x_n.subs(n, 1), 12))
print("De seks første nullpunktene:")
for value in range(1, 7):
    print(value, N(x_n.subs(n, value), 12))

Eksakt følgeformel x_n = pi*(n - 1) + 3*pi/4
Første nullpunkt = 2.35619449019
De seks første nullpunktene:
1 2.35619449019
2 5.49778714378
3 8.63937979737
4 11.7809724510
5 14.9225651046
6 18.0641577581

Fasit: \(\displaystyle x_n=\frac{3\pi}{4}+(n-1)\pi\approx2,356+(n-1)\pi\).

Hva spør oppgaven om? Følgeformelen har konstant differanse π, så nullpunktene danner en aritmetisk følge. Vi løser en ulikhet for n.

Steg 1 — Sammenlign to påfølgende ledd

Steg 2 — Klassifiser følgen

Steg 3 — Bruk øvre grense

Steg 4 — Trekk fra første ledd

Steg 5 — Divider med π

Steg 6 — Finn største heltall n

Steg 7 — Kontroller de to siste kandidatene

from sympy import pi, N

zeros = []
n = 1
while True:
    value = 3*pi/4 + (n - 1)*pi
    if value >= 30:
        break
    zeros.append(value)
    n += 1

print("Antall nullpunkter i [0, 30) =", len(zeros))
print("Siste nullpunkt i intervallet =", N(zeros[-1], 15))
print("Første nullpunkt utenfor intervallet =", N(3*pi/4 + len(zeros)*pi, 15))
print("Fast differanse =", pi)

Antall nullpunkter i [0, 30) = 9
Siste nullpunkt i intervallet = 27.4889357189107
Første nullpunkt utenfor intervallet = 30.6305283725005
Fast differanse = pi

Fasit: Nullpunktene danner en aritmetisk følge med differanse \(\pi\), og intervallet \([0,30)\) inneholder 9 nullpunkter.

Hva spør oppgaven om? Toppunkter på samme side ligger 2π fra hverandre. Sinusdelen har samme verdi, mens eksponentialfaktoren multipliseres med en fast faktor.

Steg 1 — Skriv x-koordinatene til toppene

Steg 2 — Sammenlign to påfølgende toppverdier

Steg 3 — Forkort felles faktorer

Steg 4 — Beregn kvotienten

Steg 5 — Kontroller med oppgitte tall

Steg 6 — Konkluder at følgen er geometrisk

Steg 7 — Bruk formelen for femte ledd

Steg 8 — Regn ut

from sympy import pi, exp, atan, sqrt, N

ratio = exp(-2*pi/5)
first_top = 25/sqrt(13)*exp(-atan(2/3)/5)
terms = [first_top*ratio**k for k in range(5)]

print("Eksakt kvotient =", ratio)
print("Numerisk kvotient =", N(ratio, 15))
for index, term in enumerate(terms, start=1):
    print(f"a_{index} =", N(term, 15))
print("Kontroll a_2/a_1 =", N(terms[1]/terms[0], 15))
print("Kontroll a_3/a_2 =", N(terms[2]/terms[1], 15))

Eksakt kvotient = exp(-2*pi/5)
Numerisk kvotient = 0.284609543336029
a_1 = 6.16446051712932
a_2 = 1.75446429269316
a_3 = 0.499337281142770
a_4 = 0.142116155556698
a_5 = 0.0404476141336640
Kontroll a_2/a_1 = 0.284609543336029
Kontroll a_3/a_2 = 0.284609543336029

Fasit: Følgen er geometrisk med kvotient \(k=e^{-0,4\pi}\approx0,28461\), og det femte leddet er omtrent \(0,0404\).

Hva spør oppgaven om? Toppverdiene danner en geometrisk rekke. Vi kontrollerer at absoluttverdien av kvotienten er mindre enn 1 og bruker sumformelen.

Steg 1 — Bruk første ledd og kvotient

Steg 2 — Sjekk konvergenskravet

Steg 3 — Konkluder om konvergens

Steg 4 — Skriv sumformelen

Steg 5 — Sett inn

Steg 6 — Beregn summen

Steg 7 — Tolk resultatet

from sympy import pi, exp, atan, sqrt, summation, symbols, oo, simplify, N

n = symbols('n', integer=True, nonnegative=True)
ratio = exp(-2*pi/5)
first_top = 25/sqrt(13)*exp(-atan(2/3)/5)
formula_sum = simplify(first_top/(1 - ratio))
direct_sum = summation(first_top*ratio**n, (n, 0, oo))

print("Første ledd =", N(first_top, 15))
print("Kvotient =", N(ratio, 15))
print("Er abs(k) < 1?", bool(ratio < 1))
print("Sum fra formel =", N(formula_sum, 15))
print("Sum fra SymPy-summasjon =", N(direct_sum, 15))
print("Differanse =", simplify(formula_sum - direct_sum))

Første ledd = 6.16446051712932
Kvotient = 0.284609543336029
Er abs(k) < 1? True
Sum fra formel = 8.61691746053702
Sum fra SymPy-summasjon = 8.61691746053702
Differanse = -1.70971372923716*sqrt(13)*(exp(2*pi/5)/(1 - exp(2*pi/5)) + Sum(exp(-2*pi*n/5), (n, 0, oo)))

Fasit: Rekken konvergerer, og summen er omtrent \(8,617\).

Hva spør oppgaven om? Vi erstatter fart og akselerasjon med de deriverte av posisjonen og samler alle ledd på én side.

Steg 1 — Bruk definisjonen av fart

Steg 2 — Bruk definisjonen av akselerasjon

Steg 3 — Sett inn i Newtons likning

Steg 4 — Flytt alle ledd til høyre side

Steg 5 — Divider med massen

Steg 6 — Tolk koeffisientene

from sympy import symbols, Eq, solve, simplify

b, k, m, y, yp, ypp = symbols('b k m y yp ypp', nonzero=True)
newton_equation = Eq(-b*yp - k*y, m*ypp)
solved_for_ypp = solve(newton_equation, ypp)[0]
standard_form = simplify(ypp + b*yp/m + k*y/m)

print("Newtons likning =", newton_equation)
print("Løst for y'' =", solved_for_ypp)
print("Standardformens venstreside =", standard_form)
print("Når y'' erstattes fra Newton-likningen =", simplify(standard_form.subs(ypp, solved_for_ypp)))

Newtons likning = Eq(-b*yp - k*y, m*ypp)
Løst for y'' = (-b*yp - k*y)/m
Standardformens venstreside = (b*yp + k*y + m*ypp)/m
Når y'' erstattes fra Newton-likningen = 0

Fasit: \(\displaystyle y\prime\prime+\frac bm y\prime+\frac km y=0\).

Hva spør oppgaven om? Vi beregner koeffisientene og bruker løsningen fra oppgave 3, siden differensiallikningen og betingelsene er de samme.

Steg 1 — Beregn dempingskoeffisienten

Steg 2 — Beregn fjærkoeffisienten

Steg 3 — Sett inn i standardformen

Steg 4 — Bruk den generelle løsningen

Steg 5 — Bruk \(y(0)=5\)

Steg 6 — Bruk \(y(3\pi/4)=0\)

Steg 7 — Skriv den bestemte bevegelsen

Steg 8 — Kontroller enheten

from sympy import symbols, Function, Eq, dsolve, diff, Rational, pi, simplify

t = symbols('t', real=True)
y = Function('y')
b_over_m = Rational(10, 10)/Rational(25, 10)
k_over_m = Rational(26, 10)/Rational(25, 10)
solution = dsolve(
    Eq(diff(y(t), t, 2) + b_over_m*diff(y(t), t) + k_over_m*y(t), 0),
    ics={y(0): 5, y(3*pi/4): 0}
)

print("b/m =", b_over_m)
print("k/m =", k_over_m)
print("Differensiallikning: y'' +", b_over_m, "y' +", k_over_m, "y = 0")
print("Løsning fra SymPy =", solution)
print("Kontroll y(0) =", simplify(solution.rhs.subs(t, 0)))
print("Kontroll y(3*pi/4) =", simplify(solution.rhs.subs(t, 3*pi/4)))

b/m = 2/5
k/m = 26/25
Differensiallikning: y'' + 2/5 y' + 26/25 y = 0
Løsning fra SymPy = Eq(y(t), (5*sin(t) + 5*cos(t))*exp(-t/5))
Kontroll y(0) = 5
Kontroll y(3*pi/4) = 0

Fasit: \(\displaystyle y(t)=5e^{-0,2t}(\sin t+\cos t)\) desimeter.

Hva spør oppgaven om? Loddet passerer likevektsstillingen når y(t)=0. Vi løser nullpunktslikningen og sammenligner påfølgende tidspunkter.

Steg 1 — Sett utslaget lik null

Steg 2 — Fjern faktorene som ikke kan være null

Steg 3 — Løs den trigonometriske likningen

Steg 4 — Finn neste passering

Steg 5 — Finn tidsforskjellen

Steg 6 — Tolk

from sympy import pi, simplify

passage_times = [3*pi/4 + n*pi for n in range(5)]
print("De fem første passeringstidene:")
for value in passage_times:
    print(value)
print("Tidsforskjeller:")
for left, right in zip(passage_times, passage_times[1:]):
    print(simplify(right - left))

De fem første passeringstidene:
3*pi/4
7*pi/4
11*pi/4
15*pi/4
19*pi/4
Tidsforskjeller:
pi
pi
pi
pi

Fasit: Det går \(\pi\) sekunder mellom hver passering av likevektsstillingen.

Hva spør oppgaven om? Maksima på samme side ligger én hel periode, 2π sekunder, fra hverandre. Bare eksponentialfaktoren endrer størrelsen mellom disse punktene.

Steg 1 — Finn tiden mellom utslag på samme side

Steg 2 — Sammenlign eksponentialfaktorene

Steg 3 — Beregn gjenværende andel

Steg 4 — Gjør andelen om til prosent

Steg 5 — Finn reduksjonen

Steg 6 — Rund som oppgaven ber om

Steg 7 — Koble til de målte toppverdiene

from sympy import pi, exp, N

remaining_ratio = exp(-2*pi/5)
remaining_percent = 100*remaining_ratio
decrease_percent = 100*(1 - remaining_ratio)

print("Gjenværende forhold =", N(remaining_ratio, 15))
print("Gjenværende prosent =", N(remaining_percent, 15))
print("Prosentvis reduksjon =", N(decrease_percent, 15))
print("Avrundet til én desimal =", round(float(decrease_percent), 1), "%")

Gjenværende forhold = 0.284609543336029
Gjenværende prosent = 28.4609543336029
Prosentvis reduksjon = 71.5390456663971
Avrundet til én desimal = 71.5 %

Fasit: Maksimalutslaget på samme side reduseres med omtrent \(71,5\,\%\) fra gang til gang.

Hva spør oppgaven om? Vi parer første og siste ledd. Hvert par får samme sum, og dette gir den kjente formelen for summen av de n første positive heltallene.

Steg 1 — Skriv summen forlengs

Steg 2 — Skriv den samme summen baklengs

Steg 3 — Legg summene sammen leddvis

Steg 4 — Tell antall ledd

Steg 5 — Divider med 2

Steg 6 — Sett inn \(n=8\)

Steg 7 — Regn ut

from sympy import symbols, summation, simplify

k, n = symbols('k n', integer=True, positive=True)
symbolic_sum = summation(k, (k, 1, n))
formula = n*(n + 1)/2

print("Symbolsk sum =", symbolic_sum)
print("Oppgitt formel =", formula)
print("Differanse etter forenkling =", simplify(symbolic_sum - formula))
print("S_8 =", symbolic_sum.subs(n, 8))

Symbolsk sum = n**2/2 + n/2
Oppgitt formel = n*(n + 1)/2
Differanse etter forenkling = 0
S_8 = 36

Fasit: \(\displaystyle S_n=\frac{n(n+1)}2\), og \(S_8=36\).

Hva spør oppgaven om? Vi beregner delsummene fortløpende til grensen passeres og kontrollerer både den siste summen under grensen og den første over.

Steg 1 — Definer delsum

Steg 2 — Start med små n

Steg 3 — Finn summen ved \(n=15\)

Steg 4 — Sammenlign med grensen

Steg 5 — Finn neste delsum

Steg 6 — Sammenlign på nytt

Steg 7 — Konkluder minimalitet

limit = 15000
total = 0
n = 0

print("n | delsum")
print("--+-------")
while total <= limit:
    n += 1
    total += n**3
    if n >= 13:
        print(f"{n:2d} | {total}")

previous_total = total - n**3
print("\nFørste n med sum > 15000 =", n)
print("s_15 =", previous_total)
print("s_16 =", total)
print("Kontroll s_15 <= 15000:", previous_total <= limit)
print("Kontroll s_16 > 15000:", total > limit)

n | delsum
--+-------
13 | 8281
14 | 11025
15 | 14400
16 | 18496

Første n med sum > 15000 = 16
s_15 = 14400
s_16 = 18496
Kontroll s_15 <= 15000: True
Kontroll s_16 > 15000: True

Fasit: Rekken må ha minst 16 ledd.

Hva spør oppgaven om? Et fullstendig induksjonsbevis må ha grunntrinn, induksjonshypotese og et induksjonssteg der vi faktisk viser formelen for k+1.

Steg 1 — Grunntrinn: sett \(n=1\)

Steg 2 — Induksjonshypotese

Steg 3 — Start venstresiden for \(k+1\)

Steg 4 — Bruk induksjonshypotesen

Steg 5 — Faktoriser \((k+1)^2\)

Steg 6 — Samle uttrykket i parentes

Steg 7 — Sett sammen

Steg 8 — Konklusjon

from sympy import symbols, summation, simplify, factor

j, k, n = symbols('j k n', integer=True, positive=True)
formula_n = n**2*(n + 1)**2/4
ground_left = 1**3
ground_right = formula_n.subs(n, 1)
hypothesis_expression = k**2*(k + 1)**2/4
step_left = hypothesis_expression + (k + 1)**3
step_target = (k + 1)**2*(k + 2)**2/4

print("Grunntrinn, venstreside =", ground_left)
print("Grunntrinn, høyreside =", ground_right)
print("Induksjonssteg før faktorisering =", step_left)
print("Induksjonssteg faktorisert =", factor(step_left))
print("Mål for k+1 =", step_target)
print("Differanse i induksjonssteget =", simplify(step_left - step_target))
print("Direkte symbolsk sum =", summation(j**3, (j, 1, n)))
print("Direkte kontroll mot formelen =", simplify(summation(j**3, (j, 1, n)) - formula_n))

Grunntrinn, venstreside = 1
Grunntrinn, høyreside = 1
Induksjonssteg før faktorisering = k**2*(k + 1)**2/4 + (k + 1)**3
Induksjonssteg faktorisert = (k + 1)**2*(k + 2)**2/4
Mål for k+1 = (k + 1)**2*(k + 2)**2/4
Differanse i induksjonssteget = 0
Direkte symbolsk sum = n**4/4 + n**3/2 + n**2/4
Direkte kontroll mot formelen = 0

Fasit: Formelen er bevist for alle positive heltall \(n\).

Hva spør oppgaven om? Vi bruker resultatet fra a for summen av heltallene og resultatet fra c for summen av kubene. Begge gir det samme algebraiske uttrykket.

Steg 1 — Bruk kubesumformelen

Steg 2 — Skriv uttrykket som et kvadrat

Steg 3 — Bruk formelen fra punkt a

Steg 4 — Kvadrer summen

Steg 5 — Sammenlign uttrykkene

Steg 6 — Konkluder

from sympy import symbols, summation, simplify

k, n = symbols('k n', integer=True, positive=True)
sum_cubes = summation(k**3, (k, 1, n))
sum_integers = summation(k, (k, 1, n))
control = simplify(sum_cubes - sum_integers**2)

print("Sum av kuber =", sum_cubes)
print("Sum av heltall =", sum_integers)
print("Kvadratet av heltallssummen =", sum_integers**2)
print("Differanse =", control)
for value in [3, 5, 10]:
    print(f"n={value}: kubesum={sum_cubes.subs(n, value)}, kvadrat={sum_integers.subs(n, value)**2}")

Sum av kuber = n**4/4 + n**3/2 + n**2/4
Sum av heltall = n**2/2 + n/2
Kvadratet av heltallssummen = (n**2/2 + n/2)**2
Differanse = 0
n=3: kubesum=36, kvadrat=36
n=5: kubesum=225, kvadrat=225
n=10: kubesum=3025, kvadrat=3025

Fasit: Identiteten følger direkte av de to sumformlene.