math-exercises 3.0.101 → 3.0.103

package/lib/exercises/math/python/pythonWhileStatementOperationCompletion.js

@@ -0,0 +1,120 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../math/utils/random/randint.js";
+import { random } from "../../../utils/alea/random.js";
+import { handleVEAError } from "../../../utils/errors/handleVEAError.js";
+const getPropositions = (n, { answer, operation, coeff }) => {
+    const propositions = [];
+    addValidProp(propositions, answer, "raw");
+    tryToAddWrongProp(propositions, `\`${operation}${coeff}\``, "raw");
+    tryToAddWrongProp(propositions, `\`x>1500\``, "raw");
+    tryToAddWrongProp(propositions, `\`${coeff}\``, "raw");
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    return `\`x${identifiers.operation}${identifiers.coeff}\``;
+};
+const getInstruction = (identifiers) => {
+    const { coeff, operation } = identifiers;
+    let word = "";
+    if (operation === "*") {
+        if (coeff === 2)
+            word = "doubler ce nombre";
+        else if (coeff === 3)
+            word = "tripler ce nombre";
+        else
+            word = `multiplier ce nombre par $${coeff}$`;
+    }
+    else {
+        word = `additionner $${coeff}$ à ce nombre`;
+    }
+    return `On considère la fonction en Python ci-dessous. Cette fonction doit permettre, pour un paramètre \`x\` saisi en entrée, de déterminer combien de fois on doit ${word} pour qu'il dépasse $1500$.
+  
+Par quoi faut-il remplacer les trois points ?
+
+\`\`\`
+def boucle(x):
+  compt=0
+  while x<1500:
+    x=...
+    compt=compt+1
+  return compt
+\`\`\`
+`;
+};
+const getHint = (identifiers) => {
+    const { coeff, operation } = identifiers;
+    return `Sers-toi de cet exemple : en Python, si l'on veut diviser une variable \`a\` par $2$, on écrit : 
+  
+\`\`\`
+a = a/2
+\`\`\``;
+};
+const getCorrection = (identifiers) => {
+    const { coeff, operation } = identifiers;
+    let word = "";
+    if (operation === "*") {
+        if (coeff === 2)
+            word = "doubler `x` ";
+        else if (coeff === 3)
+            word = "tripler `x`";
+        else
+            word = `multiplier \`x\` par $${coeff}$`;
+    }
+    else {
+        word = `additionner $${coeff}$ à \`x\``;
+    }
+    return `On veut  ${word} à chaque exécution de la boucle \`while\`. En python, cela se traduit par : 
+  
+\`\`\`
+x=x${operation}${coeff}
+\`\`\`
+`;
+};
+const getKeys = (identifiers) => {
+    return ["x", "sup", "inf", "equal"];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return ans === answer;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getPythonWhileStatementCompletionQuestion = (ops) => {
+    const identifiers = {
+        operation: random(["+", "*"]),
+        coeff: randint(2, 11),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "raw",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const pythonWhileStatementOperationCompletion = {
+    id: "pythonWhileStatementOperationCompletion",
+    label: "Compléter une instruction dans une boucle `while` en Python",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getPythonWhileStatementCompletionQuestion(opts), nb, 15),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+    maxAllowedQuestions: 15,
+};

package/lib/exercises/math/python/variableType.js

@@ -100,7 +100,7 @@ const getQuestionFromIdentifiers = (identifiers) => {
 };
 export const variableType = {
     id: "variableType",
-    label: "Déterminer le type d’une variable en Python",
+    label: "Déterminer le type d'une variable en Python",
     isSingleStep: true,
     generator: (nb, opts) => getDistinctQuestions(() => getVariableTypeQuestion(opts), nb),
     qcmTimer: 60,

package/lib/exercises/math/python/whileLoop.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"whileLoop.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/python/whileLoop.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAIrC,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAgIF,eAAO,MAAM,SAAS,EAAE,QAAQ,CAAC,WAAW,CAY3C,CAAC"}
+{"version":3,"file":"whileLoop.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/python/whileLoop.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAIrC,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAiIF,eAAO,MAAM,SAAS,EAAE,QAAQ,CAAC,WAAW,CAY3C,CAAC"}

package/lib/exercises/math/python/whileLoop.js

@@ -18,6 +18,7 @@ const getInstruction = (identifiers) => {
     const { a, initialValue, opIndex, step, x } = identifiers;
     const op = operations[opIndex];
     return `Qu'affichera le programme suivant ?
+  
 \`\`\`
 a = ${a}
 n = ${initialValue}

package/lib/exercises/math/python/whileLoopCount.js

@@ -11,7 +11,7 @@ def boucle(x):
   return x
 \`\`\`
 
-Si l'on saisit la commande boucle($${inputValue}$), combien de fois la boucle s'exécute-t-elle ?`;
+Si l'on saisit la commande \`boucle(${inputValue})\`, combien de fois la boucle s'exécute-t-elle ?`;
 };
 const getAnswer = ({ inputValue, threshold }) => {
     let x = inputValue;
@@ -53,7 +53,7 @@ const getQuestionFromIdentifiers = (identifiers) => ({
     hint: getHint(identifiers),
     correction: getCorrection(identifiers),
     keys: [],
-    answerFormat: "raw",
+    answerFormat: "tex",
     identifiers,
 });
 const getPyWhileLoopCountQuestion = () => {

package/lib/exercises/math/sampling/samplingFrequency.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"samplingFrequency.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/sampling/samplingFrequency.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AAwGF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAoBnD,CAAC"}
+{"version":3,"file":"samplingFrequency.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/sampling/samplingFrequency.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AAsGF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAoBnD,CAAC"}

package/lib/exercises/math/sampling/samplingFrequency.js

@@ -22,12 +22,10 @@ const getAnswer = (identifiers) => {
 };
 const getInstruction = (identifiers) => {
     const length = identifiers.samples.length;
-    return `Ce graphique donne les fréquences $${length}$ échantillons d'une expérience aléatoire. Estimer la probabilité de l'évènement $A$.`;
+    return `Ce graphique donne les fréquences de $${length}$ échantillons d'une expérience aléatoire. Estimer la probabilité de l'évènement $A$.`;
 };
 const getHint = (identifiers) => {
-    return `Chaque échantillon donne une valeur approximative proche de la probabilité réelle. 
-  
-Tu peux estimer cette probabilité en déterminant graphiquement la moyenne des fréquences des échantillons.`;
+    return `Tu peux estimer la probabilité de $A$ en déterminant graphiquement la moyenne des fréquences des échantillons.`;
 };
 const getCorrection = (identifiers) => {
     const { samples } = identifiers;

package/lib/exercises/math/sequences/genericSequenceVariations.js

@@ -5,9 +5,9 @@ import { randint } from "../../../math/utils/random/randint.js";
 const getInstruction = (identifiers) => {
     const { coeffs } = identifiers;
     const u = new Polynomial(coeffs, "n");
-    return `Soit $u$ la suite définie par $u_n = ${u
-        .toTree()
-        .toTex()}$. Quel est le sens de variations de $u$ ?`;
+    return `Soit $u$ la suite définie par $u_n = ${u.toTree().toTex()}$. 
+    
+Quel est le sens de variations de $u$ ?`;
 };
 const getAnswer = (identifiers) => {
     const { coeffs } = identifiers;

package/lib/exercises/math/sequences/sequencePlot.js

@@ -80,7 +80,7 @@ const getQuestionFromIdentifiers = (identifiers) => {
         instruction: getInstruction(identifiers),
         ggbOptions: getGGBOptions(identifiers),
         keys: [],
-        answerFormat: "raw",
+        answerFormat: "tex",
         identifiers,
         hint: getHint(identifiers),
         correction: getCorrection(identifiers),

package/lib/exercises/pc/electricity/kirchhoffVoltageLaw.js

@@ -57,7 +57,7 @@ La tension $U_{DC}$ aux bornes de la diode est $${uDC}$ $V$.
 
 La tension $U_{ED}$ aux bornes du conducteur ohmique est $${uED} \\ \\textrm{V}$.
 
-Cacluler la tension de la pile $U_{AB}$.
+Calculer la tension de la pile $U_{AB}$.
 
 ${schema}`;
         case "UED":

package/lib/index.d.ts

@@ -1381,6 +1381,10 @@ declare const mathExercises: (Exercise<{
     shape: "square" | "rectangle";
     side: number;
     side2?: number;
+}, {}> | Exercise<{
+    isEqui: boolean;
+    side: number;
+    base?: number;
 }, {}> | Exercise<{
     ratio: number;
     triangleIdentifiers: import("./math/geometry/triangles/triangle.js").TriangleIdentifiers;
@@ -1751,6 +1755,15 @@ declare const mathExercises: (Exercise<{
 }, {}> | Exercise<{
     triangleIdentifiers: import("./math/geometry/triangles/triangle.js").TriangleIdentifiers;
     angleAsked: number;
+}, {}> | Exercise<{
+    perimeter: number;
+    askingX: boolean;
+}, {}> | Exercise<{
+    shape: number;
+    side: number;
+}, {}> | Exercise<{
+    shape: number;
+    side: number;
 }, {}> | Exercise<{
     coeffs: number[];
     to: "+\\infty" | "-\\infty";
@@ -2511,6 +2524,25 @@ declare const mathExercises: (Exercise<{
     a: number;
     b: number;
     opName: string;
+}, {}> | Exercise<{
+    coeff: number;
+    iterations: number;
+    operation: string;
+}, {}> | Exercise<{
+    ineq: string;
+    coeff: number;
+}, {}> | Exercise<{
+    threshold: number;
+}, {}> | Exercise<{
+    operation: string;
+    coeff: number;
+}, {}> | Exercise<{
+    coeff: number;
+    iterations: number;
+    operation: string;
+}, {}> | Exercise<{
+    m: number;
+    p: number;
 }, {}> | Exercise<{
     p: number;
     n: 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;AAE/D,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAA6B,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;AAE/D,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,QAAQ,EAAE,QAAQ,EAAE,cAAc,EAAE,CAAC"}

package/lib/math/probability/binomial.d.ts

@@ -3,6 +3,7 @@ export declare class Binomial {
     n: number;
     p: AlgebraicNode;
     constructor(n: number, p: AlgebraicNode);
+    equals(k: number): number;
     sup(k: number): number;
     inf(k: number): number;
     ineq(a: number, b: number): number;

package/lib/math/probability/binomial.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"binomial.d.ts","sourceRoot":"","sources":["../../../src/math/probability/binomial.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAKlE,qBAAa,QAAQ;IACnB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,aAAa,CAAC;gBACL,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,aAAa;IAKvC,GAAG,CAAC,CAAC,EAAE,MAAM;IAWb,GAAG,CAAC,CAAC,EAAE,MAAM;IAWb,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM;CAW1B"}
+{"version":3,"file":"binomial.d.ts","sourceRoot":"","sources":["../../../src/math/probability/binomial.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAKlE,qBAAa,QAAQ;IACnB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,aAAa,CAAC;gBACL,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,aAAa;IAoBvC,MAAM,CAAC,CAAC,EAAE,MAAM;IAQhB,GAAG,CAAC,CAAC,EAAE,MAAM;IAWb,GAAG,CAAC,CAAC,EAAE,MAAM;IAWb,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM;CAW1B"}

package/lib/math/probability/binomial.js

@@ -7,6 +7,26 @@ export class Binomial {
         this.n = n;
         this.p = p;
     }
+    // //ex sample([1,2,3]) renvoit un échantillon [v_i] où v_i = nb de fois où on a obtenu i succès avec B(n,p)
+    // sample(values: number[]) {
+    //   const proba = this.p.evaluate();
+    //   const res = [];
+    //   for (const v of values) {
+    //     let count = 0;
+    //     for (let i = 0; i < this.n; i++) {
+    //       const success = Math.random() < proba;
+    //       success && count++;
+    //     }
+    //     v === count && res.push(count);
+    //   }
+    //   return res;
+    // }
+    equals(k) {
+        const proba = this.p.evaluate();
+        return (combinations(k, this.n) *
+            Math.pow(proba, k) *
+            Math.pow(1 - proba, this.n - k));
+    }
     sup(k) {
         const proba = this.p.evaluate();
         return sum(k, this.n, (i) => combinations(i, this.n) *

package/lib/math/utils/stats/gaussianWithNoise.d.ts

@@ -0,0 +1,3 @@
+import { AlgebraicNode } from "../../../tree/nodes/algebraicNode.js";
+export declare const gaussianWithNoise: (n: number, p: AlgebraicNode) => number[];
+//# sourceMappingURL=gaussianWithNoise.d.ts.map

package/lib/math/utils/stats/gaussianWithNoise.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gaussianWithNoise.d.ts","sourceRoot":"","sources":["../../../../src/math/utils/stats/gaussianWithNoise.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAElE,eAAO,MAAM,iBAAiB,MAAO,MAAM,KAAK,aAAa,aAO5D,CAAC"}

package/lib/math/utils/stats/gaussianWithNoise.js

@@ -0,0 +1,9 @@
+import { Binomial } from "../../../math/probability/binomial.js";
+export const gaussianWithNoise = (n, p) => {
+    const binomial = new Binomial(n, p);
+    const res = [];
+    for (let i = 0; i < n; i++) {
+        res.push(binomial.equals(i));
+    }
+    return res;
+};

package/lib/playground.d.ts

@@ -1,2 +1,7 @@
 export declare const playground: () => void;
+/***
+ *
+ * !!TODO
+ *  - j'ai l'impression que opposite(3).simplify() et numberNode(-3) ne passent pas "equals", j'ai du mal à comprendre pourquoi alors que opposite(3) se simplifie bien en numberNode
+ */
 //# sourceMappingURL=playground.d.ts.map

package/lib/playground.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"playground.d.ts","sourceRoot":"","sources":["../src/playground.ts"],"names":[],"mappings":"AAwCA,eAAO,MAAM,UAAU,YAAW,CAAC"}
+{"version":3,"file":"playground.d.ts","sourceRoot":"","sources":["../src/playground.ts"],"names":[],"mappings":"AAwCA,eAAO,MAAM,UAAU,YAEtB,CAAC;AAEF;;;;GAIG"}

package/lib/playground.js

@@ -1 +1,8 @@
-export const playground = () => { };
+export const playground = () => {
+    // console.log(opposite(3).simplify());
+};
+/***
+ *
+ * !!TODO
+ *  - j'ai l'impression que opposite(3).simplify() et numberNode(-3) ne passent pas "equals", j'ai du mal à comprendre pourquoi alors que opposite(3) se simplifie bien en numberNode
+ */

package/package.json

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