import sympy as sp
x = sp.symbols("x", positive=True)
f = x**2 + sp.log(x)
f_prime = sp.diff(f, x)
expected = 2*x + 1/x
print("f(x) =", f)
print("f'(x) =", f_prime)
print("Expected =", expected)
print("Difference =", sp.simplify(f_prime-expected))
print("Domain: x > 0")

Utskrift fra Python:
f(x) = x**2 + log(x)
f'(x) = 2*x + 1/x
Expected = 2*x + 1/x
Difference = 0
Domain: x > 0

import sympy as sp
x = sp.symbols("x", real=True)
g = x*sp.sqrt(1-2*x)
g_prime = sp.simplify(sp.diff(g, x))
expected = (1-3*x)/sp.sqrt(1-2*x)
print("g(x) =", g)
print("g'(x) =", g_prime)
print("Expected =", expected)
print("Difference =", sp.simplify(g_prime-expected))
print("Function domain: x <= 1/2")
print("Derivative domain: x < 1/2")

Utskrift fra Python:
g(x) = x*sqrt(1 - 2*x)
g'(x) = (1 - 3*x)/sqrt(1 - 2*x)
Expected = (1 - 3*x)/sqrt(1 - 2*x)
Difference = 0
Function domain: x <= 1/2
Derivative domain: x < 1/2

import sympy as sp
x = sp.symbols("x", real=True)
h = x/sp.exp(x**2)
h_prime = sp.factor(sp.diff(h, x))
expected = (1-2*x**2)/sp.exp(x**2)
print("h(x) =", h)
print("h'(x) =", h_prime)
print("Expected =", expected)
print("Difference =", sp.simplify(h_prime-expected))
print("h'(0) =", h_prime.subs(x,0))

Utskrift fra Python:
h(x) = x*exp(-x**2)
h'(x) = -(2*x**2 - 1)*exp(-x**2)
Expected = (1 - 2*x**2)*exp(-x**2)
Difference = 0
h'(0) = 1

import sympy as sp
x = sp.symbols("x", positive=True)
solution = sp.Integer(1000)
lhs = sp.log(solution**3,10)-2*sp.log(solution,10)
print("Domain: x > 0")
print("Reduced equation: log10(x) = 3")
print("Solution x =", solution)
print("Left side at x=1000 =", sp.simplify(lhs))
print("Equation satisfied =", sp.simplify(lhs-3)==0)

Utskrift fra Python:
Domain: x > 0
Reduced equation: log10(x) = 3
Solution x = 1000
Left side at x=1000 = 3
Equation satisfied = True

import sympy as sp
x, y = sp.symbols("x y", real=True)
quadratic = y**2-y-2
roots = sp.solve(sp.Eq(quadratic,0),y)
valid = [r for r in roots if r.is_positive]
solution = sp.log(valid[0])
print("Quadratic in y =", quadratic)
print("Roots for y =", roots)
print("Positive root =", valid[0])
print("Solution x =", solution)
print("Original left side =", sp.simplify(sp.exp(solution)-2*sp.exp(-solution)-1))

Utskrift fra Python:
Quadratic in y = y**2 - y - 2
Roots for y = [-1, 2]
Positive root = 2
Solution x = log(2)
Original left side = 0

import sympy as sp
x = sp.symbols("x")
P = x**3+2*x**2-5*x-6
Q, R = sp.div(P,x-2)
print("Dividend =", P)
print("Divisor =", x-2)
print("Quotient =", Q)
print("Remainder =", R)
print("Reconstruction =", sp.expand((x-2)*Q+R))
print("Difference =", sp.expand(P-((x-2)*Q+R)))

Utskrift fra Python:
Dividend = x**3 + 2*x**2 - 5*x - 6
Divisor = x - 2
Quotient = x**2 + 4*x + 3
Remainder = 0
Reconstruction = x**3 + 2*x**2 - 5*x - 6
Difference = 0

import sympy as sp
x = sp.symbols("x")
P = x**3+2*x**2-5*x-6
factored = sp.factor(P)
roots = sp.solve(sp.Eq(P,0),x)
print("Polynomial =", P)
print("Factorized =", factored)
print("Roots =", roots)
for root in roots:
    print(f"P({root}) =", sp.expand(P.subs(x,root)))

Utskrift fra Python:
Polynomial = x**3 + 2*x**2 - 5*x - 6
Factorized = (x - 2)*(x + 1)*(x + 3)
Roots = [-3, -1, 2]
P(-3) = 0
P(-1) = 0
P(2) = 0

import sympy as sp
x = sp.symbols("x", real=True)
V = x**3-4*x**2+2*x+7
h = x+1
A = sp.cancel(V/h)
critical = sp.solve(sp.Eq(sp.diff(A,x),0),x)[0]
height = sp.simplify(critical+1)
print("V(x) =", V)
print("h(x) =", h)
print("Base area A(x) =", A)
print("A'(x) =", sp.diff(A,x))
print("Critical x =", critical)
print("A''(x) =", sp.diff(A,x,2))
print("Optimal height h =", height)
print("Minimum area =", sp.simplify(A.subs(x,critical)))

Utskrift fra Python:
V(x) = x**3 - 4*x**2 + 2*x + 7
h(x) = x + 1
Base area A(x) = x**2 - 5*x + 7
A'(x) = 2*x - 5
Critical x = 5/2
A''(x) = 2
Optimal height h = 7/2
Minimum area = 3/4

import sympy as sp
x = sp.symbols("x")
expr = (x**2-1)/(x-1)
factored = sp.factor(x**2-1)
simplified = sp.cancel(expr)
limit_value = sp.limit(expr,x,1)
print("Expression =", expr)
print("Factored numerator =", factored)
print("Simplified for x != 1 =", simplified)
print("Limit as x -> 1 =", limit_value)
print("Direct substitution gives 0/0, not the limit")

Utskrift fra Python:
Expression = (x**2 - 1)/(x - 1)
Factored numerator = (x - 1)*(x + 1)
Simplified for x != 1 = x + 1
Limit as x -> 1 = 2
Direct substitution gives 0/0, not the limit

import sympy as sp
k = sp.symbols("k", real=True)
left_value = 2**2+1
right_value = 2-k
solution = sp.solve(sp.Eq(right_value,left_value),k)[0]
print("Left limit at x=2 =", left_value)
print("Right value f(2) =", right_value)
print("Continuity equation =", sp.Eq(right_value,left_value))
print("k =", solution)
print("Right value with k=-3 =", right_value.subs(k,solution))

Utskrift fra Python:
Left limit at x=2 = 5
Right value f(2) = 2 - k
Continuity equation = Eq(2 - k, 5)
k = -3
Right value with k=-3 = 5

import sympy as sp
x = sp.symbols("x", real=True)
left_branch = x**2+1
right_branch = x+3
left_slope = sp.diff(left_branch,x).subs(x,2)
right_slope = sp.diff(right_branch,x).subs(x,2)
print("Left branch =", left_branch)
print("Right branch =", right_branch)
print("Left derivative at 2 =", left_slope)
print("Right derivative at 2 =", right_slope)
print("Differentiable at x=2 =", left_slope==right_slope)

Utskrift fra Python:
Left branch = x**2 + 1
Right branch = x + 3
Left derivative at 2 = 4
Right derivative at 2 = 1
Differentiable at x=2 = False

import math
positions = 4
count = math.factorial(positions)
print("Number of tires =", positions)
print("Choices by position = 4 * 3 * 2 * 1")
print("4! =", count)
print("Total placements =", count)
print("Each placement is assumed equally likely")

Utskrift fra Python:
Number of tires = 4
Choices by position = 4 * 3 * 2 * 1
4! = 24
Total placements = 24
Each placement is assumed equally likely

import itertools, math
permutations = list(itertools.permutations(range(4)))
derangements = [p for p in permutations if all(p[i] != i for i in range(4))]
probability = len(derangements)/len(permutations)
print("Total placements =", len(permutations))
print("Derangements =", len(derangements))
print("Exact probability = 9/24 = 3/8")
print("Decimal probability =", probability)
print("Percent =", 100*probability)

Utskrift fra Python:
Total placements = 24
Derangements = 9
Exact probability = 9/24 = 3/8
Decimal probability = 0.375
Percent = 37.5

from fractions import Fraction
angle_CBS = 52
angle_DEB = 79
angle_BSC = 180-2*angle_CBS
v = 180-angle_BSC
angle_CDB = angle_BSC/2
u = 90-angle_CDB
angle_AED = 180-angle_DEB
w = 180-angle_AED-u
print("angle BSC =", angle_BSC)
print("v =", v)
print("angle CDB =", angle_CDB)
print("u =", u)
print("angle AED =", angle_AED)
print("w =", w)
print("Triangle AED check =", w+u+angle_AED)

Utskrift fra Python:
angle BSC = 76
v = 104
angle CDB = 38.0
u = 52.0
angle AED = 101
w = 27.0
Triangle AED check = 180.0

import sympy as sp
x, y = sp.symbols("x y", real=True)
original = x**2+y**2-4*x-8*y-5
standard = (x-2)**2+(y-4)**2-25
print("Original left minus right =", original)
print("Standard left minus right =", sp.expand(standard))
print("Difference =", sp.expand(original-standard))
print("Center = (2, 4)")
print("Radius squared =", 25)
print("Radius =", sp.sqrt(25))

Utskrift fra Python:
Original left minus right = x**2 - 4*x + y**2 - 8*y - 5
Standard left minus right = x**2 - 4*x + y**2 - 8*y - 5
Difference = 0
Center = (2, 4)
Radius squared = 25
Radius = 5

import sympy as sp
x = sp.symbols("x", real=True)
equation = sp.Eq((x-2)**2+16,25)
solutions = sp.solve(equation,x)
print("Equation on x-axis =", equation)
print("x-solutions =", solutions)
points = [(value,0) for value in solutions]
print("Intersection points =", points)
for value in solutions:
    print(f"Circle check for x={value}:", sp.simplify((value-2)**2+16))

Utskrift fra Python:
Equation on x-axis = Eq((x - 2)**2 + 16, 25)
x-solutions = [-1, 5]
Intersection points = [(-1, 0), (5, 0)]
Circle check for x=-1: 25
Circle check for x=5: 25

import sympy as sp
u = sp.Matrix([2,-1])
v = sp.Matrix([2,4])
dot = u.dot(v)
cosine = sp.simplify(dot/(sp.sqrt(u.dot(u))*sp.sqrt(v.dot(v))))
angle = sp.acos(cosine)*180/sp.pi
print("Direction l =", tuple(u))
print("Direction m =", tuple(v))
print("Dot product =", dot)
print("cos(angle) =", cosine)
print("Angle in degrees =", sp.simplify(angle))

Utskrift fra Python:
Direction l = (2, -1)
Direction m = (2, 4)
Dot product = 0
cos(angle) = 0
Angle in degrees = 90

import sympy as sp
a = sp.symbols("a", real=True)
point = sp.Matrix([sp.Rational(3,2),sp.Rational(9,4)])
center = sp.Matrix([0,a])
tangent = sp.Matrix([1,3])
radius_vector = point-center
equation = sp.Eq(radius_vector.dot(tangent),0)
solution = sp.solve(equation,a)[0]
print("Point of tangency =", tuple(point))
print("Tangent direction =", tuple(tangent))
print("Radius vector =", tuple(radius_vector))
print("Perpendicular equation =", equation)
print("a =", solution)
print("Center =", (0,solution))
print("Radius =", sp.simplify(sp.sqrt((point-sp.Matrix([0,solution])).dot(point-sp.Matrix([0,solution])))))

Utskrift fra Python:
Point of tangency = (3/2, 9/4)
Tangent direction = (1, 3)
Radius vector = (3/2, 9/4 - a)
Perpendicular equation = Eq(33/4 - 3*a, 0)
a = 11/4
Center = (0, 11/4)
Radius = sqrt(10)/2

n = 12
p = 0.74
outcomes = ("bestått", "ikke bestått")
print("Fixed number of trials n =", n)
print("Two outcomes =", outcomes)
print("Constant success probability p =", p)
print("Assumption: trials are independent")
print("Model: X ~ Binomial(12, 0.74)")

Utskrift fra Python:
Fixed number of trials n = 12
Two outcomes = ('bestått', 'ikke bestått')
Constant success probability p = 0.74
Assumption: trials are independent
Model: X ~ Binomial(12, 0.74)

from math import comb
n = 12
p = 0.74
terms = [comb(n,k)*p**k*(1-p)**(n-k) for k in range(8,n+1)]
probability = sum(terms)
print("Model: Binomial(n=12, p=0.74)")
print("k-values =", list(range(8,13)))
print("Individual terms =", [round(v,12) for v in terms])
print("P(X >= 8) =", probability)
print("Percent =", 100*probability)

Utskrift fra Python:
Model: Binomial(n=12, p=0.74)
k-values = [8, 9, 10, 11, 12]
Individual terms = [0.203400655722, 0.257293137152, 0.219688755568, 0.113685090294, 0.026963771416]
P(X >= 8) = 0.8210314101524017
Percent = 82.10314101524017

from math import comb
n = 7
k = 5
p = 0.74
coefficient = comb(n,k)
probability = coefficient*p**k*(1-p)**(n-k)
print("n =", n, "k =", k, "p =", p)
print("Binomial coefficient =", coefficient)
print("Success factor =", p**k)
print("Failure factor =", (1-p)**(n-k))
print("P(G=5) =", probability)
print("Percent =", 100*probability)

Utskrift fra Python:
n = 7 k = 5 p = 0.74
Binomial coefficient = 21
Success factor = 0.22190066239999998
Failure factor = 0.06760000000000001
P(G=5) = 0.31501018034304
Percent = 31.501018034304

from math import comb
p = 0.74
p_boys = comb(7,5)*p**5*(1-p)**2
p_girls = comb(5,4)*p**4*(1-p)
combined = p_boys*p_girls
print("P(exactly 5 boys) =", p_boys)
print("P(exactly 4 girls) =", p_girls)
print("Product under independence =", combined)
print("Percent =", 100*combined)
print("Check combined is below each factor =", combined < p_boys and combined < p_girls)

Utskrift fra Python:
P(exactly 5 boys) = 0.31501018034304
P(exactly 4 girls) = 0.38982548799999994
Product under independence = 0.12279899727719357
Percent = 12.279899727719357
Check combined is below each factor = True

import math
p = 0.74
threshold = 0.02
boundary = math.log(threshold)/math.log(p)
n = 1
while p**n >= threshold:
    n += 1
print("Real-valued boundary =", boundary)
print("Minimum integer n =", n)
print("0.74^(n-1) =", p**(n-1))
print("0.74^n =", p**n)
print("Condition satisfied =", p**n < threshold)

Utskrift fra Python:
Real-valued boundary = 12.992217996908751
Minimum integer n = 13
0.74^(n-1) = 0.02696377141592078
0.74^n = 0.01995319084778138
Condition satisfied = True

import sympy as sp
k = sp.symbols("k", real=True)
a = sp.Matrix([3,1])
b = sp.Matrix([k,2])
expression = 3*a+5*b
solution = sp.solve(sp.Eq(expression[0],-6),k)[0]
print("a =", tuple(a))
print("b =", tuple(b))
print("3a + 5b =", tuple(expression))
print("k =", solution)
print("Vector at k=-3 =", tuple(expression.subs(k,solution)))

Utskrift fra Python:
a = (3, 1)
b = (k, 2)
3a + 5b = (5*k + 9, 13)
k = -3
Vector at k=-3 = (-6, 13)

import sympy as sp
k = sp.symbols("k", real=True)
cosine = (3*k+2)/(sp.sqrt(10)*sp.sqrt(k**2+4))
boundary = sp.solve(sp.Eq(cosine,sp.Rational(1,2)),k)[0]
solution = sp.solve_univariate_inequality(cosine < sp.Rational(1,2),k)
quadratic = sp.expand(2*(3*k+2)**2-5*(k**2+4))
print("cos(theta) =", cosine)
print("Boundary equation root =", boundary)
print("Decimal boundary =", sp.N(boundary,12))
print("Squared-case polynomial =", quadratic)
print("Complete solution =", solution)
for value in [-2,0,1]:
    print(f"k={value}: cos(theta)=", sp.N(cosine.subs(k,value),8))

Utskrift fra Python:
cos(theta) = sqrt(10)*(3*k + 2)/(10*sqrt(k**2 + 4))
Boundary equation root = -12/13 + 10*sqrt(3)/13
Decimal boundary = 0.409269851976
Squared-case polynomial = 13*k**2 + 24*k - 12
Complete solution = k < -12/13 + 10*sqrt(3)/13
k=-2: cos(theta)= -0.44721360
k=0: cos(theta)= 0.31622777
k=1: cos(theta)= 0.70710678

import sympy as sp
t, k = sp.symbols("t k", real=True)
r = sp.Matrix([-12*t*sp.exp(-t/2), t**2+k*t])
velocity = sp.diff(r,t)
v0 = velocity.subs(t,0)
speed0 = sp.sqrt(v0.dot(v0))
solutions = sp.solve(sp.Eq(speed0,13),k)
print("r(t) =", tuple(r))
print("r'(t) =", tuple(velocity))
print("r'(0) =", tuple(v0))
print("Speed at t=0 =", speed0)
print("Solutions for k =", solutions)
for value in solutions:
    print(f"Speed for k={value} =", sp.simplify(speed0.subs(k,value)))

Utskrift fra Python:
r(t) = (-12*t*exp(-t/2), k*t + t**2)
r'(t) = (6*t*exp(-t/2) - 12*exp(-t/2), k + 2*t)
r'(0) = (-12, k)
Speed at t=0 = sqrt(k**2 + 144)
Solutions for k = [-5, 5]
Speed for k=-5 = 13
Speed for k=5 = 13

import numpy as np
import math
samples = [-1,0,1,2.5,5,6]
def position(t):
    return (-12*t*math.exp(-t/2), t*t-5*t)
print("Parameter interval = [-1, 6]")
print("x(t) = -12*t*exp(-t/2)")
print("y(t) = t^2-5*t")
for value in samples:
    print(f"r({value}) =", tuple(round(v,8) for v in position(value)))
points = np.array([position(v) for v in np.linspace(-1,6,701)])
print("Number of plotted sample points =", len(points))
print("x-range approximately =", (points[:,0].min(),points[:,0].max()))
print("y-range =", (points[:,1].min(),points[:,1].max()))

Utskrift fra Python:
Parameter interval = [-1, 6]
x(t) = -12*t*exp(-t/2)
y(t) = t^2-5*t
r(-1) = (19.78465525, 6)
r(0) = (0.0, 0)
r(1) = (-7.27836792, -4)
r(2.5) = (-8.59514391, -6.25)
r(5) = (-4.92509992, 0)
r(6) = (-3.58466892, 6)
Number of plotted sample points = 701
x-range approximately = (np.float64(-8.829106588114616), np.float64(19.78465524840154))
y-range = (np.float64(-6.25), np.float64(6.0))

import sympy as sp
t = sp.symbols("t", real=True)
expr = t*sp.exp(-t/2)-(5-t)*sp.exp(-(5-t)/2)
t1 = sp.nsolve(expr,0.7,prec=40)
t2 = 5-t1
x1 = -12*t1*sp.exp(-t1/2)
y1 = t1**2-5*t1
x2 = -12*t2*sp.exp(-t2/2)
y2 = t2**2-5*t2
print("Equation after t2=5-t1:", expr)
print("t1 =", sp.N(t1,14))
print("t2 =", sp.N(t2,14))
print("t1+t2 =", sp.N(t1+t2,14))
print("Position at t1 =", (sp.N(x1,12),sp.N(y1,12)))
print("Position at t2 =", (sp.N(x2,12),sp.N(y2,12)))
print("Coordinate differences =", (sp.N(x1-x2,8),sp.N(y1-y2,8)))

Utskrift fra Python:
Equation after t2=5-t1: t*exp(-t/2) - (5 - t)*exp(t/2 - 5/2)
t1 = 0.72397054128032
t2 = 4.2760294587197
t1+t2 = 5.0000000000000
Position at t1 = (-6.04914417213, -3.09571936176)
Position at t2 = (-6.04914417213, -3.09571936176)
Coordinate differences = (0, 9.1835496e-41)

import sympy as sp
x, a, b, c = sp.symbols("x a b c", real=True)
f = a*x**3+b*x**2+c*x+1
equations = [sp.Eq(f.subs(x,1),0),sp.Eq(f.subs(x,2),-3),sp.Eq(sp.diff(f,x,2).subs(x,2),0)]
solution = sp.solve(equations,[a,b,c],dict=True)[0]
f_solution = sp.expand(f.subs(solution))
print("Equations =", equations)
print("Solution =", solution)
print("f(x) =", f_solution)
print("f(1) =", f_solution.subs(x,1))
print("f(2) =", f_solution.subs(x,2))
print("f''(2) =", sp.diff(f_solution,x,2).subs(x,2))

Utskrift fra Python:
Equations = [Eq(a + b + c + 1, 0), Eq(8*a + 4*b + 2*c + 1, -3), Eq(12*a + 2*b, 0)]
Solution = {a: 1/3, b: -2, c: 2/3}
f(x) = x**3/3 - 2*x**2 + 2*x/3 + 1
f(1) = 0
f(2) = -3
f''(2) = 0

import sympy as sp
s = sp.symbols("s", real=True)
g = s**3-3*s**2-13*s+15
factor_g = sp.factor(g)
area = sp.factor(sp.Rational(1,2)*(s-1)*(-g))
expanded = sp.expand(area)
print("g(s) =", g)
print("Factorized g(s) =", factor_g)
print("For 1 < s < 5, g(s) is negative")
print("Area A(s) =", area)
print("Expanded A(s) =", expanded)
print("A(1) =", area.subs(s,1), "A(5) =", area.subs(s,5))

Utskrift fra Python:
g(s) = s**3 - 3*s**2 - 13*s + 15
Factorized g(s) = (s - 5)*(s - 1)*(s + 3)
For 1 < s < 5, g(s) is negative
Area A(s) = -(s - 5)*(s - 1)**2*(s + 3)/2
Expanded A(s) = -s**4/2 + 2*s**3 + 5*s**2 - 14*s + 15/2
A(1) = 0 A(5) = 0

import sympy as sp
s = sp.symbols("s", real=True)
area = sp.Rational(1,2)*(s-1)**2*(5-s)*(s+3)
derivative = sp.factor(sp.diff(area,s))
critical = sp.solve(sp.Eq(derivative,0),s)
s_max = 1+2*sp.sqrt(2)
max_area = sp.simplify(area.subs(s,s_max))
print("A(s) =", sp.expand(area))
print("A'(s) =", derivative)
print("All critical values =", critical)
print("Critical value in (1,5) =", s_max)
print("Decimal s =", sp.N(s_max,12))
print("Maximum area =", max_area)
print("Endpoint values =", area.subs(s,1), area.subs(s,5))

Utskrift fra Python:
A(s) = -s**4/2 + 2*s**3 + 5*s**2 - 14*s + 15/2
A'(s) = -2*(s - 1)*(s**2 - 2*s - 7)
All critical values = [1, 1 - 2*sqrt(2), 1 + 2*sqrt(2)]
Critical value in (1,5) = 1 + 2*sqrt(2)
Decimal s = 3.82842712475
Maximum area = 32
Endpoint values = 0 0