import sympy as sp
x = sp.symbols("x", real=True)
f = 3*x**2 - 2*x + 1
term_1 = sp.diff(3*x**2, x)
term_2 = sp.diff(-2*x, x)
term_3 = sp.diff(1, x)
derivative = sp.diff(f, x)
print("f(x) =", f)
print("Derivative of 3*x**2 =", term_1)
print("Derivative of -2*x =", term_2)
print("Derivative of 1 =", term_3)
print("f'(x) =", derivative)
print("Expanded check =", sp.expand(derivative))

Utskrift fra Python:
f(x) = 3*x**2 - 2*x + 1
Derivative of 3*x**2 = 6*x
Derivative of -2*x = -2
Derivative of 1 = 0
f'(x) = 6*x - 2
Expanded check = 6*x - 2

import sympy as sp
x = sp.symbols("x", real=True)
u = x**2
v = sp.exp(x)
u_prime = sp.diff(u, x)
v_prime = sp.diff(v, x)
product_rule = sp.expand(u_prime*v + u*v_prime)
factored = sp.factor(product_rule)
print("u(x) =", u)
print("v(x) =", v)
print("u'(x) =", u_prime)
print("v'(x) =", v_prime)
print("Product rule gives =", product_rule)
print("Factored derivative =", factored)
print("Direct SymPy derivative =", sp.diff(u*v, x))

Utskrift fra Python:
u(x) = x**2
v(x) = exp(x)
u'(x) = 2*x
v'(x) = exp(x)
Product rule gives = x**2*exp(x) + 2*x*exp(x)
Factored derivative = x*(x + 2)*exp(x)
Direct SymPy derivative = x**2*exp(x) + 2*x*exp(x)

import sympy as sp
x = sp.symbols("x", real=True)
inner = x**3 - 1
h = sp.log(inner)
inner_prime = sp.diff(inner, x)
h_prime = sp.diff(h, x)
print("Inner function =", inner)
print("Derivative of inner function =", inner_prime)
print("h(x) =", h)
print("h'(x) =", h_prime)
print("Combined fraction =", sp.together(h_prime))
print("Domain condition: x**3 - 1 > 0")
print("Domain solution =", sp.solve_univariate_inequality(inner > 0, x))

Utskrift fra Python:
Inner function = x**3 - 1
Derivative of inner function = 3*x**2
h(x) = log(x**3 - 1)
h'(x) = 3*x**2/(x**3 - 1)
Combined fraction = 3*x**2/(x**3 - 1)
Domain condition: x**3 - 1 > 0
Domain solution = 1 < x

import sympy as sp
a, b = sp.symbols("a b", positive=True)
expression = 2*sp.log(b) - sp.log(1/b) - sp.log(a*b**2) + sp.log(a/b**2)
expanded = 2*sp.log(b) + sp.log(b) - (sp.log(a) + 2*sp.log(b)) + (sp.log(a) - 2*sp.log(b))
simplified = sp.simplify(expanded)
print("Original expression =", expression)
print("After applying log rules =", expanded)
print("Coefficient of log(a) =", -1 + 1)
print("Coefficient of log(b) =", 2 + 1 - 2 - 2)
print("Simplified expression =", simplified)
print("Equivalent form =", sp.log(1/b))
print("Difference check =", sp.simplify(simplified - sp.log(1/b)))

Utskrift fra Python:
Original expression = -log(1/b) + 2*log(b) + log(a/b**2) - log(a*b**2)
After applying log rules = -log(b)
Coefficient of log(a) = 0
Coefficient of log(b) = -1
Simplified expression = -log(b)
Equivalent form = log(1/b)
Difference check = 0

import sympy as sp
a = sp.Matrix([3, 1])
b = sp.Matrix([4, 2])
two_b = 2*b
result = a - two_b
check = result + two_b
print("a =", list(a))
print("b =", list(b))
print("2*b =", list(two_b))
print("First component: 3 - 8 =", result[0])
print("Second component: 1 - 4 =", result[1])
print("a - 2*b =", list(result))
print("Check by adding 2*b =", list(check))

Utskrift fra Python:
a = [3, 1]
b = [4, 2]
2*b = [8, 4]
First component: 3 - 8 = -5
Second component: 1 - 4 = -3
a - 2*b = [-5, -3]
Check by adding 2*b = [3, 1]

import sympy as sp
a = sp.Matrix([3, 1])
b = sp.Matrix([4, 2])
first_product = a[0]*b[0]
second_product = a[1]*b[1]
dot_product = a.dot(b)
print("a =", list(a))
print("b =", list(b))
print("First component product =", first_product)
print("Second component product =", second_product)
print("Sum of component products =", first_product + second_product)
print("a dot b =", dot_product)
print("The dot product is positive =", dot_product > 0)

Utskrift fra Python:
a = [3, 1]
b = [4, 2]
First component product = 12
Second component product = 2
Sum of component products = 14
a dot b = 14
The dot product is positive = True

import sympy as sp
t, k = sp.symbols("t k", real=True)
b = sp.Matrix([4, 2])
c = sp.Matrix([t + 1, 3])
solutions = sp.solve([sp.Eq(c[0], k*b[0]), sp.Eq(c[1], k*b[1])], [t, k], dict=True)
print("b =", list(b))
print("c =", list(c))
print("Equations: t + 1 = 4*k and 3 = 2*k")
print("Solutions =", solutions)
t_value = solutions[0][t]
k_value = solutions[0][k]
print("t =", t_value)
print("Scale factor k =", k_value)
print("c when t=5 =", list(c.subs(t, t_value)))
print("k*b =", list(k_value*b))

Utskrift fra Python:
b = [4, 2]
c = [t + 1, 3]
Equations: t + 1 = 4*k and 3 = 2*k
Solutions = [{k: 3/2, t: 5}]
t = 5
Scale factor k = 3/2
c when t=5 = [6, 3]
k*b = [6, 3]

import sympy as sp
t = sp.symbols("t", real=True)
a = sp.Matrix([3, 1])
c = sp.Matrix([t + 1, 3])
a_length_squared = a.dot(a)
c_length_squared = sp.expand(c.dot(c))
equation = sp.Eq(c_length_squared, a_length_squared)
solutions = sp.solve(equation, t)
print("|a|**2 =", a_length_squared)
print("|c|**2 =", c_length_squared)
print("Equation =", equation)
print("Solutions for t =", solutions)
for value in solutions:
    current = c.subs(t, value)
    print("t =", value, "gives c =", list(current), "and |c|**2 =", current.dot(current))

Utskrift fra Python:
|a|**2 = 10
|c|**2 = t**2 + 2*t + 10
Equation = Eq(t**2 + 2*t + 10, 10)
Solutions for t = [-2, 0]
t = -2 gives c = [-1, 3] and |c|**2 = 10
t = 0 gives c = [1, 3] and |c|**2 = 10

import sympy as sp
x = sp.symbols("x", real=True)
f = 2*(x - 3)**2
base = x
height = f
area_formula = sp.Rational(1, 2)*base*height
expanded_area = sp.expand(area_formula)
print("Base AB =", base)
print("Height BC =", height)
print("Triangle area = 1/2 * base * height")
print("Area before expansion =", area_formula)
print("Expansion of (x - 3)**2 =", sp.expand((x - 3)**2))
print("Expanded area F(x) =", expanded_area)
print("Difference from target =", sp.expand(expanded_area - (x**3 - 6*x**2 + 9*x)))

Utskrift fra Python:
Base AB = x
Height BC = 2*(x - 3)**2
Triangle area = 1/2 * base * height
Area before expansion = x*(x - 3)**2
Expansion of (x - 3)**2 = x**2 - 6*x + 9
Expanded area F(x) = x**3 - 6*x**2 + 9*x
Difference from target = 0

import sympy as sp
x = sp.symbols("x", real=True)
F = x**3 - 6*x**2 + 9*x
F_prime = sp.diff(F, x)
critical_points = sp.solve(sp.Eq(F_prime, 0), x)
print("F(x) =", F)
print("F'(x) =", F_prime)
print("Factored derivative =", sp.factor(F_prime))
print("Critical points =", critical_points)
print("Sign at x=1/2 =", sp.sign(F_prime.subs(x, sp.Rational(1, 2))))
print("Sign at x=2 =", sp.sign(F_prime.subs(x, 2)))
print("F(1) =", F.subs(x, 1))
print("Limit as x approaches 0 from the right =", sp.limit(F, x, 0, dir='+'))
print("Limit as x approaches 3 from the left =", sp.limit(F, x, 3, dir='-'))

Utskrift fra Python:
F(x) = x**3 - 6*x**2 + 9*x
F'(x) = 3*x**2 - 12*x + 9
Factored derivative = 3*(x - 3)*(x - 1)
Critical points = [1, 3]
Sign at x=1/2 = 1
Sign at x=2 = -1
F(1) = 4
Limit as x approaches 0 from the right = 0
Limit as x approaches 3 from the left = 0

import sympy as sp
x = sp.symbols("x", real=True)
F = x**3 - 6*x**2 + 9*x
area_at_2 = sp.simplify(F.subs(x, 2))
equation_polynomial = sp.expand(F - area_at_2)
factored = sp.factor(equation_polynomial)
solutions = sp.solve(sp.Eq(F, area_at_2), x)
valid_solutions = [s for s in solutions if bool(s > 0) and bool(s < 3)]
print("F(x) =", F)
print("F(2) =", area_at_2)
print("Equation polynomial =", equation_polynomial)
print("Factored polynomial =", factored)
print("All exact solutions =", solutions)
print("Decimal solutions =", [sp.N(s, 10) for s in solutions])
print("Solutions in 0 < x < 3 =", valid_solutions)
for s in valid_solutions:
    print("Check F(", s, ") =", sp.simplify(F.subs(x, s)), sep="")

Utskrift fra Python:
F(x) = x**3 - 6*x**2 + 9*x
F(2) = 2
Equation polynomial = x**3 - 6*x**2 + 9*x - 2
Factored polynomial = (x - 2)*(x**2 - 4*x + 1)
All exact solutions = [2, 2 - sqrt(3), sqrt(3) + 2]
Decimal solutions = [2.000000000, 0.2679491924, 3.732050808]
Solutions in 0 < x < 3 = [2, 2 - sqrt(3)]
Check F(2) =2
Check F(2 - sqrt(3)) =2

import itertools
symbols = list(range(10))
number_of_positions = 4
count_by_product_rule = len(symbols)**number_of_positions
all_codes = itertools.product(symbols, repeat=number_of_positions)
count_by_enumeration = sum(1 for _ in all_codes)
print("Available digits =", symbols)
print("Number of choices per position =", len(symbols))
print("Number of positions =", number_of_positions)
print("Product rule expression = 10**4")
print("Count by product rule =", count_by_product_rule)
print("Count by complete enumeration =", count_by_enumeration)
print("Repetition allowed =", True)
print("Order matters =", True)

Utskrift fra Python:
Available digits = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
Number of choices per position = 10
Number of positions = 4
Product rule expression = 10**4
Count by product rule = 10000
Count by complete enumeration = 10000
Repetition allowed = True
Order matters = True

import math
n = 10
r = 4
factorial_formula = math.factorial(n) // (math.factorial(r)*math.factorial(n-r))
combination_function = math.comb(n, r)
ordered_without_repetition = math.perm(n, r)
print("n =", n)
print("r =", r)
print("10! =", math.factorial(n))
print("4! =", math.factorial(r))
print("6! =", math.factorial(n-r))
print("Binomial coefficient by factorials =", factorial_formula)
print("math.comb(10, 4) =", combination_function)
print("Ordered count would be =", ordered_without_repetition)
print("Ordered count divided by 4! =", ordered_without_repetition // math.factorial(r))

Utskrift fra Python:
n = 10
r = 4
10! = 3628800
4! = 24
6! = 720
Binomial coefficient by factorials = 210
math.comb(10, 4) = 210
Ordered count would be = 5040
Ordered count divided by 4! = 210

import math
values = {r: math.comb(10, r) for r in range(11)}
maximum_count = max(values.values())
maximizing_r = [r for r, count in values.items() if count == maximum_count]
print("Counts C(10, r) for r = 0,...,10:")
for r, count in values.items():
    print("r =", r, "count =", count)
print("Maximum count =", maximum_count)
print("Value(s) of r giving the maximum =", maximizing_r)
print("C(10,4) =", values[4])
print("C(10,5) =", values[5])
print("C(10,6) =", values[6])

Utskrift fra Python:
Counts C(10, r) for r = 0,...,10:
r = 0 count = 1
r = 1 count = 10
r = 2 count = 45
r = 3 count = 120
r = 4 count = 210
r = 5 count = 252
r = 6 count = 210
r = 7 count = 120
r = 8 count = 45
r = 9 count = 10
r = 10 count = 1
Maximum count = 252
Value(s) of r giving the maximum = [5]
C(10,4) = 210
C(10,5) = 252
C(10,6) = 210

import sympy as sp
A = sp.Matrix([3, -2])
C = sp.Matrix([1, 4])
AC = C - A
half_AC = sp.Rational(1, 2)*AC
M_vector = A + half_AC
M_average = (A + C)/2
print("A =", list(A))
print("C =", list(C))
print("Vector AC =", list(AC))
print("Half of vector AC =", list(half_AC))
print("A + 1/2*AC =", list(M_vector))
print("Coordinate average =", list(M_average))
print("Both methods agree =", M_vector == M_average)

Utskrift fra Python:
A = [3, -2]
C = [1, 4]
Vector AC = [-2, 6]
Half of vector AC = [-1, 3]
A + 1/2*AC = [2, 1]
Coordinate average = [2, 1]
Both methods agree = True

import sympy as sp
M = sp.Matrix([2, 1])
AC = sp.Matrix([-2, 6])
direction = sp.Matrix([3, 1])
dot_product = AC.dot(direction)
point_at_t0 = M + 0*direction
point_at_t1 = M + direction
print("Midpoint M =", list(M))
print("Direction vector of the parameter line =", list(direction))
print("Vector AC =", list(AC))
print("AC dot direction =", dot_product)
print("Point at t=0 =", list(point_at_t0))
print("Point at t=1 =", list(point_at_t1))
print("Passes through M =", point_at_t0 == M)
print("Perpendicular to AC =", dot_product == 0)

Utskrift fra Python:
Midpoint M = [2, 1]
Direction vector of the parameter line = [3, 1]
Vector AC = [-2, 6]
AC dot direction = 0
Point at t=0 = [2, 1]
Point at t=1 = [5, 2]
Passes through M = True
Perpendicular to AC = True

import sympy as sp
t = sp.symbols("t", real=True)
point_x = sp.Integer(12)
point_y = sp.Rational(9, 2)
t_from_x = sp.solve(sp.Eq(point_x, 2 + 3*t), t)[0]
t_from_y = sp.solve(sp.Eq(point_y, 1 + t), t)[0]
y_from_x_parameter = 1 + t_from_x
x_from_y_parameter = 2 + 3*t_from_y
print("Point =", (point_x, point_y))
print("t from x equation =", t_from_x)
print("Corresponding y =", y_from_x_parameter)
print("Required y =", point_y)
print("t from y equation =", t_from_y)
print("Corresponding x =", x_from_y_parameter)
print("Required x =", point_x)
print("Same parameter value =", sp.simplify(t_from_x - t_from_y) == 0)

Utskrift fra Python:
Point = (12, 9/2)
t from x equation = 10/3
Corresponding y = 13/3
Required y = 9/2
t from y equation = 7/2
Corresponding x = 25/2
Required x = 12
Same parameter value = False

import sympy as sp
t, s = sp.symbols("t s", real=True)
A = sp.Matrix([3, -2])
B = sp.Matrix([9, 4])
N = (A + B)/2
AB = B - A
normal_direction = sp.Matrix([1, -1])
l_point = sp.Matrix([2 + 3*t, 1 + t])
m_point = N + s*normal_direction
solution = sp.solve([sp.Eq(l_point[0], m_point[0]), sp.Eq(l_point[1], m_point[1])], [t, s], dict=True)[0]
intersection = sp.simplify(l_point.subs(t, solution[t]))
print("Midpoint N of AB =", list(N))
print("Vector AB =", list(AB))
print("Chosen normal direction =", list(normal_direction))
print("Dot product AB with normal direction =", AB.dot(normal_direction))
print("Parameter solution =", solution)
print("Intersection point =", list(intersection))
print("Distance to A squared =", sp.expand((intersection-A).dot(intersection-A)))
print("Distance to B squared =", sp.expand((intersection-B).dot(intersection-B)))
print("Distance to C squared =", sp.expand((intersection-sp.Matrix([1,4])).dot(intersection-sp.Matrix([1,4]))))

Utskrift fra Python:
Midpoint N of AB = [6, 1]
Vector AB = [6, 6]
Chosen normal direction = [1, -1]
Dot product AB with normal direction = 0
Parameter solution = {s: -1, t: 1}
Intersection point = [5, 2]
Distance to A squared = 20
Distance to B squared = 20
Distance to C squared = 20

import sympy as sp
x = sp.symbols("x", real=True)
left_solutions = sp.solve(sp.Eq(x**2, 1), x)
right_solutions = [sp.Integer(1)]
print("Solutions of x**2 = 1 =", left_solutions)
print("Solutions of x = 1 =", right_solutions)
print("Does x=1 imply x**2=1? =", sp.simplify(1**2) == 1)
print("Counterexample to the opposite direction: x = -1")
print("At x=-1, x**2 =", (-1)**2)
print("At x=-1, x=1 is", -1 == 1)
print("Correct relation: x**2 = 1  <=  x = 1")

Utskrift fra Python:
Solutions of x**2 = 1 = [-1, 1]
Solutions of x = 1 = [1]
Does x=1 imply x**2=1? = True
Counterexample to the opposite direction: x = -1
At x=-1, x**2 = 1
At x=-1, x=1 is False
Correct relation: x**2 = 1  <=  x = 1

import sympy as sp
x = sp.symbols("x", real=True)
C = sp.symbols("C", real=True)
f_left = 5*x**2 - 1
derivative = sp.diff(f_left, x)
general_antiderivative = sp.integrate(10*x, x) + C
counterexample = 5*x**2 + 7
print("Given function =", f_left)
print("Derivative of given function =", derivative)
print("General function with derivative 10*x =", general_antiderivative)
print("A counterexample function =", counterexample)
print("Derivative of counterexample =", sp.diff(counterexample, x))
print("Counterexample equals 5*x**2 - 1 =", sp.simplify(counterexample - f_left) == 0)
print("Correct relation: f(x)=5*x**2-1  =>  f'(x)=10*x")

Utskrift fra Python:
Given function = 5*x**2 - 1
Derivative of given function = 10*x
General function with derivative 10*x = C + 5*x**2
A counterexample function = 5*x**2 + 7
Derivative of counterexample = 10*x
Counterexample equals 5*x**2 - 1 = False
Correct relation: f(x)=5*x**2-1  =>  f'(x)=10*x

import sympy as sp
x, a = sp.symbols("x a", real=True)
f = sp.exp(1 - x)
f_prime = sp.diff(f, x)
f_a = f.subs(x, a)
slope_a = f_prime.subs(x, a)
tangent = sp.expand(f_a + slope_a*(x - a))
condition_at_origin = sp.simplify(tangent.subs(x, 0))
a_solution = sp.solve(sp.Eq(condition_at_origin, 0), a)
chosen_a = a_solution[0]
final_tangent = sp.simplify(tangent.subs(a, chosen_a))
print("f(x) =", f)
print("f'(x) =", f_prime)
print("Tangent at x=a =", tangent)
print("Tangent value at x=0 =", condition_at_origin)
print("Solution for a =", a_solution)
print("Point of tangency =", (chosen_a, sp.simplify(f.subs(x, chosen_a))))
print("Slope at tangency =", sp.simplify(f_prime.subs(x, chosen_a)))
print("Final tangent y =", final_tangent)
print("Check at origin =", final_tangent.subs(x, 0))

Utskrift fra Python:
f(x) = exp(1 - x)
f'(x) = -exp(1 - x)
Tangent at x=a = E*a*exp(-a) - E*x*exp(-a) + E*exp(-a)
Tangent value at x=0 = (a + 1)*exp(1 - a)
Solution for a = [-1]
Point of tangency = (-1, exp(2))
Slope at tangency = -exp(2)
Final tangent y = -x*exp(2)
Check at origin = 0

from fractions import Fraction
total_songs = 20
kygo_songs = 4
probability_fraction = Fraction(kygo_songs, total_songs)
probability_decimal = kygo_songs / total_songs
print("Total number of songs =", total_songs)
print("Number of Kygo songs =", kygo_songs)
print("Probability as a fraction =", probability_fraction)
print("Probability as a decimal =", probability_decimal)
print("Sampling method = with replacement")
print("The playlist composition after each play remains 4 of 20")
print("Probability on every play =", probability_decimal)

Utskrift fra Python:
Total number of songs = 20
Number of Kygo songs = 4
Probability as a fraction = 1/5
Probability as a decimal = 0.2
Sampling method = with replacement
The playlist composition after each play remains 4 of 20
Probability on every play = 0.2

import math
n = 5
k = 2
p = 0.2
q = 1 - p
combinations = math.comb(n, k)
power_success = p**k
power_failure = q**(n-k)
probability = combinations*power_success*power_failure
print("n =", n)
print("k =", k)
print("p =", p)
print("q =", q)
print("C(5,2) =", combinations)
print("p**2 =", power_success)
print("q**3 =", power_failure)
print("P(X=2) =", probability)
print("Percentage =", 100*probability)

Utskrift fra Python:
n = 5
k = 2
p = 0.2
q = 0.8
C(5,2) = 10
p**2 = 0.04000000000000001
q**3 = 0.5120000000000001
P(X=2) = 0.2048000000000001
Percentage = 20.48000000000001

import math
threshold = math.log(0.1) / math.log(0.8)
minimum_n = math.floor(threshold) + 1
probability_n_minus_1 = 1 - 0.8**(minimum_n - 1)
probability_n = 1 - 0.8**minimum_n
print("Solve 1 - 0.8**n > 0.9")
print("Equivalent inequality: 0.8**n < 0.1")
print("log(0.1) =", math.log(0.1))
print("log(0.8) =", math.log(0.8))
print("Threshold n >", threshold)
print("Smallest integer n =", minimum_n)
print("Probability for n=10 =", probability_n_minus_1)
print("Probability for n=11 =", probability_n)
print("n=11 satisfies the strict inequality =", probability_n > 0.9)

Utskrift fra Python:
Solve 1 - 0.8**n > 0.9
Equivalent inequality: 0.8**n < 0.1
log(0.1) = -2.3025850929940455
log(0.8) = -0.2231435513142097
Threshold n > 10.318851158516171
Smallest integer n = 11
Probability for n=10 = 0.8926258175999999
Probability for n=11 = 0.91410065408
n=11 satisfies the strict inequality = True

import sympy as sp
AB = sp.Matrix([6-3, 5-5])
AC = sp.Matrix([7-3, 9-5])
length_AB = sp.sqrt(AB.dot(AB))
length_AC = sp.sqrt(AC.dot(AC))
dot_product = AB.dot(AC)
cos_angle = sp.simplify(dot_product/(length_AB*length_AC))
angle_radians = sp.acos(cos_angle)
angle_degrees = sp.simplify(angle_radians*180/sp.pi)
print("Vector AB =", list(AB))
print("Vector AC =", list(AC))
print("Length AB =", length_AB)
print("Length AC =", length_AC)
print("Dot product AB dot AC =", dot_product)
print("cos(angle BAC) =", cos_angle)
print("Angle in radians =", angle_radians)
print("Angle in degrees =", angle_degrees)

Utskrift fra Python:
Vector AB = [3, 0]
Vector AC = [4, 4]
Length AB = 3
Length AC = 4*sqrt(2)
Dot product AB dot AC = 12
cos(angle BAC) = sqrt(2)/2
Angle in radians = pi/4
Angle in degrees = 45

import sympy as sp
A = sp.Matrix([3, 5])
B = sp.Matrix([6, 5])
C = sp.Matrix([7, 9])
sum_vector = A + B + C
T = sum_vector/3
print("A =", list(A))
print("B =", list(B))
print("C =", list(C))
print("A + B + C =", list(sum_vector))
print("Tyngdepunkt T =", list(T))
print("T as decimals =", [sp.N(value, 8) for value in T])
print("Average x-coordinate =", sp.Rational(3+6+7, 3))
print("Average y-coordinate =", sp.Rational(5+5+9, 3))

Utskrift fra Python:
A = [3, 5]
B = [6, 5]
C = [7, 9]
A + B + C = [16, 19]
Tyngdepunkt T = [16/3, 19/3]
T as decimals = [5.3333333, 6.3333333]
Average x-coordinate = 16/3
Average y-coordinate = 19/3

import sympy as sp
D = sp.Matrix([2, 3])
E = sp.Matrix([-3, 5])
S = sp.Matrix([4, 2])
three_S = 3*S
F = three_S - D - E
centroid_check = (D + E + F)/3
print("D =", list(D))
print("E =", list(E))
print("S =", list(S))
print("3*S =", list(three_S))
print("F = 3*S - D - E =", list(F))
print("Centroid check =", list(centroid_check))
print("Check equals S =", centroid_check == S)
print("F coordinates =", (F[0], F[1]))

Utskrift fra Python:
D = [2, 3]
E = [-3, 5]
S = [4, 2]
3*S = [12, 6]
F = 3*S - D - E = [13, -2]
Centroid check = [4, 2]
Check equals S = True
F coordinates = (13, -2)

import sympy as sp
x = sp.symbols("x", real=True)
f = 2*sp.log(x**2 + 4) - x/2
sample_points = [-4, 0, 4, 8, 16]
print("f(x) =", f)
print("Domain check: x**2 + 4 is always positive for real x")
print("Plot interval = [-4, 16]")
for value in sample_points:
    exact = sp.simplify(f.subs(x, value))
    decimal = sp.N(exact, 10)
    print("x =", value, "exact f(x) =", exact, "decimal =", decimal)
f_prime = sp.simplify(sp.diff(f, x))
print("f'(x) =", f_prime)
print("Stationary x-values =", sp.solve(sp.Eq(f_prime, 0), x))

Utskrift fra Python:
f(x) = -x/2 + 2*log(x**2 + 4)
Domain check: x**2 + 4 is always positive for real x
Plot interval = [-4, 16]
x = -4 exact f(x) = 2 + 2*log(20) decimal = 7.991464547
x = 0 exact f(x) = log(16) decimal = 2.772588722
x = 4 exact f(x) = -2 + 2*log(20) decimal = 3.991464547
x = 8 exact f(x) = -4 + 2*log(68) decimal = 4.439015410
x = 16 exact f(x) = -8 + 2*log(260) decimal = 3.121363262
f'(x) = (-x**2 + 8*x - 4)/(2*(x**2 + 4))
Stationary x-values = [4 - 2*sqrt(3), 2*sqrt(3) + 4]

import sympy as sp
x = sp.symbols("x", real=True)
f = 2*sp.log(x**2 + 4) - x/2
f_prime = sp.factor(sp.diff(f, x))
stationary = sp.solve(sp.Eq(f_prime, 0), x)
print("f(x) =", f)
print("f'(x) =", f_prime)
print("Stationary x-values =", stationary)
for value in stationary:
    y_value = sp.simplify(f.subs(x, value))
    second_derivative = sp.simplify(sp.diff(f, x, 2).subs(x, value))
    classification = "minimum" if second_derivative > 0 else "maximum"
    print("x =", value)
    print("  y exact =", y_value)
    print("  y decimal =", sp.N(y_value, 12))
    print("  f''(x) =", sp.N(second_derivative, 12))
    print("  classification =", classification)

Utskrift fra Python:
f(x) = -x/2 + 2*log(x**2 + 4)
f'(x) = -(x**2 - 8*x + 4)/(2*(x**2 + 4))
Stationary x-values = [4 - 2*sqrt(3), 2*sqrt(3) + 4]
x = 4 - 2*sqrt(3)
  y exact = -2 + sqrt(3) + log(256*(2 - sqrt(3))**2)
  y decimal = 2.64331245820
  f''(x) = 0.808012701892
  classification = minimum
x = 2*sqrt(3) + 4
  y exact = -2 - sqrt(3) + log(256*(sqrt(3) + 2)**2)
  y decimal = 4.44704243076
  f''(x) = -0.0580127018922
  classification = maximum

import sympy as sp
x, k = sp.symbols("x k", real=True)
g = 2*sp.log(x**2 + k) - x/2
g_prime = sp.simplify(sp.diff(g, x))
condition = sp.simplify(g_prime.subs(x, 1))
k_solution = sp.solve(sp.Eq(condition, 0), k)
chosen_k = k_solution[0]
critical_for_k = sp.solve(sp.Eq(g_prime.subs(k, chosen_k), 0), x)
print("g(x) =", g)
print("g'(x) =", g_prime)
print("g'(1) =", condition)
print("Solution for k =", k_solution)
print("k > 0 check =", chosen_k > 0)
print("Critical x-values when k=7 =", critical_for_k)
print("Derivative at x=0 =", sp.N(g_prime.subs({k: chosen_k, x: 0})))
print("Derivative at x=2 =", sp.N(g_prime.subs({k: chosen_k, x: 2})))
print("Therefore x=1 changes from decreasing to increasing")

Utskrift fra Python:
g(x) = -x/2 + 2*log(k + x**2)
g'(x) = (-k - x**2 + 8*x)/(2*(k + x**2))
g'(1) = (7 - k)/(2*(k + 1))
Solution for k = [7]
k > 0 check = True
Critical x-values when k=7 = [1, 7]
Derivative at x=0 = -0.500000000000000
Derivative at x=2 = 0.227272727272727
Therefore x=1 changes from decreasing to increasing

import sympy as sp
x, k = sp.symbols("x k", real=True, positive=True)
g_prime_numerator = -x**2 + 8*x - k
discriminant = sp.discriminant(x**2 - 8*x + k, x)
roots = sp.solve(sp.Eq(x**2 - 8*x + k, 0), x)
print("Equation for stationary points: x**2 - 8*x + k = 0")
print("Discriminant =", discriminant)
print("Formal roots =", roots)
print("For 0 < k < 16: discriminant > 0, so there are two distinct roots")
print("Example k=7 roots =", sp.solve(sp.Eq(x**2 - 8*x + 7, 0), x))
print("For k=16: factored numerator =", sp.factor(g_prime_numerator.subs(k, 16)))
print("At k=16 the derivative is non-positive on both sides of x=4")
print("For k>16: discriminant < 0, so there are no stationary points")
print("Conclusion: 2 extrema for 0<k<16 and 0 extrema for k>=16")

Utskrift fra Python:
Equation for stationary points: x**2 - 8*x + k = 0
Discriminant = 64 - 4*k
Formal roots = [4 - sqrt(16 - k), sqrt(16 - k) + 4]
For 0 < k < 16: discriminant > 0, so there are two distinct roots
Example k=7 roots = [1, 7]
For k=16: factored numerator = -(x - 4)**2
At k=16 the derivative is non-positive on both sides of x=4
For k>16: discriminant < 0, so there are no stationary points
Conclusion: 2 extrema for 0<k<16 and 0 extrema for k>=16

import sympy as sp
t = sp.symbols("t", real=True)
position = sp.Matrix([80 + 4*t, 16 + 3*t])
velocity = position.diff(t)
speed = sp.sqrt(velocity.dot(velocity))
meters_per_hour = speed*1852
meters_per_second = sp.N(meters_per_hour/3600, 10)
print("Position vector OP(t) =", list(position))
print("Derivative of x-component =", sp.diff(position[0], t))
print("Derivative of y-component =", sp.diff(position[1], t))
print("Velocity vector v =", list(velocity), "nm/h")
print("Speed squared =", velocity.dot(velocity))
print("Speed =", speed, "nm/h")
print("Speed =", meters_per_hour, "m/h")
print("Speed in m/s =", meters_per_second)

Utskrift fra Python:
Position vector OP(t) = [4*t + 80, 3*t + 16]
Derivative of x-component = 4
Derivative of y-component = 3
Velocity vector v = [4, 3] nm/h
Speed squared = 25
Speed = 5 nm/h
Speed = 9260 m/h
Speed in m/s = 2.572222222

import sympy as sp
t_meeting = sp.Integer(4)
P4 = sp.Matrix([80 + 4*t_meeting, 16 + 3*t_meeting])
distance_squared = P4.dot(P4)
distance = sp.sqrt(distance_squared)
rescue_speed = sp.simplify(distance/t_meeting)
rescue_velocity = P4/t_meeting
print("Meeting time =", t_meeting, "hours")
print("Euler position after 4 hours =", list(P4))
print("Distance squared from O =", distance_squared)
print("Distance from O =", distance, "nm")
print("Required velocity vector =", list(rescue_velocity), "nm/h")
print("Length of velocity vector =", sp.sqrt(rescue_velocity.dot(rescue_velocity)))
print("Required speed =", rescue_speed, "nm/h")
print("Distance check: speed * time =", rescue_speed*t_meeting, "nm")

Utskrift fra Python:
Meeting time = 4 hours
Euler position after 4 hours = [96, 28]
Distance squared from O = 10000
Distance from O = 100 nm
Required velocity vector = [24, 7] nm/h
Length of velocity vector = 25
Required speed = 25 nm/h
Distance check: speed * time = 100 nm

import sympy as sp
t = sp.symbols("t", real=True)
P = sp.Matrix([80 + 4*t, 16 + 3*t])
Q = sp.Matrix([-10, 50])
displacement = P - Q
distance_squared = sp.expand(displacement.dot(displacement))
reachable_squared = (35*t)**2
equation_polynomial = sp.expand(distance_squared - reachable_squared)
solutions = sp.solve(sp.Eq(equation_polynomial, 0), t)
positive_solution = [s for s in solutions if sp.N(s) > 0][0]
meeting_position = sp.simplify(P.subs(t, positive_solution))
meeting_distance = sp.sqrt(distance_squared.subs(t, positive_solution))
print("Displacement QP(t) =", list(displacement))
print("Distance squared =", distance_squared)
print("Reachable distance squared =", reachable_squared)
print("Equation polynomial =", equation_polynomial)
print("Exact solutions =", solutions)
print("Decimal solutions =", [sp.N(s, 12) for s in solutions])
print("Positive meeting time =", sp.N(positive_solution, 12), "hours")
print("Meeting position =", [sp.N(value, 10) for value in meeting_position])
print("Distance from Q at meeting =", sp.N(meeting_distance, 12), "nm")
print("35*t at meeting =", sp.N(35*positive_solution, 12), "nm")

Utskrift fra Python:
Displacement QP(t) = [4*t + 90, 3*t - 34]
Distance squared = 25*t**2 + 516*t + 9256
Reachable distance squared = 1225*t**2
Equation polynomial = -1200*t**2 + 516*t + 9256
Exact solutions = [43/200 - 7*sqrt(57009)/600, 43/200 + 7*sqrt(57009)/600]
Decimal solutions = [-2.57059837976, 3.00059837976]
Positive meeting time = 3.00059837976 hours
Meeting position = [92.00239352, 25.00179514]
Distance from Q at meeting = 105.020943292 nm
35*t at meeting = 105.020943292 nm