math-exercises 1.1.1 → 1.2.1

package/src/tree/nodes/operators/multiplyNode.ts

@@ -1,15 +1,9 @@
 import { Node, NodeType } from "../node";
-import { OperatorNode } from "./operatorNode";
+import { OperatorIds, OperatorNode } from "./operatorNode";
 
-export class MultiplyNode implements Node, OperatorNode {
-  leftChild: Node;
-  rightChild: Node;
-  type: NodeType = NodeType.operator;
-  id: string = "multiply";
-  tex = "\\times";
+export class MultiplyNode extends OperatorNode {
   constructor(leftChild: Node, rightChild: Node) {
-    this.leftChild = leftChild;
-    this.rightChild = rightChild;
+    super(OperatorIds.multiply, leftChild, rightChild, true, "\\times");
   }
 
   toString(): string {

package/src/tree/nodes/operators/operatorNode.js

@@ -1,2 +1,37 @@
 "use strict";
 exports.__esModule = true;
+exports.OperatorNode = exports.OperatorIds = void 0;
+var coin_1 = require("../../../utils/coin");
+var node_1 = require("../node");
+var OperatorIds;
+(function (OperatorIds) {
+    OperatorIds[OperatorIds["add"] = 0] = "add";
+    OperatorIds[OperatorIds["substract"] = 1] = "substract";
+    OperatorIds[OperatorIds["multiply"] = 2] = "multiply";
+    OperatorIds[OperatorIds["fraction"] = 3] = "fraction";
+    OperatorIds[OperatorIds["divide"] = 4] = "divide";
+    OperatorIds[OperatorIds["power"] = 5] = "power";
+    OperatorIds[OperatorIds["equal"] = 6] = "equal";
+})(OperatorIds = exports.OperatorIds || (exports.OperatorIds = {}));
+var OperatorNode = /** @class */ (function () {
+    function OperatorNode(id, leftChild, rightChild, isCommutative, tex) {
+        this.type = node_1.NodeType.operator;
+        this.id = id;
+        this.leftChild = leftChild;
+        this.rightChild = rightChild;
+        this.isCommutative = isCommutative;
+        this.tex = tex;
+    }
+    /**shuffles in place */
+    OperatorNode.prototype.shuffle = function () {
+        var _a;
+        if (!this.isCommutative)
+            return this;
+        if ((0, coin_1.coin)())
+            return this;
+        _a = [this.rightChild, this.leftChild], this.leftChild = _a[0], this.rightChild = _a[1];
+        return this;
+    };
+    return OperatorNode;
+}());
+exports.OperatorNode = OperatorNode;

package/src/tree/nodes/operators/operatorNode.ts

@@ -1,3 +1,36 @@
-export interface OperatorNode {
-  id: string;
+import { coin } from "../../../utils/coin";
+import { Node, NodeType } from "../node";
+
+export enum OperatorIds {
+  add,
+  substract,
+  multiply,
+  fraction,
+  divide,
+  power,
+  equal,
+}
+
+export abstract class OperatorNode implements Node {
+  id: OperatorIds;
+  leftChild: Node;
+  rightChild: Node;
+  isCommutative: boolean;
+  type = NodeType.operator;
+  tex: string;
+  constructor(id: OperatorIds, leftChild: Node, rightChild: Node, isCommutative: boolean, tex: string) {
+    this.id = id;
+    this.leftChild = leftChild;
+    this.rightChild = rightChild;
+    this.isCommutative = isCommutative;
+    this.tex = tex;
+  }
+
+  /**shuffles in place */
+  shuffle(): Node {
+    if (!this.isCommutative) return this;
+    if (coin()) return this;
+    [this.leftChild, this.rightChild] = [this.rightChild, this.leftChild];
+    return this;
+  }
 }

package/src/tree/nodes/operators/powerNode.js

@@ -1,18 +1,30 @@
 "use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
 exports.__esModule = true;
 exports.PowerNode = void 0;
-var node_1 = require("../node");
-var PowerNode = /** @class */ (function () {
+var operatorNode_1 = require("./operatorNode");
+var PowerNode = /** @class */ (function (_super) {
+    __extends(PowerNode, _super);
     function PowerNode(leftChild, rightChild) {
-        this.tex = "^";
-        this.type = node_1.NodeType.operator;
-        this.id = "power";
-        this.leftChild = leftChild;
-        this.rightChild = rightChild;
+        return _super.call(this, operatorNode_1.OperatorIds.power, leftChild, rightChild, false, "^") || this;
     }
     PowerNode.prototype.toString = function () {
         return "(".concat(this.leftChild, ")^{").concat(this.rightChild, "}");
     };
     return PowerNode;
-}());
+}(operatorNode_1.OperatorNode));
 exports.PowerNode = PowerNode;

package/src/tree/nodes/operators/powerNode.ts

@@ -1,14 +1,9 @@
 import { Node, NodeType } from "../node";
+import { OperatorIds, OperatorNode } from "./operatorNode";
 
-export class PowerNode implements Node {
-  tex = "^";
-  type = NodeType.operator;
-  id = "power";
-  leftChild: Node;
-  rightChild: Node;
+export class PowerNode extends OperatorNode {
   constructor(leftChild: Node, rightChild: Node) {
-    this.leftChild = leftChild;
-    this.rightChild = rightChild;
+    super(OperatorIds.power, leftChild, rightChild, false, "^");
   }
 
   toString(): string {

package/src/tree/nodes/operators/substractNode.js

@@ -1,18 +1,30 @@
 "use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
 exports.__esModule = true;
 exports.SubstractNode = void 0;
-var node_1 = require("../node");
-var SubstractNode = /** @class */ (function () {
+var operatorNode_1 = require("./operatorNode");
+var SubstractNode = /** @class */ (function (_super) {
+    __extends(SubstractNode, _super);
     function SubstractNode(leftChild, rightChild) {
-        this.type = node_1.NodeType.operator;
-        this.id = "substract";
-        this.tex = "-";
-        this.leftChild = leftChild;
-        this.rightChild = rightChild;
+        return _super.call(this, operatorNode_1.OperatorIds.substract, leftChild, rightChild, false, "-") || this;
     }
     SubstractNode.prototype.toString = function () {
         return "".concat(this.leftChild, "-(").concat(this.rightChild, ")");
     };
     return SubstractNode;
-}());
+}(operatorNode_1.OperatorNode));
 exports.SubstractNode = SubstractNode;

package/src/tree/nodes/operators/substractNode.ts

@@ -1,15 +1,9 @@
 import { Node, NodeType } from "../node";
-import { OperatorNode } from "./operatorNode";
+import { OperatorIds, OperatorNode } from "./operatorNode";
 
-export class SubstractNode implements Node, OperatorNode {
-  leftChild: Node;
-  rightChild: Node;
-  type: NodeType = NodeType.operator;
-  id: string = "substract";
-  tex = "-";
+export class SubstractNode extends OperatorNode {
   constructor(leftChild: Node, rightChild: Node) {
-    this.leftChild = leftChild;
-    this.rightChild = rightChild;
+    super(OperatorIds.substract, leftChild, rightChild, false, "-");
   }
   toString(): string {
     return `${this.leftChild}-(${this.rightChild})`;

package/src/tree/nodes/variables/variableNode.js

@@ -4,13 +4,10 @@ exports.VariableNode = void 0;
 var node_1 = require("../node");
 var VariableNode = /** @class */ (function () {
     function VariableNode(tex) {
-        this.id = "variable";
-        this.leftChild = null;
-        this.rightChild = null;
+        this.type = node_1.NodeType.variable;
         if (tex.length !== 1 || !tex.match("[a-zA-Z]"))
             throw Error("variable must be a letter");
         this.tex = tex;
-        this.type = node_1.NodeType.variable;
     }
     VariableNode.prototype.toString = function () {
         return "".concat(this.tex);

package/src/tree/nodes/variables/variableNode.ts

@@ -2,16 +2,13 @@ import { Node, NodeType } from "../node";
 
 export class VariableNode implements Node {
   tex: string;
-  type: NodeType;
-  id = "variable";
-  leftChild = null;
-  rightChild = null;
+  type = NodeType.variable;
+
   constructor(tex: string) {
-    if (tex.length !== 1 || !tex.match("[a-zA-Z]"))
-      throw Error("variable must be a letter");
+    if (tex.length !== 1 || !tex.match("[a-zA-Z]")) throw Error("variable must be a letter");
     this.tex = tex;
-    this.type = NodeType.variable;
   }
+
   toString(): string {
     return `${this.tex}`;
   }

package/src/utils/coin.js

@@ -0,0 +1,7 @@
+"use strict";
+exports.__esModule = true;
+exports.coin = void 0;
+var coin = function () {
+    return Math.random() < 0.5;
+};
+exports.coin = coin;

package/src/utils/coin.ts

@@ -0,0 +1,3 @@
+export const coin = (): Boolean => {
+  return Math.random() < 0.5;
+};

package/src/utils/shuffle.js

@@ -1,13 +1,24 @@
 "use strict";
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
 exports.__esModule = true;
 exports.shuffle = void 0;
 /* Randomize array in-place using Durstenfeld shuffle algorithm */
 function shuffle(array) {
-    for (var i = array.length - 1; i > 0; i--) {
+    var res = __spreadArray([], array, true);
+    for (var i = res.length - 1; i > 0; i--) {
         var j = Math.floor(Math.random() * (i + 1));
-        var temp = array[i];
-        array[i] = array[j];
-        array[j] = temp;
+        var temp = res[i];
+        res[i] = res[j];
+        res[j] = temp;
     }
+    return res;
 }
 exports.shuffle = shuffle;

package/src/utils/shuffle.ts

@@ -1,9 +1,11 @@
 /* Randomize array in-place using Durstenfeld shuffle algorithm */
-export function shuffle<T>(array: T[]) {
-  for (var i = array.length - 1; i > 0; i--) {
+export function shuffle<T>(array: T[]): T[] {
+  const res = [...array];
+  for (var i = res.length - 1; i > 0; i--) {
     var j = Math.floor(Math.random() * (i + 1));
-    var temp = array[i];
-    array[i] = array[j];
-    array[j] = temp;
+    var temp = res[i];
+    res[i] = res[j];
+    res[j] = temp;
   }
+  return res;
 }

package/src/exercises/calcul/priority.ts

@@ -1,33 +0,0 @@
-import { randint } from "../../mathutils/random/randint";
-import { Interval } from "../../sets/intervals/intervals";
-import { Exercise, Question } from "../exercise";
-import { getDistinctQuestions } from "../utils/getDistinctQuestions";
-
-/**
- * a*b ±c±d
- * a/b ±c±d
- */
-// export const priorityExercise: Exercise = {
-//   connector: "=",
-//   instruction: "Simplifier : ",
-//   label: "Priorités opératoires",
-//   levels: ["6", "5", "4"],
-//   section: "Calculs",
-//   generator: (nb: number) => getDistinctQuestions(getPriorityQuestions, nb),
-// };
-
-// export function getPriorityQuestions(): Question {
-//   const nbOfTerms = randint(3, 5);
-//   const max = 20;
-//   const terms = [];
-//   const interval = new Interval(`[[${-max}; ${max}]]`).exclude(0);
-//   for (let i = 0; i < nbOfTerms; i++) {
-//     terms.push(interval.getRandomElement());
-//   }
-//   const tex = new Latex("");
-//   terms.forEach((term) => tex.add(term));
-//   const statement = tex.toTex();
-//   const answer = terms.reduce((acc, curr) => acc + curr).toString();
-//   const question: Question = { statement, answer };
-//   return question;
-// }

package/src/expression/expression.js

@@ -1,9 +0,0 @@
-"use strict";
-exports.__esModule = true;
-exports.ExpressionType = void 0;
-var ExpressionType;
-(function (ExpressionType) {
-    ExpressionType[ExpressionType["real"] = 0] = "real";
-    ExpressionType[ExpressionType["affine"] = 1] = "affine";
-    ExpressionType[ExpressionType["polynomial"] = 2] = "polynomial";
-})(ExpressionType = exports.ExpressionType || (exports.ExpressionType = {}));

package/src/expression/expression.ts

@@ -1,13 +0,0 @@
-export enum ExpressionType {
-  real,
-  affine,
-  polynomial,
-}
-
-export interface Expression {
-  // type: ExpressionType;
-  add(expression: Expression): Expression;
-  multiply(expression: Expression): Expression;
-  opposite(): Expression;
-  toTex(): string;
-}

package/src/tree/nodes/operators/oppositeNode.ts

@@ -1,17 +0,0 @@
-import { Node, NodeType } from "../node";
-import { OperatorNode } from "./operatorNode";
-
-export class OppositeNode implements Node, OperatorNode {
-  leftChild: Node;
-  rightChild: null;
-  type: NodeType = NodeType.operator;
-  id: string = "opposite";
-  tex = "-";
-  constructor(leftChild: Node) {
-    this.leftChild = leftChild;
-    this.rightChild = null;
-  }
-  toString(): string {
-    return `-(${this.leftChild})`;
-  }
-}