from sympy import symbols, integrate, simplify
x = symbols('x', real=True)
integrand = 4*x**3 - x
antiderivative = integrate(integrand, x)
value = integrate(integrand, (x, -1, 1))
print("Integrand =", integrand)
print("h(-x) + h(x) =", simplify(integrand.subs(x, -x) + integrand))
print("Stamfunksjon =", antiderivative)
print("H(1) =", antiderivative.subs(x, 1))
print("H(-1) =", antiderivative.subs(x, -1))
print("Bestemt integral =", value)
assert value == 0

Kjørt utskriftIntegrand = 4*x**3 - x
h(-x) + h(x) = 0
Stamfunksjon = x**4 - x**2/2
H(1) = 1/2
H(-1) = 1/2
Bestemt integral = 0

from sympy import symbols, exp, log, integrate, Rational, simplify
x = symbols('x', real=True)
integrand = exp(2*x)
F = integrate(integrand, x)
value = integrate(integrand, (x, 0, log(2)))
print("Integrand =", integrand)
print("Stamfunksjon =", F)
print("Øvre verdi =", simplify(F.subs(x, log(2))))
print("Nedre verdi =", simplify(F.subs(x, 0)))
print("Bestemt integral =", value)
print("Kontroll mot 3/2 =", simplify(value - Rational(3,2)))
assert simplify(value - Rational(3,2)) == 0

Kjørt utskriftIntegrand = exp(2*x)
Stamfunksjon = exp(2*x)/2
Øvre verdi = 2
Nedre verdi = 1/2
Bestemt integral = 3/2
Kontroll mot 3/2 = 0

from sympy import symbols, tan, sin, cos, diff, simplify, trigsimp
x = symbols('x', real=True)
f = tan(x)
derivative = diff(f, x)
identity_form = 1 + tan(x)**2
quotient_form = diff(sin(x)/cos(x), x)
print("f(x) =", f)
print("Derivert av tan(x) =", derivative)
print("Derivert via sin/cos =", quotient_form)
print("1 + tan(x)^2 =", identity_form)
print("Kontroll derivative - identity =", trigsimp(derivative - identity_form))
print("Kontroll kvotientform =", simplify(trigsimp(quotient_form - identity_form)))
assert trigsimp(derivative - identity_form) == 0

Kjørt utskriftf(x) = tan(x)
Derivert av tan(x) = tan(x)**2 + 1
Derivert via sin/cos = sin(x)**2/cos(x)**2 + 1
1 + tan(x)^2 = tan(x)**2 + 1
Kontroll derivative - identity = 0
Kontroll kvotientform = 0

from sympy import symbols, tan, sin, cos, log, diff, simplify, trigsimp
x = symbols('x', real=True)
integrand = (1 + tan(x)**2)/tan(x)
F = log(tan(x))
rewritten = cos(x)/sin(x) + sin(x)/cos(x)
print("Integrand =", integrand)
print("Omskrevet =", rewritten)
print("Trigonometrisk kontroll =", trigsimp(integrand - rewritten))
print("Foreslått stamfunksjon = log(tan(x))")
print("Derivert tilbake =", diff(F, x))
print("Kontroll =", simplify(trigsimp(diff(F, x) - integrand)))
print("Merk: absoluttverdi brukes i den reelle stamfunksjonen.")
assert simplify(trigsimp(diff(F, x) - integrand)) == 0

Kjørt utskriftIntegrand = (tan(x)**2 + 1)/tan(x)
Omskrevet = sin(x)/cos(x) + cos(x)/sin(x)
Trigonometrisk kontroll = -tan(x) - 1/tan(x) + 2/sin(2*x)
Foreslått stamfunksjon = log(tan(x))
Derivert tilbake = (tan(x)**2 + 1)/tan(x)
Kontroll = 0
Merk: absoluttverdi brukes i den reelle stamfunksjonen.

from sympy import Matrix, Rational
A = Matrix([0,0,0])
B = Matrix([5,0,0])
C = Matrix([4,2,0])
T = Matrix([0,0,5])
AB = B-A
AC = C-A
cross = AB.cross(AC)
base_area = cross.norm()/2
height = 5
volume = Rational(1,3)*base_area*height
print("AB =", tuple(AB))
print("AC =", tuple(AC))
print("AB x AC =", tuple(cross))
print("Grunnflateareal =", base_area)
print("Høyde =", height)
print("Volum =", volume)
assert base_area == 5
assert volume == Rational(25,3)

Kjørt utskriftAB = (5, 0, 0)
AC = (4, 2, 0)
AB x AC = (0, 0, 10)
Grunnflateareal = 5
Høyde = 5
Volum = 25/3

from sympy import Matrix, Rational, sqrt, simplify
B = Matrix([5,0,0])
C = Matrix([4,2,0])
T = Matrix([0,0,5])
BC = C-B
BT = T-B
cross = BC.cross(BT)
norm = simplify(cross.norm())
area = norm/2
print("BC =", tuple(BC))
print("BT =", tuple(BT))
print("BC x BT =", tuple(cross))
print("Lengde av kryssprodukt =", norm)
print("Areal av trekant BCT =", area)
print("Kontroll mot 15/2 =", simplify(area - Rational(15,2)))
assert area == Rational(15,2)

Kjørt utskriftBC = (-1, 2, 0)
BT = (-5, 0, 5)
BC x BT = (10, 5, 10)
Lengde av kryssprodukt = 15
Areal av trekant BCT = 15/2
Kontroll mot 15/2 = 0

from sympy import Matrix, sqrt, Rational, simplify
A = Matrix([0,0,0])
B = Matrix([5,0,0])
C = Matrix([4,2,0])
T = Matrix([0,0,5])
normal = (C-B).cross(T-B)
primitive_normal = normal/5
constant = primitive_normal.dot(B)
distance = abs(primitive_normal.dot(A)-constant)/primitive_normal.norm()
print("Normalvektor fra kryssprodukt =", tuple(normal))
print("Forenklet normalvektor =", tuple(primitive_normal))
print("Planlikning: 2*x + y + 2*z =", constant)
print("Avstand fra A til planet =", distance)
print("Kontroll mot 10/3 =", simplify(distance - Rational(10,3)))
assert distance == Rational(10,3)

Kjørt utskriftNormalvektor fra kryssprodukt = (10, 5, 10)
Forenklet normalvektor = (2, 1, 2)
Planlikning: 2*x + y + 2*z = 10
Avstand fra A til planet = 10/3
Kontroll mot 10/3 = 0

a = 3
d = 4
N = 10
S = 0
print("Startverdier: a =", a, ", d =", d, ", N =", N, ", S =", S)
for i in range(N):
    print(f"runde {i+1:2d}: legger til a = {a:2d}")
    S = S + a
    a = a + d
print("Summen S =", S)
print("Neste verdi av a =", a)
expected = N*(2*3 + (N-1)*d)//2
print("Kontroll med sumformelen =", expected)
assert S == expected

Kjørt utskriftStartverdier: a = 3 , d = 4 , N = 10 , S = 0
runde  1: legger til a =  3
runde  2: legger til a =  7
runde  3: legger til a = 11
runde  4: legger til a = 15
runde  5: legger til a = 19
runde  6: legger til a = 23
runde  7: legger til a = 27
runde  8: legger til a = 31
runde  9: legger til a = 35
runde 10: legger til a = 39
Summen S = 210
Neste verdi av a = 43
Kontroll med sumformelen = 210

a = 3
d = 4
N = 100
S = 0
for i in range(N):
    S = S + a
    a = a + d
print("N =", N)
print("Første ledd = 3")
print("Siste ledd som ble summert =", a-d)
print("Verdien av a etter løkken =", a)
print("Programmet skriver S =", S)
formula = N*(2*3 + (N-1)*d)//2
print("Sumformelen gir =", formula)
assert S == 20100
assert S == formula

Kjørt utskriftN = 100
Første ledd = 3
Siste ledd som ble summert = 399
Verdien av a etter løkken = 403
Programmet skriver S = 20100
Sumformelen gir = 20100

from sympy import symbols, sin, tan, pi, N
v = symbols('v', positive=True)
for value in [0.1, 0.3, 0.5, 0.8, 1.2]:
    left = sin(value)/2
    middle = value/2
    right = tan(value)/2
    print(f"v = {value:3.1f}: 0.5*sin(v) = {left:.12f}, 0.5*v = {middle:.12f}, 0.5*tan(v) = {right:.12f}")
    assert left < middle < right
print("Kontrollpunktene ligger i intervallet (0, pi/2) =", (0, float(N(pi/2, 15))))

Kjørt utskriftv = 0.1: 0.5*sin(v) = 0.049916708323, 0.5*v = 0.050000000000, 0.5*tan(v) = 0.050167336043
v = 0.3: 0.5*sin(v) = 0.147760103331, 0.5*v = 0.150000000000, 0.5*tan(v) = 0.154668124805
v = 0.5: 0.5*sin(v) = 0.239712769302, 0.5*v = 0.250000000000, 0.5*tan(v) = 0.273151244922
v = 0.8: 0.5*sin(v) = 0.358678045450, 0.5*v = 0.400000000000, 0.5*tan(v) = 0.514819278525
v = 1.2: 0.5*sin(v) = 0.466019542984, 0.5*v = 0.600000000000, 0.5*tan(v) = 1.286075811063
Kontrollpunktene ligger i intervallet (0, pi/2) = (0, 1.5707963267948966)

from sympy import symbols, sin, cos, tan, simplify
v = symbols('v', positive=True)
identity = simplify(tan(v)/sin(v) - 1/cos(v))
print("tan(v)/sin(v) - 1/cos(v) =", identity)
for value in [0.1, 0.5, 1.0]:
    middle = value/float(sin(value))
    upper = 1/float(cos(value))
    print(f"v = {value:.1f}: 1 < {middle:.12f} < {upper:.12f}")
    assert 1 < middle < upper
assert identity == 0

Kjørt utskrifttan(v)/sin(v) - 1/cos(v) = 0
v = 0.1: 1 < 1.001668613163 < 1.005020918400
v = 0.5: 1 < 1.042914821467 < 1.139493927325
v = 1.0: 1 < 1.188395105778 < 1.850815717681

from sympy import symbols, sin, cos, limit, S
v = symbols('v', positive=True)
ratio_limit = limit(sin(v)/v, v, 0, dir='+')
lower_limit = limit(cos(v), v, 0, dir='+')
upper_limit = limit(S.One, v, 0, dir='+')
print("lim cos(v) når v -> 0+ =", lower_limit)
print("lim sin(v)/v når v -> 0+ =", ratio_limit)
print("lim 1 når v -> 0+ =", upper_limit)
for value in [0.5, 0.1, 0.01, 0.001]:
    low = float(cos(value))
    mid = float(sin(value)/value)
    print(f"v={value:g}: cos(v)={low:.15f} < sin(v)/v={mid:.15f} < 1")
    assert low < mid < 1
assert lower_limit == ratio_limit == upper_limit == 1

Kjørt utskriftlim cos(v) når v -> 0+ = 1
lim sin(v)/v når v -> 0+ = 1
lim 1 når v -> 0+ = 1
v=0.5: cos(v)=0.877582561890373 < sin(v)/v=0.958851077208406 < 1
v=0.1: cos(v)=0.995004165278026 < sin(v)/v=0.998334166468282 < 1
v=0.01: cos(v)=0.999950000416665 < sin(v)/v=0.999983333416666 < 1
v=0.001: cos(v)=0.999999500000042 < sin(v)/v=0.999999833333342 < 1

import numpy as np
from scipy.optimize import curve_fit

x_data = np.array([0, 2, 4, 6, 8, 10], dtype=float)
y_data = np.array([2, 70, 246, 456, 582, 655], dtype=float)

def logistic(x, L, A, k):
    return L/(1 + A*np.exp(-k*x))

parameters, covariance = curve_fit(
    logistic, x_data, y_data,
    p0=(700, 30, 0.7), bounds=(0, np.inf), maxfev=100000
)
L, A, k = parameters
predicted = logistic(x_data, L, A, k)
ss_res = np.sum((y_data-predicted)**2)
ss_tot = np.sum((y_data-y_data.mean())**2)
r_squared = 1-ss_res/ss_tot
print(f"L = {L:.9f}")
print(f"A = {A:.9f}")
print(f"k = {k:.9f}")
print(f"R^2 = {r_squared:.12f}")
for x_value, observed, model_value in zip(x_data, y_data, predicted):
    print(f"x={x_value:>4.1f}: observert={observed:>6.1f}, modell={model_value:>10.4f}")
assert r_squared > 0.997

Kjørt utskriftL = 660.363710742
A = 30.720705867
k = 0.706557278
R^2 = 0.997574316686
x= 0.0: observert=   2.0, modell=   20.8181
x= 2.0: observert=  70.0, modell=   77.9013
x= 4.0: observert= 246.0, modell=  234.1910
x= 6.0: observert= 456.0, modell=  457.6636
x= 8.0: observert= 582.0, modell=  596.1063
x=10.0: observert= 655.0, modell=  643.4816

import numpy as np
from scipy.integrate import quad

L = 660.3634667
A = 30.72074684
k = 0.70655791

def F(x):
    return L/(1 + A*np.exp(-k*x))

I, I_error = quad(F, -0.5, 10.5)
G_integral, G_error = quad(F, 2.5, 7.5)
G = G_integral/5
S = sum(F(i) for i in range(11))
D = (F(5.001)-F(5))/0.001
print(f"I = {I:.12f}")
print(f"Estimert integrasjonsfeil for I = {I_error:.3e}")
print(f"G = {G:.12f}")
print(f"S = {S:.12f}")
print(f"F(5) = {F(5):.12f}")
print(f"F(5.001) = {F(5.001):.12f}")
print(f"D = {D:.12f}")
assert abs(I-3728.736936638496) < 1e-6
assert abs(G-344.4484764815358) < 1e-6
assert abs(S-3728.815494779811) < 1e-6
assert abs(D-116.30549114943278) < 1e-6

Kjørt utskriftI = 3728.736936638496
Estimert integrasjonsfeil for I = 4.835e-11
G = 344.448476481536
S = 3728.815494779811
F(5) = 347.969763971638
F(5.001) = 348.086069462788
D = 116.305491149433

import math
L = 660.3634667
A = 30.72074684
k = 0.70655791

def F(x):
    return L/(1 + A*math.exp(-k*x))

def F_prime(x):
    exponential = math.exp(-k*x)
    return L*A*k*exponential/(1 + A*exponential)**2

D = (F(5.001)-F(5))/0.001
analytic = F_prime(5)
print("x=5 svarer til år", 2008+5)
print(f"F(5) = {F(5):.6f} millioner kroner per år")
print(f"Differansekvotient D = {D:.6f}")
print(f"Analytisk F'(5) = {analytic:.6f}")
print(f"Forskjell = {D-analytic:.6f}")
print("I og S tolkes som omtrent samlet beløp i millioner kroner.")
print("G tolkes som gjennomsnittlig årlig beløp.")
assert abs(D-analytic) < 0.02

Kjørt utskriftx=5 svarer til år 2013
F(5) = 347.969764 millioner kroner per år
Differansekvotient D = 116.305491
Analytisk F'(5) = 116.307710
Forskjell = -0.002218
I og S tolkes som omtrent samlet beløp i millioner kroner.
G tolkes som gjennomsnittlig årlig beløp.

from sympy import Matrix, symbols, simplify
A = Matrix([1,0,3])
B = Matrix([0,1,2])
C = Matrix([2,3,2])
P = Matrix([2,-5,5])
AB = B-A
AC = C-A
normal = AB.cross(AC)
primitive = normal/2
constant_beta = -primitive.dot(P)
print("AB =", tuple(AB))
print("AC =", tuple(AC))
print("AB x AC =", tuple(normal))
print("Forenklet normalvektor =", tuple(primitive))
print("Beta: x - y - 2*z + d = 0")
print("d =", constant_beta)
print("Kontroll i P =", primitive.dot(P)+constant_beta)
assert tuple(primitive) == (1,-1,-2)
assert constant_beta == 3
assert primitive.dot(P)+constant_beta == 0

Kjørt utskriftAB = (-1, 1, -1)
AC = (1, 3, -1)
AB x AC = (2, -2, -4)
Forenklet normalvektor = (1, -1, -2)
Beta: x - y - 2*z + d = 0
d = 3
Kontroll i P = 0

from sympy import Matrix, symbols, Eq, solve, Rational, simplify
t = symbols('t', real=True)
A = Matrix([1,0,3])
normal = Matrix([1,-1,-2])
Q_t = A + t*normal
beta_expression = Q_t[0]-Q_t[1]-2*Q_t[2]+3
parameter = solve(Eq(beta_expression,0), t)[0]
Q = Q_t.subs(t, parameter)
center = (A+Q)/2
print("Normalen gjennom A: A + t*n =", tuple(Q_t))
print("Beta-uttrykk langs normalen =", beta_expression)
print("t =", parameter)
print("Q =", tuple(Q))
print("Kontroll Q i beta =", simplify(Q[0]-Q[1]-2*Q[2]+3))
print("Kulens sentrum =", tuple(center))
print("AQ =", tuple(Q-A))
assert parameter == Rational(1,3)
assert tuple(Q) == (Rational(4,3),Rational(-1,3),Rational(7,3))

Kjørt utskriftNormalen gjennom A: A + t*n = (t + 1, -t, 3 - 2*t)
Beta-uttrykk langs normalen = 6*t - 2
t = 1/3
Q = (4/3, -1/3, 7/3)
Kontroll Q i beta = 0
Kulens sentrum = (7/6, -1/6, 8/3)
AQ = (1/3, -1/3, -2/3)

from sympy import symbols, exp, sin, cos, Matrix, diff, sqrt, N, simplify, Rational
t = symbols('t', real=True)
r = Matrix([1 + exp(t/20), 1 - sin(t), Rational(1,10)*exp(-2*t+2) + cos(t)])
v = r.diff(t)
v1 = simplify(v.subs(t, 1))
speed1 = sqrt(simplify(v1.dot(v1)))
print("r(t) =", list(r))
print("v(t) = r'(t) =", list(v))
print("v(1) =", list(v1))
print("|v(1)| eksakt =", speed1)
print("|v(1)| desimal =", N(speed1, 15), "cm/s")
assert abs(float(N(speed1, 20)) - 1.174457883969599) < 1e-12

Kjørt utskriftr(t) = [exp(t/20) + 1, 1 - sin(t), exp(2 - 2*t)/10 + cos(t)]
v(t) = r'(t) = [exp(t/20)/20, -cos(t), -exp(2 - 2*t)/5 - sin(t)]
v(1) = [exp(1/20)/20, -cos(1), -sin(1) - 1/5]
|v(1)| eksakt = sqrt(exp(1/10)/400 + 2*sin(1)/5 + 26/25)
|v(1)| desimal = 1.17445788396960 cm/s

import numpy as np
from scipy.optimize import minimize_scalar
from math import exp, sin, cos, sqrt

def speed(t):
    return sqrt((exp(t/20)/20)**2 + cos(t)**2 + (0.2*exp(-2*t+2) + sin(t))**2)

result = minimize_scalar(speed, bounds=(0, 5), method="bounded", options={"xatol": 1e-14})
t_min = result.x
s_min = result.fun
print("Optimalisering vellykket =", result.success)
print("t_min =", format(t_min, ".15f"), "s")
print("s(t_min) =", format(s_min, ".15f"), "cm/s")
print("s(0) =", format(speed(0), ".15f"), "cm/s")
print("s(5) =", format(speed(5), ".15f"), "cm/s")
# Tett rutenett som uavhengig kontroll
grid = np.linspace(0, 5, 200001)
values = np.array([speed(float(x)) for x in grid])
index = int(np.argmin(values))
print("Rutenettminimum ved t =", format(grid[index], ".6f"), "med fart", format(values[index], ".12f"))
assert result.success
assert abs(t_min - 3.54201023) < 2e-6
assert s_min < speed(0) and s_min < speed(5)

Kjørt utskriftOptimalisering vellykket = True
t_min = 3.542010118761751 s
s(t_min) = 1.001298264729785 cm/s
s(0) = 1.785056302004441 cm/s
s(5) = 1.001994578016918 cm/s
Rutenettminimum ved t = 3.542000 med fart 1.001298264730

from scipy.optimize import brentq
from math import exp, sin, cos

def vx(t):
    return exp(t/20)/20

def vy(t):
    return -cos(t)

def vz(t):
    return -0.2*exp(-2*t+2) - sin(t)

root_xy = brentq(vz, 3, 4)
print("Rot for z-komponenten i [3,4] =", format(root_xy, ".15f"), "s")
print("v_x ved roten =", format(vx(root_xy), ".15f"))
print("v_y ved roten =", format(vy(root_xy), ".15f"))
print("v_z ved roten =", format(vz(root_xy), ".15e"))
# x-komponenten er positiv på hele intervallet; minimum opptrer ved t=0.
print("min v_x på [0,5] = v_x(0) =", vx(0))
print("max v_x på [0,5] = v_x(5) =", vx(5))
print("Parallell med xy-planet = ja")
print("Parallell med yz-planet = nei")
assert abs(vz(root_xy)) < 1e-12
assert vx(0) > 0 and vx(5) > 0

Kjørt utskriftRot for z-komponenten i [3,4] = 3.144337277528660 s
v_x ved roten = 0.058512468559978
v_y ved roten = 0.999996233522081
v_z ved roten = 1.212138028838794e-15
min v_x på [0,5] = v_x(0) = 0.05
max v_x på [0,5] = v_x(5) = 0.06420127083438706
Parallell med xy-planet = ja
Parallell med yz-planet = nei

from decimal import Decimal, getcontext
getcontext().prec = 28
offer1 = []
offer2 = []
a = Decimal("100")
b = Decimal("100")
for week in range(1, 5):
    offer1.append(a)
    offer2.append(b)
    print(f"uke {week}: tilbud 1 = {a} kr, tilbud 2 = {b} kr")
    a = a + Decimal("10")
    b = b * Decimal("1.05")
print("Tilbud 1, fire uker =", offer1)
print("Tilbud 2, fire uker =", offer2)
assert offer1 == [Decimal("100"), Decimal("110"), Decimal("120"), Decimal("130")]
assert offer2[-1] == Decimal("115.762500")

Kjørt utskriftuke 1: tilbud 1 = 100 kr, tilbud 2 = 100 kr
uke 2: tilbud 1 = 110 kr, tilbud 2 = 105.00 kr
uke 3: tilbud 1 = 120 kr, tilbud 2 = 110.2500 kr
uke 4: tilbud 1 = 130 kr, tilbud 2 = 115.762500 kr
Tilbud 1, fire uker = [Decimal('100'), Decimal('110'), Decimal('120'), Decimal('130')]
Tilbud 2, fire uker = [Decimal('100'), Decimal('105.00'), Decimal('110.2500'), Decimal('115.762500')]

def a(n):
    return 100 + 10*(n-1)

def b(n):
    return 100*1.05**(n-1)

first_week = None
for n in range(1, 101):
    if b(n) > a(n):
        first_week = n
        break
print("Første uke med b_n > a_n =", first_week)
for n in [26, 27, 28, 29]:
    print(f"n={n}: a_n={a(n):.6f}, b_n={b(n):.6f}, b_n-a_n={b(n)-a(n):.6f}")
assert first_week == 28
assert b(27) <= a(27)
assert b(28) > a(28)

Kjørt utskriftFørste uke med b_n > a_n = 28
n=26: a_n=350.000000, b_n=338.635494, b_n-a_n=-11.364506
n=27: a_n=360.000000, b_n=355.567269, b_n-a_n=-4.432731
n=28: a_n=370.000000, b_n=373.345632, b_n-a_n=3.345632
n=29: a_n=380.000000, b_n=392.012914, b_n-a_n=12.012914

def sum_offer1(n):
    return n/2*(2*100 + (n-1)*10)

def sum_offer2(n):
    return 100*(1.05**n - 1)/0.05

first_week = None
for n in range(2, 201):
    if sum_offer2(n) > sum_offer1(n):
        first_week = n
        break
print("Første n med samlet tilbud 2 > samlet tilbud 1 =", first_week)
for n in [37, 38, 39, 40]:
    A = sum_offer1(n)
    B = sum_offer2(n)
    print(f"n={n}: A_n={A:.6f}, B_n={B:.6f}, B_n-A_n={B-A:.6f}")
assert first_week == 39
assert sum_offer2(38) <= sum_offer1(38)
assert sum_offer2(39) > sum_offer1(39)

Kjørt utskriftFørste n med samlet tilbud 2 > samlet tilbud 1 = 39
n=37: A_n=10360.000000, B_n=10162.813886, B_n-A_n=-197.186114
n=38: A_n=10830.000000, B_n=10770.954580, B_n-A_n=-59.045420
n=39: A_n=11310.000000, B_n=11409.502309, B_n-A_n=99.502309
n=40: A_n=11800.000000, B_n=12079.977424, B_n-A_n=279.977424

from math import pi
from scipy.integrate import quad
import mpmath as mp

def f(x):
    return (2-mp.cos(x))/mp.sin(x)

def shell_integrand_float(x):
    from math import sin, cos
    return 2*pi*x*(2-cos(x))/sin(x)

a = pi/4
b = 3*pi/4
volume_scipy, error = quad(shell_integrand_float, a, b, epsabs=1e-12, epsrel=1e-12)
mp.mp.dps = 50
volume_mpmath = 2*mp.pi*mp.quad(lambda x: x*f(x), [mp.pi/4, 3*mp.pi/4])
inner_integral = volume_mpmath/(2*mp.pi)
print("Nedre grense a =", format(a, ".15f"))
print("Øvre grense b =", format(b, ".15f"))
print("Integral uten faktoren 2*pi =", mp.nstr(inner_integral, 25))
print("Volum fra scipy.integrate.quad =", format(volume_scipy, ".15f"))
print("Estimert integrasjonsfeil =", format(error, ".3e"))
print("Volum fra mpmath (50 siffer presisjon) =", mp.nstr(volume_mpmath, 35))
print("Forskjell mellom metodene =", mp.nstr(abs(volume_mpmath-volume_scipy), 12))
assert abs(volume_scipy - 37.12987186509575) < 1e-11
assert abs(float(volume_mpmath) - volume_scipy) < 1e-11

Kjørt utskriftNedre grense a = 0.785398163397448
Øvre grense b = 2.356194490192345
Integral uten faktoren 2*pi = 5.909402643698679917773135
Volum fra scipy.integrate.quad = 37.129871865095751
Estimert integrasjonsfeil = 4.592e-12
Volum fra mpmath (50 siffer presisjon) = 37.129871865095750596162950644693611
Forskjell mellom metodene = 5.08327822642e-16

from sympy import symbols, sin, cos, pi, sqrt, diff, simplify, N, Rational
x = symbols('x', real=True)
f = (2-cos(x))/sin(x)
fp = simplify(diff(f, x))
cone_height = Rational(3)*45/(pi*4**2)
left = simplify(f.subs(x, pi/4))
right = simplify(f.subs(x, 3*pi/4))
critical = pi/3
critical_value = simplify(f.subs(x, critical))
body_height = right
print("f'(x) =", fp)
print("f(pi/4) =", left, "=", N(left, 15))
print("f(pi/3) =", critical_value, "=", N(critical_value, 15))
print("f(3*pi/4) =", right, "=", N(right, 15))
print("Kjeglehøyde =", cone_height, "=", N(cone_height, 15))
print("Legemets maksimale høyde =", body_height, "=", N(body_height, 15))
print("Høydeforskjell legeme - kjegle =", N(body_height-cone_height, 15))
print("Får plass =", bool(body_height <= cone_height))
assert simplify(fp - (1-2*cos(x))/sin(x)**2) == 0
assert body_height > cone_height

Kjørt utskriftf'(x) = (1 - 2*cos(x))/sin(x)**2
f(pi/4) = -1 + 2*sqrt(2) = 1.82842712474619
f(pi/3) = sqrt(3) = 1.73205080756888
f(3*pi/4) = 1 + 2*sqrt(2) = 3.82842712474619
Kjeglehøyde = 135/(16*pi) = 2.68573966467573
Legemets maksimale høyde = 1 + 2*sqrt(2) = 3.82842712474619
Høydeforskjell legeme - kjegle = 1.14268746007046
Får plass = False

from sympy import symbols, sqrt, simplify
h, k = symbols('h k', real=True)
distance = sqrt(h**2 + k**2)
print("Horisontal katet = h")
print("Vertikal katet = k_i")
print("Avstandsformelen gir S_i =", distance)
print("S_i^2 - (h^2+k_i^2) =", simplify(distance**2 - (h**2+k**2)))
assert simplify(distance**2 - (h**2+k**2)) == 0

Kjørt utskriftHorisontal katet = h
Vertikal katet = k_i
Avstandsformelen gir S_i = sqrt(h**2 + k**2)
S_i^2 - (h^2+k_i^2) = 0

import numpy as np
from math import pi

def polyline_length(N):
    x = np.linspace(-1.0, 1.0, N + 1)
    y = np.sqrt(np.maximum(0.0, 1.0 - x*x))
    h = 2.0/N
    k = np.diff(y)
    segments = np.sqrt(h*h + k*k)
    return float(np.sum(segments)), h, segments

for N in [100, 1000, 10000, 100000]:
    length, h, segments = polyline_length(N)
    print(f"N={N:6d}, h={h:.10f}, polylengde={length:.12f}, feil mot pi={length-pi:.12e}")
length, h, segments = polyline_length(100000)
print("Antall linjestykker =", len(segments))
print("Første linjestykke =", format(segments[0], ".15f"))
print("Siste linjestykke =", format(segments[-1], ".15f"))
print("Endelig tilnærming =", format(length, ".15f"))
print("Eksakt halvsirkellengde pi =", format(pi, ".15f"))
assert abs(length - pi) < 1e-6

Kjørt utskriftN=   100, h=0.0200000000, polylengde=3.140760589842, feil mot pi=-8.320637473282e-04
N=  1000, h=0.0020000000, polylengde=3.141566356216, feil mot pi=-2.629737331361e-05
N= 10000, h=0.0002000000, polylengde=3.141591822040, feil mot pi=-8.315499977485e-07
N=100000, h=0.0000200000, polylengde=3.141592627294, feil mot pi=-2.629577444679e-08
Antall linjestykker = 100000
Første linjestykke = 0.006324555320337
Siste linjestykke = 0.006324555320320
Endelig tilnærming = 3.141592627294019
Eksakt halvsirkellengde pi = 3.141592653589793