(d)

Courbe du chien

v_C = 5.5 (slider from 0 to 50, step 0.1)
t = 0.395 (slider from 0 to 10, step 0.0010)
v_P = 5 (slider from 0 to 50, step 0.1)
C_0 = (0, 0)
h = 6 (slider from 0 to 20, step 1)
P_0: (0.0, h)
R: (6.0, h)
b = Ray(P_0, R)
e, E, P, g = Déplacement(P_0, R, v_P, t)
A = Point(xAxis)
distanceP0P = Distance(P_0, P)
TexteP0P: Name[P_0] + (Name[P]) + " \, = \, " + distanceP0P
n = 0.1 (slider from 0 to 1, step 0.1)
A1: (0.0, h)
A2: A1 + (n * v_P, 0.0)
A3: A2 + (n * v_P, 0.0)
A4: A3 + (n * v_P, 0.0)
A5: A4 + (n * v_P, 0.0)
A6: A5 + (n * v_P, 0.0)
A7: A6 + (n * v_P, 0.0)
A8: A7 + (n * v_P, 0.0)
A9: A8 + (n * v_P, 0.0)
A10: A9 + (n * v_P, 0.0)
A11: A10 + (n * v_P, 0.0)
A12: A11 + (n * v_P, 0.0)
A13: A12 + (n * v_P, 0.0)
A14: A13 + (n * v_P, 0.0)
A15: A14 + (n * v_P, 0.0)
B1 = (0, 0)
B2: B1 + n * v_C / h * Vector[B1, A1]
B3: B2 + n * v_C / h * Vector[B2, A2]
B4: B3 + n * v_C / h * Vector[B3, A3]
B5: B4 + n * v_C / h * Vector[B4, A4]
B6: B5 + n * v_C / h * Vector[B5, A5]
B7: B6 + n * v_C / h * Vector[B6, A6]
B8: B7 + n * v_C / h * Vector[B7, A7]
B9: B8 + n * v_C / h * Vector[B8, A8]
B10: B9 + n * v_C / h * Vector[B9, A9]
B11: B10 + n * v_C / h * Vector[B10, A10]
B12: B11 + n * v_C / h * Vector[B11, A11]
B13: B12 + n * v_C / h * Vector[B12, A12]
B14: B13 + n * v_C / h * Vector[B13, A13]
B15: B14 + n * v_C / h * Vector[B14, A14]
p = Segment(B2, A2)
q = Segment(B3, A3)
r = Segment(B4, A4)
o = true
a = Segment(B15, A15)
L_1: {A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15}

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.0) + "π"

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

Abarre: (x(A), -1.0 * 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) < 0.0, A, Midpoint[A, B])
D = If(f(x(A)) * f((x(A) + x(B)) / 2.0) < 0.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.0, x(C))
M: (x(C), I)
loc1 = Locus(M, C)

Tool: Fonct. réciproque (command Fonct)
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.0 * (x + 0.14)^(7.0) - 2.0 * (x + 0.14)^(4.0) + 9.0 * (x + 0.14)^(3.0) - (x + 0.14)
list1: {Root[f(x)]}
S = Sequence(x(Element[list1, i]), i, 1.0, 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.0) - 3.0 * x
list1 = Sequence(f(a + i * (b - a) / 1000.0), i, 0.0, 1000.0)
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.0) - 3.0 * x
list1 = Sequence(f(a + i * (b - a) / 1000.0), i, 0.0, 1000.0)
m = Min(list1)

Tool: Module
Input: A
Output: T5

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

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.0, 1.0, 1.0, 2.0, 2.0, 2.0, 1.0}
n = Length(L1)
L2: {1.0, 3.0, 5.0, 7.0, 9.0, 6.0, 4.0}
P = Sequence(Element[L1, i] * Element[L2, i], i, 1.0, 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.0) + y(B)^(2.0)), (x(B) * y(A) - x(A) * y(B)) / (x(B)^(2.0) + y(B)^(2.0)))
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.0, 6.0, 0.0, 7.0, 4.0}
n = Length(L1)
L2: {2.0, 7.0, 6.0, 9.0, 5.0}
Q = Sequence(Element[L1, i] / Element[L2, i], i, 1.0, 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.0, 3.0, 5.0, 7.0, 9.0, 6.0, 4.0}
n = Length(L1)
L2: {1.0, 1.0, 1.0, 2.0, 2.0, 2.0, 1.0}
S = Sequence(Element[L1, i] + Element[L2, i], i, 1.0, n)

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

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

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

h_1 = Segment(E, F)
k = Circle(E, 2.0 * 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.0)
c = Circle(A, 1.0)
U = Intersect(c, a)
M: A + v * t * Vector[A, U]
b = Segment(A, M)