math-exercises 3.0.200 → 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/utils/data/randomDataTable.d.ts

@@ -6,6 +6,9 @@ export declare const randomDataCategAndValues: (nbCateg: number, nbValues: numbe
     categ: DataCategory;
     values: number[];
 }[];
-export declare const randomDataTable: (nbCateg?: number, nbValues?: number, isRowBased?: boolean) => string[][];
+export declare const randomDataTable: (arrCategAndValues: {
+    categ: DataCategory;
+    values: number[];
+}[], isRowBased?: boolean) => string[][];
 export {};
 //# sourceMappingURL=randomDataTable.d.ts.map

package/lib/exercises/utils/data/randomDataTable.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"randomDataTable.d.ts","sourceRoot":"","sources":["../../../../src/exercises/utils/data/randomDataTable.ts"],"names":[],"mappings":"AAKA,KAAK,YAAY,GAAG;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,GAAG,EAAE,CAAC,GAAG,CAAC,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;CAC7C,CAAC;AA6DF,eAAO,MAAM,wBAAwB,GAAI,SAAS,MAAM,EAAE,UAAU,MAAM;;;GAazE,CAAC;AAEF,eAAO,MAAM,eAAe,GAC1B,UAAS,MAAU,EACnB,WAAU,MAAU,EACpB,aAAY,OAAc,eAW3B,CAAC"}
+{"version":3,"file":"randomDataTable.d.ts","sourceRoot":"","sources":["../../../../src/exercises/utils/data/randomDataTable.ts"],"names":[],"mappings":"AAKA,KAAK,YAAY,GAAG;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,GAAG,EAAE,CAAC,GAAG,CAAC,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;CAC7C,CAAC;AA6DF,eAAO,MAAM,wBAAwB,GAAI,SAAS,MAAM,EAAE,UAAU,MAAM;;;GAazE,CAAC;AAEF,eAAO,MAAM,eAAe,GAC1B,mBAAmB;IACjB,KAAK,EAAE,YAAY,CAAC;IACpB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,EAAE,EACH,aAAY,OAAc,eAU3B,CAAC"}

package/lib/exercises/utils/data/randomDataTable.js

@@ -51,8 +51,7 @@ export const randomDataCategAndValues = (nbCateg, nbValues) => {
     });
     return arrCategAndValues;
 };
-export const randomDataTable = (nbCateg = 3, nbValues = 3, isRowBased = true) => {
-    const arrCategAndValues = randomDataCategAndValues(nbCateg, nbValues);
+export const randomDataTable = (arrCategAndValues, isRowBased = true) => {
     const rowBasedDataTable = arrCategAndValues.map(({ categ, values }) => {
         return [categ.nameTex, ...values.map((value) => `$${value.frenchify()}$`)];
     });

package/lib/exercises/vea/varLineVEA.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"varLineVEA.d.ts","sourceRoot":"","sources":["../../../src/exercises/vea/varLineVEA.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,eAAO,MAAM,UAAU,GAAI,KAAK,MAAM,EAAE,EAAE,EAAE,aAAa,MAAM,EAAE,EAAE,YAoClE,CAAC"}
+{"version":3,"file":"varLineVEA.d.ts","sourceRoot":"","sources":["../../../src/exercises/vea/varLineVEA.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAMH,eAAO,MAAM,UAAU,GAAI,KAAK,MAAM,EAAE,EAAE,EAAE,aAAa,MAAM,EAAE,EAAE,YAkDlE,CAAC"}

package/lib/exercises/vea/varLineVEA.js

@@ -4,7 +4,9 @@
  * @param answerTable lignes de variations de la réponse
  * cette fonction ne check que la ligne des variations
  */
-import { rationalVEA } from "./rationalVEA.js";
+import { parseAlgebraic } from "../../tree/parsers/latexParser.js";
+import { NodeComparator } from "../../tree/utilities/nodeComparator.js";
+import { handleVEAError } from "../../utils/errors/handleVEAError.js";
 export const varLineVEA = (ans, answerTable) => {
     const isValue = (s) => s !== "" && s !== "\\ " && s !== " ";
     const flattenTable = (table) => {
@@ -41,7 +43,18 @@ export const varLineVEA = (ans, answerTable) => {
         }
         else {
             const isValid = (!isValue(value) && !isValue(flattenedAnswerTable[i])) ||
-                rationalVEA(value, flattenedAnswerTable[i]);
+                // rationalVEA(value, flattenedAnswerTable[i]);
+                (() => {
+                    try {
+                        const [nodeAns, nodeAnswer] = [value, flattenedAnswerTable[i]].map((str) => parseAlgebraic(str));
+                        return (NodeComparator.isEqualViaSub(nodeAns, nodeAnswer) ||
+                            NodeComparator.isEqualViaFrac(nodeAns, nodeAnswer));
+                    }
+                    catch (e) {
+                        handleVEAError(e);
+                        return false;
+                    }
+                })();
             if (!isValid)
                 return false;
             continue;

package/lib/exercises/vea/xTableLineVEA.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"xTableLineVEA.d.ts","sourceRoot":"","sources":["../../../src/exercises/vea/xTableLineVEA.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH,eAAO,MAAM,aAAa,GAAI,KAAK,MAAM,EAAE,EAAE,aAAa,MAAM,EAAE,YAYjE,CAAC"}
+{"version":3,"file":"xTableLineVEA.d.ts","sourceRoot":"","sources":["../../../src/exercises/vea/xTableLineVEA.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAMH,eAAO,MAAM,aAAa,GAAI,KAAK,MAAM,EAAE,EAAE,aAAa,MAAM,EAAE,YAyBjE,CAAC"}

package/lib/exercises/vea/xTableLineVEA.js

@@ -5,7 +5,9 @@
  * cette fonction ne check que la ligne des x dans un tableau de variations / signes
  * TODO passer en argument le VEA check qui est ajd fixé à rationalVEA
  */
-import { rationalVEA } from "./rationalVEA.js";
+import { parseAlgebraic } from "../../tree/parsers/latexParser.js";
+import { NodeComparator } from "../../tree/utilities/nodeComparator.js";
+import { handleVEAError } from "../../utils/errors/handleVEAError.js";
 export const xTableLineVEA = (ans, answerTable) => {
     return ans.slice(1).every((cell, i) => {
         const answerCell = answerTable[i + 1];
@@ -14,6 +16,15 @@ export const xTableLineVEA = (ans, answerTable) => {
             answerCell === " " ||
             answerCell.includes("\\infty"))
             return cell === answerCell;
-        return rationalVEA(cell, answerCell);
+        // return rationalVEA(cell, answerCell);
+        try {
+            const [nodeAns, nodeAnswer] = [cell, answerCell].map((str) => parseAlgebraic(str));
+            return (NodeComparator.isEqualViaSub(nodeAns, nodeAnswer) ||
+                NodeComparator.isEqualViaFrac(nodeAns, nodeAnswer));
+        }
+        catch (e) {
+            handleVEAError(e);
+            return false;
+        }
     });
 };