math-exercises 3.0.128 → 3.0.130

package/lib/exercises/math/calcul/ordering/compareA10N.d.ts

@@ -3,9 +3,14 @@ type A10N = {
     a: number;
     n: number;
 };
+type Item = {
+    tex: string;
+    isValid: boolean;
+};
 type Identifiers = {
     signType: string;
-    items: A10N[];
+    a10Ns: A10N[];
+    items: Item[];
 };
 type Options = {
     signTypes: string[];

package/lib/exercises/math/calcul/ordering/compareA10N.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compareA10N.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/ordering/compareA10N.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAmBrC,KAAK,IAAI,GAAG;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAEF,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,IAAI,EAAE,CAAC;CACf,CAAC;AAwTF,KAAK,OAAO,GAAG;IACb,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB,CAAC;AA0CF,eAAO,MAAM,WAAW,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAetD,CAAC"}
+{"version":3,"file":"compareA10N.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/ordering/compareA10N.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAkBrC,KAAK,IAAI,GAAG;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAEF,KAAK,IAAI,GAAG;IACV,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,OAAO,CAAC;CAClB,CAAC;AAEF,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,IAAI,EAAE,CAAC;IACd,KAAK,EAAE,IAAI,EAAE,CAAC;CACf,CAAC;AA2TF,KAAK,OAAO,GAAG;IACb,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB,CAAC;AAyCF,eAAO,MAAM,WAAW,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAgBtD,CAAC"}

package/lib/exercises/math/calcul/ordering/compareA10N.js

@@ -6,12 +6,11 @@ import { round } from "../../../../math/utils/round.js";
 import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
 import { multiply, } from "../../../../tree/nodes/operators/multiplyNode.js";
 import { power } from "../../../../tree/nodes/operators/powerNode.js";
-import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
 import { coinFlip } from "../../../../utils/alea/coinFlip.js";
 import { probaLawFlip } from "../../../../utils/alea/probaLawFlip.js";
 import { random, randomMany } from "../../../../utils/alea/random.js";
 import { shuffle } from "../../../../utils/alea/shuffle.js";
-import { permute } from "../../../../utils/arrays/permutations.js";
+import { getAllPicks } from "../../../../utils/arrays/getAllPicks.js";
 const getTexForA10N = (a10N) => {
     const { a, n } = a10N;
     return `${a.frenchify()} \\times 10^{${n}}`;
@@ -55,12 +54,14 @@ const compareFuncForA10N = (a10N1, a10N2) => {
     }
 };
 const getInstruction = (identifiers) => {
-    const { items } = identifiers;
-    return `Ranger par ordre croissant les nombres suivants :
+    const { a10Ns } = identifiers;
+    return `Voici une liste de nombres :
 
-$$
-${items.map((item) => getTexForA10N(item)).join(" ; ")}
-$$`;
+${a10Ns.map((a10N) => `- $${getTexForA10N(a10N)}$`).join(`
+  
+`)}
+
+Parmi les propositions suivantes, lesquelles sont vraies ?`;
 };
 const getHint = (identifiers) => {
     const { signType } = identifiers;
@@ -87,15 +88,15 @@ On range les puissances de $10$ en ordre croissant, puis pour chaque puissance d
 `;
 };
 const getCorrection = (identifiers) => {
-    const { signType, items } = identifiers;
+    const { signType, a10Ns } = identifiers;
     return `Même si on a l'impression que les nombres sont écris en écriture scientifique, ce n'est pas le cas. 
 Il faut les convertir en écriture scientifique et utiliser cette écriture pour les ranger dans l'ordre croissant.
 
-${items
-        .map((item) => `
+${a10Ns
+        .map((a10N) => `
   
 $$
-${getTexForA10N(item)} = ${getSciMultNodeForA10N(item).toTex()}
+${getTexForA10N(a10N)} = ${getSciMultNodeForA10N(a10N).toTex()}
 $$
 
 `)
@@ -104,45 +105,45 @@ $$
 ${(() => {
         switch (signType) {
             case "positifs": {
-                const positive = items.toSorted(compareFuncForA10N);
+                const positive = a10Ns.toSorted(compareFuncForA10N);
                 return `Ici, tous les nombres sont positifs, donc
 on range les puissances de $10$ en ordre croissant, puis pour chaque puissance de $10$, les facteurs en ordre croissant.
 C'est un double tri.
 
 $$
-${positive.map((item) => getSciMultNodeForA10N(item).toTex()).join("<")}
+${positive.map((a10N) => getSciMultNodeForA10N(a10N).toTex()).join("<")}
 $$
 
 Conclusion :
 
 $$
-${positive.map((item) => getTexForA10N(item)).join("<")}
+${positive.map((a10N) => getTexForA10N(a10N)).join("<")}
 $$
 
 `;
             }
             case "négatifs": {
-                const negative = items.toSorted(compareFuncForA10N);
+                const negative = a10Ns.toSorted(compareFuncForA10N);
                 return `Ici, tous les nombres sont négatifs, donc
 on range les puissances de $10$ en ordre décroissant, puis pour chaque puissance de $10$, les facteurs en ordre décroissant.
 C'est un double tri.
 
 $$
-${negative.map((item) => getSciMultNodeForA10N(item).toTex()).join("<")}
+${negative.map((a10N) => getSciMultNodeForA10N(a10N).toTex()).join("<")}
 $$
 
 Conclusion :
 
 $$
-${negative.map((item) => getTexForA10N(item)).join("<")}
+${negative.map((a10N) => getTexForA10N(a10N)).join("<")}
 $$
 `;
             }
             case "mélange": {
-                const positive = items
+                const positive = a10Ns
                     .filter(({ a }) => a >= 0)
                     .toSorted(compareFuncForA10N);
-                const negative = items
+                const negative = a10Ns
                     .filter(({ a }) => a < 0)
                     .toSorted(compareFuncForA10N);
                 return `Ici, il y a des nombres négatifs et des nombres positifs.
@@ -150,20 +151,20 @@ On commence par les négatifs :
 on range les puissances de $10$ en ordre décroissant, puis pour chaque puissance de $10$, les facteurs en ordre décroissant.
 
 $$
-${negative.map((item) => getSciMultNodeForA10N(item).toTex()).join("<")}
+${negative.map((a10N) => getSciMultNodeForA10N(a10N).toTex()).join("<")}
 $$
 
 Puis on range les positifs :
 on range les puissances de $10$ en ordre croissant, puis pour chaque puissance de $10$, les facteurs en ordre croissant.
 
 $$
-${positive.map((item) => getSciMultNodeForA10N(item).toTex()).join("<")}
+${positive.map((a10N) => getSciMultNodeForA10N(a10N).toTex()).join("<")}
 $$
 
 Conclusion :
 
 $$
-${[...negative, ...positive].map((item) => getTexForA10N(item)).join("<")}
+${[...negative, ...positive].map((a10N) => getTexForA10N(a10N)).join("<")}
 $$
 `;
             }
@@ -174,37 +175,23 @@ $$
 const getPropositions = (n, { answer, ...identifiers }) => {
     const { items } = identifiers;
     const propositions = [];
-    addValidProp(propositions, answer);
-    permute(items)
-        .slice(0, 5)
-        .forEach((permutedItems) => {
-        const arrayOfTex = permutedItems.map((item) => getTexForA10N(item));
-        tryToAddWrongProp(propositions, arrayOfTex.join("<"));
-        tryToAddWrongProp(propositions, arrayOfTex.join(">"));
+    items.forEach((item) => {
+        if (item.isValid) {
+            addValidProp(propositions, item.tex);
+        }
+        else {
+            tryToAddWrongProp(propositions, item.tex);
+        }
     });
     return shuffleProps(propositions, n);
 };
-const getAnswer = (identifiers) => {
-    const { items } = identifiers;
-    const answer = items
-        .toSorted(compareFuncForA10N)
-        .map((item) => getTexForA10N(item))
-        .join("<");
-    return answer;
-};
-const isAnswerValid = (ans, { answer, items }) => {
-    const nbItems = items.length;
-    const [ansNodes, answerNodes] = [ans, answer].map((str) => str.split("<").map((tex) => parseAlgebraic(tex)));
-    return (ansNodes.length === nbItems &&
-        [...Array(nbItems).keys()].every((i) => ansNodes[i].equals(answerNodes[i])));
-};
 const getKeys = (identifiers) => {
-    const { items } = identifiers;
+    const { a10Ns } = identifiers;
     return [
         "sup",
         "inf",
-        ...items.map((item) => {
-            const tex = getTexForA10N(item);
+        ...a10Ns.map((a10N) => {
+            const tex = getTexForA10N(a10N);
             return {
                 id: "custom",
                 label: tex,
@@ -263,14 +250,34 @@ const getCompareA10NQuestion = (optsIn) => {
         arrayOfN.push(random(subPoolOfN) + random([-2, -1, 0, 1, 2]));
     }
     arrayOfN = shuffle(arrayOfN);
-    const items = [...Array(nbItems).keys()].map((i) => {
+    const a10Ns = [...Array(nbItems).keys()].map((i) => {
         return {
             a: arrayOfA[i],
             n: arrayOfN[i],
         };
     });
+    const nbTotal = 4;
+    const nbValid = randint(1, 4);
+    const ascOrderedA10Ns = a10Ns.toSorted(compareFuncForA10N);
+    const items = shuffle(shuffle(getAllPicks(ascOrderedA10Ns).filter((arr) => arr.length === 2))
+        .slice(0, nbTotal)
+        .map(([a10N1, a10N2], i) => {
+        if (i < nbValid) {
+            return {
+                tex: `${getTexForA10N(a10N1)}<${getTexForA10N(a10N2)}`,
+                isValid: true,
+            };
+        }
+        else {
+            return {
+                tex: `${getTexForA10N(a10N2)}<${getTexForA10N(a10N1)}`,
+                isValid: false,
+            };
+        }
+    }));
     return getQuestionFromIdentifiers({
         signType,
+        a10Ns,
         items,
     });
 };
@@ -298,7 +305,6 @@ const options = [
 ];
 const getQuestionFromIdentifiers = (identifiers, opts) => {
     const question = {
-        answer: getAnswer(identifiers),
         instruction: getInstruction(identifiers),
         keys: getKeys(identifiers),
         answerFormat: "tex",
@@ -318,9 +324,10 @@ export const compareA10N = {
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
-    isAnswerValid,
     subject: "Mathématiques",
     maxAllowedQuestions: 30,
     getQuestionFromIdentifiers,
     hasHintAndCorrection: true,
+    answerType: "QCM",
+    isQCM: true,
 };

package/lib/exercises/math/calcul/ordering/compareABUsingQuotient.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compareABUsingQuotient.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/ordering/compareABUsingQuotient.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAK7C,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,eAAe,EAAE,CAAC;CACnC,CAAC;AA+IF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAgBxD,CAAC"}
+{"version":3,"file":"compareABUsingQuotient.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/ordering/compareABUsingQuotient.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAK7C,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,eAAe,EAAE,CAAC;CACnC,CAAC;AA2HF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAgBxD,CAAC"}

package/lib/exercises/math/calcul/ordering/compareABUsingQuotient.js

@@ -10,7 +10,7 @@ const getInstruction = (identifiers) => {
     const [A, B] = orderedNodeIds.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds).toTex());
     return `Sachant que $\\frac{${B}}{${A}} > 1$,
   
-comparer $${B}$ et $${A}$.;`;
+comparer $${B}$ et $${A}$.`;
 };
 const getHint = (identifiers) => {
     const { orderedNodeIds } = identifiers;
@@ -44,21 +44,6 @@ const getAnswer = (identifiers) => {
     const [A, B] = orderedNodeIds.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds).toTex());
     return `${B}>${A}`;
 };
-const isAnswerValid = (ans, { ...identifiers }) => {
-    const { orderedNodeIds } = identifiers;
-    const [A, B] = orderedNodeIds.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds).toTex());
-    const compSymbol = ans.includes(">")
-        ? ">"
-        : ans.includes("<")
-            ? "<"
-            : undefined;
-    if (!compSymbol) {
-        return false;
-    }
-    else {
-        return (compSymbol === ">" ? [B, A] : [A, B]).every((tex, i) => tex === ans.split(compSymbol)[i]);
-    }
-};
 const getPropositions = (nbProps, { ...identifiers }) => {
     const { orderedNodeIds } = identifiers;
     const [A, B] = orderedNodeIds.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds).toTex());
@@ -88,7 +73,7 @@ const getKeys = (identifiers) => {
 };
 const getCompareABUsingQuotientQuestion = () => {
     const n = randint(2, 150);
-    const orderedNodesIncreasing = [add(1, sqrt(add(1, n))), add(2, sqrt(n))];
+    const orderedNodesIncreasing = [add(1, sqrt(1 + n)), add(2, sqrt(n))];
     return getQuestionFromIdentifiers({
         orderedNodeIds: orderedNodesIncreasing.map((node) => node.toIdentifiers()),
     });
@@ -113,10 +98,10 @@ export const compareABUsingQuotient = {
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
-    isAnswerValid,
     getAnswer,
     subject: "Mathématiques",
     maxAllowedQuestions: 30,
     getQuestionFromIdentifiers,
     hasHintAndCorrection: true,
+    answerType: "QCU",
 };

package/lib/exercises/math/calcul/ordering/compareFracABWithFracAPlusCBPlusC.d.ts

@@ -4,6 +4,9 @@ type Identifiers = {
     nodeIds: NodeIdentifiers[];
     texAnswers: string[];
 };
-export declare const compareFracABWithFracAPlusCBPlusC: Exercise<Identifiers>;
+type Options = {
+    isFracOfSums: boolean;
+};
+export declare const compareFracABWithFracAPlusCBPlusC: Exercise<Identifiers, Options>;
 export {};
 //# sourceMappingURL=compareFracABWithFracAPlusCBPlusC.d.ts.map

package/lib/exercises/math/calcul/ordering/compareFracABWithFracAPlusCBPlusC.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compareFracABWithFracAPlusCBPlusC.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/ordering/compareFracABWithFracAPlusCBPlusC.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAY7C,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,eAAe,EAAE,CAAC;IAC3B,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB,CAAC;AA4LF,eAAO,MAAM,iCAAiC,EAAE,QAAQ,CAAC,WAAW,CAmBnE,CAAC"}
+{"version":3,"file":"compareFracABWithFracAPlusCBPlusC.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/ordering/compareFracABWithFracAPlusCBPlusC.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAY7C,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,eAAe,EAAE,CAAC;IAC3B,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB,CAAC;AA0MF,KAAK,OAAO,GAAG;IACb,YAAY,EAAE,OAAO,CAAC;CACvB,CAAC;AAgBF,eAAO,MAAM,iCAAiC,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAqB1E,CAAC"}

package/lib/exercises/math/calcul/ordering/compareFracABWithFracAPlusCBPlusC.js

@@ -1,9 +1,9 @@
-import { addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { lcm } from "../../../../math/utils/arithmetic/lcm.js";
 import { randint } from "../../../../math/utils/random/randint.js";
 import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
-import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { add, isAddNode } from "../../../../tree/nodes/operators/addNode.js";
 import { frac, isFractionNode, } from "../../../../tree/nodes/operators/fractionNode.js";
 import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
 import { coinFlip } from "../../../../utils/alea/coinFlip.js";
@@ -33,12 +33,17 @@ const getCorrection = (identifiers) => {
         ? frac(multiply(node.leftChild.simplify(), frac(sameDen, node.rightChild)).simplify(), sameDen)
         : frac(multiply(node, sameDen).simplify(), sameDen));
     const answer = getAnswer(identifiers);
-    return `On a : 
+    const isFracOfSums = isAddNode(nodes[1].leftChild);
+    return `${isFracOfSums
+        ? `On a : 
 
 $$
 ${nodes[1].toSimplificationTex()}
 $$
 
+`
+        : ``}
+
 On veut donc comparer $${nodesSimplified[0].toTex()}$ et $${nodesSimplified[1].toTex()}$.
 
 On peut choisir $${sameDen.frenchify()}$ comme dénominateur commun.
@@ -84,14 +89,19 @@ const getAnswer = (identifiers) => {
     const { texAnswers } = identifiers;
     return texAnswers[0];
 };
-const isAnswerValid = (ans, { texAnswers }) => {
-    return texAnswers.includes(ans);
-};
-const getCompareFracABWithFracAPlusCBPlusCQuestion = () => {
+const getCompareFracABWithFracAPlusCBPlusCQuestion = (optsIn) => {
+    const opts = optsIn ?? optsDefault;
     const a = randint(1, 10);
-    const b = randint(1, 10, [a]);
+    const b = randint(2, 10, [a]);
     const c = randint(1, 10);
-    const nodes = [frac(a, b), frac(add(a, c), add(b, c))];
+    const nodes = [
+        frac(a, b),
+        (() => {
+            const nodeNum = opts.isFracOfSums ? add(a, c) : (a + c).toTree();
+            const nodeDec = opts.isFracOfSums ? add(b, c) : (b + c).toTree();
+            return frac(nodeNum, nodeDec);
+        })(),
+    ];
     const isOrderAsc = coinFlip();
     const sortedNodes = nodes.toSorted((node1, node2) => (isOrderAsc ? +1 : -1) * (node1.evaluate() - node2.evaluate()));
     const texAnswers = [
@@ -132,17 +142,31 @@ const getQuestionFromIdentifiers = (identifiers, opts) => {
     };
     return question;
 };
+const optsDefault = {
+    isFracOfSums: false,
+};
+const options = [
+    {
+        id: "isFracOfSums",
+        label: "Fraction de sommes ?",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.checkbox,
+        values: [true, false],
+        defaultValue: optsDefault.isFracOfSums,
+    },
+];
 export const compareFracABWithFracAPlusCBPlusC = {
     id: "compareFracABWithFracAPlusCBPlusC",
     label: "Effectuer des comparaisons entre des fractions simples (de la forme $\\frac{a}{b}$ et $\\frac{a+c}{b+c}$)",
     isSingleStep: true,
     generator: (nb, opts) => getDistinctQuestions(() => getCompareFracABWithFracAPlusCBPlusCQuestion(opts), nb, 30),
+    options,
     qcmTimer: 60,
     freeTimer: 60,
-    isAnswerValid,
     getPropositions,
     subject: "Mathématiques",
     maxAllowedQuestions: 30,
     getQuestionFromIdentifiers,
     hasHintAndCorrection: true,
+    answerType: "QCU",
 };

package/lib/exercises/math/calcul/ordering/compareFracAndDec.d.ts

@@ -5,18 +5,14 @@ type QCMItem = {
     isValidAnswer: boolean;
 };
 type QuestionParam = {
-    fakeName: string;
+    letter: string;
     trueName: string;
     tex: string;
     nodeIds: NodeIdentifiers;
     explainTex: string;
 };
 type Identifiers = {
-    sign: number;
-    a: number;
-    b: number;
-    c: number;
-    dictFakeNameToQuestionParam: Record<string, QuestionParam>;
+    questionParams: QuestionParam[];
     items: QCMItem[];
 };
 type Options = {

package/lib/exercises/math/calcul/ordering/compareFracAndDec.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compareFracAndDec.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/ordering/compareFracAndDec.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAiBT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAY7C,KAAK,OAAO,GAAG;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,aAAa,EAAE,OAAO,CAAC;CACxB,CAAC;AAEF,KAAK,aAAa,GAAG;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,eAAe,CAAC;IACzB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,2BAA2B,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;IAC3D,KAAK,EAAE,OAAO,EAAE,CAAC;CAClB,CAAC;AAkYF,KAAK,OAAO,GAAG;IACb,QAAQ,EAAE,OAAO,CAAC;IAClB,eAAe,EAAE,MAAM,CAAC;IACxB,yBAAyB,EAAE,OAAO,CAAC;CACpC,CAAC;AA+BF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAgB5D,CAAC"}
+{"version":3,"file":"compareFracAndDec.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/ordering/compareFracAndDec.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAU7C,KAAK,OAAO,GAAG;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,aAAa,EAAE,OAAO,CAAC;CACxB,CAAC;AAEF,KAAK,aAAa,GAAG;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,eAAe,CAAC;IACzB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,aAAa,EAAE,CAAC;IAChC,KAAK,EAAE,OAAO,EAAE,CAAC;CAClB,CAAC;AA6RF,KAAK,OAAO,GAAG;IACb,QAAQ,EAAE,OAAO,CAAC;IAClB,eAAe,EAAE,MAAM,CAAC;IACxB,yBAAyB,EAAE,OAAO,CAAC;CACpC,CAAC;AAuBF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAgB5D,CAAC"}