math-exercises 3.0.181 → 3.0.182

package/lib/exercises/math/functions/exponential/algebraic/index.d.ts

@@ -1,5 +1,4 @@
 export * from "./approxExpN.js";
 export * from "./approxExpKa.js";
 export * from "./approxExpAPlusB.js";
-export * from "./rewriteExpUsingExpA.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/functions/exponential/algebraic/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/exponential/algebraic/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,kBAAkB,CAAC;AACjC,cAAc,sBAAsB,CAAC;AACrC,cAAc,0BAA0B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/exponential/algebraic/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,kBAAkB,CAAC;AACjC,cAAc,sBAAsB,CAAC"}

package/lib/exercises/math/functions/exponential/algebraic/index.js

@@ -1,4 +1,4 @@
 export * from "./approxExpN.js";
 export * from "./approxExpKa.js";
 export * from "./approxExpAPlusB.js";
-export * from "./rewriteExpUsingExpA.js";
+// export * from "./rewriteExpUsingExpA.js";

package/lib/exercises/math/probaStat/independancy/independancyFromEffectifTable.d.ts

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    aCapB: number;
+    aCapBBarre: number;
+    aBarreCapB: number;
+    aBarreCapBBarre: number;
+};
+export declare const independancyFromEffectifTable: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=independancyFromEffectifTable.d.ts.map

package/lib/exercises/math/probaStat/independancy/independancyFromEffectifTable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"independancyFromEffectifTable.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/independancy/independancyFromEffectifTable.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,eAAe,EAAE,MAAM,CAAC;CACzB,CAAC;AAwJF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,CAqB/D,CAAC"}

package/lib/exercises/math/probaStat/independancy/independancyFromEffectifTable.js

@@ -0,0 +1,154 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { dollarize } from "../../../../utils/latex/dollarize.js";
+import { mdTable } from "../../../../utils/markdown/mdTable.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer, "raw");
+    ["Oui", "Non", "On ne peut pas savoir"].forEach((prop) => tryToAddWrongProp(propositions, prop, "raw"));
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { aBarreCapB, aBarreCapBBarre, aCapB, aCapBBarre } = identifiers;
+    return aCapB * aBarreCapBBarre === aCapBBarre * aBarreCapB ? "Oui" : "Non";
+};
+const getInstruction = (identifiers) => {
+    const { aBarreCapB, aBarreCapBBarre, aCapB, aCapBBarre } = identifiers;
+    const total = aBarreCapB + aBarreCapBBarre + aCapB + aCapBBarre;
+    const aTotal = aCapB + aCapBBarre;
+    const bTotal = aCapB + aBarreCapB;
+    const aBarreTotal = aBarreCapB + aBarreCapBBarre;
+    const bBarreTotal = aBarreCapBBarre + aCapBBarre;
+    return `On considère deux événements $A$ et $B$. 
+  
+Le tableau suivant donne le nombre d'issues pour chacun des événements $A\\cap B$, $\\overline A\\cap B$, $A\\cap \\overline B$ et $\\overline A \\cap \\overline B$. 
+      
+${mdTable([
+        [" ", "$B$", "$\\overline{B}$", "Total"],
+        ["$A$", dollarize(aCapB), `$${aCapBBarre}$`, `$${aTotal}$`],
+        [
+            "$\\overline{A}$",
+            dollarize(aBarreCapB),
+            dollarize(aBarreCapBBarre),
+            dollarize(aBarreTotal),
+        ],
+        ["Total", dollarize(bTotal), dollarize(bBarreTotal), dollarize(total)],
+    ])}
+
+Les événements $A$ et $B$ sont-ils indépendants ?
+  `;
+};
+const getHint = () => {
+    return `Deux évènements $A$ et $B$ sont indépendants lorsque :
+  
+  
+$$
+P(A\\cap B) = P(A)\\times P(B)
+$$
+
+Une autre façon de vérifier si deux évènements sont indépendants utilise les probabilités conditionnelles : $A$ et $B$ sont indépendants si et seulement si :
+
+$$
+P_B(A) = P(A)
+$$
+
+Choisis une de ces deux méthodes, puis vérifie si l'égalité est vraie.`;
+};
+const getCorrection = (identifiers) => {
+    const { aBarreCapB, aBarreCapBBarre, aCapB, aCapBBarre } = identifiers;
+    const total = aBarreCapB + aBarreCapBBarre + aCapB + aCapBBarre;
+    const aTotal = aCapB + aCapBBarre;
+    const bTotal = aCapB + aBarreCapB;
+    const pA = frac(aTotal, total);
+    const pB = frac(bTotal, total);
+    const pANB = frac(aCapB, total);
+    const isInde = getAnswer(identifiers) === "Oui";
+    return `On vérifie si $P(A\\cap B) = P(A)\\times P(B)$.
+  
+On a : 
+
+$$
+P(A\\cap B) = ${pANB.toSimplificationTex()}
+$$
+
+$$
+P(A) = ${pA.toSimplificationTex()}
+$$
+
+$$
+P(B) = ${pB.toSimplificationTex()}
+$$
+
+donc :
+
+$$
+P(A) \\times P(B) = ${multiply(pA.simplify(), pB.simplify()).toSimplificationTex()}
+$$
+
+Puisque $P(A\\cap B) ${isInde ? "=" : "\\neq"} P(A)\\times P(B)$, les évènements $A$ et $B$ ${isInde ? "sont" : "ne sont pas"} indépendants.`;
+};
+const getIndependancyFromEffectifTableQuestion = () => {
+    const isInde = coinFlip();
+    let aCapB;
+    let aCapBBarre;
+    let aBarreCapB;
+    let aBarreCapBBarre;
+    if (isInde) {
+        const r = randint(1, 7);
+        const u = randint(1, 7, [r]);
+        const s = randint(1, 7);
+        const t = randint(1, 7, [s]);
+        console.log(r, u, s, t);
+        aCapB = r * s;
+        aCapBBarre = r * t;
+        aBarreCapB = u * s;
+        aBarreCapBBarre = u * t;
+    }
+    else {
+        do {
+            aCapB = randint(1, 20);
+            aCapBBarre = randint(1, 20, [aCapB]);
+            aBarreCapB = randint(1, 20, [aCapB, aCapBBarre]);
+            aBarreCapBBarre = randint(1, 20, [aCapB, aCapBBarre, aBarreCapB]);
+        } while (aCapB * aBarreCapBBarre === aCapBBarre * aBarreCapB);
+    }
+    const identifiers = {
+        aBarreCapB,
+        aBarreCapBBarre,
+        aCapB,
+        aCapBBarre,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "raw",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const independancyFromEffectifTable = {
+    id: "independancyFromEffectifTable",
+    label: "Déterminer si deux évènements sont indépendants à partir d'un tableau d'effectifs",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getIndependancyFromEffectifTableQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    answerType: "QCU",
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/probaStat/independancy/independancyFromProbaTree.d.ts

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

package/lib/exercises/math/probaStat/independancy/independancyFromProbaTree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"independancyFromProbaTree.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/independancy/independancyFromProbaTree.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAO7C,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,eAAe,CAAC;IACvB,OAAO,EAAE,eAAe,CAAC;IACzB,YAAY,EAAE,eAAe,CAAC;CAC/B,CAAC;AAoJF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAiB3D,CAAC"}

package/lib/exercises/math/probaStat/independancy/independancyFromProbaTree.js

@@ -0,0 +1,152 @@
+/* eslint-disable @typescript-eslint/naming-convention */
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { RationalConstructor } from "../../../../math/numbers/rationals/rational.js";
+import { randfloat } from "../../../../math/utils/random/randfloat.js";
+import { reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer, "raw");
+    ["Oui", "Non", "On ne peut pas savoir"].forEach((prop) => tryToAddWrongProp(propositions, prop, "raw"));
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { p_ABIds, p_ABarreBIds } = identifiers;
+    const p_AB = reifyAlgebraic(p_ABIds);
+    const p_ABarreB = reifyAlgebraic(p_ABarreBIds);
+    return p_AB.simplify().toTex() === p_ABarreB.simplify().toTex()
+        ? "Oui"
+        : "Non";
+};
+const getInstruction = (identifiers) => {
+    const { pAIds, p_ABIds, p_ABarreBIds } = identifiers;
+    const pA = reifyAlgebraic(pAIds);
+    const pABarre = substract(1, pA).simplify();
+    const p_AB = reifyAlgebraic(p_ABIds);
+    const p_ABBarre = substract(1, p_AB).simplify();
+    const p_ABarreB = reifyAlgebraic(p_ABarreBIds);
+    const p_ABarreBBarre = substract(1, p_ABarreB).simplify();
+    const tree = [
+        [
+            [
+                [`£${pA.toTex()}£`, "£A£"],
+                [`£${pABarre.toTex()}£`, "£\\overline{A}£"],
+            ],
+        ],
+        [
+            [
+                [`£${p_AB.toTex()}£`, "£B£"],
+                [`£${p_ABBarre.toTex()}£`, "£\\overline{B}£"],
+            ],
+            [
+                [`£${p_ABarreB.toTex()}£`, "£B£"],
+                [`£${p_ABarreBBarre.toTex()}£`, "£\\overline{B}£"],
+            ],
+        ],
+    ];
+    return `On considère l'arbre de probabilités ci-dessous :
+  
+<svg id="treeDiagram">${JSON.stringify(tree)}</svg>
+
+Les événements $A$ et $B$ sont-ils indépendants ?`;
+};
+const getHint = () => {
+    return `Deux évènements $A$ et $B$ sont indépendants lorsque :
+  
+  
+$$
+P(A\\cap B) = P(A)\\times P(B)
+$$
+
+Une autre façon de vérifier si deux évènements sont indépendants utilise les probabilités conditionnelles : $A$ et $B$ sont indépendants si et seulement si :
+
+$$
+P_A(B) = P(B)
+$$
+
+Choisis une de ces deux méthodes, puis vérifie si l'égalité est vraie.`;
+};
+const getCorrection = (identifiers) => {
+    const { pAIds, p_ABIds, p_ABarreBIds } = identifiers;
+    const pA = reifyAlgebraic(pAIds);
+    const p_AB = reifyAlgebraic(p_ABIds);
+    const p_ABarreB = reifyAlgebraic(p_ABarreBIds);
+    const pB = add(multiply(pA, p_AB), multiply(substract(1, pA), p_ABarreB));
+    const isInde = p_AB.simplify().toTex() === pB.simplify().toTex();
+    return `Deux évènements $A$ et $B$ sont indépendants si et seulement si :
+  
+$$
+P_A(B) = P(B)
+$$
+
+Ici, $P_A(B)$ se lit dans l'arbre : 
+
+$$
+P_A(B) = ${p_AB.simplify().toTex()}
+$$
+
+Il reste donc à calculer $P(B)$, en utilisant la formule des probabilités totales : 
+
+${alignTex([
+        ["P(B)", "=", "P(A\\cap B)+P(\\overline{A}\\cap B)"],
+        ["", "=", pB.toTex()],
+        ["", "=", pB.simplify().toTex()],
+    ])}
+
+Puisque $P_A(B) ${isInde ? "=" : "\\neq"} P(B)$, les évènements $A$ et $B$ ${isInde ? "sont" : "ne sont pas"} indépendants.
+
+
+**Remarque** : en fait, on peut voir directement si $A$ et $B$ sont indépendants ou non, en comparant $P_A(B)$ et $P_{\\overline{A}}(B)$. En effet, ces deux probabilités sont égales si et seulement si $A$ et $B$ sont indépendants. L'idée est que si $A$ et $B$ sont indépendants, le fait que $A$ soit réalisé ou non ne change pas la probabilité de $B$. 
+`;
+};
+const getIndependancyFromProbaTreeQuestion = () => {
+    const getProba = (isFrac = false) => {
+        return isFrac
+            ? RationalConstructor.randomIrreductibleProba().toTree()
+            : randfloat(0.1, 0.91, 1).toTree();
+    };
+    const isInde = coinFlip();
+    const isFrac = coinFlip();
+    const pAIds = getProba(isFrac);
+    const p_ABIds = getProba(isFrac);
+    const p_ABarreBIds = isInde ? p_ABIds : getProba(isFrac);
+    const identifiers = {
+        p_ABarreBIds: p_ABarreBIds.toIdentifiers(),
+        p_ABIds: p_ABIds.toIdentifiers(),
+        pAIds: pAIds.toIdentifiers(),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "raw",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const independancyFromProbaTree = {
+    id: "independancyFromProbaTree",
+    label: "Déterminer si deux évènements sont indépendants à partir d'un arbre",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getIndependancyFromProbaTreeQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

package/lib/exercises/math/probaStat/independancy/index.d.ts

@@ -2,4 +2,6 @@ export * from "./independancy.js";
 export * from "./isIndependantFromDefinition.js";
 export * from "./independancyFindCap.js";
 export * from "./independancyFindCup.js";
+export * from "./independancyFromEffectifTable.js";
+export * from "./independancyFromProbaTree.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/probaStat/independancy/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/independancy/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,kCAAkC,CAAC;AACjD,cAAc,0BAA0B,CAAC;AACzC,cAAc,0BAA0B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/independancy/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,kCAAkC,CAAC;AACjD,cAAc,0BAA0B,CAAC;AACzC,cAAc,0BAA0B,CAAC;AACzC,cAAc,oCAAoC,CAAC;AACnD,cAAc,gCAAgC,CAAC"}

package/lib/exercises/math/probaStat/independancy/index.js

@@ -2,3 +2,5 @@ export * from "./independancy.js";
 export * from "./isIndependantFromDefinition.js";
 export * from "./independancyFindCap.js";
 export * from "./independancyFindCup.js";
+export * from "./independancyFromEffectifTable.js";
+export * from "./independancyFromProbaTree.js";

package/lib/exercises/math/probaStat/trees/index.d.ts

@@ -1,2 +1,5 @@
-export { probabilityTree, } from "./probabilityTree.js";
+export { probabilityTree, probabilityTreeIntersection, probabilityTreeTotalProbability, probabilityTreeReadProbability, probabilityTreeInversionProbability, } from "./probabilityTreeV2.js";
+export * from "./fillProbaTreeWithComplementaryProbabilities.js";
+export * from "./buildTreeFromSituation.js";
+export * from "./probaTreeSituationTotalProbaFormula.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/probaStat/trees/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/trees/index.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,eAAe,GAKhB,MAAM,sBAAsB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/trees/index.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,eAAe,EACf,2BAA2B,EAC3B,+BAA+B,EAC/B,8BAA8B,EAC9B,mCAAmC,GACpC,MAAM,wBAAwB,CAAC;AAChC,cAAc,kDAAkD,CAAC;AACjE,cAAc,6BAA6B,CAAC;AAC5C,cAAc,0CAA0C,CAAC"}

package/lib/exercises/math/probaStat/trees/index.js

@@ -1,10 +1,6 @@
 // export * from "./treeInInstruction.js";
 // export * from "./treeInAnswer.js";
-export { probabilityTree,
-// probabilityTreeIntersection,
-// probabilityTreeTotalProbability,
-// probabilityTreeReadProbability,
-// probabilityTreeInversionProbability,
- } from "./probabilityTree.js";
-// export * from "./fillProbaTreeWithComplementaryProbabilities.js";
-// export * from "./buildTreeFromSituation.js";
+export { probabilityTree, probabilityTreeIntersection, probabilityTreeTotalProbability, probabilityTreeReadProbability, probabilityTreeInversionProbability, } from "./probabilityTreeV2.js";
+export * from "./fillProbaTreeWithComplementaryProbabilities.js";
+export * from "./buildTreeFromSituation.js";
+export * from "./probaTreeSituationTotalProbaFormula.js";

package/lib/exercises/math/probaStat/trees/probaTreeSituationTotalProbaFormula.d.ts

@@ -1,2 +1,8 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { ProbaTreeSituationParams } from "./probaTreeSituations.js";
+type Identifiers = {
+    params: ProbaTreeSituationParams;
+};
+export declare const probaTreeSituationTotalProbaFormula: Exercise<Identifiers>;
 export {};
 //# sourceMappingURL=probaTreeSituationTotalProbaFormula.d.ts.map

package/lib/exercises/math/probaStat/trees/probaTreeSituationTotalProbaFormula.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"probaTreeSituationTotalProbaFormula.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/trees/probaTreeSituationTotalProbaFormula.ts"],"names":[],"mappings":""}
+{"version":3,"file":"probaTreeSituationTotalProbaFormula.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/trees/probaTreeSituationTotalProbaFormula.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAWrC,OAAO,EAGL,wBAAwB,EACzB,MAAM,0BAA0B,CAAC;AAElC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,wBAAwB,CAAC;CAClC,CAAC;AA2HF,eAAO,MAAM,mCAAmC,EAAE,QAAQ,CAAC,WAAW,CAqBrE,CAAC"}

package/lib/exercises/math/probaStat/trees/probaTreeSituationTotalProbaFormula.js

@@ -1,80 +1,125 @@
-// import {
-//   Exercise,
-//   Proposition,
-//   QCMGenerator,
-//   Question,
-//   QuestionGenerator,
-//   VEA,
-//   addValidProp,
-//   shuffleProps,
-//   GetAnswer,
-//   GetHint,
-//   GetCorrection,
-//   GetInstruction,
-//   GetKeys,
-//   GetQuestionFromIdentifiers,
-// } from '../../../../exercises/exercise.js';
-// import { getDistinctQuestions } from '../../../../exercises/utils/getDistinctQuestions.js';
-// import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
-export {};
-// type Identifiers = {
-// };
-// const getPropositions: QCMGenerator<Identifiers> = (n, { answer }) => {
-//   const propositions: Proposition[] = [];
-//   addValidProp(propositions, answer);
-//   propWhile(propositions, n, () => {
-//     throw Error("QCM not implemented")
-//   })
-//   return shuffleProps(propositions, n);
-// };
-// const getAnswer : GetAnswer<Identifiers> = (identifiers)=>{
-// }
-// const getInstruction : GetInstruction<Identifiers> = (identifiers)=>{
-// }
-// const getHint : GetHint<Identifiers> = (identifiers)=>{
-// }
-// const getCorrection : GetCorrection<Identifiers> = (identifiers)=>{
-// }
-// const getKeys : GetKeys<Identifiers> = (identifiers)=>{
-//   return []
-// }
-// const isAnswerValid: VEA<Identifiers> = (ans, {answer})=>{
-//   try {
-//     throw Error("VEA not implemented")
-//   } catch(err){
-//     return handleVEAError(err)
-//   }
-// }
-// const getProbaTreeSituationTotalProbaFormulaQuestion: QuestionGenerator<Identifiers>  = (ops)=>{
-//   const identifiers: Identifiers = {}
-//   return getQuestionFromIdentifiers(identifiers);
-// }
-// const getQuestionFromIdentifiers: GetQuestionFromIdentifiers<Identifiers> = (identifiers)=>{
-//   return {
-//     answer: getAnswer(identifiers),
-//     instruction: getInstruction(identifiers),
-//     keys: getKeys(identifiers),
-//     answerFormat: 'tex',
-//     identifiers,
-//     hint: getHint(identifiers),
-//     correction: getCorrection(identifiers)
-//   }
-// }
-// export const probaTreeSituationTotalProbaFormula: Exercise<Identifiers> = {
-//   id: 'probaTreeSituationTotalProbaFormula',
-//   connector: "",
-//   label: undefined,
-//   isSingleStep: true,
-//   generator: (nb, opts) => getDistinctQuestions(()=>getProbaTreeSituationTotalProbaFormulaQuestion(opts), nb),
-//   qcmTimer: 60,
-//   freeTimer: 60,
-//   getPropositions,
-//   isAnswerValid,
-//   subject: "Mathématiques",
-//   getInstruction,
-//   getHint,
-//   getCorrection,
-//   getAnswer,
-//   getQuestionFromIdentifiers,
-//   hasHintAndCorrection: true
-// };
+import { addValidProp, shuffleProps, propWhile, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { rationalVEA } from "../../../../exercises/vea/rationalVEA.js";
+import { randfloat } from "../../../../math/utils/random/randfloat.js";
+import { round } from "../../../../math/utils/round.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 { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+import { buildProbaTreeSituation, getProbaTreeSituation, } from "./probaTreeSituations.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, round(randfloat(0, 1, 4), 4).frenchify());
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { params } = identifiers;
+    const situation = getProbaTreeSituation(params);
+    const { firstCondProba, mainEventProba, secondCondProba } = situation;
+    const firstCondProbaDec = frac(firstCondProba, 100).evaluate();
+    const mainEventProbaDec = frac(mainEventProba, 100).evaluate();
+    const secondCondProbaDec = frac(secondCondProba, 100).evaluate();
+    const aNb = multiply(mainEventProbaDec, firstCondProbaDec).evaluate();
+    const abarreNb = multiply(substract(1, mainEventProbaDec), secondCondProbaDec).evaluate();
+    const pb = round(add(aNb, abarreNb).evaluate(), 6);
+    return pb.frenchify();
+};
+const getInstruction = (identifiers) => {
+    const { params } = identifiers;
+    const situation = getProbaTreeSituation(params);
+    return (situation.context +
+        `
+  
+Calculer $P(${situation.secondEvent})$.`);
+};
+const getHint = () => {
+    return `Modélise la situation par un arbre pondéré. 
+    
+Puis, utilise la formule des probabilités totales : pour deux évènements $A$ et $B$, on a :
+
+$$
+P(B) = P(A\\cap B)+P(\\overline{A}\\cap B)
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { params } = identifiers;
+    const situation = getProbaTreeSituation(params);
+    const { mainEvent, mainEventProba, firstCondProba, secondCondProba, secondEvent, tree, } = situation;
+    const firstCondProbaDec = frac(firstCondProba, 100).evaluate();
+    const mainEventProbaDec = frac(mainEventProba, 100).evaluate();
+    const secondCondProbaDec = frac(secondCondProba, 100).evaluate();
+    return `On commence par modéliser la situation par un arbre : 
+  
+<svg id="treeDiagram">${JSON.stringify(tree)}</svg>
+
+On utilise ensuite la formule des probabilités totales :
+
+$$
+P(${secondEvent}) = P(${mainEvent}\\cap ${secondEvent})+P(\\overline{${mainEvent}}\\cap ${secondEvent})
+$$
+
+On a donc : 
+
+${alignTex([
+        [
+            `P(${secondEvent})`,
+            "=",
+            add(multiply(mainEventProbaDec, firstCondProbaDec), multiply(substract(1, mainEventProbaDec).simplify(), secondCondProbaDec)).toTex(),
+        ],
+        ["", "=", getAnswer(identifiers)],
+    ])}
+`;
+};
+const getKeys = () => {
+    return ["percent"];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return rationalVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getProbaTreeSituationTotalProbaFormulaQuestion = () => {
+    const params = buildProbaTreeSituation();
+    const identifiers = {
+        params,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const probaTreeSituationTotalProbaFormula = {
+    id: "probaTreeSituationTotalProbaFormula",
+    connector: "=",
+    label: "Utiliser la formule des probabilités totales dans un contexte",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getProbaTreeSituationTotalProbaFormulaQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/sequences/geometric/index.d.ts

@@ -9,10 +9,7 @@ export * from "./geometricFindTerm.js";
 export * from "./geometricFindTermFirstRankOne.js";
 export * from "./geometricRecognizeReasonFromFirstTerms.js";
 export * from "./geometricVariations.js";
-export * from "./geometricFindExplicitFormulaFromTwoTerms.js";
-export * from "./geometricFindExplicitFormulaFromTwoConsecutiveTerms.js";
 export * from "./geometricFindRandomTermFromTwoTerms.js";
-export * from "./geometricFindRandomTermFromTwoConsecutiveTerms.js";
 export * from "./sum/index.js";
 export * from "./situations/index.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/sequences/geometric/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/geometric/index.ts"],"names":[],"mappings":"AAAA,cAAc,oCAAoC,CAAC;AACnD,cAAc,mCAAmC,CAAC;AAClD,cAAc,+CAA+C,CAAC;AAE9D,cAAc,0BAA0B,CAAC;AACzC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,sCAAsC,CAAC;AACrD,cAAc,kDAAkD,CAAC;AACjE,cAAc,wBAAwB,CAAC;AACvC,cAAc,oCAAoC,CAAC;AAEnD,cAAc,6CAA6C,CAAC;AAC5D,cAAc,0BAA0B,CAAC;AAEzC,cAAc,+CAA+C,CAAC;AAC9D,cAAc,0DAA0D,CAAC;AACzE,cAAc,0CAA0C,CAAC;AACzD,cAAc,qDAAqD,CAAC;AAEpE,cAAc,gBAAgB,CAAC;AAE/B,cAAc,uBAAuB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/geometric/index.ts"],"names":[],"mappings":"AAAA,cAAc,oCAAoC,CAAC;AACnD,cAAc,mCAAmC,CAAC;AAClD,cAAc,+CAA+C,CAAC;AAE9D,cAAc,0BAA0B,CAAC;AACzC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,sCAAsC,CAAC;AACrD,cAAc,kDAAkD,CAAC;AACjE,cAAc,wBAAwB,CAAC;AACvC,cAAc,oCAAoC,CAAC;AAEnD,cAAc,6CAA6C,CAAC;AAC5D,cAAc,0BAA0B,CAAC;AAEzC,cAAc,0CAA0C,CAAC;AAEzD,cAAc,gBAAgB,CAAC;AAE/B,cAAc,uBAAuB,CAAC"}

package/lib/exercises/math/sequences/geometric/index.js

@@ -9,9 +9,9 @@ export * from "./geometricFindTerm.js";
 export * from "./geometricFindTermFirstRankOne.js";
 export * from "./geometricRecognizeReasonFromFirstTerms.js";
 export * from "./geometricVariations.js";
-export * from "./geometricFindExplicitFormulaFromTwoTerms.js";
-export * from "./geometricFindExplicitFormulaFromTwoConsecutiveTerms.js";
 export * from "./geometricFindRandomTermFromTwoTerms.js";
-export * from "./geometricFindRandomTermFromTwoConsecutiveTerms.js";
 export * from "./sum/index.js";
 export * from "./situations/index.js";
+// export * from "./geometricFindExplicitFormulaFromTwoTerms.js";
+// export * from "./geometricFindExplicitFormulaFromTwoConsecutiveTerms.js";
+// export * from "./geometricFindRandomTermFromTwoConsecutiveTerms.js";

package/lib/exercises/math/sequences/geometric/situations/index.d.ts

@@ -1,4 +1,3 @@
-export * from "./geometricFindExplicitFormulaFromSituation.js";
 export * from "./geometricFindRecurrenceFormulaFromSituation.js";
 export * from "./geometricFindTermFromSituation.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/sequences/geometric/situations/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/sequences/geometric/situations/index.ts"],"names":[],"mappings":"AAAA,cAAc,gDAAgD,CAAC;AAC/D,cAAc,kDAAkD,CAAC;AACjE,cAAc,qCAAqC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/sequences/geometric/situations/index.ts"],"names":[],"mappings":"AAAA,cAAc,kDAAkD,CAAC;AACjE,cAAc,qCAAqC,CAAC"}

package/lib/exercises/math/sequences/geometric/situations/index.js

@@ -1,5 +1,5 @@
-export * from "./geometricFindExplicitFormulaFromSituation.js";
 export * from "./geometricFindRecurrenceFormulaFromSituation.js";
 export * from "./geometricFindTermFromSituation.js";
 // export * from "./geometricFindRankFromSituation.js";
 // export * from "./geometricFindThresholdFromSituation.js";
+// export * from "./geometricFindExplicitFormulaFromSituation.js";

package/lib/index.d.ts

@@ -1607,13 +1607,6 @@ declare const mathExercises: (Exercise<{
     expBRounded: number;
     precision: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
-    nodeIdsA: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
-    nodeIdsB: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
-    nodeIdsAOpB: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
-    rand: number;
-}, {
-    isUseExpNotation: boolean;
-}> | Exercise<{
     nodeIdsF: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
     nodeIdsT: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
     x: number;
@@ -2987,6 +2980,15 @@ declare const mathExercises: (Exercise<{
 }, Record<string, string | boolean | string[]>> | Exercise<{
     pAIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
     pBIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    aCapB: number;
+    aCapBBarre: number;
+    aBarreCapB: number;
+    aBarreCapBBarre: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    pAIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    p_ABIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    p_ABarreBIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     questionType: string;
     value?: string;
@@ -3246,11 +3248,25 @@ declare const mathExercises: (Exercise<{
     BC: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
     BD: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
     probaName: string;
+    useContraryNames?: boolean;
+}, {
+    allowApproximate?: string;
+    eventTypes?: string[];
+    probaType?: string;
+    eventsNames?: string;
+}> | Exercise<{
+    initTree: string[][][][];
+    valueDatas: {
+        isComp: boolean;
+        value: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    }[];
 }, {
-    allowApproximate: string;
-    eventTypes: string[];
-    probaType: string;
+    probaType?: string;
 }> | Exercise<{
+    params: import("./exercises/math/probaStat/trees/probaTreeSituations.js").ProbaTreeSituationParams;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    params: import("./exercises/math/probaStat/trees/probaTreeSituations.js").ProbaTreeSituationParams;
+}, Record<string, string | boolean | string[]>> | Exercise<{
     firstValue: number;
     askedRank: number;
     reason: number;
@@ -3417,28 +3433,6 @@ declare const mathExercises: (Exercise<{
     value2: number;
     precisionInitial: number;
     precisionReason: number;
-}, import("./exercises/options/optionFirstTermRankOne.js").OptionFirstTermRankOne> | Exercise<{
-    rank1: number;
-    value1: number;
-    rank2: number;
-    value2: number;
-    precisionInitial: number;
-    precisionReason: number;
-}, import("./exercises/options/optionFirstTermRankOne.js").OptionFirstTermRankOne> | Exercise<{
-    rank1: number;
-    value1: number;
-    rank2: number;
-    value2: number;
-    precisionInitial: number;
-    precisionReason: number;
-    rankAsked: number;
-}, import("./exercises/options/optionFirstTermRankOne.js").OptionFirstTermRankOne> | Exercise<{
-    rank1: number;
-    value1: number;
-    rank2: number;
-    value2: number;
-    precisionInitial: number;
-    precisionReason: number;
     rankAsked: number;
 }, import("./exercises/options/optionFirstTermRankOne.js").OptionFirstTermRankOne> | Exercise<{
     raison: number;
@@ -3464,11 +3458,6 @@ declare const mathExercises: (Exercise<{
     initial: number;
     reason: number;
     superfluousData?: import("./math/utils/sequences/situations/seqGeometricSituations.js").SituationGeometricSuperfluousData;
-}, import("./exercises/options/optionFirstTermRankOne.js").OptionFirstTermRankOne & import("./exercises/options/optionIsWithSuperfluousData.js").OptionIsWithSuperfluousData> | Exercise<{
-    situationIndex: number;
-    initial: number;
-    reason: number;
-    superfluousData?: import("./math/utils/sequences/situations/seqGeometricSituations.js").SituationGeometricSuperfluousData;
 }, import("./exercises/options/optionFirstTermRankOne.js").OptionFirstTermRankOne & import("./exercises/options/optionIsWithSuperfluousData.js").OptionIsWithSuperfluousData> | Exercise<{
     situationIndex: number;
     initial: number;

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,KAAK,aAAa,MAAM,2BAA2B,CAAC;AAE3D,OAAO,4BAA4B,CAAC;AACpC,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,QAAQ,EAAE,QAAQ,EAAE,cAAc,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,KAAK,aAAa,MAAM,2BAA2B,CAAC;AAE3D,OAAO,4BAA4B,CAAC;AACpC,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,QAAQ,EAAE,QAAQ,EAAE,cAAc,EAAE,CAAC"}

package/lib/tree/parsers/rationalParser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rationalParser.d.ts","sourceRoot":"","sources":["../../../src/tree/parsers/rationalParser.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,cAAc,GAAI,KAAK,MAAM,qSA0CzC,CAAC"}
+{"version":3,"file":"rationalParser.d.ts","sourceRoot":"","sources":["../../../src/tree/parsers/rationalParser.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,cAAc,GAAI,KAAK,MAAM,qSAiDzC,CAAC"}

package/lib/tree/parsers/rationalParser.js

@@ -1,13 +1,19 @@
+import { round } from "../../math/utils/round.js";
 import { isOppositeNode } from "../nodes/functions/oppositeNode.js";
 import { isNumberOrOppositeNumberNode } from "../nodes/numbers/numberNode.js";
-import { isFractionNode } from "../nodes/operators/fractionNode.js";
+import { frac, isFractionNode } from "../nodes/operators/fractionNode.js";
 import { parseAlgebraic } from "./latexParser.js";
 import { numberParser } from "./numberParser.js";
+import { percentParser } from "./percentParser.js";
 export const rationalParser = (ans) => {
     const nb = numberParser(ans);
     if (nb !== false) {
         return nb.unfrenchify().toTree();
     }
+    const percent = percentParser(ans, false);
+    if (percent !== false) {
+        return round(frac(percent.replace("\\%", "").unfrenchify(), 100).evaluate(), 8).toTree();
+    }
     const parsed = parseAlgebraic(ans);
     if (!parsed)
         return false;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "math-exercises",
   "type": "module",
-  "version": "3.0.181",
+  "version": "3.0.182",
   "description": "Math exercises generator for middle school and high school",
   "main": "lib/index.js",
   "files": [