math-exercises 3.0.78 → 3.0.80

package/lib/exercises/math/probaStat/describeEvent.js

@@ -0,0 +1,182 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { coinFlip } from "../../../utils/alea/coinFlip.js";
+import { random } from "../../../utils/alea/random.js";
+import { handleVEAError } from "../../../utils/errors/handleVEAError.js";
+const getPropositions = (n, { answer, eventA, eventB, question }) => {
+    const propositions = [];
+    addValidProp(propositions, answer, "raw");
+    const flipComplement = (event) => ({
+        desc: event.desc,
+        isComplementary: !event.isComplementary,
+    });
+    const generateWrongAnswer = () => {
+        const templates = [
+            () => {
+                const descA = flipComplement(eventA).isComplementary
+                    ? `ne pas ${eventA.desc}`
+                    : eventA.desc;
+                const descB = eventB.isComplementary
+                    ? `ne pas ${eventB.desc}`
+                    : eventB.desc;
+                return `${descA} et ${descB}`;
+            },
+            () => {
+                const descA = eventA.isComplementary
+                    ? `ne pas ${eventA.desc}`
+                    : eventA.desc;
+                const descB = flipComplement(eventB).isComplementary
+                    ? `ne pas ${eventB.desc}`
+                    : eventB.desc;
+                return `${descA} ou ${descB}`;
+            },
+            () => {
+                const descA = flipComplement(eventA).isComplementary
+                    ? `ne pas ${eventA.desc}`
+                    : eventA.desc;
+                const descB = flipComplement(eventB).isComplementary
+                    ? `ne pas ${eventB.desc}`
+                    : eventB.desc;
+                const op = coinFlip() ? "et" : "ou";
+                return `${descA} ${op} ${descB}`;
+            },
+            () => {
+                const descA1 = eventA.isComplementary
+                    ? `ne pas ${eventA.desc}`
+                    : eventA.desc;
+                const descA2 = flipComplement(eventA).isComplementary
+                    ? `ne pas ${eventA.desc}`
+                    : eventA.desc;
+                const op = coinFlip() ? "et" : "ou";
+                return `${descA1} ${op} ${descA2}`;
+            },
+            () => {
+                return `ne pas ne pas ${eventA.desc}`.replace("ne pas ne pas", eventA.desc);
+            },
+        ];
+        return random(templates)();
+    };
+    while (propositions.length < n) {
+        const wrong = generateWrongAnswer();
+        tryToAddWrongProp(propositions, wrong, "raw");
+    }
+    return shuffleProps(propositions, n);
+};
+const getAnswer = ({ eventA, eventB, question }) => {
+    const describe = (e) => e.isComplementary ? `ne pas ${e.desc}` : `${e.desc}`;
+    if (question === "comp") {
+        return `ne pas ${eventA.desc}`;
+    }
+    else if (question === "union") {
+        return `${describe(eventA)} ou ${describe(eventB)}`;
+    }
+    else {
+        return `${describe(eventA)} et ${describe(eventB)}`;
+    }
+};
+const getInstruction = (identifiers) => {
+    const { eventA, eventB, question } = identifiers;
+    let instruction = `$A$ est l'évènement "${eventA.desc}" et $B$ est l'évènement "${eventB.desc}".\n\n`;
+    if (question === "comp") {
+        return instruction + `Décrire par une phrase l'évènement $\\overline{A}$.`;
+    }
+    const overlineA = eventA.isComplementary ? "\\overline{A}" : "A";
+    const overlineB = eventB.isComplementary ? "\\overline{B}" : "B";
+    const operator = question === "union" ? "\\cup" : "\\cap";
+    return (instruction +
+        `Décrire par une phrase l'évènement $${overlineA} ${operator} ${overlineB}$.`);
+};
+const getHint = ({ question }) => {
+    switch (question) {
+        case "comp":
+            return `Le contraire ($\\overline{A})$ d'un évènement $A$ signifie que l'évènement ne se réalise pas.`;
+        case "union":
+            return `L'union ($\\cup$) de deux événements signifie que l'un ou l'autre des évènements (ou les deux) se réalisent.`;
+        case "intersection":
+            return `L'intersection ($\\cap$) de deux événements signifie que les deux évènements se réalisent en même temps.`;
+        default:
+            return "";
+    }
+};
+const getCorrection = (identifiers) => {
+    const { eventA, eventB, question } = identifiers;
+    const answer = getAnswer(identifiers);
+    if (question === "comp") {
+        return `Le contraire de l'évènement "${eventA.desc}" est l'évènement "${answer}".`;
+    }
+    else if (question === "union") {
+        return `L'union signifie que l'un ou l'autre (ou les deux) évènement(s) se produit : "${answer}".`;
+    }
+    else {
+        return `L'intersection signifie que les deux évènements se produisent en même temps : "${answer}".`;
+    }
+};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        throw Error("VEA not implemented");
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getDescribeEventQuestion = (ops) => {
+    const allEvents = [
+        "trouver des mures",
+        "trouver des fraises",
+        "trouver des pommes",
+        "perdre son parapluie",
+        "rater le bus",
+        "avoir un bonbon",
+        "avoir un bonbon au chocolat",
+        "avoir un bonbon à la menthe",
+        "avoir un bonbon à la fraise",
+    ];
+    const eventA = {
+        desc: random(allEvents),
+        isComplementary: coinFlip(),
+    };
+    const eventB = {
+        desc: random(allEvents.filter((e) => e !== eventA.desc)),
+        isComplementary: coinFlip(),
+    };
+    const questionTypes = [
+        "union",
+        "intersection",
+        "comp",
+    ];
+    const question = random(questionTypes);
+    const identifiers = { eventA, eventB, question };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "raw",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const describeEvent = {
+    id: "describeEvent",
+    label: "Décrire un évènement en une phrase à partir de sa notation",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getDescribeEventQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

package/lib/exercises/math/probaStat/getSampleCountAndSize.d.ts

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../exercises/exercise.js";
+type Identifiers = {
+    expCount: number;
+    repCount: number;
+    isSize: boolean;
+};
+export declare const getSampleCountAndSize: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=getSampleCountAndSize.d.ts.map

package/lib/exercises/math/probaStat/getSampleCountAndSize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getSampleCountAndSize.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/probaStat/getSampleCountAndSize.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,OAAO,CAAC;CACjB,CAAC;AA4FF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAiBvD,CAAC"}

package/lib/exercises/math/probaStat/getSampleCountAndSize.js

@@ -0,0 +1,95 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../math/utils/random/randint.js";
+import { parseAlgebraic } from "../../../tree/parsers/latexParser.js";
+import { coinFlip } from "../../../utils/alea/coinFlip.js";
+import { handleVEAError } from "../../../utils/errors/handleVEAError.js";
+const getPropositions = (n, { answer, expCount, isSize, repCount }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    tryToAddWrongProp(propositions, expCount.frenchify());
+    tryToAddWrongProp(propositions, repCount.frenchify());
+    while (propositions.length < n) {
+        let wrongValue;
+        wrongValue = randint(1, 200);
+        tryToAddWrongProp(propositions, wrongValue.frenchify());
+    }
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { expCount, repCount, isSize } = identifiers;
+    const answer = isSize ? expCount.frenchify() : repCount.frenchify();
+    return answer;
+};
+const getInstruction = (identifiers) => {
+    const { expCount, repCount, isSize } = identifiers;
+    const qst = isSize
+        ? "Quelle est la taille de chaque échantillon ?"
+        : "Quel est le nombre d'échantillons obtenus?";
+    return `On lance $${expCount}$ fois trois pièces simultanément.\n\n
+  On répète l'expérience $${repCount}$ fois.\n\n
+  ${qst}`;
+};
+const getHint = ({ isSize }) => {
+    return isSize
+        ? `La taille d'un échantillon correspond au nombre de répétitions à l'intérieur d'une même expérience.`
+        : `Le nombre d'échantillons correspond au nombre de fois qu'on répète l'expérience entière.`;
+};
+const getCorrection = ({ expCount, repCount, isSize, }) => {
+    if (isSize) {
+        return `Chaque fois qu'on répète l'expérience, on lance $${expCount}$ fois trois pièces.  
+La taille de chaque échantillon est donc $${expCount}$.`;
+    }
+    else {
+        return `On répète l'expérience complète $${repCount}$ fois.  
+On obtient donc $${repCount}$ échantillons.`;
+    }
+};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const ansNode = parseAlgebraic(ans);
+        const answerNode = parseAlgebraic(answer);
+        return answerNode.simplify().equals(ansNode.simplify());
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getGetSampleCountAndSizeQuestion = (ops) => {
+    const expCount = randint(1, 301);
+    const repCount = randint(1, 51);
+    const isSize = coinFlip();
+    const identifiers = { expCount, repCount, isSize };
+    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 getSampleCountAndSize = {
+    id: "getSampleCountAndSize",
+    label: "Distinguer taille et nombre d'échantillons",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getGetSampleCountAndSizeQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -1,3 +1,4 @@
+export * from "./averageLinearity.js";
 export * from "./ballsBasicProbas.js";
 export * from "./cardBasicProbas.js";
 export * from "./conditionalProbability.js";
@@ -18,4 +19,7 @@ export * from "./unionIntersectionProba.js";
 export * from "./calculateMeanFromFrequencies.js";
 export * from "./mostLeastProbable.js";
 export * from "./checkEquiprobability.js";
+export * from "./getSampleCountAndSize.js";
+export * from "./describeEvent.js";
+export * from "./cumulativeSum.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/probaStat/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,qBAAqB,CAAC;AACpC,cAAc,uBAAuB,CAAC;AACtC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,iCAAiC,CAAC;AAChD,cAAc,kCAAkC,CAAC;AACjD,cAAc,6BAA6B,CAAC;AAC5C,cAAc,mCAAmC,CAAC;AAClD,cAAc,wBAAwB,CAAC;AACvC,cAAc,2BAA2B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/probaStat/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,qBAAqB,CAAC;AACpC,cAAc,uBAAuB,CAAC;AACtC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,iCAAiC,CAAC;AAChD,cAAc,kCAAkC,CAAC;AACjD,cAAc,6BAA6B,CAAC;AAC5C,cAAc,mCAAmC,CAAC;AAClD,cAAc,wBAAwB,CAAC;AACvC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC"}

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

@@ -1,3 +1,4 @@
+export * from "./averageLinearity.js";
 export * from "./ballsBasicProbas.js";
 export * from "./cardBasicProbas.js";
 export * from "./conditionalProbability.js";
@@ -18,3 +19,6 @@ export * from "./unionIntersectionProba.js";
 export * from "./calculateMeanFromFrequencies.js";
 export * from "./mostLeastProbable.js";
 export * from "./checkEquiprobability.js";
+export * from "./getSampleCountAndSize.js";
+export * from "./describeEvent.js";
+export * from "./cumulativeSum.js";

package/lib/index.d.ts

@@ -41,6 +41,11 @@ declare const mathExercises: (Exercise<{
     n: number;
 }, {}> | Exercise<{
     a: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+}, {}> | Exercise<{
+    options: {
+        a: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+        isDecimal: boolean;
+    }[];
 }, {}> | Exercise<{
     a: number;
     b: number;
@@ -95,6 +100,9 @@ declare const mathExercises: (Exercise<{
     a: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
     b: number;
     c: number;
+}, {}> | Exercise<{
+    a: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    interval: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
 }, {}> | Exercise<{
     integerFirst: boolean;
     integer: number;
@@ -133,6 +141,9 @@ declare const mathExercises: (Exercise<{
 }> | Exercise<{
     num: number;
     denum: number;
+}, {}> | Exercise<{
+    num: number;
+    denum: number;
 }, {}> | Exercise<{
     num: number;
     denum: number;
@@ -295,6 +306,11 @@ declare const mathExercises: (Exercise<{
 }, {}> | Exercise<{
     dec: number;
     pow: number;
+}, {}> | Exercise<{
+    choices: {
+        node: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+        irrationalUsed: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers | null;
+    }[];
 }, {}> | Exercise<{
     a: number;
     sign: number;
@@ -1738,6 +1754,16 @@ declare const mathExercises: (Exercise<{
 }, {}> | Exercise<{
     kIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
     uCoeffs: number[];
+}, {}> | Exercise<{
+    kind: "factor";
+    a: number;
+    operator: "multiplication" | "division" | "soustraction" | "addition";
+    factor: number;
+} | {
+    kind: "series";
+    series: number[];
+    operator: "multiplication" | "division" | "soustraction" | "addition";
+    factor: number;
 }, {}> | Exercise<{
     repartitions: number[];
     colorAskedIndex: number;
@@ -1909,6 +1935,24 @@ declare const mathExercises: (Exercise<{
     total: number;
     distribution: number[];
     observe: boolean;
+}, {}> | Exercise<{
+    expCount: number;
+    repCount: number;
+    isSize: boolean;
+}, {}> | Exercise<{
+    eventA: {
+        desc: string;
+        isComplementary: boolean;
+    };
+    eventB: {
+        desc: string;
+        isComplementary: boolean;
+    };
+    question: "union" | "intersection" | "comp";
+}, {}> | Exercise<{
+    xVals: number[];
+    yVals: number[];
+    x: number;
 }, {}> | Exercise<{
     firstValue: number;
     askedRank: number;

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,KAAK,aAAa,MAAM,2BAA2B,CAAC;AAE3D,OAAO,4BAA4B,CAAC;AACpC,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAE/D,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,QAAQ,EAAE,QAAQ,EAAE,cAAc,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,KAAK,aAAa,MAAM,2BAA2B,CAAC;AAE3D,OAAO,4BAA4B,CAAC;AACpC,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAE/D,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,QAAQ,EAAE,QAAQ,EAAE,cAAc,EAAE,CAAC"}

package/lib/math/numbers/decimals/decimal.d.ts

@@ -31,7 +31,7 @@ export declare class Decimal implements Nombre {
     toScientificPart(): number;
     toScientificNotation(decimals?: number): NumberNode | MultiplyNode;
     getDigitAtRank(rank: number): number;
-    toRational(simplify?: boolean): Rational | import("../integer/integer.js").Integer;
+    toRational(shouldSimplify?: boolean): Rational | import("../integer/integer.js").Integer;
     toTree(): NumberNode;
     toPercentNode(): PercentNode;
     toLowerBound(tenthPower: number): Decimal;

package/lib/math/numbers/decimals/decimal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"decimal.d.ts","sourceRoot":"","sources":["../../../../src/math/numbers/decimals/decimal.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,UAAU,EAAE,MAAM,wCAAwC,CAAC;AACpE,OAAO,EAAE,WAAW,EAAE,MAAM,yCAAyC,CAAC;AACtE,OAAO,EAAE,YAAY,EAAE,MAAM,4CAA4C,CAAC;AAE1E,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAClD,OAAO,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAEpD,eAAO,MAAM,iBAAiB,UAAyC,CAAC;AACxE,8BAAsB,kBAAkB;IACtC,MAAM,CAAC,cAAc,CAAC,SAAS,EAAE,MAAM,EAAE,YAAY,GAAE,MAAU,GAAG,MAAM;IAY1E,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO;IAMpE,MAAM,CAAC,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO;IAK/D,MAAM,CAAC,gBAAgB,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO;CAMrD;AAED,qBAAa,OAAQ,YAAW,MAAM;IACpC,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,aAAsB;IAC1B,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,kBAAkB,EAAE,MAAM,CAAC;gBACf,KAAK,EAAE,MAAM,GAAG,MAAM;IASlC,KAAK,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM;IASxB,MAAM,CAAC,CAAC,EAAE,MAAM;IAIhB;;;;OAIG;IACH,KAAK,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM;IAIhC,oBAAoB,CAAC,KAAK,EAAE,MAAM;IAiClC,gBAAgB;IA6BhB,oBAAoB,CAAC,QAAQ,CAAC,EAAE,MAAM;IAuCtC,cAAc,CAAC,IAAI,EAAE,MAAM;IAS3B,UAAU,CAAC,QAAQ,CAAC,EAAE,OAAO;IAQ7B,MAAM;IAIN,aAAa;IAIb,YAAY,CAAC,UAAU,EAAE,MAAM;IAS/B,YAAY,CAAC,UAAU,EAAE,MAAM;CAShC"}
+{"version":3,"file":"decimal.d.ts","sourceRoot":"","sources":["../../../../src/math/numbers/decimals/decimal.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,UAAU,EAAE,MAAM,wCAAwC,CAAC;AACpE,OAAO,EAAE,WAAW,EAAE,MAAM,yCAAyC,CAAC;AACtE,OAAO,EAAE,YAAY,EAAE,MAAM,4CAA4C,CAAC;AAE1E,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAClD,OAAO,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAEpD,eAAO,MAAM,iBAAiB,UAAyC,CAAC;AACxE,8BAAsB,kBAAkB;IACtC,MAAM,CAAC,cAAc,CAAC,SAAS,EAAE,MAAM,EAAE,YAAY,GAAE,MAAU,GAAG,MAAM;IAY1E,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO;IAMpE,MAAM,CAAC,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO;IAK/D,MAAM,CAAC,gBAAgB,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO;CAMrD;AAED,qBAAa,OAAQ,YAAW,MAAM;IACpC,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,aAAsB;IAC1B,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,kBAAkB,EAAE,MAAM,CAAC;gBACf,KAAK,EAAE,MAAM,GAAG,MAAM;IASlC,KAAK,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM;IASxB,MAAM,CAAC,CAAC,EAAE,MAAM;IAIhB;;;;OAIG;IACH,KAAK,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM;IAIhC,oBAAoB,CAAC,KAAK,EAAE,MAAM;IAiClC,gBAAgB;IA6BhB,oBAAoB,CAAC,QAAQ,CAAC,EAAE,MAAM;IAuCtC,cAAc,CAAC,IAAI,EAAE,MAAM;IAS3B,UAAU,CAAC,cAAc,UAAO;IAQhC,MAAM;IAIN,aAAa;IAIb,YAAY,CAAC,UAAU,EAAE,MAAM;IAS/B,YAAY,CAAC,UAAU,EAAE,MAAM;CAShC"}

package/lib/math/numbers/decimals/decimal.js

@@ -173,11 +173,11 @@ export class Decimal {
             return Number(this.decimalPart[-rank - 1]);
         }
     }
-    toRational(simplify) {
-        const ratio = new Rational(this.multiplyByPowerOfTen(this.precision).value, 10 ** this.precision);
-        if (simplify)
-            return ratio.simplify();
-        return ratio;
+    toRational(shouldSimplify = true) {
+        const rational = new Rational(this.multiplyByPowerOfTen(this.precision).value, 10 ** this.precision);
+        if (shouldSimplify)
+            return rational.simplify();
+        return rational;
     }
     toTree() {
         return new NumberNode(this.value, this.tex);

package/lib/tree/nodes/numbers/numberNode.d.ts

@@ -1,6 +1,7 @@
 import { Node, NodeIds, NodeOptions, NodeType, ToTexOptions } from "../node.js";
 import { AlgebraicNode, SimplifyOptions } from "../algebraicNode.js";
 import { OppositeNode } from "../functions/oppositeNode.js";
+import { MultiplyNode } from "../operators/multiplyNode.js";
 export declare function isNumberNode(a: Node): a is NumberNode;
 export declare function isNumberOrOppositeNumberNode(a: Node): a is NumberNode | OppositeNode<NumberNode>;
 export declare abstract class NumberNodeConstructor {
@@ -28,6 +29,7 @@ export declare class NumberNode implements AlgebraicNode {
     equals(node: AlgebraicNode): boolean;
     toDetailedEvaluation(vars: Record<string, AlgebraicNode>): this;
     derivative(varName?: string | undefined): AlgebraicNode;
-    toFrac(): AlgebraicNode | NumberNode;
+    toFrac(shouldSimplify?: boolean): AlgebraicNode | NumberNode;
+    toPrimeDecomposition(usePowers?: boolean): AlgebraicNode | this | MultiplyNode;
 }
 //# sourceMappingURL=numberNode.d.ts.map

package/lib/tree/nodes/numbers/numberNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"numberNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/numbers/numberNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAChF,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAGrE,OAAO,EAAE,YAAY,EAAkB,MAAM,8BAA8B,CAAC;AAG5E,wBAAgB,YAAY,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,UAAU,CAErD;AACD,wBAAgB,4BAA4B,CAC1C,CAAC,EAAE,IAAI,GACN,CAAC,IAAI,UAAU,GAAG,YAAY,CAAC,UAAU,CAAC,CAE5C;AACD,8BAAsB,qBAAqB;IACzC,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,QAAQ,GAAE,MAAM,EAAO;CAGhE;AACD,qBAAa,UAAW,YAAW,aAAa;IAC9C,GAAG,EAAE,MAAM,CAAC;IACZ,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,QAAQ,CAAmB;IACjC,SAAS,EAAE,OAAO,CAAC;IACnB,IAAI,CAAC,EAAE,WAAW,CAAC;gBAEjB,KAAK,EAAE,MAAM,EACb,GAAG,CAAC,EAAE,MAAM,EACZ,UAAU,CAAC,EAAE,MAAM,EACnB,IAAI,CAAC,EAAE,WAAW;IASpB,YAAY,IAAI,MAAM;IAGtB,KAAK,CAAC,OAAO,CAAC,EAAE,YAAY,GAAG,MAAM;IAiBrC,QAAQ;IAGR,aAAa;;;;IAMb,cAAc;IAOd,iBAAiB;IAGjB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAGtC,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe,GAAG,aAAa;IAQ/C,MAAM,CAAC,IAAI,EAAE,aAAa;IAG1B,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAGxD,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,GACd,aAAa;IAGtC,MAAM;CAGP"}
+{"version":3,"file":"numberNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/numbers/numberNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAChF,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAGrE,OAAO,EAAE,YAAY,EAAkB,MAAM,8BAA8B,CAAC;AAM5E,OAAO,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAE5D,wBAAgB,YAAY,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,UAAU,CAErD;AACD,wBAAgB,4BAA4B,CAC1C,CAAC,EAAE,IAAI,GACN,CAAC,IAAI,UAAU,GAAG,YAAY,CAAC,UAAU,CAAC,CAE5C;AACD,8BAAsB,qBAAqB;IACzC,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,QAAQ,GAAE,MAAM,EAAO;CAGhE;AACD,qBAAa,UAAW,YAAW,aAAa;IAC9C,GAAG,EAAE,MAAM,CAAC;IACZ,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,QAAQ,CAAmB;IACjC,SAAS,EAAE,OAAO,CAAC;IACnB,IAAI,CAAC,EAAE,WAAW,CAAC;gBAEjB,KAAK,EAAE,MAAM,EACb,GAAG,CAAC,EAAE,MAAM,EACZ,UAAU,CAAC,EAAE,MAAM,EACnB,IAAI,CAAC,EAAE,WAAW;IASpB,YAAY,IAAI,MAAM;IAGtB,KAAK,CAAC,OAAO,CAAC,EAAE,YAAY,GAAG,MAAM;IAiBrC,QAAQ;IAGR,aAAa;;;;IAMb,cAAc;IAOd,iBAAiB;IAGjB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAGtC,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe,GAAG,aAAa;IAQ/C,MAAM,CAAC,IAAI,EAAE,aAAa;IAG1B,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAGxD,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,GACd,aAAa;IAGtC,MAAM,CAAC,cAAc,UAAO;IAI5B,oBAAoB,CAAC,SAAS,CAAC,EAAE,OAAO;CAsBzC"}

package/lib/tree/nodes/numbers/numberNode.js

@@ -4,6 +4,11 @@ import { colorize } from "../../../utils/latex/colorize.js";
 import { isOppositeNode } from "../functions/oppositeNode.js";
 import { Decimal } from "../../../math/numbers/decimals/decimal.js";
 import { round } from "../../../math/utils/round.js";
+import { isInt } from "../../../utils/isInt.js";
+import { power } from "../operators/powerNode.js";
+import { operatorComposition } from "../../../tree/utilities/operatorComposition.js";
+import { MultiplyNode } from "../operators/multiplyNode.js";
+import { primeDecomposition } from "../../../math/utils/arithmetic/primeDecomposition.js";
 export function isNumberNode(a) {
     return a.type === NodeType.number;
 }
@@ -83,7 +88,34 @@ export class NumberNode {
     derivative(varName) {
         return (0).toTree();
     }
-    toFrac() {
-        return new Decimal(this.value).toRational(true).toTree();
+    toFrac(shouldSimplify = true) {
+        return new Decimal(this.value).toRational(shouldSimplify).toTree();
+    }
+    toPrimeDecomposition(usePowers) {
+        if (!isInt(this.value)) {
+            throw new Error("Can't get the prime decomposition of a decimal");
+        }
+        const decomp = primeDecomposition(this.value);
+        if (!decomp.length)
+            return this;
+        let nodes = [];
+        if (usePowers) {
+            for (const d of decomp) {
+                if (d.power === 1)
+                    nodes.push(d.value.toTree());
+                else
+                    nodes.push(power(d.value, d.power));
+            }
+        }
+        else {
+            for (const d of decomp) {
+                for (let i = 0; i < d.power; i++) {
+                    nodes.push(d.value.toTree());
+                }
+            }
+        }
+        if (nodes.length === 1)
+            return nodes[0];
+        return operatorComposition(MultiplyNode, nodes);
     }
 }

package/package.json

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