math-exercises 3.0.138 → 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/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;

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.138",
+  "version": "3.0.139",
   "description": "Math exercises generator for middle school and high school",
   "main": "lib/index.js",
   "files": [