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

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

print("Funksjon f(x) =", f)
print("Derivert f'(x) =", derivative)
print("Forventet uttrykk =", expected)
print("Symbolsk kontroll =", simplify(derivative - expected))
print("f'(0) =", derivative.subs(x, 0))
print("f'(1/2) =", simplify(derivative.subs(x, 1/2)))
print("Numerisk f'(1/2) =", N(derivative.subs(x, 1/2), 12))

assert simplify(derivative - expected) == 0

Kjørt utskriftFunksjon f(x) = 2*cos(pi*x)
Derivert f'(x) = -2*pi*sin(pi*x)
Forventet uttrykk = -2*pi*sin(pi*x)
Symbolsk kontroll = 0
f'(0) = 0
f'(1/2) = -2*pi
Numerisk f'(1/2) = -6.28318530718

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

x = symbols('x', real=True)
g = cos(x)**2*sin(x)
raw = diff(g, x)
expected = cos(x)*(3*cos(x)**2 - 2)

print("Funksjon g(x) =", g)
print("Derivert, direkte =", raw)
print("Faktorisert kandidat =", expected)
print("Trigonometrisk kontroll =", trigsimp(raw - expected))
print("Utvidet forventet uttrykk =", simplify(expected.expand(trig=True)))
print("g'(0) =", raw.subs(x, 0))

assert trigsimp(raw - expected) == 0

Kjørt utskriftFunksjon g(x) = sin(x)*cos(x)**2
Derivert, direkte = -2*sin(x)**2*cos(x) + cos(x)**3
Faktorisert kandidat = (3*cos(x)**2 - 2)*cos(x)
Trigonometrisk kontroll = 0
Utvidet forventet uttrykk = (3*cos(x)**2 - 2)*cos(x)
g'(0) = 1

from sympy import symbols, integrate, simplify

x = symbols('x', real=True)
integrand = 2*x**3 + 3*x - 1
antiderivative = integrate(integrand, x)
value = integrate(integrand, (x, -1, 1))
odd_part = 2*x**3 + 3*x

print("Integrand =", integrand)
print("Stamfunksjon =", antiderivative)
print("Bidrag fra odd del =", integrate(odd_part, (x, -1, 1)))
print("Bidrag fra konstantleddet =", integrate(-1, (x, -1, 1)))
print("Bestemt integral =", value)
print("Kontroll F(1)-F(-1) =", simplify(antiderivative.subs(x,1)-antiderivative.subs(x,-1)))

assert value == -2

Kjørt utskriftIntegrand = 2*x**3 + 3*x - 1
Stamfunksjon = x**4/2 + 3*x**2/2 - x
Bidrag fra odd del = 0
Bidrag fra konstantleddet = -2
Bestemt integral = -2
Kontroll F(1)-F(-1) = -2

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

x = symbols('x', real=True)
integrand = 8*x/(2*x**2 - 1)
F_component = 2*log(2*x**2 - 1)
cas_form = integrate(integrand, x)

print("Integrand =", integrand)
print("Stamfunksjon fra SymPy =", cas_form)
print("Reell global skrivemåte = 2*log(Abs(2*x**2 - 1))")
print("Kontrollert komponentform =", F_component)
print("Derivert tilbake =", simplify(diff(F_component, x)))
print("Kontrollforskjell =", simplify(diff(F_component, x) - integrand))
print("Definisjonsbrudd ved x = ±sqrt(2)/2")

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

Kjørt utskriftIntegrand = 8*x/(2*x**2 - 1)
Stamfunksjon fra SymPy = 2*log(2*x**2 - 1)
Reell global skrivemåte = 2*log(Abs(2*x**2 - 1))
Kontrollert komponentform = 2*log(2*x**2 - 1)
Derivert tilbake = 8*x/(2*x**2 - 1)
Kontrollforskjell = 0
Definisjonsbrudd ved x = ±sqrt(2)/2

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

x = symbols('x', real=True)
integrand = (x + 3)*(x + 1)**2
expanded = expand(integrand)
F = integrate(integrand, x)

print("Opprinnelig integrand =", integrand)
print("Utvidet integrand =", expanded)
print("Stamfunksjon =", F)
print("Derivert tilbake =", expand(diff(F, x)))
print("Kontrollforskjell =", simplify(diff(F, x)-integrand))

assert expanded == x**3 + 5*x**2 + 7*x + 3
assert simplify(diff(F, x)-integrand) == 0

Kjørt utskriftOpprinnelig integrand = (x + 1)**2*(x + 3)
Utvidet integrand = x**3 + 5*x**2 + 7*x + 3
Stamfunksjon = x**4/4 + 5*x**3/3 + 7*x**2/2 + 3*x
Derivert tilbake = x**3 + 5*x**2 + 7*x + 3
Kontrollforskjell = 0

from sympy import symbols, summation, Eq, solve

j, n = symbols('j n', integer=True, positive=True)
a1 = 7
d = 4
an = 483
n_value = solve(Eq(an, a1 + (n-1)*d), n)[0]
sum_formula = n_value*(a1+an)/2
sum_direct = summation(a1+(j-1)*d, (j,1,n_value))

print("Første ledd =", a1)
print("Differanse =", d)
print("Siste ledd =", an)
print("Antall ledd =", n_value)
print("Sumformel gir =", sum_formula)
print("Direkte summering gir =", sum_direct)

assert n_value == 120
assert sum_formula == sum_direct == 29400

Kjørt utskriftFørste ledd = 7
Differanse = 4
Siste ledd = 483
Antall ledd = 120
Sumformel gir = 29400
Direkte summering gir = 29400

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

a1, k = symbols('a1 k', real=True)
solutions = solve([Eq(a1*k, 6), Eq(a1/(1-k), 24)], [a1, k], dict=True)
valid = [s for s in solutions if abs(float(s[k])) < 1]

print("Alle algebraiske løsninger =", solutions)
print("Løsninger med |k| < 1 =", valid)
solution = valid[0]
print("a1 =", solution[a1])
print("k =", solution[k])
print("Andre ledd =", simplify(solution[a1]*solution[k]))
print("Uendelig sum =", simplify(solution[a1]/(1-solution[k])))

assert solution[a1] == 12
assert solution[k] == Rational(1,2)

Kjørt utskriftAlle algebraiske løsninger = [{a1: 12, k: 1/2}]
Løsninger med |k| < 1 = [{a1: 12, k: 1/2}]
a1 = 12
k = 1/2
Andre ledd = 6
Uendelig sum = 24

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

x = symbols('x', real=True)
solution_set = solveset(2*sin(2*x)-1, x, domain=Interval(0, pi))
expected = {pi/12, 5*pi/12}

print("Likning: 2*sin(2*x) = 1")
print("Definisjonsintervall =", Interval(0, pi))
print("Løsningsmengde =", solution_set)
for value in sorted(expected, key=float):
    print("Kontroll for x =", value, ":", simplify(2*sin(2*value)))

assert set(solution_set) == expected

Kjørt utskriftLikning: 2*sin(2*x) = 1
Definisjonsintervall = Interval(0, pi)
Løsningsmengde = {pi/12, 5*pi/12}
Kontroll for x = pi/12 : 1
Kontroll for x = 5*pi/12 : 1

from sympy import symbols, cos, pi, solveset, Interval, simplify, Rational

x = symbols('x', real=True)
expr = 2*cos(x)**2 - cos(x) - 1
domain = Interval(0, 4*pi)
solution_set = solveset(cos(x)-1, x, domain=domain).union(
    solveset(cos(x)+Rational(1,2), x, domain=domain)
)
expected = {0, 2*pi/3, 4*pi/3, 2*pi, 8*pi/3, 10*pi/3, 4*pi}

print("Faktorisert likning i u: (2*u + 1)*(u - 1) = 0")
print("Løsningsmengde =", solution_set)
print("Antall løsninger =", len(solution_set))
for value in sorted(expected, key=float):
    print("x =", value, "gir venstreside minus høyreside =", simplify(expr.subs(x,value)))

assert set(solution_set) == expected

Kjørt utskriftFaktorisert likning i u: (2*u + 1)*(u - 1) = 0
Løsningsmengde = {0, 2*pi/3, 4*pi/3, 2*pi, 8*pi/3, 10*pi/3, 4*pi}
Antall løsninger = 7
x = 0 gir venstreside minus høyreside = 0
x = 2*pi/3 gir venstreside minus høyreside = 0
x = 4*pi/3 gir venstreside minus høyreside = 0
x = 2*pi gir venstreside minus høyreside = 0
x = 8*pi/3 gir venstreside minus høyreside = 0
x = 10*pi/3 gir venstreside minus høyreside = 0
x = 4*pi gir venstreside minus høyreside = 0

from sympy import symbols, sin, pi, simplify

x = symbols('x', real=True)
f = sin(x)**2

print("Funksjon f(x) =", f)
print("f(0) =", f.subs(x,0))
print("f(pi/2) =", f.subs(x,pi/2))
print("f(pi) =", f.subs(x,pi))
print("Periodetest f(x+pi)-f(x) =", simplify(f.subs(x,x+pi)-f))
print("Funksjonen er alltid ikke-negativ fordi den er et kvadrat.")
print("Riktig alternativ: B")

assert simplify(f.subs(x,x+pi)-f) == 0
assert f.subs(x,0) == 0 and f.subs(x,pi/2) == 1

Kjørt utskriftFunksjon f(x) = sin(x)**2
f(0) = 0
f(pi/2) = 1
f(pi) = 0
Periodetest f(x+pi)-f(x) = 0
Funksjonen er alltid ikke-negativ fordi den er et kvadrat.
Riktig alternativ: B

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

x, a = symbols('x a', real=True)
f = x + a
area = integrate(f, (x,0,2))
solutions = solve(Eq(area,3), a)

print("Funksjon f(x) =", f)
print("Arealuttrykk =", area)
print("Likning =", Eq(area,3))
print("Løsninger =", solutions)
print("Kontrollareal for a=1/2 =", simplify(area.subs(a,Rational(1,2))))
print("Positivitetskontroll a>0 =", solutions[0] > 0)

assert solutions == [Rational(1,2)]

Kjørt utskriftFunksjon f(x) = a + x
Arealuttrykk = 2*a + 2
Likning = Eq(2*a + 2, 3)
Løsninger = [1/2]
Kontrollareal for a=1/2 = 3
Positivitetskontroll a>0 = True

from sympy import symbols, integrate, Eq, solve, pi, factor, simplify

x, a = symbols('x a', real=True)
volume = pi*integrate((x+a)**2, (x,0,2))
equation = Eq(volume, 98*pi/3)
solutions = solve(equation, a)

print("Volumuttrykk =", simplify(volume))
print("Volum uten faktor pi =", simplify(volume/pi))
print("Likning =", equation)
print("Faktorisert polynom =", factor(simplify((volume-98*pi/3)/pi)))
print("Algebraiske løsninger =", solutions)
print("Gyldig løsning med a>0 =", [v for v in solutions if v>0])
print("Kontroll V(3) =", simplify(volume.subs(a,3)))

assert [v for v in solutions if v>0] == [3]

Kjørt utskriftVolumuttrykk = 2*pi*(3*a**2 + 6*a + 4)/3
Volum uten faktor pi = 2*a**2 + 4*a + 8/3
Likning = Eq(pi*(2*a**2 + 4*a + 8/3), 98*pi/3)
Faktorisert polynom = 2*(a - 3)*(a + 5)
Algebraiske løsninger = [-5, 3]
Gyldig løsning med a>0 = [3]
Kontroll V(3) = 98*pi/3

from sympy import symbols, Eq, solve, Matrix

t = symbols('t', real=True)
point = Matrix([1+2*t, 2-t, 6+t])
t_value = solve(Eq(point[1],0), t)[0]
intersection = point.subs(t,t_value)

print("Parameterpunkt på linjen =", point.T)
print("Likning y=0 gir t =", t_value)
print("Skjæringspunkt =", intersection.T)
print("Kontroll y-koordinat =", intersection[1])

assert intersection == Matrix([5,0,8])

Kjørt utskriftParameterpunkt på linjen = Matrix([[2*t + 1, 2 - t, t + 6]])
Likning y=0 gir t = 2
Skjæringspunkt = Matrix([[5, 0, 8]])
Kontroll y-koordinat = 0

from sympy import Matrix, symbols, expand

x, y, z = symbols('x y z', real=True)
P = Matrix([2,-2,6])
normal = Matrix([2,-1,1])
X = Matrix([x,y,z])
plane_expression = expand(normal.dot(X-P))

print("Punkt P =", P.T)
print("Normalvektor =", normal.T)
print("Punkt-normal-uttrykk =", plane_expression)
print("Planlikning: 2*x - y + z = 12")
print("Kontroll i P =", plane_expression.subs({x:2,y:-2,z:6}))

assert plane_expression == 2*x-y+z-12

Kjørt utskriftPunkt P = Matrix([[2, -2, 6]])
Normalvektor = Matrix([[2, -1, 1]])
Punkt-normal-uttrykk = 2*x - y + z - 12
Planlikning: 2*x - y + z = 12
Kontroll i P = 0

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

t = symbols('t', real=True)
L = Matrix([1+2*t, 2-t, 6+t])
plane_left = 2*L[0]-L[1]+L[2]
t_value = solve(Eq(plane_left,12), t)[0]
intersection = L.subs(t,t_value)

print("Punkt på linjen =", L.T)
print("Planets venstreside langs linjen =", simplify(plane_left))
print("Parameter ved skjæring =", t_value)
print("Skjæringspunkt =", intersection.T)
print("Kontroll i planet =", 2*intersection[0]-intersection[1]+intersection[2])

assert intersection == Matrix([3,1,7])

Kjørt utskriftPunkt på linjen = Matrix([[2*t + 1, 2 - t, t + 6]])
Planets venstreside langs linjen = 6*t + 6
Parameter ved skjæring = 1
Skjæringspunkt = Matrix([[3, 1, 7]])
Kontroll i planet = 12

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

x = symbols('x', real=True)
y = Function('y')
ode = Eq(diff(y(x),x)-2*y(x), x)
solution = dsolve(ode, ics={y(0):1})
expected = Rational(5,4)*exp(2*x) - x/2 - Rational(1,4)
residual = simplify(diff(expected,x)-2*expected-x)

print("Differensiallikning =", ode)
print("Løsning fra SymPy =", solution)
print("Forventet eksplisitt løsning =", expected)
print("ODE-residual =", residual)
print("Initialverdi y(0) =", simplify(expected.subs(x,0)))
print("Kontroll mot SymPy =", simplify(solution.rhs-expected))

assert residual == 0
assert simplify(expected.subs(x,0)) == 1

Kjørt utskriftDifferensiallikning = Eq(-2*y(x) + Derivative(y(x), x), x)
Løsning fra SymPy = Eq(y(x), -x/2 + 5*exp(2*x)/4 - 1/4)
Forventet eksplisitt løsning = -x/2 + 5*exp(2*x)/4 - 1/4
ODE-residual = 0
Initialverdi y(0) = 1
Kontroll mot SymPy = 0

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

x = symbols('x', real=True)
y_solution = Rational(5,4)*exp(2*x) - x/2 - Rational(1,4)
slope = simplify(diff(y_solution,x).subs(x,0))
tangent = 1 + slope*x

print("Løsningsfunksjon =", y_solution)
print("Derivert =", diff(y_solution,x))
print("Stigningstall ved x=0 =", slope)
print("Tangentfunksjon =", tangent)
print("Tangentens verdi ved x=0 =", tangent.subs(x,0))
print("Differensiallikningen gir y'(0)=0+2*1 = 2")

assert slope == 2
assert tangent == 2*x+1

Kjørt utskriftLøsningsfunksjon = -x/2 + 5*exp(2*x)/4 - 1/4
Derivert = 5*exp(2*x)/2 - 1/2
Stigningstall ved x=0 = 2
Tangentfunksjon = 2*x + 1
Tangentens verdi ved x=0 = 1
Differensiallikningen gir y'(0)=0+2*1 = 2

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

A = Matrix([1,-1,0])
B = Matrix([1,2,4])
C = Matrix([5,1,-4])
rA, rB, rC = symbols('rA rB rC', positive=True)

def distance(P,Q):
    v = P-Q
    return sqrt(v.dot(v))

dAB, dAC, dBC = distance(A,B), distance(A,C), distance(B,C)
solution = solve([Eq(rA+rB,dAB), Eq(rA+rC,dAC), Eq(rB+rC,dBC)], [rA,rB,rC], dict=True)[0]

print("Avstand AB =", dAB)
print("Avstand AC =", dAC)
print("Avstand BC =", dBC)
print("Løsning for radiene =", solution)
print("Kontroll rA+rB =", solution[rA]+solution[rB])
print("Kontroll rA+rC =", solution[rA]+solution[rC])
print("Kontroll rB+rC =", solution[rB]+solution[rC])

assert solution == {rA:1,rB:4,rC:5}

Kjørt utskriftAvstand AB = 5
Avstand AC = 6
Avstand BC = 9
Løsning for radiene = {rA: 1, rB: 4, rC: 5}
Kontroll rA+rB = 5
Kontroll rA+rC = 6
Kontroll rB+rC = 9

from sympy import symbols, expand, factor, simplify

k = symbols('k', integer=True, positive=True)
P_k = k**3-k
P_next = (k+1)**3-(k+1)
increment = expand(P_next-P_k)

print("Påstand P(k) =", P_k)
print("Neste uttrykk P(k+1) =", expand(P_next))
print("Forskjell P(k+1)-P(k) =", increment)
print("Faktorisert forskjell =", factor(increment))
print("Omskriving P(k+1) = P(k) +", factor(increment))
print("Startkontroll P(1) =", P_k.subs(k,1))
print("Rest av forskjellen modulo 3 =", simplify(increment % 3))

assert factor(increment) == 3*k*(k+1)
assert P_k.subs(k,1) == 0

Kjørt utskriftPåstand P(k) = k**3 - k
Neste uttrykk P(k+1) = k**3 + 3*k**2 + 2*k
Forskjell P(k+1)-P(k) = 3*k**2 + 3*k
Faktorisert forskjell = 3*k*(k + 1)
Omskriving P(k+1) = P(k) + 3*k*(k + 1)
Startkontroll P(1) = 0
Rest av forskjellen modulo 3 = 0

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

x = symbols('x', real=True)
f = 2*x + sin(x)
g = 2*x + 4*sin(x)

print("f(x) =", f)
print("g(x) =", g)
print("Domene: [0, 4*pi]")
print("f(0), g(0) =", f.subs(x,0), g.subs(x,0))
print("f(4*pi), g(4*pi) =", simplify(f.subs(x,4*pi)), simplify(g.subs(x,4*pi)))
print("f'(x) =", diff(f,x))
print("g'(x) =", diff(g,x))
print("Eksempel ved x=3*pi/2:", N(f.subs(x,3*pi/2),10), N(g.subs(x,3*pi/2),10))

assert simplify(f.subs(x,4*pi)-8*pi) == 0
assert simplify(g.subs(x,4*pi)-8*pi) == 0

Kjørt utskriftf(x) = 2*x + sin(x)
g(x) = 2*x + 4*sin(x)
Domene: [0, 4*pi]
f(0), g(0) = 0 0
f(4*pi), g(4*pi) = 8*pi 8*pi
f'(x) = cos(x) + 2
g'(x) = 4*cos(x) + 2
Eksempel ved x=3*pi/2: 8.424777961 5.424777961

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

x = symbols('x', real=True)
f = 2*x + sin(x)
g = 2*x + 4*sin(x)
A_f = integrate(f, (x,0,4*pi))
A_g = integrate(g, (x,0,4*pi))
sine_integral = integrate(sin(x), (x,0,4*pi))

print("Areal under f =", A_f)
print("Areal under g =", A_g)
print("Integral av sin(x) over intervallet =", sine_integral)
print("Forskjell mellom arealene =", simplify(A_f-A_g))
print("Numerisk areal =", N(A_f,12))
print("Begge funksjonene er ikke-negative på intervallet.")

assert A_f == A_g == 16*pi**2

Kjørt utskriftAreal under f = 16*pi**2
Areal under g = 16*pi**2
Integral av sin(x) over intervallet = 0
Forskjell mellom arealene = 0
Numerisk areal = 157.913670417
Begge funksjonene er ikke-negative på intervallet.

from sympy import symbols, sin, pi, integrate, expand, simplify, N

x = symbols('x', real=True)
f = 2*x + sin(x)
g = 2*x + 4*sin(x)
V_f = pi*integrate(f**2, (x,0,4*pi))
V_g = pi*integrate(g**2, (x,0,4*pi))
expected_f = 256*pi**4/3 - 14*pi**2
expected_g = 256*pi**4/3 - 32*pi**2

print("Utvidet f(x)^2 =", expand(f**2))
print("Utvidet g(x)^2 =", expand(g**2))
print("Volum V_f =", simplify(V_f))
print("Volum V_g =", simplify(V_g))
print("Numerisk V_f =", N(V_f,12))
print("Numerisk V_g =", N(V_g,12))
print("Kontroll V_f =", simplify(V_f-expected_f))
print("Kontroll V_g =", simplify(V_g-expected_g))

assert simplify(V_f-expected_f) == 0
assert simplify(V_g-expected_g) == 0

Kjørt utskriftUtvidet f(x)^2 = 4*x**2 + 4*x*sin(x) + sin(x)**2
Utvidet g(x)^2 = 4*x**2 + 16*x*sin(x) + 16*sin(x)**2
Volum V_f = pi**2*(-14 + 256*pi**2/3)
Volum V_g = pi**2*(-32 + 256*pi**2/3)
Numerisk V_f = 8174.06797329
Numerisk V_g = 7996.41509407
Kontroll V_f = 0
Kontroll V_g = 0

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

x = symbols('x', real=True)
k = symbols('k', positive=True)
h = 2*x + k*sin(x)
area = integrate(h, (x,0,4*pi))

print("h(x) =", h)
print("Symbolsk areal A(k) =", area)
print("Forenklet areal =", simplify(area))
print("Derivert av arealet med hensyn på k =", diff(area,k))
print("A(1) =", area.subs(k,1))
print("A(8) =", area.subs(k,8))

assert simplify(area-16*pi**2) == 0
assert diff(area,k) == 0

Kjørt utskrifth(x) = k*sin(x) + 2*x
Symbolsk areal A(k) = 16*pi**2
Forenklet areal = 16*pi**2
Derivert av arealet med hensyn på k = 0
A(1) = 16*pi**2
A(8) = 16*pi**2

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

x = symbols('x', real=True)
k = symbols('k', real=True)
V = pi*integrate((2*x+k*sin(x))**2, (x,0,4*pi))
V1 = diff(V,k)
V2 = diff(V,k,2)
critical = solve(V1,k)

print("Volumfunksjon V(k) =", simplify(V))
print("Faktorisert første derivert =", factor(V1))
print("Andre derivert =", V2)
print("Kritiske punkter =", critical)
print("Gyldig kritisk punkt i 0<k<9 =", [v for v in critical if 0<v<9])
print("Minimumsvolum V(4) =", simplify(V.subs(k,4)))

assert critical == [4]
assert V2 == 4*pi**2

Kjørt utskriftVolumfunksjon V(k) = pi**2*(2*k**2 - 16*k + 256*pi**2/3)
Faktorisert første derivert = 4*pi**2*(k - 4)
Andre derivert = 4*pi**2
Kritiske punkter = [4]
Gyldig kritisk punkt i 0<k<9 = [4]
Minimumsvolum V(4) = pi**2*(-32 + 256*pi**2/3)

from sympy import symbols, Eq, solve, Matrix

x, y, z = symbols('x y z', real=True)
equations = [Eq(2*x-2*y-z,4), Eq(2*x+y-z,-2), Eq(3*y+2*z,6)]
solution = solve(equations, [x,y,z], dict=True)[0]
P = Matrix([solution[x],solution[y],solution[z]])

print("Likningssystem =")
for equation in equations:
    print(" ", equation)
print("Løsning =", solution)
print("Punkt P =", P.T)
print("Kontroll i alpha =", 2*P[0]-2*P[1]-P[2])
print("Kontroll i beta =", 2*P[0]+P[1]-P[2])
print("Kontroll i gamma =", 3*P[1]+2*P[2])

assert P == Matrix([3,-2,6])

Kjørt utskriftLikningssystem =
  Eq(2*x - 2*y - z, 4)
  Eq(2*x + y - z, -2)
  Eq(3*y + 2*z, 6)
Løsning = {x: 3, y: -2, z: 6}
Punkt P = Matrix([[3, -2, 6]])
Kontroll i alpha = 4
Kontroll i beta = -2
Kontroll i gamma = 6

from sympy import Matrix, Rational, sqrt, simplify

A = Matrix([0,-2,0])
B = Matrix([4,2,0])
C = Matrix([-2,2,0])
P = Matrix([3,-2,6])
AB = B-A
AC = C-A
cross = AB.cross(AC)
base_area = simplify(sqrt(cross.dot(cross))/2)
height = abs(P[2])
volume = simplify(Rational(1,3)*base_area*height)

def plane_values(Q):
    return (2*Q[0]-2*Q[1]-Q[2], 2*Q[0]+Q[1]-Q[2], 3*Q[1]+2*Q[2])

print("Grunnflatepunkter A, B, C =", A.T, B.T, C.T)
print("Toppunkt P =", P.T)
print("Kryssprodukt AB x AC =", cross.T)
print("Grunnflateareal =", base_area)
print("Pyramidehøyde =", height)
print("Volum =", volume)
print("Planverdier i toppunktet =", plane_values(P))

assert base_area == 12
assert volume == 24

Kjørt utskriftGrunnflatepunkter A, B, C = Matrix([[0, -2, 0]]) Matrix([[4, 2, 0]]) Matrix([[-2, 2, 0]])
Toppunkt P = Matrix([[3, -2, 6]])
Kryssprodukt AB x AC = Matrix([[0, 0, 24]])
Grunnflateareal = 12
Pyramidehøyde = 6
Volum = 24
Planverdier i toppunktet = (4, -2, 6)

from decimal import Decimal, getcontext

getcontext().prec = 28
salary_2019 = Decimal('478400')
q = Decimal('1.04')
salaries = [salary_2019*q**n for n in range(1,11)]
total = sum(salaries)
formula = salary_2019*q*(q**10-1)/(q-1)

print("Lønn i 2019 =", salary_2019)
print("Årlig faktor =", q)
print("Lønn i 2020 =", salaries[0])
print("Lønn i 2029 =", salaries[-1])
print("Antall år i summen =", len(salaries))
print("Direkte sum =", total)
print("Geometrisk sumformel =", formula)
print("Sum i millioner kroner =", total/Decimal('1000000'))

assert total == formula
assert total > Decimal('5970000')

Kjørt utskriftLønn i 2019 = 478400
Årlig faktor = 1.04
Lønn i 2020 = 497536.00
Lønn i 2029 = 708148.86590493573408358400
Antall år i summen = 10
Direkte sum = 5973470.51352832908617318400
Geometrisk sumformel = 5973470.51352832908617318400
Sum i millioner kroner = 5.973470513528329086173184

from decimal import Decimal, getcontext

getcontext().prec = 30
q = Decimal('1.04')

def with_education(m):
    return Decimal('574000')*(q**m-1)/(q-1)

def without_education(m):
    # Samme sluttår: m arbeidsår etter utdanningen og to ekstra inntektsår i alternativet.
    return Decimal('478400')*q*(q**(m+2)-1)/(q-1)

first = None
for m in range(1,80):
    if with_education(m) >= without_education(m):
        first = m
        break

print("Første antall arbeidsår som oppfyller kravet =", first)
for m in (18,19,20):
    edu = with_education(m)
    no_edu = without_education(m)
    print(f"m={m}: med utdanning = {edu:.2f}, uten = {no_edu:.2f}, forskjell = {edu-no_edu:.2f}")
print("Første sluttår =", 2021+first)

assert first == 20
assert with_education(19) < without_education(19)
assert with_education(20) >= without_education(20)

Kjørt utskriftFørste antall arbeidsår som oppfyller kravet = 20
m=18: med utdanning = 14720467.00, uten = 14815666.10, forskjell = -95199.11
m=19: med utdanning = 15883285.68, uten = 15905828.75, forskjell = -22543.07
m=20: med utdanning = 17092617.10, uten = 17039597.90, forskjell = 53019.21
Første sluttår = 2041

from sympy import symbols, Eq, solve, simplify

va, k = symbols('va k', positive=True)
equilibrium = Eq(9.81*(1-va**2/k**2), 0)
solutions = solve(equilibrium, va)

print("Likevektslikning =", equilibrium)
print("Løsninger med symbolsk fortegn = ±k")
print("Med positive antakelser gir SymPy =", solutions)
print("Kontroll av k^2-va^2 ved va=k =", simplify(k**2-va**2).subs(va,k))
print("Fysisk konklusjon: va = k, derfor va^2 = k^2")

assert solutions == [k]

Kjørt utskriftLikevektslikning = Eq(9.81 - 9.81*va**2/k**2, 0)
Løsninger med symbolsk fortegn = ±k
Med positive antakelser gir SymPy = [k]
Kontroll av k^2-va^2 ved va=k = 0
Fysisk konklusjon: va = k, derfor va^2 = k^2

from sympy import symbols, Rational, exp, diff, simplify, limit, oo

x = symbols('x', real=True, nonnegative=True)
g = Rational(981,100)
k = Rational(9,5)
y_exp = k*(1-exp(-Rational(109,10)*x))/(1+exp(-Rational(109,10)*x))
residual = simplify(diff(y_exp,x)-g*(1-y_exp**2/k**2))

print("k =", k)
print("g/k =", simplify(g/k))
print("Eksponentialform y(x) =", y_exp)
print("Tanh-form y(x) = (9/5)*tanh((109/20)*x)")
print("Eksponentialformen følger av tanh(u)=(1-exp(-2u))/(1+exp(-2u))")
print("ODE-residual =", residual)
print("Initialverdi y(0) =", simplify(y_exp.subs(x,0)))
print("Grense når x går mot uendelig =", limit(y_exp,x,oo))

assert residual == 0
assert y_exp.subs(x,0) == 0

Kjørt utskriftk = 9/5
g/k = 109/20
Eksponentialform y(x) = (9/5 - 9*exp(-109*x/10)/5)/(1 + exp(-109*x/10))
Tanh-form y(x) = (9/5)*tanh((109/20)*x)
Eksponentialformen følger av tanh(u)=(1-exp(-2u))/(1+exp(-2u))
ODE-residual = 0
Initialverdi y(0) = 0
Grense når x går mot uendelig = 9/5

from sympy import symbols, Rational, log, cosh, nsolve, N, diff, simplify

t = symbols('t', positive=True)
g = Rational(981,100)
k = Rational(9,5)
s = k**2/g*log(cosh(g*t/k))
t_value = nsolve(s-12, 7)

print("Strekningsfunksjon s(t) =", s)
print("Derivert s'(t) =", simplify(diff(s,t)))
print("Likning s(t)=12")
print("Numerisk løsning t =", N(t_value,15))
print("Kontroll s(t) =", N(s.subs(t,t_value),15))
print("Avvik fra 12 m =", N(s.subs(t,t_value)-12,6))
print("Avrundet tid =", round(float(t_value),2), "sekunder")

assert abs(float(s.subs(t,t_value)-12)) < 1e-10

Kjørt utskriftStrekningsfunksjon s(t) = 36*log(cosh(109*t/20))/109
Derivert s'(t) = 9*tanh(109*t/20)/5
Likning s(t)=12
Numerisk løsning t = 6.79384963557675
Kontroll s(t) = 12.0000000000000
Avvik fra 12 m = 1.77636e-15
Avrundet tid = 6.79 sekunder

from sympy import symbols, Rational, log, cosh, nsolve, N

k = symbols('k', positive=True)
g = Rational(981,100)
T = Rational(47,10)
distance = k**2/g*log(cosh(g*T/k))
k_value = nsolve(distance-12, 2.7)

print("Generell strekning etter 4,7 s =", distance)
print("Likning: s(4,7) = 12")
print("Positiv løsning k =", N(k_value,15))
print("Kontrollert strekning =", N(distance.subs(k,k_value),15))
print("Avvik fra 12 m =", N(distance.subs(k,k_value)-12,6))
print("Terminalfart va = k =", round(float(k_value),2), "m/s")

assert abs(float(distance.subs(k,k_value)-12)) < 1e-10
assert float(k_value) > 0

Kjørt utskriftGenerell strekning etter 4,7 s = 100*k**2*log(cosh(46107/(1000*k)))/981
Likning: s(4,7) = 12
Positiv løsning k = 2.65952409451535
Kontrollert strekning = 12.0000000000000
Avvik fra 12 m = 0
Terminalfart va = k = 2.66 m/s