math-exercises 3.0.172 → 3.0.174

package/lib/exercises/math/geometry/lines/readLineNormalVectorOnGraph.js

@@ -0,0 +1,195 @@
+import { addValidProp, shuffleProps, GeneratorOptionType, GeneratorOptionTarget, propWhile, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { colinearVectorVEA } from "../../../../exercises/vea/colinearVectorVEA.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { Line } from "../../../../math/geometry/line.js";
+import { PointConstructor, } from "../../../../math/geometry/point.js";
+import { Vector, VectorConstructor } from "../../../../math/geometry/vector.js";
+import { RationalConstructor } from "../../../../math/numbers/rationals/rational.js";
+import { opposite } from "../../../../tree/nodes/functions/oppositeNode.js";
+import { vectorParser } from "../../../../tree/parsers/vectorParser.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        const vec = VectorConstructor.random("v");
+        const sol = vectorParser(answer);
+        if (!sol)
+            throw new Error("answer malformed in readLineNormalVectorOnGraph");
+        if (vec.isColinear(sol))
+            return;
+        tryToAddWrongProp(propositions, vec.toBinomCoords().toTex());
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { point1Ids, point2Ids, point3Ids } = identifiers;
+    const point1 = PointConstructor.fromIdentifiers(point1Ids);
+    const point2 = PointConstructor.fromIdentifiers(point2Ids);
+    if (point3Ids) {
+        //perp tracée
+        const point3 = PointConstructor.fromIdentifiers(point3Ids);
+        const vector = VectorConstructor.fromPoints(point2, point3);
+        return vector.simplify().toBinomCoords().toTex();
+    }
+    else {
+        const vector = VectorConstructor.fromPoints(point1, point2);
+        const normal = vector.getOrthogonal();
+        return normal.toBinomCoords().toTex();
+    }
+};
+const getInstruction = (_identifiers, opts) => {
+    if (opts?.withoutPerp) {
+        return `Ci-dessous est tracée une droite $d$.
+        
+Déterminer graphiquement les coordonnées d'un vecteur normal à $d$.`;
+    }
+    return `Ci-dessous sont tracées deux droites perpendiculaires $d$ et $d'$.
+    
+Déterminer graphiquement les coordonnées d'un vecteur normal à $d$.`;
+};
+const getHint = (_identifiers, opts) => {
+    if (opts?.withoutPerp) {
+        const u = new Vector("u", "a".toTree(), "b".toTree());
+        const v = new Vector("v", opposite("b"), "a".toTree());
+        return `Détermine un vecteur directeur de $d$. Puis, utilise la propriété suivante : si $${u.toTexWithBinomCoords()}$ est un vecteur directeur de $d$, alors $${v.toTexWithBinomCoords()}$ est un vecteur normal à $d$.`;
+    }
+    return `Un vecteur normal d'une droite est un vecteur qui est orthogonal à un vecteur directeur de cette droite. 
+  
+Ici, un vecteur normal à $d$ est donc également un vecteur directeur de $d'$.`;
+};
+const getCorrection = (identifiers) => {
+    const { point1Ids, point2Ids, point3Ids } = identifiers;
+    const point1 = PointConstructor.fromIdentifiers(point1Ids);
+    const point2 = PointConstructor.fromIdentifiers(point2Ids);
+    if (point3Ids) {
+        const point3 = PointConstructor.fromIdentifiers(point3Ids);
+        return `Un vecteur normal à la droite $d$ est un vecteur directeur de la droite $d'$.
+    
+On lit donc graphiquement un vecteur directeur de $d'$.
+
+Cette droite passe par les points de coordonnées $${point2.toCoords()}$ et $${point3.toCoords()}$. Un vecteur directeur de $d'$ est donc : 
+
+$$
+${VectorConstructor.fromPoints(point2, point3).toBinomCoords().toTex()}
+$$
+
+C'est un vecteur normal à $d$.`;
+    }
+    const u = new Vector("u", "a".toTree(), "b".toTree());
+    const v = new Vector("v", opposite("b"), "a".toTree());
+    return `La droite $d$ passe par les points de coordonnées $${point1.toCoords()}$ et $${point2.toCoords()}$. Un vecteur directeur de $d$ est donc :
+  
+$$
+${VectorConstructor.fromPoints(point1, point2).toBinomCoords().toTex()}
+$$
+
+On sait que si $${u.toTexWithBinomCoords()}$ est un vecteur directeur de $d$, alors $${v.toTexWithBinomCoords()}$ est un vecteur normal à $d$.
+
+Ici, les coordonnées d'un vecteur normal à $d$ sont donc : 
+
+$$
+${getAnswer(identifiers)}
+$$`;
+};
+const getGGBOptions = (identifiers) => {
+    const { point1Ids, point2Ids, point3Ids } = identifiers;
+    const point1 = PointConstructor.fromIdentifiers(point1Ids);
+    const point2 = PointConstructor.fromIdentifiers(point2Ids);
+    const line = new Line(point1, point2, "d");
+    const ggb = new GeogebraConstructor({
+        commands: line.toGGBCommands(true, {
+            isFixed: true,
+            isSelectionnable: false,
+            showLabel: true,
+            showUnderlyingPoints: false,
+        }),
+    });
+    if (point3Ids) {
+        const point3 = PointConstructor.fromIdentifiers(point3Ids);
+        ggb.commands?.push(`d' = PerpendicularLine(${point2.name}, d)`);
+        ggb.commands?.push(`alpha = Angle(d,d')`);
+        ggb.commands?.push(`ShowLabel(d', true)`);
+        ggb.commands?.push(`ShowLabel(alpha, false)`);
+        return ggb.getOptions({
+            coords: ggb.getCoordsForPoints([point1, point2, point3]),
+        });
+    }
+    else {
+        return ggb.getOptions({
+            coords: ggb.getCoordsForPoints([point1, point2]),
+        });
+    }
+};
+const getKeys = () => {
+    return ["binom", "semicolon"];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return colinearVectorVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getReadLineNormalVectorOnGraphQuestion = (opts) => {
+    const point1 = PointConstructor.random("A");
+    const ratio = RationalConstructor.randomIrreductibleWithSign(6);
+    const translation = new Vector("u", ratio.num.toTree(), ratio.denum.toTree());
+    const point2 = translation.getEndPoint(point1);
+    let point3;
+    if (!opts?.withoutPerp) {
+        const vector = VectorConstructor.fromPoints(point1, point2);
+        const normal = vector.getOrthogonal();
+        point3 = normal.getEndPoint(point2);
+    }
+    const identifiers = {
+        point1Ids: point1.toIdentifiers(),
+        point2Ids: point2.toIdentifiers(),
+        point3Ids: point3?.toIdentifiers(),
+    };
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    return {
+        answer: getAnswer(identifiers, opts),
+        instruction: getInstruction(identifiers, opts),
+        keys: getKeys(identifiers, opts),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+        ggbOptions: getGGBOptions(identifiers, opts),
+    };
+};
+const options = [
+    {
+        id: "withoutPerp",
+        label: "Ne pas tracer de droite perpendiculaire",
+        type: GeneratorOptionType.checkbox,
+        target: GeneratorOptionTarget.generation,
+        defaultValue: false,
+        tooltipText: "S'il n'y a pas de droite perpendiculaire tracée, l'élève devra utiliser le vecteur directeur de la droite puis la propriété qui donne un vecteur normal à partir d'un vecteur directeur.",
+    },
+];
+export const readLineNormalVectorOnGraph = {
+    id: "readLineNormalVectorOnGraph",
+    label: "Déterminer graphiquement les coordonnées d'un vecteur normal à une droite",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getReadLineNormalVectorOnGraphQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getHint,
+    getCorrection,
+    getInstruction,
+    getAnswer,
+    getGGBOptions,
+    hasGeogebra: true,
+    getQuestionFromIdentifiers,
+    options,
+    hasHintAndCorrection: true,
+};

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

@@ -11,4 +11,5 @@ export * from "./randomVariableSituationVariance.js";
 export * from "./randomVariableSituationStandardDeviation.js";
 export * from "./randomVariableSituationIsGameFavorable.js";
 export * from "./randomVariableSituationProbabilityLaw.js";
+export * from "./missingValueInRandomVariableProbabilityLaw.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/randomVariable/index.ts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAC;AAC3C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,sCAAsC,CAAC;AAErD,cAAc,4CAA4C,CAAC;AAC3D,cAAc,mCAAmC,CAAC;AAClD,cAAc,oCAAoC,CAAC;AACnD,cAAc,gDAAgD,CAAC;AAC/D,cAAc,qCAAqC,CAAC;AACpD,cAAc,sCAAsC,CAAC;AACrD,cAAc,+CAA+C,CAAC;AAC9D,cAAc,6CAA6C,CAAC;AAC5D,cAAc,4CAA4C,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/randomVariable/index.ts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAC;AAC3C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,sCAAsC,CAAC;AAErD,cAAc,4CAA4C,CAAC;AAC3D,cAAc,mCAAmC,CAAC;AAClD,cAAc,oCAAoC,CAAC;AACnD,cAAc,gDAAgD,CAAC;AAC/D,cAAc,qCAAqC,CAAC;AACpD,cAAc,sCAAsC,CAAC;AACrD,cAAc,+CAA+C,CAAC;AAC9D,cAAc,6CAA6C,CAAC;AAC5D,cAAc,4CAA4C,CAAC;AAE3D,cAAc,iDAAiD,CAAC"}

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

@@ -13,3 +13,4 @@ export * from "./randomVariableSituationStandardDeviation.js";
 export * from "./randomVariableSituationIsGameFavorable.js";
 export * from "./randomVariableSituationProbabilityLaw.js";
 // export * from "./decideWhichGameIsLessRisky.js";
+export * from "./missingValueInRandomVariableProbabilityLaw.js";

package/lib/exercises/math/probaStat/randomVariable/missingValueInRandomVariableProbabilityLaw.d.ts

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

package/lib/exercises/math/probaStat/randomVariable/missingValueInRandomVariableProbabilityLaw.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"missingValueInRandomVariableProbabilityLaw.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/randomVariable/missingValueInRandomVariableProbabilityLaw.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAe7C,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,eAAe,EAAE,CAAC;IAC3B,OAAO,EAAE,eAAe,EAAE,CAAC;CAC5B,CAAC;AAgHF,eAAO,MAAM,0CAA0C,EAAE,QAAQ,CAAC,WAAW,CAsB1E,CAAC"}

package/lib/exercises/math/probaStat/randomVariable/missingValueInRandomVariableProbabilityLaw.js

@@ -0,0 +1,119 @@
+import { addValidProp, tryToAddWrongProp, shuffleProps, propWhile, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { randfloat } from "../../../../math/utils/random/randfloat.js";
+import { round } from "../../../../math/utils/round.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.js";
+import { RandomVariable, RandomVariableConstructor, } from "../../../../math/probability/randomVariable.js";
+import { isVariableNode, VariableNode, } from "../../../../tree/nodes/variables/variableNode.js";
+import { operatorComposition } from "../../../../tree/utilities/operatorComposition.js";
+import { AddNode } from "../../../../tree/nodes/operators/addNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+const getPropositions = (n, { answer }) => {
+    const props = [];
+    addValidProp(props, answer);
+    propWhile(props, n, () => {
+        const numeric = answer.unfrenchify();
+        const offset = randfloat(-0.2, 0.2, 2);
+        const candidate = round(numeric + offset, 2).frenchify();
+        tryToAddWrongProp(props, candidate);
+    });
+    return shuffleProps(props, n);
+};
+const getAnswer = ({ pValues }) => {
+    const probas = pValues
+        .map((e) => reifyAlgebraic(e))
+        .filter((p) => !isVariableNode(p));
+    const sum = operatorComposition(AddNode, probas).simplify();
+    return substract(1, sum).simplify().toTex();
+};
+const getInstruction = ({ pValues, xValues }) => {
+    const va = new RandomVariable(xValues.map((e) => reifyAlgebraic(e)), pValues.map((e) => reifyAlgebraic(e)));
+    return `On considère une variable aléatoire $X$ dont la loi de probabilité est la suivante : 
+  
+${va.getLawMdTable()}
+
+Que vaut $x$ ?`;
+};
+const getHint = () => {
+    return `Dans une loi de probabilité, la somme des probabilités est égale à $1$.`;
+};
+const getCorrection = (identifiers) => {
+    const { pValues, xValues } = identifiers;
+    const probas = pValues.map((e) => reifyAlgebraic(e));
+    const index = probas.findIndex((p) => isVariableNode(p));
+    const xs = xValues.map((e) => reifyAlgebraic(e));
+    const sum = operatorComposition(AddNode, probas.filter((_p, i) => i !== index));
+    return `
+On additionne les probabilités connues :
+
+$$
+${sum.toTex()} = ${sum.simplify().toTex()}
+$$
+
+Puisque la somme des probabilités d'une loi de probabilité vaut $1$, on peut en déduire la probabilité manquante : 
+
+
+$$
+P(X = ${xs[index].toTex()}) = 1 - ${sum.simplify().toTex()} = ${getAnswer(identifiers)}.
+$$
+`;
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const a = parseAlgebraic(ans);
+        const b = parseAlgebraic(answer);
+        return a.simplify().equals(b.simplify());
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getGetMissingProbabilityValueQuestion = () => {
+    const va = RandomVariableConstructor.random();
+    const pValues = [...va.yValues];
+    pValues[randint(0, pValues.length)] = new VariableNode("x");
+    const identifiers = {
+        pValues: pValues.map((e) => e.toIdentifiers()),
+        xValues: va.xValues.map((e) => e.toIdentifiers()),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => ({
+    answer: getAnswer(identifiers),
+    instruction: getInstruction(identifiers),
+    keys: getKeys(identifiers),
+    answerFormat: "tex",
+    identifiers,
+    hint: getHint(identifiers),
+    correction: getCorrection(identifiers),
+    style: {
+        tableOptions: {
+            firstColumnIsHeader: true,
+            firstCellIsDivided: false,
+            firstRowIsHeader: false,
+        },
+    },
+});
+export const missingValueInRandomVariableProbabilityLaw = {
+    id: "missingValueInRandomVariableProbabilityLaw",
+    label: "Déterminer une valeur manquante dans la loi de probabilité d'une variable aléatoire",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getGetMissingProbabilityValueQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=buildTreeFromSituation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"buildTreeFromSituation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/trees/buildTreeFromSituation.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1,68 @@
+// import {
+//   Exercise,
+//   QuestionGenerator,
+//   GetHint,
+//   GetCorrection,
+//   GetInstruction,
+//   GetKeys,
+//   GetQuestionFromIdentifiers,
+//   GetAnswerTreeTable,
+//   TreeDiagramVEA,
+// } from '../../../../exercises/exercise.js';
+// import { getDistinctQuestions } from '../../../../exercises/utils/getDistinctQuestions.js';
+// import { treeTableVEA } from '../../../../exercises/vea/treeTableVEA.js';
+// import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+export {};
+// type Identifiers = {
+//   situationId: string
+// };
+// const getAnswerTreeTable : GetAnswerTreeTable<Identifiers> = (identifiers)=>{
+// }
+// const getInstruction : GetInstruction<Identifiers> = (identifiers)=>{
+//   const {} = identifiers
+// }
+// const getHint : GetHint<Identifiers> = (identifiers)=>{
+// }
+// const getCorrection : GetCorrection<Identifiers> = (identifiers)=>{
+// }
+// const getKeys : GetKeys<Identifiers> = (identifiers)=>{
+//   return []
+// }
+// const isAnswerTreeTableValid: TreeDiagramVEA<Identifiers> = (ans, {answerTreeTable})=>{
+//   try {
+//     return treeTableVEA(ans, answerTreeTable)
+//   } catch(err){
+//     return handleVEAError(err)
+//   }
+// }
+// const getBuildTreeFromSituationQuestion: QuestionGenerator<Identifiers>  = (ops)=>{
+//   const identifiers: Identifiers = {}
+//   return getQuestionFromIdentifiers(identifiers);
+// }
+// const getQuestionFromIdentifiers: GetQuestionFromIdentifiers<Identifiers> = (identifiers)=>{
+//   return {
+//     answerTreeTable: getAnswerTreeTable(identifiers),
+//     instruction: getInstruction(identifiers),
+//     keys: getKeys(identifiers),
+//     answerFormat: 'tex',
+//     identifiers,
+//     hint: getHint(identifiers),
+//     correction: getCorrection(identifiers)
+//   }
+// }
+// export const buildTreeFromSituation: Exercise<Identifiers> = {
+//   id: 'buildTreeFromSituation',
+//   label: "undefined",
+//   isSingleStep: true,
+//   generator: (nb, opts) => getDistinctQuestions(()=>getBuildTreeFromSituationQuestion(opts), nb),
+//   qcmTimer: 60,
+//   freeTimer: 60,
+//   isAnswerTreeTableValid,
+//   subject: "Mathématiques",
+//   getInstruction,
+//   getHint,
+//   getCorrection,
+//   getAnswerTreeTable,
+//   getQuestionFromIdentifiers,
+//   hasHintAndCorrection: true
+// };

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

@@ -0,0 +1,15 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    initTree: string[][][][];
+    valueDatas: {
+        isComp: boolean;
+        value: NodeIdentifiers;
+    }[];
+};
+type Options = {
+    probaType?: string;
+};
+export declare const fillProbaTreeWithComplementaryProbabilities: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=fillProbaTreeWithComplementaryProbabilities.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fillProbaTreeWithComplementaryProbabilities.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/trees/fillProbaTreeWithComplementaryProbabilities.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAKrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAM7C,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,MAAM,EAAE,EAAE,EAAE,EAAE,CAAC;IACzB,UAAU,EAAE;QACV,MAAM,EAAE,OAAO,CAAC;QAChB,KAAK,EAAE,eAAe,CAAC;KACxB,EAAE,CAAC;CACL,CAAC;AA6KF,KAAK,OAAO,GAAG;IACb,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AA4BF,eAAO,MAAM,2CAA2C,EAAE,QAAQ,CAChE,WAAW,EACX,OAAO,CAuBR,CAAC"}

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

@@ -0,0 +1,206 @@
+import { GeneratorOptionTarget, GeneratorOptionType, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { treeTableVEA } from "../../../../exercises/vea/treeTableVEA.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 { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { random } from "../../../../utils/alea/random.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getAnswerTreeTable = (identifiers) => {
+    const { valueDatas } = identifiers;
+    const reified = valueDatas.map((d) => reifyAlgebraic(d.value));
+    const missingData = reified.map((d) => substract(1, d).simplify());
+    const datas = [
+        [
+            (valueDatas[0].isComp ? missingData : reified)[0].toTex(),
+            (valueDatas[0].isComp ? reified : missingData)[0].toTex(),
+        ],
+        [
+            (valueDatas[1].isComp ? missingData : reified)[1].toTex(),
+            (valueDatas[1].isComp ? reified : missingData)[1].toTex(),
+        ],
+        [
+            (valueDatas[2].isComp ? missingData : reified)[2].toTex(),
+            (valueDatas[2].isComp ? reified : missingData)[2].toTex(),
+        ],
+    ];
+    return [
+        [
+            [
+                [`$${datas[0][0]}$`, "$A$"],
+                [`$${datas[0][1]}$`, "$\\overline{A}$"],
+            ],
+        ],
+        [
+            [
+                [`$${datas[1][0]}$`, "$B$"],
+                [`$${datas[1][1]}$`, "$\\overline{B}$"],
+            ],
+            [
+                [`$${datas[2][0]}$`, "$B$"],
+                [`$${datas[2][1]}$`, "$\\overline{B}$"],
+            ],
+        ],
+    ];
+};
+const getInstruction = () => {
+    return `Compléter les probabilités manquantes dans l'arbre pondéré suivant : 
+  
+  `;
+};
+const getHint = () => {
+    return `Dans un arbre pondéré, la somme des probabilités des branches issues d'un même noeud est égale à $1$.`;
+};
+const getCorrection = (identifiers) => {
+    const { valueDatas } = identifiers;
+    const events = valueDatas.map((d, i) => {
+        if (i === 0)
+            return d.isComp ? "P(A)" : "P\\left(\\overline{A}\\right)";
+        if (i === 1)
+            return d.isComp ? "P_A(B)" : "P_A\\left(\\overline{B}\\right)";
+        else
+            return d.isComp
+                ? "P_{\\overline{A}}(B)"
+                : "P_{\\overline{A}}\\left(\\overline{B}\\right)";
+    });
+    const probas = valueDatas.map((d) => reifyAlgebraic(d.value));
+    return `Dans un arbre pondéré, la somme des probabilités des branches issues d'un même noeud est égale à $1$.
+  
+On a donc : 
+
+$$
+${events[0]} = 1 - ${probas[0].toTex()} = ${substract(1, probas[0])
+        .simplify()
+        .toTex()}
+$$
+
+$$
+${events[1]} = 1 - ${probas[1].toTex()} = ${substract(1, probas[1])
+        .simplify()
+        .toTex()}
+$$
+
+$$
+${events[2]} = 1 - ${probas[2].toTex()} = ${substract(1, probas[2])
+        .simplify()
+        .toTex()}
+$$
+`;
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerTreeTableValid = (ans, { answerTreeTable }) => {
+    try {
+        return treeTableVEA(ans, answerTreeTable);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getFillProbaTreeWithComplementaryProbabilitiesQuestion = (ops) => {
+    const type = ops?.probaType === "Fractions"
+        ? "frac"
+        : ops?.probaType === "Décimales"
+            ? "dec"
+            : random(["frac", "dec"]);
+    const valueDatas = [
+        {
+            isComp: coinFlip(),
+            value: type === "frac"
+                ? RationalConstructor.randomIrreductibleProba().toTree()
+                : randfloat(0.1, 1, 1).toTree(),
+        },
+        {
+            isComp: coinFlip(),
+            value: type === "frac"
+                ? RationalConstructor.randomIrreductibleProba().toTree()
+                : randfloat(0.1, 1, 1).toTree(),
+        },
+        {
+            isComp: coinFlip(),
+            value: type === "frac"
+                ? RationalConstructor.randomIrreductibleProba().toTree()
+                : randfloat(0.1, 1, 1).toTree(),
+        },
+    ];
+    const initTree = [
+        [
+            [
+                [!valueDatas[0].isComp ? valueDatas[0].value.toTex() : "", "$A$"],
+                [
+                    valueDatas[0].isComp ? valueDatas[0].value.toTex() : "",
+                    "$\\overline{A}$",
+                ],
+            ],
+        ],
+        [
+            [
+                [!valueDatas[1].isComp ? valueDatas[1].value.toTex() : "", "$B$"],
+                [
+                    valueDatas[1].isComp ? valueDatas[1].value.toTex() : "",
+                    "$\\overline{B}$",
+                ],
+            ],
+            [
+                [!valueDatas[2].isComp ? valueDatas[2].value.toTex() : "", "$B$"],
+                [
+                    valueDatas[2].isComp ? valueDatas[2].value.toTex() : "",
+                    "$\\overline{B}$",
+                ],
+            ],
+        ],
+    ];
+    const identifiers = {
+        initTree,
+        valueDatas: valueDatas.map((d) => {
+            return {
+                isComp: d.isComp,
+                value: d.value.toIdentifiers(),
+            };
+        }),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const options = [
+    {
+        id: "probaType",
+        label: "Format des probabilités",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.select,
+        defaultValue: "Aléatoire",
+        values: ["Fractions", "Décimales", "Aléatoire"],
+    },
+];
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answerTreeTable: getAnswerTreeTable(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        initTreeTable: identifiers.initTree,
+    };
+};
+export const fillProbaTreeWithComplementaryProbabilities = {
+    id: "fillProbaTreeWithComplementaryProbabilities",
+    label: "Compléter un arbre pondéré par les probabilités des événements contraires",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getFillProbaTreeWithComplementaryProbabilitiesQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    isAnswerTreeTableValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswerTreeTable,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "treeDiagram",
+    options,
+};

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=probaTreeSituations.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"probaTreeSituations.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/trees/probaTreeSituations.ts"],"names":[],"mappings":""}