(d)

C poursuit P sur la droite (d). 
C a pour position initiale Co et  vitesse Vc.
P a pour position initiale  Po  et vitesse Vp.
M a pour coordonnées ( t ; CP )

CP en fonction de t

Distances CoC et CoP en fonction de t

v_C = 8 (slider from 0 to 50, step 0.1)
t = 0 (slider from 0 to 10, step 0.0050)
C_0 = (2.32476744474527, 4.352115068901485)
B = (13.624793766536852, 1.993028154122449)
c, C_1, C, a = Déplacement(C_0, B, v_C, t)
b = Ray(C_0, B)
P_0 = Point(b)
v_P = 4.5 (slider from 0 to 50, step 0.1)
d_1, F, P, e = Déplacement(P_0, B, v_P, t)
d = Distance(C, P)
TexteDG: Name[C] + (Name[P]) + " \, = \, " + d
M: (t, d)
distanceC0P0 = Distance(C_0, P_0)
TexteC0P0: Name[C_0] + (Name[P_0]) + " \, = \, " + distanceC0P0
f(x) = v_C * x
h = Segment(C_0, P_0)
g(x) = v_P * x + h
C': (t, f(t))
P': (t, g(t))
A = Intersect(f, g)
i = false
j = false

Tool: Affixe
Input: A
Output: T1

T1: "  z=" + (x(A)) + "+" + (y(A)) + "i"

Tool: Argument
Clic sur :point, origine, point E
Input: A, O, E
Output: T2

α = Angle(E, O, A)
T2: "arg :" + (α / 180) + "π"

Tool: conjugué
clic sur point, origine
Input: A, O
Output: Abarre, u

Abarre: (x(A), -1 * y(A))
u = Vector(O, Abarre)

Tool: Parabole
Pour construire la parabole ayant pour tangentes (AB) et (AC): clic sur A, B, C
Input: A, B, C
Output: c

D = Midpoint(A, B)
E = Midpoint(A, C)
F = Midpoint(D, E)
G = Midpoint(D, F)
H = Midpoint(D, B)
I = Midpoint(G, H)
J = Midpoint(F, E)
K = Midpoint(C, E)
L = Midpoint(J, K)
c = Conic(B, I, F, L, C)

Tool: Dichotomie1
clic sur f, A, B tq f(x(A))*f(x(B)<0; renvoie un encadrement d'amplitude moitié
Input: f, A, B
Output: C, D

f(x) = cos(x)
C = If(f(x(A)) * f((x(A) + x(B)) / 2) < 0, A, Midpoint[A, B])
D = If(f(x(A)) * f((x(A) + x(B)) / 2) < 0, Midpoint[A, B], B)

Tool: EqDiff y'=f(y) (command EqDiffy')
Clic sur A, f, h
Input: A, f, h
Output: B

f(x) = x
y_0: y(A)
y_1: y_0 + h * f(y_0)
x_0: x(A)
B: (x_0 + h, y_1)

Tool: EqDiff y'=f(y) (command EqDiffy'1)
Clic sur A, f, h
Input: A, f, h
Output: B

f(x) = x
y_0: y(A)
y_1: y_0 + h * f(y_0)
x_0: x(A)
B: (x_0 + h, y_1)

Tool: EqDiffy'=f(y)-Global (command EqDiffGlobal)
Input: A, f, h
Output: B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, Z

y_0: y(A)
f(x) = x
y_1: y_0 + h * f(y_0)
x_0: x(A)
B: (x_0 + h, y_1)
C = EqDiffy'(B, f, h)
D = EqDiffy'(C, f, h)
E = EqDiffy'(D, f, h)
F = EqDiffy'(E, f, h)
G = EqDiffy'(F, f, h)
H = EqDiffy'(G, f, h)
I = EqDiffy'(H, f, h)
J = EqDiffy'(I, f, h)
K = EqDiffy'(J, f, h)
L = EqDiffy'(K, f, h)
M = EqDiffy'(A, f, -h)
N = EqDiffy'(M, f, -h)
O = EqDiffy'(N, f, -h)
P = EqDiffy'(O, f, -h)
Q = EqDiffy'(P, f, -h)
R = EqDiffy'(Q, f, -h)
S = EqDiffy'(R, f, -h)
T = EqDiffy'(S, f, -h)
U = EqDiffy'(T, f, -h)
V = EqDiffy'(U, f, -h)
W = EqDiffy'(V, f, -h)
Z = EqDiffy'(W, f, -h)

Tool: Eqy''=f(y) (command Eqy'')
Input: A, f, h, yprim0
Output: B, yprim1

f(x) = -x
x_0: x(A)
y_0: y(A)
yprim1: yprim0 + h * f(y_0)
y_1: y_0 + h * yprim0
B: (x_0 + h, y_1)

Tool: Eqy''=f(y) (command Eqy''1)
Input: A, f, h, yprim0
Output: B, yprim1

f(x) = x
x_0: x(A)
y_0: y(A)
yprim1: yprim0 + h * f(y_0)
y_1: y_0 + h * yprim0
B: (x_0 + h, y_1)

Tool: Eqy''=f(y)Global (command Eqy''Global)
Clic sur A, f, h, y'_0
Input: A, f, h, yprim0
Output: B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W

f(x) = -x
x_0: x(A)
y_0: y(A)
yprim1: yprim0 + h * f(y_0)
y_1: y_0 + h * yprim0
B: (x_0 + h, y_1)
C, a = Eqy''(B, f, h, yprim1)
D, b = Eqy''(C, f, h, a)
E, c = Eqy''(D, f, h, b)
F, d = Eqy''(E, f, h, c)
G, e = Eqy''(F, f, h, d)
H, g = Eqy''(G, f, h, e)
I, i = Eqy''(H, f, h, g)
J, j = Eqy''(I, f, h, i)
K, k = Eqy''(J, f, h, j)
L, l = Eqy''(K, f, h, k)
M, m = Eqy''(A, f, -h, yprim0)
N, n = Eqy''(M, f, -h, m)
O, o = Eqy''(N, f, -h, n)
P, p = Eqy''(O, f, -h, o)
Q, q = Eqy''(P, f, -h, p)
R, r = Eqy''(Q, f, -h, q)
S, s = Eqy''(R, f, -h, r)
T, t = Eqy''(S, f, -h, s)
U, u = Eqy''(T, f, -h, t)
V, v = Eqy''(U, f, -h, u)
W, w = Eqy''(V, f, -h, v)

Tool: fonct. déf par intégrale (command fonct)
Clic sur f, A,B
Input: f, A, B
Output: loc1

f(x) = exp(x)
AB = Segment(A, B)
C = Point(AB)
I = Integral(f, 0, x(C))
M: (x(C), I)
loc1 = Locus(M, C)

Tool: Fonct. réciproque (command Fonct1)
clic sur f, A, B
Input: f, A, B
Output: loc1

f(x) = log(x)
AB = Segment(A, B)
C = Point(AB)
M: (f(x(C)), x(C))
loc1 = Locus(M, C)

Tool: Liste racines (command Listeracines)
fournit la liste des solutions de f(x)=0 (f(x) polynome)
Input: f
Output: S

f(x) = 3 * (x + 0.14)^(7) - 2 * (x + 0.14)^(4) + 9 * (x + 0.14)^(3) - (x + 0.14)
list1: {Root[f]}
S = Sequence(x(Element[list1, i]), i, 1, Length[list1])

Tool: Maximum fonction (command Maximumfonction)
Renvoie une approximation du max de f sur [a,b]
Input: f, a, b
Output: M

f(x) = x^(3) - 3 * x
list1 = Sequence(f(a + i * (b - a) / 1000), i, 0, 1000)
M = Max(list1)

Tool: Minimum fonction (command Minimumfonction)
Renvoie une approximation du minimum de f sur [a,b]
Input: f, a, b
Output: m

f(x) = x^(3) - 3 * x
list1 = Sequence(f(a + i * (b - a) / 1000), i, 0, 1000)
m = Min(list1)

Tool: Module
Input: A
Output: T5

T5: "
module :" + (sqrt(x(A)^(2) + y(A)^(2)))

Tool: Produit
Clic sur point 1, point 2, origine, point E
Input: A, B, O, E
Output: D, T4, T5, T6, v

D: (x(A) * x(B) - y(A) * y(B), x(A) * y(B) + y(A) * x(B))
v = Vector(O, D)
T4 = Affixe(D)
T5 = Module(D)
T6 = Argument(D, O, E)

Tool: Produit de 2 listes (command Produitde2listes)
Multiplie terme à terme 2 listes de même longueur
Input: L1, L2
Output: P

L1: {1, 1, 1, 2, 2, 2, 1}
n = Length(L1)
L2: {1, 3, 5, 7, 9, 6, 4}
P = Sequence(Element[L1, i] * Element[L2, i], i, 1, n)

Tool: Quotient
Clic sur point numérateur, point dénominateur, origine, pointE
Input: A, B, O, E
Output: F, a, T9, T10, T11

F: ((x(A) * x(B) + y(A) * y(B)) / (x(B)^(2) + y(B)^(2)), (x(B) * y(A) - x(A) * y(B)) / (x(B)^(2) + y(B)^(2)))
a = Vector(O, F)
T9 = Affixe(F)
T10 = Module(F)
T11 = Argument(F, O, E)

Tool: Quotient de 2 listes (command Quotientde2listes)
Divise terme à terme 2 listes de même longueur
Input: L1, L2
Output: Q

L1: {3, 6, 0, 7, 4}
n = Length(L1)
L2: {2, 7, 6, 9, 5}
Q = Sequence(Element[L1, i] / Element[L2, i], i, 1, n)

Tool: Somme
Clic sur point 1, point 2, origine, point E
Input: A, B, O, E
Output: C, w, T7, T8, T9

C: A + B
w = Vector(O, C)
T7 = Affixe(C)
T8 = Module(C)
T9 = Argument(C, O, E)

Tool: Somme de 2 listes (command Sommede2listes)
Additionne  terme à terme 2 listes de même longueur
Input: L1, L2
Output: S

L1: {1, 3, 5, 7, 9, 6, 4}
n = Length(L1)
L2: {1, 1, 1, 2, 2, 2, 1}
S = Sequence(Element[L1, i] + Element[L2, i], i, 1, n)

Tool: Poursuivre
Chasseur puis Cible
Input: E, F
Output: G

h_1 = Segment(E, F)
k = Circle(E, 2)
G = Intersect(k, h_1)

Tool: chase
Input: E, F, h
Output: G

h_1 = Segment(E, F)
k = Circle(E, 2 * h)
G = Intersect(k, h_1)

Tool: Déplacement
Input: A, B, v, t
Output: c, U, M, b

a = Ray(A, B)
c_1 = Circle(A, 1)
c = Circle(A, 1)
U = Intersect(c, a)
M: A + v * t * Vector[A, U]
b = Segment(A, M)