math-exercises 1.3.2 → 1.3.4

package/lib/tree/parsers/latexParser.js

@@ -1,110 +1,117 @@
-"use strict";
-// import { FunctionNode, FunctionsIds } from "../nodes/functions/functionNode";
-// import { Node, NodeType } from "../nodes/node";
-// import { OperatorIds, OperatorNode } from "../nodes/operators/operatorNode";
-// export function latexParser(node: Node): string {
-//   if (!node) {
-//     console.log("parsing a null node ???");
-//     return "";
-//   }
-//   switch (node.type) {
-//     case NodeType.variable:
-//       return node.tex;
-//     case NodeType.number:
-//       return node.tex;
-//     case NodeType.operator:
-//       const operatorNode = node as OperatorNode;
-//       let rightTex = latexParser(operatorNode.rightChild);
-//       let leftTex = latexParser(operatorNode.leftChild);
-//       const { leftChild, rightChild } = operatorNode;
-//       switch (operatorNode.id) {
-//         case OperatorIds.add:
-//           return `${leftTex} ${rightTex[0] === "-" ? "" : "+ "}${rightTex}`;
-//         case OperatorIds.substract: {
-//           const needBrackets =
-//             (rightChild.type === NodeType.operator &&
-//               [OperatorIds.add, OperatorIds.substract].includes((rightChild as OperatorNode).id)) ||
-//             rightTex[0] === "-";
-//           if (needBrackets) rightTex = `(${rightTex})`;
-//           return `${leftTex} - ${rightTex}`;
-//         }
-//         case OperatorIds.multiply: {
-//           if (leftChild.type === NodeType.operator) {
-//             if ([OperatorIds.add, OperatorIds.substract, OperatorIds.divide].includes((leftChild as OperatorNode).id))
-//               leftTex = `(${leftTex})`;
-//           }
-//           let needBrackets = rightTex[0] === "-";
-//           if (rightChild.type === NodeType.operator) {
-//             const operatorRightChild = rightChild as OperatorNode;
-//             needBrackets ||= [OperatorIds.add, OperatorIds.substract].includes(operatorRightChild.id);
-//           }
-//           if (needBrackets) rightTex = `(${rightTex})`;
-//           //  permet de gérer le cas 3*2^x
-//           let showTimesSign = !isNaN(+rightTex[0]) || rightChild.type === NodeType.number;
-//           if (rightChild.type === NodeType.operator) {
-//             const operatorRightChild = rightChild as OperatorNode;
-//             showTimesSign ||= [OperatorIds.fraction].includes(operatorRightChild.id);
-//           }
-//           return `${leftTex}${showTimesSign ? "\\times " : ""}${rightTex}`;
-//         }
-//         case OperatorIds.divide: {
-//           if (leftChild.type === NodeType.operator) {
-//             if ([OperatorIds.add, OperatorIds.substract, OperatorIds.multiply].includes((leftChild as OperatorNode).id))
-//               leftTex = `(${leftTex})`;
-//           }
-//           let needBrackets = rightTex[0] === "-";
-//           if (rightChild.type === NodeType.operator) {
-//             const operatorRightChild = rightChild as OperatorNode;
-//             needBrackets ||= [OperatorIds.add, OperatorIds.substract].includes(operatorRightChild.id);
-//           }
-//           if (needBrackets) rightTex = `(${rightTex})`;
-//           return `${leftTex} \\div ${rightTex}`;
-//         }
-//         case OperatorIds.fraction: {
-//           return `\\frac{${leftTex}}{${rightTex}}`;
-//         }
-//         case OperatorIds.power: {
-//           let needBrackets = leftTex[0] === "-";
-//           if (leftChild.type === NodeType.operator) {
-//             const childOperator = leftChild as OperatorNode;
-//             needBrackets ||= [
-//               OperatorIds.add,
-//               OperatorIds.substract,
-//               OperatorIds.multiply,
-//               OperatorIds.divide,
-//               OperatorIds.fraction,
-//               OperatorIds.power,
-//             ].includes(childOperator.id);
-//           }
-//           if (needBrackets) leftTex = `(${leftTex})`;
-//           return `${leftTex}^{${rightTex}}`;
-//         }
-//         case OperatorIds.equal: {
-//           return `${leftTex} = ${rightTex}`;
-//         }
-//         default:
-//           return node.tex;
-//       }
-//     case NodeType.function: {
-//       const functionNode = node as FunctionNode;
-//       const child = functionNode.child;
-//       let childTex = latexParser(functionNode.child);
-//       switch (functionNode.id) {
-//         case FunctionsIds.sqrt: {
-//           return `\\sqrt{${childTex}}`;
-//         }
-//         case FunctionsIds.opposite: {
-//           let needBrackets = childTex[0] === "-";
-//           if (child.type === NodeType.operator) {
-//             const operatorChild = child as OperatorNode;
-//             needBrackets ||= [OperatorIds.add, OperatorIds.substract].includes(operatorChild.id);
-//           }
-//           if (needBrackets) childTex = `(${childTex})`;
-//           return `-${childTex}`;
-//         }
-//       }
-//     }
-//     default:
-//       return "";
-//   }
-// }
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.latexParser = void 0;
+const functionNode_1 = require("../nodes/functions/functionNode");
+const node_1 = require("../nodes/node");
+const operatorNode_1 = require("../nodes/operators/operatorNode");
+function latexParser(node) {
+    if (!node) {
+        console.log("parsing a null node ???");
+        return "";
+    }
+    switch (node.type) {
+        case node_1.NodeType.variable:
+            return node.tex;
+        case node_1.NodeType.number:
+            return node.tex;
+        case node_1.NodeType.operator:
+            const operatorNode = node;
+            let rightTex = latexParser(operatorNode.rightChild);
+            let leftTex = latexParser(operatorNode.leftChild);
+            const { leftChild, rightChild } = operatorNode;
+            switch (operatorNode.id) {
+                case operatorNode_1.OperatorIds.add:
+                    return `${leftTex} ${rightTex[0] === "-" ? "" : "+ "}${rightTex}`;
+                case operatorNode_1.OperatorIds.substract: {
+                    const needBrackets = (rightChild.type === node_1.NodeType.operator &&
+                        [operatorNode_1.OperatorIds.add, operatorNode_1.OperatorIds.substract].includes(rightChild.id)) ||
+                        rightTex[0] === "-";
+                    if (needBrackets)
+                        rightTex = `(${rightTex})`;
+                    return `${leftTex} - ${rightTex}`;
+                }
+                case operatorNode_1.OperatorIds.multiply: {
+                    if (leftChild.type === node_1.NodeType.operator) {
+                        if ([operatorNode_1.OperatorIds.add, operatorNode_1.OperatorIds.substract, operatorNode_1.OperatorIds.divide].includes(leftChild.id))
+                            leftTex = `(${leftTex})`;
+                    }
+                    let needBrackets = rightTex[0] === "-";
+                    if (rightChild.type === node_1.NodeType.operator) {
+                        const operatorRightChild = rightChild;
+                        needBrackets || (needBrackets = [operatorNode_1.OperatorIds.add, operatorNode_1.OperatorIds.substract].includes(operatorRightChild.id));
+                    }
+                    if (needBrackets)
+                        rightTex = `(${rightTex})`;
+                    //  permet de gérer le cas 3*2^x
+                    let showTimesSign = !isNaN(+rightTex[0]) || rightChild.type === node_1.NodeType.number;
+                    if (rightChild.type === node_1.NodeType.operator) {
+                        const operatorRightChild = rightChild;
+                        showTimesSign || (showTimesSign = [operatorNode_1.OperatorIds.fraction].includes(operatorRightChild.id));
+                    }
+                    return `${leftTex}${showTimesSign ? "\\times " : ""}${rightTex}`;
+                }
+                case operatorNode_1.OperatorIds.divide: {
+                    if (leftChild.type === node_1.NodeType.operator) {
+                        if ([operatorNode_1.OperatorIds.add, operatorNode_1.OperatorIds.substract, operatorNode_1.OperatorIds.multiply].includes(leftChild.id))
+                            leftTex = `(${leftTex})`;
+                    }
+                    let needBrackets = rightTex[0] === "-";
+                    if (rightChild.type === node_1.NodeType.operator) {
+                        const operatorRightChild = rightChild;
+                        needBrackets || (needBrackets = [operatorNode_1.OperatorIds.add, operatorNode_1.OperatorIds.substract].includes(operatorRightChild.id));
+                    }
+                    if (needBrackets)
+                        rightTex = `(${rightTex})`;
+                    return `${leftTex} \\div ${rightTex}`;
+                }
+                case operatorNode_1.OperatorIds.fraction: {
+                    return `\\frac{${leftTex}}{${rightTex}}`;
+                }
+                case operatorNode_1.OperatorIds.power: {
+                    let needBrackets = leftTex[0] === "-";
+                    if (leftChild.type === node_1.NodeType.operator) {
+                        const childOperator = leftChild;
+                        needBrackets || (needBrackets = [
+                            operatorNode_1.OperatorIds.add,
+                            operatorNode_1.OperatorIds.substract,
+                            operatorNode_1.OperatorIds.multiply,
+                            operatorNode_1.OperatorIds.divide,
+                            operatorNode_1.OperatorIds.fraction,
+                            operatorNode_1.OperatorIds.power,
+                        ].includes(childOperator.id));
+                    }
+                    if (needBrackets)
+                        leftTex = `(${leftTex})`;
+                    return `${leftTex}^{${rightTex}}`;
+                }
+                case operatorNode_1.OperatorIds.equal: {
+                    return `${leftTex} = ${rightTex}`;
+                }
+                default:
+                    return node.tex;
+            }
+        case node_1.NodeType.function: {
+            const functionNode = node;
+            const child = functionNode.child;
+            let childTex = latexParser(functionNode.child);
+            switch (functionNode.id) {
+                case functionNode_1.FunctionsIds.sqrt: {
+                    return `\\sqrt{${childTex}}`;
+                }
+                case functionNode_1.FunctionsIds.opposite: {
+                    let needBrackets = childTex[0] === "-";
+                    if (child.type === node_1.NodeType.operator) {
+                        const operatorChild = child;
+                        needBrackets || (needBrackets = [operatorNode_1.OperatorIds.add, operatorNode_1.OperatorIds.substract].includes(operatorChild.id));
+                    }
+                    if (needBrackets)
+                        childTex = `(${childTex})`;
+                    return `-${childTex}`;
+                }
+            }
+        }
+        default:
+            return "";
+    }
+}
+exports.latexParser = latexParser;

package/lib/utils/coin.js

@@ -1,7 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.coin = void 0;
-const coin = () => {
-    return Math.random() < 0.5;
-};
-exports.coin = coin;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.coin = void 0;
+const coin = () => {
+    return Math.random() < 0.5;
+};
+exports.coin = coin;

package/lib/utils/random.js

@@ -1,7 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.random = void 0;
-function random(array) {
-    return array[Math.floor(Math.random() * array.length)];
-}
-exports.random = random;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.random = void 0;
+function random(array) {
+    return array[Math.floor(Math.random() * array.length)];
+}
+exports.random = random;

package/lib/utils/shuffle.js

@@ -1,15 +1,15 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.shuffle = void 0;
-/* Randomize array in-place using Durstenfeld shuffle algorithm */
-function shuffle(array) {
-    const res = [...array];
-    for (var i = res.length - 1; i > 0; i--) {
-        var j = Math.floor(Math.random() * (i + 1));
-        var temp = res[i];
-        res[i] = res[j];
-        res[j] = temp;
-    }
-    return res;
-}
-exports.shuffle = shuffle;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shuffle = void 0;
+/* Randomize array in-place using Durstenfeld shuffle algorithm */
+function shuffle(array) {
+    const res = [...array];
+    for (var i = res.length - 1; i > 0; i--) {
+        var j = Math.floor(Math.random() * (i + 1));
+        var temp = res[i];
+        res[i] = res[j];
+        res[j] = temp;
+    }
+    return res;
+}
+exports.shuffle = shuffle;

package/package.json

@@ -1,38 +1,41 @@
-{
-  "name": "math-exercises",
-  "version": "1.3.2",
-  "description": "Math exercises generator for middle school and high school",
-  "main": "src/index.js",
-  "files": [
-    "lib/**/*"
-  ],
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1",
-    "start:dev": "nodemon",
-    "build": "tsc",
-    "prepublish": "tsc"
-  },
-  "keywords": [],
-  "author": "Heureux Hasard",
-  "license": "ISC",
-  "devDependencies": {
-    "@types/node": "^18.11.9",
-    "nodemon": "^2.0.20",
-    "prettier": "^2.8.4",
-    "ts-node": "^10.9.1",
-    "tslint": "^6.1.3",
-    "tslint-config-prettier": "^1.18.0",
-    "typescript": "^4.9.3"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/krirkrirk/math-exercises.git"
-  },
-  "bugs": {
-    "url": "https://github.com/krirkrirk/math-exercises/issues"
-  },
-  "homepage": "https://github.com/krirkrirk/math-exercises#readme",
-  "dependencies": {
-    "mathjs": "^11.5.1"
-  }
-}
+{
+  "name": "math-exercises",
+  "version": "1.3.4",
+  "description": "Math exercises generator for middle school and high school",
+  "main": "src/index.js",
+  "files": [
+    "lib/**/*"
+  ],
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "start:dev": "nodemon",
+    "build": "tsc",
+    "prepublish": "tsc"
+  },
+  "keywords": [],
+  "author": "Heureux Hasard",
+  "license": "ISC",
+  "devDependencies": {
+    "@types/node": "^18.11.9",
+    "nodemon": "^2.0.20",
+    "prettier": "^2.8.4",
+    "ts-node": "^10.9.1",
+    "tslint": "^6.1.3",
+    "tslint-config-prettier": "^1.18.0",
+    "typescript": "^4.9.3"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/krirkrirk/math-exercises.git"
+  },
+  "bugs": {
+    "url": "https://github.com/krirkrirk/math-exercises/issues"
+  },
+  "homepage": "https://github.com/krirkrirk/math-exercises#readme",
+  "dependencies": {
+    "mathjs": "^11.5.1"
+  },
+  "exports": {
+    ".": "./lib/index.js"
+  }
+}

package/lib/exercises/calcul/operations/operationsPriorities.js

@@ -1,98 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getPriorityQuestions = exports.operationsPriorities = void 0;
-const randint_1 = require("../../../mathutils/random/randint");
-const numberNode_1 = require("../../../tree/nodes/numbers/numberNode");
-const addNode_1 = require("../../../tree/nodes/operators/addNode");
-const divideNode_1 = require("../../../tree/nodes/operators/divideNode");
-const multiplyNode_1 = require("../../../tree/nodes/operators/multiplyNode");
-const coin_1 = require("../../../utils/coin");
-const getDistinctQuestions_1 = require("../../utils/getDistinctQuestions");
-/**
- * a*b ±c±d
- * a/b ±c±d
- * a*b*c ± d
- * a*b±c*d
- * a/b ± c*d
- */
-exports.operationsPriorities = {
-    id: 'operationsPriorities',
-    connector: '=',
-    instruction: 'Calculer :',
-    label: 'Priorités opératoires',
-    levels: ['6', '5', '4'],
-    section: 'Calculs',
-    isSingleStep: true,
-    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getPriorityQuestions, nb),
-};
-function getPriorityQuestions() {
-    const type = (0, randint_1.randint)(1, 6);
-    let startStatement = '';
-    let answer = '';
-    let a, b, c, d;
-    let statement;
-    switch (type) {
-        case 1: // a*b ±c±d
-            [c, d] = [1, 2, 3, 4].map((el) => (0, randint_1.randint)(-10, 11, [0]));
-            [a, b] = [1, 2].map((el) => (0, randint_1.randint)(-10, 11));
-            statement = (0, coin_1.coin)()
-                ? //a*b first ou last
-                    new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(a), new numberNode_1.NumberNode(b)), new addNode_1.AddNode(new numberNode_1.NumberNode(c), new numberNode_1.NumberNode(d)))
-                : //a*b middle
-                    new addNode_1.AddNode(new addNode_1.AddNode(new numberNode_1.NumberNode(c), new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(a), new numberNode_1.NumberNode(b))), new numberNode_1.NumberNode(d));
-            statement.shuffle();
-            startStatement = statement.toTex();
-            answer = (a * b + c + d).toString();
-            break;
-        case 2: // a/b ±c±d
-            [b, c, d] = [1, 2, 3].map((el) => (0, randint_1.randint)(-10, 11, [0]));
-            a = b * (0, randint_1.randint)(0, 11);
-            statement = (0, coin_1.coin)()
-                ? //a/b first ou last
-                    new addNode_1.AddNode(new divideNode_1.DivideNode(new numberNode_1.NumberNode(a), new numberNode_1.NumberNode(b)), new addNode_1.AddNode(new numberNode_1.NumberNode(c), new numberNode_1.NumberNode(d)))
-                : //a/b middle
-                    new addNode_1.AddNode(new addNode_1.AddNode(new numberNode_1.NumberNode(c), new divideNode_1.DivideNode(new numberNode_1.NumberNode(a), new numberNode_1.NumberNode(b))), new numberNode_1.NumberNode(d));
-            statement.shuffle();
-            startStatement = statement.toTex();
-            answer = (a / b + c + d).toString();
-            break;
-        case 3: // a*b ± c*d
-            [a, b, c, d] = [1, 2, 3, 4].map((el) => (0, randint_1.randint)(-10, 11));
-            statement = new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(a), new numberNode_1.NumberNode(b)), new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(c), new numberNode_1.NumberNode(d)));
-            startStatement = statement.toTex();
-            answer = (a * b + c * d).toString();
-            break;
-        case 4: // a*b ± c/d
-            [a, b] = [1, 2].map((el) => (0, randint_1.randint)(-10, 11));
-            d = (0, randint_1.randint)(-10, 11, [0]);
-            c = d * (0, randint_1.randint)(0, 11);
-            statement = new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(a), new numberNode_1.NumberNode(b)), new divideNode_1.DivideNode(new numberNode_1.NumberNode(c), new numberNode_1.NumberNode(d)));
-            statement.shuffle();
-            startStatement = statement.toTex();
-            answer = (a * b + c / d).toString();
-            break;
-        case 5: // a/b ± c/d
-            [b, d] = [1, 2].map((el) => (0, randint_1.randint)(-10, 11, [0]));
-            a = b * (0, randint_1.randint)(0, 11);
-            c = d * (0, randint_1.randint)(0, 11);
-            statement = new addNode_1.AddNode(new divideNode_1.DivideNode(new numberNode_1.NumberNode(a), new numberNode_1.NumberNode(b)), new divideNode_1.DivideNode(new numberNode_1.NumberNode(c), new numberNode_1.NumberNode(d)));
-            startStatement = statement.toTex();
-            answer = (a / b + c / d).toString();
-            break;
-        case 5: // a*b*c ± d
-            [b, d] = [1, 2].map((el) => (0, randint_1.randint)(-10, 11, [0]));
-            a = b * (0, randint_1.randint)(0, 11);
-            c = d * (0, randint_1.randint)(0, 11);
-            statement = new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(a), new numberNode_1.NumberNode(b)), new numberNode_1.NumberNode(c)), new numberNode_1.NumberNode(d));
-            statement.shuffle();
-            startStatement = statement.toTex();
-            answer = (a * b * c + d).toString();
-            break;
-    }
-    const question = {
-        startStatement,
-        answer,
-    };
-    return question;
-}
-exports.getPriorityQuestions = getPriorityQuestions;

package/lib/exercises/calcul/operations/operationsPrioritiesWithoutRelative.js

@@ -1,111 +0,0 @@
-"use strict";
-// import { randint } from "../../mathutils/random/randint";
-// import { latexParser } from "../../tree/parsers/latexParser";
-// import { Node } from "../../tree/nodes/node";
-// import { NumberNode } from "../../tree/nodes/numbers/numberNode";
-// import { AddNode } from "../../tree/nodes/operators/addNode";
-// import { DivideNode } from "../../tree/nodes/operators/divideNode";
-// import { MultiplyNode } from "../../tree/nodes/operators/multiplyNode";
-// import { coin } from "../../utils/coin";
-// import { Exercise, Question } from "../exercise";
-// import { getDistinctQuestions } from "../utils/getDistinctQuestions";
-// /**
-//  * a*b ±c±d
-//  * a/b ±c±d
-//  * a*b*c ± d
-//  * a*b±c*d
-//  * a/b ± c*d
-//  */
-// export const operationsPriorities: Exercise = {
-//   id: "operationsPrioritiesWithoutRelative",
-//   connector: "=",
-//   instruction: "Calculer :",
-//   label: "Priorités opératoires (sans relatif)",
-//   levels: ["6", "5", "4"],
-//   section: "Calculs",
-//   isSingleStep: true,
-//   generator: (nb: number) => getDistinctQuestions(getPriorityQuestionsWithoutRelatif, nb),
-// };
-// export function getPriorityQuestionsWithoutRelatif(): Question {
-//   const type = randint(1, 6);
-//   let statement: Node;
-//   let answer: string = "";
-//   let a, b, c, d: number;
-//   switch (type) {
-//     case 1: // a*b ±c±d
-//       [c, d] = [1, 2, 3, 4].map((el) => randint(-10, 11, [0]));
-//       [a, b] = [1, 2].map((el) => randint(-10, 11));
-//       statement = coin()
-//         ? //a*b first ou last
-//           new AddNode(
-//             new MultiplyNode(new NumberNode(a), new NumberNode(b)),
-//             new AddNode(new NumberNode(c), new NumberNode(d))
-//           ).shuffle()
-//         : //a*b middle
-//           new AddNode(
-//             new AddNode(new NumberNode(c), new MultiplyNode(new NumberNode(a), new NumberNode(b))),
-//             new NumberNode(d)
-//           );
-//       answer = (a * b + c + d).toString();
-//       break;
-//     case 2: // a/b ±c±d
-//       [b, c, d] = [1, 2, 3].map((el) => randint(-10, 11, [0]));
-//       a = b * randint(0, 11);
-//       statement = coin()
-//         ? //a/b first ou last
-//           new AddNode(
-//             new DivideNode(new NumberNode(a), new NumberNode(b)),
-//             new AddNode(new NumberNode(c), new NumberNode(d))
-//           ).shuffle()
-//         : //a/b middle
-//           new AddNode(
-//             new AddNode(new NumberNode(c), new DivideNode(new NumberNode(a), new NumberNode(b))),
-//             new NumberNode(d)
-//           );
-//       answer = (a / b + c + d).toString();
-//       break;
-//     case 3: // a*b ± c*d
-//       [a, b, c, d] = [1, 2, 3, 4].map((el) => randint(-10, 11));
-//       statement = new AddNode(
-//         new MultiplyNode(new NumberNode(a), new NumberNode(b)),
-//         new MultiplyNode(new NumberNode(c), new NumberNode(d))
-//       );
-//       answer = (a * b + c * d).toString();
-//       break;
-//     case 4: // a*b ± c/d
-//       [a, b] = [1, 2].map((el) => randint(-10, 11));
-//       d = randint(-10, 11, [0]);
-//       c = d * randint(0, 11);
-//       statement = new AddNode(
-//         new MultiplyNode(new NumberNode(a), new NumberNode(b)),
-//         new DivideNode(new NumberNode(c), new NumberNode(d))
-//       ).shuffle();
-//       answer = (a * b + c / d).toString();
-//       break;
-//     case 5: // a/b ± c/d
-//       [b, d] = [1, 2].map((el) => randint(-10, 11, [0]));
-//       a = b * randint(0, 11);
-//       c = d * randint(0, 11);
-//       statement = new AddNode(
-//         new DivideNode(new NumberNode(a), new NumberNode(b)),
-//         new DivideNode(new NumberNode(c), new NumberNode(d))
-//       );
-//       answer = (a / b + c / d).toString();
-//       break;
-//     case 5: // a*b*c ± d
-//       [b, d] = [1, 2].map((el) => randint(-10, 11, [0]));
-//       a = b * randint(0, 11);
-//       c = d * randint(0, 11);
-//       statement = new AddNode(
-//         new MultiplyNode(new MultiplyNode(new NumberNode(a), new NumberNode(b)), new NumberNode(c)),
-//         new NumberNode(d)
-//       ).shuffle();
-//       answer = (a * b * c + d).toString();
-//       break;
-//   }
-//   const question: Question = {
-//     startStatement: latexParser(statement!),
-//     answer: answer,
-//   };
-//   return question;
-// }

package/lib/exercises/geometry/cartesian/midpoint.js

@@ -1,29 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getMidpointQuestion = exports.midpoint = void 0;
-const point_1 = require("../../../geometry/point");
-const randTupleInt_1 = require("../../../mathutils/random/randTupleInt");
-const numberNode_1 = require("../../../tree/nodes/numbers/numberNode");
-const getDistinctQuestions_1 = require("../../utils/getDistinctQuestions");
-exports.midpoint = {
-    id: 'midpoint',
-    connector: '=',
-    instruction: '',
-    label: 'Coordonnées du milieu',
-    levels: ['3', '2', '1'],
-    isSingleStep: false,
-    section: 'Géométrie cartésienne',
-    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getMidpointQuestion, nb),
-};
-function getMidpointQuestion() {
-    const [coords1, coords2] = (0, randTupleInt_1.distinctRandTupleInt)(2, 2, { from: -9, to: 10 });
-    const A = new point_1.Point('A', new numberNode_1.NumberNode(coords1[0]), new numberNode_1.NumberNode(coords1[1]));
-    const B = new point_1.Point('B', new numberNode_1.NumberNode(coords2[0]), new numberNode_1.NumberNode(coords2[1]));
-    const question = {
-        instruction: `Soit $${A.toTexWithCoords()}$ et $${B.toTexWithCoords()}$. Quelles sont les coordonnées du milieu $I$ de $[AB]$ ?`,
-        startStatement: 'I',
-        answer: A.midpoint(B).toTexWithCoords(),
-    };
-    return question;
-}
-exports.getMidpointQuestion = getMidpointQuestion;