def solve():
print("Les coordonnées du vecteur u(x; y; z) sont :")
x1 = int_input("x = ")
print("La coordonnée en y est l'inconnue")
z1 = int_input("z = ")
print("Les coordonnées du vecteur v(x; y; z) sont :")
x2 = int_input("x = ")
y2 = int_input("y = ")
z2 = int_input("z = ")
y1 = Fraction(float(-(x1 * x2) - (z1 * z2)) /
float(y2)).limit_denominator()
print(f"La coordonnée en y doit être égale à {y1}")
def solve():
print(
"Les coefficients de l'équation paramétrique donnée ax + by + cz + d = 0 sont :"
)
a = int_input("a = ")
b = int_input("b = ")
c = int_input("c = ")
d = int_input("d = ")
print("Les coordonnées du point A sont :")
Ax = int_input("Ax = ")
Ay = int_input("Ay = ")
Az = int_input("Az = ")
print("Les coordonnées du point B sont :")
Bx = int_input("Bx = ")
By = int_input("By = ")
Bz = int_input("Bz = ")
# Calcul des coordonnées du vecteur AB
ABx = Bx - Ax
ABy = By - Ay
ABz = Bz - Az
# Vérifions si les points de la droite sont tous les deux inclus dans le plan
is_a_in_plane = a * Ax + b * Ay + c * Az + d == 0
is_b_in_plane = a * Bx + b * By + c * Bz + d == 0
if (is_a_in_plane and is_b_in_plane):
print("(AB) est incluse dans le plan")
else:
# Calcul du produit scalaire entre le vecteur normal au plan et le vecteur AB
scalar_product = a * ABx + b * ABy + c * ABz
# Vérification du parallélisme de (AB) au plan
if (scalar_product == 0):
print("(AB) est parallèle au plan")
else:
# La droite (AB) est sécante au plan
print("(AB) est sécante au plan")
# Calculons le point d'intersection
t = ((-a * Ax) + (-b * Ay) + (-c * Az) +
(-d)) / ((a * ABx) + (b * ABy) + (c * ABz))
Mx = Fraction(ABx * t + Ax).limit_denominator()
My = Fraction(ABy * t + Ay).limit_denominator()
Mz = Fraction(ABz * t + Az).limit_denominator()
print(
f"Le point d'intersection du plan et de la droite (AB) est M({Mx}; {My}; {Mz})"
)
# Vérifions si (AB) et le plan sont orthogonaux
if (ABx == 0 or ABy == 0 or ABz == 0):
print("(AB) et le plan NE sont PAS orthogonaux")
else:
if ((a / ABx) == (b / ABy) == (c / ABz)):
print("(AB) et le plan sont orthogonaux")
else:
print("(AB) et le plan NE sont PAS orthogonaux")
def solve():
print(
"Les coefficients de la première équation ax + by + cz = d du système sont :"
)
a1 = int_input("a = ")
b1 = int_input("b = ")
c1 = int_input("c = ")
d1 = int_input("d = ")
print(
"Les coefficients de la deuxième équation ax + by + cz = d du système sont :"
)
a2 = int_input("a = ")
b2 = int_input("b = ")
c2 = int_input("c = ")
d2 = int_input("d = ")
# Cas du plan
if ((a1 / a2) == (b1 / b2) == (c1 / c2) == (d1 / d2)):
print(
f"Les équations sont équivalentes, le système représente donc un plan de vecteur normal n({a1}; {b1}; {c1})"
)
# Cas de la droite
else:
# La droite a pour vecteur directeur un vecteur perpendiculaire au deux vecteurs normaux (produit vectoriel)
vector_product = np.cross((a1, b1, c1), (a2, b2, c2))
print(
f"Les équations sont différentes, le système représente donc une droite (ou l'ensemble vide)"
)
print(
f"Un vecteur directeur de cette droite est u({str(vector_product).replace(' ', '; ')[1:-1]})"
)
def solve():
print(
"Les coefficients de l'équation paramétrique donnée ax + by + cz + d = 0 sont :"
)
a = int_input("a = ")
b = int_input("b = ")
c = int_input("c = ")
d = int_input("d = ")
print("Les coordonnées du point A sont :")
ax = int_input("Ax = ")
ay = int_input("Ay = ")
az = int_input("Az = ")
print("Les coordonnées du point B sont :")
bx = int_input("Bx = ")
by = int_input("By = ")
bz = int_input("Bz = ")
AB = np.array([bx - ax, by - ay, bz - az])
# Vérifions si les points de la droite sont tous les deux inclus dans le plan
a_in_plane = a * ax + b * ay + c * az + d == 0
b_in_plane = a * bx + b * by + c * bz + d == 0
if (a_in_plane and b_in_plane):
print("(AB) est incluse dans le plan")
else:
# Calcul du produit scalaire entre le vecteur normal au plan et le vecteur AB
scalar_product = a * AB[0] + b * AB[1] + c * AB[2]
# Vérification du parallélisme de (AB) au plan
if (scalar_product == 0):
print("(AB) est parallèle au plan")
else:
# La droite (AB) est sécante au plan
print("(AB) est sécante au plan")
# Calculons le point d'intersection
t = ((-a * ax) + (-b * ay) + (-c * az) +
(-d)) / ((a * AB[0]) + (b * AB[1]) + (c * AB[2]))
Mx = Fraction(AB[0] * t + ax).limit_denominator()
My = Fraction(AB[1] * t + ay).limit_denominator()
Mz = Fraction(AB[2] * t + az).limit_denominator()
print(
f"Le point d'intersection du plan et de la droite (AB) est M({Mx}; {My}; {Mz})"
)
# Vérifions si (AB) et le plan sont orthogonaux
if (AB[0] == 0 or AB[1] == 0 or AB[2] == 0):
print("(AB) et le plan NE sont PAS orthogonaux")
else:
if ((a / AB[0]) == (b / AB[1]) == (c / AB[2])):
print("(AB) et le plan sont orthogonaux")
else:
print("(AB) et le plan NE sont PAS orthogonaux")
def solve():
print("La question est p(x ≤ t)")
t = int_input("t = ")
print(f"La probabilité p(x ≤ {t}) est égale à 1-e^(-{t}a)")
print(
"\nEntrez la valeur maximale que peut prendre la probabilité p, dans le dernier paragraphe (c'est un nombre décimal)"
)
m = float_input("m = ")
print(
f"L'intervalle est ]0; ln({Fraction(- m + 1).limit_denominator()})/(-{t})]"
)
def solve():
print("La question est :")
print("\t1. P(X ≤ a)")
print("\t2. P(X ≥ a)")
choix = 0
while not choix in [1, 2]:
choix = int_input("1 ou 2 ? ")
a = fraction_input("a = ")
p = fraction_input("Entrez la valeur de la probabilité P : ")
if choix == 1:
result = f"ln({- p + 1})/({- a})"
else:
result = f"ln({p})/({- a})"
print(f"\nLa paramètre λ est égal à {result}")
def solve():
print("Les constantes pour chacune des coordonnées de l'équation paramétrique de la droite (d) sont :")
print("La constante de la coordonnée en x est l'inconnue")
ya = int_input("y = a + bt, dans ce cas a = ")
za = int_input("z = a + bt, dans ce cas a = ")
print("Les coefficients pour chacune des coordonnées de l'équation paramétrique de la droite (d) sont :")
xb = int_input("x = a + bt, dans ce cas b = ")
yb = int_input(f"y = {ya} + bt, dans ce cas b = ")
zb = int_input(f"z = {za} + bt, dans ce cas b = ")
print("Les coordonnées du point M sont :")
mx = int_input("Mx = ")
my = int_input("My = ")
mz = int_input("Mz = ")
t = (my - ya) / yb
xa = Fraction(-xb * t + mx).limit_denominator()
print(f"La constante inconnue en x doit être égale à {xa}")
def solve():
p = fraction_input("Entrez le paramètre de la loi exponentielle : ")
print("La question est :")
print("\t1. P(X ≤ a)")
print("\t2. P(X ≥ a)")
choix = 0
while not choix in [1, 2]:
choix = int_input("1 ou 2 ? ")
a = fraction_input("a = ")
exponent = Fraction(-p * a).limit_denominator()
if choix == 1:
result = f"1 - e^({exponent})"
else:
result = f"e^({exponent})"
print(f"\nLa probabilité P est de {result}")
def solve():
print("Entrez les bornes de l'intervalle [a; b] :")
a = float_input("a = ")
b = float_input("b = ")
print("La question est :")
print("\t1. P(X ≤ y)")
print("\t2. P(X ≥ y)")
choix = 0
while not choix in [1, 2]:
choix = int_input("1 ou 2 ? ")
y = float_input("y = ")
if choix == 1:
result = Fraction(abs(y - a) * (1 / (b - a))).limit_denominator()
else:
result = Fraction(abs(b - y) * (1 / (b - a))).limit_denominator()
print(f"\nLa probabilité P est de {result}")
def solve():
print("Les coordonnées du point A sont :")
ax = int_input("Ax = ")
ay = int_input("Ay = ")
az = int_input("Az = ")
print("Les coordonnées du vecteur normal n(x; y; z) sont :")
a = Fraction(int_input("Nx = ")).limit_denominator()
b = Fraction(int_input("Ny = ")).limit_denominator()
c = Fraction(int_input("Nz = ")).limit_denominator()
d = Fraction(-(a * ax) - (b * ay) - (c * az)).limit_denominator()
print(f"Une équation cartésienne de P est {a} x + {b} y + {c} z + {d} = 0")
def solve():
print("Les coordonnées du point A sont :")
ax = int_input("Ax = ")
ay = int_input("Ay = ")
az = int_input("Az = ")
print("Les coordonnées du point B sont :")
bx = int_input("Bx = ")
by = int_input("By = ")
bz = int_input("Bz = ")
print("Les coordonnées du point C sont :")
cx = int_input("Cx = ")
cy = int_input("Cy = ")
cz = int_input("Cz = ")
AB = np.array([bx - ax, by - ay, bz - az])
AC = np.array([cx - ax, cy - ay, cz - az])
vector_product = np.cross(AB, AC)
a = Fraction(vector_product[0]).limit_denominator()
b = Fraction(vector_product[1]).limit_denominator()
c = Fraction(vector_product[2]).limit_denominator()
d = Fraction(-(a * ax) - (b * ay) - (c * az)).limit_denominator()
print(f"Une équation cartésienne de P est {a} x + {b} y + {c} z + {d} = 0")
def solve():
print("Les coordonnées du point A sont :")
Ax = int_input("Ax = ")
Ay = int_input("Ay = ")
Az = int_input("Az = ")
print("Les coordonnées du point B sont :")
Bx = int_input("Bx = ")
By = int_input("By = ")
Bz = int_input("Bz = ")
print("Les coordonnées du point C sont :")
Cx = int_input("Cx = ")
Cy = int_input("Cy = ")
Cz = int_input("Cz = ")
AB = np.array([Bx - Ax, By - Ay, Bz - Az])
AC = np.array([Cx - Ax, Cy - Ay, Cz - Az])
vector_product = np.cross(AB, AC)
a = Fraction(vector_product[0]).limit_denominator()
b = Fraction(vector_product[1]).limit_denominator()
c = Fraction(vector_product[2]).limit_denominator()
d = Fraction(-(a * Ax) - (b * Ay) - (c * Az)).limit_denominator()
print(f"Une équation cartésienne de P est {a} x + {b} y + {c} z + {d} = 0")
def solve():
print("Les coordonnées du point M sont :")
Mx = int_input("Mx = ")
My = int_input("My = ")
Mz = int_input("Mz = ")
print(
"Les coefficients pour chacune des coordonnées de l'équation paramétrique de la droite (d) sont :"
)
Xb = int_input("x = a + bt, dans ce cas b = ")
Yb = int_input("y = a + bt, dans ce cas b = ")
Zb = int_input("z = a + bt, dans ce cas b = ")
print(
"Les constantes pour chacune des coordonnées de l'équation paramétrique de la droite (d) sont :"
)
print("La constante de la coordonnée en x est l'inconnue")
Ya = int_input(f"y = a + {Yb}t, dans ce cas a = ")
Za = int_input(f"z = a + {Zb}t, dans ce cas a = ")
t = (My - Ya) / Yb
Xa = Fraction(-Xb * t + Mx).limit_denominator()
print(f"La constante inconnue en x doit être égale à {Xa}")
def solve():
print("X suit la loi normale N(u, o) :")
u = float_input("u = ")
o = float_input("o = ")
norm = normale.normale(u, o)
print("La question est :")
print("\t1. P(X ≤ a)")
print("\t2. P(X ≥ a)")
choix = 0
while not choix in [1, 2]:
choix = int_input("1 ou 2 ? ")
a = float_input("a = ")
if choix == 1:
p = round(norm.p_X_inf(a), 4)
print(f"\nP(X ≤ {a}) = {p}")
else:
p = round(norm.p_X_sup(a), 4)
print(f"\nP(X ≥ {a}) = {p}")
def solve():
print("Entrez les valeurs définissant la fonction f(x) = m*x^p :")
m = fraction_input("m = ")
p = int_input("p = ")
print("Entrez les bornes de l'intervalle [a; b] dans lequel se situe X :")
a = fraction_input("a = ")
b = fraction_input("b = ")
def F(x):
return Fraction((m / (p + 1)) * pow(x, (p + 1))).limit_denominator()
p_a = F(b) - F(a)
print(f"La probabilité que X prenne ses valeurs dans [{a}; {b}] est {round(float(p_a), 4)}")
print(
f"\nEntrez les bornes de l'intervalle [u; v] dans lequel se situe X sachant qu'il appartient à l'intervalle [{a}; {b}] :")
u = fraction_input("u = ")
v = fraction_input("v = ")
p_b = F(v) - F(u)
result = p_b / p_a
print(f"La probabilité P est de {round(float(result), 4)}")
def solve():
for i in range(4):
print(f"\tCouple n°{i + 1}")
print("Les coordonnées du vecteur normal u(x; y; z) sont :")
x1 = int_input("x = ")
y1 = int_input("y = ")
z1 = int_input("z = ")
print("Les coordonnées du vecteur normal v(x; y; z) sont :")
x2 = int_input("x = ")
y2 = int_input("y = ")
z2 = int_input("z = ")
scalar_product = np.dot((x1, y1, z1), (x2, y2, z2))
if scalar_product == 0:
print("Les deux plans sont orthogonaux")
else:
print("Les deux plans NE sont PAS orthogonaux")
def solve():
print(
"Les constantes pour chacune des coordonnées de l'équation paramétrique de la droite D sont :"
)
x1a = int_input("x = a + bt, dans ce cas a = ")
y1a = int_input("y = a + bt, dans ce cas a = ")
z1a = int_input("z = a + bt, dans ce cas a = ")
print(
"Les coefficients pour chacune des coordonnées de l'équation paramétrique de la droite D sont :"
)
x1b = int_input(f"x = {x1a} + bt, dans ce cas b = ")
y1b = int_input(f"y = {y1a} + bt, dans ce cas b = ")
z1b = int_input(f"z = {z1a} + bt, dans ce cas b = ")
print(
"Les constantes pour chacune des coordonnées de l'équation paramétrique de la droite D' sont :"
)
x2a = int_input("x = a + bt, dans ce cas a = ")
y2a = int_input("y = a + bt, dans ce cas a = ")
z2a = int_input("z = a + bt, dans ce cas a = ")
print(
"Les coefficients pour chacune des coordonnées de l'équation paramétrique de la droite D' sont :"
)
x2b = int_input(f"x = {x2a} + bt, dans ce cas b = ")
y2b = int_input(f"y = {y2a} + bt, dans ce cas b = ")
z2b = int_input(f"z = {z2a} + bt, dans ce cas b = ")
# On résout le système d'équations linéaires.
m1 = np.array([[x1b, -x2b], [y1b - z1b, -y2b + z2b]])
m2 = np.array([(x2a - x1a), (y2a - y1a - z2a + z1a)])
t1 = np.linalg.solve(m1, m2)[0]
# On calcule les coordonnées du point d'intersection.
x = Fraction(x1b * t1 + x1a).limit_denominator()
y = Fraction(y1b * t1 + y1a).limit_denominator()
z = Fraction(z1b * t1 + z1a).limit_denominator()
print(f"Le point d'intersection des deux droites est M({x}; {y}; {z})")
# Recherche d'une nouvelle mise à jour.
check_for_updates = True
if check_for_updates:
update_info_url = "https://yougi3.github.io/Kwyk-Solver/update_info.json"
update_info = updater.get_update_info(update_info_url)
if update_info is not None:
update_version = update_info["version"]
if (update_version.strip() != version.strip()):
print(
f"\n! Une nouvelle mise à jour est disponible (version {update_version})."
)
if input("Souhaitez-vous la télécharger et l'installer ? (o/N) : "
).strip().lower() == "o":
updater.download_and_install(update_info["url"])
else:
print("Mise à jour ignorée.")
supported_ex = (260, 20110, 20116, 20118, 20119, 20124, 20128, 20129, 28036,
28037)
while True:
print(f"\nExercices supportés : {str(supported_ex)[1:-1]}")
ex = int_input("Entrez le numéro de l'exercice : ")
if ex in supported_ex:
print()
exec(f"from solvers import solver_{ex}")
exec(f"solver_{ex}.solve()")
else:
print("Exercice non supporté par le solveur.")
def solve():
print("Les coordonnées du point A sont :")
ax = int_input("Ax = ")
ay = int_input("Ay = ")
az = int_input("Az = ")
print("Les coordonnées du point B sont :")
bx = int_input("Bx = ")
by = int_input("By = ")
bz = int_input("Bz = ")
print("Les coordonnées du point C sont :")
cx = int_input("Cx = ")
cy = int_input("Cy = ")
cz = int_input("Cz = ")
print("Les coordonnées du point D sont :")
dx = int_input("Dx = ")
dy = int_input("Dy = ")
dz = int_input("Dz = ")
AB = np.array([bx - ax, by - ay, bz - az])
CD = np.array([dx - cx, dy - cy, dz - cz])
m1 = np.array([[AB[0], -CD[0]], [AB[1] - AB[2], -CD[1] - (-CD[2])]])
m2 = np.array([(cx - ax), ((cy - ay) - (cz - az))])
t1 = np.linalg.solve(m1, m2)[0]
x = Fraction(AB[0] * t1 + ax).limit_denominator()
y = Fraction(AB[1] * t1 + ay).limit_denominator()
z = Fraction(AB[2] * t1 + az).limit_denominator()
print(f"Le point d'intersection des deux droites est M({x}; {y}; {z})")
def solve():
print(
"Les constantes pour chacune des coordonnées de l'équation paramétrique de la droite D sont :"
)
Xa1 = int_input("x = a + bt, dans ce cas a = ")
Ya1 = int_input("y = a + bt, dans ce cas a = ")
Za1 = int_input("z = a + bt, dans ce cas a = ")
print(
"Les coefficients pour chacune des coordonnées de l'équation paramétrique de la droite D sont :"
)
Xb1 = int_input(f"x = {Xa1} + bt, dans ce cas b = ")
Yb1 = int_input(f"y = {Ya1} + bt, dans ce cas b = ")
Zb1 = int_input(f"z = {Za1} + bt, dans ce cas b = ")
print(
"Les constantes pour chacune des coordonnées de l'équation paramétrique de la droite D' sont :"
)
Xa2 = int_input("x = a + bt, dans ce cas a = ")
Ya2 = int_input("y = a + bt, dans ce cas a = ")
Za2 = int_input("z = a + bt, dans ce cas a = ")
print(
"Les coefficients pour chacune des coordonnées de l'équation paramétrique de la droite D' sont :"
)
Xb2 = int_input(f"x = {Xa2} + bt, dans ce cas b = ")
Yb2 = int_input(f"y = {Ya2} + bt, dans ce cas b = ")
Zb2 = int_input(f"z = {Za2} + bt, dans ce cas b = ")
# On résout le système d'équations linéaires.
m1 = np.array([[Xb1, -Xb2], [Yb1 - Zb1, -Yb2 + Zb2]])
m2 = np.array([(Xa2 - Xa1), (Ya2 - Ya1 - Za2 + Za1)])
t1 = np.linalg.solve(m1, m2)[0]
# On calcule les coordonnées du point d'intersection.
x = Fraction(Xb1 * t1 + Xa1).limit_denominator()
y = Fraction(Yb1 * t1 + Ya1).limit_denominator()
z = Fraction(Zb1 * t1 + Za1).limit_denominator()
print(f"Le point d'intersection des deux droites est M({x}; {y}; {z})")
def solve():
print("Les coordonnées du point A sont :")
Ax = int_input("Ax = ")
Ay = int_input("Ay = ")
Az = int_input("Az = ")
print("Les coordonnées du point B sont :")
Bx = int_input("Bx = ")
By = int_input("By = ")
Bz = int_input("Bz = ")
print("Les coordonnées du point C sont :")
Cx = int_input("Cx = ")
Cy = int_input("Cy = ")
Cz = int_input("Cz = ")
print("Les coordonnées du point D sont :")
Dx = int_input("Dx = ")
Dy = int_input("Dy = ")
Dz = int_input("Dz = ")
AB = np.array([Bx - Ax, By - Ay, Bz - Az])
CD = np.array([Dx - Cx, Dy - Cy, Dz - Cz])
m1 = np.array([[AB[0], -CD[0]], [AB[1] - AB[2], -CD[1] - (-CD[2])]])
m2 = np.array([(Cx - Ax), ((Cy - Ay) - (Cz - Az))])
t1 = np.linalg.solve(m1, m2)[0]
x = Fraction(AB[0] * t1 + Ax).limit_denominator()
y = Fraction(AB[1] * t1 + Ay).limit_denominator()
z = Fraction(AB[2] * t1 + Az).limit_denominator()
print(f"Le point d'intersection des deux droites est M({x}; {y}; {z})")
solvers_directory_path = f"{os.curdir}/solvers/"
# Affichage de la liste des exercices supportés en se basant sur les fichiers
# présents dans le dossier 'solvers'.
supported_ex = []
solver_filename_pattern = "solver_([0123456789]+).py"
for file in os.listdir(solvers_directory_path):
solver_filename_match = re.match(solver_filename_pattern, file)
if solver_filename_match:
# On récupère le numéro de l'exercice, celui-ci étant inclus dans
# le nom du fichier.
supported_ex.append(int(solver_filename_match.group(1)))
# On trie la liste dans l'ordre croissant et on l'affiche à l'utilisateur.
supported_ex.sort()
print(
f"\nExercices supportés : {rreplace(str(supported_ex), ',', ' et', 1)[1:-1]}."
)
while True:
print(f"\n{'-' * (len(prompt) - 1)}\n")
ex = int_input(prompt)
if ex in supported_ex:
print()
try:
exec(f"from solvers import solver_{ex}")
exec(f"solver_{ex}.solve()")
except Exception as e:
print(f"\n(!) Une erreur est survenue : {str(e)}.")
else:
print("\n(!) Exercice non supporté par le solveur.")
