import sympy as sp
x = sp.symbols("x", real=True)
expr = (x-1)/(x**2+x-2)
factored_denominator = sp.factor(x**2+x-2)
cancelled = sp.cancel(expr)
limit_value = sp.limit(expr, x, 1)
print("Expression =", expr)
print("Factorized denominator =", factored_denominator)
print("Cancelled expression for x != 1 =", cancelled)
print("Direct numerator at x=1 =", (x-1).subs(x,1))
print("Direct denominator at x=1 =", (x**2+x-2).subs(x,1))
print("Two-sided limit =", limit_value)
print("Decimal value =", sp.N(limit_value,12))

Utskrift fra Python:
Expression = (x - 1)/(x**2 + x - 2)
Factorized denominator = (x - 1)*(x + 2)
Cancelled expression for x != 1 = 1/(x + 2)
Direct numerator at x=1 = 0
Direct denominator at x=1 = 0
Two-sided limit = 1/3
Decimal value = 0.333333333333

import sympy as sp
vectors = {
    "a": sp.Matrix([2,-5]),
    "b": sp.Matrix([1,-4]),
    "c": sp.Matrix([-2,10]),
    "d": sp.Matrix([4,1]),
}
length_squares = {name: sp.expand(v.dot(v)) for name,v in vectors.items()}
lengths = {name: sp.sqrt(value) for name,value in length_squares.items()}
print("Vectors =", vectors)
print("Squared lengths =", length_squares)
print("Exact lengths =", lengths)
for first in vectors:
    for second in vectors:
        if first < second and length_squares[first] == length_squares[second]:
            print("Equal-length pair =", first, second)
print("Common length of b and d =", lengths["b"])
print("Decimal common length =", sp.N(lengths["b"],12))

Utskrift fra Python:
Vectors = {'a': Matrix([
[ 2],
[-5]]), 'b': Matrix([
[ 1],
[-4]]), 'c': Matrix([
[-2],
[10]]), 'd': Matrix([
[4],
[1]])}
Squared lengths = {'a': 29, 'b': 17, 'c': 104, 'd': 17}
Exact lengths = {'a': sqrt(29), 'b': sqrt(17), 'c': 2*sqrt(26), 'd': sqrt(17)}
Equal-length pair = b d
Common length of b and d = sqrt(17)
Decimal common length = 4.12310562562

import sympy as sp
vectors = {
    "a": sp.Matrix([2,-5]),
    "b": sp.Matrix([1,-4]),
    "c": sp.Matrix([-2,10]),
    "d": sp.Matrix([4,1]),
}
names = list(vectors)
dot_products = {}
for i, first in enumerate(names):
    for second in names[i+1:]:
        dot_products[(first,second)] = vectors[first].dot(vectors[second])
print("All pairwise dot products:")
for pair,value in dot_products.items():
    print(pair, "->", value)
normal_pairs = [pair for pair,value in dot_products.items() if value == 0]
print("Pairs with dot product zero =", normal_pairs)
print("b dot d =", vectors["b"].dot(vectors["d"]))
print("Conclusion: b and d are perpendicular")

Utskrift fra Python:
All pairwise dot products:
('a', 'b') -> 22
('a', 'c') -> -54
('a', 'd') -> 3
('b', 'c') -> -42
('b', 'd') -> 0
('c', 'd') -> 2
Pairs with dot product zero = [('b', 'd')]
b dot d = 0
Conclusion: b and d are perpendicular

import sympy as sp
vectors = {
    "a": sp.Matrix([2,-5]),
    "b": sp.Matrix([1,-4]),
    "c": sp.Matrix([-2,10]),
    "d": sp.Matrix([4,1]),
}
names = list(vectors)
determinants = {}
for i, first in enumerate(names):
    for second in names[i+1:]:
        matrix = sp.Matrix.hstack(vectors[first], vectors[second])
        determinants[(first,second)] = matrix.det()
print("Pairwise determinants:")
for pair,value in determinants.items():
    print(pair, "->", value)
parallel_pairs = [pair for pair,value in determinants.items() if value == 0]
print("Parallel pairs =", parallel_pairs)
print("Number of parallel pairs =", len(parallel_pairs))
print("Conclusion: no two vectors are parallel")

Utskrift fra Python:
Pairwise determinants:
('a', 'b') -> -3
('a', 'c') -> 10
('a', 'd') -> 22
('b', 'c') -> 2
('b', 'd') -> 17
('c', 'd') -> -42
Parallel pairs = []
Number of parallel pairs = 0
Conclusion: no two vectors are parallel

import sympy as sp
x = sp.symbols("x", real=True)
f = x/(1+x**2)
f_prime = sp.factor(sp.diff(f,x))
critical_points = sp.solve(sp.Eq(sp.together(f_prime).as_numer_denom()[0],0),x)
print("f(x) =", f)
print("Exact derivative =", f_prime)
print("Critical points =", critical_points)
print("Derivative at x=0 =", f_prime.subs(x,0))
print("Derivative at x=2 =", sp.simplify(f_prime.subs(x,2)))
print("The loop searches while the forward difference is positive")
print("Therefore it approximates the x-coordinate of a local maximum")
print("Expected stopping location is close to x=1")

Utskrift fra Python:
f(x) = x/(x**2 + 1)
Exact derivative = -(x - 1)*(x + 1)/(x**2 + 1)**2
Critical points = [-1, 1]
Derivative at x=0 = 1
Derivative at x=2 = -3/25
The loop searches while the forward difference is positive
Therefore it approximates the x-coordinate of a local maximum
Expected stopping location is close to x=1

def f(x):
    return x/(1+x**2)
h = 0.0001
x = 0
iterations = 0
while (f(x+h)-f(x))/h > 0:
    x = x + 0.01
    iterations += 1
final_difference = (f(x+h)-f(x))/h
print("Number of loop iterations =", iterations)
print("x=", x)
print("f(x) =", f(x))
print("Final forward difference =", final_difference)
print("Rounded x to two decimals =", round(x,2))
print("Mathematical interpretation: maximum near x = 1")

Utskrift fra Python:
Number of loop iterations = 100
x= 1.0000000000000007
f(x) = 0.5
Final forward difference = -2.4997500180923282e-05
Rounded x to two decimals = 1.0
Mathematical interpretation: maximum near x = 1

import sympy as sp
P = sp.Matrix([6,1])
normal = sp.Matrix([2,-1])
t = sp.symbols("t", real=True)
point_on_normal = P + t*normal
equation = sp.Eq(2*point_on_normal[0]-point_on_normal[1]+4,0)
t_value = sp.solve(equation,t)[0]
H = sp.simplify(point_on_normal.subs(t,t_value))
reflected = 2*H-P
midpoint = sp.simplify((P+reflected)/2)
print("P =", P.T)
print("Normal vector =", normal.T)
print("Line-intersection equation =", equation)
print("Parameter t =", t_value)
print("Foot point H =", H.T)
print("Reflected point P' =", reflected.T)
print("Midpoint check =", midpoint.T)
print("Line check at H =", 2*H[0]-H[1]+4)
print("Equal distances squared =", (P-H).dot(P-H), (reflected-H).dot(reflected-H))

Utskrift fra Python:
P = Matrix([[6, 1]])
Normal vector = Matrix([[2, -1]])
Line-intersection equation = Eq(5*t + 15, 0)
Parameter t = -3
Foot point H = Matrix([[0, 4]])
Reflected point P' = Matrix([[-6, 7]])
Midpoint check = Matrix([[0, 4]])
Line check at H = 0
Equal distances squared = 45 45

import sympy as sp
x = sp.symbols("x", real=True)
f = 4*x*sp.exp(-x)
f_prime = sp.factor(sp.diff(f,x))
f_second = sp.factor(sp.diff(f,x,2))
maximum_x = sp.solve(sp.Eq(f_prime,0),x)[0]
inflection_x = sp.solve(sp.Eq(f_second,0),x)[0]
print("f(x) =", f)
print("f(0) =", f.subs(x,0))
print("f'(x) =", f_prime)
print("Maximum x-coordinate =", maximum_x)
print("Maximum value =", sp.simplify(f.subs(x,maximum_x)), "=", sp.N(f.subs(x,maximum_x),12))
print("f''(x) =", f_second)
print("Inflection x-coordinate =", inflection_x)
print("Inflection value =", sp.simplify(f.subs(x,inflection_x)))
print("Limit as x -> infinity =", sp.limit(f,x,sp.oo))
print("Limit as x -> -infinity =", sp.limit(f,x,-sp.oo))
print("Matching sketch = IV")

Utskrift fra Python:
f(x) = 4*x*exp(-x)
f(0) = 0
f'(x) = -4*(x - 1)*exp(-x)
Maximum x-coordinate = 1
Maximum value = 4*exp(-1) = 1.47151776469
f''(x) = 4*(x - 2)*exp(-x)
Inflection x-coordinate = 2
Inflection value = 8*exp(-2)
Limit as x -> infinity = 0
Limit as x -> -infinity = -oo
Matching sketch = IV

import sympy as sp
t = sp.symbols("t", real=True)
r = sp.Matrix([28*t-3*t**2, 10*t-5*t**2])
v = r.diff(t)
v0 = v.subs(t,0)
speed0 = sp.sqrt(v0.dot(v0))
print("Position r(t) =", r.T)
print("Velocity v(t) =", v.T)
print("Initial velocity v(0) =", v0.T)
print("Speed squared at t=0 =", v0.dot(v0))
print("Exact initial speed =", sp.simplify(speed0))
print("Decimal initial speed =", sp.N(speed0,12))
print("Unit = m/s")

Utskrift fra Python:
Position r(t) = Matrix([[-3*t**2 + 28*t, -5*t**2 + 10*t]])
Velocity v(t) = Matrix([[28 - 6*t, 10 - 10*t]])
Initial velocity v(0) = Matrix([[28, 10]])
Speed squared at t=0 = 884
Exact initial speed = 2*sqrt(221)
Decimal initial speed = 29.7321374946
Unit = m/s

import sympy as sp
t = sp.symbols("t", real=True)
y = 10*t-5*t**2
solutions = sp.solve(sp.Eq(y,0),t)
positive_after_start = [s for s in solutions if s > 0]
print("Height y(t) =", y)
print("Factorized height =", sp.factor(y))
print("Ground equation: y(t) = 0")
print("All solutions =", solutions)
print("Solution after the kick =", positive_after_start)
for value in solutions:
    print("Check y(", value, ") =", y.subs(t,value))
print("Flight time = 2 seconds")

Utskrift fra Python:
Height y(t) = -5*t**2 + 10*t
Factorized height = -5*t*(t - 2)
Ground equation: y(t) = 0
All solutions = [0, 2]
Solution after the kick = [2]
Check y( 0 ) = 0
Check y( 2 ) = 0
Flight time = 2 seconds

import sympy as sp
t = sp.symbols("t", real=True)
r = sp.Matrix([28*t-3*t**2, 10*t-5*t**2])
v = r.diff(t)
top_time = sp.solve(sp.Eq(v[1],0),t)[0]
v_top = sp.simplify(v.subs(t,top_time))
speed_top = sp.sqrt(v_top.dot(v_top))
print("Velocity v(t) =", v.T)
print("Vertical velocity =", v[1])
print("Time at highest point =", top_time)
print("Position at highest point =", r.subs(t,top_time).T)
print("Velocity at highest point =", v_top.T)
print("Speed squared =", v_top.dot(v_top))
print("Speed at highest point =", speed_top)
print("Unit = m/s")

Utskrift fra Python:
Velocity v(t) = Matrix([[28 - 6*t, 10 - 10*t]])
Vertical velocity = 10 - 10*t
Time at highest point = 1
Position at highest point = Matrix([[25, 5]])
Velocity at highest point = Matrix([[22, 0]])
Speed squared = 484
Speed at highest point = 22
Unit = m/s

import sympy as sp
x, b = sp.symbols("x b", real=True)
f = x**4-b*x**3+2
f_prime = sp.factor(sp.diff(f,x))
turning_location = sp.solve(sp.Eq(4*x-3*b,0),x)[0]
condition = sp.solve_univariate_inequality(turning_location <= -3,b)
print("f(x) =", f)
print("f'(x) =", f_prime)
print("Sign-changing critical location =", turning_location)
print("Required inequality =", sp.Le(turning_location,-3))
print("Parameter solution =", condition)
for value in [-5,-4,-3,0]:
    derivative = sp.factor(f_prime.subs(b,value))
    print("b =", value, "-> f'(x) =", derivative)
print("Final condition: b <= -4")

Utskrift fra Python:
f(x) = -b*x**3 + x**4 + 2
f'(x) = x**2*(-3*b + 4*x)
Sign-changing critical location = 3*b/4
Required inequality = 3*b/4 <= -3
Parameter solution = b <= -4
b = -5 -> f'(x) = x**2*(4*x + 15)
b = -4 -> f'(x) = 4*x**2*(x + 3)
b = -3 -> f'(x) = x**2*(4*x + 9)
b = 0 -> f'(x) = 4*x**3
Final condition: b <= -4

import sympy as sp
a,b,r,s,t = sp.symbols("a b r s t", real=True)
distance_squared = (s-a)**2 + (t-b)**2
radius_squared = r**2
difference = sp.expand(distance_squared-radius_squared)
print("Center S = (a,b)")
print("Point P = (s,t)")
print("Squared distance d^2 =", distance_squared)
print("Squared radius r^2 =", radius_squared)
print("Comparison expression d^2-r^2 =", difference)
print("If d^2-r^2 < 0: inside")
print("If d^2-r^2 = 0: on the circle")
print("If d^2-r^2 > 0: outside")
print("Using squared values avoids an unnecessary square root")

Utskrift fra Python:
Center S = (a,b)
Point P = (s,t)
Squared distance d^2 = (-a + s)**2 + (-b + t)**2
Squared radius r^2 = r**2
Comparison expression d^2-r^2 = a**2 - 2*a*s + b**2 - 2*b*t - r**2 + s**2 + t**2
If d^2-r^2 < 0: inside
If d^2-r^2 = 0: on the circle
If d^2-r^2 > 0: outside
Using squared values avoids an unnecessary square root

def classify_point(a, b, r, s, t, tolerance=1e-9):
    if r < 0:
        raise ValueError("Radius must be non-negative")
    difference = (s-a)**2 + (t-b)**2 - r**2
    if abs(difference) <= tolerance:
        return "Punktet ligger på sirkelen"
    if difference < 0:
        return "Punktet ligger innenfor sirkelen"
    return "Punktet ligger utenfor sirkelen"

test_cases = [
    (0,0,5,3,4),
    (0,0,5,1,1),
    (0,0,5,6,0),
]
print("Algorithm compares squared distance with radius squared")
print("Floating-point tolerance =", 1e-9)
print("Number of test cases =", len(test_cases))
for case in test_cases:
    a,b,r,s,t = case
    squared_distance = (s-a)**2 + (t-b)**2
    print("Input =", case)
    print("Squared distance =", squared_distance, "radius squared =", r**2)
    print("Output =", classify_point(a,b,r,s,t))

Utskrift fra Python:
Algorithm compares squared distance with radius squared
Floating-point tolerance = 1e-09
Number of test cases = 3
Input = (0, 0, 5, 3, 4)
Squared distance = 25 radius squared = 25
Output = Punktet ligger på sirkelen
Input = (0, 0, 5, 1, 1)
Squared distance = 2 radius squared = 25
Output = Punktet ligger innenfor sirkelen
Input = (0, 0, 5, 6, 0)
Squared distance = 36 radius squared = 25
Output = Punktet ligger utenfor sirkelen

import numpy as np
x = np.array([0,4,8,12,16], dtype=float)
temperature = np.array([70,53,42,35,30], dtype=float)
room_temperature = 21.2
difference = temperature-room_temperature
slope, intercept = np.polyfit(x, np.log(difference), 1)
A = np.exp(intercept)
predicted = room_temperature + A*np.exp(slope*x)
print("Times =", x)
print("Measured temperatures =", temperature)
print("Temperature differences =", difference)
print("Regression slope k =", slope)
print("Regression intercept ln(A) =", intercept)
print("A = exp(intercept) =", A)
print("Rounded A =", round(A), "rounded k =", round(slope,2))
print("Predicted temperatures =", np.round(predicted,6))
print("Rounded model: 21.2 + 49*exp(-0.11*x)")

Utskrift fra Python:
Times = [ 0.  4.  8. 12. 16.]
Measured temperatures = [70. 53. 42. 35. 30.]
Temperature differences = [48.8 31.8 20.8 13.8  8.8]
Regression slope k = -0.10651887200932143
Regression intercept ln(A) = 3.888464956674536
A = exp(intercept) = 48.83586379013603
Rounded A = 49 rounded k = -0.11
Predicted temperatures = [70.035864 53.093093 42.028328 34.802295 30.08321 ]
Rounded model: 21.2 + 49*exp(-0.11*x)

import sympy as sp
x = sp.symbols("x", real=True)
f = -sp.Rational(245,100)*x + sp.Rational(656,10)
g = sp.Rational(13,100)*x**2 - sp.Rational(445,100)*x + 70
h = sp.Rational(212,10) + 49*sp.exp(-sp.Rational(11,100)*x)
room = sp.Rational(212,10)
linear_room_time = sp.solve(sp.Eq(f,room),x)[0]
quadratic_vertex = sp.solve(sp.Eq(sp.diff(g,x),0),x)[0]
quadratic_minimum = sp.simplify(g.subs(x,quadratic_vertex))
print("Linear model f(x) =", f)
print("Time when f reaches room temperature =", linear_room_time, "=", sp.N(linear_room_time,10))
print("Quadratic model g(x) =", g)
print("Quadratic vertex time =", quadratic_vertex, "=", sp.N(quadratic_vertex,10))
print("Quadratic minimum temperature =", sp.N(quadratic_minimum,10))
print("Exponential model h(x) =", h)
print("h'(x) =", sp.factor(sp.diff(h,x)))
print("Long-term limit of h =", sp.limit(h,x,sp.oo))
print("Practical data interval = [0,16] minutes")
print("Best long-term qualitative model = h")

Utskrift fra Python:
Linear model f(x) = 328/5 - 49*x/20
Time when f reaches room temperature = 888/49 = 18.12244898
Quadratic model g(x) = 13*x**2/100 - 89*x/20 + 70
Quadratic vertex time = 445/26 = 17.11538462
Quadratic minimum temperature = 31.91826923
Exponential model h(x) = 106/5 + 49*exp(-11*x/100)
h'(x) = -539*exp(-11*x/100)/100
Long-term limit of h = 106/5
Practical data interval = [0,16] minutes
Best long-term qualitative model = h

import sympy as sp
x,a,b = sp.symbols("x a b", real=True)
left = 2*x**2+3*x+a
right = -2*x**2+b*x
continuity = sp.Eq(left.subs(x,1), right.subs(x,1))
derivative_match = sp.Eq(sp.diff(left,x).subs(x,1), sp.diff(right,x).subs(x,1))
solution = sp.solve([continuity,derivative_match],[a,b], dict=True)[0]
left_fixed = left.subs(solution)
right_fixed = right.subs(solution)
print("Continuity equation =", continuity)
print("Derivative equation =", derivative_match)
print("Solution =", solution)
print("Left expression =", left_fixed)
print("Right expression =", right_fixed)
print("Value from left at x=1 =", left_fixed.subs(x,1))
print("Value from right at x=1 =", right_fixed.subs(x,1))
print("Derivative from left =", sp.diff(left_fixed,x).subs(x,1))
print("Derivative from right =", sp.diff(right_fixed,x).subs(x,1))

Utskrift fra Python:
Continuity equation = Eq(a + 5, b - 2)
Derivative equation = Eq(7, b - 4)
Solution = {a: 4, b: 11}
Left expression = 2*x**2 + 3*x + 4
Right expression = -2*x**2 + 11*x
Value from left at x=1 = 9
Value from right at x=1 = 9
Derivative from left = 7
Derivative from right = 7

import sympy as sp
x = sp.symbols("x", real=True)
left = 2*x**2+3*x+4
right = -2*x**2+11*x
left_second = sp.diff(left,x,2)
right_second = sp.diff(right,x,2)
point_value = right.subs(x,1)
left_slope = sp.diff(left,x).subs(x,1)
right_slope = sp.diff(right,x).subs(x,1)
print("Left branch =", left)
print("Right branch =", right)
print("Left second derivative =", left_second)
print("Right second derivative =", right_second)
print("Common point value =", point_value)
print("Left slope at x=1 =", left_slope)
print("Right slope at x=1 =", right_slope)
print("Concavity changes from up to down")
print("Inflection point = (1,9)")

Utskrift fra Python:
Left branch = 2*x**2 + 3*x + 4
Right branch = -2*x**2 + 11*x
Left second derivative = 4
Right second derivative = -4
Common point value = 9
Left slope at x=1 = 7
Right slope at x=1 = 7
Concavity changes from up to down
Inflection point = (1,9)

import sympy as sp
x,C = sp.symbols("x C", real=True)
f = sp.exp(x)/(sp.exp(x)+C)
f_prime = sp.factor(sp.diff(f,x))
print("f(x) =", f)
print("f'(x) =", f_prime)
print("Numerator of derivative =", sp.factor(sp.together(f_prime).as_numer_denom()[0]))
print("Denominator of derivative =", sp.factor(sp.together(f_prime).as_numer_denom()[1]))
for value in [2,-2,0]:
    specialized = sp.simplify(f.subs(C,value))
    specialized_derivative = sp.simplify(f_prime.subs(C,value))
    print("C =", value, "-> f =", specialized, ", f' =", specialized_derivative)
print("For C>0 the derivative is positive")
print("For C<0 the derivative is negative where defined")
print("For C=0 the function is constant 1")
print("No strict top or bottom point occurs")

Utskrift fra Python:
f(x) = exp(x)/(C + exp(x))
f'(x) = C*exp(x)/(C + exp(x))**2
Numerator of derivative = C*exp(x)
Denominator of derivative = (C + exp(x))**2
C = 2 -> f = exp(x)/(exp(x) + 2) , f' = 2*exp(x)/(exp(x) + 2)**2
C = -2 -> f = exp(x)/(exp(x) - 2) , f' = -2*exp(x)/(exp(x) - 2)**2
C = 0 -> f = 1 , f' = 0
For C>0 the derivative is positive
For C<0 the derivative is negative where defined
For C=0 the function is constant 1
No strict top or bottom point occurs

import sympy as sp
x,C = sp.symbols("x C", real=True)
f = sp.exp(x)/(sp.exp(x)+C)
f_second = sp.factor(sp.diff(f,x,2))
inflection_x = sp.log(C)
inflection_y = sp.simplify(f.subs(x,inflection_x))
print("f(x) =", f)
print("f''(x) =", f_second)
print("Candidate equation = exp(x) = C")
print("Real candidate requires C > 0")
print("Candidate x-coordinate =", inflection_x)
print("Candidate y-coordinate =", inflection_y)
for value in [sp.Rational(1,4),1,4]:
    x_value = sp.log(value)
    print("C =", value, "-> inflection point =", (x_value, sp.simplify(f.subs({C:value,x:x_value}))))
print("For C <= 0 there is no regular inflection point")

Utskrift fra Python:
f(x) = exp(x)/(C + exp(x))
f''(x) = C*(C - exp(x))*exp(x)/(C + exp(x))**3
Candidate equation = exp(x) = C
Real candidate requires C > 0
Candidate x-coordinate = log(C)
Candidate y-coordinate = 1/2
C = 1/4 -> inflection point = (-log(4), 1/2)
C = 1 -> inflection point = (0, 1/2)
C = 4 -> inflection point = (log(4), 1/2)
For C <= 0 there is no regular inflection point

import sympy as sp
x,C,u = sp.symbols("x C u", positive=True)
f_shifted = sp.exp(x+sp.log(C))/(sp.exp(x+sp.log(C))+C)
base = sp.exp(x)/(sp.exp(x)+1)
difference = sp.simplify(f_shifted-base)
family_at_u = sp.exp(u)/(sp.exp(u)+C)
translated_base = sp.exp(u-sp.log(C))/(sp.exp(u-sp.log(C))+1)
print("f(x+ln(C)) =", sp.simplify(f_shifted))
print("Base logistic function =", base)
print("Difference =", difference)
print("Equivalent family form f_C(u) =", family_at_u)
print("Translated base F(u-ln(C)) =", sp.simplify(translated_base))
print("Translation difference =", sp.simplify(family_at_u-translated_base))
for value in [sp.Rational(1,4),1,4]:
    print("C =", value, "-> horizontal shift ln(C) =", sp.N(sp.log(value),10))
print("Horizontal asymptotes remain y=0 and y=1")

Utskrift fra Python:
f(x+ln(C)) = exp(x)/(exp(x) + 1)
Base logistic function = exp(x)/(exp(x) + 1)
Difference = 0
Equivalent family form f_C(u) = exp(u)/(C + exp(u))
Translated base F(u-ln(C)) = exp(u)/(C + exp(u))
Translation difference = 0
C = 1/4 -> horizontal shift ln(C) = -1.386294361
C = 1 -> horizontal shift ln(C) = 0
C = 4 -> horizontal shift ln(C) = 1.386294361
Horizontal asymptotes remain y=0 and y=1

import sympy as sp
x,A = sp.symbols("x A", positive=True)
C = -A
f = sp.exp(x)/(sp.exp(x)+C)
shifted = sp.simplify(f.subs(x,x+sp.log(A)))
asymptote = sp.log(A)
derivative = sp.factor(sp.diff(f,x))
print("Let A = -C > 0")
print("f(x) =", f)
print("Vertical asymptote x =", asymptote)
print("f(x+ln(A)) =", shifted)
print("Derivative =", derivative)
print("Limit x -> -infinity =", sp.limit(f,x,-sp.oo))
print("Limit x -> infinity =", sp.limit(f,x,sp.oo))
print("Left limit at asymptote =", sp.limit(f,x,asymptote,dir='-'))
print("Right limit at asymptote =", sp.limit(f,x,asymptote,dir='+'))
for value in [sp.Rational(1,4),1,4]:
    print("A =", value, "(C =", -value, ") -> asymptote =", sp.N(sp.log(value),10))

Utskrift fra Python:
Let A = -C > 0
f(x) = exp(x)/(-A + exp(x))
Vertical asymptote x = log(A)
f(x+ln(A)) = exp(x)/(exp(x) - 1)
Derivative = -A*exp(x)/(A - exp(x))**2
Limit x -> -infinity = 0
Limit x -> infinity = 1
Left limit at asymptote = -oo
Right limit at asymptote = oo
A = 1/4 (C = -1/4 ) -> asymptote = -1.386294361
A = 1 (C = -1 ) -> asymptote = 0
A = 4 (C = -4 ) -> asymptote = 1.386294361

import sympy as sp
x = sp.symbols("x", real=True)
f = x**3-x**2-2*x+3
x1,x2,x3 = -2,1,2
m = sp.Rational(x1+x2,2)
f_m = sp.simplify(f.subs(x,m))
slope = sp.simplify(sp.diff(f,x).subs(x,m))
tangent = sp.expand(f_m+slope*(x-m))
target = sp.simplify(f.subs(x,x3))
print("f(x) =", f)
print("Intersection x-values =", (x1,x2,x3))
print("m =", m)
print("f(m) =", f_m)
print("f'(m) =", slope)
print("Tangent y =", tangent)
print("Tangent value at x3 =", tangent.subs(x,x3))
print("f(x3) =", target)
print("Difference =", sp.simplify(tangent.subs(x,x3)-target))

Utskrift fra Python:
f(x) = x**3 - x**2 - 2*x + 3
Intersection x-values = (-2, 1, 2)
m = -1/2
f(m) = 29/8
f'(m) = -1/4
Tangent y = 7/2 - x/4
Tangent value at x3 = 3
f(x3) = 3
Difference = 0

import sympy as sp
x,x1,x2,x3,k,a,b = sp.symbols("x x1 x2 x3 k a b")
q = k*(x-x1)*(x-x2)*(x-x3)
g = sp.expand(q+a*x+b)
print("q(x) = g(x)-(a*x+b) =", q)
print("Expanded general g(x) =", g)
for root in [x1,x2,x3]:
    difference_at_root = sp.simplify(g.subs(x,root)-(a*root+b))
    print("At x =", root, ", g(x)-(a*x+b) =", difference_at_root)
print("Degree of product term =", sp.Poly(q,x).degree())
print("Leading coefficient =", sp.Poly(q,x).LC())
print("Therefore g(x) = k product + (a*x+b)")

Utskrift fra Python:
q(x) = g(x)-(a*x+b) = k*(x - x1)*(x - x2)*(x - x3)
Expanded general g(x) = a*x + b + k*x**3 - k*x**2*x1 - k*x**2*x2 - k*x**2*x3 + k*x*x1*x2 + k*x*x1*x3 + k*x*x2*x3 - k*x1*x2*x3
At x = x1 , g(x)-(a*x+b) = 0
At x = x2 , g(x)-(a*x+b) = 0
At x = x3 , g(x)-(a*x+b) = 0
Degree of product term = 3
Leading coefficient = k
Therefore g(x) = k product + (a*x+b)

import sympy as sp
x,x1,x2,x3,k,a,b = sp.symbols("x x1 x2 x3 k a b")
m = (x1+x2)/2
p = (x-x1)*(x-x2)*(x-x3)
g = k*p+a*x+b
p_m = sp.factor(p.subs(x,m))
p_prime_m = sp.factor(sp.diff(p,x).subs(x,m))
tangent_at_x3 = sp.simplify(g.subs(x,m)+sp.diff(g,x).subs(x,m)*(x3-m))
g_at_x3 = sp.simplify(g.subs(x,x3))
print("m =", m)
print("p(m) =", p_m)
print("p'(m) =", p_prime_m)
print("Cancellation expression =", sp.factor(p_m+p_prime_m*(x3-m)))
print("Tangent evaluated at x3 =", tangent_at_x3)
print("g(x3) =", g_at_x3)
print("Difference =", sp.factor(tangent_at_x3-g_at_x3))
print("Identity proved symbolically")

Utskrift fra Python:
m = x1/2 + x2/2
p(m) = -(x1 - x2)**2*(x1 + x2 - 2*x3)/8
p'(m) = -(x1 - x2)**2/4
Cancellation expression = 0
Tangent evaluated at x3 = a*x3 + b
g(x3) = a*x3 + b
Difference = 0
Identity proved symbolically

import sympy as sp
x = sp.symbols("x", real=True)
h = x**3-2*x+1
line = 2*x+1
intersection_polynomial = sp.factor(h-line)
intersections = sp.solve(sp.Eq(h,line),x)
x1,x2,x3 = intersections
m = sp.Rational(x1+x2,2)
tangent_point = (m,sp.simplify(h.subs(x,m)))
slope = sp.diff(h,x).subs(x,m)
tangent = sp.expand(tangent_point[1]+slope*(x-m))
print("h(x) =", h)
print("Auxiliary line =", line)
print("h(x)-line =", intersection_polynomial)
print("Intersection x-values =", intersections)
print("Choose x3=2 for P=(2,5)")
print("m = average of the other two =", m)
print("Tangency point =", tangent_point)
print("Tangent slope =", slope)
print("Tangent equation y =", tangent)
print("Tangent value at x=2 =", tangent.subs(x,2))
print("P y-coordinate =", h.subs(x,2))

Utskrift fra Python:
h(x) = x**3 - 2*x + 1
Auxiliary line = 2*x + 1
h(x)-line = x*(x - 2)*(x + 2)
Intersection x-values = [-2, 0, 2]
Choose x3=2 for P=(2,5)
m = average of the other two = -1
Tangency point = (-1, 2)
Tangent slope = 1
Tangent equation y = x + 3
Tangent value at x=2 = 5
P y-coordinate = 5