import sympy as sp
x = sp.symbols("x", real=True)
polynomial_part = x**2 + 2*x
exponential_part = sp.exp(x)
f = polynomial_part + exponential_part
polynomial_derivative = sp.diff(polynomial_part, x)
exponential_derivative = sp.diff(exponential_part, x)
derivative = sp.diff(f, x)
print("Polynomial part =", polynomial_part)
print("Exponential part =", exponential_part)
print("Derivative of polynomial part =", polynomial_derivative)
print("Derivative of exponential part =", exponential_derivative)
print("f'(x) =", derivative)
print("Difference from 2*x + 2 + exp(x) =", sp.simplify(derivative-(2*x+2+sp.exp(x))))

Utskrift fra Python:
Polynomial part = x**2 + 2*x
Exponential part = exp(x)
Derivative of polynomial part = 2*x + 2
Derivative of exponential part = exp(x)
f'(x) = 2*x + exp(x) + 2
Difference from 2*x + 2 + exp(x) = 0

import sympy as sp
x = sp.symbols("x", positive=True)
u = x**2
v = sp.log(x)
u_prime = sp.diff(u, x)
v_prime = sp.diff(v, x)
product_rule = sp.expand(u_prime*v + u*v_prime)
direct_derivative = sp.diff(u*v, x)
print("u(x) =", u)
print("v(x) =", v)
print("u'(x) =", u_prime)
print("v'(x) =", v_prime)
print("Product-rule result =", product_rule)
print("Factored result =", sp.factor(product_rule))
print("Direct derivative check =", direct_derivative)
print("Difference check =", sp.simplify(product_rule-direct_derivative))

Utskrift fra Python:
u(x) = x**2
v(x) = log(x)
u'(x) = 2*x
v'(x) = 1/x
Product-rule result = 2*x*log(x) + x
Factored result = x*(2*log(x) + 1)
Direct derivative check = 2*x*log(x) + x
Difference check = 0

import sympy as sp
x = sp.symbols("x", real=True)
numerator = x - 1
denominator = sp.exp(2*x + 1)
h = numerator / denominator
rewritten = numerator * sp.exp(-(2*x + 1))
product_rule = sp.diff(numerator, x)*sp.exp(-(2*x+1)) + numerator*sp.diff(sp.exp(-(2*x+1)), x)
derivative = sp.simplify(sp.diff(h, x))
print("Numerator =", numerator)
print("Denominator =", denominator)
print("Rewritten h(x) =", rewritten)
print("Product-rule expression =", sp.expand(product_rule))
print("Simplified derivative =", derivative)
print("Expected form =", (3-2*x)/sp.exp(2*x+1))
print("Difference check =", sp.simplify(derivative-(3-2*x)/sp.exp(2*x+1)))

Utskrift fra Python:
Numerator = x - 1
Denominator = exp(2*x + 1)
Rewritten h(x) = (x - 1)*exp(-2*x - 1)
Product-rule expression = -2*x*exp(-1)*exp(-2*x) + 3*exp(-1)*exp(-2*x)
Simplified derivative = (3 - 2*x)*exp(-2*x - 1)
Expected form = (3 - 2*x)*exp(-2*x - 1)
Difference check = 0

import sympy as sp
x, u = sp.symbols("x u", real=True)
quadratic = u**2 + 7*u - 8
factored = sp.factor(quadratic)
u_solutions = sp.solve(sp.Eq(quadratic, 0), u)
positive_u = [value for value in u_solutions if value.is_positive]
x_solutions = [sp.log(value) for value in positive_u]
original = sp.exp(2*x) + 7*sp.exp(x) - 8
print("Quadratic in u =", quadratic)
print("Factored quadratic =", factored)
print("All u-solutions =", u_solutions)
print("Positive u-solutions =", positive_u)
print("Corresponding x-solutions =", x_solutions)
for value in x_solutions:
    print("Check at x =", value, ":", sp.simplify(original.subs(x, value)))

Utskrift fra Python:
Quadratic in u = u**2 + 7*u - 8
Factored quadratic = (u - 1)*(u + 8)
All u-solutions = [-8, 1]
Positive u-solutions = [1]
Corresponding x-solutions = [0]
Check at x = 0 : 0

import sympy as sp
x = sp.symbols("x", real=True)
arg1 = x**2 - 5*x - 1
arg2 = 3 - 2*x
algebraic_equation = sp.expand(arg1 - arg2)
candidates = sp.solve(sp.Eq(arg1, arg2), x)
valid = [value for value in candidates if bool(arg1.subs(x,value)>0) and bool(arg2.subs(x,value)>0)]
print("First logarithm argument =", arg1)
print("Second logarithm argument =", arg2)
print("Equation after equal arguments =", algebraic_equation)
print("Candidates =", candidates)
for value in candidates:
    print("x =", value, "gives arguments", arg1.subs(x,value), "and", arg2.subs(x,value))
print("Valid solutions =", valid)
for value in valid:
    print("Original expression at x =", value, "is", sp.simplify(sp.log(arg1.subs(x,value))-sp.log(arg2.subs(x,value))))

Utskrift fra Python:
First logarithm argument = x**2 - 5*x - 1
Second logarithm argument = 3 - 2*x
Equation after equal arguments = x**2 - 3*x - 4
Candidates = [-1, 4]
x = -1 gives arguments 5 and 5
x = 4 gives arguments -5 and -5
Valid solutions = [-1]
Original expression at x = -1 is 0

import sympy as sp
a = sp.Matrix([2, 3])
b = sp.Matrix([-5, 3])
two_b = 2*b
three_a = 3*a
result = two_b - three_a
print("a =", list(a))
print("b =", list(b))
print("2*b =", list(two_b))
print("3*a =", list(three_a))
print("2*b - 3*a =", list(result))
print("Component check =", [2*b[i]-3*a[i] for i in range(2)])

Utskrift fra Python:
a = [2, 3]
b = [-5, 3]
2*b = [-10, 6]
3*a = [6, 9]
2*b - 3*a = [-16, -3]
Component check = [-16, -3]

import sympy as sp
a = sp.Matrix([2, 3])
length_squared = a.dot(a)
length = sp.sqrt(length_squared)
comparison_value = sp.Integer(4)
comparison = sp.simplify(length < comparison_value)
print("a =", list(a))
print("Length squared =", length_squared)
print("Exact length =", length)
print("Decimal length =", sp.N(length, 12))
print("Comparison value =", comparison_value)
print("Is |a| > 4?", bool(length > comparison_value))
print("Is |a| < 4?", bool(comparison))

Utskrift fra Python:
a = [2, 3]
Length squared = 13
Exact length = sqrt(13)
Decimal length = 3.60555127546
Comparison value = 4
Is |a| > 4? False
Is |a| < 4? True

import sympy as sp
a = sp.Matrix([2, 3])
b = sp.Matrix([-5, 3])
dot_product = a.dot(b)
length_a = sp.sqrt(a.dot(a))
length_b = sp.sqrt(b.dot(b))
cosine = sp.simplify(dot_product/(length_a*length_b))
angle = sp.acos(cosine)
print("a =", list(a))
print("b =", list(b))
print("Dot product =", dot_product)
print("|a| =", length_a)
print("|b| =", length_b)
print("Exact cosine =", cosine)
print("Angle in degrees =", sp.N(angle*180/sp.pi, 12))
print("Angle classification =", "obtuse" if dot_product < 0 else "right" if dot_product == 0 else "acute")

Utskrift fra Python:
a = [2, 3]
b = [-5, 3]
Dot product = -1
|a| = sqrt(13)
|b| = sqrt(34)
Exact cosine = -sqrt(442)/442
Angle in degrees = 92.7263109939
Angle classification = obtuse

import sympy as sp
x = sp.symbols("x", real=True)
f = x**3 + 6*x**2 - x - 30
divisor = x - 2
value_at_two = sp.expand(f.subs(x, 2))
quotient, remainder = sp.div(f, divisor)
reconstructed = sp.expand(divisor*quotient + remainder)
print("f(x) =", f)
print("f(2) =", value_at_two)
print("Divisor =", divisor)
print("Quotient =", quotient)
print("Remainder =", remainder)
print("Reconstructed polynomial =", reconstructed)
print("Difference check =", sp.expand(f-reconstructed))

Utskrift fra Python:
f(x) = x**3 + 6*x**2 - x - 30
f(2) = 0
Divisor = x - 2
Quotient = x**2 + 8*x + 15
Remainder = 0
Reconstructed polynomial = x**3 + 6*x**2 - x - 30
Difference check = 0

import sympy as sp
x = sp.symbols("x", real=True)
f = x**3 + 6*x**2 - x - 30
known_factor = x - 2
quotient = sp.div(f, known_factor)[0]
factored_quotient = sp.factor(quotient)
full_factorization = sp.factor(f)
roots = sp.solve(sp.Eq(f, 0), x)
print("f(x) =", f)
print("Known factor =", known_factor)
print("Quadratic quotient =", quotient)
print("Factored quotient =", factored_quotient)
print("Full factorization =", full_factorization)
print("Roots =", roots)
print("Expansion check =", sp.expand(full_factorization))

Utskrift fra Python:
f(x) = x**3 + 6*x**2 - x - 30
Known factor = x - 2
Quadratic quotient = x**2 + 8*x + 15
Factored quotient = (x + 3)*(x + 5)
Full factorization = (x - 2)*(x + 3)*(x + 5)
Roots = [-5, -3, 2]
Expansion check = x**3 + 6*x**2 - x - 30

import sympy as sp
x = sp.symbols("x", real=True)
f = (x+5)*(x+3)*(x-2)
expression = -2*f
solution = sp.solve_univariate_inequality(expression >= 0, x)
test_points = [-6, -4, 0, 3]
print("Factored f(x) =", f)
print("Inequality expression =", sp.expand(expression))
print("Equivalent condition is f(x) <= 0")
print("Roots =", sp.solve(sp.Eq(f, 0), x))
for point in test_points:
    print("f(", point, ") =", f.subs(x, point))
print("Solution set =", solution)

Utskrift fra Python:
Factored f(x) = (x - 2)*(x + 3)*(x + 5)
Inequality expression = -2*x**3 - 12*x**2 + 2*x + 60
Equivalent condition is f(x) <= 0
Roots = [-5, -3, 2]
f( -6 ) = -24
f( -4 ) = 6
f( 0 ) = -30
f( 3 ) = 48
Solution set = (x <= -5) | ((-3 <= x) & (x <= 2))

import sympy as sp
p_man = sp.Rational(70, 100)
p_woman = 1 - p_man
p_fir_given_man = sp.Rational(60, 100)
p_fir_given_woman = sp.Rational(40, 100)
man_branch = p_man*p_fir_given_man
woman_branch = p_woman*p_fir_given_woman
p_fir = sp.simplify(man_branch + woman_branch)
print("P(man) =", p_man)
print("P(woman) =", p_woman)
print("P(man and fir) =", man_branch)
print("P(woman and fir) =", woman_branch)
print("P(fir) =", p_fir)
print("Decimal probability =", sp.N(p_fir, 12))
print("Percentage =", sp.N(100*p_fir, 12))

Utskrift fra Python:
P(man) = 7/10
P(woman) = 3/10
P(man and fir) = 21/50
P(woman and fir) = 3/25
P(fir) = 27/50
Decimal probability = 0.540000000000
Percentage = 54.0000000000

import sympy as sp
p_woman = sp.Rational(3, 10)
p_fir_given_woman = sp.Rational(2, 5)
p_woman_and_fir = p_woman*p_fir_given_woman
p_fir = sp.Rational(54, 100)
conditional = sp.simplify(p_woman_and_fir/p_fir)
print("P(woman) =", p_woman)
print("P(fir | woman) =", p_fir_given_woman)
print("P(woman and fir) =", p_woman_and_fir)
print("P(fir) =", p_fir)
print("P(woman | fir) =", conditional)
print("Decimal probability =", sp.N(conditional, 12))
print("Percentage =", sp.N(100*conditional, 12))

Utskrift fra Python:
P(woman) = 3/10
P(fir | woman) = 2/5
P(woman and fir) = 3/25
P(fir) = 27/50
P(woman | fir) = 2/9
Decimal probability = 0.222222222222
Percentage = 22.2222222222

import sympy as sp
a, x = sp.symbols("a x", real=True)
left_branch = 2*x**2 - 3*x - 2
right_branch = x**2 + x + 3
left_value = sp.expand(left_branch.subs(x, a))
right_limit = sp.expand(right_branch.subs(x, a))
continuity_polynomial = sp.expand(left_value-right_limit)
solutions = sp.solve(sp.Eq(left_value, right_limit), a)
print("Left branch =", left_branch)
print("Right branch =", right_branch)
print("f(a) from left branch =", left_value)
print("Right-hand limit at a =", right_limit)
print("Continuity polynomial =", continuity_polynomial)
print("Factored equation =", sp.factor(continuity_polynomial))
print("Solutions for a =", solutions)
for value in solutions:
    print("a =", value, "gives common value", left_value.subs(a,value))

Utskrift fra Python:
Left branch = 2*x**2 - 3*x - 2
Right branch = x**2 + x + 3
f(a) from left branch = 2*a**2 - 3*a - 2
Right-hand limit at a = a**2 + a + 3
Continuity polynomial = a**2 - 4*a - 5
Factored equation = (a - 5)*(a + 1)
Solutions for a = [-1, 5]
a = -1 gives common value 3
a = 5 gives common value 33

import sympy as sp
x = sp.symbols("x", real=True)
inner = x**2 + 3
g = x - 2*sp.log(inner)
inner_derivative = sp.diff(inner, x)
log_derivative = inner_derivative/inner
derivative_sum_form = 1 - 2*log_derivative
derivative_fraction = sp.factor(sp.together(derivative_sum_form))
direct = sp.diff(g, x)
print("Inner function =", inner)
print("Inner derivative =", inner_derivative)
print("g(x) =", g)
print("Derivative in sum form =", derivative_sum_form)
print("Derivative as one fraction =", derivative_fraction)
print("Direct derivative =", direct)
print("Difference check =", sp.simplify(direct-derivative_fraction))

Utskrift fra Python:
Inner function = x**2 + 3
Inner derivative = 2*x
g(x) = x - 2*log(x**2 + 3)
Derivative in sum form = -4*x/(x**2 + 3) + 1
Derivative as one fraction = (x - 3)*(x - 1)/(x**2 + 3)
Direct derivative = -4*x/(x**2 + 3) + 1
Difference check = 0

import sympy as sp
x = sp.symbols("x", real=True)
g = x - 2*sp.log(x**2 + 3)
g_prime = sp.factor(sp.diff(g, x))
critical = sp.solve(sp.Eq(sp.together(g_prime).as_numer_denom()[0], 0), x)
test_points = [0, 2, 4]
signs = [sp.sign(sp.N(g_prime.subs(x, value))) for value in test_points]
print("g(x) =", g)
print("g'(x) =", g_prime)
print("Critical x-values =", critical)
for point, sign in zip(test_points, signs):
    print("Sign of g' at x =", point, "is", sign)
print("g(1) =", sp.simplify(g.subs(x, 1)))
print("g(3) =", sp.simplify(g.subs(x, 3)))
print("Classification: x=1 maximum, x=3 minimum")

Utskrift fra Python:
g(x) = x - 2*log(x**2 + 3)
g'(x) = (x - 3)*(x - 1)/(x**2 + 3)
Critical x-values = [1, 3]
Sign of g' at x = 0 is 1
Sign of g' at x = 2 is -1
Sign of g' at x = 4 is 1
g(1) = 1 - log(16)
g(3) = 3 - log(144)
Classification: x=1 maximum, x=3 minimum

import sympy as sp
x = sp.symbols("x", real=True)
g = x - 2*sp.log(x**2 + 3)
g_second = sp.factor(sp.diff(g, x, 2))
numerator, denominator = sp.together(g_second).as_numer_denom()
candidates = sp.solve(sp.Eq(numerator, 0), x)
test_points = [-2, 0, 2]
print("g(x) =", g)
print("g''(x) =", g_second)
print("Numerator =", sp.factor(numerator))
print("Denominator =", denominator)
print("Candidates =", candidates)
for point in test_points:
    print("Sign of g'' at x =", point, "is", sp.sign(g_second.subs(x, point)))
print("Inflection x-values =", candidates)

Utskrift fra Python:
g(x) = x - 2*log(x**2 + 3)
g''(x) = 4*(x**2 - 3)/(x**2 + 3)**2
Numerator = 4*(x**2 - 3)
Denominator = (x**2 + 3)**2
Candidates = [-sqrt(3), sqrt(3)]
Sign of g'' at x = -2 is 1
Sign of g'' at x = 0 is -1
Sign of g'' at x = 2 is 1
Inflection x-values = [-sqrt(3), sqrt(3)]

import sympy as sp
x, y = sp.symbols("x y", real=True)
A = sp.Point(0, 0)
B = sp.Point(8, 0)
solutions = sp.solve([sp.Eq(x**2+y**2, 25), sp.Eq((x-8)**2+y**2, 49)], [x, y])
C = sp.Point(sp.Rational(5,2), 5*sp.sqrt(3)/2)
print("A =", A)
print("B =", B)
print("Circle-intersection solutions =", solutions)
print("Chosen C =", C)
print("AB =", A.distance(B))
print("AC =", sp.simplify(A.distance(C)))
print("BC =", sp.simplify(B.distance(C)))
print("Triangle area =", sp.Triangle(A,B,C).area)

Utskrift fra Python:
A = Point2D(0, 0)
B = Point2D(8, 0)
Circle-intersection solutions = [(5/2, -5*sqrt(3)/2), (5/2, 5*sqrt(3)/2)]
Chosen C = Point2D(5/2, 5*sqrt(3)/2)
AB = 8
AC = 5
BC = 7
Triangle area = 10*sqrt(3)

import sympy as sp
A = sp.Point(0, 0)
B = sp.Point(8, 0)
C = sp.Point(sp.Rational(5,2), 5*sp.sqrt(3)/2)
a = B.distance(C)
b = A.distance(C)
c = A.distance(B)
I = sp.Point((a*A.x+b*B.x+c*C.x)/(a+b+c), (a*A.y+b*B.y+c*C.y)/(a+b+c))
area = sp.Triangle(A,B,C).area
semiperimeter = (a+b+c)/2
inradius = sp.simplify(area/semiperimeter)
print("Side lengths a,b,c =", a, b, c)
print("Semiperimeter =", semiperimeter)
print("Area =", area)
print("Incenter I =", I)
print("Inradius =", inradius)
print("Distance from I to AB =", sp.Line(A,B).distance(I))
print("Distance from I to AC =", sp.Line(A,C).distance(I))
print("Distance from I to BC =", sp.Line(B,C).distance(I))

Utskrift fra Python:
Side lengths a,b,c = 7 5 8
Semiperimeter = 10
Area = 10*sqrt(3)
Incenter I = Point2D(3, sqrt(3))
Inradius = sqrt(3)
Distance from I to AB = sqrt(3)
Distance from I to AC = sqrt(3)
Distance from I to BC = sqrt(3)

import sympy as sp
A = sp.Point(0, 0)
C = sp.Point(sp.Rational(5,2), 5*sp.sqrt(3)/2)
D = sp.Point(sp.Rational(18,5), sp.Rational(-24,5))
AD = sp.simplify(A.distance(D))
CD = sp.simplify(C.distance(D))
DA = sp.Matrix(A-D)
DC = sp.Matrix(C-D)
cos_angle = sp.simplify(DA.dot(DC)/(sp.sqrt(DA.dot(DA))*sp.sqrt(DC.dot(DC))))
angle = sp.acos(cos_angle)
print("A =", A)
print("C =", C)
print("Chosen D =", D)
print("AD =", AD)
print("CD =", CD)
print("Is AD < CD?", bool(AD < CD))
print("cos(angle ADC) =", cos_angle)
print("angle ADC in degrees =", sp.N(angle*180/sp.pi, 12))

Utskrift fra Python:
A = Point2D(0, 0)
C = Point2D(5/2, 5*sqrt(3)/2)
Chosen D = Point2D(18/5, -24/5)
AD = 6
CD = sqrt(24*sqrt(3) + 43)
Is AD < CD? True
cos(angle ADC) = (4*sqrt(3) + 9)/(2*sqrt(24*sqrt(3) + 43))
angle ADC in degrees = 30.0000000000

import sympy as sp
n = 10
k = 5
p = sp.Rational(2, 5)
q = 1 - p
combination = sp.binomial(n, k)
probability = sp.simplify(combination*p**k*q**(n-k))
print("n =", n)
print("k =", k)
print("p =", p)
print("q =", q)
print("C(10,5) =", combination)
print("Exact probability =", probability)
print("Decimal probability =", sp.N(probability, 14))
print("Percentage =", sp.N(100*probability, 12))

Utskrift fra Python:
n = 10
k = 5
p = 2/5
q = 3/5
C(10,5) = 252
Exact probability = 1959552/9765625
Decimal probability = 0.20065812480000
Percentage = 20.0658124800

import sympy as sp
n = 10
p = sp.Rational(2, 5)
q = 1 - p
terms = [sp.binomial(n,k)*p**k*q**(n-k) for k in range(6,11)]
tail_probability = sp.simplify(sum(terms))
cumulative_to_five = sp.simplify(sum(sp.binomial(n,k)*p**k*q**(n-k) for k in range(0,6)))
print("n =", n)
print("p =", p)
print("k-values included =", list(range(6,11)))
for k, term in zip(range(6,11), terms):
    print("P(X =", k, ") =", sp.N(term, 12))
print("Exact upper-tail probability =", tail_probability)
print("Decimal upper-tail probability =", sp.N(tail_probability, 14))
print("Complement check =", sp.simplify(1-cumulative_to_five))

Utskrift fra Python:
n = 10
p = 2/5
k-values included = [6, 7, 8, 9, 10]
P(X = 6 ) = 0.111476736000
P(X = 7 ) = 0.0424673280000
P(X = 8 ) = 0.0106168320000
P(X = 9 ) = 0.00157286400000
P(X = 10 ) = 0.000104857600000
Exact upper-tail probability = 1623424/9765625
Decimal upper-tail probability = 0.16623861760000
Complement check = 1623424/9765625

import math
n_positions = 10
yellow_plants = 4
red_plants = 6
arrangements_choose_yellow = math.comb(n_positions, yellow_plants)
arrangements_multinomial = math.factorial(n_positions)//(math.factorial(yellow_plants)*math.factorial(red_plants))
print("Number of positions =", n_positions)
print("Identical yellow plants =", yellow_plants)
print("Identical red plants =", red_plants)
print("Choose yellow positions =", arrangements_choose_yellow)
print("Multinomial calculation =", arrangements_multinomial)
print("10! =", math.factorial(10))
print("4!*6! =", math.factorial(4)*math.factorial(6))
print("Methods agree?", arrangements_choose_yellow == arrangements_multinomial)

Utskrift fra Python:
Number of positions = 10
Identical yellow plants = 4
Identical red plants = 6
Choose yellow positions = 210
Multinomial calculation = 210
10! = 3628800
4!*6! = 17280
Methods agree? True

import sympy as sp
# Exact coordinate model for a=6, b=7, c=10
A = sp.Point(0, 0)
B = sp.Point(10, 0)
C = sp.Point(sp.Rational(113,20), 3*sp.sqrt(759)/20)
D = sp.Point(sp.Rational(70,13), 0)
E = sp.Point(sp.Rational(203,40), -7*sp.sqrt(759)/40)
direction_ED = sp.Matrix(D-E)
direction_EA = sp.Matrix(A-E)
direction_CD = sp.Matrix(D-C)
direction_CB = sp.Matrix(B-C)
def cosine(u,v):
    return sp.simplify(u.dot(v)/(sp.sqrt(u.dot(u))*sp.sqrt(v.dot(v))))
parallel_test = sp.simplify(direction_EA[0]*direction_CB[1]-direction_EA[1]*direction_CB[0])
print("A, B, C, D, E =", A, B, C, D, E)
print("Direction ED =", list(direction_ED))
print("Direction EA =", list(direction_EA))
print("Direction CD =", list(direction_CD))
print("Direction CB =", list(direction_CB))
print("EA x CB determinant =", parallel_test)
print("EA parallel to CB?", parallel_test == 0)
print("cos(angle DEA) =", cosine(direction_ED,direction_EA))
print("cos(angle DCB) =", cosine(direction_CD,direction_CB))
print("Cosine difference =", sp.simplify(cosine(direction_ED,direction_EA)-cosine(direction_CD,direction_CB)))

Utskrift fra Python:
A, B, C, D, E = Point2D(0, 0) Point2D(10, 0) Point2D(113/20, 3*sqrt(759)/20) Point2D(70/13, 0) Point2D(203/40, -7*sqrt(759)/40)
Direction ED = [161/520, 7*sqrt(759)/40]
Direction EA = [-203/40, 7*sqrt(759)/40]
Direction CD = [-69/260, -3*sqrt(759)/20]
Direction CB = [87/20, -3*sqrt(759)/20]
EA x CB determinant = 0
EA parallel to CB? True
cos(angle DEA) = sqrt(322)/28
cos(angle DCB) = sqrt(322)/28
Cosine difference = 0

import sympy as sp
# Symbolic angle labels are enough for the AA argument
angle_AED = sp.Symbol("alpha", positive=True)
angle_BCD = angle_AED
angle_ADE = sp.Symbol("beta", positive=True)
angle_BDC = angle_ADE
angle_EAD = sp.pi-angle_AED-angle_ADE
angle_CBD = sp.pi-angle_BCD-angle_BDC
print("angle AED =", angle_AED)
print("angle BCD =", angle_BCD)
print("angle ADE =", angle_ADE)
print("angle BDC =", angle_BDC)
print("Third angle EAD =", angle_EAD)
print("Third angle CBD =", angle_CBD)
print("Third angles equal?", sp.simplify(angle_EAD-angle_CBD) == 0)
print("Similarity correspondence = E<->C, D<->D, A<->B")

Utskrift fra Python:
angle AED = alpha
angle BCD = alpha
angle ADE = beta
angle BDC = beta
Third angle EAD = -alpha - beta + pi
Third angle CBD = -alpha - beta + pi
Third angles equal? True
Similarity correspondence = E<->C, D<->D, A<->B

import sympy as sp
alpha = sp.Symbol("alpha", positive=True)
angle_ACE = alpha
angle_ECB = alpha
angle_AEC = angle_ECB
angle_CAE = sp.pi-angle_ACE-angle_AEC
print("angle ACE =", angle_ACE)
print("angle ECB =", angle_ECB)
print("angle AEC =", angle_AEC)
print("angle ACE - angle AEC =", sp.simplify(angle_ACE-angle_AEC))
print("Third angle CAE =", angle_CAE)
print("Equal opposite sides: AE = AC")
print("Triangle AEC is isosceles?", sp.simplify(angle_ACE-angle_AEC) == 0)

Utskrift fra Python:
angle ACE = alpha
angle ECB = alpha
angle AEC = alpha
angle ACE - angle AEC = 0
Third angle CAE = pi - 2*alpha
Equal opposite sides: AE = AC
Triangle AEC is isosceles? True

import sympy as sp
AD, DB, AE, AC, BC, a, b = sp.symbols("AD DB AE AC BC a b", positive=True)
ratio_from_similarity = AE/BC
substitute_isosceles = ratio_from_similarity.subs(AE, AC)
substitute_labels = substitute_isosceles.subs({AC:b, BC:a})
print("Similarity gives AD/DB = AE/BC")
print("Right-hand ratio =", ratio_from_similarity)
print("Using AE = AC gives =", substitute_isosceles)
print("Using AC = b and BC = a gives =", substitute_labels)
print("Final relation: AD/DB =", substitute_labels)
print("Cross-multiplied form: a*AD = b*DB")

Utskrift fra Python:
Similarity gives AD/DB = AE/BC
Right-hand ratio = AE/BC
Using AE = AC gives = AC/BC
Using AC = b and BC = a gives = b/a
Final relation: AD/DB = b/a
Cross-multiplied form: a*AD = b*DB

import sympy as sp
AD, DB, k = sp.symbols("AD DB k", positive=True)
a = sp.Integer(6)
b = sp.Integer(7)
c = sp.Integer(10)
solution = sp.solve([sp.Eq(AD/DB,b/a), sp.Eq(AD+DB,c)], [AD,DB], dict=True)[0]
k_value = sp.solve(sp.Eq((7+6)*k,c), k)[0]
print("a =", a)
print("b =", b)
print("c =", c)
print("Ratio b/a =", sp.Rational(b,a))
print("k =", k_value)
print("AD =", solution[AD])
print("DB =", solution[DB])
print("Sum check =", sp.simplify(solution[AD]+solution[DB]))
print("Ratio check =", sp.simplify(solution[AD]/solution[DB]))

Utskrift fra Python:
a = 6
b = 7
c = 10
Ratio b/a = 7/6
k = 10/13
AD = 70/13
DB = 60/13
Sum check = 10
Ratio check = 7/6

import sympy as sp
s = sp.symbols("s", real=True)
A = sp.Matrix([3, 0])
B = sp.Matrix([5, 5])
direction = B - A
parametric_point = A + s*direction
point_at_zero = parametric_point.subs(s, 0)
point_at_one = parametric_point.subs(s, 1)
standard_form = sp.expand(5*parametric_point[0]-2*parametric_point[1]-15)
print("A =", list(A))
print("B =", list(B))
print("Direction vector B-A =", list(direction))
print("Parametric point =", list(parametric_point))
print("At s=0 =", list(point_at_zero))
print("At s=1 =", list(point_at_one))
print("Standard-form check 5x-2y-15 =", standard_form)

Utskrift fra Python:
A = [3, 0]
B = [5, 5]
Direction vector B-A = [2, 5]
Parametric point = [2*s + 3, 5*s]
At s=0 = [3, 0]
At s=1 = [5, 5]
Standard-form check 5x-2y-15 = 0

import sympy as sp
t, x = sp.symbols("t x", real=True)
r = sp.Matrix([t+1, t**2+2])
parameter_from_x = sp.solve(sp.Eq(x, r[0]), t)[0]
cartesian_y = sp.expand(r[1].subs(t, parameter_from_x))
sample_parameters = [-3, -1, 0, 1, 3]
sample_points = [r.subs(t,value) for value in sample_parameters]
print("r(t) =", list(r))
print("t expressed by x =", parameter_from_x)
print("Cartesian equation y =", cartesian_y)
print("Parameter interval = [-3, 3]")
print("Corresponding x interval = [-2, 4]")
for value, point in zip(sample_parameters, sample_points):
    print("t =", value, "gives point", list(point))
print("Line equation: y = 5*x/2 - 15/2")

Utskrift fra Python:
r(t) = [t + 1, t**2 + 2]
t expressed by x = x - 1
Cartesian equation y = x**2 - 2*x + 3
Parameter interval = [-3, 3]
Corresponding x interval = [-2, 4]
t = -3 gives point [-2, 11]
t = -1 gives point [0, 3]
t = 0 gives point [1, 2]
t = 1 gives point [2, 3]
t = 3 gives point [4, 11]
Line equation: y = 5*x/2 - 15/2

import sympy as sp
t = sp.symbols("t", real=True)
r = sp.Matrix([t+1, t**2+2])
tangent = r.diff(t)
t_value = sp.solve(sp.Eq(tangent[1]/tangent[0], sp.Rational(5,2)), t)[0]
P = sp.simplify(r.subs(t, t_value))
line_expression = 5*P[0] - 2*P[1] - 15
distance = sp.simplify(abs(line_expression)/sp.sqrt(5**2+(-2)**2))
rationalized = sp.radsimp(distance)
print("r(t) =", list(r))
print("Tangent vector r'(t) =", list(tangent))
print("Parallel-tangent parameter =", t_value)
print("Closest point P =", list(P))
print("Line expression at P =", line_expression)
print("Distance before rationalizing =", distance)
print("Exact minimum distance =", rationalized)
print("Decimal minimum distance =", sp.N(rationalized, 12))
print("Parameter belongs to [-3,3]?", bool(-3 <= t_value <= 3))

Utskrift fra Python:
r(t) = [t + 1, t**2 + 2]
Tangent vector r'(t) = [1, 2*t]
Parallel-tangent parameter = 5/4
Closest point P = [9/4, 57/16]
Line expression at P = -87/8
Distance before rationalizing = 3*sqrt(29)/8
Exact minimum distance = 3*sqrt(29)/8
Decimal minimum distance = 2.01943680268
Parameter belongs to [-3,3]? True

import sympy as sp
x = sp.symbols("x", real=True)
f = x*(x**2-4)
f_prime = sp.diff(f, x)
f_second = sp.diff(f, x, 2)
tangent = sp.expand(f.subs(x,0)+f_prime.subs(x,0)*x)
critical_points = sp.solve(sp.Eq(f_prime,0), x)
x_D = -2/sp.sqrt(3)
y_D = sp.simplify(f.subs(x,x_D))
print("f(x) =", sp.expand(f))
print("f'(x) =", f_prime)
print("f''(x) =", f_second)
print("Inflection tangent =", tangent)
print("A =", (-2,0))
print("B =", (0,0))
print("C =", (-2,tangent.subs(x,-2)))
print("Critical x-values =", critical_points)
print("D =", (x_D,y_D))

Utskrift fra Python:
f(x) = x**3 - 4*x
f'(x) = 3*x**2 - 4
f''(x) = 6*x
Inflection tangent = -4*x
A = (-2, 0)
B = (0, 0)
C = (-2, 8)
Critical x-values = [-2*sqrt(3)/3, 2*sqrt(3)/3]
D = (-2*sqrt(3)/3, 16*sqrt(3)/9)

import sympy as sp
A = sp.Point(-2,0)
B = sp.Point(0,0)
C = sp.Point(-2,8)
D = sp.Point(-2/sp.sqrt(3), 16/(3*sp.sqrt(3)))
area_ABC = abs(sp.Polygon(A,B,C).area)
area_ABD = sp.simplify(abs(sp.Polygon(A,B,D).area))
ratio = sp.radsimp(sp.simplify(area_ABC/area_ABD))
print("A =", A)
print("B =", B)
print("C =", C)
print("D =", D)
print("Area ABC =", area_ABC)
print("Area ABD =", area_ABD)
print("Exact ratio Area(ABC)/Area(ABD) =", ratio)
print("Decimal ratio =", sp.N(ratio, 12))

Utskrift fra Python:
A = Point2D(-2, 0)
B = Point2D(0, 0)
C = Point2D(-2, 8)
D = Point2D(-2*sqrt(3)/3, 16*sqrt(3)/9)
Area ABC = 8
Area ABD = 16*sqrt(3)/9
Exact ratio Area(ABC)/Area(ABD) = 3*sqrt(3)/2
Decimal ratio = 2.59807621135

import sympy as sp
r, x = sp.symbols("r x", positive=True)
g = x*(x**2-r**2)
g_prime = sp.diff(g, x)
E = sp.Point(-r,0)
F = sp.Point(0,0)
tangent = sp.expand(g_prime.subs(x,0)*x)
G = sp.Point(-r, sp.simplify(tangent.subs(x,-r)))
x_H = -r/sp.sqrt(3)
H = sp.Point(x_H, sp.simplify(g.subs(x,x_H)))
area_EFG = sp.simplify(abs(sp.Polygon(E,F,G).area))
area_EFH = sp.simplify(abs(sp.Polygon(E,F,H).area))
ratio = sp.radsimp(sp.simplify(area_EFG/area_EFH))
print("g(x) =", sp.expand(g))
print("g'(x) =", g_prime)
print("Inflection tangent =", tangent)
print("E =", E)
print("F =", F)
print("G =", G)
print("H =", H)
print("Area EFG =", area_EFG)
print("Area EFH =", area_EFH)
print("Simplified area ratio =", ratio)

Utskrift fra Python:
g(x) = -r**2*x + x**3
g'(x) = -r**2 + 3*x**2
Inflection tangent = -r**2*x
E = Point2D(-r, 0)
F = Point2D(0, 0)
G = Point2D(-r, r**3)
H = Point2D(-sqrt(3)*r/3, 2*sqrt(3)*r**3/9)
Area EFG = r**4/2
Area EFH = sqrt(3)*r**4/9
Simplified area ratio = 3*sqrt(3)/2