import sympy as sp
x = sp.symbols("x", positive=True)
f = sp.exp(x) + sp.log(x)
f_prime = sp.diff(f, x)
print("f(x) =", f)
print("f'(x) =", f_prime)
print("Domain condition: x > 0")
print("Check at x=1:", sp.simplify(f_prime.subs(x, 1)))

Utskrift fra Python:
f(x) = exp(x) + log(x)
f'(x) = exp(x) + 1/x
Domain condition: x > 0
Check at x=1: 1 + E

import sympy as sp
x = sp.symbols("x")
expression = (x**3 - 8)/(x**2 - 4)
factored_numerator = sp.factor(x**3 - 8)
factored_denominator = sp.factor(x**2 - 4)
simplified = sp.cancel(expression)
limit_value = sp.limit(expression, x, 2)
print("Numerator factored =", factored_numerator)
print("Denominator factored =", factored_denominator)
print("Simplified expression =", simplified)
print("Limit as x -> 2 =", limit_value)

Utskrift fra Python:
Numerator factored = (x - 2)*(x**2 + 2*x + 4)
Denominator factored = (x - 2)*(x + 2)
Simplified expression = (x**2 + 2*x + 4)/(x + 2)
Limit as x -> 2 = 3

import sympy as sp
A = sp.Matrix([1, 3])
B = sp.Matrix([4, 0])
C = sp.Matrix([9, 4])
BC = C - B
BA = A - B
dot_product = BC.dot(BA)
cos_value = sp.simplify(dot_product/(sp.sqrt(BC.dot(BC))*sp.sqrt(BA.dot(BA))))
angle = sp.acos(cos_value)*180/sp.pi
print("BC =", tuple(BC))
print("BA =", tuple(BA))
print("BC dot BA =", dot_product)
print("cos(angle) =", cos_value)
print("angle in degrees =", sp.N(angle, 12))
print("Angle greater than 90 degrees:", bool(sp.N(angle) > 90))

Utskrift fra Python:
BC = (5, 4)
BA = (-3, 3)
BC dot BA = -3
cos(angle) = -sqrt(82)/82
angle in degrees = 96.3401917459
Angle greater than 90 degrees: True

import sympy as sp
t = sp.symbols("t", real=True)
A = sp.Matrix([1, 3])
B = sp.Matrix([4, 0])
C = sp.Matrix([9, 4])
P = B + t*(C-B)
AB = B-A
AP = P-A
condition = sp.expand(AB.dot(AP))
solution = sp.solve(sp.Eq(condition, 0), t)[0]
P_value = P.subs(t, solution)
print("P(t) =", tuple(P))
print("AB =", tuple(AB))
print("AP(t) =", tuple(AP))
print("Dot product equation =", condition)
print("t =", solution)
print("P =", tuple(P_value))
print("Orthogonality check =", AB.dot(P_value-A))

Utskrift fra Python:
P(t) = (5*t + 4, 4*t)
AB = (3, -3)
AP(t) = (5*t + 3, 4*t - 3)
Dot product equation = 3*t + 18
t = -6
P = (-26, -24)
Orthogonality check = 0

def A(x):
    return x*(x**2-9)**4

t = 0.0
d = 0.01
iterations = 0
while A(t) < A(t+d):
    t = t + d
    iterations += 1
print("Iterations =", iterations)
print("Final t =", round(t, 12))
print("A(t) =", A(t))
print("A(t+d) =", A(t+d))
print("Next value is larger:", A(t) < A(t+d))
print("The search stops near t = 1")

Utskrift fra Python:
Iterations = 100
Final t = 1.0
A(t) = 4095.999999999999
A(t+d) = 4095.5399809454325
Next value is larger: False
The search stops near t = 1

import sympy as sp
t = sp.symbols("t", real=True)
A = t*(t**2-9)**4
A_prime = sp.factor(sp.diff(A, t))
critical = sp.solve(sp.Eq(A_prime, 0), t)
candidates = [sp.Integer(0), sp.Integer(1), sp.Integer(3)]
values = [(value, sp.simplify(A.subs(t, value))) for value in candidates]
print("A(t) =", A)
print("A'(t) =", A_prime)
print("Critical points =", critical)
print("Candidates and areas =", values)
maximum = max(values, key=lambda pair: pair[1])
print("Maximum candidate =", maximum)

Utskrift fra Python:
A(t) = t*(t**2 - 9)**4
A'(t) = 9*(t - 3)**3*(t - 1)*(t + 1)*(t + 3)**3
Critical points = [-3, -1, 1, 3]
Candidates and areas = [(0, 0), (1, 4096), (3, 0)]
Maximum candidate = (1, 4096)

import math
start_wage = 272.55
end_wage = 340.10
years = 14
growth_factor = (end_wage/start_wage)**(1/years)
growth_rate = growth_factor - 1
print("Start wage =", start_wage)
print("End wage =", end_wage)
print("Number of years =", years)
print("Annual growth factor =", round(growth_factor, 12))
print("Annual growth rate =", round(growth_rate, 12))
print("Annual percentage =", round(100*growth_rate, 6))
print("Check =", round(start_wage*growth_factor**years, 10))

Utskrift fra Python:
Start wage = 272.55
End wage = 340.1
Number of years = 14
Annual growth factor = 1.015941271115
Annual growth rate = 0.015941271115
Annual percentage = 1.594127
Check = 340.1

import numpy as np
x = np.array([0, 2, 5, 7, 11, 14], dtype=float)
y = np.array([272.55, 285.50, 307.30, 314.00, 327.60, 340.10], dtype=float)
slope, intercept = np.polyfit(x, np.log(y), 1)
A = np.exp(intercept)
b = np.exp(slope)
predicted = A*b**x
rmse = np.sqrt(np.mean((predicted-y)**2))
print("A =", round(A, 12))
print("b =", round(b, 12))
print("Model: g(x) = A*b**x")
print("g(0) =", round(A, 6))
print("g(14) =", round(A*b**14, 6))
print("RMSE =", round(rmse, 6))

Utskrift fra Python:
A = 277.83265814877
b = 1.015456718024
Model: g(x) = A*b**x
g(0) = 277.832658
g(14) = 344.384133
RMSE = 4.553125

A = 277.83265814877024
b = 1.0154567180236385
hours = 1700
amalie_wages = [272.55*1.023**k for k in range(15)]
per_wages = [A*b**k for k in range(15)]
amalie_total = hours*sum(amalie_wages)
per_total = hours*sum(per_wages)
print("Number of years =", len(amalie_wages))
print("Amalie first hourly wage =", round(amalie_wages[0], 6))
print("Amalie last hourly wage =", round(amalie_wages[-1], 6))
print("Amalie total salary =", round(amalie_total, 2))
print("Per first model wage =", round(per_wages[0], 6))
print("Per last model wage =", round(per_wages[-1], 6))
print("Per total salary =", round(per_total, 2))
print("Difference =", round(amalie_total-per_total, 2))

Utskrift fra Python:
Number of years = 15
Amalie first hourly wage = 272.55
Amalie last hourly wage = 374.718434
Amalie total salary = 8188601.24
Per first model wage = 277.832658
Per last model wage = 344.384133
Per total salary = 7905086.29
Difference = 283514.95

start_per = 340.10
amalie_2025 = 272.55*1.023**17
years = 3
required_factor = (amalie_2025/start_per)**(1/years)
required_rate = required_factor-1
print("Amalie hourly wage in 2025 =", round(amalie_2025, 12))
print("Per hourly wage in 2022 =", start_per)
print("Required annual factor =", round(required_factor, 12))
print("Required annual rate =", round(required_rate, 12))
print("Required percentage =", round(100*required_rate, 6))
print("Check in 2025 =", round(start_per*required_factor**3, 12))

Utskrift fra Python:
Amalie hourly wage in 2025 = 401.173243220885
Per hourly wage in 2022 = 340.1
Required annual factor = 1.056594735586
Required annual rate = 0.056594735586
Required percentage = 5.659474
Check in 2025 = 401.173243220885

import sympy as sp
t = sp.symbols("t", real=True)
A = sp.Matrix([3,2])
u = sp.Matrix([4,3])
v = sp.Matrix([2*t,5*t])
B = A+u
D = A+v
C = A+u+v
print("A =", tuple(A))
print("u =", tuple(u))
print("v =", tuple(v))
print("B =", tuple(B))
print("D =", tuple(D))
print("C =", tuple(C))
print("C-B =", tuple(sp.simplify(C-B)))
print("C-D =", tuple(sp.simplify(C-D)))

Utskrift fra Python:
A = (3, 2)
u = (4, 3)
v = (2*t, 5*t)
B = (7, 5)
D = (2*t + 3, 5*t + 2)
C = (2*t + 7, 5*t + 5)
C-B = (2*t, 5*t)
C-D = (4, 3)

import sympy as sp
t = sp.symbols("t", real=True)
A = sp.Matrix([3,2])
C = sp.Matrix([7+2*t,5+5*t])
midpoint = sp.simplify((A+C)/2)
solutions = sp.solve([sp.Eq(midpoint[0],8),sp.Eq(midpoint[1],11)],[t], dict=True)
print("Midpoint =", tuple(midpoint))
print("Solutions =", solutions)
value = sp.Integer(3)
print("Midpoint at t=3 =", tuple(midpoint.subs(t,value)))
B = sp.Matrix([7,5]); D = sp.Matrix([3+2*t,2+5*t])
print("Midpoint of BD at t=3 =", tuple(((B+D)/2).subs(t,value)))

Utskrift fra Python:
Midpoint = (t + 5, 5*t/2 + 7/2)
Solutions = [{t: 3}]
Midpoint at t=3 = (8, 11)
Midpoint of BD at t=3 = (8, 11)

import sympy as sp
x = sp.E
left = sp.log(x)**4
right = 4*sp.log(x)
print("x = e")
print("(ln x)^4 =", left)
print("4 ln x =", right)
print("Difference =", sp.simplify(left-right))
print("Statement true for all x>0:", left == right)

Utskrift fra Python:
x = e
(ln x)^4 = 1
4 ln x = 4
Difference = -3
Statement true for all x>0: False

import sympy as sp
x = sp.symbols("x", real=True)
examples = [x**4+x, -x**4+3*x, 2*x**4-5*x**2+1]
for f in examples:
    derivative = sp.diff(f,x)
    roots = sp.nroots(derivative)
    real_roots = [root for root in roots if abs(complex(root).imag) < 1e-10]
    print("f(x) =", f)
    print("f'(x) =", derivative)
    print("Real stationary points =", real_roots)
print("A real cubic derivative always has at least one real root")
print("Its leading term changes sign between minus and plus infinity")

Utskrift fra Python:
f(x) = x**4 + x
f'(x) = 4*x**3 + 1
Real stationary points = [-0.629960524947437]
f(x) = -x**4 + 3*x
f'(x) = 3 - 4*x**3
Real stationary points = [0.908560296416070]
f(x) = 2*x**4 - 5*x**2 + 1
f'(x) = 8*x**3 - 10*x
Real stationary points = [-1.11803398874989, 0, 1.11803398874989]
A real cubic derivative always has at least one real root
Its leading term changes sign between minus and plus infinity

domain = [0, 1, 2]
values = [0, 2, 1]
injective = len(set(values)) == len(values)
strictly_increasing = all(values[i] < values[i+1] for i in range(len(values)-1))
strictly_decreasing = all(values[i] > values[i+1] for i in range(len(values)-1))
inverse = {value: argument for argument, value in zip(domain, values)}
print("Domain =", domain)
print("Function values =", values)
print("Injective =", injective)
print("Strictly increasing =", strictly_increasing)
print("Strictly decreasing =", strictly_decreasing)
print("Inverse mapping =", inverse)

Utskrift fra Python:
Domain = [0, 1, 2]
Function values = [0, 2, 1]
Injective = True
Strictly increasing = False
Strictly decreasing = False
Inverse mapping = {0: 0, 2: 1, 1: 2}

functions = {
    "f": {"injective": False, "reason": "symmetric branches"},
    "g": {"injective": True, "reason": "strictly increasing"},
    "h": {"injective": False, "reason": "overlapping y-values"},
    "k": {"injective": True, "reason": "strictly decreasing"},
}
for name, information in functions.items():
    print(name, "has inverse:", information["injective"])
    print("reason:", information["reason"])
print("Functions with inverses =", [name for name, info in functions.items() if info["injective"]])

Utskrift fra Python:
f has inverse: False
reason: symmetric branches
g has inverse: True
reason: strictly increasing
h has inverse: False
reason: overlapping y-values
k has inverse: True
reason: strictly decreasing
Functions with inverses = ['g', 'k']

interval_g = "[1, infinity)"
interval_k = "(-infinity, 3]"
print("Range of g =", interval_g)
print("Domain of inverse g =", interval_g)
print("Range of k =", interval_k)
print("Domain of inverse k =", interval_k)
print("f has no inverse on shown domain")
print("h has no inverse on shown domain")

Utskrift fra Python:
Range of g = [1, infinity)
Domain of inverse g = [1, infinity)
Range of k = (-infinity, 3]
Domain of inverse k = (-infinity, 3]
f has no inverse on shown domain
h has no inverse on shown domain

import sympy as sp
I = sp.symbols("I", positive=True)
solution = sp.solve(sp.Eq(130,120+10*sp.log(I,10)),I)[0]
print("Equation: 130 = 120 + 10*lg(I)")
print("lg(I) =", sp.Rational(130-120,10))
print("I =", solution)
print("Unit: W/m^2")
print("Check L =", sp.simplify(120+10*sp.log(solution,10)))

Utskrift fra Python:
Equation: 130 = 120 + 10*lg(I)
lg(I) = 1
I = 10
Unit: W/m^2
Check L = 130

import math
delta_L = 2
intensity_factor = 10**(delta_L/10)
percentage_increase = 100*(intensity_factor-1)
print("Increase in sound level =", delta_L, "dB")
print("Intensity factor =", round(intensity_factor, 12))
print("Percentage increase =", round(percentage_increase, 8))
print("Check delta L =", round(10*math.log10(intensity_factor), 12))

Utskrift fra Python:
Increase in sound level = 2 dB
Intensity factor = 1.584893192461
Percentage increase = 58.48931925
Check delta L = 2.0

import sympy as sp
r = sp.symbols("r", positive=True)
threshold = 50*sp.sqrt(10)
L = 140-20*sp.log(r/50,10)
print("Threshold distance exact =", threshold)
print("Threshold distance decimal =", sp.N(threshold,12))
print("Sound level at threshold =", sp.simplify(L.subs(r,threshold)))
for distance in [158,159,160]:
    level = sp.N(L.subs(r,distance),10)
    print("r =", distance, "m, L =", level, "dB")
print("Condition for L < 130: r > 50*sqrt(10)")

Utskrift fra Python:
Threshold distance exact = 50*sqrt(10)
Threshold distance decimal = 158.113883008
Sound level at threshold = 130
r = 158 m, L = 130.0062583 dB
r = 159 m, L = 129.9514576 dB
r = 160 m, L = 129.8970004 dB
Condition for L < 130: r > 50*sqrt(10)

import sympy as sp
A = sp.Point(4,-2)
B = sp.Point(6,6)
P = sp.Point(2,8)
line = sp.Line(A,B)
distance = sp.simplify(line.distance(P))
standard_numerator = abs(4*2-8-18)
print("Line through A and B:", line)
print("Standard equation: 4*x - y - 18 = 0")
print("Numerator =", standard_numerator)
print("Denominator =", sp.sqrt(17))
print("Exact distance =", distance)
print("Rationalized =", sp.radsimp(distance))
print("Decimal distance =", sp.N(distance,12))

Utskrift fra Python:
Line through A and B: Line2D(Point2D(4, -2), Point2D(6, 6))
Standard equation: 4*x - y - 18 = 0
Numerator = 18
Denominator = sqrt(17)
Exact distance = 18*sqrt(17)/17
Rationalized = 18*sqrt(17)/17
Decimal distance = 4.36564125065

import sympy as sp
x = sp.symbols("x", real=True)
f = x**2+2*x
numerator = sp.simplify(abs(4*x-f-18))
positive_form = (x-1)**2+17
distance = positive_form/sp.sqrt(17)
derivative = sp.diff(distance,x)
critical = sp.solve(sp.Eq(derivative,0),x)
minimum = sp.simplify(distance.subs(x,critical[0]))
print("Point on graph = (x,", f, ")")
print("Expression before absolute value =", sp.expand(4*x-f-18))
print("Positive numerator =", positive_form)
print("Distance function =", distance)
print("Derivative =", derivative)
print("Critical x =", critical)
print("Minimum distance =", minimum)
print("Tangent slope at x=1 =", sp.diff(f,x).subs(x,1))

Utskrift fra Python:
Point on graph = (x, x**2 + 2*x )
Expression before absolute value = -x**2 + 2*x - 18
Positive numerator = (x - 1)**2 + 17
Distance function = sqrt(17)*((x - 1)**2 + 17)/17
Derivative = sqrt(17)*(2*x - 2)/17
Critical x = [1]
Minimum distance = sqrt(17)
Tangent slope at x=1 = 4

import math

def approximate_average(N):
    if N <= 0:
        raise ValueError("N must be a positive integer")
    total = 0.0
    step = 1.0/N
    for i in range(N+1):
        x = i*step
        total += math.sqrt(x)
    return total/(N+1)

for N in [10, 100, 1000, 1000000]:
    approximation = approximate_average(N)
    print("N =", N)
    print("approximate average =", format(approximation, ".12f"))
    print("error from 2/3 =", format(approximation-2/3, ".12e"))
exact_average = 2/3
print("Exact average from integral =", exact_average)

Utskrift fra Python:
N = 10
approximate average = 0.645917583370
error from 2/3 = -2.074908329683e-02
N = 100
approximate average = 0.664814799112
error from 2/3 = -1.851867554639e-03
N = 1000
approximate average = 0.666493640753
error from 2/3 = -1.730259137377e-04
N = 1000000
approximate average = 0.666666499792
error from 2/3 = -1.668743561112e-07
Exact average from integral = 0.6666666666666666