math-exercises 2.1.24 → 2.1.26

package/lib/exercises/trigonometry/trigonometryAngleCalcul.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trigonometryAngleCalcul = void 0;
+const exercise_1 = require("../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../exercises/utils/getDistinctQuestions");
+const geogebraConstructor_1 = require("../../geogebra/geogebraConstructor");
+const triangles_1 = require("../../math/geometry/triangles");
+const randint_1 = require("../../math/utils/random/randint");
+const round_1 = require("../../math/utils/round");
+const shuffle_1 = require("../../utils/shuffle");
+const getTrigonometryAngleCalcul = () => {
+    const vertices = [];
+    const code = 65 + (0, randint_1.randint)(0, 24); // Générer un code de caractère majuscule aléatoire (A-Z)
+    for (let i = 0; i < 3; i++)
+        vertices.push(String.fromCharCode(code + i));
+    const triangle = triangles_1.TriangleConstructor.createRandomRightTriangle({
+        minRapport: 0.5,
+        maxRapport: 1.5,
+        names: vertices,
+    });
+    const sides = [
+        triangle.getSideCName(),
+        triangle.getSideBName(),
+        triangle.getSideAName(),
+    ];
+    const sideLengths = [
+        triangle.getSideCnumber(),
+        triangle.getSideBnumber(),
+        triangle.getSideAnumber(),
+    ].map((el) => (0, round_1.round)(el / 2, 2));
+    const angle = [triangle.vertexB.name, triangle.vertexC.name];
+    const randAngle = (0, randint_1.randint)(0, 2);
+    const randSides = (0, shuffle_1.shuffle)([0, 1, 2]);
+    const answer = randAngle === 0
+        ? Math.round((Math.acos(sideLengths[0] / sideLengths[2]) * 180) / Math.PI)
+        : Math.round((Math.acos(sideLengths[1] / sideLengths[2]) * 180) / Math.PI);
+    const answerTex = answer + "^{\\circ}";
+    const ggb = new geogebraConstructor_1.GeogebraConstructor(triangle.generateCommands({ highlightedAngle: angle[randAngle] }), {
+        hideAxes: true,
+        hideGrid: true,
+    });
+    const question = {
+        instruction: `Le triangle $${triangle.getTriangleName()}$ rectangle en $${triangle.getRightAngle()}$ est tel que $${sides[randSides[0]]} = ${(sideLengths[randSides[0]] + "").replace(".", ",")}$ cm et $${sides[randSides[1]]} = ${(sideLengths[randSides[1]] + "").replace(".", ",")}$ cm. Calculer $\\widehat{${angle[randAngle]}}$ à $1^\\circ$ près.`,
+        answer: answerTex,
+        keys: ["degree"],
+        commands: ggb.commands,
+        options: ggb.getOptions(),
+        coords: triangle.generateCoords(),
+        answerFormat: "tex",
+        identifiers: { randAngle, sideLengths, randSides },
+    };
+    return question;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, (0, randint_1.randint)(20, 80) + "°");
+    }
+    return (0, shuffle_1.shuffle)(propositions);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return [answer, answer.split("^")[0]].includes(ans);
+};
+exports.trigonometryAngleCalcul = {
+    id: "trigonometryAngleCalcul",
+    connector: "=",
+    label: "Utiliser la trigonométrie pour calculer un angle",
+    levels: ["4ème", "3ème", "2nde"],
+    isSingleStep: false,
+    sections: ["Trigonométrie", "Géométrie euclidienne"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getTrigonometryAngleCalcul, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    hasGeogebra: true,
+};

package/lib/exercises/trigonometry/trigonometrySideCalcul.d.ts

@@ -0,0 +1,10 @@
+import { MathExercise } from "../../exercises/exercise";
+type Identifiers = {
+    sideLengths: number[];
+    randAngle: number;
+    randSide: number;
+    randSideQuestion: number;
+};
+export declare const trigonometrySideCalcul: MathExercise<Identifiers>;
+export {};
+//# sourceMappingURL=trigonometrySideCalcul.d.ts.map

package/lib/exercises/trigonometry/trigonometrySideCalcul.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trigonometrySideCalcul.d.ts","sourceRoot":"","sources":["../../../src/exercises/trigonometry/trigonometrySideCalcul.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AASlC,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,gBAAgB,EAAE,MAAM,CAAC;CAC1B,CAAC;AA4FF,eAAO,MAAM,sBAAsB,EAAE,YAAY,CAAC,WAAW,CAc5D,CAAC"}

package/lib/exercises/trigonometry/trigonometrySideCalcul.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trigonometrySideCalcul = void 0;
+const exercise_1 = require("../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../exercises/utils/getDistinctQuestions");
+const geogebraConstructor_1 = require("../../geogebra/geogebraConstructor");
+const triangles_1 = require("../../math/geometry/triangles");
+const randint_1 = require("../../math/utils/random/randint");
+const round_1 = require("../../math/utils/round");
+const numberNode_1 = require("../../tree/nodes/numbers/numberNode");
+const shuffle_1 = require("../../utils/shuffle");
+const getTrigonometrySideCalcul = () => {
+    const vertices = [];
+    const code = 65 + (0, randint_1.randint)(0, 24); // Générer un code de caractère majuscule aléatoire (A-Z)
+    for (let i = 0; i < 3; i++)
+        vertices.push(String.fromCharCode(code + i));
+    const triangle = triangles_1.TriangleConstructor.createRandomRightTriangle({
+        minRapport: 0.5,
+        maxRapport: 1.5,
+        names: vertices,
+    });
+    const sides = [
+        triangle.getSideCName(),
+        triangle.getSideBName(),
+        triangle.getSideAName(),
+    ];
+    const sideLengths = [
+        triangle.getSideCnumber(),
+        triangle.getSideBnumber(),
+        triangle.getSideAnumber(),
+    ].map((el) => (0, round_1.round)(el / 2, 2));
+    const angle = [triangle.vertexB.name, triangle.vertexC.name];
+    const randAngle = (0, randint_1.randint)(0, 2);
+    const randSide = (0, randint_1.randint)(0, 3); // valeurs possible : 0 1 2
+    const randSideQuestion = (0, randint_1.randint)(0, 3, [randSide]); // si rand = 0, valeurs possible 1 2
+    const angleValue = [
+        (0, round_1.round)((Math.acos(sideLengths[0] / sideLengths[2]) * 180) / Math.PI, 1),
+        (0, round_1.round)((Math.acos(sideLengths[1] / sideLengths[2]) * 180) / Math.PI, 1),
+    ];
+    const commands = [
+        ...triangle.generateCommands({
+            highlightedAngle: angle[randAngle],
+            colorHighlightedAngle: "Black",
+            showLabels: [sides[randSideQuestion]],
+            setCaptions: ["?"],
+            highlightedSide: sides[randSideQuestion],
+        }),
+    ];
+    const ggb = new geogebraConstructor_1.GeogebraConstructor(commands, {
+        hideAxes: true,
+        hideGrid: true,
+    });
+    const answer = `${((0, round_1.round)(sideLengths[randSideQuestion], 1) + "").replace(".", ",")}`;
+    const question = {
+        instruction: `Le triangle $${triangle.getTriangleName()}$ rectangle en $${triangle.getRightAngle()}$ est tel que $${sides[randSide]} = ${(sideLengths[randSide] + "").replace(".", ",")}$ cm et $\\widehat{${angle[randAngle]}} = ${(angleValue[randAngle] + "").replace(".", ",")}^\\circ$. Calculer $${sides[randSideQuestion]}$ à $0,1$ cm près.`,
+        answer,
+        keys: [],
+        commands: ggb.commands,
+        options: ggb.getOptions(),
+        coords: triangle.generateCoords(),
+        answerFormat: "tex",
+        identifiers: { randAngle, randSide, randSideQuestion, sideLengths },
+    };
+    return question;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, `${((0, round_1.round)((0, randint_1.randint)(11, 100) / 10, 1) + "").replace(".", ",")}`);
+    }
+    return (0, shuffle_1.shuffle)(propositions);
+};
+const isAnswerValid = (ans, { answer }) => {
+    const answerTree = new numberNode_1.NumberNode(Number(answer.replace(",", ".")));
+    const texs = answerTree.toAllValidTexs();
+    return texs.includes(ans);
+};
+exports.trigonometrySideCalcul = {
+    id: "trigonometrySideCalcul",
+    connector: "=",
+    label: "Utiliser la trigonométrie pour calculer un côté",
+    levels: ["4ème", "3ème", "2nde"],
+    isSingleStep: false,
+    sections: ["Trigonométrie", "Géométrie euclidienne"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getTrigonometrySideCalcul, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    hasGeogebra: true,
+};

package/lib/math/geometry/droite.d.ts

@@ -0,0 +1,20 @@
+import { Node } from '../../tree/nodes/node';
+import { Point } from './point';
+export declare abstract class DroiteConstructor {
+    static fromTwoPoints(A: Point, B: Point, name?: string): Droite;
+    static fromPointAndSlope(A: Point, m: Node, name?: string): Droite;
+    static fromPointAndAngle(A: Point, theta: Node, name?: string): Droite;
+}
+export declare class Droite {
+    name: string;
+    a: Node;
+    b: Node;
+    constructor(name: string | undefined, a: Node, b: Node);
+    toTex(): string;
+    toEquationForm(): string;
+    toEquationExpression(): string;
+    toPolynome(): string;
+    getLeadingCoefficient(): string;
+    intersection(D: Droite, name?: string): Point | void;
+}
+//# sourceMappingURL=droite.d.ts.map

package/lib/math/geometry/droite.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"droite.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/droite.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,uBAAuB,CAAC;AAQ7C,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAIhC,8BAAsB,iBAAiB;IACrC,MAAM,CAAC,aAAa,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,IAAI,SAAM,GAAG,MAAM;IAM5D,MAAM,CAAC,iBAAiB,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,IAAI,EAAE,IAAI,SAAM,GAAG,MAAM;IAI/D,MAAM,CAAC,iBAAiB,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,SAAM,GAAG,MAAM;CAKpE;AAED,qBAAa,MAAM;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,IAAI,CAAC;IACR,CAAC,EAAE,IAAI,CAAC;gBAEI,IAAI,oBAAM,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI;IAOxC,KAAK,IAAI,MAAM;IAIf,cAAc,IAAI,MAAM;IAIxB,oBAAoB,IAAI,MAAM;IAI9B,UAAU,IAAI,MAAM;IAKpB,qBAAqB,IAAI,MAAM;IAI/B,YAAY,CAAC,CAAC,EAAE,MAAM,EAAE,IAAI,SAAM,GAAG,KAAK,GAAG,IAAI;CAMlD"}

package/lib/math/geometry/droite.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Droite = exports.DroiteConstructor = void 0;
+const numberNode_1 = require("../../tree/nodes/numbers/numberNode");
+const addNode_1 = require("../../tree/nodes/operators/addNode");
+const fractionNode_1 = require("../../tree/nodes/operators/fractionNode");
+const multiplyNode_1 = require("../../tree/nodes/operators/multiplyNode");
+const substractNode_1 = require("../../tree/nodes/operators/substractNode");
+const simplify_1 = require("../../tree/parsers/simplify");
+const mathjs_1 = require("mathjs");
+const point_1 = require("./point");
+const polynomial_1 = require("../polynomials/polynomial");
+const round_1 = require("../utils/round");
+class DroiteConstructor {
+    static fromTwoPoints(A, B, name = 'd') {
+        const a = new fractionNode_1.FractionNode(new substractNode_1.SubstractNode(B.y, A.y), new substractNode_1.SubstractNode(B.x, A.x));
+        const b = new substractNode_1.SubstractNode(A.y, new multiplyNode_1.MultiplyNode(a, A.x));
+        return new Droite(name, (0, simplify_1.simplifyNode)(a), (0, simplify_1.simplifyNode)(b));
+    }
+    static fromPointAndSlope(A, m, name = 'd') {
+        return new Droite(name, (0, simplify_1.simplifyNode)(m), (0, simplify_1.simplifyNode)(new substractNode_1.SubstractNode(A.y, new multiplyNode_1.MultiplyNode(m, A.x))));
+    }
+    static fromPointAndAngle(A, theta, name = 'd') {
+        const m = new numberNode_1.NumberNode((0, round_1.round)(Math.tan(parseFloat(theta.toMathString())), 2));
+        const b = new substractNode_1.SubstractNode(A.y, new multiplyNode_1.MultiplyNode(m, A.x));
+        return new Droite(name, (0, simplify_1.simplifyNode)(m), (0, simplify_1.simplifyNode)(b));
+    }
+}
+exports.DroiteConstructor = DroiteConstructor;
+class Droite {
+    constructor(name = 'D', a, b) {
+        // ax + b
+        this.name = name;
+        this.a = a;
+        this.b = b;
+    }
+    toTex() {
+        return `${this.name}`;
+    }
+    toEquationForm() {
+        return `${this.a.toTex()}x+${this.b.toTex()}`;
+    }
+    toEquationExpression() {
+        return `(${this.name}) : y = ${this.toEquationForm()}`; // (D) : y = ax + b
+    }
+    toPolynome() {
+        const polynome = new polynomial_1.Polynomial([(0, mathjs_1.evaluate)(this.b.toMathString()), (0, mathjs_1.evaluate)(this.a.toMathString())], 'x');
+        return polynome.toTex();
+    }
+    getLeadingCoefficient() {
+        return `${(0, simplify_1.simplifyNode)(this.a).toTex()}`;
+    }
+    // TODO : ajouter des conditions ou cas ou les deux droites sont Parallèles
+    intersection(D, name = 'P') {
+        if ((0, mathjs_1.evaluate)(D.a.toMathString()) === (0, mathjs_1.evaluate)(this.a.toMathString()))
+            return;
+        const x = new fractionNode_1.FractionNode(new substractNode_1.SubstractNode(D.b, this.b), new substractNode_1.SubstractNode(this.a, D.a));
+        const y = new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(this.a, x), this.b);
+        return new point_1.Point(name, (0, simplify_1.simplifyNode)(x), (0, simplify_1.simplifyNode)(y));
+    }
+}
+exports.Droite = Droite;

package/lib/tree/nodes/expression/expressionNode.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=expressionNode.d.ts.map

package/lib/tree/nodes/expression/expressionNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expressionNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/expression/expressionNode.ts"],"names":[],"mappings":""}

package/lib/tree/nodes/expression/expressionNode.js

@@ -0,0 +1 @@
+"use strict";

package/lib/tree/nodes/operators/equalNode.d.ts

@@ -0,0 +1,16 @@
+import { Node } from '../node';
+import { OperatorNode } from './operatorNode';
+type EqualNodeOptions = {
+    isRightChildOnlyValid?: boolean;
+};
+export declare class EqualNode extends OperatorNode implements Node {
+    opts: EqualNodeOptions | undefined;
+    constructor(leftChild: Node, rightChild: Node, opts?: EqualNodeOptions);
+    toEquivalentNodes(): Node[];
+    toAllValidTexs(): string[];
+    toMathString(): string;
+    toTex(): string;
+    toMathjs(): boolean | import("mathjs").MathCollection;
+}
+export {};
+//# sourceMappingURL=equalNode.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"equalNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/equalNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAY,MAAM,SAAS,CAAC;AACzC,OAAO,EAAe,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAE3D,KAAK,gBAAgB,GAAG;IACtB,qBAAqB,CAAC,EAAE,OAAO,CAAC;CACjC,CAAC;AACF,qBAAa,SAAU,SAAQ,YAAa,YAAW,IAAI;IACzD,IAAI,EAAE,gBAAgB,GAAG,SAAS,CAAC;gBACvB,SAAS,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,IAAI,CAAC,EAAE,gBAAgB;IAKtE,iBAAiB;IAiBjB,cAAc,IAAI,MAAM,EAAE;IAI1B,YAAY,IAAI,MAAM;IAGtB,KAAK,IAAI,MAAM;IAIf,QAAQ;CAGT"}

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

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EqualNode = void 0;
+const mathjs_1 = require("mathjs");
+const operatorNode_1 = require("./operatorNode");
+class EqualNode extends operatorNode_1.OperatorNode {
+    constructor(leftChild, rightChild, opts) {
+        super(operatorNode_1.OperatorIds.equal, leftChild, rightChild, true, '=');
+        this.opts = opts;
+    }
+    toEquivalentNodes() {
+        const res = [];
+        const rightNodes = this.rightChild.toEquivalentNodes();
+        if (this.opts?.isRightChildOnlyValid) {
+            res.push(...rightNodes);
+        }
+        const leftNodes = this.leftChild.toEquivalentNodes();
+        rightNodes.forEach((rightNode) => {
+            leftNodes.forEach((leftNode) => {
+                res.push(new EqualNode(leftNode, rightNode));
+                res.push(new EqualNode(rightNode, leftNode));
+            });
+        });
+        return res;
+    }
+    toAllValidTexs() {
+        return this.toEquivalentNodes().map((node) => node.toTex());
+    }
+    toMathString() {
+        return `${this.leftChild.toMathString()} = ${this.rightChild.toMathString()}`;
+    }
+    toTex() {
+        return `${this.leftChild.toTex()}=${this.rightChild.toTex()}`;
+    }
+    toMathjs() {
+        return (0, mathjs_1.equal)(this.leftChild.toMathjs(), this.rightChild.toMathjs());
+    }
+}
+exports.EqualNode = EqualNode;

package/lib/tree/parsers/simplify.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=simplify.d.ts.map

package/lib/tree/parsers/simplify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"simplify.d.ts","sourceRoot":"","sources":["../../../src/tree/parsers/simplify.ts"],"names":[],"mappings":""}

package/lib/tree/parsers/simplify.js

@@ -0,0 +1,99 @@
+"use strict";
+// import { Complex, complex, simplify as mathsimplify } from "mathjs";
+// import { OppositeNode } from "../nodes/functions/oppositeNode";
+// import { SqrtNode } from "../nodes/functions/sqrtNode";
+// import { Node } from "../nodes/node";
+// import { NumberNode } from "../nodes/numbers/numberNode";
+// import { PiNode } from "../nodes/numbers/piNode";
+// import { AddNode } from "../nodes/operators/addNode";
+// import { FractionNode } from "../nodes/operators/fractionNode";
+// import { MultiplyNode } from "../nodes/operators/multiplyNode";
+// import { PowerNode } from "../nodes/operators/powerNode";
+// import { SubstractNode } from "../nodes/operators/substractNode";
+// import { VariableNode } from "../nodes/variables/variableNode";
+// import { LogNode } from "../nodes/functions/logNode";
+// import { ExpNode } from "../nodes/functions/expNode";
+// import { CosNode } from "../../tree/nodes/functions/cosNode";
+// import { SinNode } from "../../tree/nodes/functions/sinNode";
+// import { ComplexNode } from "../nodes/complex/complexNode";
+// interface MathjsNode {
+//   isSymbolNode: boolean;
+//   isFunctionNode: boolean;
+//   isConstantNode: boolean;
+//   isOperatorNode: boolean;
+//   fn?: MathjsNode | string;
+//   name?: string;
+//   value?: any;
+//   args?: MathjsNode[];
+// }
+// export const simplifyComplex = (node: Node): Node => {
+//   return mathjsComplexToNode(complex(node.toMathjs()));
+// };
+// const mathjsComplexToNode = (complex: Complex) => {
+//   return new ComplexNode(
+//     new NumberNode(complex.re),
+//     new NumberNode(complex.im),
+//   );
+// };
+// export const simplifyNode = (node: Node): Node => {
+//   return mathjsNodeToNode(
+//     mathsimplify(node.toMathString()) as unknown as MathjsNode,
+//   );
+// };
+// const mathjsNodeToNode = (mathjsNode: MathjsNode): Node => {
+//   if (mathjsNode.isSymbolNode) {
+//     if (mathjsNode.name === "pi") return PiNode;
+//     return new VariableNode(mathjsNode.name!);
+//   } else if (mathjsNode.isConstantNode) {
+//     return new NumberNode(mathjsNode.value!);
+//   } else if (mathjsNode.isOperatorNode) {
+//     switch (mathjsNode.fn) {
+//       case "add":
+//         return new AddNode(
+//           mathjsNodeToNode(mathjsNode.args![0]),
+//           mathjsNodeToNode(mathjsNode.args![1]),
+//         );
+//       case "subtract":
+//         return new SubstractNode(
+//           mathjsNodeToNode(mathjsNode.args![0]),
+//           mathjsNodeToNode(mathjsNode.args![1]),
+//         );
+//       case "unaryMinus":
+//         return new OppositeNode(mathjsNodeToNode(mathjsNode.args![0]));
+//       case "divide":
+//         return new FractionNode(
+//           mathjsNodeToNode(mathjsNode.args![0]),
+//           mathjsNodeToNode(mathjsNode.args![1]),
+//         );
+//       case "multiply":
+//         return new MultiplyNode(
+//           mathjsNodeToNode(mathjsNode.args![0]),
+//           mathjsNodeToNode(mathjsNode.args![1]),
+//         );
+//       case "pow":
+//         return new PowerNode(
+//           mathjsNodeToNode(mathjsNode.args![0]),
+//           mathjsNodeToNode(mathjsNode.args![1]),
+//         );
+//     }
+//   } else if (mathjsNode.isFunctionNode) {
+//     const fn = mathjsNode.fn as MathjsNode;
+//     switch (fn.name) {
+//       //mathjs arrondit les racines carrées, on truc avec sqr pour bypass
+//       case "sqr":
+//         return new SqrtNode(mathjsNodeToNode(mathjsNode.args![0]));
+//       case "sqrt":
+//         return new SqrtNode(mathjsNodeToNode(mathjsNode.args![0]));
+//       case "log":
+//         return new LogNode(mathjsNodeToNode(mathjsNode.args![0]));
+//       case "exp":
+//         return new ExpNode(mathjsNodeToNode(mathjsNode.args![0]));
+//       case "cos":
+//         return new CosNode(mathjsNodeToNode(mathjsNode.args![0]));
+//       case "sin":
+//         return new SinNode(mathjsNodeToNode(mathjsNode.args![0]));
+//     }
+//   }
+//   console.log(mathjsNode);
+//   throw Error("unrecognized mathjs node");
+// };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "math-exercises",
-  "version": "2.1.24",
+  "version": "2.1.26",
   "description": "Math exercises generator for middle school and high school",
   "main": "lib/index.js",
   "files": [