math-exercises 3.0.137 → 3.0.139

package/lib/exercises/math/calcul/arithmetics/countDivisors.d.ts

@@ -0,0 +1,7 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    nb: number;
+};
+export declare const countDivisors: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=countDivisors.d.ts.map

package/lib/exercises/math/calcul/arithmetics/countDivisors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"countDivisors.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/arithmetics/countDivisors.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AAoGF,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,WAAW,CAkB/C,CAAC"}

package/lib/exercises/math/calcul/arithmetics/countDivisors.js

@@ -0,0 +1,103 @@
+import { addValidProp, shuffleProps, propWhile, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { numberVEA } from "../../../../exercises/vea/numberVEA.js";
+import { dividersOf } from "../../../../math/utils/arithmetic/dividersOf.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { joinanded } from "../../../../utils/strings/joinanded.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const answerNb = answer.unfrenchify();
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, Math.max(1, answerNb + randint(-3, 3, [0])).frenchify());
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const dividers = dividersOf(identifiers.nb);
+    return dividers.length.frenchify();
+};
+const getInstruction = (identifiers) => {
+    return `Combien le nombre $${identifiers.nb}$ a-t-il de diviseurs ?`;
+};
+const getHint = (identifiers) => {
+    return `Les diviseurs de $${identifiers.nb}$ sont les nombres $a$ et $b$ tels que 
+  
+$$
+${identifiers.nb} = a \\times b
+$$
+
+N'oublie pas que tout nombre naturel $n$ peut s'écrire : 
+
+$$
+n = 1 \\times n
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const divisors = dividersOf(identifiers.nb);
+    const pureDivisors = divisors.slice(1, divisors.length % 2 === 0 ? divisors.length / 2 : divisors.length - 1);
+    if (divisors.length === 2) {
+        return `$${identifiers.nb}$ est un nombre premier, car il n'est divisible que par lui-même et $1$. 
+
+Il n'a donc que deux diviseurs.`;
+    }
+    return `Comme tous les nombres naturels, $${identifiers.nb}$ est divisible par $1$ et par lui-même. 
+  
+De plus, il est divisible par ${joinanded(divisors.slice(1, divisors.length - 1).map((e) => `$${e.frenchify()}$`))}, car :
+
+${pureDivisors
+        .map((d) => `\n$$\n${identifiers.nb} = ${d} \\times ${frac(identifiers.nb, d)
+        .simplify()
+        .toTex()}\n$$`)
+        .join("\n \n")}
+
+Le nombre de diviseurs de $${identifiers.nb}$ est donc $${divisors.length}$.
+`;
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return numberVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getCountDivisorsQuestion = () => {
+    const nb = randint(2, 101);
+    const identifiers = { nb };
+    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 countDivisors = {
+    id: "countDivisors",
+    connector: "=",
+    label: "Compter les diviseurs d'un nombre",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getCountDivisorsQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/calcul/arithmetics/findPrimeInList.d.ts

@@ -0,0 +1,7 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    nbs: number[];
+};
+export declare const findPrimeInList: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=findPrimeInList.d.ts.map

package/lib/exercises/math/calcul/arithmetics/findPrimeInList.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"findPrimeInList.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/arithmetics/findPrimeInList.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAYrC,KAAK,WAAW,GAAG;IACjB,GAAG,EAAE,MAAM,EAAE,CAAC;CACf,CAAC;AAkFF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAmBjD,CAAC"}

package/lib/exercises/math/calcul/arithmetics/findPrimeInList.js

@@ -0,0 +1,89 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { primes } from "../../../../math/numbers/integer/primes.js";
+import { dividersOf } from "../../../../math/utils/arithmetic/dividersOf.js";
+import { isPrime } from "../../../../math/utils/arithmetic/isPrime.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { random } from "../../../../utils/alea/random.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { doWhile } from "../../../../utils/doWhile.js";
+import { joinanded } from "../../../../utils/strings/joinanded.js";
+import { pluralize } from "../../../../utils/strings/pluralize.js";
+const getPropositions = (n, { nbs }) => {
+    const propositions = [];
+    for (const nb of nbs) {
+        if (isPrime(nb))
+            addValidProp(propositions, nb.frenchify());
+        else
+            tryToAddWrongProp(propositions, nb.frenchify());
+    }
+    return shuffleProps(propositions, n);
+};
+const getAnswer = () => {
+    return "";
+};
+const getInstruction = () => {
+    return `Parmi les nombres suivants, lequel ou lesquels sont des nombres premiers ?`;
+};
+const getHint = () => {
+    return `Un nombre est premier s'il n'a que deux diviseurs : $1$ et lui-même.`;
+};
+const getCorrection = (identifiers) => {
+    return `Un nombre est premier s'il n'a que deux diviseurs : $1$ et lui-même. 
+  
+Pour chaque nombre, on compte son nombre de diviseurs :
+  
+${identifiers.nbs
+        .map((nb) => {
+        const divisors = dividersOf(nb);
+        return `\n
+- $${nb}$ a $${divisors.length}$ ${pluralize("diviseur", divisors.length)} : ${joinanded(divisors.map((e) => `$${e.frenchify()}$`))}. ${divisors.length === 2
+            ? "Il est donc premier."
+            : "Il n'est donc pas premier."}`;
+    })
+        .join("")}`;
+};
+const getFindPrimeInListQuestion = () => {
+    const nbRightAnswer = randint(1, 4);
+    const nbs = [];
+    for (let i = 0; i < nbRightAnswer; i++) {
+        nbs.push(doWhile(() => random(primes), (nb) => nbs.includes(nb)));
+    }
+    for (let i = 0; i < 4 - nbRightAnswer; i++) {
+        nbs.push(doWhile(() => randint(1, 101), (x) => isPrime(x) || nbs.includes(x)));
+    }
+    const identifiers = {
+        nbs: shuffle(nbs),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const findPrimeInList = {
+    id: "findPrimeInList",
+    connector: "=",
+    label: "Trouver les nombres premiers dans une liste",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getFindPrimeInListQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCM",
+    isQCM: true,
+};

package/lib/exercises/math/calcul/arithmetics/findRightPrimeDecomposition.d.ts

@@ -0,0 +1,12 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    nb: number;
+    fakeDecomps: NodeIdentifiers[];
+};
+type Options = {
+    doNotUsePowers?: boolean;
+};
+export declare const findRightPrimeDecomposition: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=findRightPrimeDecomposition.d.ts.map

package/lib/exercises/math/calcul/arithmetics/findRightPrimeDecomposition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"findRightPrimeDecomposition.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/arithmetics/findRightPrimeDecomposition.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAQrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAU7C,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,WAAW,EAAE,eAAe,EAAE,CAAC;CAChC,CAAC;AAEF,KAAK,OAAO,GAAG;IACb,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B,CAAC;AAkIF,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAsBtE,CAAC"}

package/lib/exercises/math/calcul/arithmetics/findRightPrimeDecomposition.js

@@ -0,0 +1,129 @@
+import { addValidProp, shuffleProps, GeneratorOptionTarget, GeneratorOptionType, 
+// tryToAddWrongProp,
+addWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { dividersOf } from "../../../../math/utils/arithmetic/dividersOf.js";
+import { isPrime } from "../../../../math/utils/arithmetic/isPrime.js";
+// import { isPrime } from "../../../../math/utils/arithmetic/isPrime.js";
+import { primeDecompNode } from "../../../../math/utils/arithmetic/primeDecompNode.js";
+import { primeDecomposition } from "../../../../math/utils/arithmetic/primeDecomposition.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.js";
+import { multiply, MultiplyNode, } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { power } from "../../../../tree/nodes/operators/powerNode.js";
+import { operatorComposition } from "../../../../tree/utilities/operatorComposition.js";
+import { random } from "../../../../utils/alea/random.js";
+import { doWhile } from "../../../../utils/doWhile.js";
+const options = [
+    {
+        id: "doNotUsePowers",
+        label: "Ne pas utiliser de puissances",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.checkbox,
+        defaultValue: false,
+    },
+];
+const getPropositions = (n, { answer, fakeDecomps }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    for (const decomp of fakeDecomps) {
+        addWrongProp(propositions, reifyAlgebraic(decomp).toTex({ forceNoSimplification: true }));
+    }
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers, opts) => {
+    const decomp = primeDecompNode(identifiers.nb, !opts?.doNotUsePowers);
+    return decomp.toTex();
+};
+const getInstruction = (identifiers) => {
+    return `Parmi les propositions suivantes, laquelle est la décomposition en produit de facteurs premiers de $${identifiers.nb}$ ?`;
+};
+const getHint = (_identifiers, opts) => {
+    return `La décomposition en produit de facteurs premiers d'un nombre $n$ est une écriture de la forme : 
+  
+${opts?.doNotUsePowers
+        ? `$$
+n = p_1 \\times p_2 \\times ...  
+$$`
+        : `$$
+n = p_1^{k_1} \\times p_2^{k_2} \\times ...
+$$`}
+
+où $p_1$, $p_2$, ... sont des nombres premiers${opts?.doNotUsePowers
+        ? " ."
+        : " et $k_1$, $k_2$, ... sont des entiers naturels."} 
+
+Parmi les écritures proposées, il faut donc repérer celle dans laquelle chaque facteur est un nombre premier.`;
+};
+const getCorrection = (identifiers, opts) => {
+    return `La décomposition en produit de facteurs premiers de $${identifiers.nb}$ est : 
+  
+$$
+${getAnswer(identifiers, opts)}
+$$`;
+};
+const getFindRightPrimeDecompositionQuestion = (opts) => {
+    let nb = 0;
+    let divisors = [];
+    do {
+        nb = randint(10, 101);
+        divisors = dividersOf(nb);
+    } while (divisors.length < 5);
+    // const pureDivisors = divisors.slice(
+    //   0,
+    //   divisors.length % 2 === 0 ? divisors.length / 2 : (divisors.length + 1) / 2,
+    // );
+    const fakeDecomps = [];
+    const nonPrimes = [];
+    console.log(nb);
+    for (let i = 0; i < 3; i++) {
+        const nonPrime = doWhile(() => random(divisors.slice(1).filter((n) => !isPrime(n))), (n) => nonPrimes.includes(n));
+        nonPrimes.push(nonPrime);
+        if (nonPrime === nb) {
+            fakeDecomps.push(multiply(1, nb).toIdentifiers());
+        }
+        else {
+            const rest = nb / nonPrime;
+            const fakeDecomp = primeDecomposition(rest);
+            fakeDecomp.push({ value: nonPrime, power: 1 });
+            fakeDecomp.sort((a, b) => a.value - b.value);
+            fakeDecomps.push(operatorComposition(MultiplyNode, fakeDecomp.map((d) => d.power > 1
+                ? opts?.doNotUsePowers
+                    ? power(d.value, d.power).toMultiplyNode()
+                    : power(d.value, d.power)
+                : d.value.toTree())).toIdentifiers());
+        }
+    }
+    const identifiers = { nb, fakeDecomps };
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    return {
+        answer: getAnswer(identifiers, opts),
+        instruction: getInstruction(identifiers, opts),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+    };
+};
+export const findRightPrimeDecomposition = {
+    id: "findRightPrimeDecomposition",
+    connector: "=",
+    label: "Trouver la bonne décomposition en produit de facteurs premiers",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getFindRightPrimeDecompositionQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+    options,
+};

package/lib/exercises/math/calcul/arithmetics/index.d.ts

@@ -11,4 +11,6 @@ export * from "./primeNumberIdentification.js";
 export * from "./whichMultipleAmI.js";
 export * from "./isMultipleOrDivisor.js";
 export * from "./coprime.js";
+export * from "./countDivisors.js";
+export * from "./findPrimeInList.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/calcul/arithmetics/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/arithmetics/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,mBAAmB,CAAC;AAClC,cAAc,iBAAiB,CAAC;AAChC,cAAc,mBAAmB,CAAC;AAClC,cAAc,yBAAyB,CAAC;AACxC,cAAc,0BAA0B,CAAC;AACzC,cAAc,iBAAiB,CAAC;AAChC,cAAc,iCAAiC,CAAC;AAChD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,uBAAuB,CAAC;AACtC,cAAc,0BAA0B,CAAC;AACzC,cAAc,cAAc,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/arithmetics/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,mBAAmB,CAAC;AAClC,cAAc,iBAAiB,CAAC;AAChC,cAAc,mBAAmB,CAAC;AAClC,cAAc,yBAAyB,CAAC;AACxC,cAAc,0BAA0B,CAAC;AACzC,cAAc,iBAAiB,CAAC;AAChC,cAAc,iCAAiC,CAAC;AAChD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,uBAAuB,CAAC;AACtC,cAAc,0BAA0B,CAAC;AACzC,cAAc,cAAc,CAAC;AAC7B,cAAc,oBAAoB,CAAC;AACnC,cAAc,sBAAsB,CAAC"}

package/lib/exercises/math/calcul/arithmetics/index.js

@@ -11,3 +11,6 @@ export * from "./primeNumberIdentification.js";
 export * from "./whichMultipleAmI.js";
 export * from "./isMultipleOrDivisor.js";
 export * from "./coprime.js";
+export * from "./countDivisors.js";
+export * from "./findPrimeInList.js";
+// export * from "./findRightPrimeDecomposition.js";

package/lib/exercises/math/calculLitteral/equation/index.d.ts

@@ -15,4 +15,5 @@ export * from "./equationWithDistributivity.js";
 export * from "./choseOperationToSolveEquation.js";
 export * from "./factorizeEquation.js";
 export * from "./equationFromProblem.js";
+export * from "./isEqualityTrue.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/calculLitteral/equation/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/equation/index.ts"],"names":[],"mappings":"AAAA,cAAc,2BAA2B,CAAC;AAC1C,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,uBAAuB,CAAC;AACtC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,0BAA0B,CAAC;AACzC,cAAc,kCAAkC,CAAC;AACjD,cAAc,kCAAkC,CAAC;AACjD,cAAc,kCAAkC,CAAC;AACjD,cAAc,mCAAmC,CAAC;AAClD,cAAc,2CAA2C,CAAC;AAC1D,cAAc,iCAAiC,CAAC;AAChD,cAAc,oCAAoC,CAAC;AACnD,cAAc,wBAAwB,CAAC;AACvC,cAAc,0BAA0B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/equation/index.ts"],"names":[],"mappings":"AAAA,cAAc,2BAA2B,CAAC;AAC1C,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,uBAAuB,CAAC;AACtC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,0BAA0B,CAAC;AACzC,cAAc,kCAAkC,CAAC;AACjD,cAAc,kCAAkC,CAAC;AACjD,cAAc,kCAAkC,CAAC;AACjD,cAAc,mCAAmC,CAAC;AAClD,cAAc,2CAA2C,CAAC;AAC1D,cAAc,iCAAiC,CAAC;AAChD,cAAc,oCAAoC,CAAC;AACnD,cAAc,wBAAwB,CAAC;AACvC,cAAc,0BAA0B,CAAC;AACzC,cAAc,qBAAqB,CAAC"}

package/lib/exercises/math/calculLitteral/equation/index.js

@@ -15,3 +15,4 @@ export * from "./equationWithDistributivity.js";
 export * from "./choseOperationToSolveEquation.js";
 export * from "./factorizeEquation.js";
 export * from "./equationFromProblem.js";
+export * from "./isEqualityTrue.js";

package/lib/exercises/math/calculLitteral/equation/isEqualityTrue.d.ts

@@ -0,0 +1,14 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    evaluationDict: Record<string, NodeIdentifiers>;
+    equalNodeIds: NodeIdentifiers;
+    isEqual: boolean;
+};
+type Options = {
+    typeCoeff: "Entier" | "Fraction" | "Décimal";
+    typeTestValue: "Entier" | "Fraction" | "Décimal";
+};
+export declare const isEqualityTrue1: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=isEqualityTrue.d.ts.map

package/lib/exercises/math/calculLitteral/equation/isEqualityTrue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isEqualityTrue.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/equation/isEqualityTrue.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAOrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAkB7C,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;IAChD,YAAY,EAAE,eAAe,CAAC;IAC9B,OAAO,EAAE,OAAO,CAAC;CAClB,CAAC;AAkUF,KAAK,OAAO,GAAG;IACb,SAAS,EAAE,QAAQ,GAAG,UAAU,GAAG,SAAS,CAAC;IAC7C,aAAa,EAAE,QAAQ,GAAG,UAAU,GAAG,SAAS,CAAC;CAClD,CAAC;AA6BF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAkB1D,CAAC"}

package/lib/exercises/math/calculLitteral/equation/isEqualityTrue.js

@@ -0,0 +1,314 @@
+import { addValidProp, tryToAddWrongProp, GeneratorOptionTarget, GeneratorOptionType, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { nodeBySubstitutingVar } from "../../../../math/utils/functions/functionComposition.js";
+import { randfloat } from "../../../../math/utils/random/randfloat.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { EqualNode } from "../../../../tree/nodes/equations/equalNode.js";
+import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
+import { isNumberNode } from "../../../../tree/nodes/numbers/numberNode.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { frac, isFractionNode, } from "../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { VariableNode } from "../../../../tree/nodes/variables/variableNode.js";
+import { parseLatex } from "../../../../tree/parsers/latexParser.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { random } from "../../../../utils/alea/random.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+import { joinanded } from "../../../../utils/strings/joinanded.js";
+const varNames = ["x", "y", "z", "t", "u", "v"];
+const getPropositions = (_, { answer }) => {
+    const propositions = [];
+    ["Oui", "Non"].forEach((strYN) => {
+        if (strYN === answer) {
+            addValidProp(propositions, strYN);
+        }
+        else {
+            tryToAddWrongProp(propositions, strYN);
+        }
+    });
+    return propositions;
+};
+const getAnswer = (identifiers) => {
+    const { isEqual } = identifiers;
+    return isEqual ? "Oui" : "Non";
+};
+const getInstruction = (identifiers) => {
+    const { evaluationDict, equalNodeIds } = identifiers;
+    const equalNode = NodeConstructor.fromIdentifiers(equalNodeIds);
+    const strEvaluation = `${joinanded(Object.entries(evaluationDict).map(([varName, nodeIds]) => {
+        const node = NodeConstructor.fromIdentifiers(nodeIds);
+        return `$${varName} = ${node.toTex()}$`;
+    }), ", ", " et ")}`;
+    return `En considérant l'équation ci-dessous, l'égalité est-elle vérifiée pour ${strEvaluation} ? 
+  
+$$
+${equalNode.toTex()}
+$$
+
+`;
+};
+const getHint = () => {
+    return `L'expression $3x$ vaut $3,3$ pour $x = 1,1$.`;
+};
+const getCorrection = (identifiers) => {
+    const { evaluationDict, equalNodeIds, isEqual } = identifiers;
+    const evaluationEntries = Object.entries(evaluationDict).map(([varName, nodeIds]) => [
+        varName,
+        NodeConstructor.fromIdentifiers(nodeIds),
+    ]);
+    const equalNode = NodeConstructor.fromIdentifiers(equalNodeIds);
+    const [lhsNode, rhsNode] = [equalNode.leftChild, equalNode.rightChild];
+    const [evaluatedLhsNode, evaluatedRhsNode] = [lhsNode, rhsNode].map((nodeCarrier) => evaluationEntries.reduce((acc, [varName, nodeInjected]) => nodeBySubstitutingVar(acc, nodeInjected, new VariableNode(varName)), nodeCarrier));
+    return `Pour tester si l'égalité est vérifiée, on évalue chaque membre de l'équation.
+  
+On évalue le membre de gauche : 
+
+${alignTex([
+        ["", lhsNode.toTex()],
+        ["=", evaluatedLhsNode.toTex()],
+        [
+            "=",
+            (() => {
+                const evLhsAsAddNode = evaluatedLhsNode;
+                return add(evLhsAsAddNode.leftChild.simplify(), evLhsAsAddNode.rightChild);
+            })().toTex(),
+        ],
+        ["=", evaluatedLhsNode.simplify().toTex()],
+    ])}
+
+On évalue le membre de droite : 
+
+${alignTex([
+        ["", rhsNode.toTex()],
+        ["=", evaluatedRhsNode.toTex()],
+        [
+            "=",
+            (() => {
+                const evRhsAsAddNode = evaluatedRhsNode;
+                return add(evRhsAsAddNode.leftChild.simplify(), evRhsAsAddNode.rightChild);
+            })().toTex(),
+        ],
+        ["=", evaluatedRhsNode.simplify().toTex()],
+    ])}
+
+${isEqual
+        ? `Les deux valeurs sont égales donc l'égalité est vérifiée.`
+        : `Les deux valeurs sont différentes. L'égalité n'est pas vérifiée.`}
+
+`;
+};
+const getKeys = () => {
+    return [];
+};
+const getIsEqualityTrue1Question = (optsIn) => {
+    const arrayedOptions = optsIn ?? optsDefault;
+    const opts = {
+        typeCoeff: random(arrayedOptions.typeCoeff),
+        typeTestValue: random(arrayedOptions.typeTestValue),
+    };
+    const roundDecimalTo = 1;
+    const varName = random(varNames);
+    function getRandomIntNode(excludes = []) {
+        let outNode = (1).toTree();
+        let counter = -1;
+        let isFound = false;
+        while (!isFound && counter < 100) {
+            counter++;
+            const intExcludes = excludes
+                .filter((node) => isNumberNode(node))
+                .map((node) => node.evaluate())
+                .filter((value) => value % 1 === 0);
+            let n;
+            try {
+                n = randint(-9, 10, intExcludes);
+            }
+            catch (_) {
+                (() => { })();
+            }
+            if (n) {
+                outNode = n.toTree();
+                isFound = true;
+            }
+        }
+        return outNode;
+    }
+    function getRandomFractionNode(excludes = []) {
+        let outNode = (1).toTree();
+        let counter = -1;
+        let isFound = false;
+        while (!isFound && counter < 100) {
+            counter++;
+            const num = randint(-9, 10);
+            const den = randint(0, 10, [0, num]);
+            const fractionNode = frac(num, den);
+            const isExcluded = excludes.some((excludedNode) => substract(excludedNode, fractionNode).evaluate() === 0);
+            if (!isExcluded) {
+                outNode = fractionNode;
+                isFound = true;
+            }
+        }
+        return outNode;
+    }
+    function getRandomDecimalNode(excludes = [], roundTo) {
+        let outNode = (1).toTree();
+        let counter = -1;
+        let isFound = false;
+        while (!isFound && counter < 100) {
+            counter++;
+            const decimalNode = randfloat(-10, 10, roundTo).toTree();
+            const isExcluded = excludes.some((excludedNode) => substract(excludedNode, decimalNode).evaluate() === 0);
+            if (!isExcluded) {
+                outNode = decimalNode;
+                isFound = true;
+            }
+        }
+        return outNode;
+    }
+    function getRandomNode(typeCoeff, excludes = []) {
+        switch (typeCoeff) {
+            case "Fraction":
+                return getRandomFractionNode(excludes);
+            case "Décimal": {
+                return getRandomDecimalNode(excludes, roundDecimalTo);
+            }
+            case "Entier":
+            default:
+                return getRandomIntNode(excludes);
+        }
+    }
+    function createRandomIdentifiers() {
+        const [a, b] = [
+            getRandomNode(opts.typeCoeff),
+            getRandomNode(opts.typeCoeff),
+        ];
+        const [c, d] = [
+            getRandomNode(opts.typeCoeff, [a]),
+            getRandomNode(opts.typeCoeff),
+        ];
+        const lhsNode = add(multiply(a, varName.toTree()), b);
+        const rhsNode = add(multiply(c, varName.toTree()), d);
+        const equalNode = new EqualNode(lhsNode, rhsNode);
+        //ax+b=cx+d
+        //x=(d-b)/(a-c)
+        const solutionNode = frac(substract(d, b), substract(a, c)).simplify();
+        const isEqual = coinFlip();
+        const evaluationDict = {};
+        if (isEqual) {
+            let isSalvation = true;
+            switch (opts.typeTestValue) {
+                case "Entier":
+                    {
+                        const value = solutionNode.evaluate();
+                        const isInteger = value % 1 === 0;
+                        if (isInteger) {
+                            evaluationDict[varName] = value.toTree().toIdentifiers();
+                        }
+                        else {
+                            isSalvation = false;
+                        }
+                    }
+                    break;
+                case "Décimal":
+                    {
+                        const value = solutionNode.evaluate();
+                        const strValue = value.toString();
+                        const isDecimalWithNbDigits = strValue.split(".")?.[1]?.length === roundDecimalTo;
+                        if (isDecimalWithNbDigits) {
+                            evaluationDict[varName] = value.toTree().toIdentifiers();
+                        }
+                        else {
+                            isSalvation = false;
+                        }
+                    }
+                    break;
+                case "Fraction": {
+                    if (isFractionNode(solutionNode)) {
+                        evaluationDict[varName] = solutionNode.toIdentifiers();
+                    }
+                    else {
+                        isSalvation = false;
+                    }
+                }
+            }
+            if (!isSalvation) {
+                return null;
+            }
+        }
+        else {
+            const missNode = getRandomNode(opts.typeTestValue, [solutionNode]);
+            evaluationDict[varName] = missNode.toIdentifiers();
+        }
+        const identifiers = {
+            evaluationDict,
+            equalNodeIds: equalNode.toIdentifiers(),
+            isEqual,
+        };
+        return identifiers;
+    }
+    let identifiers;
+    let counter = -1;
+    while (!identifiers && counter < 100) {
+        counter++;
+        identifiers = createRandomIdentifiers();
+    }
+    const defaultIdentifiers = {
+        evaluationDict: { x: (0).toTree().toIdentifiers() },
+        equalNodeIds: parseLatex("3x+4=-5x+4").toIdentifiers(),
+        isEqual: true,
+    };
+    return getQuestionFromIdentifiers(identifiers ?? defaultIdentifiers, opts);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        answer: getAnswer(identifiers, opts),
+        instruction: getInstruction(identifiers, opts),
+        keys: getKeys(identifiers, opts),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+        options: opts,
+    };
+    return question;
+};
+const optsDefault = {
+    typeCoeff: ["Entier"],
+    typeTestValue: ["Entier", "Fraction", "Décimal"],
+};
+const options = [
+    {
+        id: "typeCoeff",
+        label: "Type des coefficients",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        values: ["Entier", "Fraction", "Décimal"],
+        defaultValue: optsDefault.typeCoeff,
+    },
+    {
+        id: "typeTestValue",
+        label: "Type des valeurs de test",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        values: ["Entier", "Fraction", "Décimal"],
+        defaultValue: optsDefault.typeTestValue,
+    },
+];
+export const isEqualityTrue1 = {
+    id: "isEqualityTrue1",
+    label: "Tester une égalité pour une certaine valeur de la variable",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getIsEqualityTrue1Question(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    answerType: "QCU",
+    hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
+};

package/lib/exercises/math/dataRepresentations/compareBoxPlot.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compareBoxPlot.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/dataRepresentations/compareBoxPlot.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,OAAO,CAAC;IAChB,UAAU,EAAE,OAAO,EAAE,CAAC;CACvB,CAAC;AAKF,KAAK,OAAO,GAAG;IACb,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB,CAAC;AAmQF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAmBhD,CAAC"}
+{"version":3,"file":"compareBoxPlot.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/dataRepresentations/compareBoxPlot.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,OAAO,CAAC;IAChB,UAAU,EAAE,OAAO,EAAE,CAAC;CACvB,CAAC;AAKF,KAAK,OAAO,GAAG;IACb,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB,CAAC;AA8PF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAmBhD,CAAC"}

package/lib/exercises/math/dataRepresentations/compareBoxPlot.js

@@ -128,10 +128,6 @@ const getGGBOptions = (identifiers) => {
         coords: [xMin - 5, xMax + 5, yMin - 5, yMax + 5],
     });
 };
-const isAnswerValid = (ans, { answer }) => {
-    const ansRefined = ans.split(";").toSorted().join(";");
-    return ansRefined === answer;
-};
 const getBoxPlotReadingQuestion = () => {
     const nbDistri = 2;
     const nbInAnswer = 1;
@@ -183,7 +179,6 @@ export const compareBoxPlot = {
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
-    isAnswerValid,
     subject: "Mathématiques",
     getHint,
     getCorrection,
@@ -193,4 +188,5 @@ export const compareBoxPlot = {
     hasGeogebra: true,
     getQuestionFromIdentifiers,
     hasHintAndCorrection: true,
+    answerType: "QCU",
 };

package/lib/exercises/math/geometry/cartesian/index.d.ts

@@ -11,6 +11,7 @@ export * from "./readAbscissOnLine.js";
 export * from "./readAbscissOnSemiLine.js";
 export * from "./placeAbscissOnLine.js";
 export * from "./placeAbscissOnSemiLine.js";
+export * from "./placeAbscissOnSemiLineV2.js";
 export * from "./cartesianFromVectorAndPoint.js";
 export * from "./cartesianFromTwoPoints.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/geometry/cartesian/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/cartesian/index.ts"],"names":[],"mappings":"AAAA,cAAc,+BAA+B,CAAC;AAC9C,cAAc,eAAe,CAAC;AAC9B,cAAc,8BAA8B,CAAC;AAC7C,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,qBAAqB,CAAC;AACpC,cAAc,kBAAkB,CAAC;AACjC,cAAc,oCAAoC,CAAC;AAEnD,cAAc,wBAAwB,CAAC;AACvC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,yBAAyB,CAAC;AACxC,cAAc,6BAA6B,CAAC;AAE5C,cAAc,kCAAkC,CAAC;AACjD,cAAc,6BAA6B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/cartesian/index.ts"],"names":[],"mappings":"AAAA,cAAc,+BAA+B,CAAC;AAC9C,cAAc,eAAe,CAAC;AAC9B,cAAc,8BAA8B,CAAC;AAC7C,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,qBAAqB,CAAC;AACpC,cAAc,kBAAkB,CAAC;AACjC,cAAc,oCAAoC,CAAC;AAEnD,cAAc,wBAAwB,CAAC;AACvC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,yBAAyB,CAAC;AACxC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,kCAAkC,CAAC;AACjD,cAAc,6BAA6B,CAAC"}

package/lib/exercises/math/geometry/cartesian/index.js

@@ -12,6 +12,6 @@ export * from "./readAbscissOnLine.js";
 export * from "./readAbscissOnSemiLine.js";
 export * from "./placeAbscissOnLine.js";
 export * from "./placeAbscissOnSemiLine.js";
-// export * from "./placeAbscissOnSemiLineV2.js";
+export * from "./placeAbscissOnSemiLineV2.js";
 export * from "./cartesianFromVectorAndPoint.js";
 export * from "./cartesianFromTwoPoints.js";

package/lib/exercises/math/geometry/cartesian/placeAbscissOnSemiLineV2.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"placeAbscissOnSemiLineV2.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/cartesian/placeAbscissOnSemiLineV2.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAQrC,OAAO,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAK1D,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAK7C,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,UAAU,CAAC;IACxB,QAAQ,EAAE,eAAe,CAAC;IAC1B,QAAQ,EAAE,eAAe,CAAC;IAC1B,QAAQ,EAAE,eAAe,CAAC;CAC3B,CAAC;AAiOF,KAAK,OAAO,GAAG;IACb,YAAY,EAAE,UAAU,GAAG,oBAAoB,CAAC;IAChD,UAAU,EAAE,SAAS,GAAG,YAAY,GAAG,UAAU,CAAC;CACnD,CAAC;AA6BF,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAanE,CAAC"}
+{"version":3,"file":"placeAbscissOnSemiLineV2.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/cartesian/placeAbscissOnSemiLineV2.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAOrC,OAAO,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAK1D,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAK7C,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,UAAU,CAAC;IACxB,QAAQ,EAAE,eAAe,CAAC;IAC1B,QAAQ,EAAE,eAAe,CAAC;IAC1B,QAAQ,EAAE,eAAe,CAAC;CAC3B,CAAC;AAwNF,KAAK,OAAO,GAAG;IACb,YAAY,EAAE,UAAU,GAAG,oBAAoB,CAAC;IAChD,UAAU,EAAE,SAAS,GAAG,YAAY,GAAG,UAAU,CAAC;CACnD,CAAC;AA6BF,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAanE,CAAC"}

package/lib/exercises/math/geometry/cartesian/placeAbscissOnSemiLineV2.js

@@ -2,7 +2,6 @@ import { GeneratorOptionTarget, GeneratorOptionType, } from "../../../../exercis
 import { toolBarConstructor } from "../../../../exercises/utils/geogebra/toolBarConstructor.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
-import { GeogebraParser } from "../../../../geogebra/parsers/geogebraParser.js";
 import { ggbPointToCoords } from "../../../../geogebra/parsers/ggbPointToCoords.js";
 import { parseGGBPoints } from "../../../../geogebra/parsers/parseGGBPoints.js";
 import { Point } from "../../../../math/geometry/point.js";
@@ -81,18 +80,12 @@ const getStudentGGBOptions = ({ abscissType, absciss1, axisUnit, absciss2, }) =>
 };
 const isGGBAnswerValid = (ans, { absciss2, axisUnit }) => {
     const [absciss2Node, axisUnitNode] = [absciss2, axisUnit].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
-    const commands = ans;
-    const dictObj = new GeogebraParser(commands).objectDict();
-    const strPointA = dictObj["A"];
-    if (!strPointA) {
-        return false;
-    }
-    const coordsA = ggbPointToCoords(strPointA);
-    const points = parseGGBPoints(ans).map((p) => ggbPointToCoords(p));
-    return (points.length === 3 && //O,I,A
+    const arrCoords = parseGGBPoints(ans).map((p) => ggbPointToCoords(p));
+    const coordsA = arrCoords[0];
+    return (arrCoords.length === 1 &&
         Math.abs(coordsA.y) < 0.5 * axisUnitNode.evaluate() &&
         Math.abs(coordsA.x - absciss2Node.evaluate()) <
-            0.1 * axisUnitNode.evaluate());
+            0.2 * axisUnitNode.evaluate());
 };
 const getPlaceAbscissOnSemiLineV2Question = (optsIn) => {
     const arrayedOptions = optsIn ?? optsDefault;

package/lib/exercises/math/geometry/euclidianConstructions/index.d.ts

@@ -2,4 +2,6 @@ export * from "./buildMediatriceWithCompass.js";
 export * from "./buildTriangleWithSizes.js";
 export * from "./pointImageFromTranslation.js";
 export * from "./buildPointFromAxialSymetry.js";
+export * from "./pointImageFromHomothety.js";
+export * from "./segmentImageFromHomothety.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/geometry/euclidianConstructions/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/euclidianConstructions/index.ts"],"names":[],"mappings":"AAAA,cAAc,iCAAiC,CAAC;AAChD,cAAc,6BAA6B,CAAC;AAC5C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,iCAAiC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/euclidianConstructions/index.ts"],"names":[],"mappings":"AAAA,cAAc,iCAAiC,CAAC;AAChD,cAAc,6BAA6B,CAAC;AAC5C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,iCAAiC,CAAC;AAChD,cAAc,8BAA8B,CAAC;AAC7C,cAAc,gCAAgC,CAAC"}

package/lib/exercises/math/geometry/euclidianConstructions/index.js

@@ -2,5 +2,5 @@ export * from "./buildMediatriceWithCompass.js";
 export * from "./buildTriangleWithSizes.js";
 export * from "./pointImageFromTranslation.js";
 export * from "./buildPointFromAxialSymetry.js";
-// export * from "./pointImageFromHomothety.js";
-// export * from "./segmentImageFromHomothety.js";
+export * from "./pointImageFromHomothety.js";
+export * from "./segmentImageFromHomothety.js";

package/lib/exercises/math/probaStat/basicProbas/possibleValuesForProba.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"possibleValuesForProba.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/basicProbas/possibleValuesForProba.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAUrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAW7C,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,eAAe,EAAE,CAAC;IAClC,qBAAqB,EAAE,OAAO,CAAC;CAChC,CAAC;AA2EF,KAAK,OAAO,GAAG;IACb,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB,CAAC;AAuNF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAgBjE,CAAC"}
+{"version":3,"file":"possibleValuesForProba.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/basicProbas/possibleValuesForProba.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAUrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAW7C,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,eAAe,EAAE,CAAC;IAClC,qBAAqB,EAAE,OAAO,CAAC;CAChC,CAAC;AA2EF,KAAK,OAAO,GAAG;IACb,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB,CAAC;AA6OF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAgBjE,CAAC"}

package/lib/exercises/math/probaStat/basicProbas/possibleValuesForProba.js

@@ -235,6 +235,26 @@ const getPossibleValuesForProbaQuestion = (optsIn) => {
                 .length === 2;
     }
     arrNode = shuffle(arrNode);
+    //fix prevent everything to be false
+    //{
+    function isPossibleProba(node) {
+        const value = node.evaluate();
+        return 0 <= value && value <= 1;
+    }
+    function isInvalidNode(node) {
+        return (isFilterPossibleProba ? (x) => !x : (x) => x)(isPossibleProba(node));
+    }
+    const isEverythingFalse = arrNode.every(isInvalidNode);
+    if (isEverythingFalse) {
+        arrNode.pop();
+        if (isFilterPossibleProba) {
+            arrNode.push((1).toTree());
+        }
+        else {
+            arrNode.push((-1).toTree());
+        }
+    }
+    //}
     const identifiers = {
         arrayOfNodeIds: arrNode.map((node) => node.toIdentifiers()),
         isFilterPossibleProba,

package/lib/index.d.ts

@@ -49,6 +49,10 @@ declare const mathExercises: (Exercise<{
 }, Record<string, string | boolean | string[]>> | Exercise<{
     a: number;
     b: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    nb: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    nbs: number[];
 }, Record<string, string | boolean | string[]>> | Exercise<{
     integerFirst: boolean;
     integer: number;
@@ -490,6 +494,13 @@ declare const mathExercises: (Exercise<{
     shuffleArrays: number[][];
     equalNodeIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
 }, Record<string, string | boolean | string[]>> | Exercise<{
+    evaluationDict: Record<string, import("./tree/nodes/nodeConstructor.js").NodeIdentifiers>;
+    equalNodeIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    isEqual: boolean;
+}, {
+    typeCoeff: "Entier" | "Fraction" | "D\u00E9cimal";
+    typeTestValue: "Entier" | "Fraction" | "D\u00E9cimal";
+}> | Exercise<{
     a: number;
     b: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
@@ -1607,6 +1618,14 @@ declare const mathExercises: (Exercise<{
     abscissTex: string;
     coeff: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
+    abscissType: import("./math/numbers/nombre.js").NumberType;
+    axisUnit: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    absciss1: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    absciss2: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+}, {
+    questionType: "standard" | "\u00E9viter le comptage";
+    numberType: "Entiers" | "Rationnels" | "D\u00E9cimaux";
+}> | Exercise<{
     vectorIdentifiers: import("./math/geometry/vector.js").VectorIdentifiers;
     pointIdentifiers: import("./math/geometry/point.js").PointIdentifiers;
 }, Record<string, string | boolean | string[]>> | Exercise<{
@@ -1893,6 +1912,22 @@ declare const mathExercises: (Exercise<{
     point: import("./math/geometry/point.js").PointIdentifiers;
     line: import("./math/geometry/line.js").LineIdentifiers;
 }, Record<string, string | boolean | string[]>> | Exercise<{
+    pointsDict: Record<string, import("./math/geometry/point.js").PointIdentifiers>;
+    nameTargetPoint: string;
+    nameCenterPoint: string;
+    factor: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+}, {
+    isPositiveFactorOnly: boolean;
+    factorTypes: string[];
+}> | Exercise<{
+    pointsDict: Record<string, import("./math/geometry/point.js").PointIdentifiers>;
+    nameTargetPoints: string[];
+    nameCenterPoint: string;
+    factor: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+}, {
+    isPositiveFactorOnly: boolean;
+    factorTypes: string[];
+}> | Exercise<{
     type: number;
     commands: string[];
 }, Record<string, string | boolean | string[]>> | Exercise<{

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/nodes/operators/powerNode.d.ts

@@ -1,5 +1,7 @@
 import { Node, NodeIds, NodeOptions, NodeType, ToTexOptions } from "../node.js";
 import { OperatorIds, OperatorNode } from "./operatorNode.js";
+import { NumberNode } from "../numbers/numberNode.js";
+import { MultiplyNode } from "./multiplyNode.js";
 import { AlgebraicNode, SimplifyOptions } from "../algebraicNode.js";
 export declare function isPowerNode(a: Node): a is PowerNode;
 export declare function isSquareNode(a: Node): a is SquareNode;
@@ -31,6 +33,7 @@ export declare class PowerNode implements OperatorNode {
     simplify(opts?: SimplifyOptions, _log?: boolean): AlgebraicNode;
     equals(node: AlgebraicNode): boolean;
     derivative(varName?: string | undefined): AlgebraicNode;
+    toMultiplyNode(): AlgebraicNode | import("../numbers/constantNode.js").ConstantNode | NumberNode | MultiplyNode;
 }
 export declare class SquareNode extends PowerNode {
     constructor(child: AlgebraicNode, opts?: NodeOptions);

package/lib/tree/nodes/operators/powerNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"powerNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/powerNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAChF,OAAO,EAAE,WAAW,EAAE,YAAY,EAAkB,MAAM,mBAAmB,CAAC;AAG9E,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAMrE,wBAAgB,WAAW,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,SAAS,CAEnD;AAED,wBAAgB,YAAY,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,UAAU,CAErD;AACD,eAAO,MAAM,MAAM,GAAI,GAAG,aAAa,GAAG,MAAM,GAAG,MAAM,eAKxD,CAAC;AAEF,eAAO,MAAM,KAAK,GAChB,GAAG,aAAa,GAAG,MAAM,GAAG,MAAM,EAClC,GAAG,aAAa,GAAG,MAAM,GAAG,MAAM,EAClC,OAAO,WAAW,cAOnB,CAAC;AAEF,qBAAa,SAAU,YAAW,YAAY;IAC5C,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,EAAE,EAAE,WAAW,CAAC;IAChB,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,aAAa,CAAC;IAC1B,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;gBAEjB,SAAS,EAAE,aAAa,EACxB,UAAU,EAAE,aAAa,EACzB,IAAI,CAAC,EAAE,WAAW;IAUpB,YAAY,IAAI,MAAM;IAGtB,aAAa;;;;;;;;;IAOb,iBAAiB;IAqBjB,cAAc,IAAI,MAAM,EAAE;IAI1B,KAAK,CAAC,IAAI,CAAC,EAAE,YAAY,GAAG,MAAM;IA0BlC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAMtC,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAOxD,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe,EAAE,IAAI,UAAQ,GAAG,aAAa;IA6D7D,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAOpC,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,aAAa;CAcxD;AAED,qBAAa,UAAW,SAAQ,SAAS;gBAC3B,KAAK,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,WAAW;CAIrD"}
+{"version":3,"file":"powerNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/powerNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAChF,OAAO,EAAE,WAAW,EAAE,YAAY,EAAkB,MAAM,mBAAmB,CAAC;AAC9E,OAAO,EAAE,UAAU,EAAgB,MAAM,0BAA0B,CAAC;AACpE,OAAO,EAAE,YAAY,EAA4B,MAAM,mBAAmB,CAAC;AAC3E,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAOrE,wBAAgB,WAAW,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,SAAS,CAEnD;AAED,wBAAgB,YAAY,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,UAAU,CAErD;AACD,eAAO,MAAM,MAAM,GAAI,GAAG,aAAa,GAAG,MAAM,GAAG,MAAM,eAKxD,CAAC;AAEF,eAAO,MAAM,KAAK,GAChB,GAAG,aAAa,GAAG,MAAM,GAAG,MAAM,EAClC,GAAG,aAAa,GAAG,MAAM,GAAG,MAAM,EAClC,OAAO,WAAW,cAOnB,CAAC;AAEF,qBAAa,SAAU,YAAW,YAAY;IAC5C,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,EAAE,EAAE,WAAW,CAAC;IAChB,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,aAAa,CAAC;IAC1B,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;gBAEjB,SAAS,EAAE,aAAa,EACxB,UAAU,EAAE,aAAa,EACzB,IAAI,CAAC,EAAE,WAAW;IAUpB,YAAY,IAAI,MAAM;IAGtB,aAAa;;;;;;;;;IAOb,iBAAiB;IAqBjB,cAAc,IAAI,MAAM,EAAE;IAI1B,KAAK,CAAC,IAAI,CAAC,EAAE,YAAY,GAAG,MAAM;IA0BlC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAMtC,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAOxD,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe,EAAE,IAAI,UAAQ,GAAG,aAAa;IA6D7D,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAOpC,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,aAAa;IAcvD,cAAc;CASf;AAED,qBAAa,UAAW,SAAQ,SAAS;gBAC3B,KAAK,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,WAAW;CAIrD"}

package/lib/tree/nodes/operators/powerNode.js

@@ -7,6 +7,7 @@ import { isSqrtNode } from "../functions/sqrtNode.js";
 import { round } from "../../../math/utils/round.js";
 import { FractionNode, isFractionNode } from "./fractionNode.js";
 import { FunctionsIds, isFunctionNode } from "../functions/functionNode.js";
+import { operatorComposition } from "../../../tree/utilities/operatorComposition.js";
 export function isPowerNode(a) {
     return isOperatorNode(a) && a.id === OperatorIds.power;
 }
@@ -156,6 +157,17 @@ export class PowerNode {
             throw Error("unimplemented");
         return multiply(multiply(this.rightChild, power(this.leftChild, this.rightChild.value - 1)), this.leftChild.derivative(varName));
     }
+    toMultiplyNode() {
+        if (this.rightChild.evaluate() === 1)
+            return this.leftChild;
+        if (this.rightChild.evaluate() === 0)
+            return (1).toTree();
+        const lefts = [];
+        for (let i = 0; i < this.rightChild.evaluate(); i++) {
+            lefts.push(this.leftChild);
+        }
+        return operatorComposition(MultiplyNode, lefts);
+    }
 }
 export class SquareNode extends PowerNode {
     constructor(child, opts) {

package/lib/utils/strings/joinanded.d.ts

@@ -1,2 +1,2 @@
-export declare const joinanded: (arrStr: string[], separator: string, lastSeparator: string) => string;
+export declare const joinanded: (arrStr: string[], separator?: string, lastSeparator?: string) => string;
 //# sourceMappingURL=joinanded.d.ts.map

package/lib/utils/strings/joinanded.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"joinanded.d.ts","sourceRoot":"","sources":["../../../src/utils/strings/joinanded.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,SAAS,GACpB,QAAQ,MAAM,EAAE,EAChB,WAAW,MAAM,EACjB,eAAe,MAAM,WAWtB,CAAC"}
+{"version":3,"file":"joinanded.d.ts","sourceRoot":"","sources":["../../../src/utils/strings/joinanded.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,SAAS,GACpB,QAAQ,MAAM,EAAE,EAChB,YAAW,MAAa,EACxB,gBAAe,MAAe,WAW/B,CAAC"}

package/lib/utils/strings/joinanded.js

@@ -1,4 +1,4 @@
-export const joinanded = (arrStr, separator, lastSeparator) => {
+export const joinanded = (arrStr, separator = ", ", lastSeparator = " et ") => {
     if (arrStr.length === 0) {
         return "";
     }

package/package.json

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