math-exercises 2.2.55 → 2.2.57

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

@@ -0,0 +1,214 @@
+"use strict";
+// import {
+//   Exercise,
+//   Proposition,
+//   QCMGenerator,
+//   Question,
+//   QuestionGenerator,
+//   VEA,
+//   addValidProp,
+//   tryToAddWrongProp,
+// } from "../../../../exercises/exercise";
+// import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions";
+// import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor";
+// import { Rational } from "../../../../math/numbers/rationals/rational";
+// import { randint } from "../../../../math/utils/random/randint";
+// import { Node } from "../../../../tree/nodes/node";
+// import { coinFlip } from "../../../../utils/alea/coinFlip";
+// import { shuffle } from "../../../../utils/alea/shuffle";
+// type Identifiers = {
+//   sideLengths: number[];
+//   rand: number;
+//   rand2: number;
+//   isAskingC: boolean;
+//   xA: number;
+//   yA: number;
+//   xB: number;
+//   yB: number;
+//   xC: number;
+//   yC: number;
+//   factor: number;
+// };
+// const getThales: QuestionGenerator<Identifiers> = () => {
+//   const vertices = [];
+//   const code = 65 + randint(0, 22); // Générer un code de caractère majuscule aléatoire (A-Z)
+//   for (let i = 0; i < 5; i++) vertices.push(String.fromCharCode(code + i));
+//   const [xA, yA] = [randint(-10, 11), randint(-10, 11)];
+//   let xB, yB, xC, yC;
+//   let d1, d2, d3; // distance entre le point A et B
+//   let theta = 0; // angle entre AB et AC
+//   do {
+//     [xB, yB, xC, yC] = [
+//       randint(-10, 11),
+//       randint(-10, 11),
+//       randint(-10, 11),
+//       randint(-10, 11),
+//     ];
+//     d1 = Math.hypot(xB - xA, yB - yA); // Calculer la distance entre A et B
+//     d2 = Math.hypot(xC - xA, yC - yA); // Calculer la distance entre A et C
+//     theta = Math.acos(
+//       ((xB - xA) * (xC - xA) + (yB - yA) * (yC - yA)) / (d1 * d2),
+//     );
+//   } while (
+//     !theta ||
+//     theta < 0.35 ||
+//     theta > 2.1 ||
+//     d1 / d2 > 1.3 ||
+//     d1 / d2 < 0.7
+//   );
+//   d3 = Math.sqrt(d1 ** 2 + d2 ** 2 - 2 * d1 * d2 * Math.cos(theta)); // Calculer la distance entre C et B
+//   // CB² = AB² * AC² - 2*AB*AC*cos(theta)  : pythagore généralisé
+//   const factor = randint(-5, 6, [-2, -1, 0, 1, 2]) / 10; // facteur = AB/AE, Pour que l'affichage soit acceptable, les valeurs de factor sont +- 0.5 0.4 0.3
+//   const [xD, yD] = [xA + factor * (xB - xA), yA + factor * (yB - yA)];
+//   const [xE, yE] = [xA + factor * (xC - xA), yA + factor * (yC - yA)];
+//   const xMin = Math.min(xA, xB, xC, xD, xE);
+//   const xMax = Math.max(xA, xB, xC, xD, xE);
+//   const yMin = Math.min(yA, yB, yC, yD, yE);
+//   const yMax = Math.max(yA, yB, yC, yD, yE);
+//   // AB AC BC AD AE
+//   const sides = [
+//     `${vertices[0]}${vertices[1]}`,
+//     `${vertices[0]}${vertices[3]}`,
+//     `${vertices[0]}${vertices[2]}`,
+//     `${vertices[0]}${vertices[4]}`,
+//     `${vertices[1]}${vertices[2]}`,
+//     `${vertices[3]}${vertices[4]}`,
+//   ];
+//   // round pour avoir des valeurs dans N tout en gardant les proportions pour que ça soit cohérent. sides[i] a pour longueur sideLengths[i]
+//   const sideLengths = [d1, factor * d1, d2, factor * d2, d3, factor * d3].map(
+//     (el) => Math.round(Math.abs(el)),
+//   );
+//   const rand = randint(0, 3);
+//   let rand2 = randint(0, 3, [rand]);
+//   if (sideLengths[2 * rand] === sideLengths[2 * rand2])
+//     rand2 = randint(0, 3, [rand, rand2]); // condition pour pas prendre 2 longueurs identiques
+//   let instruction = `Dans la figure ci-dessous, on a $(${vertices[3]}${vertices[4]})//(${vertices[1]}${vertices[2]})$, `;
+//   let statement: Node;
+//   let startStatement;
+//   const isAskingC = coinFlip();
+//   if (isAskingC) {
+//     // a/b = c/d on cherche c
+//     instruction += `$${sides[2 * rand]} = ${sideLengths[2 * rand]}$, $${
+//       sides[2 * rand + 1]
+//     } = ${sideLengths[2 * rand + 1]}$, $${sides[2 * rand2]} = ${
+//       sideLengths[2 * rand2]
+//     }$. Déterminer $${sides[2 * rand2 + 1]}$.`;
+//     startStatement = `${sides[2 * rand2 + 1]}`;
+//     statement = new Rational(
+//       sideLengths[2 * rand2] * sideLengths[2 * rand + 1],
+//       sideLengths[2 * rand],
+//     )
+//       .simplify()
+//       .toTree();
+//   } else {
+//     // a/b = c/d on cherche d
+//     instruction += `$${sides[2 * rand]} = ${sideLengths[2 * rand]}$, $${
+//       sides[2 * rand + 1]
+//     } = ${sideLengths[2 * rand + 1]}$, $${sides[2 * rand2 + 1]} = ${
+//       sideLengths[2 * rand2 + 1]
+//     }$. Déterminer $${sides[2 * rand2]}$.`;
+//     startStatement = `${sides[2 * rand2]}`;
+//     statement = new Rational(
+//       sideLengths[2 * rand2 + 1] * sideLengths[2 * rand],
+//       sideLengths[2 * rand + 1],
+//     )
+//       .simplify()
+//       .toTree();
+//   }
+//   const commands = [
+//     `${vertices[0]} = Point({${xA}, ${yA}})`,
+//     `${vertices[1]} = Point({${xB}, ${yB}})`,
+//     `${vertices[2]} = Point({${xC}, ${yC}})`,
+//     `${vertices[3]} = Point(${vertices[0]}, Vector(${factor}Vector(${vertices[0]},${vertices[1]})))`,
+//     `${vertices[4]} = Intersect(Line(${vertices[3]}, Line(${vertices[1]}, ${vertices[2]})) , Line(${vertices[0]}, ${vertices[2]}))`,
+//     `l = Segment(${vertices[0]}, ${vertices[1]})`,
+//     `i = Segment(${vertices[0]}, ${vertices[2]})`,
+//     `j = Segment(${vertices[1]}, ${vertices[2]})`,
+//     `k = Segment(${vertices[3]}, ${vertices[4]})`,
+//     `If(${factor} < 0, Segment(${vertices[0]}, ${vertices[3]}))`,
+//     `If(${factor} < 0, Segment(${vertices[0]}, ${vertices[4]}))`,
+//     `ShowLabel(${vertices[0]}, true)`,
+//     `ShowLabel(${vertices[1]}, true)`,
+//     `ShowLabel(${vertices[2]}, true)`,
+//     `ShowLabel(${vertices[3]}, true)`,
+//     `ShowLabel(${vertices[4]}, true)`,
+//   ];
+//   const ggb = new GeogebraConstructor({
+//     commands,
+//     hideAxes: true,
+//     hideGrid: true,
+//   });
+//   const answer = statement.toTex();
+//   const question: Question<Identifiers> = {
+//     instruction,
+//     startStatement,
+//     answer,
+//     keys: [],
+//     ggbOptions: ggb.getOptions({
+//       coords: [xMin - 1, xMax + 1, yMin - 1, yMax + 1],
+//     }),
+//     answerFormat: "tex",
+//     identifiers: {
+//       isAskingC,
+//       rand,
+//       rand2,
+//       sideLengths,
+//       xA,
+//       yA,
+//       xB,
+//       yB,
+//       xC,
+//       yC,
+//       factor,
+//     },
+//   };
+//   return question;
+// };
+// const getPropositions: QCMGenerator<Identifiers> = (n, { answer }) => {
+//   const propositions: Proposition[] = [];
+//   addValidProp(propositions, answer);
+//   while (propositions.length < n) {
+//     tryToAddWrongProp(
+//       propositions,
+//       new Rational(randint(2, 30), randint(2, 30)).simplify().toTree().toTex(),
+//     );
+//   }
+//   return shuffle(propositions);
+// };
+// const isAnswerValid: VEA<Identifiers> = (
+//   ans,
+//   { isAskingC, rand, rand2, sideLengths },
+// ) => {
+//   let answer: Node;
+//   if (isAskingC)
+//     answer = new Rational(
+//       sideLengths[2 * rand2] * sideLengths[2 * rand + 1],
+//       sideLengths[2 * rand],
+//     )
+//       .simplify()
+//       .toTree();
+//   else
+//     answer = new Rational(
+//       sideLengths[2 * rand2 + 1] * sideLengths[2 * rand],
+//       sideLengths[2 * rand + 1],
+//     )
+//       .simplify()
+//       .toTree();
+//   const texs = answer.toAllValidTexs({ allowFractionToDecimal: true });
+//   return texs.includes(ans);
+// };
+// export const thalesCalcul: Exercise<Identifiers> = {
+//   id: "thalesCalcul",
+//   connector: "=",
+//   label: "Utiliser le théoreme de Thalès pour faire des calculs",
+//   levels: ["5ème", "4ème", "3ème", "2nde"],
+//   isSingleStep: false,
+//   sections: ["Théorème de Thalès", "Géométrie euclidienne"],
+//   generator: (nb: number) => getDistinctQuestions(getThales, nb),
+//   qcmTimer: 60,
+//   freeTimer: 60,
+//   getPropositions,
+//   isAnswerValid,
+//   hasGeogebra: true,
+//   subject: "Mathématiques",
+// };

package/lib/exercises/math/percent/index.d.ts

@@ -6,7 +6,6 @@ export * from "./reciprocalPercentage";
 export * from "./percentToDecimal";
 export * from "./valuePercent";
 export * from "./findProportion";
-export * from "./isTableProportional";
 export * from "./cmToEvolution";
 export * from "./htToTTC";
 export * from "./ttcToHT";

package/lib/exercises/math/percent/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/percent/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,wBAAwB,CAAC;AACvC,cAAc,iBAAiB,CAAC;AAChC,cAAc,iBAAiB,CAAC;AAChC,cAAc,wBAAwB,CAAC;AACvC,cAAc,oBAAoB,CAAC;AACnC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,kBAAkB,CAAC;AACjC,cAAc,uBAAuB,CAAC;AACtC,cAAc,iBAAiB,CAAC;AAChC,cAAc,WAAW,CAAC;AAC1B,cAAc,WAAW,CAAC;AAC1B,cAAc,WAAW,CAAC;AAC1B,cAAc,2BAA2B,CAAC;AAC1C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,oCAAoC,CAAC;AACnD,cAAc,uCAAuC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/percent/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,wBAAwB,CAAC;AACvC,cAAc,iBAAiB,CAAC;AAChC,cAAc,iBAAiB,CAAC;AAChC,cAAc,wBAAwB,CAAC;AACvC,cAAc,oBAAoB,CAAC;AACnC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,kBAAkB,CAAC;AACjC,cAAc,iBAAiB,CAAC;AAChC,cAAc,WAAW,CAAC;AAC1B,cAAc,WAAW,CAAC;AAC1B,cAAc,WAAW,CAAC;AAC1B,cAAc,2BAA2B,CAAC;AAC1C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,oCAAoC,CAAC;AACnD,cAAc,uCAAuC,CAAC"}

package/lib/exercises/math/percent/index.js

@@ -22,7 +22,6 @@ __exportStar(require("./reciprocalPercentage"), exports);
 __exportStar(require("./percentToDecimal"), exports);
 __exportStar(require("./valuePercent"), exports);
 __exportStar(require("./findProportion"), exports);
-__exportStar(require("./isTableProportional"), exports);
 __exportStar(require("./cmToEvolution"), exports);
 __exportStar(require("./htToTTC"), exports);
 __exportStar(require("./ttcToHT"), exports);

package/lib/exercises/math/probaStat/binomial/binomialInequation.d.ts

@@ -0,0 +1,16 @@
+import { Exercise } from "../../../../exercises/exercise";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor";
+import { IntervalNodeIdentifiers } from "../../../../tree/nodes/sets/intervalNode";
+type Identifiers = {
+    n: number;
+    p: NodeIdentifiers;
+    interval: IntervalNodeIdentifiers;
+    type: number;
+    isSentence: boolean;
+};
+type Options = {
+    instructionType: string;
+};
+export declare const binomialInequation: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=binomialInequation.d.ts.map

package/lib/exercises/math/probaStat/binomial/binomialInequation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"binomialInequation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/binomial/binomialInequation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAiBT,MAAM,0BAA0B,CAAC;AAUlC,OAAO,EAEL,eAAe,EAChB,MAAM,kCAAkC,CAAC;AAM1C,OAAO,EAEL,uBAAuB,EACxB,MAAM,oCAAoC,CAAC;AAK5C,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,eAAe,CAAC;IACnB,QAAQ,EAAE,uBAAuB,CAAC;IAClC,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,OAAO,CAAC;CACrB,CAAC;AAgKF,KAAK,OAAO,GAAG;IACb,eAAe,EAAE,MAAM,CAAC;CACzB,CAAC;AAeF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAiB7D,CAAC"}

package/lib/exercises/math/probaStat/binomial/binomialInequation.js

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.binomialInequation = void 0;
+const exercise_1 = require("../../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
+const numberVEA_1 = require("../../../../exercises/vea/numberVEA");
+const rational_1 = require("../../../../math/numbers/rationals/rational");
+const binomial_1 = require("../../../../math/probability/binomial");
+const randfloat_1 = require("../../../../math/utils/random/randfloat");
+const randint_1 = require("../../../../math/utils/random/randint");
+const round_1 = require("../../../../math/utils/round");
+const nodeConstructor_1 = require("../../../../tree/nodes/nodeConstructor");
+const infiniteNode_1 = require("../../../../tree/nodes/numbers/infiniteNode");
+const closure_1 = require("../../../../tree/nodes/sets/closure");
+const intervalNode_1 = require("../../../../tree/nodes/sets/intervalNode");
+const coinFlip_1 = require("../../../../utils/alea/coinFlip");
+const random_1 = require("../../../../utils/alea/random");
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, (0, randfloat_1.randfloat)(0, 1, 2).frenchify());
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const binomial = new binomial_1.Binomial(identifiers.n, nodeConstructor_1.NodeConstructor.fromIdentifiers(identifiers.p));
+    const a = nodeConstructor_1.NodeConstructor.fromIdentifiers(identifiers.interval.leftChild).evaluate();
+    const b = nodeConstructor_1.NodeConstructor.fromIdentifiers(identifiers.interval.rightChild).evaluate();
+    const isStrict = identifiers.interval.closure === closure_1.ClosureType.OO;
+    const ans = identifiers.type === 1
+        ? binomial.inf(isStrict ? b - 1 : b)
+        : identifiers.type === 2
+            ? binomial.sup(isStrict ? a + 1 : a)
+            : binomial.ineq(isStrict ? a + 1 : a, isStrict ? b - 1 : b);
+    return (0, round_1.round)(ans, 2).frenchify();
+};
+const getInstruction = (identifiers, opts) => {
+    //au plus : X<=k
+    //moins de : X<k
+    //au moins: X >= k
+    //pus de : X>k
+    //entre : a <= X <= b (strict exclus)
+    const pNode = nodeConstructor_1.NodeConstructor.fromIdentifiers(identifiers.p);
+    const interval = nodeConstructor_1.NodeConstructor.fromIdentifiers(identifiers.interval);
+    const isStrict = interval.closure === closure_1.ClosureType.OO;
+    let sentence = "";
+    switch (identifiers.type) {
+        case 1:
+            sentence = isStrict
+                ? `moins de $${interval.b.toTex()}$`
+                : `au plus $${interval.b.toTex()}$`;
+            break;
+        case 2:
+            sentence = isStrict
+                ? `plus de $${interval.a.toTex()}$`
+                : `au moins $${interval.a.toTex()}$`;
+            break;
+        case 3:
+            sentence = `entre $${interval.a.toTex()}$ et $${interval.b.toTex()}$`;
+    }
+    return `Soit $X$ une variable aléatoire qui suit une loi binomiale de paramètres $n = ${identifiers.n}$ et $p = ${pNode.toTex()}$.
+  
+${identifiers.isSentence
+        ? `Quelle est la probabilité d'obtenir ${sentence} succès ? Arrondir à $10^{-2}$ près.`
+        : `Calculer en donnant la réponse à $10^{-2}$ près :
+  
+$$
+${interval.toInequality("P(X)".toTree()).toTex()}
+$$`}`;
+};
+// const getHint: GetHint<Identifiers> = (identifiers) => {};
+// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    return (0, numberVEA_1.numberVEA)(ans, answer);
+};
+const getBinomialInequationQuestion = (opts) => {
+    const n = (0, random_1.random)([(0, randint_1.randint)(4, 10), 5 * (0, randint_1.randint)(3, 10)]);
+    const p = (0, random_1.random)([
+        (0, randfloat_1.randfloat)(0.01, 0.99, 2).toTree(),
+        rational_1.RationalConstructor.randomIrreductibleProba().toTree(),
+    ]);
+    const isSentence = !opts || opts?.instructionType === "Toutes"
+        ? (0, coinFlip_1.coinFlip)()
+        : opts.instructionType === "Uniquement sous forme de phrase";
+    const type = (0, randint_1.randint)(1, 4);
+    let interval;
+    let isStrict = isSentence && type === 3 ? false : (0, coinFlip_1.coinFlip)();
+    switch (type) {
+        case 1:
+            //P(X< <= b)
+            interval = new intervalNode_1.IntervalNode(infiniteNode_1.MinusInfinityNode, (0, randint_1.randint)(isStrict ? 2 : 1, isStrict ? n + 1 : n).toTree(), isStrict ? closure_1.ClosureType.OO : closure_1.ClosureType.OF);
+            break;
+        case 2:
+            //P(X > >= a)
+            interval = new intervalNode_1.IntervalNode((0, randint_1.randint)(isStrict ? 0 : 1, isStrict ? n - 1 : n).toTree(), infiniteNode_1.PlusInfinityNode, isStrict ? closure_1.ClosureType.OO : closure_1.ClosureType.FO);
+            break;
+        case 3:
+        default:
+            //P(a < X  <b)
+            let a, b;
+            do {
+                a = (0, randint_1.randint)(isStrict ? 0 : 1, isStrict ? n - 1 : n);
+                b = (0, randint_1.randint)(a + 1, isStrict ? n + 1 : n);
+            } while (!b || Math.abs(b - a) < 2 || (isStrict && Math.abs(b - a) < 3));
+            interval = new intervalNode_1.IntervalNode(a.toTree(), b.toTree(), isStrict ? closure_1.ClosureType.OO : closure_1.ClosureType.FF);
+            break;
+    }
+    const identifiers = {
+        n,
+        p: p.toIdentifiers(),
+        interval: interval.toIdentifiers(),
+        type,
+        isSentence,
+    };
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers, opts),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        // hint: getHint(identifiers),
+        // correction: getCorrection(identifiers),
+    };
+    return question;
+};
+//>a, <a, [a,b], au plus a, au moins b, plus de, moins de,
+const options = [
+    {
+        id: "instructionType",
+        label: "Types de consignes",
+        target: exercise_1.GeneratorOptionTarget.instruction,
+        type: exercise_1.GeneratorOptionType.select,
+        values: [
+            "Toutes",
+            "Uniquement sous forme de phrase",
+            "Uniquement sous forme mathématique",
+        ],
+    },
+];
+exports.binomialInequation = {
+    id: "binomialInequation",
+    connector: "\\iff",
+    label: "Calculer une probabilité binomiale du type $P(x) \\leq a$, $P(X)\\geq a$ ou $a\\leq P(X)\\leq b$",
+    isSingleStep: true,
+    generator: (nb, opts) => (0, getDistinctQuestions_1.getDistinctQuestions)(() => getBinomialInequationQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    // getHint,
+    // getCorrection,
+    getAnswer,
+    options,
+};

package/lib/exercises/math/probaStat/binomial/calculateProbaOfBinomialDistribution.d.ts

@@ -0,0 +1,13 @@
+import { Exercise } from "../../../../exercises/exercise";
+type Identifiers = {
+    exerciseVars: ExerciseVars;
+};
+type ExerciseVars = {
+    n: number;
+    k: number;
+    a: number;
+    b: number;
+};
+export declare const calculateProbaOfBinomialDistribution: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=calculateProbaOfBinomialDistribution.d.ts.map

package/lib/exercises/math/probaStat/binomial/calculateProbaOfBinomialDistribution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"calculateProbaOfBinomialDistribution.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/binomial/calculateProbaOfBinomialDistribution.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAWlC,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,YAAY,CAAC;CAC5B,CAAC;AAEF,KAAK,YAAY,GAAG;IAClB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAqHF,eAAO,MAAM,oCAAoC,EAAE,QAAQ,CAAC,WAAW,CActE,CAAC"}

package/lib/exercises/math/probaStat/binomial/calculateProbaOfBinomialDistribution.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateProbaOfBinomialDistribution = void 0;
+const exercise_1 = require("../../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
+const rational_1 = require("../../../../math/numbers/rationals/rational");
+const combination_1 = require("../../../../math/utils/combinatorics/combination");
+const randfloat_1 = require("../../../../math/utils/random/randfloat");
+const randint_1 = require("../../../../math/utils/random/randint");
+const numberNode_1 = require("../../../../tree/nodes/numbers/numberNode");
+const multiplyNode_1 = require("../../../../tree/nodes/operators/multiplyNode");
+const powerNode_1 = require("../../../../tree/nodes/operators/powerNode");
+const alignTex_1 = require("../../../../utils/latex/alignTex");
+const getCalculateProbaOfBinomialDistributionQuestion = () => {
+    const exercise = generateExercise();
+    const p = new rational_1.Rational(exercise.a, exercise.b);
+    const correctAns = new numberNode_1.NumberNode(getCorrectAnswer(exercise.n, p.value, exercise.k));
+    const question = {
+        answer: correctAns.toTex(),
+        instruction: `Soit $X$ une variable aléatoire qui suit une loi binomiale de paramètres $n=${exercise.n}$ et $p=${p
+            .toTree()
+            .simplify()
+            .toTex()}$. Donner une valeur arrondie au centième de $P(X=${exercise.k}).$`,
+        keys: [],
+        answerFormat: "tex",
+        hint: `Si $X$ est une variable aléatoire qui suit une loi binomiale de paramètres $n$ et $p$, alors on a : 
+    
+$P(X=k) = \\binom{n}{k} p^k (1-p)^{n-k}$`,
+        correction: `Si $X$ est une variable aléatoire qui suit une loi binomiale de paramètres $n$ et $p$, alors on a : 
+    
+$P(X=k) = \\binom{n}{k} p^k (1-p)^{n-k}$
+
+Ici, on a donc : 
+
+${(0, alignTex_1.alignTex)([
+            [
+                `P(X=${exercise.k})`,
+                "=",
+                `\\binom{${exercise.n}}{${exercise.k}} ${new multiplyNode_1.MultiplyNode(new powerNode_1.PowerNode(p.toTree(), exercise.k.toTree()), new powerNode_1.PowerNode(new rational_1.Rational(exercise.b - exercise.a, exercise.b).toTree(), (exercise.n - exercise.k).toTree())).toTex()}`,
+            ],
+            ["", "\\approx", correctAns.toTex()],
+        ])}`,
+        identifiers: { exerciseVars: exercise },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, exerciseVars }) => {
+    const propositions = [];
+    const p = exerciseVars.a / exerciseVars.b;
+    (0, exercise_1.addValidProp)(propositions, answer);
+    generatePropositions(exerciseVars.n, p, exerciseVars.k).forEach((value) => (0, exercise_1.tryToAddWrongProp)(propositions, value));
+    const correctAns = getCorrectAnswer(n, p, exerciseVars.k);
+    let random;
+    while (propositions.length < n) {
+        random = new numberNode_1.NumberNode(+(correctAns + (0, randfloat_1.randfloat)(0.1, 0.6, 2, [correctAns])).toFixed(2));
+        (0, exercise_1.tryToAddWrongProp)(propositions, random.toTex());
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+const generatePropositions = (n, p, k) => {
+    const kChooseN = (0, combination_1.combinations)(k, n);
+    const firstProposition = new numberNode_1.NumberNode(+(Math.pow(p, n - k) * Math.pow(1 - p, k)).toFixed(2));
+    const secondProposition = new numberNode_1.NumberNode(+(Math.pow(p, n) * Math.pow(1 - p, k)).toFixed(2));
+    const thirdProposition = new numberNode_1.NumberNode(+(kChooseN * Math.pow(p, k)).toFixed(2));
+    return [
+        firstProposition.toTex(),
+        secondProposition.toTex(),
+        thirdProposition.toTex(),
+    ].filter((value) => +value !== 0);
+};
+const getCorrectAnswer = (n, p, k) => {
+    const kChooseN = (0, combination_1.combinations)(k, n);
+    return +(kChooseN * Math.pow(p, k) * Math.pow(1 - p, n - k)).toFixed(2);
+};
+const generateExercise = () => {
+    let n;
+    let k;
+    let a;
+    let b;
+    let correctAns;
+    do {
+        n = (0, randint_1.randint)(2, 9);
+        k = (0, randint_1.randint)(1, n);
+        b = (0, randint_1.randint)(2, 11);
+        a = (0, randint_1.randint)(1, b);
+        correctAns = getCorrectAnswer(n, a / b, k);
+    } while (correctAns === 0);
+    return { n, k, a, b };
+};
+exports.calculateProbaOfBinomialDistribution = {
+    id: "calculateProbaOfBinomialDistribution",
+    label: "Calculer une probabilité avec la loi binomiale",
+    levels: ["TermTech"],
+    isSingleStep: true,
+    sections: ["Probabilités"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getCalculateProbaOfBinomialDistributionQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/probaStat/binomial/expectedValueOfBinomialProba.d.ts

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

package/lib/exercises/math/probaStat/binomial/expectedValueOfBinomialProba.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expectedValueOfBinomialProba.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/binomial/expectedValueOfBinomialProba.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAYlC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAiFF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,CAc9D,CAAC"}

package/lib/exercises/math/probaStat/binomial/expectedValueOfBinomialProba.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expectedValueOfBinomialProba = void 0;
+const exercise_1 = require("../../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
+const rational_1 = require("../../../../math/numbers/rationals/rational");
+const randint_1 = require("../../../../math/utils/random/randint");
+const numberNode_1 = require("../../../../tree/nodes/numbers/numberNode");
+const multiplyNode_1 = require("../../../../tree/nodes/operators/multiplyNode");
+const substractNode_1 = require("../../../../tree/nodes/operators/substractNode");
+const alignTex_1 = require("../../../../utils/latex/alignTex");
+const getExpectedValueOfBinomialProbaQuestion = () => {
+    const nX = (0, randint_1.randint)(1, 9);
+    const b = (0, randint_1.randint)(2, 11);
+    const a = (0, randint_1.randint)(1, b);
+    const p = new rational_1.Rational(a, b);
+    const node = getCorrectAnswer(nX, p);
+    const answer = node.toTex();
+    const question = {
+        answer,
+        instruction: `Soit $X$ une variable aléatoire qui suit une loi binomiale de paramètres $n=${nX}$ et $p=${p
+            .toTree()
+            .simplify()
+            .toTex()}$. Calculez l'espérance de $X$.`,
+        keys: [],
+        answerFormat: "tex",
+        identifiers: { nX, a, b },
+        hint: `L'espérance d'une variable aléatoire $X$ qui suit une loi binomiale de paramètres $n$ et $p$ est donnée par $E(X) = np$.`,
+        correction: `L'espérance d'une variable aléatoire $X$ qui suit une loi binomiale de paramètres $n$ et $p$ est donnée par $E(X) = np$.
+    
+Ici, on a donc :
+
+${(0, alignTex_1.alignTex)([
+            ["E(X)", "=", new multiplyNode_1.MultiplyNode(nX.toTree(), p.toTree()).toTex()],
+            ["", "=", answer],
+        ])}`,
+    };
+    return question;
+};
+const getPropositions = (n, { answer, nX, a, b }) => {
+    const propositions = [];
+    const p = new rational_1.Rational(a, b);
+    (0, exercise_1.addValidProp)(propositions, answer);
+    generatePropositions(nX, p).forEach((value) => (0, exercise_1.tryToAddWrongProp)(propositions, value));
+    let random;
+    while (propositions.length < n) {
+        random = rational_1.RationalConstructor.randomIrreductible(10).toTree();
+        (0, exercise_1.tryToAddWrongProp)(propositions, random.toTex());
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { nX, a, b }) => {
+    const p = new rational_1.Rational(a, b);
+    const correctAns = getCorrectAnswer(nX, p);
+    return correctAns
+        .toAllValidTexs({ allowFractionToDecimal: true })
+        .includes(ans);
+};
+const generatePropositions = (n, p) => {
+    const pTree = p.toTree().simplify();
+    const oneMinusP = new substractNode_1.SubstractNode(new numberNode_1.NumberNode(1), pTree).simplify();
+    const nNode = new numberNode_1.NumberNode(n);
+    const firstProposition = pTree;
+    const secondProposition = new multiplyNode_1.MultiplyNode(nNode, new multiplyNode_1.MultiplyNode(pTree, oneMinusP).simplify()).simplify();
+    const thirdProposition = new multiplyNode_1.MultiplyNode(nNode, oneMinusP).simplify();
+    return [
+        firstProposition.toTex(),
+        secondProposition.toTex(),
+        thirdProposition.toTex(),
+    ];
+};
+const getCorrectAnswer = (n, p) => {
+    const nNode = new numberNode_1.NumberNode(n);
+    return new multiplyNode_1.MultiplyNode(nNode, p.toTree().simplify()).simplify();
+};
+exports.expectedValueOfBinomialProba = {
+    id: "expectedValueOfBinomialProba",
+    label: "Calcul de l'espérance d'une loi binomiale",
+    levels: ["TermTech"],
+    isSingleStep: true,
+    sections: ["Probabilités"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getExpectedValueOfBinomialProbaQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    hasHintAndCorrection: true,
+};

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

@@ -0,0 +1,5 @@
+export * from "./calculateProbaOfBinomialDistribution";
+export * from "./expectedValueOfBinomialProba";
+export * from "./varianceOfBinomialProba";
+export * from "./binomialInequation";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/binomial/index.ts"],"names":[],"mappings":"AAAA,cAAc,wCAAwC,CAAC;AACvD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,sBAAsB,CAAC"}