math-exercises 3.0.199 → 3.0.201

package/lib/exercises/math/spaceGeometry/vectors/findLinearDecompositionWrtCoplanarUVFromCoords.d.ts

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { SpacePointIdentifiers } from "../../../../math/geometry/spacePoint.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    spacePointIdsForVecs: SpacePointIdentifiers[];
+    nodeIdsCoeffs: NodeIdentifiers[];
+};
+export declare const findLinearDecompositionWrtCoplanarUVFromCoords: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=findLinearDecompositionWrtCoplanarUVFromCoords.d.ts.map

package/lib/exercises/math/spaceGeometry/vectors/findLinearDecompositionWrtCoplanarUVFromCoords.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"findLinearDecompositionWrtCoplanarUVFromCoords.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/vectors/findLinearDecompositionWrtCoplanarUVFromCoords.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAGL,qBAAqB,EACtB,MAAM,mCAAmC,CAAC;AAM3C,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AA8B7C,KAAK,WAAW,GAAG;IACjB,oBAAoB,EAAE,qBAAqB,EAAE,CAAC;IAC9C,aAAa,EAAE,eAAe,EAAE,CAAC;CAClC,CAAC;AA4QF,eAAO,MAAM,8CAA8C,EAAE,QAAQ,CAAC,WAAW,CAmB9E,CAAC"}

package/lib/exercises/math/spaceGeometry/vectors/findLinearDecompositionWrtCoplanarUVFromCoords.js

@@ -0,0 +1,236 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, propWhile, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { SpacePoint, SpacePointConstructor, } from "../../../../math/geometry/spacePoint.js";
+import { SpaceVector } from "../../../../math/geometry/spaceVector.js";
+import { Vector } from "../../../../math/geometry/vector.js";
+import { GeneralSystem } from "../../../../math/systems/generalSystem.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { NodeComparator } from "../../../../tree/utilities/nodeComparator.js";
+import { randomMany } from "../../../../utils/alea/random.js";
+import { zip } from "../../../../utils/arrays/arrayZip.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const strForSystem3D = (coeffs, [varNameX, varNameY] = ["x", "y"]) => {
+    return `\\left\\{\\begin{matrix}
+  ${add(multiply(coeffs[0][0], varNameX), multiply(coeffs[0][1], varNameY)).toTex()}=${coeffs[0][2].toTex()} \\\\
+  ${add(multiply(coeffs[1][0], varNameX), multiply(coeffs[1][1], varNameY)).toTex()}=${coeffs[1][2].toTex()} \\\\
+  ${add(multiply(coeffs[2][0], varNameX), multiply(coeffs[2][1], varNameY)).toTex()}=${coeffs[2][2].toTex()}
+  \\end{matrix}\\right.`;
+};
+const getHydrated = (identifiers) => {
+    const { spacePointIdsForVecs, nodeIdsCoeffs } = identifiers;
+    const [vecU, vecV] = zip(["u", "v"], spacePointIdsForVecs).map(([name, pointIds]) => {
+        const spacePoint = SpacePointConstructor.fromIdentifiers(pointIds);
+        return new SpaceVector(name, spacePoint.x, spacePoint.y, spacePoint.z);
+    });
+    const [nodeFactor1, nodeFactor2] = nodeIdsCoeffs.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const vecW = (() => {
+        const vecRaw = vecU.times(nodeFactor1).add(vecV.times(nodeFactor2));
+        return new SpaceVector("w", vecRaw.x, vecRaw.y, vecRaw.z);
+    })();
+    const generalSystem = new GeneralSystem([
+        [vecU.x, vecV.x, vecW.x],
+        [vecU.y, vecV.y, vecW.y],
+    ]);
+    return {
+        vecU,
+        vecV,
+        nodeFactor1,
+        nodeFactor2,
+        vecW,
+        generalSystem,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { vecU, vecV, vecW } = getHydrated(identifiers);
+    return `Soient trois vecteurs coplanaires $\\overrightarrow{u}$, $\\overrightarrow{v}$ et $\\overrightarrow{w}$ tels que : 
+
+${alignTex([vecU, vecV, vecW].map((vec) => [vec.toTex(), "=", vec.toCoordsTex()]))}
+  
+Quelles sont les coordonnées de $\\overrightarrow{w}$ dans la base $(\\overrightarrow{u};\\overrightarrow{v})$ ?`;
+};
+const getAnswerVector = (identifiers) => {
+    const { nodeIdsCoeffs } = identifiers;
+    const [nodeFactor1, nodeFactor2] = nodeIdsCoeffs.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const vecWWrtUV = new Vector("w", nodeFactor1, nodeFactor2);
+    return vecWWrtUV;
+};
+const getAnswer = (identifiers) => {
+    return getAnswerVector(identifiers).toInlineCoordsTex();
+};
+const getHint = () => {
+    return `Les vecteurs sont coplanaires. Il existe donc deux réels $a$ et $b$ tels que : 
+
+$$
+\\overrightarrow{w} = a \\overrightarrow{u} + b \\overrightarrow{v}
+$$
+
+Cela donne un système de $2$ équations: une pour chaque composante du vecteur \\overrightarrow{w}.
+Résout ce système, autrement dit détermine $a$ et $b$.
+
+Les coordonnées de $\\overrightarrow{w}$ dans la base $(\\overrightarrow{u};\\overrightarrow{v})$.`;
+};
+const getCorrection = (identifiers) => {
+    const { vecU, vecV, nodeFactor1, nodeFactor2, vecW, generalSystem } = getHydrated(identifiers);
+    return `Les vecteurs sont coplanaires. Il existe donc deux réels $a$ et $b$ tels que : 
+
+${alignTex([
+        ["\\overrightarrow{w}", "=", "a \\overrightarrow{u} + b \\overrightarrow{v}"],
+        [
+            vecW.toCoordsTex(),
+            "=",
+            `a ${vecU.toCoordsTex()} + b ${vecV.toCoordsTex()}`,
+        ],
+    ])}
+
+On obtient un système :
+
+$$
+${strForSystem3D([
+        [vecU.x, vecV.x, vecW.x],
+        [vecU.y, vecV.y, vecW.y],
+        [vecU.z, vecV.z, vecW.z],
+    ], ["a", "b"])}
+$$
+
+Les deux premières lignes suffisent pour résoudre le système.
+
+${generalSystem.toCorrectionTex(["a", "b"], false)}
+
+Les coordonnées de $\\overrightarrow{w}$ dans la base $(\\overrightarrow{u};\\overrightarrow{v})$ sont $(${nodeFactor1.toTex()};${nodeFactor2.toTex()})$.`;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        const identifiersWrong = createQCPassedIdentifiers();
+        tryToAddWrongProp(propositions, getAnswer(identifiersWrong));
+    });
+    return shuffleProps(propositions, n);
+};
+const getKeys = () => {
+    return ["semicolon"];
+};
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
+    const vecAnswer = getAnswerVector(identifiers);
+    const arrNodeAnswer = [vecAnswer.x, vecAnswer.y];
+    function matchGroups(regex, input) {
+        const match = regex.exec(input);
+        return match?.groups || undefined;
+    }
+    try {
+        const arrNodeAns = (() => {
+            const arrKey = [...Array(2).keys()]
+                .map((i) => i + 1)
+                .map((v) => `str${v}`);
+            const strRegex = `^\\\\left\\(${arrKey
+                .map((strKey) => `(?<${strKey}>.*(?!;$))`)
+                .join(";")}\\\\right\\)$`;
+            const regex = new RegExp(strRegex);
+            const ansParts = matchGroups(regex, ans);
+            if (ansParts === undefined) {
+                throw new Error("Parsing error: ans is not a tuple");
+            }
+            const arrNode = Object.entries(ansParts).map(([_key, str]) => parseAlgebraic(str));
+            return arrNode;
+        })();
+        return zip(arrNodeAns, arrNodeAnswer).every(([nodeAns, nodeAnswer]) => NodeComparator.isEqualViaSub(nodeAns, nodeAnswer));
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const createRandomIdentifiers = () => {
+    const [nodeFactor1, nodeFactor2] = randomMany([
+        (-3).toTree(),
+        (-2).toTree(),
+        (-1).toTree(),
+        (1).toTree(),
+        (2).toTree(),
+        (3).toTree(),
+    ], 2);
+    const funcRand1 = () => randint(-3, 4, [0]).toTree();
+    const funcRand2 = () => randint(-6, 7, [0]).toTree();
+    const funcRand3 = () => randint(-9, 10, [0]).toTree();
+    const [vecU, vecV] = zip(["u", "v"], [
+        [funcRand1, funcRand2, funcRand3],
+        [funcRand3, funcRand2, funcRand1],
+    ]).map(([name, [funcRandX, funcRandY, funcRandZ]]) => new SpaceVector(name, funcRandX(), funcRandY(), funcRandZ()));
+    const identifiers = {
+        spacePointIdsForVecs: [vecU, vecV].map((vec) => new SpacePoint(vec.name, vec.x, vec.y, vec.z).toIdentifiers()),
+        nodeIdsCoeffs: [nodeFactor1, nodeFactor2].map((node) => node.toIdentifiers()),
+    };
+    return identifiers;
+};
+const isIdentifiersQCPassed = (identifiers) => {
+    const isExploding = (identifiers) => {
+        let isExploding = false;
+        try {
+            getCorrection(identifiers);
+        }
+        catch (_) {
+            isExploding = true;
+        }
+        return isExploding;
+    };
+    return !isExploding(identifiers);
+};
+const createQCPassedIdentifiers = () => {
+    let identifiers;
+    let counter = -1;
+    let isValid = false;
+    while (!isValid && counter < 100) {
+        counter++;
+        const identifiersCandidate = createRandomIdentifiers();
+        isValid = isIdentifiersQCPassed(identifiersCandidate);
+        if (isValid) {
+            identifiers = identifiersCandidate;
+        }
+    }
+    if (!isValid) {
+        const vecU = new SpaceVector("u", (1).toTree(), (2).toTree(), (3).toTree());
+        const vecV = new SpaceVector("u", (2).toTree(), (3).toTree(), (5).toTree());
+        const [nodeFactor1, nodeFactor2] = [(-1).toTree(), (3).toTree()];
+        const identifiersDefault = {
+            spacePointIdsForVecs: [vecU, vecV].map((vec) => new SpacePoint(vec.name, vec.x, vec.y, vec.z).toIdentifiers()),
+            nodeIdsCoeffs: [nodeFactor1, nodeFactor2].map((node) => node.toIdentifiers()),
+        };
+        identifiers = identifiersDefault;
+    }
+    return identifiers;
+};
+const getFindLinearDecompositionWrtCoplanarUVFromCoordsQuestion = () => {
+    const identifiers = createQCPassedIdentifiers();
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers, _opts) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const findLinearDecompositionWrtCoplanarUVFromCoords = {
+    id: "findLinearDecompositionWrtCoplanarUVFromCoords",
+    label: "Déterminer si $3$ points de coordonnées données sont alignés",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getFindLinearDecompositionWrtCoplanarUVFromCoordsQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    isAnswerValid,
+    getPropositions,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/spaceGeometry/vectors/index.d.ts

@@ -1,4 +1,6 @@
 export * from "./spaceVectorNormCalculation.js";
 export * from "./spaceVectorCoordinatesFromPoints.js";
 export * from "./spaceVectorLinearCombinationCoords.js";
+export * from "./findLinearDecompositionWrtCoplanarUVFromCoords.js";
+export * from "./spacePointsDistanceCalculation.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/spaceGeometry/vectors/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/vectors/index.ts"],"names":[],"mappings":"AAAA,cAAc,iCAAiC,CAAC;AAChD,cAAc,uCAAuC,CAAC;AACtD,cAAc,yCAAyC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/vectors/index.ts"],"names":[],"mappings":"AAAA,cAAc,iCAAiC,CAAC;AAChD,cAAc,uCAAuC,CAAC;AACtD,cAAc,yCAAyC,CAAC;AACxD,cAAc,qDAAqD,CAAC;AACpE,cAAc,qCAAqC,CAAC"}

package/lib/exercises/math/spaceGeometry/vectors/index.js

@@ -1,3 +1,5 @@
 export * from "./spaceVectorNormCalculation.js";
 export * from "./spaceVectorCoordinatesFromPoints.js";
 export * from "./spaceVectorLinearCombinationCoords.js";
+export * from "./findLinearDecompositionWrtCoplanarUVFromCoords.js";
+export * from "./spacePointsDistanceCalculation.js";

package/lib/exercises/math/spaceGeometry/vectors/spacePointsDistanceCalculation.d.ts

@@ -0,0 +1,8 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { SpacePointIdentifiers } from "../../../../math/geometry/spacePoint.js";
+type Identifiers = {
+    spacePointIds: SpacePointIdentifiers[];
+};
+export declare const spacePointsDistanceCalculation: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=spacePointsDistanceCalculation.d.ts.map

package/lib/exercises/math/spaceGeometry/vectors/spacePointsDistanceCalculation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spacePointsDistanceCalculation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/vectors/spacePointsDistanceCalculation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAGrC,OAAO,EAGL,qBAAqB,EACtB,MAAM,mCAAmC,CAAC;AA0C3C,KAAK,WAAW,GAAG;IACjB,aAAa,EAAE,qBAAqB,EAAE,CAAC;CACxC,CAAC;AAsKF,eAAO,MAAM,8BAA8B,EAAE,QAAQ,CAAC,WAAW,CAahE,CAAC"}

package/lib/exercises/math/spaceGeometry/vectors/spacePointsDistanceCalculation.js

@@ -0,0 +1,156 @@
+import { addValidProp, propWhile, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { numberVEA } from "../../../../exercises/vea/numberVEA.js";
+import { SpacePoint, SpacePointConstructor, } from "../../../../math/geometry/spacePoint.js";
+import { SpaceVector } from "../../../../math/geometry/spaceVector.js";
+import { round } from "../../../../math/utils/round.js";
+import { sqrt } from "../../../../tree/nodes/functions/sqrtNode.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { square } from "../../../../tree/nodes/operators/powerNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { VariableNode } from "../../../../tree/nodes/variables/variableNode.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const norm3DRaw = (spaceVector) => {
+    return sqrt(add(square(spaceVector.x), add(square(spaceVector.y), square(spaceVector.z))));
+};
+const spaceVectorFromPointsRaw = (spacePointStart, spacePointEnd) => {
+    return new SpaceVector(`${spacePointStart.name}${spacePointEnd.name}`, substract(spacePointEnd.x, spacePointStart.x), substract(spacePointEnd.y, spacePointStart.y), substract(spacePointEnd.z, spacePointStart.z));
+};
+const simplifySpaceVector = (vec, opts = {}) => {
+    return new SpaceVector(vec.name, vec.x.simplify(opts), vec.y.simplify(opts), vec.z.simplify(opts));
+};
+const getHydrated = (identifiers) => {
+    const { spacePointIds } = identifiers;
+    const [A, B] = spacePointIds.map((spacePointIds) => SpacePointConstructor.fromIdentifiers(spacePointIds));
+    const [vecAB] = [[A, B]].map(([spacePointStart, spacePointEnd]) => spaceVectorFromPointsRaw(spacePointStart, spacePointEnd));
+    const vecABSimplified = simplifySpaceVector(vecAB);
+    const [nodeNormAB] = [vecABSimplified].map((vec) => norm3DRaw(vec));
+    return {
+        A,
+        B,
+        vecAB,
+        vecABSimplified,
+        nodeNormAB,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { spacePointIds } = identifiers;
+    const [A, B] = spacePointIds.map((spacePointIds) => SpacePointConstructor.fromIdentifiers(spacePointIds));
+    return `Soient deux points $A$ et $B$ de coordonnées :
+  
+${alignTex([A, B].map((spacePoint) => [spacePoint.toTexWithCoords()]))}
+
+Calculer la distance entre $A$ et $B$ (arrondie à $2$ décimales).`;
+};
+const getAnswer = (identifiers) => {
+    const { nodeNormAB } = getHydrated(identifiers);
+    return round(nodeNormAB.evaluate(), 2).frenchify();
+};
+const getHint = () => {
+    const A = new SpacePoint("A", new VariableNode("a_{x}"), new VariableNode("a_{y}"), new VariableNode("a_{z}"));
+    const B = new SpacePoint("B", new VariableNode("b_{x}"), new VariableNode("b_{y}"), new VariableNode("b_{z}"));
+    const vecAB = spaceVectorFromPointsRaw(A, B);
+    return `Dans un repère dans l'espace orthonormé, la distance entre deux points $A$ et $B$ est la norme du vecteur $\\overrightarrow{AB}$.
+
+Si les coordonnées de $A$ et de $B$ sont :
+
+${alignTex([A, B].map((spacePoint) => [spacePoint.toTexWithCoords()]))}
+
+alors
+
+${alignTex([
+        ["", "AB"],
+        ["=", "\\lVert \\overrightarrow{AB} \\rVert"],
+        ["=", ""],
+    ])}
+
+$$
+${norm3DRaw(vecAB).toTex()}
+$$
+
+`;
+};
+const getCorrection = (identifiers) => {
+    const { vecAB, vecABSimplified, nodeNormAB } = getHydrated(identifiers);
+    const valueNormAB = nodeNormAB.evaluate();
+    const valueNormABRounded = round(valueNormAB, 2);
+    const isEqualToRounded = valueNormAB === valueNormABRounded;
+    const symbolApproxOrEqual = isEqualToRounded ? "=" : "\\approx";
+    return `On a : 
+  
+${alignTex([[vecAB, vecABSimplified]].flatMap(([vec, vecSimplified]) => [
+        [vec.toTex(), "=", vec.toCoordsTex()],
+        ["", "=", vecSimplified.toCoordsTex()],
+    ]))}
+  
+Par conséquent :
+  
+${alignTex([
+        ["AB", "=", "\\lVert \\overrightarrow{AB} \\rVert"],
+        ["", "=", ""],
+    ])}
+
+$$
+${norm3DRaw(vecAB).toTex()}
+$$
+
+$$
+${symbolApproxOrEqual}${valueNormABRounded.frenchify()}
+$$
+
+`;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        const identifiersWrong = createRandomIdentifiers();
+        tryToAddWrongProp(propositions, getAnswer(identifiersWrong));
+    });
+    return shuffleProps(propositions, n);
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return numberVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const createRandomIdentifiers = () => {
+    const [A, B] = ["A", "B"].map((name) => SpacePointConstructor.random(name));
+    const identifiers = {
+        spacePointIds: [A, B].map((spacePoint) => spacePoint.toIdentifiers()),
+    };
+    return identifiers;
+};
+const getSpacePointsDistanceCalculationQuestion = () => {
+    const identifiers = createRandomIdentifiers();
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const spacePointsDistanceCalculation = {
+    id: "spacePointsDistanceCalculation",
+    label: "Calculer la distance entre deux points (dans l'espace)",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getSpacePointsDistanceCalculationQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
+};

package/lib/exercises/math/trigonometry/functions/index.d.ts

@@ -7,4 +7,5 @@ export * from "./cosInequationMainInterval.js";
 export * from "./sinInequationMainInterval.js";
 export * from "./readPeriodicityOnFunctionGraph.js";
 export * from "./associateAngleSimplification.js";
+export * from "./parityOfCosAXTimesSinBX.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/trigonometry/functions/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/trigonometry/functions/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC;AACtC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,kCAAkC,CAAC;AAEjD,cAAc,0BAA0B,CAAC;AACzC,cAAc,gCAAgC,CAAC;AAC/C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,qCAAqC,CAAC;AACpD,cAAc,mCAAmC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/trigonometry/functions/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC;AACtC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,kCAAkC,CAAC;AAEjD,cAAc,0BAA0B,CAAC;AACzC,cAAc,gCAAgC,CAAC;AAC/C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,qCAAqC,CAAC;AACpD,cAAc,mCAAmC,CAAC;AAClD,cAAc,8BAA8B,CAAC"}

package/lib/exercises/math/trigonometry/functions/index.js

@@ -8,3 +8,4 @@ export * from "./cosInequationMainInterval.js";
 export * from "./sinInequationMainInterval.js";
 export * from "./readPeriodicityOnFunctionGraph.js";
 export * from "./associateAngleSimplification.js";
+export * from "./parityOfCosAXTimesSinBX.js";

package/lib/exercises/math/trigonometry/functions/parityOfCosAXTimesSinBX.d.ts

@@ -0,0 +1,8 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    nodeIdsF: NodeIdentifiers;
+};
+export declare const parityOfCosAXTimesSinBX: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=parityOfCosAXTimesSinBX.d.ts.map

package/lib/exercises/math/trigonometry/functions/parityOfCosAXTimesSinBX.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parityOfCosAXTimesSinBX.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/trigonometry/functions/parityOfCosAXTimesSinBX.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAqD7C,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,eAAe,CAAC;CAC3B,CAAC;AAoKF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAczD,CAAC"}

package/lib/exercises/math/trigonometry/functions/parityOfCosAXTimesSinBX.js

@@ -0,0 +1,193 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { opposite } from "../../../../tree/nodes/functions/oppositeNode.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
+import { multiply, } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { FunctionsIds, } from "../../../../tree/nodes/functions/functionNode.js";
+import { random } from "../../../../utils/alea/random.js";
+import { sin } from "../../../../tree/nodes/functions/sinNode.js";
+import { cos } from "../../../../tree/nodes/functions/cosNode.js";
+import { VariableNode } from "../../../../tree/nodes/variables/variableNode.js";
+import { nodeBySubstitutingVar } from "../../../../math/utils/functions/functionComposition.js";
+const rewriteFunctionNode = (nodeFunc) => {
+    const isChildMinusSigned = nodeFunc.child
+        .simplify({ towardsDistribute: true })
+        .toTex()
+        .startsWith("-");
+    if (isChildMinusSigned) {
+        switch (nodeFunc.id) {
+            case FunctionsIds.cos:
+                return cos(opposite(nodeFunc.child).simplify());
+            case FunctionsIds.sin:
+                return opposite(sin(opposite(nodeFunc.child).simplify()));
+            default:
+                return nodeFunc;
+        }
+    }
+    else {
+        return nodeFunc;
+    }
+};
+const rewriteNodeF = (nodeF) => {
+    return multiply(rewriteFunctionNode(nodeF.leftChild), rewriteFunctionNode(nodeF.rightChild));
+};
+const getParityType = (nodeF) => {
+    const [bit1, bit2] = [
+        nodeF.leftChild,
+        nodeF.rightChild,
+    ].map((node) => (node.id === FunctionsIds.sin ? 1 : 0));
+    if ((bit1 + bit2) % 2 === 0) {
+        return "even";
+    }
+    else {
+        return "uneven";
+    }
+};
+const getInstruction = (identifiers) => {
+    const { nodeIdsF } = identifiers;
+    const nodeF = NodeConstructor.fromIdentifiers(nodeIdsF);
+    return `Soit $f$ la fonction définie par : 
+  
+$$
+f(x) = ${nodeF.toTex()}
+$$
+
+La fonction $f$ est-elle paire, impaire, ou ni paire ni impaire ?`;
+};
+const getAnswer = (identifiers) => {
+    const { nodeIdsF } = identifiers;
+    const nodeF = NodeConstructor.fromIdentifiers(nodeIdsF);
+    const type = getParityType(nodeF);
+    switch (type) {
+        case "even":
+            return "Paire";
+        case "uneven":
+            return "Impaire";
+        default:
+            return "Ni paire, ni impaire";
+    }
+};
+const getHint = () => {
+    return `Une fonction $f$ est paire si pour tout $x$ de son ensemble de définition, on a : $f(-x) = f(x)$.
+  
+Une fonction $f$ est impaire si pour tout $x$ de son ensemble de définition, on a : $f(-x) = -f(x)$.`;
+};
+const getCorrection = (identifiers) => {
+    const { nodeIdsF } = identifiers;
+    const nodeF = NodeConstructor.fromIdentifiers(nodeIdsF);
+    const type = getParityType(nodeF);
+    const nodeFRewritten = rewriteNodeF(nodeF);
+    const isNodeFRewritable = nodeFRewritten.toTex() !== nodeF.toTex();
+    const nodeVarX = new VariableNode("x");
+    const nodeFOfMinusX = nodeBySubstitutingVar(nodeF, opposite(nodeVarX), nodeVarX);
+    const nodeFOfMinusXRewritten1 = multiply(nodeFOfMinusX.leftChild.simplify(), nodeFOfMinusX.rightChild.simplify());
+    const nodeFOfMinusXRewritten2 = rewriteNodeF(nodeFOfMinusXRewritten1);
+    return `${isNodeFRewritable
+        ? `On peut réécrire $f(x)$ : 
+    
+${alignTex([
+            ["f(x)", "=", nodeF.toTex()],
+            ["", "=", nodeFRewritten.toTex({ forceParenthesis: true })],
+            ...(() => {
+                const texNodeFRewrittenSimplified = nodeFRewritten.simplify().toTex();
+                if (texNodeFRewrittenSimplified !==
+                    nodeFRewritten.toTex({ forceParenthesis: true })) {
+                    return [["", "=", texNodeFRewrittenSimplified]];
+                }
+                else {
+                    return [];
+                }
+            })(),
+        ])}
+
+`
+        : ``}
+  
+On exprime $f(-x)$ : 
+
+${alignTex([
+        ["f(-x)", "=", nodeFOfMinusX.toTex()],
+        ["", "=", nodeFOfMinusXRewritten1.toTex()],
+        ...(() => {
+            const texNodeFOfMinusXRewritten2 = nodeFOfMinusXRewritten2.toTex({
+                forceParenthesis: true,
+            });
+            if (texNodeFOfMinusXRewritten2 !== nodeFOfMinusXRewritten1.toTex()) {
+                return [["", "=", texNodeFOfMinusXRewritten2]];
+            }
+            else {
+                return [];
+            }
+        })(),
+        ...(() => {
+            const texNodeFOfMinusXRewritten2Simplified = nodeFOfMinusXRewritten2
+                .simplify()
+                .toTex();
+            if (texNodeFOfMinusXRewritten2Simplified !==
+                nodeFOfMinusXRewritten2.toTex({ forceParenthesis: true })) {
+                return [["", "=", texNodeFOfMinusXRewritten2Simplified]];
+            }
+            else {
+                return [];
+            }
+        })(),
+    ])}
+
+${type === "even"
+        ? "Puisque $f(-x) = f(x)$, la fonction $f$ est paire."
+        : `Puisque $f(-x) = -f(x)$, la fonction $f$ est impaire.`}
+`;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer, "raw");
+    tryToAddWrongProp(propositions, "Paire", "raw");
+    tryToAddWrongProp(propositions, "Impaire", "raw");
+    tryToAddWrongProp(propositions, "Ni paire, ni impaire", "raw");
+    tryToAddWrongProp(propositions, "On ne peut pas savoir", "raw");
+    return shuffleProps(propositions, n);
+};
+const getParityOfCosAXTimesSinBXQuestion = () => {
+    const nodeVarX = new VariableNode("x");
+    const nodeFactor1 = ((coinFlip() ? +1 : -1) * randint(1, 10)).toTree();
+    const node1 = multiply(nodeFactor1, nodeVarX);
+    const nodeFactor2 = ((coinFlip() ? +1 : -1) * randint(1, 10)).toTree();
+    const node2 = multiply(nodeFactor2, nodeVarX);
+    const [func1, func2] = random([
+        [sin, sin],
+        [sin, cos],
+        [cos, sin],
+        [cos, cos],
+    ]);
+    const nodeF = multiply(func1(node1), func2(node2));
+    const identifiers = { nodeIdsF: nodeF.toIdentifiers() };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "raw",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const parityOfCosAXTimesSinBX = {
+    id: "parityOfCosAXTimesSinBX",
+    label: "Déterminer si une fonction du type $\\cos(ax) \\sin(bx)$ est paire ou impaire",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getParityOfCosAXTimesSinBXQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    answerType: "QCU",
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};