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

x = symbols('x', real=True)
f = 2*sin(3*x)
derivative = diff(f, x)
expected = 6*cos(3*x)

print("Funksjon f(x) =", f)
print("Derivert f'(x) =", derivative)
print("Forventet uttrykk =", expected)
print("Symbolsk differanse =", simplify(derivative - expected))
print("Kontroll ved x=0 =", derivative.subs(x, 0))
print("Kontroll ved x=pi/6 =", simplify(derivative.subs(x, pi/6)))

assert simplify(derivative - expected) == 0

Kjørt utskriftFunksjon f(x) = 2*sin(3*x)
Derivert f'(x) = 6*cos(3*x)
Forventet uttrykk = 6*cos(3*x)
Symbolsk differanse = 0
Kontroll ved x=0 = 6
Kontroll ved x=pi/6 = 0

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

x = symbols('x', real=True, nonzero=True)
g = sin(x)/x
derivative = simplify(diff(g, x))
expected = (x*cos(x) - sin(x))/x**2

print("Funksjon g(x) =", g)
print("Derivert g'(x) =", derivative)
print("Forventet uttrykk =", expected)
print("Symbolsk differanse =", simplify(derivative - expected))
print("Numerisk kontroll ved x=1 =", derivative.subs(x, 1).evalf(12))
print("Numerisk kontroll ved x=2 =", derivative.subs(x, 2).evalf(12))

assert simplify(derivative - expected) == 0

Kjørt utskriftFunksjon g(x) = sin(x)/x
Derivert g'(x) = (x*cos(x) - sin(x))/x**2
Forventet uttrykk = (x*cos(x) - sin(x))/x**2
Symbolsk differanse = 0
Numerisk kontroll ved x=1 = -0.301168678940
Numerisk kontroll ved x=2 = -0.435397774980

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

x = symbols('x', real=True)
h = x*cos(x**2)
derivative = diff(h, x)
expected = cos(x**2) - 2*x**2*sin(x**2)

print("Funksjon h(x) =", h)
print("Derivert h'(x) =", derivative)
print("Forventet uttrykk =", expected)
print("Symbolsk differanse =", simplify(derivative - expected))
print("Kontroll ved x=0 =", derivative.subs(x, 0))
print("Kontroll ved x=1 =", derivative.subs(x, 1).evalf(12))

assert simplify(derivative - expected) == 0

Kjørt utskriftFunksjon h(x) = x*cos(x**2)
Derivert h'(x) = -2*x**2*sin(x**2) + cos(x**2)
Forventet uttrykk = -2*x**2*sin(x**2) + cos(x**2)
Symbolsk differanse = 0
Kontroll ved x=0 = 1
Kontroll ved x=1 = -1.14263966375

from sympy import symbols, integrate, diff, simplify

x = symbols('x', real=True)
integrand = x**3 - 3*x + 2
antiderivative = integrate(integrand, x)
expected = x**4/4 - 3*x**2/2 + 2*x

print("Integrand =", integrand)
print("Stamfunksjon fra SymPy =", antiderivative)
print("Forventet stamfunksjon =", expected)
print("Derivert tilbake =", diff(expected, x))
print("Kontrollforskjell =", simplify(diff(expected, x) - integrand))
print("Eksempelverdi F(2) =", expected.subs(x, 2))

assert simplify(antiderivative - expected) == 0
assert simplify(diff(expected, x) - integrand) == 0

Kjørt utskriftIntegrand = x**3 - 3*x + 2
Stamfunksjon fra SymPy = x**4/4 - 3*x**2/2 + 2*x
Forventet stamfunksjon = x**4/4 - 3*x**2/2 + 2*x
Derivert tilbake = x**3 - 3*x + 2
Kontrollforskjell = 0
Eksempelverdi F(2) = 2

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

x = symbols('x', real=True)
integrand = x*exp(2*x)
antiderivative = integrate(integrand, x)
expected = exp(2*x)*(2*x - 1)/4

print("Integrand =", integrand)
print("Stamfunksjon fra SymPy =", antiderivative)
print("Faktorisert forventet form =", expected)
print("SymPy-form faktorisert =", factor(antiderivative))
print("Derivert tilbake =", simplify(diff(expected, x)))
print("Kontrollforskjell =", simplify(diff(expected, x) - integrand))

assert simplify(antiderivative - expected) == 0
assert simplify(diff(expected, x) - integrand) == 0

Kjørt utskriftIntegrand = x*exp(2*x)
Stamfunksjon fra SymPy = (2*x - 1)*exp(2*x)/4
Faktorisert forventet form = (2*x - 1)*exp(2*x)/4
SymPy-form faktorisert = (2*x - 1)*exp(2*x)/4
Derivert tilbake = x*exp(2*x)
Kontrollforskjell = 0

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

x = symbols('x', real=True)
integrand = x*sqrt(x**2 + 1)
antiderivative = integrate(integrand, x)
from sympy import Rational
expected = (x**2 + 1)**Rational(3,2)/3

print("Integrand =", integrand)
print("Stamfunksjon fra SymPy =", antiderivative)
print("Forventet uttrykk =", expected)
print("Derivert tilbake =", simplify(diff(expected, x)))
print("Kontrollforskjell =", simplify(diff(expected, x) - integrand))
print("Numerisk kontroll ved x=2 =", simplify(diff(expected,x).subs(x,2)))

assert simplify(diff(expected, x) - integrand) == 0

Kjørt utskriftIntegrand = x*sqrt(x**2 + 1)
Stamfunksjon fra SymPy = x**2*sqrt(x**2 + 1)/3 + sqrt(x**2 + 1)/3
Forventet uttrykk = (x**2 + 1)**(3/2)/3
Derivert tilbake = x*sqrt(x**2 + 1)
Kontrollforskjell = 0
Numerisk kontroll ved x=2 = 2*sqrt(5)

from sympy import symbols, sin, pi, solveset, Interval, simplify

x = symbols('x', real=True)
expression = 2*sin(2*x) - 1
solution_set = solveset(expression, x, domain=Interval(0, 2*pi))
expected = [pi/12, 5*pi/12, 13*pi/12, 17*pi/12]

print("Likningsuttrykk =", expression)
print("Løsningsmengde på [0, 2*pi] =", solution_set)
print("Forventede løsninger =", expected)
for value in expected:
    print("x =", value, "gir uttrykket", simplify(expression.subs(x, value)))
print("Antall løsninger =", len(expected))

assert all(simplify(expression.subs(x,v)) == 0 for v in expected)

Kjørt utskriftLikningsuttrykk = 2*sin(2*x) - 1
Løsningsmengde på [0, 2*pi] = {pi/12, 5*pi/12, 13*pi/12, 17*pi/12}
Forventede løsninger = [pi/12, 5*pi/12, 13*pi/12, 17*pi/12]
x = pi/12 gir uttrykket 0
x = 5*pi/12 gir uttrykket 0
x = 13*pi/12 gir uttrykket 0
x = 17*pi/12 gir uttrykket 0
Antall løsninger = 4

from sympy import symbols, cos, pi, factor, solve, solveset, Interval, simplify

x, u = symbols('x u', real=True)
polynomial = 2*u**2 + 3*u - 2
u_solutions = solve(polynomial, u)
expression = 2*cos(x)**2 + 3*cos(x) - 2
solution_set = solveset(expression, x, domain=Interval(0, 2*pi))
expected = [pi/3, 5*pi/3]

print("Andregradspolynom =", polynomial)
print("Faktorisert =", factor(polynomial))
print("Algebraiske u-løsninger =", u_solutions)
print("Gyldige cosinusverdier =", [v for v in u_solutions if -1 <= v <= 1])
print("Løsningsmengde for x =", solution_set)
for value in expected:
    print("Kontroll x =", value, "->", simplify(expression.subs(x,value)))

from sympy import Rational
assert u_solutions == [-2, Rational(1,2)]
assert all(simplify(expression.subs(x,v)) == 0 for v in expected)

Kjørt utskriftAndregradspolynom = 2*u**2 + 3*u - 2
Faktorisert = (u + 2)*(2*u - 1)
Algebraiske u-løsninger = [-2, 1/2]
Gyldige cosinusverdier = [1/2]
Løsningsmengde for x = {pi/3, 5*pi/3}
Kontroll x = pi/3 -> 0
Kontroll x = 5*pi/3 -> 0

from sympy import symbols, sin, pi, diff, solve, simplify

x = symbols('x', real=True)
f = 2*sin(pi*x - pi/2) + 3
f_prime = simplify(diff(f, x))
critical = [0, 1, 2, 3, 4]
endpoints = [-1, 5]
points = [(value, simplify(f.subs(x,value))) for value in endpoints + critical]

print("f(x) =", f)
print("f'(x) =", f_prime)
print("Kritiske punkter fra f'(x)=0 i intervallet =", critical)
print("Funksjonsverdier i endepunkter og kritiske punkter:")
for point in points:
    print("  ", point)
print("Toppunkter =", [p for p in points if p[1] == 5])
print("Bunnpunkter =", [p for p in points if p[1] == 1])

assert [p for p in points if p[1] == 5] == [(-1,5),(5,5),(1,5),(3,5)]

Kjørt utskriftf(x) = 3 - 2*cos(pi*x)
f'(x) = 2*pi*sin(pi*x)
Kritiske punkter fra f'(x)=0 i intervallet = [0, 1, 2, 3, 4]
Funksjonsverdier i endepunkter og kritiske punkter:
   (-1, 5)
   (5, 5)
   (0, 1)
   (1, 5)
   (2, 1)
   (3, 5)
   (4, 1)
Toppunkter = [(-1, 5), (5, 5), (1, 5), (3, 5)]
Bunnpunkter = [(0, 1), (2, 1), (4, 1)]

from sympy import symbols, sin, pi, simplify

x = symbols('x', real=True)
f = 2*sin(pi*x - pi/2) + 3
sample_x = [-1, -1/2, 0, 1/2, 1, 3/2, 2, 5/2, 3, 7/2, 4, 9/2, 5]

print("Funksjon =", f)
print("Amplitude = 2")
print("Midtlinje = y = 3")
print("Periode =", simplify(2*pi/pi))
print("Nøkkelpunkter for skissen:")
for value in sample_x:
    print("x =", value, "f(x) =", simplify(f.subs(x,value)))
print("Verdiområde på intervallet: [1, 5]")

assert simplify(f.subs(x,0)-1) == 0
assert simplify(f.subs(x,1)-5) == 0

Kjørt utskriftFunksjon = 3 - 2*cos(pi*x)
Amplitude = 2
Midtlinje = y = 3
Periode = 2
Nøkkelpunkter for skissen:
x = -1 f(x) = 5
x = -0.5 f(x) = 3
x = 0 f(x) = 1
x = 0.5 f(x) = 3
x = 1 f(x) = 5
x = 1.5 f(x) = 3
x = 2 f(x) = 1
x = 2.5 f(x) = 3
x = 3 f(x) = 5
x = 3.5 f(x) = 3
x = 4 f(x) = 1
x = 4.5 f(x) = 3
x = 5 f(x) = 5
Verdiområde på intervallet: [1, 5]

from sympy import symbols, sin, cos, pi, integrate, simplify

x = symbols('x', real=True)
f = 2*sin(pi*x - pi/2) + 3
rewritten = simplify(f.rewrite(cos))
area = integrate(f, (x,0,4))
antiderivative = integrate(f, x)

print("f(x) =", f)
print("Omskrevet form =", rewritten)
print("Stamfunksjon =", antiderivative)
print("Bestemt integral fra 0 til 4 =", area)
print("Nedre minimum på intervallet = 1, så integralet er geometrisk areal")
print("Kontroll med to perioder: gjennomsnittsverdi 3 * intervallengde 4 =", 3*4)

assert simplify(area - 12) == 0

Kjørt utskriftf(x) = 3 - 2*cos(pi*x)
Omskrevet form = 3 - 2*cos(pi*x)
Stamfunksjon = 3*x - 2*sin(pi*x)/pi
Bestemt integral fra 0 til 4 = 12
Nedre minimum på intervallet = 1, så integralet er geometrisk areal
Kontroll med to perioder: gjennomsnittsverdi 3 * intervallengde 4 = 12

from sympy import Matrix, simplify

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

print("A =", A.T)
print("B =", B.T)
print("C =", C.T)
print("AB =", AB.T)
print("AC =", AC.T)
print("AB x AC =", cross.T)
print("Skalarprodukt med AB =", simplify(cross.dot(AB)))
print("Skalarprodukt med AC =", simplify(cross.dot(AC)))

assert cross == Matrix([18,2,10])
assert cross.dot(AB) == 0 and cross.dot(AC) == 0

Kjørt utskriftA = Matrix([[1, 0, 3]])
B = Matrix([[3, 2, -1]])
C = Matrix([[0, 4, 4]])
AB = Matrix([[2, 2, -4]])
AC = Matrix([[-1, 4, 1]])
AB x AC = Matrix([[18, 2, 10]])
Skalarprodukt med AB = 0
Skalarprodukt med AC = 0

from sympy import Matrix

points = {
    "A": Matrix([1,0,3]),
    "B": Matrix([3,2,-1]),
    "C": Matrix([0,4,4]),
}
normal = Matrix([9,1,5])

print("Plan: 9*x + y + 5*z = 24")
for name, point in points.items():
    left_side = normal.dot(point)
    print(name, "=", point.T, "gir venstresiden", left_side)
print("Normalvektor =", normal.T)
print("2 * normalvektor =", (2*normal).T)
print("Kryssproduktet fra a) =", (points['B']-points['A']).cross(points['C']-points['A']).T)

assert all(normal.dot(point) == 24 for point in points.values())

Kjørt utskriftPlan: 9*x + y + 5*z = 24
A = Matrix([[1, 0, 3]]) gir venstresiden 24
B = Matrix([[3, 2, -1]]) gir venstresiden 24
C = Matrix([[0, 4, 4]]) gir venstresiden 24
Normalvektor = Matrix([[9, 1, 5]])
2 * normalvektor = Matrix([[18, 2, 10]])
Kryssproduktet fra a) = Matrix([[18, 2, 10]])

from sympy import symbols, Matrix, Eq, solve, simplify, Rational

t = symbols('t', real=True)
T = Matrix([11,7,5])
normal = Matrix([9,1,5])
line_point = T + t*normal
plane_equation = Eq(normal.dot(line_point), 24)
t_value = solve(plane_equation, t)[0]
H = line_point.subs(t, t_value)

print("Linje l: (x,y,z) =", T.T, "+ t", normal.T)
print("Punkt på linjen =", line_point.T)
print("Likning etter innsetting i planet =", plane_equation)
print("Parameter ved skjæring t =", t_value)
print("Skjæringspunkt H =", H.T)
print("Plan-kontroll 9x+y+5z =", simplify(normal.dot(H)))
print("TH er parallell med normalvektoren =", (T-H).cross(normal).T)

assert t_value == -1
assert simplify(normal.dot(H)) == 24

Kjørt utskriftLinje l: (x,y,z) = Matrix([[11, 7, 5]]) + t Matrix([[9, 1, 5]])
Punkt på linjen = Matrix([[9*t + 11, t + 7, 5*t + 5]])
Likning etter innsetting i planet = Eq(107*t + 131, 24)
Parameter ved skjæring t = -1
Skjæringspunkt H = Matrix([[2, 6, 0]])
Plan-kontroll 9x+y+5z = 24
TH er parallell med normalvektoren = Matrix([[0, 0, 0]])

from sympy import Matrix, sqrt, simplify, Abs, Rational

A = Matrix([1,0,3])
B = Matrix([3,2,-1])
C = Matrix([0,4,4])
T = Matrix([11,7,5])
AB = B-A
AC = C-A
AT = T-A
cross = AB.cross(AC)
base_area = sqrt(cross.dot(cross))/2
height = Abs(9*T[0] + T[1] + 5*T[2] - 24)/sqrt(107)
volume_geometry = simplify(base_area*height/3)
triple = simplify(Abs(cross.dot(AT))/6)

print("AB x AC =", cross.T)
print("Grunnflateareal =", base_area)
print("Høyde fra T til planet =", height)
print("Volum fra grunnflate og høyde =", volume_geometry)
print("Skalartrippelprodukt / 6 =", triple)
print("Kontrollforskjell =", simplify(volume_geometry - triple))

assert volume_geometry == Rational(107,3)
assert triple == Rational(107,3)

Kjørt utskriftAB x AC = Matrix([[18, 2, 10]])
Grunnflateareal = sqrt(107)
Høyde fra T til planet = sqrt(107)
Volum fra grunnflate og høyde = 107/3
Skalartrippelprodukt / 6 = 107/3
Kontrollforskjell = 0

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

x = symbols('x', real=True)
y = Function('y')
ode = Eq(diff(y(x),x,2) - 9*diff(y(x),x) - 10*y(x), 0)
solution = dsolve(ode, ics={y(0):4, diff(y(x),x).subs(x,0):7})
expected = exp(10*x) + 3*exp(-x)
residual = simplify(diff(expected,x,2) - 9*diff(expected,x) - 10*expected)

print("Differensiallikning =", ode)
print("Løsning fra SymPy =", solution)
print("Forventet y(x) =", expected)
print("Residual i differensiallikningen =", residual)
print("y(0) =", expected.subs(x,0))
print("y'(0) =", diff(expected,x).subs(x,0))

assert simplify(solution.rhs - expected) == 0
assert residual == 0

Kjørt utskriftDifferensiallikning = Eq(-10*y(x) - 9*Derivative(y(x), x) + Derivative(y(x), (x, 2)), 0)
Løsning fra SymPy = Eq(y(x), exp(10*x) + 3*exp(-x))
Forventet y(x) = exp(10*x) + 3*exp(-x)
Residual i differensiallikningen = 0
y(0) = 4
y'(0) = 7

from sympy import symbols, summation, simplify, factor

k, n = symbols('k n', integer=True, positive=True)
a_k = 3*k - 2
sum_formula = summation(a_k, (k,1,n))
expected = (3*n**2 - n)/2
arithmetic_formula = n*((3*1-2)+(3*n-2))/2

print("Generelt ledd a_k =", a_k)
print("Første ledd a_1 =", a_k.subs(k,1))
print("Siste ledd a_n =", 3*n-2)
print("Aritmetisk sumformel =", simplify(arithmetic_formula))
print("Symbolsk sum fra SymPy =", sum_formula)
print("Faktorisert form =", factor(sum_formula))
print("Kontrollforskjell =", simplify(sum_formula-expected))

assert simplify(sum_formula-expected) == 0

Kjørt utskriftGenerelt ledd a_k = 3*k - 2
Første ledd a_1 = 1
Siste ledd a_n = 3*n - 2
Aritmetisk sumformel = n*(3*n - 1)/2
Symbolsk sum fra SymPy = 3*n**2/2 - n/2
Faktorisert form = n*(3*n - 1)/2
Kontrollforskjell = 0

from sympy import symbols, simplify, expand

k = symbols('k', integer=True, positive=True)
induction_hypothesis = (3*k**2 - k)/2
next_term = 3*(k+1) - 2
left_side = simplify(induction_hypothesis + next_term)
right_side = simplify((3*(k+1)**2 - (k+1))/2)

print("Basis: s_1 =", 1)
print("Formel ved n=1 =", (3*1**2-1)/2)
print("Induksjonshypotese s_k =", induction_hypothesis)
print("Neste ledd a_(k+1) =", next_term)
print("s_(k+1) fra hypotesen =", expand(left_side))
print("Formelen ved k+1 =", expand(right_side))
print("Symbolsk differanse =", simplify(left_side-right_side))

assert simplify(left_side-right_side) == 0

Kjørt utskriftBasis: s_1 = 1
Formel ved n=1 = 1.0
Induksjonshypotese s_k = 3*k**2/2 - k/2
Neste ledd a_(k+1) = 3*k + 1
s_(k+1) fra hypotesen = 3*k**2/2 + 5*k/2 + 1
Formelen ved k+1 = 3*k**2/2 + 5*k/2 + 1
Symbolsk differanse = 0

from sympy import symbols, log, ceiling, N, Rational

n = symbols('n', integer=True, positive=True)
first = Rational(12,1)
ratio = Rational(94,100)
threshold = Rational(100,1)
critical = log(Rational(1,2))/log(ratio)
minimum_n = ceiling(critical)

def depth(number_of_hits):
    return first*(1-ratio**number_of_hits)/(1-ratio)

print("Første slag =", first, "cm")
print("Geometrisk kvotient =", ratio)
print("Kritisk reell n-verdi =", N(critical, 12))
print("Minste heltall n =", minimum_n)
print("Dybde etter 11 slag =", N(depth(11), 12), "cm")
print("Dybde etter 12 slag =", N(depth(12), 12), "cm")
print("Er S_11 > 100?", bool(depth(11) > threshold))
print("Er S_12 > 100?", bool(depth(12) > threshold))

assert minimum_n == 12
assert depth(11) < 100 < depth(12)

Kjørt utskriftFørste slag = 12 cm
Geometrisk kvotient = 47/50
Kritisk reell n-verdi = 11.2023055836
Minste heltall n = 12
Dybde etter 11 slag = 98.7403585502 cm
Dybde etter 12 slag = 104.815937037 cm
Er S_11 > 100? False
Er S_12 > 100? True

from sympy import Rational, summation, symbols, oo, simplify

n = symbols('n', integer=True, positive=True)
first = Rational(12,1)
ratio = Rational(94,100)
infinite_sum = summation(first*ratio**(n-1), (n,1,oo))
target_cm = Rational(220,1)

print("Geometrisk rekke: 12 + 12*0.94 + 12*0.94^2 + ...")
print("Kvotient =", ratio)
print("Uendelig sum =", infinite_sum, "cm")
print("Uendelig sum i meter =", infinite_sum/100)
print("Mål =", target_cm, "cm")
print("Mangler til 2,2 m =", target_cm-infinite_sum, "cm")
print("Kan målet nås?", bool(infinite_sum >= target_cm))

assert simplify(infinite_sum-200) == 0
assert infinite_sum < target_cm

Kjørt utskriftGeometrisk rekke: 12 + 12*0.94 + 12*0.94^2 + ...
Kvotient = 47/50
Uendelig sum = 200 cm
Uendelig sum i meter = 2
Mål = 220 cm
Mangler til 2,2 m = 20 cm
Kan målet nås? False

from sympy import Matrix, symbols

A = Matrix([7,12,12])
B = Matrix([1,-6,-12])
direction_full = A-B
direction = direction_full/6
t = symbols('t', real=True)
point = B+t*direction

print("A =", A.T)
print("B =", B.T)
print("A - B =", direction_full.T)
print("Forenklet retningsvektor =", direction.T)
print("Parameterpunkt =", point.T)
print("Ved t=0 får vi =", point.subs(t,0).T)
print("Ved t=6 får vi =", point.subs(t,6).T)

assert point.subs(t,0) == B
assert point.subs(t,6) == A

Kjørt utskriftA = Matrix([[7, 12, 12]])
B = Matrix([[1, -6, -12]])
A - B = Matrix([[6, 18, 24]])
Forenklet retningsvektor = Matrix([[1, 3, 4]])
Parameterpunkt = Matrix([[t + 1, 3*t - 6, 4*t - 12]])
Ved t=0 får vi = Matrix([[1, -6, -12]])
Ved t=6 får vi = Matrix([[7, 12, 12]])

from sympy import symbols, Matrix, Eq, solve, expand, factor, simplify

t = symbols('t', real=True)
point = Matrix([1+t, -6+3*t, -12+4*t])
equation_expression = expand(point.dot(point)-25)
solutions = solve(Eq(equation_expression,0), t)
intersection_points = [point.subs(t,value) for value in solutions]

print("Punkt på linjen =", point.T)
print("Kulekrav x^2+y^2+z^2-25 =", equation_expression)
print("Faktorisert uttrykk =", factor(equation_expression))
print("Parameterløsninger =", solutions)
for value, P in zip(solutions, intersection_points):
    print("t =", value, "gir punkt", P.T, "og |P|^2 =", simplify(P.dot(P)))

assert solutions == [2,3]
assert intersection_points == [Matrix([3,0,-4]),Matrix([4,3,0])]

Kjørt utskriftPunkt på linjen = Matrix([[t + 1, 3*t - 6, 4*t - 12]])
Kulekrav x^2+y^2+z^2-25 = 26*t**2 - 130*t + 156
Faktorisert uttrykk = 26*(t - 3)*(t - 2)
Parameterløsninger = [2, 3]
t = 2 gir punkt Matrix([[3, 0, -4]]) og |P|^2 = 25
t = 3 gir punkt Matrix([[4, 3, 0]]) og |P|^2 = 25

from sympy import symbols, Eq, solve, Abs, sqrt, simplify

d = symbols('d', real=True)
normal_length = sqrt(4**2 + (-3)**2)
distance = Abs(d)/normal_length
solutions = solve(Eq(distance,5), d)

print("Parallell planfamilie: 4*x - 3*y + d = 0")
print("Normalvektor = (4,-3,0)")
print("Lengde av normalvektor =", normal_length)
print("Avstand fra origo =", distance)
print("Tangentkrav: avstand = 5")
print("Løsninger for d =", solutions)
for value in solutions:
    print("Plan: 4*x - 3*y", "+" if value>0 else "-", abs(value), "= 0")

assert set(solutions) == {-25,25}

Kjørt utskriftParallell planfamilie: 4*x - 3*y + d = 0
Normalvektor = (4,-3,0)
Lengde av normalvektor = 5
Avstand fra origo = Abs(d)/5
Tangentkrav: avstand = 5
Løsninger for d = [-25, 25]
Plan: 4*x - 3*y - 25 = 0
Plan: 4*x - 3*y + 25 = 0

from sympy import symbols, Function, Eq, diff, Rational

t = symbols('t', nonnegative=True)
y = Function('y')
relative_rate = Rational(-3,100)
model = Eq(diff(y(t),t), relative_rate*y(t))

print("t = år etter starten av 2018")
print("y(t) = antall ørreter")
print("Relativ endringsrate =", relative_rate)
print("Differensiallikning =", model)
print("Initialbetingelse: y(0) = 10000")
print("Fortegnet er negativt fordi bestanden avtar")
print("Enhet for y'(t): ørreter per år")

assert relative_rate == Rational(-3,100)

Kjørt utskriftt = år etter starten av 2018
y(t) = antall ørreter
Relativ endringsrate = -3/100
Differensiallikning = Eq(Derivative(y(t), t), -3*y(t)/100)
Initialbetingelse: y(0) = 10000
Fortegnet er negativt fordi bestanden avtar
Enhet for y'(t): ørreter per år

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

t = symbols('t', nonnegative=True)
y = Function('y')
ode = Eq(diff(y(t),t), -0.03*y(t))
solution = dsolve(ode, ics={y(0):10000})
model = 10000*exp(-0.03*t)
value_2028 = model.subs(t,10)
residual = simplify(diff(model,t)+0.03*model)

print("Differensiallikning =", ode)
print("Løsning fra SymPy =", solution)
print("Modell y(t) =", model)
print("Residual y' + 0.03*y =", residual)
print("y(0) =", model.subs(t,0))
print("y(10) eksakt =", value_2028)
print("y(10) numerisk =", N(value_2028, 12))
print("Avrundet bestand i 2028 =", round(float(value_2028)))

assert abs(float(value_2028)-7408.182206817) < 1e-6

Kjørt utskriftDifferensiallikning = Eq(Derivative(y(t), t), -0.03*y(t))
Løsning fra SymPy = Eq(y(t), 10000*exp(-0.03*t))
Modell y(t) = 10000*exp(-0.03*t)
Residual y' + 0.03*y = 0
y(0) = 10000
y(10) eksakt = 7408.18220681718
y(10) numerisk = 7408.18220682
Avrundet bestand i 2028 = 7408

from sympy import symbols, Function, Eq, diff, Rational

t = symbols('t', nonnegative=True)
a = symbols('a', positive=True)
y = Function('y')
loss_rate = Rational(3,100)
model = Eq(diff(y(t),t), -loss_rate*y(t)+a)

print("a = fast antall ørreter satt ut per år")
print("Naturlig tapsledd =", -loss_rate*y(t))
print("Tilførselsledd =", a)
print("Differensiallikning =", model)
print("Startbetingelse: y(0) = 10000")
print("Målbetingelse: y(9) = 15000")
print("Tidskontroll: starten av 2027 - starten av 2018 = 9 år")

assert loss_rate == Rational(3,100)

Kjørt utskrifta = fast antall ørreter satt ut per år
Naturlig tapsledd = -3*y(t)/100
Tilførselsledd = a
Differensiallikning = Eq(Derivative(y(t), t), a - 3*y(t)/100)
Startbetingelse: y(0) = 10000
Målbetingelse: y(9) = 15000
Tidskontroll: starten av 2027 - starten av 2018 = 9 år

from sympy import symbols, exp, Eq, solve, N, simplify

t, a = symbols('t a', real=True)
model = a/0.03 + (10000-a/0.03)*exp(-0.03*t)
equation = Eq(model.subs(t,9), 15000)
a_solution = solve(equation, a)[0]
y_with_stocking = simplify(model.subs(a,a_solution))

print("Løsning med parameter a: y(t) =", model)
print("Målbetingelse ved t=9 =", equation)
print("Eksakt CAS-uttrykk for a =", a_solution)
print("Numerisk a =", N(a_solution, 12), "ørreter per år")
print("Avrundet praktisk verdi =", round(float(a_solution)))
print("Kontroll y(0) =", N(y_with_stocking.subs(t,0),12))
print("Kontroll y(9) =", N(y_with_stocking.subs(t,9),12))
print("Kontroll y'(9) =", N((-0.03*y_with_stocking+a_solution).subs(t,9),12))

assert abs(float(y_with_stocking.subs(t,9))-15000) < 1e-7

Kjørt utskriftLøsning med parameter a: y(t) = 33.3333333333333*a + (10000 - 33.3333333333333*a)*exp(-0.03*t)
Målbetingelse ved t=9 = Eq(7.88735018877156*a + 7633.79494336853, 15000)
Eksakt CAS-uttrykk for a = 933.926462035121
Numerisk a = 933.926462035 ørreter per år
Avrundet praktisk verdi = 934
Kontroll y(0) = 10000.0000000
Kontroll y(9) = 15000.0000000
Kontroll y'(9) = 483.926462035

from sympy import symbols, sqrt, solve, Eq, simplify

x = symbols('x', real=True)
f = sqrt(4-x**2)
g = simplify(f.subs(x,1))
intersections = solve(Eq(f,g), x)

print("f(x) =", f)
print("Definisjonsområde = [-2, 2]")
print("f(-2) =", f.subs(x,-2))
print("f(0) =", f.subs(x,0))
print("f(2) =", f.subs(x,2))
print("g(x) = f(1) =", g)
print("Skjæringspunktenes x-koordinater =", intersections)
for value in intersections:
    print("Punkt =", (value,g))

assert g == sqrt(3)
assert intersections == [-1,1]

Kjørt utskriftf(x) = sqrt(4 - x**2)
Definisjonsområde = [-2, 2]
f(-2) = 0
f(0) = 2
f(2) = 0
g(x) = f(1) = sqrt(3)
Skjæringspunktenes x-koordinater = [-1, 1]
Punkt = (-1, sqrt(3))
Punkt = (1, sqrt(3))

from sympy import symbols, sqrt, integrate, pi, simplify, N

x = symbols('x', real=True)
f = sqrt(4-x**2)
g = sqrt(3)
upper_area = integrate(f, (x,-1,1))
rectangle = integrate(g, (x,-1,1))
segment_area = simplify(integrate(f-g, (x,-1,1)))
expected = 2*pi/3 - sqrt(3)

print("Integral av halvsirkelen mellom -1 og 1 =", upper_area)
print("Areal under linjen y=sqrt(3) =", rectangle)
print("Sirkelsegmentets areal =", segment_area)
print("Forventet eksakt form =", expected)
print("Desimalverdi =", N(segment_area, 12))
print("Symbolsk kontroll =", simplify(segment_area-expected))

assert simplify(segment_area-expected) == 0

Kjørt utskriftIntegral av halvsirkelen mellom -1 og 1 = sqrt(3) + 2*pi/3
Areal under linjen y=sqrt(3) = 2*sqrt(3)
Sirkelsegmentets areal = -sqrt(3) + 2*pi/3
Forventet eksakt form = -sqrt(3) + 2*pi/3
Desimalverdi = 0.362344294824
Symbolsk kontroll = 0

from sympy import symbols, sqrt, pi, integrate, simplify, N

x = symbols('x', real=True)
outer_radius = sqrt(4-x**2)
inner_radius = sqrt(3)
cross_section = simplify(pi*(outer_radius**2-inner_radius**2))
volume = simplify(integrate(cross_section, (x,-1,1)))
expected = 4*pi/3

print("Ytterradius R(x) =", outer_radius)
print("Innerradius r(x) =", inner_radius)
print("Tverrsnittsareal pi*(R^2-r^2) =", cross_section)
print("Volumintegral fra -1 til 1 =", volume)
print("Forventet eksakt volum =", expected)
print("Desimalverdi =", N(volume, 12))
print("Kontrollforskjell =", simplify(volume-expected))

assert simplify(volume-expected) == 0

Kjørt utskriftYtterradius R(x) = sqrt(4 - x**2)
Innerradius r(x) = sqrt(3)
Tverrsnittsareal pi*(R^2-r^2) = pi*(1 - x**2)
Volumintegral fra -1 til 1 = 4*pi/3
Forventet eksakt volum = 4*pi/3
Desimalverdi = 4.18879020479
Kontrollforskjell = 0

from sympy import symbols, sqrt, pi, integrate, simplify, diff

x = symbols('x', real=True)
r = symbols('r', positive=True)
F = sqrt(r**2-x**2)
G = sqrt(r**2-1)
integrand = simplify(F**2-G**2)
volume = simplify(pi*integrate(integrand, (x,-1,1)))
parameter_derivative = simplify(diff(volume,r))

print("F(x) =", F)
print("G(x) = F(1) =", G)
print("F(x)^2 - G(x)^2 =", integrand)
print("Volum V(r) =", volume)
print("Derivert med hensyn på r =", parameter_derivative)
print("Resultatet inneholder r?", volume.has(r))
print("Gyldighetskrav: r > 1")

assert simplify(integrand-(1-x**2)) == 0
assert simplify(volume-4*pi/3) == 0
assert parameter_derivative == 0

Kjørt utskriftF(x) = sqrt(r**2 - x**2)
G(x) = F(1) = sqrt(r**2 - 1)
F(x)^2 - G(x)^2 = 1 - x**2
Volum V(r) = 4*pi/3
Derivert med hensyn på r = 0
Resultatet inneholder r? False
Gyldighetskrav: r > 1