math-exercises 3.0.156 → 3.0.158

package/lib/exercises/math/functions/variations/exp/varOfAEXPlusB.d.ts

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../../../exercises/exercise.js";
+type Identifiers = {
+    a: number;
+    b: number;
+    intervalAskedIndex: number;
+};
+export declare const varOfAEXPlusB: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=varOfAEXPlusB.d.ts.map

package/lib/exercises/math/functions/variations/exp/varOfAEXPlusB.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"varOfAEXPlusB.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/variations/exp/varOfAEXPlusB.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAkBrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,kBAAkB,EAAE,MAAM,CAAC;CAC5B,CAAC;AAwFF,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,WAAW,CAiB/C,CAAC"}

package/lib/exercises/math/functions/variations/exp/varOfAEXPlusB.js

@@ -0,0 +1,101 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { AffineConstructor } from "../../../../../math/polynomials/affine.js";
+import { randint } from "../../../../../math/utils/random/randint.js";
+import { exp } from "../../../../../tree/nodes/functions/expNode.js";
+import { MinusInfinityNode, PlusInfinityNode, } from "../../../../../tree/nodes/numbers/infiniteNode.js";
+import { add } from "../../../../../tree/nodes/operators/addNode.js";
+import { multiply } from "../../../../../tree/nodes/operators/multiplyNode.js";
+import { ClosureType } from "../../../../../tree/nodes/sets/closure.js";
+import { IntervalNode } from "../../../../../tree/nodes/sets/intervalNode.js";
+const createNodeAEXPlusB = (a, b) => {
+    return add(multiply(a, exp("x".toTree())), b);
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer, "raw");
+    tryToAddWrongProp(propositions, "$f$ est décroissante", "raw");
+    tryToAddWrongProp(propositions, "$f$ est croissante", "raw");
+    tryToAddWrongProp(propositions, "$f$ n'est pas monotone", "raw");
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { a } = identifiers;
+    return a > 0 ? "$f$ est croissante" : "$f$ est décroissante";
+};
+const getInterval = (identifiers) => {
+    const { intervalAskedIndex, a, b } = identifiers;
+    const interval = intervalAskedIndex === 0
+        ? new IntervalNode(MinusInfinityNode, a.toTree(), ClosureType.OF)
+        : intervalAskedIndex === 1
+            ? new IntervalNode(a.toTree(), b.toTree(), ClosureType.FF)
+            : new IntervalNode(b.toTree(), PlusInfinityNode, ClosureType.FO);
+    return interval;
+};
+const getInstructionNode = (identifiers) => {
+    const { a, b } = identifiers;
+    return createNodeAEXPlusB(a, b);
+};
+const getInstruction = (identifiers) => {
+    const interval = getInterval(identifiers);
+    const nodeInstruction = getInstructionNode(identifiers);
+    return `Soit la fonction $f$ définie sur $\\mathbb{R}$ par :
+
+$$
+f(x) = ${nodeInstruction.toTex()}
+$$
+
+Quel est le sens de variation de $f$ sur $${interval.toTex()}$ ?`;
+};
+const getHint = (identifiers) => {
+    const interval = getInterval(identifiers);
+    return `Observe comment varient les valeurs de $f(x)$ pour les valeurs de $x$ comprises dans l'intervalle $${interval.toTex()}$.`;
+};
+const getCorrection = (identifiers) => {
+    const { a, b } = identifiers;
+    const interval = getInterval(identifiers);
+    const nodeAffine = AffineConstructor.fromCoeffs([b, a]).toTree();
+    return `On sait que :
+- $x \\mapsto e^x$ est strictement croissante sur $\\mathbb{R}$
+- $x \\mapsto ${nodeAffine.toTex()}$ est strictement ${a > 0 ? "croissante" : "décroissante"} sur $\\mathbb{R}$
+
+Par composition, on en conclut que ${getAnswer(identifiers).toLocaleLowerCase()} sur $${interval.toTex()}$.`;
+};
+const getVarOfAEXPlusBQuestion = () => {
+    const a = randint(-10, 11, [0]);
+    const b = randint(-10, 11);
+    const intervalAskedIndex = randint(0, 3);
+    const identifiers = {
+        a,
+        b,
+        intervalAskedIndex,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        answerFormat: "raw",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const varOfAEXPlusB = {
+    id: "varOfAEXPlusB",
+    label: "Sens de variation de $ae^x+b$",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getVarOfAEXPlusBQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

package/lib/exercises/math/functions/variations/exp/varOfAEXPlusBOverCEXPlusD.d.ts

@@ -0,0 +1,11 @@
+import { Exercise } from "../../../../../exercises/exercise.js";
+type Identifiers = {
+    a: number;
+    b: number;
+    c: number;
+    d: number;
+    intervalAskedIndex: number;
+};
+export declare const varOfAEXPlusBOverCEXPlusD: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=varOfAEXPlusBOverCEXPlusD.d.ts.map

package/lib/exercises/math/functions/variations/exp/varOfAEXPlusBOverCEXPlusD.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"varOfAEXPlusBOverCEXPlusD.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/variations/exp/varOfAEXPlusBOverCEXPlusD.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAyBrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,kBAAkB,EAAE,MAAM,CAAC;CAC5B,CAAC;AAsMF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAiB3D,CAAC"}

package/lib/exercises/math/functions/variations/exp/varOfAEXPlusBOverCEXPlusD.js

@@ -0,0 +1,192 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../../../math/utils/random/randint.js";
+import { exp } from "../../../../../tree/nodes/functions/expNode.js";
+import { MinusInfinityNode, PlusInfinityNode, } from "../../../../../tree/nodes/numbers/infiniteNode.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 { power } from "../../../../../tree/nodes/operators/powerNode.js";
+import { substract } from "../../../../../tree/nodes/operators/substractNode.js";
+import { ClosureType } from "../../../../../tree/nodes/sets/closure.js";
+import { IntervalNode } from "../../../../../tree/nodes/sets/intervalNode.js";
+const createNodeAEXPlusB = (a, b) => {
+    return add(multiply(a, exp("x".toTree())), b);
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer, "raw");
+    tryToAddWrongProp(propositions, "$f$ est décroissante", "raw");
+    tryToAddWrongProp(propositions, "$f$ est croissante", "raw");
+    tryToAddWrongProp(propositions, "$f$ n'est pas monotone", "raw");
+    return shuffleProps(propositions, n);
+};
+const getDerivativeNodeSimplified1 = (identifiers) => {
+    const { a, b, c, d } = identifiers;
+    const nodeDen = createNodeAEXPlusB(c, d);
+    return frac(multiply(substract(multiply(a, d), multiply(c, b)), exp("x".toTree())), power(nodeDen, 2));
+};
+const getDerivativeNodeSimplified2 = (identifiers) => {
+    const { a, b, c, d } = identifiers;
+    const nodeDen = createNodeAEXPlusB(c, d);
+    return frac(multiply(substract(multiply(a, d), multiply(c, b)).evaluate(), exp("x".toTree())), power(nodeDen, 2));
+};
+const getAnswer = (identifiers) => {
+    const { a, b, c, d } = identifiers;
+    const discr = substract(multiply(a, d), multiply(c, b)).evaluate();
+    return discr > 0 ? "$f$ est croissante" : "$f$ est décroissante";
+};
+const getInterval = (identifiers) => {
+    const { intervalAskedIndex, a, b } = identifiers;
+    const interval = intervalAskedIndex === 0
+        ? new IntervalNode(MinusInfinityNode, a.toTree(), ClosureType.OF)
+        : intervalAskedIndex === 1
+            ? new IntervalNode(a.toTree(), b.toTree(), ClosureType.FF)
+            : new IntervalNode(b.toTree(), PlusInfinityNode, ClosureType.FO);
+    return interval;
+};
+const getInstructionNode = (identifiers) => {
+    const { a, b, c, d } = identifiers;
+    const nodeNum = createNodeAEXPlusB(a, b);
+    const nodeDen = createNodeAEXPlusB(c, d);
+    return frac(nodeNum, nodeDen);
+};
+const getInstruction = (identifiers) => {
+    const interval = getInterval(identifiers);
+    const nodeInstruction = getInstructionNode(identifiers);
+    return `Soit la fonction $f$ définie sur $\\mathbb{R}$ par :
+
+$$
+f(x) = ${nodeInstruction.toTex()}
+$$
+
+Quel est le sens de variation de $f$ sur $${interval.toTex()}$ ?`;
+};
+const getHint = (identifiers) => {
+    const interval = getInterval(identifiers);
+    return `Calcule la dérivée de $f$ pour en déduire les variations de $f$ sur $${interval.toTex()}$.`;
+};
+const getCorrection = (identifiers) => {
+    const { a, b, c, d } = identifiers;
+    const nodeU = createNodeAEXPlusB(a, b);
+    const nodeV = createNodeAEXPlusB(c, d);
+    const nodeUPrime = nodeU.derivative().simplify();
+    const nodeVPrime = nodeV.derivative().simplify();
+    const discr = substract(multiply(a, d), multiply(c, b)).evaluate();
+    const interval = getInterval(identifiers);
+    return `On va calculer la dérivée du quotient.
+    
+Ici, on a : 
+
+$$
+u(x) = ${nodeU.toTex()}
+$$
+
+$$
+v(x) = ${nodeV.toTex()}
+$$
+
+On calcule : 
+
+$$
+u'(x) = ${nodeUPrime.toTex()}
+$$
+
+$$
+v'(x) = ${nodeVPrime.toTex()}
+$$
+
+Donc :
+
+$$
+f'(x) = (\\frac{u}{v})'(x) = ${frac(substract(multiply(nodeUPrime, nodeV), multiply(nodeU, nodeVPrime)), power(nodeV, 2)).toTex()}
+$$
+
+$$
+f'(x) = (\\frac{u}{v})'(x) = ${getDerivativeNodeSimplified1(identifiers).toTex()}
+$$
+
+$$
+f'(x) = (\\frac{u}{v})'(x) = ${getDerivativeNodeSimplified2(identifiers).toTex()}
+$$
+
+Conclusion : Pour tout $x$ réel :
+
+$
+f'(x) ${discr > 0 ? ">" : "<"} 0
+$
+
+Autrement dit :
+
+${getAnswer(identifiers).toLocaleLowerCase()} sur $${interval.toTex()}$.`;
+};
+const getVarOfAEXPlusBOverCEXPlusDQuestion = () => {
+    function createRandomIdentifiers() {
+        const a = randint(-10, 11, [0]);
+        const b = randint(-10, 11, [0]);
+        const c = randint(-10, 11, [0]);
+        const d = randint(-10, 11, [0]);
+        const intervalAskedIndex = randint(0, 3);
+        const identifiers = {
+            a,
+            b,
+            c,
+            d,
+            intervalAskedIndex,
+        };
+        return identifiers;
+    }
+    let identifiers;
+    let counter = -1;
+    let isValid = false;
+    while (!isValid && counter < 100) {
+        counter++;
+        const identifiersCandidate = createRandomIdentifiers();
+        isValid = (() => {
+            const { a, b, c, d } = identifiersCandidate;
+            const discr = substract(multiply(a, d), multiply(c, b)).evaluate();
+            return discr !== 0;
+        })();
+        if (isValid) {
+            identifiers = identifiersCandidate;
+        }
+    }
+    if (!isValid) {
+        const identifiersDefault = {
+            a: 2,
+            b: 3,
+            c: 5,
+            d: 7,
+            intervalAskedIndex: 0,
+        };
+        identifiers = identifiersDefault;
+    }
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        answerFormat: "raw",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const varOfAEXPlusBOverCEXPlusD = {
+    id: "varOfAEXPlusBOverCEXPlusD",
+    label: "Sens de variation de $\\frac{ae^x+b}{ce^x+d}$",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getVarOfAEXPlusBOverCEXPlusDQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

package/lib/exercises/math/geometry/euclidian/pinPointFromAxialOrCentralSymmetry.js

@@ -284,8 +284,8 @@ const getPinPointFromAxialOrCentralSymmetryQuestion = (optsIn) => {
                     const vecVRaw = VectorConstructor.fromPoints(point1, rotatePoint(point2, frac(PiNode, 2).evaluate(), point1, "N"));
                     const vecVUnit = vecVRaw.times(frac(1, vecVRaw.getNorm().evaluate()).evaluate().toTree());
                     const vecSrc = VectorConstructor.fromPoints(point1, pointSrc);
-                    const dotAx = vecSrc.scalarProduct(vecUUnit);
-                    const dotPerp = vecSrc.scalarProduct(vecVUnit);
+                    const dotAx = vecSrc.scalarProduct(vecUUnit).simplify();
+                    const dotPerp = vecSrc.scalarProduct(vecVUnit).simplify();
                     const vecDst = vecUUnit
                         .times(dotAx)
                         .add(vecVUnit.times(multiply(-1, dotPerp)));

package/lib/exercises/math/geometry/euclidian/pinSegmentFromRotation.js

@@ -113,7 +113,7 @@ const getCorrection = (identifiers) => {
     const { nameObjSrc, nameObjDst, transformationIds, pointsDict } = identifiers;
     const pointsIds = Object.values(pointsDict);
     return `L'angle $\\widehat{${pointsIds[1].name}${pointsIds[0].name}${pointsIds[2].name}}$ vaut $60°$.
-L'image de $${nameObjSrc[0]}$ par ${getStrForTransformation(transformationIds)} est $${nameObjDst[1]}$ et celle de $${nameObjSrc[0]}$ est $${nameObjDst[1]}$.
+L'image de $${nameObjSrc[0]}$ par ${getStrForTransformation(transformationIds)} est $${nameObjDst[0]}$ et celle de $${nameObjSrc[1]}$ est $${nameObjDst[1]}$.
 L'image de $[${nameObjSrc}]$ par ${getStrForTransformation(transformationIds)} est donc $[${nameObjDst}]$.`;
 };
 const getSegmentSrc = (identifiers) => {

package/lib/exercises/math/geometry/euclidian/recognizeHomothetyCenter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"recognizeHomothetyCenter.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/euclidian/recognizeHomothetyCenter.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAKtC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAiE7C,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;IAC7C,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,MAAM,EAAE,eAAe,CAAC;IACxB,eAAe,EAAE,MAAM,CAAC;CACzB,CAAC;AAuSF,KAAK,OAAO,GAAG;IACb,oBAAoB,EAAE,OAAO,CAAC;IAC9B,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB,CAAC;AAyBF,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAiBnE,CAAC"}
+{"version":3,"file":"recognizeHomothetyCenter.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/euclidian/recognizeHomothetyCenter.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAKtC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAiE7C,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;IAC7C,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,MAAM,EAAE,eAAe,CAAC;IACxB,eAAe,EAAE,MAAM,CAAC;CACzB,CAAC;AAsSF,KAAK,OAAO,GAAG;IACb,oBAAoB,EAAE,OAAO,CAAC;IAC9B,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB,CAAC;AAyBF,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAiBnE,CAAC"}

package/lib/exercises/math/geometry/euclidian/recognizeHomothetyCenter.js

@@ -95,20 +95,20 @@ const getCorrection = (identifiers) => {
 ${(() => {
         if (isAboveZero) {
             return `Le rapport d'homothétie est positif 
-donc le centre est donc à l'extérieur du segment $[${nameSrcPoint}${nameDstPoint}]$.`;
+donc le centre est à l'extérieur du segment $[${nameSrcPoint}${nameDstPoint}]$.`;
         }
         else {
             return `Le rapport d'homothétie est négatif
-donc le centre est donc à l'intérieur du segment $[${nameSrcPoint}${nameDstPoint}]$.`;
+donc le centre est à l'intérieur du segment $[${nameSrcPoint}${nameDstPoint}]$.`;
         }
     })()}${(() => {
         if (isAbsBelowOne) {
             return `Le rapport est inférieur à $1$ en valeur absolue
-donc le centre est donc plus proche de $${nameDstPoint}$ que de $${nameSrcPoint}$.`;
+donc le centre est plus proche de $${nameDstPoint}$ que de $${nameSrcPoint}$.`;
         }
         else {
             return `Le rapport est supérieur à $1$ en valeur absolue
-donc le centre est donc plus proche de $${nameSrcPoint}$ que de $${nameDstPoint}$.`;
+donc le centre est plus proche de $${nameSrcPoint}$ que de $${nameDstPoint}$.`;
         }
     })()}
 
@@ -218,7 +218,6 @@ const getRecognizeHomothetyCenterQuestion = (optsIn) => {
         counter++;
         try {
             identifiers = createRandomIdentifiers();
-            console.log("identifiers", identifiers);
         }
         catch (_) {
             continue;

package/lib/exercises/math/geometry/euclidianConstructions/placeHomothetyCenter.js

@@ -109,20 +109,20 @@ const getCorrection = (identifiers) => {
 ${(() => {
         if (isAboveZero) {
             return `Le rapport d'homothétie est positif 
-donc le centre est donc à l'extérieur du segment $[${nameSrcPoint}${nameDstPoint}]$.`;
+donc le centre est à l'extérieur du segment $[${nameSrcPoint}${nameDstPoint}]$.`;
         }
         else {
             return `Le rapport d'homothétie est négatif
-donc le centre est donc à l'intérieur du segment $[${nameSrcPoint}${nameDstPoint}]$.`;
+donc le centre est à l'intérieur du segment $[${nameSrcPoint}${nameDstPoint}]$.`;
         }
     })()}${(() => {
         if (isAbsBelowOne) {
             return `Le rapport est inférieur à $1$ en valeur absolue
-donc le centre est donc plus proche de $${nameDstPoint}$ que de $${nameSrcPoint}$.`;
+donc le centre est plus proche de $${nameDstPoint}$ que de $${nameSrcPoint}$.`;
         }
         else {
             return `Le rapport est supérieur à $1$ en valeur absolue
-donc le centre est donc plus proche de $${nameSrcPoint}$ que de $${nameDstPoint}$.`;
+donc le centre est plus proche de $${nameSrcPoint}$ que de $${nameDstPoint}$.`;
         }
     })()}
 

package/lib/exercises/math/geometry/perimeters/circleCircumference.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"circleCircumference.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/perimeters/circleCircumference.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,OAAO,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AA2GF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAcrD,CAAC"}
+{"version":3,"file":"circleCircumference.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/perimeters/circleCircumference.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,OAAO,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAgHF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAcrD,CAAC"}

package/lib/exercises/math/geometry/perimeters/circleCircumference.js

@@ -22,11 +22,13 @@ const getAnswerNode = (identifiers) => {
 const getAnswer = (identifiers) => {
     return `${getAnswerNode(identifiers).toTex()} \\text{cm}`;
 };
-const getHint = () => {
-    return `Le périmètre d'un cercle de rayon $r$ est donné par : 
+const getHint = (identifiers) => {
+    const { coin } = identifiers;
+    const isRadius = coin;
+    return `Le périmètre d'un cercle de ${isRadius ? "rayon $r$" : "diamètre $d$"} est donné par : 
   
 $$
-C = 2\\pi r
+C = ${isRadius ? "2\\pi r" : "\\pi\\times d"}
 $$`;
 };
 const getCorrection = (identifiers) => {

package/lib/exercises/math/geometry/thales/thales.js

@@ -23,7 +23,7 @@ const getSubTriangle = ({ triangle, insidePointsNames, ratio, }) => {
 const getInstruction = (identifiers) => {
     const { triangleIdentifiers, insidePointsNames } = identifiers;
     const triangle = TriangleConstructor.fromIdentifiers(triangleIdentifiers);
-    return `En utilisant le théoreme de Thalès, écrire l'égalité des quotients sachant que  $\\left(${insidePointsNames.join("")}\\right)//\\left(${triangle.sides[2].toInsideName()}\\right)$.`;
+    return `En utilisant le théorème de Thalès, écrire l'égalité des quotients sachant que  $\\left(${insidePointsNames.join("")}\\right)//\\left(${triangle.sides[2].toInsideName()}\\right)$.`;
 };
 const getAnswer = (identifiers) => {
     const { triangleIdentifiers, insidePointsNames, isPapillon, ratio } = identifiers;

package/lib/exercises/math/geometry/thales/thalesCalcul.js

@@ -244,7 +244,7 @@ const getQuestionFromIdentifiers = (identifiers, opts) => {
 export const thalesCalcul = {
     id: "thalesCalcul",
     connector: "=",
-    label: "Utiliser le théoreme de Thalès pour calculer un côté",
+    label: "Utiliser le théorème de Thalès pour calculer un côté",
     isSingleStep: true,
     generator: (nb, opts) => getDistinctQuestions(() => getThalesFindSideQuestion(opts), nb),
     qcmTimer: 60,

package/lib/exercises/math/geometry/vectors/colinearity/determinant.js

@@ -75,7 +75,7 @@ const getPropositions = (n, { answer, ...identifiers }) => {
     const propositions = [];
     addValidProp(propositions, answer);
     const { u, v } = getVectors(identifiers);
-    tryToAddWrongProp(propositions, u.scalarProduct(v).toTex());
+    tryToAddWrongProp(propositions, u.scalarProduct(v).simplify().toTex());
     propWhile(propositions, n, () => {
         const wrongAnswer = randint(-20, 20) + "";
         tryToAddWrongProp(propositions, wrongAnswer);

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

@@ -24,7 +24,7 @@ const getAnswer = (identifiers) => {
     const points = getPoints(identifiers);
     const u = VectorConstructor.fromPoints(points[1], points[0]);
     const v = VectorConstructor.fromPoints(points[1], points[2]);
-    const ps = u.scalarProduct(v);
+    const ps = u.scalarProduct(v).simplify();
     const normU = u.getNorm();
     const normV = v.getNorm();
     const cos = frac(ps, multiply(normU, normV)).simplify();

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

@@ -1 +1 @@
-{"version":3,"file":"findCoordinatesToOrthogonalize.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/geometry/vectors/scalarProduct/findCoordinatesToOrthogonalize.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAGrC,OAAO,EAEL,iBAAiB,EAClB,MAAM,+BAA+B,CAAC;AAOvC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,iBAAiB,CAAC;IACxB,IAAI,EAAE,iBAAiB,CAAC;CACzB,CAAC;AAoGF,eAAO,MAAM,8BAA8B,EAAE,QAAQ,CAAC,WAAW,CAqBhE,CAAC"}
+{"version":3,"file":"findCoordinatesToOrthogonalize.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/geometry/vectors/scalarProduct/findCoordinatesToOrthogonalize.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAGrC,OAAO,EAEL,iBAAiB,EAClB,MAAM,+BAA+B,CAAC;AAQvC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,iBAAiB,CAAC;IACxB,IAAI,EAAE,iBAAiB,CAAC;CACzB,CAAC;AA0HF,eAAO,MAAM,8BAA8B,EAAE,QAAQ,CAAC,WAAW,CAsBhE,CAAC"}

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

@@ -4,9 +4,10 @@ import { rationalVEA } from "../../../../../exercises/vea/rationalVEA.js";
 import { VectorConstructor, } from "../../../../../math/geometry/vector.js";
 import { RationalConstructor } from "../../../../../math/numbers/rationals/rational.js";
 import { randint } from "../../../../../math/utils/random/randint.js";
-import { equal } from "../../../../../tree/nodes/equations/equalNode.js";
+import { equal, EqualNode } from "../../../../../tree/nodes/equations/equalNode.js";
 import { coinFlip } from "../../../../../utils/alea/coinFlip.js";
 import { handleVEAError } from "../../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../../utils/latex/alignTex.js";
 const getPropositions = (n, { answer }) => {
     const propositions = [];
     addValidProp(propositions, answer);
@@ -29,10 +30,34 @@ const getInstruction = (identifiers) => {
   
 Pour quelle valeur de $x$ les vecteurs $${u.toTex()}$ et $${v.toTex()}$ sont-ils orthogonaux ?`;
 };
-// const getHint : GetHint<Identifiers> = (identifiers)=>{
-// }
-// const getCorrection : GetCorrection<Identifiers> = (identifiers)=>{
-// }
+const getHint = () => {
+    return `Deux vecteurs sont orthogonaux si et seulement leur produit scalaire est nul.`;
+};
+const getCorrection = (identifiers) => {
+    const { uIds, vIds } = identifiers;
+    const u = VectorConstructor.fromIdentifiers(uIds);
+    const v = VectorConstructor.fromIdentifiers(vIds);
+    const psNode = u.scalarProduct(v);
+    const psNodeSimp = psNode.simplify();
+    const equation = new EqualNode(psNodeSimp, (0).toTree());
+    const steps = [];
+    const res = equation.isolate("x", { steps });
+    return `On sait que deux vecteurs sont orthogonaux si et seulement si leur produit scaraire est nul.
+  
+On commence donc par calculer $${u.toTex()}\\cdot ${v.toTex()}$ :
+
+${alignTex([
+        [`${u.toTex()}\\cdot ${v.toTex()}`, "=", u.scalarProduct(v).toTex()],
+        ["", "=", u.scalarProduct(v).simplify().toTex()],
+    ])}
+
+Il suffit alors de résoudre l'équation $${u.toTex()}\\cdot ${v.toTex()} = 0$ : 
+
+${alignTex(steps.map((e) => [e]))}
+
+Les vecteurs $${u.toTex()}$ et $${v.toTex()}$ sont donc orthogonaux si et seulement si $${res.toTex()}$.
+`;
+};
 const getKeys = () => {
     return [];
 };
@@ -88,8 +113,8 @@ const getQuestionFromIdentifiers = (identifiers) => {
         keys: getKeys(identifiers),
         answerFormat: "tex",
         identifiers,
-        // hint: getHint(identifiers),
-        // correction: getCorrection(identifiers)
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
 };
 export const findCoordinatesToOrthogonalize = {
@@ -108,4 +133,5 @@ export const findCoordinatesToOrthogonalize = {
     // getCorrection,
     getAnswer,
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

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

@@ -27,7 +27,7 @@ const getAnswer = (identifiers) => {
     const { uCoords, vCoords } = identifiers;
     const u = new Vector("u", new NumberNode(Number(uCoords[0])), new NumberNode(Number(uCoords[1])));
     const v = new Vector("v", new NumberNode(Number(vCoords[0])), new NumberNode(Number(vCoords[1])));
-    const answer = u.scalarProduct(v).toTex();
+    const answer = u.scalarProduct(v).simplify().toTex();
     return answer;
 };
 const getHint = () => {

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

@@ -1 +1 @@
-{"version":3,"file":"scalarProductViaCos.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/geometry/vectors/scalarProduct/scalarProductViaCos.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAgBrC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AA+EF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAerD,CAAC"}
+{"version":3,"file":"scalarProductViaCos.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/geometry/vectors/scalarProduct/scalarProductViaCos.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAqBrC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AAkHF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAgBrD,CAAC"}

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

@@ -3,13 +3,47 @@ import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinct
 import { mainTrigoValues, remarkableTrigoValues, } from "../../../../../math/trigonometry/remarkableValues.js";
 import { randint } from "../../../../../math/utils/random/randint.js";
 import { NumberNode } from "../../../../../tree/nodes/numbers/numberNode.js";
-import { MultiplyNode } from "../../../../../tree/nodes/operators/multiplyNode.js";
+import { multiply, MultiplyNode, } from "../../../../../tree/nodes/operators/multiplyNode.js";
 import { randomLetter } from "../../../../../utils/strings/randomLetter.js";
 import { shuffle } from "../../../../../utils/alea/shuffle.js";
 import { random } from "../../../../../utils/alea/random.js";
 import { handleVEAError } from "../../../../../utils/errors/handleVEAError.js";
 import { parseAlgebraic } from "../../../../../tree/parsers/latexParser.js";
+import { alignTex } from "../../../../../utils/latex/alignTex.js";
+import { cos } from "../../../../../tree/nodes/functions/cosNode.js";
 //|u| |v| cos(u,v)
+const getHint = () => {
+    return `Utilise la formule du produit scalaire suivante : 
+  
+$$
+\\overrightarrow{u}\\cdot \\overrightarrow{v} = ||\\overrightarrow{u}|| \\times ||\\overrightarrow{v}||\\times \\cos(\\widehat{\\overrightarrow{u}, \\overrightarrow{v}})
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { AB, AC, trigoPoint, letters } = identifiers;
+    const trigo = mainTrigoValues.find((v) => v.point === trigoPoint);
+    const [letterA, letterB, letterC] = letters;
+    const u = letterA + letterB;
+    const v = letterA + letterC;
+    return `Utilise la formule du produit scalaire suivante : 
+  
+$$
+\\overrightarrow{u}\\cdot \\overrightarrow{v} = ||\\overrightarrow{u}|| \\times ||\\overrightarrow{v}||\\times \\cos(\\widehat{\\overrightarrow{u}, \\overrightarrow{v}})
+$$
+
+Ici, on a donc : 
+
+${alignTex([
+        [
+            `\\overrightarrow{${u}}\\cdot \\overrightarrow{${v}}`,
+            "=",
+            `${u}\\times ${v}\\times \\cos\\left(${letterB}${letterA}${letterC}\\right)`,
+        ],
+        ["", "=", multiply(multiply(AB, AC), cos(trigo.angle)).toTex()],
+        ["", "=", multiply(multiply(AB, AC), trigo.cos).toTex()],
+        ["", "=", getAnswer(identifiers)],
+    ])}`;
+};
 const getInstruction = (identifiers) => {
     const { AB, AC, trigoPoint, letters } = identifiers;
     const [letterA, letterB, letterC] = letters;
@@ -45,6 +79,8 @@ const getQuestionFromIdentifiers = (identifiers) => {
         keys: ["pi"],
         answerFormat: "tex",
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -83,4 +119,5 @@ export const scalarProductViaCos = {
     getInstruction,
     getAnswer,
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/geometry/volumes/parallelepipedVolume.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parallelepipedVolume.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/volumes/parallelepipedVolume.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AA8KF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAetD,CAAC"}
+{"version":3,"file":"parallelepipedVolume.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/volumes/parallelepipedVolume.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAyLF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAetD,CAAC"}