from sympy import symbols, integrate, Rational, simplify
x = symbols('x', real=True)
expr = 4*x**2 + 3
F = integrate(expr, x)
value = integrate(expr, (x, 0, 1))
print("Integrand =", expr)
print("Antiderivert =", F)
print("F(1) =", F.subs(x, 1))
print("F(0) =", F.subs(x, 0))
print("Bestemt integral =", value)
print("Kontroll =", simplify(value - Rational(13, 3)))
assert simplify(value - Rational(13, 3)) == 0

Kjørt utskriftIntegrand = 4*x**2 + 3
Antiderivert = 4*x**3/3 + 3*x
F(1) = 13/3
F(0) = 0
Bestemt integral = 13/3
Kontroll = 0

from sympy import symbols, sqrt, integrate, diff, simplify, Rational
x = symbols('x', real=True)
expr = 4*x*sqrt(x**2 + 2)
F = Rational(4, 3)*(x**2 + 2)**Rational(3, 2)
cas_F = integrate(expr, x)
print("Integrand =", expr)
print("Foreslått antiderivert =", F)
print("SymPy-antiderivert =", cas_F)
print("Derivert tilbake =", simplify(diff(F, x)))
print("Kontroll =", simplify(diff(F, x) - expr))
assert simplify(diff(F, x) - expr) == 0

Kjørt utskriftIntegrand = 4*x*sqrt(x**2 + 2)
Foreslått antiderivert = 4*(x**2 + 2)**(3/2)/3
SymPy-antiderivert = 4*x**2*sqrt(x**2 + 2)/3 + 8*sqrt(x**2 + 2)/3
Derivert tilbake = 4*x*sqrt(x**2 + 2)
Kontroll = 0

from sympy import Matrix
u = Matrix([1, 2, -1])
v = Matrix([-1, 1, -2])
n = Matrix([-1, 1, 1])
print("u =", list(u))
print("v =", list(v))
print("n =", list(n))
print("n · u =", n.dot(u))
print("n · v =", n.dot(v))
print("u × v =", list(u.cross(v)))
assert n.dot(u) == 0
assert n.dot(v) == 0

Kjørt utskriftu = [1, 2, -1]
v = [-1, 1, -2]
n = [-1, 1, 1]
n · u = 0
n · v = 0
u × v = [-3, 3, 3]

from sympy import symbols, simplify
x, y, z = symbols('x y z', real=True)
plane = -(x - 2) + y + (z - 1)
standard = simplify(plane)
print("Punkt-normal-form = -(x-2) + y + (z-1)")
print("Forenklet venstreside =", standard)
print("Kontroll i P(2,0,1) =", standard.subs({x:2,y:0,z:1}))
print("Ekvivalent form x-y-z-1 =", x-y-z-1)
assert standard.subs({x:2,y:0,z:1}) == 0
assert simplify(standard + (x-y-z-1)) == 0

Kjørt utskriftPunkt-normal-form = -(x-2) + y + (z-1)
Forenklet venstreside = -x + y + z + 1
Kontroll i P(2,0,1) = 0
Ekvivalent form x-y-z-1 = x - y - z - 1

from sympy import symbols, sin, cos, pi, sqrt, solveset, Interval, simplify
x = symbols('x', real=True)
expr = cos(x)**2 - 3*sin(x)**2 + 2
solutions = solveset(expr, x, domain=Interval.Ropen(0, 2*pi))
expected = {pi/3, 2*pi/3, 4*pi/3, 5*pi/3}
print("Likningens venstreside flyttet til null =", expr)
print("Løsninger i [0,2*pi) =", solutions)
for value in sorted(expected, key=lambda t: float(t)):
    print("Kontroll ved", value, "=", simplify(expr.subs(x, value)))
assert set(solutions) == expected

Kjørt utskriftLikningens venstreside flyttet til null = -3*sin(x)**2 + cos(x)**2 + 2
Løsninger i [0,2*pi) = {pi/3, 2*pi/3, 4*pi/3, 5*pi/3}
Kontroll ved pi/3 = 0
Kontroll ved 2*pi/3 = 0
Kontroll ved 4*pi/3 = 0
Kontroll ved 5*pi/3 = 0

from sympy import symbols, expand, simplify
n = symbols('n', integer=True, positive=True)
s = 3*n**2 + 4*n
a_n = expand(s - s.subs(n, n-1))
a4 = simplify(s.subs(n,4) - s.subs(n,3))
print("s_n =", s)
print("s_4 =", s.subs(n,4))
print("s_3 =", s.subs(n,3))
print("a_n = s_n - s_(n-1) =", a_n)
print("a_4 =", a4)
assert a_n == 6*n + 1
assert a4 == 25

Kjørt utskrifts_n = 3*n**2 + 4*n
s_4 = 64
s_3 = 39
a_n = s_n - s_(n-1) = 6*n + 1
a_4 = 25

from sympy import symbols, Eq, solve, Rational, simplify
k = symbols('k', real=True)
solutions = solve(Eq(Rational(38,9), 6*(1-k**3)), k)
ratio = solutions[0]
S4 = simplify(6*(1-ratio**4))
first_term = simplify(6*(1-ratio))
print("Løsninger for kvotienten =", solutions)
print("Kvotient k =", ratio)
print("Første ledd a =", first_term)
print("Kontroll S3 =", simplify(first_term*(1-ratio**3)/(1-ratio)))
print("S4 =", S4)
assert ratio == Rational(2,3)
assert S4 == Rational(130,27)

Kjørt utskriftLøsninger for kvotienten = [2/3]
Kvotient k = 2/3
Første ledd a = 2
Kontroll S3 = 38/9
S4 = 130/27

from math import sin, pi

def f(x):
    return 2*sin(x + pi/6)

a = 0
b = pi
n = 10000
h = (b-a)/n
I = 0
for i in range(n):
    I = I + f(a+i*h)*h
print("a =", a)
print("b =", b)
print("n =", n)
print("h =", h)
print("Venstresum I =", I)
print("Programutskrift round(I,2) =", round(I,2))
assert abs(I-2*3**0.5) < 0.001

Kjørt utskrifta = 0
b = 3.141592653589793
n = 10000
h = 0.0003141592653589793
Venstresum I = 3.464415745912007
Programutskrift round(I,2) = 3.46

from sympy import symbols, sin, cos, pi, integrate, sqrt, simplify, N
x = symbols('x', real=True)
f = 2*sin(x+pi/6)
F = integrate(f, x)
I = integrate(f, (x,0,pi))
print("f(x) =", f)
print("Antiderivert =", F)
print("F(pi) =", F.subs(x,pi))
print("F(0) =", F.subs(x,0))
print("Eksakt integral =", I)
print("Desimalverdi =", N(I,15))
print("Kontroll =", simplify(I-2*sqrt(3)))
assert simplify(I-2*sqrt(3)) == 0

Kjørt utskriftf(x) = 2*sin(x + pi/6)
Antiderivert = -2*cos(x + pi/6)
F(pi) = sqrt(3)
F(0) = -sqrt(3)
Eksakt integral = 2*sqrt(3)
Desimalverdi = 3.46410161513775
Kontroll = 0

from sympy import symbols, diff, simplify
x = symbols('x', real=True)
F = x/(1-x)
integrand = 1/(1-x)**2
derivative = simplify(diff(F,x))
print("F(x) =", F)
print("F'(x) =", derivative)
print("Integrand =", integrand)
print("Kontroll =", simplify(derivative-integrand))
assert simplify(derivative-integrand) == 0

Kjørt utskriftF(x) = x/(1 - x)
F'(x) = (x - 1)**(-2)
Integrand = (1 - x)**(-2)
Kontroll = 0

from sympy import symbols, integrate, diff, simplify
x, u = symbols('x u', real=True)
integrand = 1/(1-x)**2
F = 1/(1-x)
print("Substitusjon u = 1-x")
print("dx = -du")
print("Nytt integral = -Integral(u**(-2), u)")
print("Antiderivert i u =", integrate(-u**-2,u))
print("Tilbake i x =", F)
print("Derivert tilbake =", simplify(diff(F,x)))
print("Kontroll =", simplify(diff(F,x)-integrand))
assert simplify(diff(F,x)-integrand) == 0

Kjørt utskriftSubstitusjon u = 1-x
dx = -du
Nytt integral = -Integral(u**(-2), u)
Antiderivert i u = 1/u
Tilbake i x = 1/(1 - x)
Derivert tilbake = (x - 1)**(-2)
Kontroll = 0

from sympy import symbols, simplify, diff
x = symbols('x', real=True)
F1 = x/(1-x)
F2 = 1/(1-x)
difference = simplify(F2-F1)
print("F1 =", F1)
print("F2 =", F2)
print("F2-F1 =", difference)
print("Derivert av forskjellen =", diff(difference,x))
print("Sammenheng: F1 = F2 - 1")
assert difference == 1
assert diff(difference,x) == 0

Kjørt utskriftF1 = x/(1 - x)
F2 = 1/(1 - x)
F2-F1 = 1
Derivert av forskjellen = 0
Sammenheng: F1 = F2 - 1

import numpy as np
from scipy.optimize import curve_fit
x = np.array([1,2,3,4,5,10,15,20,25,30,35,40,45,55,60,65], dtype=float)
y = np.array([0.25,0.18,0.11,0.06,0.02,0.11,0.57,0.99,0.80,0.32,0.02,0.14,0.64,0.77,0.31,0.01])

def model(x, a, b, c, d):
    return a*np.sin(b*x+c)+d

p0 = [0.5, 2*np.pi/29.5, -2.9, 0.5]
params, covariance = curve_fit(model, x, y, p0=p0, maxfev=100000)
a, b, c, d = params
predicted = model(x, *params)
rmse = np.sqrt(np.mean((predicted-y)**2))
print("a =", a)
print("b =", b)
print("c =", c)
print("d =", d)
print("Periode =", 2*np.pi/b)
print("RMSE =", rmse)
assert rmse < 0.02

Kjørt utskrifta = 0.4851102514937163
b = 0.21189354945447353
c = -2.920658551984734
d = 0.47475179466582185
Periode = 29.65255583926854
RMSE = 0.01807281139670276

from math import pi
b = 0.21189355
period = 2*pi/b
first_max = (pi/2 - (-2.92065851))/b
second_max = first_max + period
print("Vinkelhastighet b =", b)
print("Periode T =", period)
print("Første maksimum etter nyttår =", first_max)
print("Neste maksimum =", second_max)
print("Avstand mellom maksimum =", second_max-first_max)
assert abs(period-29.652556) < 1e-5

Kjørt utskriftVinkelhastighet b = 0.21189355
Periode T = 29.65255576292712
Første maksimum etter nyttår = 21.19675108937906
Neste maksimum = 50.84930685230618
Avstand mellom maksimum = 29.65255576292712

import numpy as np
from scipy.optimize import brentq

def f(x):
    return 0.48511025*np.sin(0.21189355*x-2.92065851)+0.47475179

left = brentq(lambda z: f(z)-0.5, 10, 20)
right = brentq(lambda z: f(z)-0.5, 25, 31)
days = [day for day in range(1,32) if f(day) >= 0.5]
print("Venstre grense =", left)
print("Høyre grense =", right)
print("Heltallsdøgn med f(x)>=0.5 =", days)
print("f(15) =", f(15))
print("f(28) =", f(28))
print("f(29) =", f(29))
assert days == list(range(15,29))

Kjørt utskriftVenstre grense = 14.029348084696059
Høyre grense = 28.364154094062055
Heltallsdøgn med f(x)>=0.5 = [15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28]
f(15) = 0.5984066058322934
f(28) = 0.5372690881646294
f(29) = 0.4346973616428914

from sympy import symbols, sin, pi, Abs, solve_univariate_inequality
x = symbols('x', real=True)
condition = Abs(2*sin(x)) < 1
print("Konvergenskrav =", condition)
# Kontroller representative punkter og grensepunkter
samples = [-2*pi, -3*pi/2, -pi, 0, pi, 3*pi/2, 2*pi]
for value in samples:
    print("x =", value, ", |2 sin x| =", Abs(2*sin(value)))
for boundary in [-11*pi/6,-7*pi/6,-5*pi/6,-pi/6,pi/6,5*pi/6,7*pi/6,11*pi/6]:
    assert Abs(2*sin(boundary)) == 1
assert Abs(2*sin(0)) < 1

Kjørt utskriftKonvergenskrav = 2*Abs(sin(x)) < 1
x = -2*pi , |2 sin x| = 0
x = -3*pi/2 , |2 sin x| = 2
x = -pi , |2 sin x| = 0
x = 0 , |2 sin x| = 0
x = pi , |2 sin x| = 0
x = 3*pi/2 , |2 sin x| = 2
x = 2*pi , |2 sin x| = 0

from sympy import symbols, sin, cos, sqrt, pi, diff, simplify, limit, oo
x = symbols('x', real=True)
S = cos(x)/(1-2*sin(x))
Sprime = simplify(diff(S,x))
print("S(x) =", S)
print("S'(x) =", Sprime)
print("S(-pi) =", S.subs(x,-pi))
print("Grense mot -5*pi/6 =", limit(S,x,-5*pi/6,dir='-'))
print("Grense mot -pi/6 =", limit(S,x,-pi/6,dir='+'))
print("Grense mot pi/6 =", limit(S,x,pi/6,dir='-'))
print("Grense mot 5*pi/6 =", limit(S,x,5*pi/6,dir='+'))
print("S(pi) =", S.subs(x,pi))
assert simplify(Sprime-(2-sin(x))/(1-2*sin(x))**2) == 0

Kjørt utskriftS(x) = cos(x)/(1 - 2*sin(x))
S'(x) = (2 - sin(x))/(2*sin(x) - 1)**2
S(-pi) = -1
Grense mot -5*pi/6 = -sqrt(3)/4
Grense mot -pi/6 = sqrt(3)/4
Grense mot pi/6 = oo
Grense mot 5*pi/6 = -oo
S(pi) = -1

points = []
for x in range(-3, 4):
    for y in range(-3, 4):
        for z in range(-3, 4):
            if x**2 + y**2 + z**2 == 9:
                points.append((x, y, z))
axis_points = [p for p in points if sum(value != 0 for value in p) == 1]
other_points = [p for p in points if p not in axis_points]
print("Antall testede punkter =", 7**3)
print("Antall punkter på kuleflaten =", len(points))
print("Aksepunkter =", axis_points)
print("Antall øvrige punkter =", len(other_points))
print("Første ti punkter =", points[:10])
assert len(points) == 30
assert len(axis_points) == 6
assert len(other_points) == 24

Kjørt utskriftAntall testede punkter = 343
Antall punkter på kuleflaten = 30
Aksepunkter = [(-3, 0, 0), (0, -3, 0), (0, 0, -3), (0, 0, 3), (0, 3, 0), (3, 0, 0)]
Antall øvrige punkter = 24
Første ti punkter = [(-3, 0, 0), (-2, -2, -1), (-2, -2, 1), (-2, -1, -2), (-2, -1, 2), (-2, 1, -2), (-2, 1, 2), (-2, 2, -1), (-2, 2, 1), (-1, -2, -2)]

from sympy import symbols, sin, cos, pi, Matrix, sqrt, simplify
t = symbols('t', real=True)
r = Matrix([cos(t), 3*sin(t), 2-cos(2*t)])
v = r.diff(t)
v_pi = v.subs(t,pi)
speed = simplify(sqrt(v_pi.dot(v_pi)))
print("r(t) =", list(r))
print("r'(t) =", list(v))
print("r'(pi) =", list(v_pi))
print("Banefart ved pi =", speed)
assert speed == 3

Kjørt utskriftr(t) = [cos(t), 3*sin(t), 2 - cos(2*t)]
r'(t) = [-sin(t), 3*cos(t), 2*sin(2*t)]
r'(pi) = [0, -3, 0]
Banefart ved pi = 3

from sympy import symbols, sin, cos, Matrix, simplify
t = symbols('t', real=True)
r = Matrix([cos(t), 3*sin(t), 2-cos(2*t)])
tangent = r.diff(t)
normal = Matrix([3,1,5])
dot_product = simplify(tangent.dot(normal))
print("Tangentvektor r'(t) =", list(tangent))
print("Normalvektor n =", list(normal))
print("r'(t) · n =", dot_product)
print("Tangentbetingelse: r'(t) · n = 0")
assert simplify(dot_product-(-3*sin(t)+3*cos(t)+10*sin(2*t))) == 0

Kjørt utskriftTangentvektor r'(t) = [-sin(t), 3*cos(t), 2*sin(2*t)]
Normalvektor n = [3, 1, 5]
r'(t) · n = 10*sin(2*t) + 3*sqrt(2)*cos(t + pi/4)
Tangentbetingelse: r'(t) · n = 0

import numpy as np
from scipy.optimize import brentq

def equation(t):
    return -3*np.sin(t)+3*np.cos(t)+10*np.sin(2*t)

def r(t):
    return np.array([np.cos(t), 3*np.sin(t), 2-np.cos(2*t)])

grid = np.linspace(0,2*np.pi,20001)
roots = []
for a,b in zip(grid[:-1],grid[1:]):
    if equation(a)*equation(b) < 0:
        root = brentq(equation,a,b)
        if not roots or abs(root-roots[-1]) > 1e-7:
            roots.append(root)
print("t-verdier =", roots)
for i,t in enumerate(roots,1):
    point = r(t)
    d = 3*point[0]+point[1]+5*point[2]
    print(f"P{i} = {point}, d = {d}")
assert len(roots) == 4
assert max(abs(equation(t)) for t in roots) < 1e-9

Kjørt utskriftt-verdier = [1.4401361901983887, 3.272252790186301, 4.890297437667566, 6.10527684989671]
P1 = [0.13028868 2.9744283  2.96604972], d = 18.19554294316614
P2 = [-0.9914761  -0.39086604  1.03395028], d = 1.8044570568338596
P3 = [ 0.17697143 -2.95264797  2.93736222], d = 12.26507745269774
P4 = [ 0.98421599 -0.5309143   1.06263778], d = 7.73492254730226

def hanoi_moves(n):
    if n == 1:
        return 1
    return 2*hanoi_moves(n-1)+1
for n in range(1,4):
    print(f"F({n}) =", hanoi_moves(n))
print("Kontroll mot 2^3-1 =", 2**3-1)
assert hanoi_moves(3) == 7

Kjørt utskriftF(1) = 1
F(2) = 3
F(3) = 7
Kontroll mot 2^3-1 = 7

def values_up_to(n_max):
    values = {1:1}
    for n in range(2,n_max+1):
        values[n] = 2*values[n-1]+1
    return values
values = values_up_to(10)
for n,value in values.items():
    print(f"F({n}) = {value}")
print("F(10) =", values[10])
assert values[10] == 1023

Kjørt utskriftF(1) = 1
F(2) = 3
F(3) = 7
F(4) = 15
F(5) = 31
F(6) = 63
F(7) = 127
F(8) = 255
F(9) = 511
F(10) = 1023
F(10) = 1023

def recursive_F(n):
    value = 1
    for _ in range(2,n+1):
        value = 2*value+1
    return value
for n in range(1,11):
    recursive = recursive_F(n)
    explicit = 2**n-1
    print(f"n={n:2d}: rekursiv={recursive:4d}, eksplisitt={explicit:4d}")
    assert recursive == explicit
print("Formel: F(n)=2**n-1")

Kjørt utskriftn= 1: rekursiv=   1, eksplisitt=   1
n= 2: rekursiv=   3, eksplisitt=   3
n= 3: rekursiv=   7, eksplisitt=   7
n= 4: rekursiv=  15, eksplisitt=  15
n= 5: rekursiv=  31, eksplisitt=  31
n= 6: rekursiv=  63, eksplisitt=  63
n= 7: rekursiv= 127, eksplisitt= 127
n= 8: rekursiv= 255, eksplisitt= 255
n= 9: rekursiv= 511, eksplisitt= 511
n=10: rekursiv=1023, eksplisitt=1023
Formel: F(n)=2**n-1

from sympy import symbols, simplify
k = symbols('k', integer=True, positive=True)
base_left = 1
base_right = 2**1-1
induction_left = 2*(2**k-1)+1
induction_right = 2**(k+1)-1
print("Grunnsteg: F(1) =", base_left, ", formel =", base_right)
print("Induksjonstrinn venstreside =", induction_left)
print("Mål for k+1 =", induction_right)
print("Forskjell =", simplify(induction_left-induction_right))
assert base_left == base_right
assert simplify(induction_left-induction_right) == 0

Kjørt utskriftGrunnsteg: F(1) = 1 , formel = 1
Induksjonstrinn venstreside = 2*2**k - 1
Mål for k+1 = 2**(k + 1) - 1
Forskjell = 0

from math import sin, radians, pi
R = 7.0
angle = radians(35)
center_height = R/sin(angle)
h = 10 + R - center_height
V = pi*h**2*(R-h/3)
opening_radius = 10*__import__('math').tan(angle)
print("Kuleradius R =", R, "cm")
print("Glassåpningens radius =", opening_radius, "cm")
print("Kulens sentrumshøyde =", center_height, "cm")
print("Kalotthøyde h =", h, "cm")
print("Overløpt volum =", V, "cm^3")
assert abs(V-390.2918804423735) < 1e-9

Kjørt utskriftKuleradius R = 7.0 cm
Glassåpningens radius = 7.002075382097097 cm
Kulens sentrumshøyde = 12.204127569347687 cm
Kalotthøyde h = 4.795872430652313 cm
Overløpt volum = 390.2918804423735 cm^3

from sympy import symbols, sin, pi, diff, factor, N
R = symbols('R', positive=True)
s = sin(35*pi/180)
h = 10 + R - R/s
V = pi*h**2*(R-h/3)
dV = factor(diff(V,R))
R_star = 10*s/(1+s-2*s**2)
V_star = V.subs(R,R_star)
opening_radius = 10*__import__('math').tan(__import__('math').radians(35))
print("h(R) =", h)
print("V(R) =", V)
print("Faktorisert V'(R) =", dV)
print("Optimal R =", N(R_star,16), "cm")
print("Maksimalt volum =", N(V_star,16), "cm^3")
print("Glassåpningens radius =", opening_radius, "cm")
print("V'(R*) =", N(diff(V,R).subs(R,R_star),12))
assert abs(float(diff(V,R).subs(R,R_star))) < 1e-9
assert float(R_star) < opening_radius

Kjørt utskrifth(R) = -R/sin(7*pi/36) + R + 10
V(R) = pi*(-R/sin(7*pi/36) + R + 10)**2*(R/(3*sin(7*pi/36)) + 2*R/3 - 10/3)
Faktorisert V'(R) = pi*(-R + R*sin(7*pi/36) + 10*sin(7*pi/36))*(-R - R*sin(7*pi/36) + 2*R*sin(7*pi/36)**2 + 10*sin(7*pi/36))/sin(7*pi/36)**3
Optimal R = 6.264510474182510 cm
Maksimalt volum = 402.0641817790401 cm^3
Glassåpningens radius = 7.002075382097097 cm
V'(R*) = 0.e-124