math-exercises 1.0.1 → 1.1.1

package/src/exercises/calculLitteral/equation/equationType2Exercise.ts

@@ -0,0 +1,40 @@
+import { Integer } from "../../../numbers/integer/integer";
+import { Rational } from "../../../numbers/rationals/rational";
+import { Affine } from "../../../polynomials/affine";
+import { DiscreteSet } from "../../../sets/discreteSet";
+import { Interval } from "../../../sets/intervals/intervals";
+import { latexParse } from "../../../tree/latexParser/latexParse";
+import { EqualNode } from "../../../tree/nodes/operators/equalNode";
+import { VariableNode } from "../../../tree/nodes/variables/variableNode";
+import { Exercise, Question } from "../../exercise";
+import { getDistinctQuestions } from "../../utils/getDistinctQuestions";
+
+/**
+ *  type ax=b
+ */
+export const equationType2Exercise: Exercise = {
+  id: "equa2",
+
+  connector: "\\iff",
+  instruction: "Résoudre : ",
+  label: "Equations $ax=b$",
+  levels: ["4", "3", "2"],
+  section: "Calcul littéral",
+  generator: (nb: number) => getDistinctQuestions(getEquationType2ExerciseQuestion, nb),
+};
+
+export function getEquationType2ExerciseQuestion(): Question {
+  const interval = new Interval("[[-10; 10]]");
+  const intervalStar = new Interval("[[-10; 10]]").difference(new DiscreteSet([new Integer(0)]));
+  const b = interval.getRandomElement();
+  const a = intervalStar.getRandomElement();
+  const solution = new Rational(b.value, a.value).simplify();
+  const affine = new Affine(a.value, 0).toTree();
+  const tree = new EqualNode(affine, b.toTree());
+  const answer = new EqualNode(new VariableNode("x"), solution.toTree());
+  const question: Question = {
+    statement: latexParse(tree),
+    answer: latexParse(answer),
+  };
+  return question;
+}

package/src/exercises/calculLitteral/equation/equationType3Exercise.js

@@ -0,0 +1,41 @@
+"use strict";
+exports.__esModule = true;
+exports.getEquationType3ExerciseQuestion = exports.equationType3Exercise = void 0;
+var integer_1 = require("../../../numbers/integer/integer");
+var rational_1 = require("../../../numbers/rationals/rational");
+var affine_1 = require("../../../polynomials/affine");
+var discreteSet_1 = require("../../../sets/discreteSet");
+var intervals_1 = require("../../../sets/intervals/intervals");
+var latexParse_1 = require("../../../tree/latexParser/latexParse");
+var equalNode_1 = require("../../../tree/nodes/operators/equalNode");
+var variableNode_1 = require("../../../tree/nodes/variables/variableNode");
+var getDistinctQuestions_1 = require("../../utils/getDistinctQuestions");
+/**
+ *  type ax+b=c
+ */
+exports.equationType3Exercise = {
+    id: "equa3",
+    connector: "\\iff",
+    instruction: "Résoudre : ",
+    label: "Equations $ax+b=c$",
+    levels: ["4", "3", "2"],
+    section: "Calcul littéral",
+    generator: function (nb) { return (0, getDistinctQuestions_1.getDistinctQuestions)(getEquationType3ExerciseQuestion, nb); }
+};
+function getEquationType3ExerciseQuestion() {
+    var interval = new intervals_1.Interval("[[-10; 10]]");
+    var intervalStar = new intervals_1.Interval("[[-10; 10]]").difference(new discreteSet_1.DiscreteSet([new integer_1.Integer(0)]));
+    var b = intervalStar.getRandomElement();
+    var a = intervalStar.getRandomElement();
+    var c = interval.getRandomElement();
+    var affine = new affine_1.Affine(a.value, b.value).toTree();
+    var solution = new rational_1.Rational(c.value - b.value, a.value).simplify();
+    var statementTree = new equalNode_1.EqualNode(affine, c.toTree());
+    var answerTree = new equalNode_1.EqualNode(new variableNode_1.VariableNode("x"), solution.toTree());
+    var question = {
+        statement: (0, latexParse_1.latexParse)(statementTree),
+        answer: (0, latexParse_1.latexParse)(answerTree)
+    };
+    return question;
+}
+exports.getEquationType3ExerciseQuestion = getEquationType3ExerciseQuestion;

package/src/exercises/calculLitteral/equation/equationType3Exercise.ts

@@ -0,0 +1,42 @@
+import { Integer } from "../../../numbers/integer/integer";
+import { Rational } from "../../../numbers/rationals/rational";
+import { Affine } from "../../../polynomials/affine";
+import { DiscreteSet } from "../../../sets/discreteSet";
+import { Interval } from "../../../sets/intervals/intervals";
+import { latexParse } from "../../../tree/latexParser/latexParse";
+import { EqualNode } from "../../../tree/nodes/operators/equalNode";
+import { VariableNode } from "../../../tree/nodes/variables/variableNode";
+import { Exercise, Question } from "../../exercise";
+import { getDistinctQuestions } from "../../utils/getDistinctQuestions";
+
+/**
+ *  type ax+b=c
+ */
+export const equationType3Exercise: Exercise = {
+  id: "equa3",
+
+  connector: "\\iff",
+  instruction: "Résoudre : ",
+  label: "Equations $ax+b=c$",
+  levels: ["4", "3", "2"],
+  section: "Calcul littéral",
+  generator: (nb: number) => getDistinctQuestions(getEquationType3ExerciseQuestion, nb),
+};
+
+export function getEquationType3ExerciseQuestion(): Question {
+  const interval = new Interval("[[-10; 10]]");
+  const intervalStar = new Interval("[[-10; 10]]").difference(new DiscreteSet([new Integer(0)]));
+  const b = intervalStar.getRandomElement();
+  const a = intervalStar.getRandomElement();
+  const c = interval.getRandomElement();
+
+  const affine = new Affine(a.value, b.value).toTree();
+  const solution = new Rational(c.value - b.value, a.value).simplify();
+  const statementTree = new EqualNode(affine, c.toTree());
+  const answerTree = new EqualNode(new VariableNode("x"), solution.toTree());
+  const question: Question = {
+    statement: latexParse(statementTree),
+    answer: latexParse(answerTree),
+  };
+  return question;
+}

package/src/exercises/calculLitteral/equation/equationType4Exercise.js

@@ -0,0 +1,43 @@
+"use strict";
+exports.__esModule = true;
+exports.getEquationType4ExerciseQuestion = exports.equationType4Exercise = void 0;
+var integer_1 = require("../../../numbers/integer/integer");
+var rational_1 = require("../../../numbers/rationals/rational");
+var affine_1 = require("../../../polynomials/affine");
+var discreteSet_1 = require("../../../sets/discreteSet");
+var intervals_1 = require("../../../sets/intervals/intervals");
+var latexParse_1 = require("../../../tree/latexParser/latexParse");
+var equalNode_1 = require("../../../tree/nodes/operators/equalNode");
+var variableNode_1 = require("../../../tree/nodes/variables/variableNode");
+var getDistinctQuestions_1 = require("../../utils/getDistinctQuestions");
+/**
+ *  type ax+b=cx+d
+ */
+exports.equationType4Exercise = {
+    id: "equa4",
+    connector: "\\iff",
+    instruction: "Résoudre : ",
+    label: "Equations $ax+b=cx+d$",
+    levels: ["4", "3", "2"],
+    section: "Calcul littéral",
+    generator: function (nb) { return (0, getDistinctQuestions_1.getDistinctQuestions)(getEquationType4ExerciseQuestion, nb); }
+};
+function getEquationType4ExerciseQuestion() {
+    var interval = new intervals_1.Interval("[[-10; 10]]");
+    var intervalStar = new intervals_1.Interval("[[-10; 10]]").difference(new discreteSet_1.DiscreteSet([new integer_1.Integer(0)]));
+    var a = intervalStar.getRandomElement();
+    var b = interval.getRandomElement();
+    var intervalC = new intervals_1.Interval("[[-10; 10]]").difference(new discreteSet_1.DiscreteSet([new integer_1.Integer(0), new integer_1.Integer(a.value)]));
+    var c = intervalC.getRandomElement();
+    var d = interval.getRandomElement();
+    var affines = [new affine_1.Affine(a.value, b.value), new affine_1.Affine(c.value, d.value)];
+    var solution = new rational_1.Rational(d.value - b.value, a.value - c.value).simplify();
+    var statementTree = new equalNode_1.EqualNode(affines[0].toTree(), affines[1].toTree());
+    var answerTree = new equalNode_1.EqualNode(new variableNode_1.VariableNode("x"), solution.toTree());
+    var question = {
+        statement: (0, latexParse_1.latexParse)(statementTree),
+        answer: (0, latexParse_1.latexParse)(answerTree)
+    };
+    return question;
+}
+exports.getEquationType4ExerciseQuestion = getEquationType4ExerciseQuestion;

package/src/exercises/calculLitteral/equation/equationType4Exercise.ts

@@ -0,0 +1,45 @@
+import { Integer } from "../../../numbers/integer/integer";
+import { Rational } from "../../../numbers/rationals/rational";
+import { Affine } from "../../../polynomials/affine";
+import { DiscreteSet } from "../../../sets/discreteSet";
+import { Interval } from "../../../sets/intervals/intervals";
+import { latexParse } from "../../../tree/latexParser/latexParse";
+import { EqualNode } from "../../../tree/nodes/operators/equalNode";
+import { VariableNode } from "../../../tree/nodes/variables/variableNode";
+import { Exercise, Question } from "../../exercise";
+import { getDistinctQuestions } from "../../utils/getDistinctQuestions";
+
+/**
+ *  type ax+b=cx+d
+ */
+export const equationType4Exercise: Exercise = {
+  id: "equa4",
+
+  connector: "\\iff",
+  instruction: "Résoudre : ",
+  label: "Equations $ax+b=cx+d$",
+  levels: ["4", "3", "2"],
+  section: "Calcul littéral",
+  generator: (nb: number) => getDistinctQuestions(getEquationType4ExerciseQuestion, nb),
+};
+
+export function getEquationType4ExerciseQuestion(): Question {
+  const interval = new Interval("[[-10; 10]]");
+  const intervalStar = new Interval("[[-10; 10]]").difference(new DiscreteSet([new Integer(0)]));
+  const a = intervalStar.getRandomElement();
+  const b = interval.getRandomElement();
+  const intervalC = new Interval("[[-10; 10]]").difference(new DiscreteSet([new Integer(0), new Integer(a.value)]));
+  const c = intervalC.getRandomElement();
+  const d = interval.getRandomElement();
+
+  const affines = [new Affine(a.value, b.value), new Affine(c.value, d.value)];
+  const solution = new Rational(d.value - b.value, a.value - c.value).simplify();
+
+  const statementTree = new EqualNode(affines[0].toTree(), affines[1].toTree());
+  const answerTree = new EqualNode(new VariableNode("x"), solution.toTree());
+  const question: Question = {
+    statement: latexParse(statementTree),
+    answer: latexParse(answerTree),
+  };
+  return question;
+}

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

@@ -1,29 +1,27 @@
 "use strict";
 exports.__esModule = true;
-exports.getFactoType1Question = exports.FactoType1Exercise = void 0;
-var add_1 = require("../../../operations/add");
-var substract_1 = require("../../../operations/substract");
+exports.getFactoType1Question = exports.factoType1Exercise = void 0;
 var affine_1 = require("../../../polynomials/affine");
+var latexParse_1 = require("../../../tree/latexParser/latexParse");
+var addNode_1 = require("../../../tree/nodes/operators/addNode");
+var multiplyNode_1 = require("../../../tree/nodes/operators/multiplyNode");
+var substractNode_1 = require("../../../tree/nodes/operators/substractNode");
 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)
+ *  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 () {
+exports.factoType1Exercise = {
+    id: "facto1",
+    connector: "=",
+    instruction: "Factoriser :",
+    label: "Factorisation du type $(ax+b)(cx+d) \\pm (ax+b)(ex+f)$",
+    levels: ["3", "2"],
+    section: "Calcul Littéral",
+    generator: function (nb) { return (0, getDistinctQuestions_1.getDistinctQuestions)(getFactoType1Question, nb); }
+};
+function getFactoType1Question() {
     var affines = affine_1.AffineConstructor.differentRandoms(3);
     var permut = [
         [affines[0], affines[1]],
@@ -31,9 +29,15 @@ var getFactoType1Question = function () {
     ];
     (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 };
-};
+    var operation = (0, random_1.random)(["add", "substract"]);
+    var statementTree = operation === "add"
+        ? new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(permut[0][0].toTree(), permut[0][1].toTree()), new multiplyNode_1.MultiplyNode(permut[1][0].toTree(), permut[1][1].toTree()))
+        : new substractNode_1.SubstractNode(new multiplyNode_1.MultiplyNode(permut[0][0].toTree(), permut[0][1].toTree()), new multiplyNode_1.MultiplyNode(permut[1][0].toTree(), permut[1][1].toTree()));
+    var answerTree = new multiplyNode_1.MultiplyNode(affines[0].toTree(), affines[1].add(operation === "add" ? affines[2] : affines[2].opposite()).toTree());
+    var question = {
+        statement: (0, latexParse_1.latexParse)(statementTree),
+        answer: (0, latexParse_1.latexParse)(answerTree)
+    };
+    return question;
+}
 exports.getFactoType1Question = getFactoType1Question;

package/src/exercises/calculLitteral/factorisation/factoType1Exercise.ts

@@ -1,30 +1,28 @@
-import { Expression } from "../../../expression/expression";
-import { add } from "../../../operations/add";
-import { substract } from "../../../operations/substract";
 import { Affine, AffineConstructor } from "../../../polynomials/affine";
+import { latexParse } from "../../../tree/latexParser/latexParse";
+import { AddNode } from "../../../tree/nodes/operators/addNode";
+import { MultiplyNode } from "../../../tree/nodes/operators/multiplyNode";
+import { SubstractNode } from "../../../tree/nodes/operators/substractNode";
 import { random } from "../../../utils/random";
 import { shuffle } from "../../../utils/shuffle";
 import { Exercise, Question } from "../../exercise";
 import { getDistinctQuestions } from "../../utils/getDistinctQuestions";
 
 /**
- *
- * @returns type (ax+b)(cx+d) +- (ax+b)(ex+f)
+ *  type (ax+b)(cx+d) ± (ax+b)(ex+f)
  */
 
-export class FactoType1Exercise implements Exercise {
-  connector = "=";
-  instruction = "Factoriser :";
-  label = "Factorisation du type $(ax+b)(cx+d) \\pm (ax+b)(ex+f)$";
-  levels = ["3", "2"];
-  section = "Calcul Littéral";
-  questions: Question[];
-  constructor(nbOfQuestions: number) {
-    this.questions = getDistinctQuestions(getFactoType1Question, nbOfQuestions);
-  }
-}
+export const factoType1Exercise: Exercise = {
+  id: "facto1",
+  connector: "=",
+  instruction: "Factoriser :",
+  label: "Factorisation du type $(ax+b)(cx+d) \\pm (ax+b)(ex+f)$",
+  levels: ["3", "2"],
+  section: "Calcul Littéral",
+  generator: (nb: number) => getDistinctQuestions(getFactoType1Question, nb),
+};
 
-export const getFactoType1Question = () => {
+export function getFactoType1Question(): Question {
   const affines = AffineConstructor.differentRandoms(3);
 
   const permut: Affine[][] = [
@@ -34,10 +32,27 @@ export const getFactoType1Question = () => {
   shuffle(permut[0]);
   shuffle(permut[1]);
 
-  const operation = random([add, substract]);
+  const operation = random(["add", "substract"]);
 
-  const statement = `(${permut[0][0]})(${permut[0][1]}) ${operation.tex} (${permut[1][0]})(${permut[1][1]})`;
+  const statementTree =
+    operation === "add"
+      ? new AddNode(
+          new MultiplyNode(permut[0][0].toTree(), permut[0][1].toTree()),
+          new MultiplyNode(permut[1][0].toTree(), permut[1][1].toTree())
+        )
+      : new SubstractNode(
+          new MultiplyNode(permut[0][0].toTree(), permut[0][1].toTree()),
+          new MultiplyNode(permut[1][0].toTree(), permut[1][1].toTree())
+        );
 
-  const answer = `(${affines[0]})(${operation.apply(affines[1], affines[2])})`;
-  return { statement, answer };
-};
+  const answerTree = new MultiplyNode(
+    affines[0].toTree(),
+    affines[1].add(operation === "add" ? affines[2] : affines[2].opposite()).toTree()
+  );
+
+  const question: Question = {
+    statement: latexParse(statementTree),
+    answer: latexParse(answerTree),
+  };
+  return question;
+}

package/src/exercises/exercise.js

@@ -1,2 +1,7 @@
 "use strict";
+// export enum Connector {
+//   equal = "=",
+//   equiv = "\\iff",
+//   implies = "\\Rightarrow",
+// }
 exports.__esModule = true;

package/src/exercises/exercise.ts

@@ -1,14 +1,23 @@
+// export enum Connector {
+//   equal = "=",
+//   equiv = "\\iff",
+//   implies = "\\Rightarrow",
+// }
+
 export interface Question {
   statement: string;
   answer: string;
 }
+
 export interface Exercise {
+  id: string;
   instruction: string;
   label: string;
   section: string;
   levels: string[];
   connector: string;
-  questions: Question[];
+  generator(nb: number): Question[];
+  // questions: Question[];
   // constructor({ generatorType, questionsNumber }: ExerciseParameters) {
 
   // }

package/src/exercises/exercises.js

@@ -0,0 +1,29 @@
+"use strict";
+exports.__esModule = true;
+exports.exercises = void 0;
+var allIdentities_1 = require("./calculLitteral/distributivity/allIdentities");
+var doubleDistributivity_1 = require("./calculLitteral/distributivity/doubleDistributivity");
+var firstIdentity_1 = require("./calculLitteral/distributivity/firstIdentity");
+var secondIdentity_1 = require("./calculLitteral/distributivity/secondIdentity");
+var simpleDistributivity_1 = require("./calculLitteral/distributivity/simpleDistributivity");
+var thirdIdentity_1 = require("./calculLitteral/distributivity/thirdIdentity");
+var equationType1Exercise_1 = require("./calculLitteral/equation/equationType1Exercise");
+var equationType2Exercise_1 = require("./calculLitteral/equation/equationType2Exercise");
+var equationType3Exercise_1 = require("./calculLitteral/equation/equationType3Exercise");
+var equationType4Exercise_1 = require("./calculLitteral/equation/equationType4Exercise");
+var factoType1Exercise_1 = require("./calculLitteral/factorisation/factoType1Exercise");
+var simpifySquareRoot_1 = require("./squareRoots/simpifySquareRoot");
+exports.exercises = [
+    factoType1Exercise_1.factoType1Exercise,
+    simpleDistributivity_1.simpleDistributivity,
+    doubleDistributivity_1.doubleDistributivity,
+    firstIdentity_1.firstIdentity,
+    secondIdentity_1.secondIdentity,
+    thirdIdentity_1.thirdIdentity,
+    allIdentities_1.allIdentities,
+    equationType1Exercise_1.equationType1Exercise,
+    equationType2Exercise_1.equationType2Exercise,
+    equationType3Exercise_1.equationType3Exercise,
+    equationType4Exercise_1.equationType4Exercise,
+    simpifySquareRoot_1.simplifySquareRoot,
+];

package/src/exercises/exercises.ts

@@ -0,0 +1,27 @@
+import { allIdentities } from "./calculLitteral/distributivity/allIdentities";
+import { doubleDistributivity } from "./calculLitteral/distributivity/doubleDistributivity";
+import { firstIdentity } from "./calculLitteral/distributivity/firstIdentity";
+import { secondIdentity } from "./calculLitteral/distributivity/secondIdentity";
+import { simpleDistributivity } from "./calculLitteral/distributivity/simpleDistributivity";
+import { thirdIdentity } from "./calculLitteral/distributivity/thirdIdentity";
+import { equationType1Exercise } from "./calculLitteral/equation/equationType1Exercise";
+import { equationType2Exercise } from "./calculLitteral/equation/equationType2Exercise";
+import { equationType3Exercise } from "./calculLitteral/equation/equationType3Exercise";
+import { equationType4Exercise } from "./calculLitteral/equation/equationType4Exercise";
+import { factoType1Exercise } from "./calculLitteral/factorisation/factoType1Exercise";
+import { simplifySquareRoot } from "./squareRoots/simpifySquareRoot";
+
+export const exercises = [
+  factoType1Exercise,
+  simpleDistributivity,
+  doubleDistributivity,
+  firstIdentity,
+  secondIdentity,
+  thirdIdentity,
+  allIdentities,
+  equationType1Exercise,
+  equationType2Exercise,
+  equationType3Exercise,
+  equationType4Exercise,
+  simplifySquareRoot,
+];

package/src/exercises/squareRoots/simpifySquareRoot.js

@@ -0,0 +1,27 @@
+"use strict";
+exports.__esModule = true;
+exports.getSimplifySquareRoot = exports.simplifySquareRoot = void 0;
+var squareRoot_1 = require("../../numbers/reals/squareRoot");
+var latexParse_1 = require("../../tree/latexParser/latexParse");
+var getDistinctQuestions_1 = require("../utils/getDistinctQuestions");
+exports.simplifySquareRoot = {
+    id: "simplifySqrt",
+    connector: "=",
+    instruction: "Simplifier :",
+    label: "Simplification de racines carrées",
+    levels: ["3", "2", "1"],
+    section: "Racines carrées",
+    generator: function (nb) { return (0, getDistinctQuestions_1.getDistinctQuestions)(getSimplifySquareRoot, nb); }
+};
+function getSimplifySquareRoot() {
+    var squareRoot = squareRoot_1.SquareRootConstructor.randomSimplifiable({
+        allowPerfectSquare: false,
+        maxSquare: 11
+    });
+    var question = {
+        statement: (0, latexParse_1.latexParse)(squareRoot.toTree()),
+        answer: (0, latexParse_1.latexParse)(squareRoot.simplify().toTree())
+    };
+    return question;
+}
+exports.getSimplifySquareRoot = getSimplifySquareRoot;

package/src/exercises/squareRoots/simpifySquareRoot.ts

@@ -0,0 +1,26 @@
+import { SquareRootConstructor } from "../../numbers/reals/squareRoot";
+import { latexParse } from "../../tree/latexParser/latexParse";
+import { Exercise, Question } from "../exercise";
+import { getDistinctQuestions } from "../utils/getDistinctQuestions";
+
+export const simplifySquareRoot: Exercise = {
+  id: "simplifySqrt",
+  connector: "=",
+  instruction: "Simplifier :",
+  label: "Simplification de racines carrées",
+  levels: ["3", "2", "1"],
+  section: "Racines carrées",
+  generator: (nb: number) => getDistinctQuestions(getSimplifySquareRoot, nb),
+};
+
+export function getSimplifySquareRoot(): Question {
+  const squareRoot = SquareRootConstructor.randomSimplifiable({
+    allowPerfectSquare: false,
+    maxSquare: 11,
+  });
+  const question: Question = {
+    statement: latexParse(squareRoot.toTree()),
+    answer: latexParse(squareRoot.simplify().toTree()),
+  };
+  return question;
+}

package/src/expression/expression.js

@@ -3,5 +3,7 @@ exports.__esModule = true;
 exports.ExpressionType = void 0;
 var ExpressionType;
 (function (ExpressionType) {
-    ExpressionType[ExpressionType["polynomial"] = 0] = "polynomial";
+    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,9 +1,13 @@
 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/index.js

@@ -1,8 +1,5 @@
 "use strict";
 exports.__esModule = true;
-var factoType1Exercise_1 = require("./exercises/calculLitteral/factorisation/factoType1Exercise");
-// exercice = new Exercice(Factorisation.type, nbQuestions, opts)
-//exercice = {questions: {statement, answer}, consigne, label, section, levels, connector, }
-var exercice = new factoType1Exercise_1.FactoType1Exercise(10);
-console.log(exercice.instruction);
-console.log(exercice.questions);
+exports.exercises = void 0;
+var exercises_1 = require("./exercises/exercises");
+exports.exercises = exercises_1.exercises;

package/src/index.ts

@@ -1,7 +1,19 @@
-import { FactoType1Exercise } from "./exercises/calculLitteral/factorisation/factoType1Exercise";
+import { allIdentities } from "./exercises/calculLitteral/distributivity/allIdentities";
+import { doubleDistributivity } from "./exercises/calculLitteral/distributivity/doubleDistributivity";
+import { simpleDistributivity } from "./exercises/calculLitteral/distributivity/simpleDistributivity";
+import { equationType1Exercise } from "./exercises/calculLitteral/equation/equationType1Exercise";
+import { equationType2Exercise } from "./exercises/calculLitteral/equation/equationType2Exercise";
+import { equationType3Exercise } from "./exercises/calculLitteral/equation/equationType3Exercise";
+import { equationType4Exercise } from "./exercises/calculLitteral/equation/equationType4Exercise";
+import { factoType1Exercise } from "./exercises/calculLitteral/factorisation/factoType1Exercise";
+import { exercises } from "./exercises/exercises";
+import { simplifySquareRoot } from "./exercises/squareRoots/simpifySquareRoot";
+import { randint } from "./mathutils/random/randint";
+import { Rational } from "./numbers/rationals/rational";
+import { SquareRoot } from "./numbers/reals/squareRoot";
+import { Affine } from "./polynomials/affine";
+import { Polynomial } from "./polynomials/polynomial";
+import { latexParse } from "./tree/latexParser/latexParse";
+import { VariableNode } from "./tree/nodes/variables/variableNode";
 
-// exercice = new Exercice(Factorisation.type, nbQuestions, opts)
-//exercice = {questions: {statement, answer}, consigne, label, section, levels, connector, }
-const exercice = new FactoType1Exercise(10);
-console.log(exercice.instruction);
-console.log(exercice.questions);
+export { exercises };

package/src/mathutils/arithmetic/isSquare.js

@@ -0,0 +1,7 @@
+"use strict";
+exports.__esModule = true;
+exports.isSquare = void 0;
+var isSquare = function (a) {
+    return a > 0 && Math.sqrt(a) % 1 === 0;
+};
+exports.isSquare = isSquare;

package/src/mathutils/arithmetic/primeFactors.js

@@ -0,0 +1,22 @@
+"use strict";
+exports.__esModule = true;
+exports.primeFactors = void 0;
+/***
+ * returns array of prime factors
+ * e.g 12 -> [2, 2, 3]
+ */
+var primeFactors = function (a) {
+    var factors = [];
+    var divisor = 2;
+    while (a >= 2) {
+        if (a % divisor === 0) {
+            factors.push(divisor);
+            a = a / divisor;
+        }
+        else {
+            divisor++;
+        }
+    }
+    return factors;
+};
+exports.primeFactors = primeFactors;

package/src/numbers/integer/integer.js

@@ -0,0 +1,15 @@
+"use strict";
+exports.__esModule = true;
+exports.Integer = void 0;
+var numberNode_1 = require("../../tree/nodes/numbers/numberNode");
+var Integer = /** @class */ (function () {
+    function Integer(value) {
+        this.value = value;
+        this.tex = value + "";
+    }
+    Integer.prototype.toTree = function () {
+        return new numberNode_1.NumberNode(this.value);
+    };
+    return Integer;
+}());
+exports.Integer = Integer;