math-exercises 2.2.40 → 2.2.42

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,OAAO,yBAAyB,CAAC;AAEjC,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,OAAO,yBAAyB,CAAC;AAEjC,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,CAAC"}

package/lib/math/sets/intervals/intervals.js

@@ -98,7 +98,7 @@ class Interval {
                 : interval.rightBracket;
         let unionLeftBracket = this.min < interval.min
             ? this.leftBracket
-            : this.max === interval.max
+            : this.min === interval.min
                 ? this.leftBracket === "[" || interval.leftBracket === "["
                     ? "["
                     : "]"

package/lib/math/systems/system.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"system.d.ts","sourceRoot":"","sources":["../../../src/math/systems/system.ts"],"names":[],"mappings":"AASA,8BAAsB,iBAAiB;IACrC,MAAM,CAAC,MAAM;IAeb,MAAM,CAAC,UAAU;CAiBlB;AACD,qBAAa,MAAM;IACjB,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC;gBAEP,MAAM,EAAE,MAAM,EAAE,EAAE;IAG9B,KAAK;;;;IAuCL,KAAK;CAcN"}
+{"version":3,"file":"system.d.ts","sourceRoot":"","sources":["../../../src/math/systems/system.ts"],"names":[],"mappings":"AASA,8BAAsB,iBAAiB;IACrC,MAAM,CAAC,MAAM;IAeb,MAAM,CAAC,UAAU;CAiBlB;AACD,qBAAa,MAAM;IACjB,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC;gBAEP,MAAM,EAAE,MAAM,EAAE,EAAE;IAG9B,KAAK;;;;IA4CL,KAAK;CAcN"}

package/lib/math/systems/system.js

@@ -45,14 +45,36 @@ class System {
     solve() {
         if (this.coeffs.length !== 2)
             throw Error("General system resolution not implemented yet");
-        //x = (c'-b'c/b)/(a'-b'a/b)
-        if (!this.coeffs[0][1] ||
-            this.coeffs[1][0] ===
-                (this.coeffs[1][1] * this.coeffs[0][0]) / this.coeffs[0][1])
+        const [a, b, c] = this.coeffs[0];
+        const [d, e, f] = this.coeffs[1];
+        if (!b || d * b === e * a)
             throw Error("No solution");
-        const x = new fractionNode_1.FractionNode(new substractNode_1.SubstractNode(this.coeffs[1][2].toTree(), new fractionNode_1.FractionNode((this.coeffs[1][1] * this.coeffs[0][2]).toTree(), this.coeffs[0][1].toTree())), new substractNode_1.SubstractNode(this.coeffs[1][0].toTree(), new fractionNode_1.FractionNode((this.coeffs[1][1] * this.coeffs[0][0]).toTree(), this.coeffs[0][1].toTree()))).simplify();
-        //y = c-ax/b
-        const y = new fractionNode_1.FractionNode(new substractNode_1.SubstractNode(this.coeffs[0][2].toTree(), new multiplyNode_1.MultiplyNode(this.coeffs[0][0].toTree(), x)), this.coeffs[0][1].toTree()).simplify();
+        const x = new fractionNode_1.FractionNode((b * f - e * c).toTree(), (d * b - e * a).toTree()).simplify();
+        const y = new fractionNode_1.FractionNode(new substractNode_1.SubstractNode(c.toTree(), new multiplyNode_1.MultiplyNode(a.toTree(), x)), b.toTree()).simplify();
+        // const x = new FractionNode(
+        //   new SubstractNode(
+        //     this.coeffs[1][2].toTree(),
+        //     new FractionNode(
+        //       (this.coeffs[1][1] * this.coeffs[0][2]).toTree(),
+        //       this.coeffs[0][1].toTree(),
+        //     ).simplify(),
+        //   ).simplify(),
+        //   new SubstractNode(
+        //     this.coeffs[1][0].toTree(),
+        //     new FractionNode(
+        //       (this.coeffs[1][1] * this.coeffs[0][0]).toTree(),
+        //       this.coeffs[0][1].toTree(),
+        //     ).simplify(),
+        //   ).simplify(),
+        // ).simplify();
+        // //y = c-ax/b
+        // const y = new FractionNode(
+        //   new SubstractNode(
+        //     this.coeffs[0][2].toTree(),
+        //     new MultiplyNode(this.coeffs[0][0].toTree(), x).simplify(),
+        //   ).simplify(),
+        //   this.coeffs[0][1].toTree(),
+        // ).simplify();
         return {
             x,
             y,

package/lib/playground.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"playground.d.ts","sourceRoot":"","sources":["../src/playground.ts"],"names":[],"mappings":"AA8BA,eAAO,MAAM,UAAU,YAAW,CAAC"}
+{"version":3,"file":"playground.d.ts","sourceRoot":"","sources":["../src/playground.ts"],"names":[],"mappings":"AAkCA,eAAO,MAAM,UAAU,YAMtB,CAAC"}

package/lib/playground.js

@@ -1,5 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.playground = void 0;
-const playground = () => { };
+const playground = () => {
+    // const frac = new AddNode(
+    //   (3).toTree(),
+    //   new OppositeNode(new FractionNode((1).toTree(), (2).toTree())),
+    // ).simplify();
+    // console.log(frac.toTex());
+};
 exports.playground = playground;

package/lib/server.js

@@ -58,11 +58,14 @@ const runServer = () => {
     });
     app.get("/exo", (req, res) => {
         const exoId = req.query.exoId;
+        const options = req.query.options
+            ? JSON.parse(req.query.options)
+            : undefined;
         const exoIndex = allExercises.findIndex((exo) => exo.id == exoId);
         const exo = allExercises[exoIndex];
         if (!exo)
             res.send("Exo not found");
-        const questions = exo?.generator(10);
+        const questions = exo?.generator(10, options);
         res.json({
             exercise: exo,
             questions,
@@ -97,6 +100,10 @@ const runServer = () => {
     });
     app.post("/vea", jsonParser, (req, res) => {
         const exoId = req.query.exoId;
+        const options = req.query.options
+            ? JSON.parse(req.query.options)
+            : undefined;
+        console.log("vea opts", options);
         const { ans, veaProps } = req.body;
         const exoIndex = allExercises.findIndex((exo) => exo.id == exoId);
         const exo = allExercises[exoIndex];
@@ -108,7 +115,7 @@ const runServer = () => {
             res.send("No VEA implemented");
             return;
         }
-        const result = exo.isAnswerValid(ans, veaProps) ?? false;
+        const result = exo.isAnswerValid(ans, veaProps, options) ?? false;
         res.json({
             result,
         });

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

@@ -1 +1 @@
-{"version":3,"file":"addNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/addNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAC7E,OAAO,EACL,uBAAuB,EACvB,WAAW,EAGZ,MAAM,gBAAgB,CAAC;AAKxB,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAQlE,wBAAgB,SAAS,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,OAAO,CAE/C;AAED,qBAAa,OAAQ,YAAW,uBAAuB;IACrD,EAAE,EAAE,WAAW,CAAC;IAChB,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,aAAa,CAAC;IAC1B,IAAI,EAAE,QAAQ,CAAC;IACf,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,SAAS,EAAE,OAAO,CAAC;gBAEjB,SAAS,EAAE,aAAa,EACxB,UAAU,EAAE,aAAa,EACzB,IAAI,CAAC,EAAE,WAAW;IASpB,OAAO,aAGL;IAEF,YAAY,IAAI,MAAM;IAItB,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,aAAa,EAAE;IAoCtD,SAAS,IAAI,MAAM,EAAE;IAIrB,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAK5C,KAAK,CAAC,OAAO,CAAC,EAAE,YAAY,GAAG,MAAM;IAerC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAMrC,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe,GAAG,aAAa;IA0K/C,aAAa;;;;;;;;;IAOb,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;CAUrC"}
+{"version":3,"file":"addNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/addNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAC7E,OAAO,EACL,uBAAuB,EACvB,WAAW,EAGZ,MAAM,gBAAgB,CAAC;AAKxB,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAQlE,wBAAgB,SAAS,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,OAAO,CAE/C;AAED,qBAAa,OAAQ,YAAW,uBAAuB;IACrD,EAAE,EAAE,WAAW,CAAC;IAChB,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,aAAa,CAAC;IAC1B,IAAI,EAAE,QAAQ,CAAC;IACf,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,SAAS,EAAE,OAAO,CAAC;gBAEjB,SAAS,EAAE,aAAa,EACxB,UAAU,EAAE,aAAa,EACzB,IAAI,CAAC,EAAE,WAAW;IASpB,OAAO,aAGL;IAEF,YAAY,IAAI,MAAM;IAItB,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,aAAa,EAAE;IAoCtD,SAAS,IAAI,MAAM,EAAE;IAIrB,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAK5C,KAAK,CAAC,OAAO,CAAC,EAAE,YAAY,GAAG,MAAM;IAerC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAMrC,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe,GAAG,aAAa;IAgP/C,aAAa;;;;;;;;;IAOb,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;CAUrC"}

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

@@ -131,18 +131,59 @@ class AddNode {
                 const f = b.rightChild;
                 return new fractionNode_1.FractionNode(new AddNode(new multiplyNode_1.MultiplyNode(c, f), new multiplyNode_1.MultiplyNode(e, d)), new multiplyNode_1.MultiplyNode(d, f)).simplify(opts);
             }
+            if ((0, oppositeNode_1.isOppositeNode)(a) && (0, fractionNode_1.isFractionNode)(a.child) && (0, fractionNode_1.isFractionNode)(b)) {
+                //-(c/d) + e/f   =  -cf+ed / df
+                const c = a.child.leftChild;
+                const d = a.child.rightChild;
+                const e = b.leftChild;
+                const f = b.rightChild;
+                return new fractionNode_1.FractionNode(new AddNode(new multiplyNode_1.MultiplyNode(new oppositeNode_1.OppositeNode(c), f), new multiplyNode_1.MultiplyNode(e, d)), new multiplyNode_1.MultiplyNode(d, f)).simplify(opts);
+            }
+            if ((0, oppositeNode_1.isOppositeNode)(b) && (0, fractionNode_1.isFractionNode)(b.child) && (0, fractionNode_1.isFractionNode)(a)) {
+                //(c/d) + (-e/f)   =  cf-ed / df
+                const c = a.leftChild;
+                const d = a.rightChild;
+                const e = b.child.leftChild;
+                const f = b.child.rightChild;
+                return new fractionNode_1.FractionNode(new AddNode(new multiplyNode_1.MultiplyNode(c, f), new multiplyNode_1.MultiplyNode(new oppositeNode_1.OppositeNode(e), d)), new multiplyNode_1.MultiplyNode(d, f)).simplify(opts);
+            }
+            if ((0, oppositeNode_1.isOppositeNode)(b) &&
+                (0, fractionNode_1.isFractionNode)(b.child) &&
+                (0, oppositeNode_1.isOppositeNode)(a) &&
+                (0, fractionNode_1.isFractionNode)(a.child)) {
+                //-(c/d) + (-e/f)   =  -cf-ed / df
+                const c = a.child.leftChild;
+                const d = a.child.rightChild;
+                const e = b.child.leftChild;
+                const f = b.child.rightChild;
+                return new fractionNode_1.FractionNode(new AddNode(new multiplyNode_1.MultiplyNode(new oppositeNode_1.OppositeNode(c), f), new multiplyNode_1.MultiplyNode(new oppositeNode_1.OppositeNode(e), d)), new multiplyNode_1.MultiplyNode(d, f)).simplify(opts);
+            }
             if ((0, fractionNode_1.isFractionNode)(a)) {
                 //c/d + b
                 const c = a.leftChild;
                 const d = a.rightChild;
                 return new fractionNode_1.FractionNode(new AddNode(c, new multiplyNode_1.MultiplyNode(d, b)), d).simplify(opts);
             }
+            if ((0, oppositeNode_1.isOppositeNode)(a) && (0, fractionNode_1.isFractionNode)(a.child)) {
+                //-(c/d) + b = (-c+bd)/d
+                const c = a.child.leftChild;
+                const d = a.child.rightChild;
+                return new fractionNode_1.FractionNode(new AddNode(new oppositeNode_1.OppositeNode(c), new multiplyNode_1.MultiplyNode(d, b)), d).simplify(opts);
+            }
             if ((0, fractionNode_1.isFractionNode)(b) && !opts?.forceDistributeFractions) {
                 //a+c/d
                 const c = b.leftChild;
                 const d = b.rightChild;
                 return new fractionNode_1.FractionNode(new AddNode(c, new multiplyNode_1.MultiplyNode(d, a)), d).simplify(opts);
             }
+            if ((0, oppositeNode_1.isOppositeNode)(b) &&
+                (0, fractionNode_1.isFractionNode)(b.child) &&
+                !opts?.forceDistributeFractions) {
+                //a+-(c/d) = (da-c)/d
+                const c = b.child.leftChild;
+                const d = b.child.rightChild;
+                return new fractionNode_1.FractionNode(new AddNode(new oppositeNode_1.OppositeNode(c), new multiplyNode_1.MultiplyNode(d, a)), d).simplify(opts);
+            }
             if ((0, numberNode_1.isNumberNode)(a) && (0, numberNode_1.isNumberNode)(b)) {
                 return new numberNode_1.NumberNode(a.value + b.value);
             }

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

@@ -1 +1 @@
-{"version":3,"file":"fractionNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/fractionNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAC/D,OAAO,EAAE,WAAW,EAAE,YAAY,EAAkB,MAAM,gBAAgB,CAAC;AAK3E,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAKlE,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,YAAY,CAEzD;AACD,qBAAa,YAAa,YAAW,YAAY;IAC/C,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB;;;OAGG;IACH,EAAE,EAAE,WAAW,CAAC;IAChB,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,aAAa,CAAC;IAC1B,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;gBAEjB,SAAS,EAAE,aAAa,EACxB,UAAU,EAAE,aAAa,EACzB,IAAI,CAAC,EAAE,WAAW;IAUpB,YAAY,IAAI,MAAM;IAItB,aAAa;;;;;;;;;IAQb,UAAU;IAGV,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;IA+BpC,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAI5C,KAAK,IAAI,MAAM;IAcf,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAMrC,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe,GAAG,aAAa;IAgJ/C,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;CAOrC"}
+{"version":3,"file":"fractionNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/fractionNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAC/D,OAAO,EAAE,WAAW,EAAE,YAAY,EAAkB,MAAM,gBAAgB,CAAC;AAK3E,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAKlE,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,YAAY,CAEzD;AACD,qBAAa,YAAa,YAAW,YAAY;IAC/C,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB;;;OAGG;IACH,EAAE,EAAE,WAAW,CAAC;IAChB,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,aAAa,CAAC;IAC1B,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;gBAEjB,SAAS,EAAE,aAAa,EACxB,UAAU,EAAE,aAAa,EACzB,IAAI,CAAC,EAAE,WAAW;IAUpB,YAAY,IAAI,MAAM;IAItB,aAAa;;;;;;;;;IAQb,UAAU;IAGV,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;IA+BpC,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAI5C,KAAK,IAAI,MAAM;IAcf,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAMrC,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe,GAAG,aAAa;IA2J/C,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;CAOrC"}

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

@@ -107,6 +107,10 @@ class FractionNode {
                 oppositesCount++;
                 recursiveNums(node.child);
             }
+            else if ((0, numberNode_1.isNumberNode)(node) && node.value < 0) {
+                oppositesCount++;
+                externalsNums.push(new numberNode_1.NumberNode(Math.abs(node.value)));
+            }
             else {
                 externalsNums.push(node);
             }
@@ -118,7 +122,11 @@ class FractionNode {
             }
             else if ((0, oppositeNode_1.isOppositeNode)(node)) {
                 oppositesCount++;
-                recursiveNums(node.child);
+                recursiveDenums(node.child);
+            }
+            else if ((0, numberNode_1.isNumberNode)(node) && node.value < 0) {
+                oppositesCount++;
+                externalsDenums.push(new numberNode_1.NumberNode(Math.abs(node.value)));
             }
             else {
                 externalsDenums.push(node);
@@ -126,9 +134,10 @@ class FractionNode {
         };
         recursiveNums(copy.leftChild);
         recursiveDenums(copy.rightChild);
-        if (oppositesCount % 2 === 1) {
-            externalsNums.unshift(new numberNode_1.NumberNode(-1));
-        }
+        const shouldAddOppositeNode = oppositesCount % 2 === 1;
+        // if (oppositesCount % 2 === 1) {
+        //   externalsNums.unshift(new NumberNode(-1));
+        // }
         const simplifyExternalNodes = (num, denum) => {
             if ((0, numberNode_1.isNumberNode)(num) && (0, numberNode_1.isNumberNode)(denum)) {
                 // console.log("num nb, denum nb", num.toTex(), denum.toTex());
@@ -193,17 +202,20 @@ class FractionNode {
             ? externalsNums[0]
             : (0, operatorComposition_1.operatorComposition)(multiplyNode_1.MultiplyNode, externalsNums).simplify(opts);
         if (externalsDenums.length === 0) {
-            return nums;
+            return shouldAddOppositeNode ? new oppositeNode_1.OppositeNode(nums).simplify() : nums;
         }
         const denums = externalsDenums.length === 1
             ? externalsDenums[0]
             : (0, operatorComposition_1.operatorComposition)(multiplyNode_1.MultiplyNode, externalsDenums);
         if (opts?.forceDistributeFractions) {
             if ((0, addNode_1.isAddNode)(nums)) {
-                return new addNode_1.AddNode(new FractionNode(nums.leftChild, denums).simplify(opts), new FractionNode(nums.rightChild, denums).simplify(opts));
+                const res = new addNode_1.AddNode(new FractionNode(nums.leftChild, denums).simplify(opts), new FractionNode(nums.rightChild, denums).simplify(opts));
+                return shouldAddOppositeNode ? new oppositeNode_1.OppositeNode(res) : res;
             }
         }
-        return new FractionNode(nums, denums);
+        return shouldAddOppositeNode
+            ? new oppositeNode_1.OppositeNode(new FractionNode(nums, denums))
+            : new FractionNode(nums, denums);
     }
     equals(node) {
         return (isFractionNode(node) &&

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

@@ -1 +1 @@
-{"version":3,"file":"latexParser.d.ts","sourceRoot":"","sources":["../../../src/tree/parsers/latexParser.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AA0CvD,eAAO,MAAM,QAAQ,UAAW,MAAM,aA4BrC,CAAC;AAEF,eAAO,MAAM,UAAU,UAAW,MAAM,kBAavC,CAAC"}
+{"version":3,"file":"latexParser.d.ts","sourceRoot":"","sources":["../../../src/tree/parsers/latexParser.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AA8CvD,eAAO,MAAM,QAAQ,UAAW,MAAM,aA4BrC,CAAC;AAEF,eAAO,MAAM,UAAU,UAAW,MAAM,kBAavC,CAAC"}

package/lib/tree/parsers/latexParser.js

@@ -4,13 +4,14 @@ exports.parseLatex = exports.tokenize = void 0;
 const oppositeNode_1 = require("../nodes/functions/oppositeNode");
 const sqrtNode_1 = require("../nodes/functions/sqrtNode");
 const numberNode_1 = require("../nodes/numbers/numberNode");
+const piNode_1 = require("../nodes/numbers/piNode");
 const addNode_1 = require("../nodes/operators/addNode");
 const fractionNode_1 = require("../nodes/operators/fractionNode");
 const multiplyNode_1 = require("../nodes/operators/multiplyNode");
 const powerNode_1 = require("../nodes/operators/powerNode");
 const substractNode_1 = require("../nodes/operators/substractNode");
 const variableNode_1 = require("../nodes/variables/variableNode");
-//cmd that needs a child, like \exp{3}
+//cmds that needs a child, like \exp{3}
 const functions = [
     "\\exp",
     "\\sqrt",
@@ -21,6 +22,8 @@ const functions = [
     "\\frac",
 ];
 const operators = ["+", "-", "\\div", "\\times", "^"];
+//cmds childless, like \\pi
+const symbols = [{ tex: "\\pi", node: piNode_1.PiNode }];
 const isDyck = (tokens) => {
     const brackets = tokens.filter((el) => el === "(" || el === ")");
     while (brackets.length) {
@@ -138,6 +141,10 @@ const buildTreeForSameDepthTokens = (tokens) => {
         }
         else if (token[0].match(/[a-z]/i))
             tempTokens[i] = new variableNode_1.VariableNode(token);
+        else if (symbols.some((el) => el.tex === token)) {
+            const obj = symbols.find((el) => el.tex === token);
+            tempTokens[i] = obj.node;
+        }
         //! les fonctions qui attendent un child ne sont pas encore parsées
         else if (functions.includes(token)) {
             tempTokens[i] = token;

package/lib/tree/parsers/numberParser.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.numberParser = void 0;
-//to use when the answer is a pure number (int / float etc)
+//returns false if ans is NaN (even in french form) and returns the frenchified form otherwise
 const numberParser = (ans) => {
     const nb = ans.unfrenchify();
     if (isNaN(nb))

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

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

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

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

package/lib/tree/parsers/rationalParser.js

@@ -0,0 +1,9 @@
+"use strict";
+// export const rationalParser = (ans: string) => {
+//     if(ans.startsWith("\\frac")){
+//         const num
+//     }
+//     const nb = ans.unfrenchify();
+//     if (isNaN(nb)) return false;
+//     return nb.frenchify();
+//   };

package/package.json

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