math-exercises 3.0.170 → 3.0.172

package/lib/exercises/math/geometry/vectors/scalarProduct/angleFromScalarProduct.js

@@ -9,6 +9,7 @@ import { frac } from "../../../../../tree/nodes/operators/fractionNode.js";
 import { multiply } from "../../../../../tree/nodes/operators/multiplyNode.js";
 import { degreeParser } from "../../../../../tree/parsers/degreeParser.js";
 import { handleVEAError } from "../../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../../utils/latex/alignTex.js";
 const getPoints = (identifiers) => {
     return identifiers.pointsIdentifiers.map(PointConstructor.fromIdentifiers);
 };
@@ -38,8 +39,92 @@ const getInstruction = (identifiers) => {
   
 Donner une mesure, arrondie au degré, de l'angle $\\widehat{${names.join("")}}$.`;
 };
-// const getHint: GetHint<Identifiers> = (identifiers) => {};
-// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {};
+const getHint = (identifiers) => {
+    const points = getPoints(identifiers);
+    const names = points.map((p) => p.name);
+    const [nA, nB, nC] = names;
+    const u = `\\overrightarrow{${nB}${nA}}`;
+    const v = `\\overrightarrow{${nB}${nC}}`;
+    return `L'angle $\\widehat{${nA}${nB}${nC}}$ est formé par les vecteurs $${u}$ et $${v}$. 
+Calcule leur produit scalaire puis utilise sa définition : 
+
+$$
+${u} \\cdot ${v} = \\lVert{${nB}${nA}}\\rVert \\times \\lVert{${nB}${nC}}\\rVert \\times \\cos(\\widehat{${nA}${nB}${nC}}) 
+$$
+
+Tu pourras alors déterminer $\\cos(\\widehat{${nA}${nB}${nC}})$ et en déduire une mesure de l'angle $\\widehat{${nA}${nB}${nC}}$.`;
+};
+const getCorrection = (identifiers) => {
+    const points = getPoints(identifiers);
+    const names = points.map((p) => p.name);
+    const u = `\\overrightarrow{${names[1]}${names[0]}}`;
+    const v = `\\overrightarrow{${names[1]}${names[2]}}`;
+    const vecURaw = VectorConstructor.fromPointsRaw(points[1], points[0]);
+    const vecVRaw = VectorConstructor.fromPointsRaw(points[1], points[2]);
+    const vecU = vecURaw.simplify();
+    const vecV = vecVRaw.simplify();
+    const nodeNormU = vecU.getNorm();
+    const nodeNormV = vecV.getNorm();
+    const nodeScalarProduct = vecU.scalarProduct(vecV);
+    const nodeNormUSimplified = nodeNormU.simplify();
+    const nodeNormVSimplified = nodeNormV.simplify();
+    const nodeScalarProductSimplified = nodeScalarProduct.simplify();
+    const angleName = `\\widehat{${names.join("")}}`;
+    return `D'après la définition du produit scalaire : 
+
+$$
+${u} \\cdot ${v} = \\lVert ${u} \\rVert \\times \\lVert ${v} \\rVert \\times \\cos(${angleName})
+$$
+
+Or : 
+
+$$
+${u} = ${vecURaw.toCoords()} = ${vecU.toCoords()}
+$$
+
+$$
+${v} = ${vecVRaw.toCoords()} = ${vecV.toCoords()}
+$$
+
+Ainsi :
+
+${alignTex([
+        [`${u} \\cdot ${v}`, "=", nodeScalarProduct.toTex()],
+        ["", "=", nodeScalarProductSimplified.toTex()],
+    ])}
+
+On calcule ensuite les normes des vecteurs : 
+
+${alignTex([
+        [`\\lVert ${u} \\rVert`, "=", nodeNormU.toTex()],
+        ["", "=", nodeNormUSimplified.toTex()],
+    ])}
+
+${alignTex([
+        [`\\lVert ${v} \\rVert`, "=", nodeNormV.toTex()],
+        ["", "=", nodeNormVSimplified.toTex()],
+    ])}
+
+On remplace alors ces valeurs dans l’égalité du produit scalaire : 
+
+$$
+${nodeScalarProductSimplified.toTex()} = ${nodeNormUSimplified.toTex()} \\times  ${nodeNormVSimplified.toTex()} \\times \\cos(${angleName})
+$$
+
+D’où: 
+
+$$
+\\cos(${angleName}) = \\frac{${nodeScalarProductSimplified.toTex()}}{${nodeNormUSimplified.toTex()} \\times ${nodeNormVSimplified.toTex()}}
+$$
+
+Enfin, on utilise la fonction $\\cos^{-1}$ de la calculatrice pour en déduire une mesure de $${angleName}$ : 
+
+$$
+${angleName} \\approx ${getAnswer(identifiers)}
+$$
+
+`;
+};
 const getKeys = () => {
     return ["degree"];
 };
@@ -70,8 +155,8 @@ const getQuestionFromIdentifiers = (identifiers) => {
         keys: getKeys(identifiers),
         answerFormat: "tex",
         identifiers,
-        // hint: getHint(identifiers),
-        // correction: getCorrection(identifiers),
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
 };
 export const angleFromScalarProduct = {
@@ -86,8 +171,9 @@ export const angleFromScalarProduct = {
     isAnswerValid,
     subject: "Mathématiques",
     getInstruction,
-    // getHint,
-    // getCorrection,
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
     getAnswer,
     getQuestionFromIdentifiers,
 };

package/lib/exercises/math/geometry/vectors/scalarProduct/index.d.ts

@@ -2,7 +2,12 @@ export * from "./scalarProductViaCoords.js";
 export * from "./scalarProductViaCos.js";
 export * from "./scalarProductOrthoInSquare.js";
 export * from "./scalarProductViaNorms.js";
-export * from "./scalarProductIdentities.js";
 export * from "./angleFromScalarProduct.js";
 export * from "./findCoordinatesToOrthogonalize.js";
+export * from "./scalarProductOfVectsOnGrid1.js";
+export * from "./scalarProductComputeBH.js";
+export * from "./scalarProductParallelogramDiagonalPlus.js";
+export * from "./alg/index.js";
+export * from "./orth/index.js";
+export * from "./alKashi/index.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/geometry/vectors/scalarProduct/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/geometry/vectors/scalarProduct/index.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAC;AAC5C,cAAc,0BAA0B,CAAC;AAEzC,cAAc,iCAAiC,CAAC;AAChD,cAAc,4BAA4B,CAAC;AAC3C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,qCAAqC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/geometry/vectors/scalarProduct/index.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAC;AAC5C,cAAc,0BAA0B,CAAC;AAEzC,cAAc,iCAAiC,CAAC;AAChD,cAAc,4BAA4B,CAAC;AAC3C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,qCAAqC,CAAC;AAEpD,cAAc,kCAAkC,CAAC;AACjD,cAAc,6BAA6B,CAAC;AAC5C,cAAc,6CAA6C,CAAC;AAE5D,cAAc,gBAAgB,CAAC;AAC/B,cAAc,iBAAiB,CAAC;AAChC,cAAc,oBAAoB,CAAC"}

package/lib/exercises/math/geometry/vectors/scalarProduct/index.js

@@ -2,6 +2,11 @@ export * from "./scalarProductViaCoords.js";
 export * from "./scalarProductViaCos.js";
 export * from "./scalarProductOrthoInSquare.js";
 export * from "./scalarProductViaNorms.js";
-export * from "./scalarProductIdentities.js";
 export * from "./angleFromScalarProduct.js";
 export * from "./findCoordinatesToOrthogonalize.js";
+export * from "./scalarProductOfVectsOnGrid1.js";
+export * from "./scalarProductComputeBH.js";
+export * from "./scalarProductParallelogramDiagonalPlus.js";
+export * from "./alg/index.js";
+export * from "./orth/index.js";
+export * from "./alKashi/index.js";

package/lib/exercises/math/geometry/vectors/scalarProduct/orth/scalarProductIsOrthogonalVecsBasisIJ.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scalarProductIsOrthogonalVecsBasisIJ.d.ts","sourceRoot":"","sources":["../../../../../../../src/exercises/math/geometry/vectors/scalarProduct/orth/scalarProductIsOrthogonalVecsBasisIJ.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAO7C,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,eAAe,EAAE,CAAC;IAC5B,QAAQ,EAAE,eAAe,EAAE,CAAC;CAC7B,CAAC;AAqNF,eAAO,MAAM,oCAAoC,EAAE,QAAQ,CAAC,WAAW,CAsBtE,CAAC"}
+{"version":3,"file":"scalarProductIsOrthogonalVecsBasisIJ.d.ts","sourceRoot":"","sources":["../../../../../../../src/exercises/math/geometry/vectors/scalarProduct/orth/scalarProductIsOrthogonalVecsBasisIJ.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAO7C,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,eAAe,EAAE,CAAC;IAC5B,QAAQ,EAAE,eAAe,EAAE,CAAC;CAC7B,CAAC;AA2NF,eAAO,MAAM,oCAAoC,EAAE,QAAQ,CAAC,WAAW,CAsBtE,CAAC"}

package/lib/exercises/math/geometry/vectors/scalarProduct/orth/scalarProductIsOrthogonalVecsBasisIJ.js

@@ -123,6 +123,12 @@ $$
 ${i} \\cdot ${j} = ${j} \\cdot ${i} = 0
 $$
 
+On a :
+
+$$
+${i} \\cdot ${i} = ${j} \\cdot ${j} = 1
+$$
+
 On peut donc calculer le produit scalaire en utilisant les coordonnées dans la base $(${i},${j})$ de la même manière que lorsque l'on travaille dans la base canonique du plan. 
 
 ${alignTex([

package/lib/exercises/math/geometry/vectors/scalarProduct/orth/scalarProductIsOrthogonalVecsUsingCoords.js

@@ -27,7 +27,7 @@ $$
 ${v} = ${vecV.toCoords()}
 $$
   
-Les vecteurs $u$ et $v$ sont-ils orthogonaux ?`;
+Les vecteurs $${u}$ et $${v}$ sont-ils orthogonaux ?`;
 };
 const getAnswerNode = (identifiers) => {
     const { vecU, vecV } = getHydrated(identifiers);

package/lib/exercises/math/geometry/vectors/scalarProduct/orth/scalarProductIsPointOnCircle.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scalarProductIsPointOnCircle.d.ts","sourceRoot":"","sources":["../../../../../../../src/exercises/math/geometry/vectors/scalarProduct/orth/scalarProductIsPointOnCircle.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AACtC,OAAO,EAGL,iBAAiB,EAClB,MAAM,+BAA+B,CAAC;AAYvC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,iBAAiB,CAAC;IAC3B,OAAO,EAAE,iBAAiB,CAAC;IAC3B,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB,CAAC;AA8LF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,CAmB9D,CAAC"}
+{"version":3,"file":"scalarProductIsPointOnCircle.d.ts","sourceRoot":"","sources":["../../../../../../../src/exercises/math/geometry/vectors/scalarProduct/orth/scalarProductIsPointOnCircle.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AACtC,OAAO,EAGL,iBAAiB,EAClB,MAAM,+BAA+B,CAAC;AAYvC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,iBAAiB,CAAC;IAC3B,OAAO,EAAE,iBAAiB,CAAC;IAC3B,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB,CAAC;AA4MF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,CAmB9D,CAAC"}

package/lib/exercises/math/geometry/vectors/scalarProduct/orth/scalarProductIsPointOnCircle.js

@@ -54,9 +54,12 @@ const getAnswer = (identifiers) => {
     const isOrthogonal = answerNode.simplify().evaluate() === 0;
     return ["Oui", "Non"][isOrthogonal ? 0 : 1];
 };
-const getHint = () => {
-    const [a, b] = ["a", "b"].map((letter) => `\\overrightarrow{${letter}}`);
-    return `Deux vecteurs $${a}$ et $${b}$ sont orthogonaux si et seulement si $${a} \\cdot ${b} = 0$.`;
+const getHint = (identifiers) => {
+    const { pointNames } = identifiers;
+    const [nA, nB, nC] = pointNames;
+    const [vecAB, vecAC] = [`${nA}${nB}`, `${nA}${nC}`].map((letter) => `\\overrightarrow{${letter}}`);
+    return `Un point $${nA}$ appartient à un cercle de diamètre $[${nB}${nC}]$ si et seulement si le triangle $${nA}${nB}${nC}$ est rectangle en $${nA}$, 
+donc si et seulement si les vecteurs $${vecAB}$ et $${vecAC}$ sont orthogonaux.`;
 };
 const getCorrection = (identifiers) => {
     const { pointNames } = identifiers;
@@ -72,7 +75,14 @@ const getCorrection = (identifiers) => {
     const vecComputationV = createVecComputation(point1, point3);
     const isOrthogonal = getAnswerNode(identifiers).simplify().evaluate() === 0;
     const nodeScalarProduct = vecU.scalarProduct(vecV);
-    return `On calcule les coordonnées des vecteurs :
+    return `${(() => {
+        const [nA, nB, nC] = pointNames;
+        const [vecAB, vecAC] = [`${nA}${nB}`, `${nA}${nC}`].map((letter) => `\\overrightarrow{${letter}}`);
+        return `Le point $${nA}$ appartient au cercle de diamètre $[${nB}${nC}]$ si et seulement si le triangle $${nA}${nB}${nC}$ est rectangle en $${nA}$, 
+donc si et seulement si les vecteurs $${vecAB}$ et $${vecAC}$ sont orthogonaux.`;
+    })()}
+  
+On calcule les coordonnées des vecteurs :
 
 ${zip([vecComputationU, vecComputationV], [vecU, vecV]).map(([vecComputation, vec]) => `
 
@@ -150,7 +160,7 @@ const getQuestionFromIdentifiers = (identifiers, opts) => {
 export const scalarProductIsPointOnCircle = {
     id: "scalarProductIsPointOnCircle",
     connector: "=",
-    label: "Déterminer si un point appartient ou non à un cercle de diamètre donné",
+    label: "Déterminer si un point appartient ou non à un cercle de diamètre donné à l'aide du produit scalaire",
     isSingleStep: true,
     generator: (nb) => getDistinctQuestions(() => getScalarProductIsPointOnCircleQuestion(), nb),
     qcmTimer: 60,

package/lib/exercises/math/geometry/vectors/scalarProduct/orth/scalarProductIsPointOnPerpendicularBisector.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scalarProductIsPointOnPerpendicularBisector.d.ts","sourceRoot":"","sources":["../../../../../../../src/exercises/math/geometry/vectors/scalarProduct/orth/scalarProductIsPointOnPerpendicularBisector.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AACtC,OAAO,EAGL,iBAAiB,EAClB,MAAM,+BAA+B,CAAC;AAavC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,iBAAiB,CAAC;IAC3B,OAAO,EAAE,iBAAiB,CAAC;IAC3B,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB,CAAC;AAmNF,eAAO,MAAM,2CAA2C,EAAE,QAAQ,CAAC,WAAW,CAsB3E,CAAC"}
+{"version":3,"file":"scalarProductIsPointOnPerpendicularBisector.d.ts","sourceRoot":"","sources":["../../../../../../../src/exercises/math/geometry/vectors/scalarProduct/orth/scalarProductIsPointOnPerpendicularBisector.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AACtC,OAAO,EAGL,iBAAiB,EAClB,MAAM,+BAA+B,CAAC;AAavC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,iBAAiB,CAAC;IAC3B,OAAO,EAAE,iBAAiB,CAAC;IAC3B,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB,CAAC;AA2NF,eAAO,MAAM,2CAA2C,EAAE,QAAQ,CAAC,WAAW,CAuB3E,CAAC"}

package/lib/exercises/math/geometry/vectors/scalarProduct/orth/scalarProductIsPointOnPerpendicularBisector.js

@@ -53,9 +53,13 @@ const getAnswer = (identifiers) => {
     const isOrthogonal = answerNode.simplify().evaluate() === 0;
     return ["Oui", "Non"][isOrthogonal ? 0 : 1];
 };
-const getHint = () => {
-    const [a, b] = ["a", "b"].map((letter) => `\\overrightarrow{${letter}}`);
-    return `Deux vecteurs $${a}$ et $${b}$ sont orthogonaux si et seulement si $${a} \\cdot ${b} = 0$.`;
+const getHint = (identifiers) => {
+    const { pointNames } = identifiers;
+    const [nA, nB, nC] = pointNames;
+    const [vecCI, vecAB] = [`${nC}I`, `${nA}${nB}`].map((letter) => `\\overrightarrow{${letter}}`);
+    return `La médiatrice du segment $[${nA}${nB}]$ est la droite passant par le milieu $I$ de $[${nA}${nB}]$ et qui est perpendiculaire à $(${nA}${nB})$. 
+Un point $${nC}$ appartient donc à cette médiatrice si et seulement si $(${nC}I)$ est perpendiculaire à $(${nA}${nB})$, 
+c'est à dire si les vecteurs $${vecCI}$ et $${vecAB}$ sont orthognaux.`;
 };
 const getCorrection = (identifiers) => {
     const { pointNames, pointIds } = identifiers;
@@ -73,17 +77,17 @@ const getCorrection = (identifiers) => {
     const vecComputationV = createVecComputation(pointI, point3);
     const isOrthogonal = getAnswerNode(identifiers).simplify().evaluate() === 0;
     const nodeScalarProduct = vecU.scalarProduct(vecV);
-    return `On nomme $O$ l'origine du repère et $I$ le milieu de $[${point1.name}${point2.name}]$. On a :
+    return `${(() => {
+        const [nA, nB, nC] = pointNames;
+        const [vecCI, vecAB] = [`${nC}I`, `${nA}${nB}`].map((letter) => `\\overrightarrow{${letter}}`);
+        return `La médiatrice du segment $[${nA}${nB}]$ est la droite passant par le milieu $I$ de $[${nA}${nB}]$ et qui est perpendiculaire à $(${nA}${nB})$. 
+Le point $${nC}$ appartient donc à cette médiatrice si et seulement si $(${nC}I)$ est perpendiculaire à $(${nA}${nB})$, 
+c'est à dire si les vecteurs $${vecCI}$ et $${vecAB}$ sont orthognaux.`;
+    })()}
+  
+  On détermine les coordonnées du milieu $I$ de $[${point1.name}${point2.name}]$ :
 
-${alignTex([
-        [
-            "\\overrightarrow{OI}",
-            "=",
-            `\\frac{\\overrightarrow{O${point1.name}} + \\overrightarrow{O${point2.name}}}{2}`,
-        ],
-        ["", "=", `${vecOI.toCoords()}`],
-        ["", "=", `${vecOI.simplify().toCoords()}`],
-    ])}
+${alignTex([[`I${vecOI.toCoords()}`], [`I${vecOI.simplify().toCoords()}`]])}
 
 On peut calculer les coordonnées des vecteurs :
 
@@ -163,7 +167,7 @@ const getQuestionFromIdentifiers = (identifiers, opts) => {
 export const scalarProductIsPointOnPerpendicularBisector = {
     id: "scalarProductIsPointOnPerpendicularBisector",
     connector: "=",
-    label: "Déterminer si un point appartient à la médiatrice d'un segment",
+    label: "Déterminer si un point appartient à la médiatrice d'un segment à l'aide du produit scalaire",
     isSingleStep: true,
     generator: (nb) => getDistinctQuestions(() => getScalarProductIsPointOnPerpendicularBisectorQuestion(), nb),
     qcmTimer: 60,

package/lib/exercises/math/geometry/vectors/scalarProduct/orth/scalarProductIsRightTriangleUsingPointCoords.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scalarProductIsRightTriangleUsingPointCoords.d.ts","sourceRoot":"","sources":["../../../../../../../src/exercises/math/geometry/vectors/scalarProduct/orth/scalarProductIsRightTriangleUsingPointCoords.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AACtC,OAAO,EAGL,iBAAiB,EAClB,MAAM,+BAA+B,CAAC;AAYvC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,iBAAiB,CAAC;IAC3B,OAAO,EAAE,iBAAiB,CAAC;IAC3B,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB,CAAC;AAiQF,eAAO,MAAM,4CAA4C,EAAE,QAAQ,CAAC,WAAW,CAuB5E,CAAC"}
+{"version":3,"file":"scalarProductIsRightTriangleUsingPointCoords.d.ts","sourceRoot":"","sources":["../../../../../../../src/exercises/math/geometry/vectors/scalarProduct/orth/scalarProductIsRightTriangleUsingPointCoords.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AACtC,OAAO,EAGL,iBAAiB,EAClB,MAAM,+BAA+B,CAAC;AAYvC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,iBAAiB,CAAC;IAC3B,OAAO,EAAE,iBAAiB,CAAC;IAC3B,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB,CAAC;AA+QF,eAAO,MAAM,4CAA4C,EAAE,QAAQ,CAAC,WAAW,CAuB5E,CAAC"}

package/lib/exercises/math/geometry/vectors/scalarProduct/orth/scalarProductIsRightTriangleUsingPointCoords.js

@@ -61,9 +61,12 @@ const getAnswer = (identifiers) => {
     const isOrthogonal = answerNode.simplify().evaluate() === 0;
     return ["Oui", "Non"][isOrthogonal ? 0 : 1];
 };
-const getHint = () => {
-    const [a, b] = ["a", "b"].map((letter) => `\\overrightarrow{${letter}}`);
-    return `Deux vecteurs $${a}$ et $${b}$ sont orthogonaux si et seulement si $${a} \\cdot ${b} = 0$.`;
+const getHint = (identifiers) => {
+    const { pointNames } = identifiers;
+    const [nA, nB, nC] = pointNames;
+    const [vecAB, vecBC] = [`${nA}${nB}`, `${nB}${nC}`].map((letter) => `\\overrightarrow{${letter}}`);
+    return `Un triangle $${nA}${nB}${nC}$ est rectangle en $${nB}$ si et seulement si les droites $(${nA}${nB})$ et $(${nB}${nC})$ sont perpendiculaires, 
+donc si et seulement si les vecteurs $${vecAB}$ et $${vecBC}$ sont orthognaux.`;
 };
 const getCorrection = (identifiers) => {
     const { pointNames } = identifiers;
@@ -79,7 +82,14 @@ const getCorrection = (identifiers) => {
     const vecComputationV = createVecComputation(point1, point3);
     const vecComputationW = createVecComputation(point2, point3);
     const isOrthogonal = getAnswerNode(identifiers).simplify().evaluate() === 0;
-    return `On calcule les coordonnées des vecteurs :
+    return `${(() => {
+        const [nA, nB, nC] = pointNames;
+        const [vecAB, vecBC] = [`${nA}${nB}`, `${nB}${nC}`].map((letter) => `\\overrightarrow{${letter}}`);
+        return `Le triangle $${nA}${nB}${nC}$ est rectangle en $${nB}$ si et seulement si les droites $(${nA}${nB})$ et $(${nB}${nC})$ sont perpendiculaires, 
+donc si et seulement si les vecteurs $${vecAB}$ et $${vecBC}$ sont orthognaux.`;
+    })()}
+  
+On calcule les coordonnées des vecteurs :
 
 ${zip([vecComputationU, vecComputationV, vecComputationW], [vecU, vecV, vecW]).map(([vecComputation, vec]) => `
 
@@ -218,7 +228,7 @@ const getQuestionFromIdentifiers = (identifiers, opts) => {
 export const scalarProductIsRightTriangleUsingPointCoords = {
     id: "scalarProductIsRightTriangleUsingPointCoords",
     connector: "=",
-    label: "Déterminer si un triangle est rectangle à partir des coordonnées de ses sommets",
+    label: "Déterminer si un triangle est rectangle à partir des coordonnées de ses sommets à l'aide du produit scalaire",
     isSingleStep: true,
     generator: (nb) => getDistinctQuestions(() => getScalarProductIsRightTriangleUsingPointCoordsQuestion(), nb),
     qcmTimer: 60,

package/lib/exercises/math/geometry/vectors/scalarProduct/scalarProductComputeBH.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scalarProductComputeBH.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/geometry/vectors/scalarProduct/scalarProductComputeBH.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAoBT,MAAM,6BAA6B,CAAC;AAKrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAoBtC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,gBAAgB,EAAE,CAAC;CAC9B,CAAC;AA+bF,KAAK,OAAO,GAAG;IACb,cAAc,EAAE,MAAM,CAAC;IACvB,oBAAoB,EAAE,OAAO,CAAC;CAC/B,CAAC;AA+BF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CA6BjE,CAAC"}
+{"version":3,"file":"scalarProductComputeBH.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/geometry/vectors/scalarProduct/scalarProductComputeBH.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAoBT,MAAM,6BAA6B,CAAC;AAKrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAqBtC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,gBAAgB,EAAE,CAAC;CAC9B,CAAC;AAmeF,KAAK,OAAO,GAAG;IACb,cAAc,EAAE,MAAM,CAAC;IACvB,oBAAoB,EAAE,OAAO,CAAC;CAC/B,CAAC;AA+BF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CA6BjE,CAAC"}

package/lib/exercises/math/geometry/vectors/scalarProduct/scalarProductComputeBH.js

@@ -9,6 +9,7 @@ import { Segment } from "../../../../../math/geometry/segment.js";
 import { Triangle } from "../../../../../math/geometry/triangles/triangle.js";
 import { VectorConstructor } from "../../../../../math/geometry/vector.js";
 import { randint } from "../../../../../math/utils/random/randint.js";
+import { round } from "../../../../../math/utils/round.js";
 import { abs } from "../../../../../tree/nodes/functions/absNode.js";
 import { add } from "../../../../../tree/nodes/operators/addNode.js";
 import { frac, isFractionNode, } from "../../../../../tree/nodes/operators/fractionNode.js";
@@ -56,6 +57,7 @@ const getCorrection = (identifiers) => {
     const nodeLengthBC = vecBC.getNorm();
     const vecBA = VectorConstructor.fromPoints(pointB, pointA);
     const nodeScalarProduct = vecBA.scalarProduct(vecBC);
+    const isScalarProductPositive = nodeScalarProduct.evaluate() > 0;
     return `Dans $BAC$, $H$ est le pied de la hauteur issue de $A$.
   
 Autrement dit, $H$ est le projeté orthogonal de $A$ sur $(BC)$.
@@ -66,20 +68,42 @@ $$
 \\overrightarrow{BA} \\cdot \\overrightarrow{BC} = \\overrightarrow{BH} \\cdot \\overrightarrow{BC}
 $$
 
-Or, puisque $B$,$C$ et $H$ sont alignés : 
+${(() => {
+        if (isScalarProductPositive) {
+            return `Or, puisque $\\overrightarrow{BH}$ et $\\overrightarrow{BC}$ sont colinéaires et de même sens : 
 
 $$
-\\lvert \\overrightarrow{BH} \\cdot \\overrightarrow{BC} \\rvert = BH \\times BC
+\\overrightarrow{BH} \\cdot \\overrightarrow{BC} = BH \\times BC
 $$
 
 On a donc : 
 
 $$
-BH = \\frac{\\lvert \\overrightarrow{BA} \\cdot \\overrightarrow{BC} \\rvert}{BC}
+BH = \\frac{\\overrightarrow{BA} \\cdot \\overrightarrow{BC}}{BC}
 $$
 
+`;
+        }
+        else {
+            return `Or, puisque $\\overrightarrow{BH}$ et $\\overrightarrow{BC}$ sont colinéaires et de sens opposés : 
+
+$$
+\\overrightarrow{BH} \\cdot \\overrightarrow{BC} = - BH \\times BC
+$$
+
+On a donc : 
+
+$$
+BH = \\frac{- \\overrightarrow{BA} \\cdot \\overrightarrow{BC}}{BC}
+$$
+
+`;
+        }
+    })()}
 Application numérique : 
 
+On calcule donc le produit scalaire $\\overrightarrow{BA} \\cdot \\overrightarrow{BC}$ :
+
 $$
 \\overrightarrow{BA} = ${vecBA.toCoords()}
 $$
@@ -92,10 +116,14 @@ $$
 \\overrightarrow{BA} \\cdot \\overrightarrow{BC} = ${nodeScalarProduct.toTex()}
 $$
 
+Puis on calcule la longueur $BC$ :
+
 $$
 BC = ${nodeLengthBC.toTex()}
 $$
 
+On a donc :
+
 $$
 BH = ${getAnswer(identifiers)}
 $$
@@ -207,7 +235,13 @@ const isAnswerValid = (ans, { answer, ...identifiers }) => {
     try {
         const nodeAns = parseAlgebraic(ans);
         const nodeAnswer = getAnswerNode(identifiers);
-        return substract(nodeAns, nodeAnswer).simplify().evaluate() === 0;
+        const isValidExact = () => {
+            return substract(nodeAns, nodeAnswer).simplify().evaluate() === 0;
+        };
+        const isValidRounded = (precision) => {
+            return nodeAns.evaluate() - round(nodeAnswer.evaluate(), precision) === 0;
+        };
+        return isValidExact() || isValidRounded(2);
     }
     catch (err) {
         return handleVEAError(err);

package/lib/exercises/math/geometry/vectors/scalarProduct/scalarProductOfVectsOnGrid1.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scalarProductOfVectsOnGrid1.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/geometry/vectors/scalarProduct/scalarProductOfVectsOnGrid1.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAmBT,MAAM,6BAA6B,CAAC;AAKrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AACtC,OAAO,EAGL,iBAAiB,EAClB,MAAM,+BAA+B,CAAC;AAWvC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,iBAAiB,CAAC;IAC3B,OAAO,EAAE,iBAAiB,CAAC;IAC3B,UAAU,EAAE,gBAAgB,CAAC;IAC7B,UAAU,EAAE,gBAAgB,CAAC;IAC7B,YAAY,EAAE,OAAO,CAAC;IACtB,SAAS,EAAE,OAAO,CAAC;CACpB,CAAC;AAiYF,KAAK,OAAO,GAAG;IACb,gBAAgB,EAAE,OAAO,CAAC;CAC3B,CAAC;AAgBF,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAyBtE,CAAC"}
+{"version":3,"file":"scalarProductOfVectsOnGrid1.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/geometry/vectors/scalarProduct/scalarProductOfVectsOnGrid1.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAmBT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AACtC,OAAO,EAGL,iBAAiB,EAClB,MAAM,+BAA+B,CAAC;AAWvC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,iBAAiB,CAAC;IAC3B,OAAO,EAAE,iBAAiB,CAAC;IAC3B,UAAU,EAAE,gBAAgB,CAAC;IAC7B,UAAU,EAAE,gBAAgB,CAAC;IAC7B,YAAY,EAAE,OAAO,CAAC;IACtB,SAAS,EAAE,OAAO,CAAC;CACpB,CAAC;AAmcF,KAAK,OAAO,GAAG;IACb,gBAAgB,EAAE,OAAO,CAAC;CAC3B,CAAC;AAgBF,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAyBtE,CAAC"}