import sympy as sp
x = sp.symbols("x", real=True)
f = x**4
solutions = sp.solve(sp.Eq(f, 1), x)
value_pos = f.subs(x, 1)
value_neg = f.subs(x, -1)
print("f(x) =", f)
print("Solutions of f(x)=1:", solutions)
print("f(1) =", value_pos)
print("f(-1) =", value_neg)
print("Different inputs:", 1 != -1)
print("Same outputs:", value_pos == value_neg)

Utskrift fra Python:
f(x) = x**4
Solutions of f(x)=1: [-1, 1]
f(1) = 1
f(-1) = 1
Different inputs: True
Same outputs: True

import sympy as sp
x, y = sp.symbols("x y", positive=True)
g = sp.exp(-(x-2)**2)
g_prime = sp.factor(sp.diff(g, x))
g_inverse = 2 + sp.sqrt(-sp.log(y))
composition = sp.simplify(g.subs(x, g_inverse))
print("g(x) =", g)
print("g'(x) =", g_prime)
print("g inverse(y) =", g_inverse)
print("g(g inverse(y)) =", composition)
print("Range: 0 < y <= 1")
print("Strictly decreasing for x > 2")

Utskrift fra Python:
g(x) = exp(-(x - 2)**2)
g'(x) = -2*(x - 2)*exp(-4)*exp(4*x)*exp(-x**2)
g inverse(y) = sqrt(-log(y)) + 2
g(g inverse(y)) = y
Range: 0 < y <= 1
Strictly decreasing for x > 2

import sympy as sp
h = sp.symbols("h", real=True)
numerator = sp.expand((4+h)**2 - 4**2)
quotient = sp.factor(numerator / h)
limit_value = sp.limit(quotient, h, 0)
print("Expanded numerator =", numerator)
print("Simplified quotient =", quotient)
print("Limit as h -> 0 =", limit_value)
x = sp.symbols("x")
derivative_check = sp.diff(x**2, x).subs(x, 4)
print("Derivative check =", derivative_check)

Utskrift fra Python:
Expanded numerator = h**2 + 8*h
Simplified quotient = h + 8
Limit as h -> 0 = 8
Derivative check = 8

import sympy as sp
values = [sp.real_root(11, 3), 10*sp.log(9, 10), 5*sp.log(9)]
labels = ["cube root of 11", "10*lg(9)", "5*ln(9)"]
for label, value in zip(labels, values):
    numeric = sp.N(value, 12)
    print(label, "=", numeric)
    print("less than 10:", bool(numeric < 10))
print("11 < 10^3:", 11 < 10**3)
print("ln(3) > 1:", bool(sp.N(sp.log(3)) > 1))

Utskrift fra Python:
cube root of 11 = 2.22398009057
less than 10: True
10*lg(9) = 9.54242509439
less than 10: True
5*ln(9) = 10.9861228867
less than 10: False
11 < 10^3: True
ln(3) > 1: True

import sympy as sp
A = sp.Matrix([1, 1])
B = sp.Matrix([9, 7])
P = sp.Matrix([5, 9])
PA = A - P
PB = B - P
dot_product = PA.dot(PB)
print("PA =", tuple(PA))
print("PB =", tuple(PB))
print("PA dot PB =", dot_product)
print("Right angle:", dot_product == 0)
print("Length PA =", sp.sqrt(PA.dot(PA)))
print("Length PB =", sp.sqrt(PB.dot(PB)))

Utskrift fra Python:
PA = (-4, -8)
PB = (4, -2)
PA dot PB = 0
Right angle: True
Length PA = 4*sqrt(5)
Length PB = 2*sqrt(5)

import sympy as sp
t = sp.symbols("t", real=True)
A = sp.Matrix([1, 1])
B = sp.Matrix([9, 7])
Q = sp.Matrix([5 + 4*t, 9 + 3*t])
condition = sp.expand((A-Q).dot(B-Q))
solutions = sp.solve(sp.Eq(condition, 0), t)
print("Equation =", sp.factor(condition))
print("Parameter solutions =", solutions)
for value in solutions:
    print("t =", value, "Q =", tuple(Q.subs(t, value)))
other = Q.subs(t, sp.Rational(-6,5))
print("Other point =", tuple(other))

Utskrift fra Python:
Equation = 5*t*(5*t + 6)
Parameter solutions = [-6/5, 0]
t = -6/5 Q = (1/5, 27/5)
t = 0 Q = (5, 9)
Other point = (1/5, 27/5)

def f(x):
    return (6*x - 3) / (x - 1)

h = 0.00001
def Df(x):
    return (f(x + h) - f(x)) / h

a = 1.5
iterations = 0
while Df(a) < -3:
    a = a + 0.001
    iterations += 1
b = f(a) - Df(a)*a
print("Iterations =", iterations)
print("a =", a)
print("Df(a) =", Df(a))
print("f(a) =", f(a))
print("b =", b)
print("Tangent: y = -3x +", b)

Utskrift fra Python:
Iterations = 500
a = 1.999999999999945
Df(a) = -2.9999700002392156
f(a) = 9.000000000000165
b = 14.999940000478432
Tangent: y = -3x + 14.999940000478432

import numpy as np
from scipy.optimize import curve_fit
x = np.array([0,10,20,31,40,50,62,70], dtype=float)
y = np.array([16924,31121,57606,93397,121848,142816,147716,154197], dtype=float)
def logistic(x, L, A, k):
    return L / (1 + A*np.exp(-k*x))
parameters, covariance = curve_fit(logistic, x, y, p0=[160000,10,0.08], maxfev=100000)
L, A, k = parameters
predicted = logistic(x, L, A, k)
rmse = np.sqrt(np.mean((predicted-y)**2))
print("L =", round(L, 3))
print("A =", round(A, 6))
print("k =", round(k, 8))
print("g(70) =", round(logistic(70,L,A,k), 3))
print("RMSE =", round(rmse, 3))

Utskrift fra Python:
L = 157303.076
A = 9.639559
k = 0.08672051
g(70) = 153876.404
RMSE = 1822.774

import sympy as sp
L = sp.Float(157303.063)
A = sp.Float(9.63956448)
k = sp.Float(0.0867205366)
x_inflection = sp.log(A)/k
y_inflection = L/2
calendar_year = 1950 + x_inflection
print("x at maximum growth =", sp.N(x_inflection, 12))
print("Calendar year =", sp.N(calendar_year, 12))
print("Production at inflection =", sp.N(y_inflection, 12))
print("Rounded year =", round(float(calendar_year)))

Utskrift fra Python:
x at maximum growth = 26.1284814188
Calendar year = 1976.12848142
Production at inflection = 78651.5315000
Rounded year = 1976

import numpy as np
from scipy.optimize import curve_fit
x = np.array([0,10,20,31,40,50,62,70], dtype=float)
production = np.array([16924,31121,57606,93397,121848,142816,147716,154197], dtype=float)
consumption = np.array([16924,31253,56770,88168,105941,123761,129900,133725], dtype=float)
def logistic(x, L, A, k):
    return L/(1+A*np.exp(-k*x))
p_prod, _ = curve_fit(logistic, x, production, p0=[160000,10,0.08], maxfev=100000)
p_cons, _ = curve_fit(logistic, x, consumption, p0=[140000,8,0.08], maxfev=100000)
print("Production parameters =", np.round(p_prod, 6))
print("Consumption parameters =", np.round(p_cons, 6))
print("Long-run surplus =", round(p_prod[0]-p_cons[0], 3), "GWh")
for year in [2030,2050,2070]:
    t = year-1950
    surplus = logistic(t,*p_prod)-logistic(t,*p_cons)
    print(year, "model surplus =", round(surplus, 3), "GWh")

Utskrift fra Python:
Production parameters = [1.57303076e+05 9.63955900e+00 8.67210000e-02]
Consumption parameters = [1.3638659e+05 7.4387860e+00 8.3201000e-02]
Long-run surplus = 20916.486 GWh
2030 model surplus = 20750.916 GWh
2050 model surplus = 20903.812 GWh
2070 model surplus = 20917.43 GWh

import sympy as sp
t, y, Q0 = sp.symbols("t y Q0", positive=True)
Q = Q0*(1-sp.exp(-sp.Rational(23,10)*t))
Q_inverse = -sp.log(1-y/Q0)/sp.Rational(23,10)
solutions = [Q_inverse]
composition = sp.simplify(Q.subs(t,Q_inverse))
print("Q(t) =", Q)
print("Solutions for t =", solutions)
print("Chosen inverse =", Q_inverse)
print("Q(Q inverse(y)) =", composition)
print("Inverse domain: 0 <= y < Q0")

Utskrift fra Python:
Q(t) = Q0*(1 - exp(-23*t/10))
Solutions for t = [-10*log(1 - y/Q0)/23]
Chosen inverse = -10*log(1 - y/Q0)/23
Q(Q inverse(y)) = y
Inverse domain: 0 <= y < Q0

import sympy as sp
t = sp.symbols("t", nonnegative=True)
exact = sp.log(10)/sp.Rational(23,10)
numeric = sp.N(exact, 12)
charge_fraction = 1-sp.exp(-sp.Rational(23,10)*exact)
print("Exact time =", exact)
print("Time in seconds =", numeric)
print("Charge fraction =", sp.simplify(charge_fraction))
print("Rounded time =", round(float(numeric),2), "s")

Utskrift fra Python:
Exact time = 10*log(10)/23
Time in seconds = 1.00112395348
Charge fraction = 9/10
Rounded time = 1.0 s

import sympy as sp
t = sp.symbols("t", real=True)
solution_x = sp.solve(sp.Eq(12*t,24),t)
solution_y = sp.solve(sp.Eq(5*t,10),t)
point_at_two = (12*2,5*2)
print("Solution from x =", solution_x)
print("Solution from y =", solution_y)
print("Point at t=2 =", point_at_two)
print("t is positive:", 2 > 0)
print("C lies on ray:", point_at_two == (24,10))

Utskrift fra Python:
Solution from x = [2]
Solution from y = [2]
Point at t=2 = (24, 10)
t is positive: True
C lies on ray: True

import sympy as sp
AB = sp.Matrix([9,1])
AC = sp.Matrix([24,10])
dot = AB.dot(AC)
length_AB = sp.sqrt(AB.dot(AB))
length_AC = sp.sqrt(AC.dot(AC))
cos_angle = sp.simplify(dot/(length_AB*length_AC))
angle_deg = sp.N(sp.acos(cos_angle)*180/sp.pi, 12)
print("AB =", tuple(AB))
print("AC =", tuple(AC))
print("Dot product =", dot)
print("Lengths =", length_AB, length_AC)
print("cos(angle) =", cos_angle)
print("angle =", angle_deg, "degrees")

Utskrift fra Python:
AB = (9, 1)
AC = (24, 10)
Dot product = 226
Lengths = sqrt(82) 26
cos(angle) = 113*sqrt(82)/1066
angle = 16.2796732021 degrees

import sympy as sp
t = sp.symbols("t", positive=True)
A = sp.Matrix([0,0]); B = sp.Matrix([9,1]); D = sp.Matrix([12*t,5*t])
DA = A-D; DB = B-D
squared = sp.factor((DA.dot(DB))**2-sp.Rational(1,4)*(DA.dot(DA))*(DB.dot(DB)))
candidates = sp.solve(sp.Eq(squared,0),t)
print("Squared equation =", squared)
print("Candidates =", candidates)
for value in candidates:
    cosine = sp.simplify((DA.dot(DB)/(sp.sqrt(DA.dot(DA))*sp.sqrt(DB.dot(DB)))).subs(t,value))
    angle = sp.N(sp.acos(cosine)*180/sp.pi,10)
    print("t =", value, "D =", tuple(D.subs(t,value)), "angle =", angle)
chosen = candidates[0]
print("Chosen D approx =", tuple(sp.N(v,8) for v in D.subs(t,chosen)))

Utskrift fra Python:
Squared equation = 3*t**2*(28561*t**2 - 38194*t + 12406)/4
Candidates = [113/169 - 11*sqrt(3)/169, 11*sqrt(3)/169 + 113/169]
t = 113/169 - 11*sqrt(3)/169 D = (1356/169 - 132*sqrt(3)/169, 565/169 - 55*sqrt(3)/169) angle = 120.0000000
t = 11*sqrt(3)/169 + 113/169 D = (132*sqrt(3)/169 + 1356/169, 55*sqrt(3)/169 + 565/169) angle = 60.00000000
Chosen D approx = (6.6708242, 2.7795101)

import sympy as sp
t = sp.symbols("t", positive=True)
B = sp.Matrix([9,1])
E = sp.Matrix([12*t,5*t])
determinant = sp.det(sp.Matrix([[B[0],B[1]],[E[0],E[1]]]))
area = sp.simplify(abs(determinant)/2)
solution = sp.solve(sp.Eq(area,11),t)
point = E.subs(t,solution[0])
print("Determinant =", determinant)
print("Area expression =", area)
print("t =", solution[0])
print("E =", tuple(point))
print("Area check =", area.subs(t,solution[0]))

Utskrift fra Python:
Determinant = 33*t
Area expression = 33*t/2
t = 2/3
E = (8, 10/3)
Area check = 11

import sympy as sp
x = sp.symbols("x", real=True)
f = x**2
a = 1
b = -1
print("f(x) =", f)
print("a =", a, "b =", b)
print("f(a) =", f.subs(x,a))
print("f(b) =", f.subs(x,b))
print("f(a) == f(b):", f.subs(x,a) == f.subs(x,b))
print("a == b:", a == b)
print("Statement valid for all functions: False")

Utskrift fra Python:
f(x) = x**2
a = 1 b = -1
f(a) = 1
f(b) = 1
f(a) == f(b): True
a == b: False
Statement valid for all functions: False

import sympy as sp
x = sp.symbols("x", positive=True)
derivative = sp.diff(sp.log(x),x)
print("Derivative of ln(x) =", derivative)
for a,b in [(sp.Rational(1,2),2),(2,3),(10,100)]:
    difference = sp.N(sp.log(b)-sp.log(a),12)
    print("a =", a, "b =", b, "ln(b)-ln(a) =", difference)
print("Derivative positive on x>0: True")
print("Therefore ln is strictly increasing")

Utskrift fra Python:
Derivative of ln(x) = 1/x
a = 1/2 b = 2 ln(b)-ln(a) = 1.38629436112
a = 2 b = 3 ln(b)-ln(a) = 0.405465108108
a = 10 b = 100 ln(b)-ln(a) = 2.30258509299
Derivative positive on x>0: True
Therefore ln is strictly increasing

import sympy as sp
x, a = sp.symbols("x a", positive=True)
left = sp.diff(sp.log(x),x)
right = sp.diff(sp.log(a*x),x)
difference = sp.simplify(right-left)
expanded = sp.expand_log(sp.log(a*x), force=True)
print("Left derivative =", left)
print("ln(a*x) expanded =", expanded)
print("Right derivative =", right)
print("Difference =", difference)
print("Statement true:", difference == 0)

Utskrift fra Python:
Left derivative = 1/x
ln(a*x) expanded = log(a) + log(x)
Right derivative = 1/x
Difference = 0
Statement true: True

import sympy as sp
x = sp.symbols("x", real=True)
f = 1-x**2
a = sp.Rational(1,2)
point_y = f.subs(x,a)
slope = sp.diff(f,x).subs(x,a)
tangent = sp.expand(point_y+slope*(x-a))
y_intercept = tangent.subs(x,0)
x_intercept = sp.solve(sp.Eq(tangent,0),x)[0]
area = sp.simplify(sp.Rational(1,2)*x_intercept*y_intercept)
print("P =", (a,point_y))
print("Slope =", slope)
print("Tangent y =", tangent)
print("A =", (x_intercept,0))
print("B =", (0,y_intercept))
print("Area =", area)
print("Area decimal =", sp.N(area,10))

Utskrift fra Python:
P = (1/2, 3/4)
Slope = -1
Tangent y = 5/4 - x
A = (5/4, 0)
B = (0, 5/4)
Area = 25/32
Area decimal = 0.7812500000

import sympy as sp
a = sp.symbols("a", positive=True)
area = (1+a**2)**2/(4*a)
derivative = sp.factor(sp.diff(area,a))
critical = sp.solve(sp.Eq(derivative,0),a)
valid = [v for v in critical if 0 < float(v) < 1]
minimum_a = valid[0]
minimum_area = sp.simplify(area.subs(a,minimum_a))
print("Area function =", area)
print("Derivative =", derivative)
print("Critical points =", critical)
print("Valid a =", minimum_a)
print("Minimum area =", minimum_area)
print("Minimum area decimal =", sp.N(minimum_area,12))

Utskrift fra Python:
Area function = (a**2 + 1)**2/(4*a)
Derivative = (a**2 + 1)*(3*a**2 - 1)/(4*a**2)
Critical points = [sqrt(3)/3]
Valid a = sqrt(3)/3
Minimum area = 4*sqrt(3)/9
Minimum area decimal = 0.769800358919

from fractions import Fraction

def centroid(A, B, C):
    points = (A, B, C)
    if any(len(point) != 2 for point in points):
        raise ValueError("Each point must have two coordinates")
    x_coordinate = sum(point[0] for point in points) / 3
    y_coordinate = sum(point[1] for point in points) / 3
    return (x_coordinate, y_coordinate)

A = (Fraction(0), Fraction(0))
B = (Fraction(9), Fraction(1))
C = (Fraction(24), Fraction(10))
T = centroid(A, B, C)
print("A =", A)
print("B =", B)
print("C =", C)
print("Centroid T =", T)
print("Decimal T =", tuple(float(value) for value in T))

Utskrift fra Python:
A = (Fraction(0, 1), Fraction(0, 1))
B = (Fraction(9, 1), Fraction(1, 1))
C = (Fraction(24, 1), Fraction(10, 1))
Centroid T = (Fraction(11, 1), Fraction(11, 3))
Decimal T = (11.0, 3.6666666666666665)

import sympy as sp
x, k = sp.symbols("x k", real=True)
f = 2*x+5+1/(x-1)
f_prime = sp.simplify(sp.diff(f,x))
solutions = sp.solve(sp.Eq(f_prime,k),x)
print("f(x) =", f)
print("f'(x) =", f_prime)
print("Formal solutions =", solutions)
print("Reality condition: 2-k > 0")
print("Therefore k < 2")
for value in [1,0,-2]:
    print("k =", value, "solutions =", sp.solve(sp.Eq(f_prime,value),x))

Utskrift fra Python:
f(x) = 2*x + 5 + 1/(x - 1)
f'(x) = 2 - 1/(x - 1)**2
Formal solutions = [1 - 1/sqrt(2 - k), 1 + 1/sqrt(2 - k)]
Reality condition: 2-k > 0
Therefore k < 2
k = 1 solutions = [0, 2]
k = 0 solutions = [1 - sqrt(2)/2, sqrt(2)/2 + 1]
k = -2 solutions = [1/2, 3/2]

import sympy as sp
x = sp.symbols("x", real=True)
f_prime = 2-1/(x-1)**2
for k_value in [1,0,-2]:
    roots = sp.solve(sp.Eq(f_prime,k_value),x)
    midpoint = sp.simplify(sum(roots)/2)
    distances = [sp.simplify(abs(root-midpoint)) for root in roots]
    print("k =", k_value)
    print("roots =", roots)
    print("midpoint =", midpoint)
    print("distances =", distances)
print("All pairs are symmetric about x=1")

Utskrift fra Python:
k = 1
roots = [0, 2]
midpoint = 1
distances = [1, 1]
k = 0
roots = [1 - sqrt(2)/2, sqrt(2)/2 + 1]
midpoint = 1
distances = [sqrt(2)/2, sqrt(2)/2]
k = -2
roots = [1/2, 3/2]
midpoint = 1
distances = [1/2, 1/2]
All pairs are symmetric about x=1

import sympy as sp
x, a, d = sp.symbols("x a d", real=True)
g_prime = a-1/(x+d)**2
formal_solutions = sp.solve(sp.Eq(g_prime,4),x)
print("g'(x) =", g_prime)
print("Formal solutions =", formal_solutions)
print("Condition for real roots: a-4 > 0")
for a_value in [3,4,5,8]:
    roots = sp.solve(sp.Eq(g_prime.subs({a:a_value,d:2}),4),x)
    print("a =", a_value, "roots for d=2:", roots)
print("Conclusion: a > 4")

Utskrift fra Python:
g'(x) = a - 1/(d + x)**2
Formal solutions = [-d - 1/sqrt(a - 4), -d + 1/sqrt(a - 4)]
Condition for real roots: a-4 > 0
a = 3 roots for d=2: []
a = 4 roots for d=2: []
a = 5 roots for d=2: [-3, -1]
a = 8 roots for d=2: [-5/2, -3/2]
Conclusion: a > 4

import sympy as sp
x, d = sp.symbols("x d", real=True)
g_prime = 3-1/(x+d)**2
for k_value in [2,1,-1]:
    roots = sp.solve(sp.Eq(g_prime,k_value),x)
    midpoint = sp.simplify(sum(roots)/2)
    print("k =", k_value)
    print("roots =", roots)
    print("midpoint =", midpoint)
print("k=3 roots =", sp.solve(sp.Eq(g_prime,3),x))
print("k=4 roots =", sp.solve(sp.Eq(g_prime,4),x))
print("Real solutions occur exactly for k < 3")

Utskrift fra Python:
k = 2
roots = [1 - d, -d - 1]
midpoint = -d
k = 1
roots = [-d - sqrt(2)/2, -d + sqrt(2)/2]
midpoint = -d
k = -1
roots = [1/2 - d, -d - 1/2]
midpoint = -d
k=3 roots = []
k=4 roots = []
Real solutions occur exactly for k < 3

import sympy as sp
b, d, x = sp.symbols("b d x", real=True)
g = 3*x+b+1/(x+d)
g_prime = sp.diff(g,x)
equation_one = sp.Eq(g_prime.subs(x,-1),g_prime.subs(x,5))
equation_two = sp.Eq(g.subs(x,1),7)
solutions = sp.solve([equation_one,equation_two],[b,d], dict=True)
print("g(x) =", g)
print("g'(x) =", g_prime)
print("Equation 1 =", equation_one)
print("Equation 2 =", equation_two)
print("Solutions =", solutions)
chosen = solutions[0]
print("g(1) check =", sp.simplify(g.subs(chosen).subs(x,1)))
print("Derivative difference =", sp.simplify(g_prime.subs(chosen).subs(x,-1)-g_prime.subs(chosen).subs(x,5)))

Utskrift fra Python:
g(x) = b + 3*x + 1/(d + x)
g'(x) = 3 - 1/(d + x)**2
Equation 1 = Eq(3 - 1/(d - 1)**2, 3 - 1/(d + 5)**2)
Equation 2 = Eq(b + 3 + 1/(d + 1), 7)
Solutions = [{b: 5, d: -2}]
g(1) check = 7
Derivative difference = 0