math-exercises 1.0.1 → 1.1.0

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

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

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

@@ -0,0 +1,18 @@
+"use strict";
+exports.__esModule = true;
+exports.MultiplyNode = void 0;
+var node_1 = require("../node");
+var MultiplyNode = /** @class */ (function () {
+    function MultiplyNode(leftChild, rightChild) {
+        this.type = node_1.NodeType.operator;
+        this.id = "multiply";
+        this.tex = "\\times";
+        this.leftChild = leftChild;
+        this.rightChild = rightChild;
+    }
+    MultiplyNode.prototype.toString = function () {
+        return "(".concat(this.leftChild, ")*(").concat(this.rightChild, ")");
+    };
+    return MultiplyNode;
+}());
+exports.MultiplyNode = MultiplyNode;

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

@@ -0,0 +1,18 @@
+import { Node, NodeType } from "../node";
+import { OperatorNode } from "./operatorNode";
+
+export class MultiplyNode implements Node, OperatorNode {
+  leftChild: Node;
+  rightChild: Node;
+  type: NodeType = NodeType.operator;
+  id: string = "multiply";
+  tex = "\\times";
+  constructor(leftChild: Node, rightChild: Node) {
+    this.leftChild = leftChild;
+    this.rightChild = rightChild;
+  }
+
+  toString(): string {
+    return `(${this.leftChild})*(${this.rightChild})`;
+  }
+}

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

@@ -0,0 +1,3 @@
+export interface OperatorNode {
+  id: string;
+}

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

@@ -0,0 +1,18 @@
+"use strict";
+exports.__esModule = true;
+exports.OppositeNode = void 0;
+var node_1 = require("../node");
+var OppositeNode = /** @class */ (function () {
+    function OppositeNode(leftChild) {
+        this.type = node_1.NodeType.operator;
+        this.id = "opposite";
+        this.tex = "-";
+        this.leftChild = leftChild;
+        this.rightChild = null;
+    }
+    OppositeNode.prototype.toString = function () {
+        return "-(".concat(this.leftChild, ")");
+    };
+    return OppositeNode;
+}());
+exports.OppositeNode = OppositeNode;

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

@@ -0,0 +1,17 @@
+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})`;
+  }
+}

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

@@ -0,0 +1,18 @@
+"use strict";
+exports.__esModule = true;
+exports.PowerNode = void 0;
+var node_1 = require("../node");
+var PowerNode = /** @class */ (function () {
+    function PowerNode(leftChild, rightChild) {
+        this.tex = "^";
+        this.type = node_1.NodeType.operator;
+        this.id = "power";
+        this.leftChild = leftChild;
+        this.rightChild = rightChild;
+    }
+    PowerNode.prototype.toString = function () {
+        return "(".concat(this.leftChild, ")^{").concat(this.rightChild, "}");
+    };
+    return PowerNode;
+}());
+exports.PowerNode = PowerNode;

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

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

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

@@ -0,0 +1,18 @@
+"use strict";
+exports.__esModule = true;
+exports.SubstractNode = void 0;
+var node_1 = require("../node");
+var SubstractNode = /** @class */ (function () {
+    function SubstractNode(leftChild, rightChild) {
+        this.type = node_1.NodeType.operator;
+        this.id = "substract";
+        this.tex = "-";
+        this.leftChild = leftChild;
+        this.rightChild = rightChild;
+    }
+    SubstractNode.prototype.toString = function () {
+        return "".concat(this.leftChild, "-(").concat(this.rightChild, ")");
+    };
+    return SubstractNode;
+}());
+exports.SubstractNode = SubstractNode;

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

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

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

@@ -0,0 +1,20 @@
+"use strict";
+exports.__esModule = true;
+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;
+        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);
+    };
+    return VariableNode;
+}());
+exports.VariableNode = VariableNode;

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

@@ -0,0 +1,18 @@
+import { Node, NodeType } from "../node";
+
+export class VariableNode implements Node {
+  tex: string;
+  type: NodeType;
+  id = "variable";
+  leftChild = null;
+  rightChild = null;
+  constructor(tex: string) {
+    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/equations/equations.ts

@@ -1,16 +0,0 @@
-export abstract class EquationConstructor{
-    firstDegree({tex:string}){
-
-    }
-}
-
-export class Equation {
-    leftTerm: string;
-    rightTerm: string;
-    
-    solve(){
-        
-    }
-
-
-}

package/src/exercises/calculLitteral/factorisation/factorisation.js

@@ -1,39 +0,0 @@
-"use strict";
-exports.__esModule = true;
-exports.getFactoType1Question = exports.FactoType1Exercise = void 0;
-var add_1 = require("../../../operations/add");
-var substract_1 = require("../../../operations/substract");
-var affine_1 = require("../../../polynomials/affine");
-var random_1 = require("../../../utils/random");
-var shuffle_1 = require("../../../utils/shuffle");
-var getDistinctQuestions_1 = require("../../utils/getDistinctQuestions");
-/**
- *
- * @returns type (ax+b)(cx+d) +- (ax+b)(ex+f)
- */
-var FactoType1Exercise = /** @class */ (function () {
-    function FactoType1Exercise(nbOfQuestions) {
-        this.connector = "=";
-        this.instruction = "Factoriser :";
-        this.label = "Factorisation du type $(ax+b)(cx+d) \\pm (ax+b)(ex+f)$";
-        this.levels = ["3", "2"];
-        this.section = "Calcul Littéral";
-        this.questions = (0, getDistinctQuestions_1.getDistinctQuestions)(exports.getFactoType1Question, nbOfQuestions);
-    }
-    return FactoType1Exercise;
-}());
-exports.FactoType1Exercise = FactoType1Exercise;
-var getFactoType1Question = function () {
-    var affines = affine_1.AffineConstructor.differentRandoms(3);
-    var permut = [
-        [affines[0], affines[1]],
-        [affines[0], affines[2]],
-    ];
-    (0, shuffle_1.shuffle)(permut[0]);
-    (0, shuffle_1.shuffle)(permut[1]);
-    var operation = (0, random_1.random)([add_1.add, substract_1.substract]);
-    var statement = "(".concat(permut[0][0], ")(").concat(permut[0][1], ") ").concat(operation.tex, " (").concat(permut[1][0], ")(").concat(permut[1][1], ")");
-    var answer = "(".concat(affines[0], ")(").concat(operation.apply(affines[1], affines[2]), ")");
-    return { statement: statement, answer: answer };
-};
-exports.getFactoType1Question = getFactoType1Question;

package/src/latex/add.js

@@ -1,7 +0,0 @@
-"use strict";
-exports.__esModule = true;
-exports.add = void 0;
-function add(nb) {
-    return nb === 0 ? "" : "".concat(nb > 0 ? "+" : "").concat(nb);
-}
-exports.add = add;

package/src/latex/latex.js

@@ -1,37 +0,0 @@
-"use strict";
-exports.__esModule = true;
-exports.Latex = exports.LatexConstructor = void 0;
-var LatexConstructor = /** @class */ (function () {
-    function LatexConstructor() {
-    }
-    LatexConstructor.fromString = function (s) {
-        return new Latex(s);
-    };
-    LatexConstructor.monome = function (n, l) {
-        return;
-    };
-    return LatexConstructor;
-}());
-exports.LatexConstructor = LatexConstructor;
-var Latex = /** @class */ (function () {
-    function Latex(tex) {
-        this.tex = tex;
-    }
-    Latex.prototype.toTex = function () {
-        return this.tex;
-    };
-    Latex.prototype.add = function (term) {
-        var s = this.tex;
-        switch (typeof term) {
-            case "number":
-                this.tex += term === 0 ? "" : "".concat(term > 0 ? "+" : "").concat(term);
-                break;
-            default:
-                break;
-        }
-        return this.tex;
-        // return new Latex(s);
-    };
-    return Latex;
-}());
-exports.Latex = Latex;

package/src/latex/latex.ts

@@ -1,35 +0,0 @@
-import { Expression } from "../expression/expression";
-
-export abstract class LatexConstructor {
-  static fromString(s: string): Latex {
-    return new Latex(s);
-  }
-  static monome(n: number, l: Latex) {
-    return;
-  }
-}
-export class Latex {
-  tex: string;
-  constructor(tex: string) {
-    this.tex = tex;
-  }
-
-  toTex(): string {
-    return this.tex;
-  }
-
-  add(term: number | Expression): string {
-    let s = this.tex;
-    switch (typeof term) {
-      case "number":
-        this.tex += term === 0 ? "" : `${term > 0 ? "+" : ""}${term}`;
-        break;
-      default:
-        break;
-    }
-    return this.tex;
-    // return new Latex(s);
-  }
-
-  //créer un type monome ?
-}

package/src/latex/multiply.ts

@@ -1,5 +0,0 @@
-import { Expression } from "../expression/expression";
-
-export function muliply(a: number | Expression, b: number | Expression) {
-  // return nb === 0 ? "" : `${nb > 0 ? "+" : ""}${nb}`;
-}

package/src/numbers/number.ts

@@ -1,4 +0,0 @@
-export enum NumberType {
-  Integer,
-  Real,
-}

package/src/operations/add.js

@@ -1,9 +0,0 @@
-"use strict";
-exports.__esModule = true;
-exports.add = void 0;
-exports.add = {
-    tex: "+",
-    apply: function (a, b) {
-        return a.add(b);
-    }
-};

package/src/operations/add.ts

@@ -1,9 +0,0 @@
-import { Expression } from "../expression/expression";
-import { Operation } from "./operation";
-
-export const add: Operation = {
-  tex: "+",
-  apply: (a: Expression, b: Expression): Expression => {
-    return a.add(b);
-  },
-};

package/src/operations/operation.ts

@@ -1,6 +0,0 @@
-import { Expression } from "../expression/expression";
-
-export interface Operation {
-  tex: string;
-  apply: Function;
-}

package/src/operations/substract.js

@@ -1,9 +0,0 @@
-"use strict";
-exports.__esModule = true;
-exports.substract = void 0;
-exports.substract = {
-    tex: "-",
-    apply: function (a, b) {
-        return a.add(b.opposite());
-    }
-};

package/src/operations/substract.ts

@@ -1,9 +0,0 @@
-import { Expression } from "../expression/expression";
-import { Operation } from "./operation";
-
-export const substract: Operation = {
-  tex: "-",
-  apply: (a: Expression, b: Expression): Expression => {
-    return a.add(b.opposite());
-  },
-};