math-exercises 3.0.171 → 3.0.172

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

@@ -1 +1 @@
-{"version":3,"file":"scalarProductLamdbaULambdaV.d.ts","sourceRoot":"","sources":["../../../../../../../src/exercises/math/geometry/vectors/scalarProduct/alg/scalarProductLamdbaULambdaV.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAgB7C,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,eAAe,CAAC;IAC9B,QAAQ,EAAE,eAAe,CAAC;IAC1B,QAAQ,EAAE,eAAe,CAAC;CAC3B,CAAC;AAmSF,KAAK,OAAO,GAAG;IACb,UAAU,EAAE,OAAO,CAAC;CACrB,CAAC;AAMF,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAsBtE,CAAC;AAEF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAsBlE,CAAC"}
+{"version":3,"file":"scalarProductLamdbaULambdaV.d.ts","sourceRoot":"","sources":["../../../../../../../src/exercises/math/geometry/vectors/scalarProduct/alg/scalarProductLamdbaULambdaV.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAgB7C,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,eAAe,CAAC;IAC9B,QAAQ,EAAE,eAAe,CAAC;IAC1B,QAAQ,EAAE,eAAe,CAAC;CAC3B,CAAC;AA+QF,KAAK,OAAO,GAAG;IACb,UAAU,EAAE,OAAO,CAAC;CACrB,CAAC;AAMF,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAsBtE,CAAC;AAEF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAsBlE,CAAC"}

package/lib/exercises/math/geometry/vectors/scalarProduct/alg/scalarProductLamdbaULambdaV.js

@@ -1,18 +1,20 @@
 import { addValidProp, shuffleProps, tryToAddWrongProp, propWhile, } from "../../../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../../../exercises/utils/getDistinctQuestions.js";
+import { rationalVEA } from "../../../../../../exercises/vea/rationalVEA.js";
 import { randint } from "../../../../../../math/utils/random/randint.js";
+import { opposite } from "../../../../../../tree/nodes/functions/oppositeNode.js";
 import { NodeConstructor, } from "../../../../../../tree/nodes/nodeConstructor.js";
 import { isNumberNode } from "../../../../../../tree/nodes/numbers/numberNode.js";
 import { add } from "../../../../../../tree/nodes/operators/addNode.js";
 import { frac } from "../../../../../../tree/nodes/operators/fractionNode.js";
 import { multiply } from "../../../../../../tree/nodes/operators/multiplyNode.js";
 import { parseAlgebraic } from "../../../../../../tree/parsers/latexParser.js";
+import { coinFlip } from "../../../../../../utils/alea/coinFlip.js";
 import { random } from "../../../../../../utils/alea/random.js";
 import { shuffle } from "../../../../../../utils/alea/shuffle.js";
 import { handleVEAError } from "../../../../../../utils/errors/handleVEAError.js";
-import { alignTex } from "../../../../../../utils/latex/alignTex.js";
 const parenthesesIfNeeded = (tex) => {
-    const isShouldParentheses = tex.startsWith("-") || tex.startsWith("+");
+    const isShouldParentheses = tex.startsWith("-");
     return isShouldParentheses ? `(${tex})` : tex;
 };
 const getHydratedNodes = (identifiers) => {
@@ -25,16 +27,6 @@ const getHydratedNodes = (identifiers) => {
 };
 const getInstruction = (identifiers) => {
     const { nodeUDotV, nodeA, nodeB } = getHydratedNodes(identifiers);
-    const texA = nodeA.evaluate() === -1
-        ? "-"
-        : nodeA.evaluate() === 1
-            ? "+"
-            : nodeA.toTex();
-    const texB = nodeB.evaluate() === -1
-        ? "-"
-        : nodeB.evaluate() === 1
-            ? "+"
-            : nodeB.toTex();
     const u = "\\overrightarrow u";
     const v = "\\overrightarrow v";
     return `Soit $${u}$ et $${v}$ deux vecteurs tels que : 
@@ -46,7 +38,7 @@ $$
 Calculer : 
 
 $$
-${parenthesesIfNeeded(`${texA}${u}`)} \\cdot ${parenthesesIfNeeded(`${texB}${v}`)}
+${multiply(nodeA, u.toTree()).toTex()} \\cdot ${parenthesesIfNeeded(multiply(nodeB, v.toTree()).toTex())}
 $$
 
 `;
@@ -58,57 +50,19 @@ const getAnswerNode = (identifiers) => {
 const getAnswer = (identifiers) => {
     return getAnswerNode(identifiers).simplify().toTex();
 };
-const getHint = (identifiers) => {
-    const { nodeA, nodeB } = getHydratedNodes(identifiers);
-    const isSignOnly = Math.abs(nodeA.evaluate()) === 1 && Math.abs(nodeB.evaluate()) === 1;
-    if (isSignOnly) {
-        return `Voici un calcul pour te mettre sur la piste : 
-
-${alignTex([
-            [
-                "",
-                "\\overrightarrow{u} \\cdot \\overrightarrow{v} + ((-\\overrightarrow{u}) \\cdot \\overrightarrow{v})",
-            ],
-            [
-                "=",
-                "(\\overrightarrow{u} + (-\\overrightarrow{u})) \\cdot \\overrightarrow{v}",
-            ],
-            ["=", "(\\overrightarrow{0} \\cdot \\overrightarrow{v})"],
-            ["=", "0"],
-        ])}
-
-`;
-    }
-    else {
-        return `Voici un calcul pour te mettre sur la piste : 
-
-${alignTex([
-            [
-                "",
-                "(\\overrightarrow{u} + \\overrightarrow{u}) \\cdot \\overrightarrow{v}",
-            ],
-            [
-                "=",
-                "\\overrightarrow{u} \\cdot \\overrightarrow{v} + \\overrightarrow{u} \\cdot \\overrightarrow{v}",
-            ],
-            ["=", "2 (\\overrightarrow{u} \\cdot \\overrightarrow{v})"],
-        ])}
+const getHint = () => {
+    return `Le produit scalaire vérifie, pour $k$ et $k'$ réels : 
+  
+$$
+(k \\overrightarrow{u}) \\cdot \\overrightarrow{v} = k (\\overrightarrow{u} \\cdot \\overrightarrow{v})
+$$
 
-`;
-    }
+$$
+\\overrightarrow{u} \\cdot (k' \\overrightarrow{v}) = k' (\\overrightarrow{u} \\cdot \\overrightarrow{v})
+$$`;
 };
 const getCorrection = (identifiers) => {
     const { nodeA, nodeB } = getHydratedNodes(identifiers);
-    const texA = nodeA.evaluate() === -1
-        ? "-"
-        : nodeA.evaluate() === 1
-            ? "+"
-            : nodeA.toTex();
-    const texB = nodeB.evaluate() === -1
-        ? "-"
-        : nodeB.evaluate() === 1
-            ? "+"
-            : nodeB.toTex();
     const u = "\\overrightarrow u";
     const v = "\\overrightarrow v";
     return `Le produit scalaire vérifie, pour $k$ et $k'$ réels : 
@@ -124,29 +78,45 @@ $$
 On a donc : 
 
 $$
-${parenthesesIfNeeded(`${texA}${u}`)} \\cdot ${parenthesesIfNeeded(`${texB}${v}`)} = ${multiply(nodeA, nodeB).toTex({
-        forceNoSimplification: true,
-        forceTimesSign: true,
-    })} \\times (\\overrightarrow{u} \\cdot \\overrightarrow{v})  = ${getAnswer(identifiers)}
+${multiply(nodeA, u.toTree()).toTex()} \\cdot ${parenthesesIfNeeded(multiply(nodeB, v.toTree()).toTex())} = ${(() => {
+        if (nodeA.evaluate() === 1 || nodeB.evaluate() === 1) {
+            return multiply(nodeA, nodeB).simplify().toTex();
+        }
+        else {
+            return multiply(nodeA, nodeB).toTex({
+                forceNoSimplification: true,
+                forceTimesSign: true,
+            });
+        }
+    })()} \\times (\\overrightarrow{u} \\cdot \\overrightarrow{v})  = ${getAnswer(identifiers)}
 $$
 
 `;
 };
 const getPropositions = (n, { answer, ...identifiers }) => {
-    const propositions = [];
-    addValidProp(propositions, answer);
+    const propositionsMandatory = [];
+    addValidProp(propositionsMandatory, answer);
     const { nodeUDotV, nodeA, nodeB } = getHydratedNodes(identifiers);
     const isSignOnly = Math.abs(nodeA.evaluate()) === 1 && Math.abs(nodeB.evaluate()) === 1;
+    //opposite
+    {
+        const identifiersWrong = {
+            ...identifiers,
+            nodeIdsA: opposite(nodeA).toIdentifiers(),
+        };
+        tryToAddWrongProp(propositionsMandatory, getAnswer(identifiersWrong));
+    }
+    const propositionsFiller = [];
     //student: strange magic: a * firstDigit(uDotV) + b * secondDigit(uDotV)
     if (isSignOnly) {
-        const uDotV = nodeUDotV.evaluate();
-        if (uDotV.frenchify().length === 2) {
-            const [firstDigit, secondDigit] = uDotV
+        const absUDotV = nodeUDotV.evaluate();
+        if (absUDotV.frenchify().length === 2) {
+            const [firstDigit, secondDigit] = absUDotV
                 .frenchify()
                 .split("")
                 .map((s) => +s);
             const nodeWrong = add(multiply(nodeA, firstDigit), multiply(nodeB, secondDigit));
-            tryToAddWrongProp(propositions, nodeWrong.simplify().toTex());
+            tryToAddWrongProp(propositionsFiller, nodeWrong.simplify().toTex());
         }
     }
     //student: concatenation
@@ -155,7 +125,7 @@ const getPropositions = (n, { answer, ...identifiers }) => {
             const a = nodeA.evaluate();
             const b = nodeB.evaluate();
             if (a > 0 && b > 0) {
-                tryToAddWrongProp(propositions, `${a.frenchify()}${b.frenchify()}`);
+                tryToAddWrongProp(propositionsFiller, `${a.frenchify()}${b.frenchify()}`);
             }
         }
     }
@@ -167,27 +137,31 @@ const getPropositions = (n, { answer, ...identifiers }) => {
             if (a > 0 && b > 0) {
                 const nodeConcat = parseAlgebraic(`${a.frenchify()}${b.frenchify()}`);
                 const nodeWrong = multiply(nodeConcat, nodeUDotV).simplify();
-                tryToAddWrongProp(propositions, nodeWrong.toTex());
+                tryToAddWrongProp(propositionsFiller, nodeWrong.toTex());
             }
         }
     }
     //student: au dot bv = (a+b)(u dot v)
     {
         const nodeWrong = multiply(add(nodeA, nodeB).simplify(), nodeUDotV).simplify();
-        tryToAddWrongProp(propositions, nodeWrong.toTex());
+        tryToAddWrongProp(propositionsFiller, nodeWrong.toTex());
     }
-    propWhile(propositions, n + 2, () => {
-        tryToAddWrongProp(propositions, randint(-30, 30).frenchify());
+    propWhile(propositionsFiller, n, () => {
+        tryToAddWrongProp(propositionsFiller, randint(-30, 30).frenchify());
     });
-    return shuffleProps(propositions, n);
+    return shuffle([
+        ...propositionsMandatory,
+        ...shuffleProps(propositionsFiller.filter((propositionFiller) => !propositionsMandatory
+            .map((proposition) => proposition.statement)
+            .includes(propositionFiller.statement)), n - propositionsMandatory.length),
+    ]);
 };
 const getKeys = () => {
     return [];
 };
 const isAnswerValid = (ans, { answer }) => {
     try {
-        const parsed = parseAlgebraic(ans);
-        return parsed.simplify().toTex() === answer;
+        return rationalVEA(ans, answer);
     }
     catch (err) {
         return handleVEAError(err);
@@ -208,13 +182,17 @@ const getScalarProductLamdbaULambdaVQuestion = (optsIn) => {
             case 1:
                 {
                     //les tables de multiplication (entiers relatifs)
-                    return [...Array(2).keys()].map(() => randint(2, 10).toTree());
+                    return random([
+                        [1, -1],
+                        [-1, 1],
+                        [-1, -1],
+                    ]).map((sign) => (sign * randint(2, 10)).toTree());
                 }
                 break;
             case 2:
                 {
                     //fraction simplifiable en un entier
-                    const common = randint(2, 10);
+                    const common = (coinFlip() ? 1 : -1) * randint(2, 10);
                     return shuffle([common, common * randint(2, 10)]).map((v, i) => i === 0 ? frac(1, v) : v.toTree());
                 }
                 break;
@@ -230,8 +208,8 @@ const getScalarProductLamdbaULambdaVQuestion = (optsIn) => {
         ]).map((v) => v.toTree())
         : createRandomNodes();
     const nodeUDotV = isSignOnly
-        ? randint(10, 100).toTree()
-        : random([1, 10, 100]).toTree();
+        ? ((coinFlip() ? +1 : -1) * randint(10, 100)).toTree()
+        : ((coinFlip() ? +1 : -1) * random([1, 10, 100])).toTree();
     const identifiers = {
         nodeIdsA: nodeA.toIdentifiers(),
         nodeIdsB: nodeB.toIdentifiers(),

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

@@ -1 +1 @@
-{"version":3,"file":"angleFromScalarProduct.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/geometry/vectors/scalarProduct/angleFromScalarProduct.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAEL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAWtC,KAAK,WAAW,GAAG;IACjB,iBAAiB,EAAE,gBAAgB,EAAE,CAAC;CAEvC,CAAC;AA8EF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAiBxD,CAAC"}
+{"version":3,"file":"angleFromScalarProduct.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/geometry/vectors/scalarProduct/angleFromScalarProduct.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAEL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAYtC,KAAK,WAAW,GAAG;IACjB,iBAAiB,EAAE,gBAAgB,EAAE,CAAC;CAEvC,CAAC;AA2KF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAkBxD,CAAC"}

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"}