from sympy import symbols, cos, sin, diff, simplify
x = symbols('x', real=True)
f = 3*cos(2*x)
derivative = diff(f, x)
expected = -6*sin(2*x)
print("f(x) =", f)
print("f'(x) =", derivative)
print("Forventet =", expected)
print("Symbolsk kontroll =", simplify(derivative - expected))
print("Kontroll ved x=0 =", derivative.subs(x, 0))
assert simplify(derivative - expected) == 0

Kjørt utskriftf(x) = 3*cos(2*x)
f'(x) = -6*sin(2*x)
Forventet = -6*sin(2*x)
Symbolsk kontroll = 0
Kontroll ved x=0 = 0

from sympy import symbols, exp, sin, cos, diff, simplify
x = symbols('x', real=True)
g = exp(sin(x))
derivative = diff(g, x)
expected = exp(sin(x))*cos(x)
print("g(x) =", g)
print("g'(x) =", derivative)
print("Faktorisert form =", derivative.factor())
print("Kontroll =", simplify(derivative - expected))
print("g'(0) =", derivative.subs(x, 0))
assert simplify(derivative - expected) == 0

Kjørt utskriftg(x) = exp(sin(x))
g'(x) = exp(sin(x))*cos(x)
Faktorisert form = exp(sin(x))*cos(x)
Kontroll = 0
g'(0) = 1

from sympy import symbols, sin, cos, diff, together, simplify
x = symbols('x', real=True)
h = x/sin(x)
raw = diff(h, x)
result = together(raw)
expected = (sin(x) - x*cos(x))/sin(x)**2
print("h(x) =", h)
print("Derivert, rå form =", raw)
print("Derivert, samlet =", result)
print("Forventet =", expected)
print("Kontroll =", simplify(result - expected))
assert simplify(result - expected) == 0

Kjørt utskrifth(x) = x/sin(x)
Derivert, rå form = -x*cos(x)/sin(x)**2 + 1/sin(x)
Derivert, samlet = (-x*cos(x) + sin(x))/sin(x)**2
Forventet = (-x*cos(x) + sin(x))/sin(x)**2
Kontroll = 0

from sympy import symbols, integrate, diff, simplify
x = symbols('x', real=True)
expr = x**2 - 3*x + 2
F = integrate(expr, x)
check = simplify(diff(F, x) - expr)
print("Integrand =", expr)
print("Stamfunksjon =", F)
print("Derivert tilbake =", diff(F, x))
print("Kontroll =", check)
assert check == 0

Kjørt utskriftIntegrand = x**2 - 3*x + 2
Stamfunksjon = x**3/3 - 3*x**2/2 + 2*x
Derivert tilbake = x**2 - 3*x + 2
Kontroll = 0

from sympy import symbols, sin, cos, integrate, diff, simplify
x = symbols('x', real=True)
expr = x*cos(x)
F = integrate(expr, x)
expected = x*sin(x) + cos(x)
print("Integrand =", expr)
print("Stamfunksjon fra SymPy =", F)
print("Forventet form =", expected)
print("Derivert tilbake =", simplify(diff(expected, x)))
print("Kontroll =", simplify(F - expected))
assert simplify(F - expected) == 0

Kjørt utskriftIntegrand = x*cos(x)
Stamfunksjon fra SymPy = x*sin(x) + cos(x)
Forventet form = x*sin(x) + cos(x)
Derivert tilbake = x*cos(x)
Kontroll = 0

from sympy import symbols, sin, cos, integrate, diff, simplify
x = symbols('x', real=True)
expr = 2*x*sin(x**2)
F = integrate(expr, x)
expected = -cos(x**2)
print("Integrand =", expr)
print("Stamfunksjon =", F)
print("Derivert av svaret =", diff(expected, x))
print("Kontroll mot integranden =", simplify(diff(expected, x) - expr))
print("Kontroll mot SymPy =", simplify(F - expected))
assert simplify(F - expected) == 0

Kjørt utskriftIntegrand = 2*x*sin(x**2)
Stamfunksjon = -cos(x**2)
Derivert av svaret = 2*x*sin(x**2)
Kontroll mot integranden = 0
Kontroll mot SymPy = 0

from sympy import symbols, simplify
x, h, r = symbols('x h r', positive=True)
m = (r - 0)/(h - 0)
y = simplify(m*x)
print("Stigningstall m =", m)
print("Linjeligning y =", y)
print("Kontroll ved x=0:", y.subs(x, 0))
print("Kontroll ved x=h:", simplify(y.subs(x, h)))
assert simplify(y.subs(x, h) - r) == 0

Kjørt utskriftStigningstall m = r/h
Linjeligning y = r*x/h
Kontroll ved x=0: 0
Kontroll ved x=h: r

from sympy import symbols, pi, integrate, simplify
x, h, r = symbols('x h r', positive=True)
radius = r*x/h
integrand = pi*radius**2
volume = integrate(integrand, (x, 0, h))
expected = pi*r**2*h/3
print("Radiusfunksjon =", radius)
print("Volumintegrand =", integrand)
print("Volum =", volume)
print("Forventet kjegleformel =", expected)
print("Kontroll =", simplify(volume - expected))
assert simplify(volume - expected) == 0

Kjørt utskriftRadiusfunksjon = r*x/h
Volumintegrand = pi*r**2*x**2/h**2
Volum = pi*h*r**2/3
Forventet kjegleformel = pi*h*r**2/3
Kontroll = 0

from sympy import pi, simplify
b = pi/2
T = simplify(2*pi/b)
print("Frekvensfaktor b =", b)
print("Periodeformel 2*pi/b =", T)
print("Argumentøkning over én periode =", simplify(b*T))
assert T == 4 and simplify(b*T - 2*pi) == 0

Kjørt utskriftFrekvensfaktor b = pi/2
Periodeformel 2*pi/b = 4
Argumentøkning over én periode = 2*pi

from sympy import symbols, sin, pi
x = symbols('x', real=True)
f = 3*sin(pi*x/2) + 5
sample_min = f.subs(x, 3)
sample_max = f.subs(x, 1)
print("f(x) =", f)
print("Likevektslinje = 5")
print("Amplitude = 3")
print("f(3) =", sample_min)
print("f(1) =", sample_max)
assert sample_min == 2 and sample_max == 8

Kjørt utskriftf(x) = 3*sin(pi*x/2) + 5
Likevektslinje = 5
Amplitude = 3
f(3) = 2
f(1) = 8

from sympy import symbols, sin, cos, pi, diff, simplify
x = symbols('x', real=True)
f = 3*sin(pi*x/2) + 5
f1 = diff(f, x)
f2 = diff(f, x, 2)
points = [(2*k, simplify(f.subs(x, 2*k))) for k in range(1, 6)]
left_right = [(k, f2.subs(x, 2*k-0.1).evalf(), f2.subs(x, 2*k+0.1).evalf()) for k in range(1, 6)]
print("f'(x) =", f1)
print("f''(x) =", f2)
print("Vendepunkter =", points)
print("Fortegn rundt hvert punkt:")
for row in left_right:
    print(row)
assert all(y == 5 for _, y in points)

Kjørt utskriftf'(x) = 3*pi*cos(pi*x/2)/2
f''(x) = -3*pi**2*sin(pi*x/2)/4
Vendepunkter = [(2, 5), (4, 5), (6, 5), (8, 5), (10, 5)]
Fortegn rundt hvert punkt:
(1, -1.15795971348234, 1.15795971348234)
(2, 1.15795971348234, -1.15795971348234)
(3, -1.15795971348234, 1.15795971348234)
(4, 1.15795971348234, -1.15795971348234)
(5, -1.15795971348234, 1.15795971348234)

from sympy import sin, pi, simplify
values = []
for k in range(13):
    value = simplify(3*sin(pi*k/2) + 5)
    values.append((k, value))
print("Nøkkelpunkter (x, f(x)):")
for point in values:
    print(point)
print("Antall hele perioder på [0,12] =", 12/4)
assert values[0] == (0, 5) and values[-1] == (12, 5)

Kjørt utskriftNøkkelpunkter (x, f(x)):
(0, 5)
(1, 8)
(2, 5)
(3, 2)
(4, 5)
(5, 8)
(6, 5)
(7, 2)
(8, 5)
(9, 8)
(10, 5)
(11, 2)
(12, 5)
Antall hele perioder på [0,12] = 3.0

from sympy import symbols, exp, diff, factor, simplify
x, r = symbols('x r', real=True)
y = exp(r*x)
y1 = diff(y, x)
y2 = diff(y, x, 2)
residual = simplify(y2 - 4*y1 - 5*y)
print("y =", y)
print("y' =", y1)
print("y'' =", y2)
print("Residual =", residual)
print("Faktorisert residual =", factor(residual))
assert simplify(residual - exp(r*x)*(r**2-4*r-5)) == 0

Kjørt utskrifty = exp(r*x)
y' = r*exp(r*x)
y'' = r**2*exp(r*x)
Residual = (r**2 - 4*r - 5)*exp(r*x)
Faktorisert residual = (r - 5)*(r + 1)*exp(r*x)

from sympy import symbols, solve, factor, exp, Function, Eq, dsolve, diff
x, r = symbols('x r', real=True)
poly = r**2 - 4*r - 5
roots = solve(poly, r)
y = Function('y')
ode = Eq(diff(y(x), x, 2) - 4*diff(y(x), x) - 5*y(x), 0)
solution = dsolve(ode)
print("Karakteristisk polynom =", poly)
print("Faktorisert =", factor(poly))
print("Røtter =", roots)
print("SymPy-løsning =", solution)
assert set(roots) == {-1, 5}

Kjørt utskriftKarakteristisk polynom = r**2 - 4*r - 5
Faktorisert = (r - 5)*(r + 1)
Røtter = [-1, 5]
SymPy-løsning = Eq(y(x), C1*exp(-x) + C2*exp(5*x))

from sympy import symbols, exp, diff, simplify, solve
x, C1, C2 = symbols('x C1 C2', real=True)
y_general = C1*exp(5*x) + C2*exp(-x)
y1_general = diff(y_general, x)
constants = solve([y_general.subs(x,0)-6, y1_general.subs(x,0)], [C1,C2], dict=True)[0]
y_special = simplify(y_general.subs(constants))
residual = simplify(diff(y_special,x,2)-4*diff(y_special,x)-5*y_special)
print("Generell løsning =", y_general)
print("Derivert =", y1_general)
print("Konstanter =", constants)
print("Spesiell løsning =", y_special)
print("y(0) =", y_special.subs(x,0))
print("y'(0) =", diff(y_special,x).subs(x,0))
print("Residual =", residual)
assert residual == 0

Kjørt utskriftGenerell løsning = C1*exp(5*x) + C2*exp(-x)
Derivert = 5*C1*exp(5*x) - C2*exp(-x)
Konstanter = {C1: 1, C2: 5}
Spesiell løsning = (exp(6*x) + 5)*exp(-x)
y(0) = 6
y'(0) = 0
Residual = 0

from fractions import Fraction
B2 = Fraction(1+3, 5+7)
B3 = Fraction(1+3+5, 7+9+11)
B4 = Fraction(1+3+5+7, 9+11+13+15)
print("B2 =", B2)
print("B3 =", B3)
print("B4 =", B4)
print("Alle like?", B2 == B3 == B4)
assert B2 == B3 == B4 == Fraction(1,3)

Kjørt utskriftB2 = 1/3
B3 = 1/3
B4 = 1/3
Alle like? True

from sympy import symbols, summation, simplify
n, i, k = symbols('n i k', integer=True, positive=True)
closed = summation(2*i-1, (i,1,n))
induction_step = simplify(k**2 + (2*k+1) - (k+1)**2)
print("Symbolsk sum =", closed)
print("Basis n=1 =", closed.subs(n,1))
print("Forskjell i induksjonssteget =", induction_step)
for value in range(1,8):
    direct = sum(2*j-1 for j in range(1,value+1))
    print(value, direct, value**2)
assert simplify(closed-n**2) == 0 and induction_step == 0

Kjørt utskriftSymbolsk sum = n**2
Basis n=1 = 1
Forskjell i induksjonssteget = 0
1 1 1
2 4 4
3 9 9
4 16 16
5 25 25
6 36 36
7 49 49

from sympy import symbols, simplify, Rational
n = symbols('n', integer=True, positive=True)
Sn = n**2
S2n = (2*n)**2
denominator = simplify(S2n - Sn)
Bn = simplify(Sn/denominator)
print("S_n =", Sn)
print("S_2n =", S2n)
print("Nevner S_2n - S_n =", denominator)
print("B_n =", Bn)
assert Bn == Rational(1,3)

Kjørt utskriftS_n = n**2
S_2n = 4*n**2
Nevner S_2n - S_n = 3*n**2
B_n = 1/3

from sympy import symbols
x, y, z = symbols('x y z', real=True)
left = x**2 - 2*x + y**2 + 2*y + z**2 - 6*z
value = left.subs({x:4, y:3, z:3})
print("Venstreside =", left)
print("Innsetting A(4,3,3) =", value)
print("Høyreside = 14")
print("Ligger A på kuleflaten?", value == 14)
assert value == 14

Kjørt utskriftVenstreside = x**2 - 2*x + y**2 + 2*y + z**2 - 6*z
Innsetting A(4,3,3) = 14
Høyreside = 14
Ligger A på kuleflaten? True

from sympy import symbols, expand, simplify, sqrt
x, y, z = symbols('x y z', real=True)
standard = (x-1)**2 + (y+1)**2 + (z-3)**2
expanded = expand(standard)
original_left = x**2-2*x+y**2+2*y+z**2-6*z
print("Standarduttrykk =", standard)
print("Utvidet standarduttrykk =", expanded)
print("Original venstreside + 11 =", original_left + 11)
print("Kontroll =", simplify(standard - (original_left+11)))
print("Sentrum = (1, -1, 3)")
print("Radius =", sqrt(25))
assert simplify(standard-(original_left+11)) == 0

Kjørt utskriftStandarduttrykk = (x - 1)**2 + (y + 1)**2 + (z - 3)**2
Utvidet standarduttrykk = x**2 - 2*x + y**2 + 2*y + z**2 - 6*z + 11
Original venstreside + 11 = x**2 - 2*x + y**2 + 2*y + z**2 - 6*z + 11
Kontroll = 0
Sentrum = (1, -1, 3)
Radius = 5

from sympy import Matrix, symbols, expand
x, y, z = symbols('x y z', real=True)
S = Matrix([1,-1,3])
A = Matrix([4,3,3])
normal = A-S
plane = expand(normal.dot(Matrix([x,y,z])-A))
print("S =", S.T)
print("A =", A.T)
print("Normalvektor SA =", normal.T)
print("Planuttrykk =", plane)
print("Kontroll i A =", plane.subs({x:4,y:3,z:3}))
assert plane == 3*x+4*y-24

Kjørt utskriftS = Matrix([[1, -1, 3]])
A = Matrix([[4, 3, 3]])
Normalvektor SA = Matrix([[3, 4, 0]])
Planuttrykk = 3*x + 4*y - 24
Kontroll i A = 0

from sympy import Matrix, symbols, expand
x, y, z = symbols('x y z', real=True)
S = Matrix([1,-1,3])
B = Matrix([1,0,1])
n_alpha = Matrix([3,4,0])
direction = B-S
n_beta = n_alpha.cross(direction)
plane = expand(n_beta.dot(Matrix([x,y,z])-S))
print("Retningsvektor SB =", direction.T)
print("Normal til alpha =", n_alpha.T)
print("Normal til beta =", n_beta.T)
print("n_beta · n_alpha =", n_beta.dot(n_alpha))
print("n_beta · SB =", n_beta.dot(direction))
print("Plan beta =", plane, "= 0")
print("Kontroll i B =", plane.subs({x:1,y:0,z:1}))
assert n_beta.dot(n_alpha)==0 and plane.subs({x:1,y:0,z:1})==0

Kjørt utskriftRetningsvektor SB = Matrix([[0, 1, -2]])
Normal til alpha = Matrix([[3, 4, 0]])
Normal til beta = Matrix([[-8, 6, 3]])
n_beta · n_alpha = 0
n_beta · SB = 0
Plan beta = -8*x + 6*y + 3*z + 5 = 0
Kontroll i B = 0

from sympy import symbols, simplify, Rational

y = symbols('y', positive=True)
births = Rational(11,1000)*y
deaths = Rational(8,1000)*y
immigration = 44000
net_rate = simplify(births - deaths + immigration)
print("Fødte per år =", births)
print("Døde per år =", deaths)
print("Netto innvandring =", immigration)
print("Samlet vekstfart =", net_rate)
print("Initialbetingelse: y(0) = 5200000")
assert simplify(net_rate - (Rational(3,1000)*y+44000)) == 0

Kjørt utskriftFødte per år = 11*y/1000
Døde per år = y/125
Netto innvandring = 44000
Samlet vekstfart = 3*y/1000 + 44000
Initialbetingelse: y(0) = 5200000

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

t = symbols('t', real=True)
y = Function('y')
ode = Eq(diff(y(t), t), Rational(3,1000)*y(t) + 44000)
solution = dsolve(ode, ics={y(0): 5200000})
model = Rational(59600000,3)*exp(Rational(3,1000)*t) - Rational(44000000,3)
residual = simplify(diff(model,t) - (Rational(3,1000)*model + 44000))
print("Differensialligning =", ode)
print("SymPy-løsning =", solution)
print("Modell =", model)
print("y(0) =", model.subs(t,0))
print("Residual =", residual)
assert residual == 0 and model.subs(t,0) == 5200000

Kjørt utskriftDifferensialligning = Eq(Derivative(y(t), t), 3*y(t)/1000 + 44000)
SymPy-løsning = Eq(y(t), 59600000*exp(3*t/1000)/3 - 44000000/3)
Modell = 59600000*exp(3*t/1000)/3 - 44000000/3
y(0) = 5200000
Residual = 0

from sympy import log, Rational, N, exp, symbols, simplify

t = symbols('t', real=True)
exact_t = log(Rational(325,298))/Rational(3,1000)
model = Rational(59600000,3)*exp(Rational(3,1000)*t)-Rational(44000000,3)
rate = Rational(3,1000)*7_000_000 + 44_000
print("Eksakt t =", exact_t)
print("t i år =", N(exact_t, 12))
print("Kalenderår ≈", N(2015 + exact_t, 12))
print("Modellverdi ved t =", simplify(model.subs(t, exact_t)))
print("Vekstfart ved 7 millioner =", rate, "personer per år")
assert simplify(model.subs(t,exact_t)-7_000_000) == 0 and rate == 65_000

Kjørt utskriftEksakt t = 1000*log(325/298)/3
t i år = 28.9105652748
Kalenderår ≈ 2043.91056527
Modellverdi ved t = 7000000
Vekstfart ved 7 millioner = 65000 personer per år

from sympy import symbols, factor, limit, oo
x = symbols('x', real=True)
f = x**2 - x**4
print("f(x) =", f)
print("Faktorisert =", factor(f))
print("f(-x)-f(x) =", (f.subs(x,-x)-f).simplify())
print("Grense x->oo =", limit(f,x,oo))
print("Grense x->-oo =", limit(f,x,-oo))
print("Nullpunkter: -1, 0, 1")
assert factor(f) == -x**2*(x-1)*(x+1)

Kjørt utskriftf(x) = -x**4 + x**2
Faktorisert = -x**2*(x - 1)*(x + 1)
f(-x)-f(x) = 0
Grense x->oo = -oo
Grense x->-oo = -oo
Nullpunkter: -1, 0, 1

from sympy import symbols, diff, solve, sqrt, simplify
x = symbols('x', real=True)
f = x**2 - x**4
f1 = diff(f,x)
f2 = diff(f,x,2)
critical = solve(f1,x)
points = [(c, simplify(f.subs(x,c)), simplify(f2.subs(x,c))) for c in critical]
print("f'(x) =", f1)
print("f''(x) =", f2)
print("Kritiske punkter (x, y, f''):")
for point in points:
    print(point)
expected_x = {-sqrt(2)/2, sqrt(2)/2}
max_x = {c for c,yv,second in points if second < 0}
assert max_x == expected_x

Kjørt utskriftf'(x) = -4*x**3 + 2*x
f''(x) = 2*(1 - 6*x**2)
Kritiske punkter (x, y, f''):
(0, 0, 2)
(-sqrt(2)/2, 1/4, -4)
(sqrt(2)/2, 1/4, -4)

from sympy import symbols, integrate, Rational, simplify
x = symbols('x', real=True)
f = x**2 - x**4
left = integrate(f,(x,-1,0))
right = integrate(f,(x,0,1))
total = integrate(f,(x,-1,1))
print("Venstre delareal =", left)
print("Høyre delareal =", right)
print("Samlet areal =", total)
print("Desimalverdi =", total.evalf())
print("Kontroll mot 4/15 =", simplify(total-Rational(4,15)))
assert total == Rational(4,15)

Kjørt utskriftVenstre delareal = 2/15
Høyre delareal = 2/15
Samlet areal = 4/15
Desimalverdi = 0.266666666666667
Kontroll mot 4/15 = 0

from sympy import symbols, integrate, pi, expand, simplify, Rational
x = symbols('x', real=True)
f = x**2-x**4
squared = expand(f**2)
volume = pi*integrate(f**2,(x,-1,1))
expected = Rational(16,315)*pi
print("f(x)^2 =", squared)
print("Integral uten pi =", integrate(f**2,(x,-1,1)))
print("Volum =", volume)
print("Desimalverdi =", volume.evalf())
print("Kontroll =", simplify(volume-expected))
assert simplify(volume-expected) == 0

Kjørt utskriftf(x)^2 = x**8 - 2*x**6 + x**4
Integral uten pi = 16/315
Volum = 16*pi/315
Desimalverdi = 0.159572960182339
Kontroll = 0

from sympy import symbols, simplify
x, y, z, p = symbols('x y z p', real=True)
alpha = x-y-3
beta = x+p*z-4
point = {x:4, y:1, z:0}
alpha_value = simplify(alpha.subs(point))
beta_value = simplify(beta.subs(point))
print("alpha i punktet =", alpha_value)
print("beta i punktet =", beta_value)
print("Uavhengig av p?", p not in beta_value.free_symbols)
assert alpha_value == 0 and beta_value == 0

Kjørt utskriftalpha i punktet = 0
beta i punktet = 0
Uavhengig av p? True

from sympy import symbols, Matrix, sqrt, solve, Eq, simplify, Rational
p = symbols('p', real=True)
n_alpha = Matrix([1,-1,0])
n_beta = Matrix([1,0,p])
cos_angle = simplify(abs(n_alpha.dot(n_beta))/(sqrt(n_alpha.dot(n_alpha))*sqrt(n_beta.dot(n_beta))))
solutions = solve(Eq(cos_angle, Rational(1,2)), p)
print("n_alpha =", n_alpha.T)
print("n_beta =", n_beta.T)
print("Skalarprodukt =", n_alpha.dot(n_beta))
print("cos(vinkel) =", cos_angle)
print("Løsninger p =", solutions)
for value in solutions:
    print(value, "gir cos =", simplify(cos_angle.subs(p,value)))
assert set(solutions) == {-1,1}

Kjørt utskriftn_alpha = Matrix([[1, -1, 0]])
n_beta = Matrix([[1, 0, p]])
Skalarprodukt = 1
cos(vinkel) = sqrt(2)/(2*sqrt(p**2 + 1))
Løsninger p = [-1, 1]
-1 gir cos = 1/2
1 gir cos = 1/2

from sympy import symbols, sqrt, acos, pi, simplify, diff, solve
p = symbols('p', real=True)
cos_theta = 1/(sqrt(2)*sqrt(1+p**2))
derivative = simplify(diff(cos_theta,p))
critical = solve(derivative,p)
angle = simplify(acos(cos_theta.subs(p,0))*180/pi)
print("cos(theta) =", cos_theta)
print("Derivert =", derivative)
print("Kritisk p =", critical)
print("cos(theta) ved p=0 =", simplify(cos_theta.subs(p,0)))
print("Minste vinkel i grader =", angle)
print("Kontroll p=1, cos =", simplify(cos_theta.subs(p,1)))
assert critical == [0] and angle == 45

Kjørt utskriftcos(theta) = sqrt(2)/(2*sqrt(p**2 + 1))
Derivert = -sqrt(2)*p/(2*(p**2 + 1)**(3/2))
Kritisk p = [0]
cos(theta) ved p=0 = sqrt(2)/2
Minste vinkel i grader = 45
Kontroll p=1, cos = 1/2

from sympy import symbols, Matrix, simplify
p, t = symbols('p t', real=True)
point = Matrix([4,1,0])
direction = Matrix([-p,-p,1])
line = point + t*direction
alpha_value = simplify(line[0]-line[1]-3)
beta_value = simplify(line[0]+p*line[2]-4)
cross = Matrix([1,-1,0]).cross(Matrix([1,0,p]))
print("Punkt på linjen =", point.T)
print("Retningsvektor =", direction.T)
print("Parameterframstilling =", line.T)
print("Kontroll i alpha =", alpha_value)
print("Kontroll i beta =", beta_value)
print("Kryssprodukt normaler =", cross.T)
assert alpha_value == 0 and beta_value == 0 and cross == direction

Kjørt utskriftPunkt på linjen = Matrix([[4, 1, 0]])
Retningsvektor = Matrix([[-p, -p, 1]])
Parameterframstilling = Matrix([[-p*t + 4, -p*t + 1, t]])
Kontroll i alpha = 0
Kontroll i beta = 0
Kryssprodukt normaler = Matrix([[-p, -p, 1]])

from sympy import symbols, Eq

a1, k = symbols('a1 k', real=True)
eq_infinite = Eq(a1/(1-k), 8)
eq_three = Eq(a1*(1+k+k**2), 7)
print("Ligning for uendelig sum:", eq_infinite)
print("Ligning for tre første ledd:", eq_three)
print("Konvergensvilkår: Abs(k) < 1")
assert eq_infinite.rhs == 8 and eq_three.rhs == 7

Kjørt utskriftLigning for uendelig sum: Eq(a1/(1 - k), 8)
Ligning for tre første ledd: Eq(a1*(k**2 + k + 1), 7)
Konvergensvilkår: Abs(k) < 1

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

a1, k = symbols('a1 k', real=True)
solutions = solve([Eq(a1/(1-k),8), Eq(a1*(1+k+k**2),7)], [a1,k], dict=True)
print("CAS-løsninger =", solutions)
valid = []
for solution in solutions:
    kval = solution[k]
    if abs(float(kval)) < 1:
        valid.append(solution)
        print("Gyldig løsning =", solution)
        print("Uendelig sum =", simplify(solution[a1]/(1-kval)))
        print("Tre første ledd =", simplify(solution[a1]*(1+kval+kval**2)))
assert valid == [{a1:4, k:Rational(1,2)}]

Kjørt utskriftCAS-løsninger = [{a1: 4, k: 1/2}]
Gyldig løsning = {a1: 4, k: 1/2}
Uendelig sum = 8
Tre første ledd = 7