from sympy import symbols, cos, sin, diff, simplify
x = symbols('x', real=True)
f = 5*x*cos(x)
derivative = diff(f, x)
expected = 5*cos(x) - 5*x*sin(x)
print("f(x) =", f)
print("f'(x) =", derivative)
print("Forventet uttrykk =", expected)
print("Kontrollforskjell =", simplify(derivative - expected))
print("f'(0) =", derivative.subs(x, 0))

f(x) = 5*x*cos(x)
f'(x) = -5*x*sin(x) + 5*cos(x)
Forventet uttrykk = -5*x*sin(x) + 5*cos(x)
Kontrollforskjell = 0
f'(0) = 5

from sympy import symbols, sin, cos, diff, simplify
x = symbols('x', real=True, nonzero=True)
g = sin(2*x)/x
derivative = simplify(diff(g, x))
expected = (2*x*cos(2*x) - sin(2*x))/x**2
print("g(x) =", g)
print("g'(x) =", derivative)
print("Forventet uttrykk =", expected)
print("Kontrollforskjell =", simplify(derivative - expected))
print("Definisjonskrav: x != 0")

g(x) = sin(2*x)/x
g'(x) = (2*x*cos(2*x) - sin(2*x))/x**2
Forventet uttrykk = (2*x*cos(2*x) - sin(2*x))/x**2
Kontrollforskjell = 0
Definisjonskrav: x != 0

from sympy import symbols, exp, integrate, simplify, N
x = symbols('x', real=True)
integrand = 2*exp(2*x)
antiderivative = integrate(integrand, x)
value = integrate(integrand, (x, 0, 1))
expected = exp(2) - 1
print("Integrand =", integrand)
print("Stamfunksjon =", antiderivative)
print("F(1) - F(0) =", value)
print("Kontrollforskjell =", simplify(value - expected))
print("Desimalverdi =", N(value, 12))

Integrand = 2*exp(2*x)
Stamfunksjon = exp(2*x)
F(1) - F(0) = -1 + exp(2)
Kontrollforskjell = 0
Desimalverdi = 6.38905609893

from sympy import symbols, exp, integrate, diff, simplify, factor
x = symbols('x', real=True)
integrand = 2*x*exp(x)
F = 2*exp(x)*(x - 1)
cas_result = integrate(integrand, x)
print("Integrand =", integrand)
print("CAS-stamfunksjon =", cas_result)
print("Valgt faktorisert form =", F)
print("Derivert av valgt form =", diff(F, x))
print("Kontrollforskjell =", simplify(diff(F, x) - integrand))
print("Faktorisert CAS-resultat =", factor(cas_result))

Integrand = 2*x*exp(x)
CAS-stamfunksjon = (2*x - 2)*exp(x)
Valgt faktorisert form = 2*(x - 1)*exp(x)
Derivert av valgt form = 2*(x - 1)*exp(x) + 2*exp(x)
Kontrollforskjell = 0
Faktorisert CAS-resultat = 2*(x - 1)*exp(x)

from sympy import Matrix
A = Matrix([2, 0, 0])
B = Matrix([0, 3, 0])
C = Matrix([0, 0, 4])
AB = B - A
AC = C - A
dot_product = AB.dot(AC)
cross_product = AB.cross(AC)
print("AB =", AB.T)
print("AC =", AC.T)
print("AB dot AC =", dot_product)
print("AB cross AC =", cross_product.T)
print("Kontroll mot AB =", cross_product.dot(AB))
print("Kontroll mot AC =", cross_product.dot(AC))

AB = Matrix([[-2, 3, 0]])
AC = Matrix([[-2, 0, 4]])
AB dot AC = 4
AB cross AC = Matrix([[12, 8, 6]])
Kontroll mot AB = 0
Kontroll mot AC = 0

from sympy import Matrix, Abs, Rational
OA = Matrix([2, 0, 0])
OB = Matrix([0, 3, 0])
OC = Matrix([0, 0, 4])
M = Matrix.hstack(OA, OB, OC)
determinant = M.det()
volume = Rational(1, 6)*Abs(determinant)
print("Matrise med kantvektorer:")
print(M)
print("Determinant =", determinant)
print("Parallellipipedvolum =", Abs(determinant))
print("Tetraedervolum =", volume)

Matrise med kantvektorer:
Matrix([[2, 0, 0], [0, 3, 0], [0, 0, 4]])
Determinant = 24
Parallellipipedvolum = 24
Tetraedervolum = 4

from sympy import Matrix, symbols, simplify
x, y, z = symbols('x y z', real=True)
A = Matrix([2, 0, 0]); B = Matrix([0, 3, 0]); C = Matrix([0, 0, 4])
normal = (B - A).cross(C - A)
plane_expression = normal.dot(Matrix([x, y, z]) - A)
normalized = simplify((6*x + 4*y + 3*z)/12)
print("Normalvektor =", normal.T)
print("Planuttrykk =", plane_expression.expand())
print("Standardform: 6*x + 4*y + 3*z = 12")
print("Normalisert venstreside =", normalized)
for name, point in [("A",A),("B",B),("C",C)]:
    value = simplify(point[0]/2 + point[1]/3 + point[2]/4)
    print(f"Kontroll {name} =", value)

Normalvektor = Matrix([[12, 8, 6]])
Planuttrykk = 12*x + 8*y + 6*z - 24
Standardform: 6*x + 4*y + 3*z = 12
Normalisert venstreside = x/2 + y/3 + z/4
Kontroll A = 1
Kontroll B = 1
Kontroll C = 1

from sympy import symbols, exp, summation, oo, simplify, N
n = symbols('n', integer=True, nonnegative=True)
ratio = exp(-1)
series_sum = summation(exp(-n), (n, 0, oo))
formula_sum = 1/(1 - ratio)
print("Første ledd =", 1)
print("Kvotient =", ratio)
print("Kvotientens desimalverdi =", N(ratio, 12))
print("Er |k| < 1?", bool(N(abs(ratio)) < 1))
print("Sum fra SymPy =", series_sum)
print("Sumformel =", simplify(formula_sum))
print("Kontrollforskjell =", simplify(series_sum - formula_sum))

Første ledd = 1
Kvotient = exp(-1)
Kvotientens desimalverdi = 0.367879441171
Er |k| < 1? True
Sum fra SymPy = 1/(1 - exp(-1))
Sumformel = E/(-1 + E)
Kontrollforskjell = 0

from sympy import symbols, exp, summation, oo, simplify, N
x = symbols('x', real=True)
n = symbols('n', integer=True, nonnegative=True)
ratio = exp(-x)
closed_form = 1/(1 - ratio)
print("Første ledd = 1")
print("Kvotient k(x) =", ratio)
print("Konvergenskrav: exp(-x) < 1")
print("Dette gir: x > 0")
print("Lukket sumform =", closed_form)
print("Alternativ form =", simplify(exp(x)/(exp(x)-1)))
for value in [1, 2]:
    partial = sum(float(exp(-value*j)) for j in range(20))
    exact = float(closed_form.subs(x, value))
    print(f"x={value}: 20-ledds sum = {partial:.12f}, eksakt = {exact:.12f}")

Første ledd = 1
Kvotient k(x) = exp(-x)
Konvergenskrav: exp(-x) < 1
Dette gir: x > 0
Lukket sumform = 1/(1 - exp(-x))
Alternativ form = exp(x)/(exp(x) - 1)
x=1: 20-ledds sum = 1.581976703609, eksakt = 1.581976706869
x=2: 20-ledds sum = 1.156517642750, eksakt = 1.156517642750

from sympy import symbols, integrate, diff, simplify
t = symbols('t', real=True)
rate = 4*t + 3
primitive_without_constant = integrate(rate, t)
C = 800
N_function = primitive_without_constant + C
value_after_10 = N_function.subs(t, 10)
print("N'(t) =", rate)
print("Integrert uten konstant =", primitive_without_constant)
print("Initialbetingelsen gir C =", C)
print("N(t) =", N_function)
print("Kontroll av N'(t) =", diff(N_function, t))
print("Kontroll av N(0) =", N_function.subs(t, 0))
print("N(10) =", value_after_10)

N'(t) = 4*t + 3
Integrert uten konstant = 2*t**2 + 3*t
Initialbetingelsen gir C = 800
N(t) = 2*t**2 + 3*t + 800
Kontroll av N'(t) = 4*t + 3
Kontroll av N(0) = 800
N(10) = 1030

from sympy import symbols, Rational, diff, factor, solve
x = symbols('x', real=True)
f = Rational(1,2)*x**4 - 2*x**3 + Rational(5,2)*x
first = diff(f, x)
second = factor(diff(f, x, 2))
candidates = solve(second, x)
print("f(x) =", f)
print("f'(x) =", first)
print("f''(x) =", second)
print("Kandidater fra f''(x)=0:", candidates)
for point in candidates:
    print(f"f({point}) =", f.subs(x, point))
for test in [-1, 1, 3]:
    print(f"f''({test}) =", second.subs(x, test))

f(x) = x**4/2 - 2*x**3 + 5*x/2
f'(x) = 2*x**3 - 6*x**2 + 5/2
f''(x) = 6*x*(x - 2)
Kandidater fra f''(x)=0: [0, 2]
f(0) = 0
f(2) = -3
f''(-1) = 18
f''(1) = -6
f''(3) = 18

from sympy import symbols, Rational, diff, expand, simplify
x = symbols('x', real=True)
f = Rational(1,2)*x**4 - 2*x**3 + Rational(5,2)*x
fp = diff(f, x)
points = [0, 2]
print("f'(x) =", fp)
for x0 in points:
    y0 = f.subs(x, x0)
    slope = fp.subs(x, x0)
    tangent = expand(y0 + slope*(x - x0))
    print(f"Punkt ved x={x0}: ({x0}, {y0})")
    print("Stigningstall =", slope)
    print("Tangent y =", tangent)
    print("Punktkontroll =", simplify(tangent.subs(x, x0) - y0))

f'(x) = 2*x**3 - 6*x**2 + 5/2
Punkt ved x=0: (0, 0)
Stigningstall = 5/2
Tangent y = 5*x/2
Punktkontroll = 0
Punkt ved x=2: (2, -3)
Stigningstall = -11/2
Tangent y = 8 - 11*x/2
Punktkontroll = 0

from sympy import symbols, summation, simplify
n = symbols('n', integer=True, positive=True)
k = symbols('k', integer=True, positive=True)
i = symbols('i', integer=True, positive=True)
base_left = summation(1/(i*(i+1)), (i, 1, 1))
base_right = n/(n+1)
induction_left = k/(k+1) + 1/((k+1)*(k+2))
induction_right = (k+1)/(k+2)
general_sum = summation(1/(i*(i+1)), (i, 1, n))
print("Grunntrinn venstre =", base_left)
print("Grunntrinn høyre =", base_right.subs(n, 1))
print("Induksjonssteg før forenkling =", induction_left)
print("Induksjonssteg etter forenkling =", simplify(induction_left))
print("Mål for P(k+1) =", induction_right)
print("Forskjell i induksjonssteget =", simplify(induction_left - induction_right))
print("Symbolsk generell sum =", simplify(general_sum))

Grunntrinn venstre = 1/2
Grunntrinn høyre = 1/2
Induksjonssteg før forenkling = k/(k + 1) + 1/((k + 1)*(k + 2))
Induksjonssteg etter forenkling = (k + 1)/(k + 2)
Mål for P(k+1) = (k + 1)/(k + 2)
Forskjell i induksjonssteget = 0
Symbolsk generell sum = n/(n + 1)

from sympy import symbols, sin, cos, simplify, pi
v = symbols('v', real=True)
AB = 2
DC = 2*cos(v)
height = sin(v)
area_from_geometry = (AB + DC)/2 * height
claimed_area = (1 + cos(v))*sin(v)
print("AB =", AB)
print("DC =", DC)
print("Høyde =", height)
print("Areal fra trapesformelen =", area_from_geometry)
print("Forenklet areal =", simplify(area_from_geometry))
print("Kontrollforskjell =", simplify(area_from_geometry - claimed_area))
print("Tillatt intervall: 0 <= v <= pi/2")

AB = 2
DC = 2*cos(v)
Høyde = sin(v)
Areal fra trapesformelen = (cos(v) + 1)*sin(v)
Forenklet areal = (cos(v) + 1)*sin(v)
Kontrollforskjell = 0
Tillatt intervall: 0 <= v <= pi/2

from sympy import symbols, sin, cos, pi, diff, solve, simplify, sqrt, N
v = symbols('v', real=True)
F = (1 + cos(v))*sin(v)
Fp = simplify(diff(F, v))
critical_value = pi/3
values = {
    "F(0)": simplify(F.subs(v, 0)),
    "F(pi/3)": simplify(F.subs(v, critical_value)),
    "F(pi/2)": simplify(F.subs(v, pi/2)),
}
print("F(v) =", F)
print("F'(v) =", Fp)
print("Kritisk løsning i intervallet =", critical_value)
for name, value in values.items():
    print(name, "=", value, "=", N(value, 12))
print("Maksimalverdien er 3*sqrt(3)/4")

F(v) = (cos(v) + 1)*sin(v)
F'(v) = cos(v) + cos(2*v)
Kritisk løsning i intervallet = pi/3
F(0) = 0 = 0
F(pi/3) = 3*sqrt(3)/4 = 1.29903810568
F(pi/2) = 1 = 1.00000000000
Maksimalverdien er 3*sqrt(3)/4

from sympy import symbols, sin, pi, N
x = symbols('x', real=True)
f = sin(pi*x) + sin(2*pi*x)
print("f(x) =", f)
print("Kontrollpunkter:")
for value in [0, 0.5, 1, 1.5, 2, 3, 4, 5, 6]:
    print(f"f({value}) =", N(f.subs(x, value), 12))
print("Grafvindu: x fra 0 til 6")
print("Funksjonen er kontinuerlig og glatt på hele intervallet")

f(x) = sin(pi*x) + sin(2*pi*x)
Kontrollpunkter:
f(0) = 0
f(0.5) = 1.00000000000
f(1) = 0
f(1.5) = -1.00000000000
f(2) = 0
f(3) = 0
f(4) = 0
f(5) = 0
f(6) = 0
Grafvindu: x fra 0 til 6
Funksjonen er kontinuerlig og glatt på hele intervallet

from sympy import symbols, sin, pi, simplify
x = symbols('x', real=True)
f = sin(pi*x) + sin(2*pi*x)
shift_two = simplify(f.subs(x, x+2) - f)
shift_one = simplify(f.subs(x, x+1) - f)
print("f(x) =", f)
print("f(x+2) - f(x) =", shift_two)
print("f(x+1) - f(x) =", shift_one)
print("Er 2 en periode?", shift_two == 0)
print("Er 1 en periode?", shift_one == 0)
print("Grunnperioden er T = 2")

f(x) = sin(pi*x) + sin(2*pi*x)
f(x+2) - f(x) = 0
f(x+1) - f(x) = -2*sin(pi*x)
Er 2 en periode? True
Er 1 en periode? False
Grunnperioden er T = 2

from sympy import symbols, sin, cos, pi, expand_trig, simplify
x = symbols('x', real=True)
original = sin(pi*x) + sin(2*pi*x)
factored = sin(pi*x)*(1 + 2*cos(pi*x))
expanded = expand_trig(original)
print("Opprinnelig uttrykk =", original)
print("Faktorisert uttrykk =", factored)
print("Trigonometrisk utvidelse =", expanded)
print("Kontrollforskjell =", simplify(original - factored))
print("Identiteten er bekreftet symbolsk")

Opprinnelig uttrykk = sin(pi*x) + sin(2*pi*x)
Faktorisert uttrykk = (2*cos(pi*x) + 1)*sin(pi*x)
Trigonometrisk utvidelse = 2*sin(pi*x)*cos(pi*x) + sin(pi*x)
Kontrollforskjell = 0
Identiteten er bekreftet symbolsk

from sympy import symbols, sin, cos, pi, solveset, Interval
x = symbols('x', real=True)
f = sin(pi*x)*(1 + 2*cos(pi*x))
solutions = solveset(f, x, domain=Interval(0, 2))
print("Faktorisert funksjon =", f)
print("Løsningsmengde på [0,2] =", solutions)
ordered = [0, pi*0 + 2/3, 1, 4/3, 2]
print("Nullpunkter i stigende rekkefølge:")
for value in [0, 2/3, 1, 4/3, 2]:
    print(f"x = {value}: f(x) =", f.subs(x, value).evalf(15))

Faktorisert funksjon = (2*cos(pi*x) + 1)*sin(pi*x)
Løsningsmengde på [0,2] = {0, 2/3, 1, 4/3, 2}
Nullpunkter i stigende rekkefølge:
x = 0: f(x) = 0
x = 0.6666666666666666: f(x) = 1.74393424900432e-16
x = 1: f(x) = 0
x = 1.3333333333333333: f(x) = 3.48786849800863e-16
x = 2: f(x) = 0

from sympy import symbols, Function, Eq, Derivative, dsolve, exp, Rational, simplify
t = symbols('t', real=True)
K = Function('K')
ode = Eq(Derivative(K(t), t), Rational(2,25)*K(t) + 20000)
solution = 270000*exp(Rational(2,25)*t) - 250000
residual = simplify(solution.diff(t) - (Rational(2,25)*solution + 20000))
print("Differensiallikning:", ode)
print("Foreslått løsning K(t) =", solution)
print("K(0) =", solution.subs(t, 0))
print("K'(t) =", solution.diff(t))
print("Høyreside =", simplify(Rational(2,25)*solution + 20000))
print("Residual =", residual)
print("SymPy dsolve =", dsolve(ode, ics={K(0): 20000}))

Differensiallikning: Eq(Derivative(K(t), t), 2*K(t)/25 + 20000)
Foreslått løsning K(t) = 270000*exp(2*t/25) - 250000
K(0) = 20000
K'(t) = 21600*exp(2*t/25)
Høyreside = 21600*exp(2*t/25)
Residual = 0
SymPy dsolve = Eq(K(t), 270000*exp(2*t/25) - 250000)

from sympy import exp, Rational, N
t_value = 20
K20_exact = 270000*exp(Rational(2,25)*t_value) - 250000
K20_decimal = N(K20_exact, 16)
print("t =", t_value)
print("Eksakt K(20) =", K20_exact)
print("e^1.6 =", N(exp(Rational(8,5)), 16))
print("K(20) med 16 siffer =", K20_decimal)
print("Avrundet til nærmeste krone =", round(float(K20_decimal)))
print("Enhet: kroner")

t = 20
Eksakt K(20) = -250000 + 270000*exp(8/5)
e^1.6 = 4.953032424395115
K(20) med 16 siffer = 1087318.754586681
Avrundet til nærmeste krone = 1087319
Enhet: kroner

from sympy import symbols, exp, Rational, log, solve, N, simplify
t = symbols('t', real=True)
K = 270000*exp(Rational(2,25)*t) - 250000
rate = simplify(K.diff(t))
solution = log(Rational(175,108))/Rational(2,25)
print("K(t) =", K)
print("K'(t) =", rate)
print("Likning: K'(t) = 35000")
print("Eksakt tidspunkt =", solution)
print("Desimaltidspunkt =", N(solution, 15))
print("Kontroll K'(t) =", N(rate.subs(t, solution), 15))
print("Tilsvarende kapital =", N(K.subs(t, solution), 15))

K(t) = 270000*exp(2*t/25) - 250000
K'(t) = 21600*exp(2*t/25)
Likning: K'(t) = 35000
Eksakt tidspunkt = 25*log(175/108)/2
Desimaltidspunkt = 6.03318433499118
Kontroll K'(t) = 35000.0000000000
Tilsvarende kapital = 187500.000000000

from sympy import symbols, integrate, log, diff, simplify
x = symbols('x', real=True)
closed_form = 1/(1-x)
antiderivative = integrate(closed_form, x)
series_expression = -log(1-x)
print("Lukket form S(x) =", closed_form)
print("Integral av S(x) =", antiderivative)
print("Valgt uttrykk =", series_expression)
print("Derivert kontroll =", simplify(diff(series_expression, x) - closed_form))
print("Verdi ved x=0 =", series_expression.subs(x, 0))
print("Dermed er integrasjonskonstanten C = 0")

Lukket form S(x) = 1/(1 - x)
Integral av S(x) = -log(x - 1)
Valgt uttrykk = -log(1 - x)
Derivert kontroll = 0
Verdi ved x=0 = 0
Dermed er integrasjonskonstanten C = 0

from sympy import symbols, summation, oo, log, simplify, N
n = symbols('n', integer=True, positive=True)
term = 1/(n*2**n)
series_sum = summation(term, (n, 1, oo))
right_side = -log(1 - 1/2)
print("Generelt ledd a_n =", term)
print("SymPy-sum =", series_sum)
print("-ln(1-1/2) =", simplify(right_side))
print("ln(2) =", log(2))
print("Kontrollforskjell =", simplify(series_sum - log(2)))
print("Desimalverdi =", N(series_sum, 16))

Generelt ledd a_n = 1/(2**n*n)
SymPy-sum = log(2)
-ln(1-1/2) = 0.693147180559945
ln(2) = log(2)
Kontrollforskjell = 0
Desimalverdi = 0.6931471805599453

from sympy import log, N, Rational
exact = log(2)
threshold = Rational(1, 2)*10**-6
print("Eksakt ln(2) =", N(exact, 18))
print("Feilgrense for 6 korrekte desimaler =", float(threshold))
for n in [15, 16, 17, 18]:
    partial = sum(Rational(1, k*2**k) for k in range(1, n+1))
    error = exact - partial
    print(f"n={n}")
    print("  delsum =", N(partial, 18))
    print("  feil =", N(error, 18))
    print("  avrundet til 6 desimaler =", f"{float(partial):.6f}")
    print("  innenfor feilgrensen?", bool(N(error) < threshold))
print("Minste antall ledd = 17")

Eksakt ln(2) = 0.693147180559945309
Feilgrense for 6 korrekte desimaler = 5e-07
n=15
  delsum = 0.693145374590687091
  feil = 1.80596925821873014e-6
  avrundet til 6 desimaler = 0.693145
  innenfor feilgrensen? False
n=16
  delsum = 0.693146328265003497
  feil = 8.52294941812480141e-7
  avrundet til 6 desimaler = 0.693146
  innenfor feilgrensen? False
n=17
  delsum = 0.693146777052917100
  feil = 4.03507028209538965e-7
  avrundet til 6 desimaler = 0.693147
  innenfor feilgrensen? True
n=18
  delsum = 0.693146988980542968
  feil = 1.91579402341483409e-7
  avrundet til 6 desimaler = 0.693147
  innenfor feilgrensen? True
Minste antall ledd = 17

from sympy import symbols, solve, factor
x = symbols('x', real=True)
k = symbols('k', positive=True)
g = 1 - k**2*x**2
solutions = solve(g, x)
print("g(x) =", g)
print("Faktorisert g(x) =", factor(g))
print("Løsninger av g(x)=0:", solutions)
for root in solutions:
    print(f"Kontroll g({root}) =", g.subs(x, root).simplify())
print("Forutsetning: k > 0")

g(x) = -k**2*x**2 + 1
Faktorisert g(x) = -(k*x - 1)*(k*x + 1)
Løsninger av g(x)=0: [-1/k, 1/k]
Kontroll g(-1/k) = 0
Kontroll g(1/k) = 0
Forutsetning: k > 0

from sympy import symbols, cos, pi, integrate, solve, simplify, Rational
x = symbols('x', real=True)
k = symbols('k', positive=True)
A1 = integrate(cos(x), (x, -pi/2, pi/2))
A2 = simplify(integrate(1-k**2*x**2, (x, -1/k, 1/k)))
solution = solve(A2 - A1, k)
print("A1 =", A1)
print("A2(k) =", A2)
print("Likning A2 = A1 gir k =", solution)
selected = Rational(2,3)
print("Kontroll A2(2/3) =", simplify(A2.subs(k, selected)))
print("Kontrollforskjell =", simplify(A2.subs(k, selected) - A1))

A1 = 2
A2(k) = 4/(3*k)
Likning A2 = A1 gir k = [2/3]
Kontroll A2(2/3) = 2
Kontrollforskjell = 0

from sympy import symbols, cos, sin, expand_trig, trigsimp, simplify
x = symbols('x', real=True)
addition = expand_trig(cos(x+x))
target = (1 + cos(2*x))/2
print("cos(x+x) utvidet =", addition)
print("Etter sin^2(x)=1-cos^2(x): cos(2x)=2*cos^2(x)-1")
print("Måluttrykk =", target)
print("Kontrollforskjell =", trigsimp(cos(x)**2 - target))
print("Identiteten gjelder for alle reelle x")

cos(x+x) utvidet = 2*cos(x)**2 - 1
Etter sin^2(x)=1-cos^2(x): cos(2x)=2*cos^2(x)-1
Måluttrykk = cos(2*x)/2 + 1/2
Kontrollforskjell = 0
Identiteten gjelder for alle reelle x

from sympy import symbols, cos, sin, pi, integrate, simplify
x = symbols('x', real=True)
radius_squared = cos(x)**2
identity_form = (1 + cos(2*x))/2
integral_value = integrate(radius_squared, (x, -pi/2, pi/2))
volume = simplify(pi*integral_value)
print("Radius^2 =", radius_squared)
print("Identitetsform =", identity_form)
print("Kontroll av identitet =", simplify(radius_squared - identity_form))
print("Integral av cos^2(x) =", integral_value)
print("Volum V1 =", volume)
print("Desimalverdi =", volume.evalf(12))

Radius^2 = cos(x)**2
Identitetsform = cos(2*x)/2 + 1/2
Kontroll av identitet = 0
Integral av cos^2(x) = pi/2
Volum V1 = pi**2/2
Desimalverdi = 4.93480220054

from sympy import symbols, simplify
a, b, x = symbols('a b x', nonzero=True, real=True)
slope = (0-b)/(a-0)
y_expression = slope*x + b
print("Stigningstall =", slope)
print("Linjeuttrykk y =", y_expression)
print("Kontroll i A: y(a) =", simplify(y_expression.subs(x, a)))
print("Kontroll i B: y(0) =", simplify(y_expression.subs(x, 0)))
print("Forutsetning: a != 0 og b != 0")

Stigningstall = -b/a
Linjeuttrykk y = b - b*x/a
Kontroll i A: y(a) = 0
Kontroll i B: y(0) = b
Forutsetning: a != 0 og b != 0

from sympy import symbols, solve, simplify
a, b, x, y = symbols('a b x y', nonzero=True, real=True)
intercept_equation = x/a + y/b - 1
solved_for_y = solve(intercept_equation, y)[0]
expected = -b*x/a + b
print("Skjæringsform: x/a + y/b = 1")
print("Løst for y =", solved_for_y)
print("Forventet y-uttrykk =", expected)
print("Kontrollforskjell =", simplify(solved_for_y - expected))
print("A-kontroll =", simplify(a/a + 0/b))
print("B-kontroll =", simplify(0/a + b/b))

Skjæringsform: x/a + y/b = 1
Løst for y = b*(a - x)/a
Forventet y-uttrykk = b - b*x/a
Kontrollforskjell = 0
A-kontroll = 1
B-kontroll = 1

from sympy import symbols, Matrix, simplify
a, b, c = symbols('a b c', nonzero=True, real=True)
AB = Matrix([-a, b, 0])
AC = Matrix([-a, 0, c])
normal = AB.cross(AC)
print("AB =", AB.T)
print("AC =", AC.T)
print("AB cross AC =", normal.T)
print("Forventet normal =", Matrix([b*c, a*c, a*b]).T)
print("n dot AB =", simplify(normal.dot(AB)))
print("n dot AC =", simplify(normal.dot(AC)))

AB = Matrix([[-a, b, 0]])
AC = Matrix([[-a, 0, c]])
AB cross AC = Matrix([[b*c, a*c, a*b]])
Forventet normal = Matrix([[b*c, a*c, a*b]])
n dot AB = 0
n dot AC = 0

from sympy import symbols, simplify
a, b, c, x, y, z = symbols('a b c x y z', nonzero=True, real=True)
standard_left = b*c*x + a*c*y + a*b*z
standard_right = a*b*c
normalized = simplify(standard_left/standard_right)
print("Standardform venstreside =", standard_left)
print("Standardform høyreside =", standard_right)
print("Etter divisjon med a*b*c =", normalized)
print("A-kontroll =", simplify(a/a + 0/b + 0/c))
print("B-kontroll =", simplify(0/a + b/b + 0/c))
print("C-kontroll =", simplify(0/a + 0/b + c/c))

Standardform venstreside = a*b*z + a*c*y + b*c*x
Standardform høyreside = a*b*c
Etter divisjon med a*b*c = z/c + y/b + x/a
A-kontroll = 1
B-kontroll = 1
C-kontroll = 1

from sympy import Matrix, symbols, simplify
x, y, z = symbols('x y z', real=True)
D = Matrix([5, 0, 0])
E = Matrix([0, 4, 0])
z_direction = Matrix([0, 0, 1])
normal = Matrix([4, 5, 0])
plane_expression = 4*x + 5*y - 20
print("Planlikning: 4*x + 5*y = 20")
print("Skjæringsform: x/5 + y/4 = 1")
print("Kontroll D =", plane_expression.subs({x:5, y:0}))
print("Kontroll E =", plane_expression.subs({x:0, y:4}))
print("Normalvektor =", normal.T)
print("n dot z-retning =", normal.dot(z_direction))
print("Ingen z-ledd: planet er parallelt med z-aksen")

Planlikning: 4*x + 5*y = 20
Skjæringsform: x/5 + y/4 = 1
Kontroll D = 0
Kontroll E = 0
Normalvektor = Matrix([[4, 5, 0]])
n dot z-retning = 0
Ingen z-ledd: planet er parallelt med z-aksen