import sympy as sp
x = sp.symbols("x", real=True)
f = x**2 + sp.exp(x)
f_prime = sp.diff(f, x)
expected = 2*x + sp.exp(x)
print("f(x) =", f)
print("f'(x) =", f_prime)
print("Expected =", expected)
print("Difference =", sp.simplify(f_prime-expected))
print("Domain = all real numbers")

Utskrift fra Python:
f(x) = x**2 + exp(x)
f'(x) = 2*x + exp(x)
Expected = 2*x + exp(x)
Difference = 0
Domain = all real numbers

import sympy as sp
x = sp.symbols("x", real=True)
g = x**3*sp.sqrt(2*x-1)
g_prime = sp.diff(g,x)
factored = sp.factor(g_prime)
expected = x**2*(7*x-3)/sp.sqrt(2*x-1)
print("g(x) =", g)
print("Expanded derivative =", sp.expand(g_prime))
print("Factored derivative =", factored)
print("Expected =", expected)
print("Difference =", sp.simplify(g_prime-expected))
print("Derivative domain: x > 1/2")

Utskrift fra Python:
g(x) = x**3*sqrt(2*x - 1)
Expanded derivative = x**3/sqrt(2*x - 1) + 3*x**2*sqrt(2*x - 1)
Factored derivative = x**2*(7*x - 3)/sqrt(2*x - 1)
Expected = x**2*(7*x - 3)/sqrt(2*x - 1)
Difference = 0
Derivative domain: x > 1/2

import sympy as sp
x = sp.symbols("x", real=True)
h = x**3/(x**2-1)
h_prime = sp.factor(sp.diff(h,x))
expected = x**2*(x**2-3)/(x**2-1)**2
print("h(x) =", h)
print("h'(x) =", h_prime)
print("Expected =", expected)
print("Difference =", sp.simplify(h_prime-expected))
print("Excluded x-values =", [-1,1])

Utskrift fra Python:
h(x) = x**3/(x**2 - 1)
h'(x) = x**2*(x**2 - 3)/((x - 1)**2*(x + 1)**2)
Expected = x**2*(x**2 - 3)/(x**2 - 1)**2
Difference = 0
Excluded x-values = [-1, 1]

import sympy as sp
a, b = sp.symbols("a b", positive=True)
expr = 2*sp.log(a**3*b**4)-3*sp.log(a)-3*sp.log(a*b**2)
expanded = sp.expand_log(expr, force=True)
simplified = sp.simplify(expanded)
print("Original expression =", expr)
print("Expanded logs =", expanded)
print("Simplified =", simplified)
print("Equivalent compact form =", sp.log(b**2))
print("Difference =", sp.simplify(simplified-2*sp.log(b)))

Utskrift fra Python:
Original expression = -3*log(a) - 3*log(a*b**2) + 2*log(a**3*b**4)
Expanded logs = 2*log(b)
Simplified = 2*log(b)
Equivalent compact form = log(b**2)
Difference = 0

import sympy as sp
x = sp.symbols("x", real=True)
left = x**3+2*x**2
right = 5*x+6
print("Left at x=2 =", left.subs(x,2))
print("Right at x=2 =", right.subs(x,2))
print("Difference at x=2 =", sp.simplify((left-right).subs(x,2)))
print("Polynomial factorization =", sp.factor(left-right))
print("x=2 is solution =", left.subs(x,2)==right.subs(x,2))

Utskrift fra Python:
Left at x=2 = 16
Right at x=2 = 16
Difference at x=2 = 0
Polynomial factorization = (x - 2)*(x + 1)*(x + 3)
x=2 is solution = True

import sympy as sp
x = sp.symbols("x", real=True)
P = x**3+2*x**2-5*x-6
factored = sp.factor(P)
solution = sp.solve_univariate_inequality(P<0,x)
print("P(x) =", P)
print("Factorization =", factored)
print("Roots =", sp.solve(sp.Eq(P,0),x))
print("Solution set =", solution)
for test in [-4,-2,0,3]:
    print("P(",test,") =", P.subs(x,test))

Utskrift fra Python:
P(x) = x**3 + 2*x**2 - 5*x - 6
Factorization = (x - 2)*(x + 1)*(x + 3)
Roots = [-3, -1, 2]
Solution set = (x < -3) | ((-1 < x) & (x < 2))
P( -4 ) = -18
P( -2 ) = 4
P( 0 ) = -6
P( 3 ) = 24

import sympy as sp
x = sp.symbols("x", real=True)
expr = (x-2)/(x+1)
solution = sp.solve_univariate_inequality(expr>=0,x)
print("Proposed inequality: (x-2)/(x+1) >= 0")
print("Zero of numerator =", 2)
print("Excluded denominator zero =", -1)
print("Solution set =", solution)
for test in [-2,0,2,3]:
    print("Value at",test,"=",sp.simplify(expr.subs(x,test)))

Utskrift fra Python:
Proposed inequality: (x-2)/(x+1) >= 0
Zero of numerator = 2
Excluded denominator zero = -1
Solution set = (2 <= x) | (x < -1)
Value at -2 = 4
Value at 0 = -2
Value at 2 = 0
Value at 3 = 1/4

import sympy as sp
t = sp.symbols("t", real=True)
r = sp.Matrix([4*t+2,2*t-5*t**2])
v = r.diff(t)
a = v.diff(t)
print("r(t) =", r.T)
print("v(t) =", v.T)
print("a(t) =", a.T)
print("Acceleration is constant =", all(c.free_symbols==set() for c in a))

Utskrift fra Python:
r(t) = Matrix([[4*t + 2, -5*t**2 + 2*t]])
v(t) = Matrix([[4, 2 - 10*t]])
a(t) = Matrix([[0, -10]])
Acceleration is constant = True

import sympy as sp
t = sp.symbols("t", real=True)
v = sp.Matrix([4,2-10*t])
a = sp.Matrix([0,-10])
dot = sp.expand(v.dot(a))
solution = sp.solve(sp.Eq(dot,0),t)[0]
print("v(t) =", v.T)
print("a(t) =", a.T)
print("v dot a =", dot)
print("t =", solution)
print("v(1/5) =", v.subs(t,solution).T)
print("Check dot product =", dot.subs(t,solution))

Utskrift fra Python:
v(t) = Matrix([[4, 2 - 10*t]])
a(t) = Matrix([[0, -10]])
v dot a = 100*t - 20
t = 1/5
v(1/5) = Matrix([[4, 0]])
Check dot product = 0

import sympy as sp
A = sp.Matrix([1,1])
B = sp.Matrix([6,2])
AB = B-A
length = sp.sqrt(AB.dot(AB))
print("A =", A.T)
print("B =", B.T)
print("AB =", AB.T)
print("AB dot AB =", AB.dot(AB))
print("|AB| =", length)
print("Decimal length =", sp.N(length,8))

Utskrift fra Python:
A = Matrix([[1, 1]])
B = Matrix([[6, 2]])
AB = Matrix([[5, 1]])
AB dot AB = 26
|AB| = sqrt(26)
Decimal length = 5.0990195

import sympy as sp
points = [sp.Matrix([1,1]),sp.Matrix([6,2]),sp.Matrix([5,7]),sp.Matrix([2,8])]
coordinate_sum = sum(points,sp.zeros(2,1))
T = coordinate_sum/4
print("Points =", [tuple(p) for p in points])
print("Coordinate sum =", coordinate_sum.T)
print("Centroid T =", T.T)
print("Decimal T =", tuple(sp.N(c) for c in T))

Utskrift fra Python:
Points = [(1, 1), (6, 2), (5, 7), (2, 8)]
Coordinate sum = Matrix([[14, 18]])
Centroid T = Matrix([[7/2, 9/2]])
Decimal T = (3.50000000000000, 4.50000000000000)

import sympy as sp
E=sp.Matrix([0,3]); F=sp.Matrix([2,-2]); G=sp.Matrix([7,3]); T=sp.Matrix([3,2])
H=4*T-E-F-G
check=(E+F+G+H)/4
print("4T =", (4*T).T)
print("E+F+G =", (E+F+G).T)
print("H =", H.T)
print("Centroid check =", check.T)
print("Check equals T =", check==T)

Utskrift fra Python:
4T = Matrix([[12, 8]])
E+F+G = Matrix([[9, 4]])
H = Matrix([[3, 4]])
Centroid check = Matrix([[3, 2]])
Check equals T = True

from math import comb
all_pairs = comb(4,2)
red_red = comb(2,2)
blue_blue = comb(2,2)
favorable = red_red+blue_blue
probability = favorable/all_pairs
print("All pairs =", all_pairs)
print("Red-red pairs =", red_red)
print("Blue-blue pairs =", blue_blue)
print("Favorable pairs =", favorable)
print("Probability =", probability)
print("Exact fraction = 1/3")

Utskrift fra Python:
All pairs = 6
Red-red pairs = 1
Blue-blue pairs = 1
Favorable pairs = 2
Probability = 0.3333333333333333
Exact fraction = 1/3

from fractions import Fraction
def p_unlike(r):
    return Fraction(4*r,(r+2)*(r+1))
for r in range(2,7):
    print("r =",r,"P(unlike) =",p_unlike(r),"=",float(p_unlike(r)))
first = next(r for r in range(2,100) if p_unlike(r) < Fraction(1,2))
print("First r below 1/2 =", first)
print("Previous probability =", p_unlike(first-1))
print("Current probability =", p_unlike(first))

Utskrift fra Python:
r = 2 P(unlike) = 2/3 = 0.6666666666666666
r = 3 P(unlike) = 3/5 = 0.6
r = 4 P(unlike) = 8/15 = 0.5333333333333333
r = 5 P(unlike) = 10/21 = 0.47619047619047616
r = 6 P(unlike) = 3/7 = 0.42857142857142855
First r below 1/2 = 5
Previous probability = 8/15
Current probability = 10/21

import sympy as sp
x=sp.symbols("x", real=True)
f=(x+2)*(x**2+x+5)
f_prime=sp.expand(sp.diff(f,x))
completed=3*(x+1)**2+4
minimum=sp.minimum(f_prime,x,sp.S.Reals)
print("Expanded f =", sp.expand(f))
print("f'(x) =", f_prime)
print("Completed square =", completed)
print("Difference =", sp.expand(f_prime-completed))
print("Minimum of f' =", minimum)
print("Strictly positive =", minimum>0)

Utskrift fra Python:
Expanded f = x**3 + 3*x**2 + 7*x + 10
f'(x) = 3*x**2 + 6*x + 7
Completed square = 3*(x + 1)**2 + 4
Difference = 0
Minimum of f' = 4
Strictly positive = True

import sympy as sp
x=sp.symbols("x", real=True)
f=(x+2)*(x**2+x+5)
f2=sp.diff(f,x,2)
x0=sp.solve(sp.Eq(f2,0),x)[0]
y0=sp.expand(f).subs(x,x0)
print("f''(x) =", f2)
print("Candidate x =", x0)
print("f''(-2) =", f2.subs(x,-2))
print("f''(0) =", f2.subs(x,0))
print("y-coordinate =", y0)
print("Inflection point =", (x0,y0))

Utskrift fra Python:
f''(x) = 6*(x + 1)
Candidate x = -1
f''(-2) = -6
f''(0) = 6
y-coordinate = 5
Inflection point = (-1, 5)

import sympy as sp
x=sp.symbols("x", real=True)
f=sp.expand((x+2)*(x**2+x+5))
roots=sp.solve(sp.Eq(f,0),x)
real_roots=[r for r in roots if r.is_real]
print("f(x) =", f)
print("All symbolic roots =", roots)
print("Real roots =", real_roots)
print("y-intercept =", f.subs(x,0))
print("Inflection point =", (-1,f.subs(x,-1)))
print("Leading coefficient =", sp.Poly(f,x).LC())

Utskrift fra Python:
f(x) = x**3 + 3*x**2 + 7*x + 10
All symbolic roots = [-2]
Real roots = [-2]
y-intercept = 10
Inflection point = (-1, 5)
Leading coefficient = 1

central_AB = 120
central_BC = 140
central_AC = 360-central_AB-central_BC
angle_A = central_BC/2
angle_B = central_AC/2
angle_C = central_AB/2
print("Central angle AB =", central_AB)
print("Central angle BC =", central_BC)
print("Central angle AC =", central_AC)
print("Angle A =", angle_A)
print("Angle B =", angle_B)
print("Angle C =", angle_C)
print("Triangle angle sum =", angle_A+angle_B+angle_C)

Utskrift fra Python:
Central angle AB = 120
Central angle BC = 140
Central angle AC = 100
Angle A = 70.0
Angle B = 50.0
Angle C = 60.0
Triangle angle sum = 180.0

import sympy as sp
b,c,d,h=sp.symbols("b c d h", positive=True)
A=sp.Matrix([0,0]); B=sp.Matrix([b,0]); D=sp.Matrix([d,h]); C=sp.Matrix([d+c,h])
M=(A+D)/2; N=(B+C)/2
MN=sp.simplify(N-M)
print("M =", M.T)
print("N =", N.T)
print("Vector MN =", MN.T)
print("Horizontal length MN =", sp.simplify(MN[0]))
print("Expected half-sum =", (b+c)/2)
print("Difference =", sp.simplify(MN[0]-(b+c)/2))

Utskrift fra Python:
M = Matrix([[d/2, h/2]])
N = Matrix([[b/2 + c/2 + d/2, h/2]])
Vector MN = Matrix([[b/2 + c/2, 0]])
Horizontal length MN = b/2 + c/2
Expected half-sum = b/2 + c/2
Difference = 0

p = 300/365
probability = p**14
print("Sunny-day probability p =", p)
print("Number of days =", 14)
print("P(all 14 sunny) =", probability)
print("Percent =", 100*probability)
print("Rounded percent =", round(100*probability,1))
print("Assumptions: constant p and independent days")

Utskrift fra Python:
Sunny-day probability p = 0.821917808219178
Number of days = 14
P(all 14 sunny) = 0.06420923026849663
Percent = 6.420923026849663
Rounded percent = 6.4
Assumptions: constant p and independent days

from math import comb
q = (300/365)**14
p0 = (1-q)**8
p1 = comb(8,1)*q*(1-q)**7
probability = 1-p0-p1
print("Trip success probability q =", q)
print("P(X=0) =", p0)
print("P(X=1) =", p1)
print("P(X>=2) =", probability)
print("Percent =", 100*probability)
print("Rounded percent =", round(100*probability,1))

Utskrift fra Python:
Trip success probability q = 0.06420923026849663
P(X=0) = 0.5880713982652962
P(X=1) = 0.32280388349089756
P(X>=2) = 0.08912471824380624
Percent = 8.912471824380624
Rounded percent = 8.9

from math import comb
def tail(d):
    p=d/365
    return sum(comb(28,k)*p**k*(1-p)**(28-k) for k in range(22,29))
first=next(d for d in range(366) if tail(d)>=0.90)
print("First annual sunny-day count =", first)
print("p for d=313 =", first/365)
print("P(X>=22) for d=312 =", tail(first-1))
print("P(X>=22) for d=313 =", tail(first))
print("312 meets requirement =", tail(first-1)>=0.90)
print("313 meets requirement =", tail(first)>=0.90)

Utskrift fra Python:
First annual sunny-day count = 313
p for d=313 = 0.8575342465753425
P(X>=22) for d=312 = 0.89912679889525
P(X>=22) for d=313 = 0.9068370286817145
312 meets requirement = False
313 meets requirement = True

import sympy as sp
t=sp.symbols("t", real=True)
y=1+7*t-5*t**2
roots=sp.solve(sp.Eq(y,0),t)
t_hit=max(roots,key=lambda z: float(z))
x_hit=sp.simplify(9*t_hit)
print("Ground equation roots =", roots)
print("Positive impact time =", t_hit)
print("Decimal time =", sp.N(t_hit,10))
print("Horizontal distance =", x_hit)
print("Decimal distance =", sp.N(x_hit,10))
print("Height check =", sp.simplify(y.subs(t,t_hit)))

Utskrift fra Python:
Ground equation roots = [7/10 - sqrt(69)/10, 7/10 + sqrt(69)/10]
Positive impact time = 7/10 + sqrt(69)/10
Decimal time = 1.530662386
Horizontal distance = 63/10 + 9*sqrt(69)/10
Decimal distance = 13.77596148
Height check = 0

import numpy as np
import math
t_end=(7+math.sqrt(69))/10
t=np.linspace(0,t_end,6)
xa=9*t; xb=25-8*t; y=1+7*t-5*t**2
print("Impact time =", t_end)
print("t sample =", t)
print("Rikard x sample =", xa)
print("Berit x sample =", xb)
print("Common y sample =", y)
print("Start points =", (0,1),(25,1))

Utskrift fra Python:
Impact time = 1.5306623862918074
t sample = [0.         0.30613248 0.61226495 0.91839743 1.22452991 1.53066239]
Rikard x sample = [ 0.          2.7551923   5.51038459  8.26557689 11.02076918 13.77596148]
Berit x sample = [25.         22.55094018 20.10188036 17.65282055 15.20376073 12.75470091]
Common y sample = [1.00000000e+00 2.67434187e+00 3.41151281e+00 3.21151281e+00
 2.07434187e+00 1.77635684e-15]
Start points = (0, 1) (25, 1)

import sympy as sp
t=sp.symbols("t", real=True)
t_meet=sp.solve(sp.Eq(9*t,25-8*t),t)[0]
x_meet=sp.simplify(9*t_meet)
y_meet=sp.simplify(1+7*t_meet-5*t_meet**2)
t_hit=(7+sp.sqrt(69))/10
print("Meeting time =", t_meet)
print("Decimal meeting time =", sp.N(t_meet,10))
print("Ground-hit time =", sp.N(t_hit,10))
print("Meeting point =", (x_meet,y_meet))
print("Decimal height =", sp.N(y_meet,10))
print("Meeting before ground =", bool(t_meet<t_hit))

Utskrift fra Python:
Meeting time = 25/17
Decimal meeting time = 1.470588235
Ground-hit time = 1.530662386
Meeting point = (225/17, 139/289)
Decimal height = 0.4809688581
Meeting before ground = True

import sympy as sp
d=sp.symbols("d", positive=True)
t_meet=d/17
t_hit=(7+sp.sqrt(69))/10
d_max=sp.simplify(17*t_hit)
print("Meeting time for distance d =", t_meet)
print("Original meeting time for d=25 =", t_meet.subs(d,25))
print("Impact time =", t_hit)
print("Largest distance for meeting before impact =", d_max)
print("Decimal largest distance =", sp.N(d_max,10))
print("25 m is below limit =", bool(25<d_max))

Utskrift fra Python:
Meeting time for distance d = d/17
Original meeting time for d=25 = 25/17
Impact time = 7/10 + sqrt(69)/10
Largest distance for meeting before impact = 119/10 + 17*sqrt(69)/10
Decimal largest distance = 26.02126057
25 m is below limit = True

import sympy as sp
a=sp.symbols("a", real=True)
A=(6-2*a)*(6*a-a**2)
A_prime=sp.factor(sp.diff(A,a))
critical=sp.solve(sp.Eq(A_prime,0),a)
valid=[r for r in critical if 0<r<3]
maximum_area=sp.simplify(A.subs(a,valid[0]))
print("A(a) =", sp.expand(A))
print("A'(a) =", A_prime)
print("Critical values =", critical)
print("Valid critical value =", valid[0])
print("A at endpoints =", A.subs(a,0),A.subs(a,3))
print("Maximum area =", maximum_area)
print("Decimal a =", sp.N(valid[0],10))

Utskrift fra Python:
A(a) = 2*a**3 - 18*a**2 + 36*a
A'(a) = 6*(a**2 - 6*a + 6)
Critical values = [3 - sqrt(3), sqrt(3) + 3]
Valid critical value = 3 - sqrt(3)
A at endpoints = 0 0
Maximum area = 12*sqrt(3)
Decimal a = 1.267949192

import sympy as sp
x,r=sp.symbols("x r", positive=True)
h=x**2
g=r-sp.sqrt(r**2-x**2)
h2=sp.diff(h,x,2)
g2=sp.simplify(sp.diff(g,x,2))
g2_at_0=sp.simplify(g2.subs(x,0))
solution=sp.solve(sp.Eq(g2_at_0,h2),r)[0]
print("h''(x) =", h2)
print("g'(x) =", sp.simplify(sp.diff(g,x)))
print("g''(x) =", g2)
print("g''(0) =", g2_at_0)
print("r =", solution)
print("Equality check =", sp.simplify(g2_at_0.subs(r,solution)-h2))

Utskrift fra Python:
h''(x) = 2
g'(x) = x/sqrt(r**2 - x**2)
g''(x) = r**2/(r**2 - x**2)**(3/2)
g''(0) = 1/r
r = 1/2
Equality check = 0

import sympy as sp
x=sp.symbols("x", real=True)
h=x**2
h1=sp.diff(h,x)
h2=sp.diff(h,x,2)
radius=sp.sqrt((1+h1.subs(x,0)**2)**3/(h2.subs(x,0)**2))
print("h'(x) =", h1)
print("h''(x) =", h2)
print("h'(0) =", h1.subs(x,0))
print("h''(0) =", h2.subs(x,0))
print("Radius formula value =", radius)
print("Decimal radius =", sp.N(radius,10))

Utskrift fra Python:
h'(x) = 2*x
h''(x) = 2
h'(0) = 0
h''(0) = 2
Radius formula value = 1/2
Decimal radius = 0.5000000000

import sympy as sp
x=sp.symbols("x", positive=True)
f=sp.log(x)
f1=sp.diff(f,x); f2=sp.diff(f,x,2)
rho=sp.simplify(sp.sqrt((1+f1**2)**3/(f2**2)))
rho_prime=sp.factor(sp.diff(rho,x))
x_min=sp.sqrt(2)/2
y_min=sp.simplify(f.subs(x,x_min))
rho_min=sp.simplify(rho.subs(x,x_min))
print("f'(x) =", f1)
print("f''(x) =", f2)
print("rho(x) =", rho)
print("rho'(x) =", rho_prime)
print("x at minimum =", x_min)
print("Point y-value =", y_min)
print("Minimum radius =", rho_min)
print("Decimal radius =", sp.N(rho_min,10))

Utskrift fra Python:
f'(x) = 1/x
f''(x) = -1/x**2
rho(x) = (x**2 + 1)**(3/2)/x
rho'(x) = sqrt(x**2 + 1)*(2*x**2 - 1)/x**2
x at minimum = sqrt(2)/2
Point y-value = -log(2)/2
Minimum radius = 3*sqrt(3)/2
Decimal radius = 2.598076211