math-exercises 2.0.21 → 2.0.23

package/lib/exercises/calculLitteral/equation/equationType3Exercise.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"equationType3Exercise.d.ts","sourceRoot":"","sources":["../../../../src/exercises/calculLitteral/equation/equationType3Exercise.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AAgBlC;;GAEG;AACH,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAsDF,eAAO,MAAM,qBAAqB,EAAE,YAAY,CAAC,WAAW,CAc3D,CAAC"}
+{"version":3,"file":"equationType3Exercise.d.ts","sourceRoot":"","sources":["../../../../src/exercises/calculLitteral/equation/equationType3Exercise.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AAiBlC;;GAEG;AACH,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAsDF,eAAO,MAAM,qBAAqB,EAAE,YAAY,CAAC,WAAW,CAc3D,CAAC"}

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

@@ -15,15 +15,16 @@ const equalNode_1 = require("../../../tree/nodes/equations/equalNode");
 const discreteSetNode_1 = require("../../../tree/nodes/sets/discreteSetNode");
 const variableNode_1 = require("../../../tree/nodes/variables/variableNode");
 const shuffle_1 = require("../../../utils/shuffle");
+const numberNode_1 = require("../../../tree/nodes/numbers/numberNode");
 const getEquationType3ExerciseQuestion = () => {
     const interval = new intervals_1.Interval("[[-10; 10]]");
     const intervalStar = new intervals_1.Interval("[[-10; 10]]").difference(new discreteSet_1.DiscreteSet([new integer_1.Integer(0)]));
-    const b = intervalStar.getRandomElement();
-    const a = intervalStar.getRandomElement();
-    const c = interval.getRandomElement();
-    const affine = new affine_1.Affine(a.value, b.value).toTree();
-    const solution = new rational_1.Rational(c.value - b.value, a.value).simplify();
-    const statementTree = new equalNode_1.EqualNode(affine, c.toTree());
+    const b = (0, randint_1.randint)(-10, 11, [0]);
+    const a = (0, randint_1.randint)(-10, 11, [0, 1]);
+    const c = (0, randint_1.randint)(-10, 11);
+    const affine = new affine_1.Affine(a, b).toTree();
+    const solution = new rational_1.Rational(c - b, a).simplify();
+    const statementTree = new equalNode_1.EqualNode(affine, new numberNode_1.NumberNode(c));
     const answerTree = new equalNode_1.EqualNode(new variableNode_1.VariableNode("x"), solution.toTree());
     const answer = answerTree.toTex();
     const question = {
@@ -32,7 +33,7 @@ const getEquationType3ExerciseQuestion = () => {
         answer,
         keys: equationKeys_1.equationKeys,
         answerFormat: "tex",
-        identifiers: { a: a.value, b: b.value, c: c.value },
+        identifiers: { a, b, c },
     };
     return question;
 };

package/lib/exercises/calculLitteral/inequations/firstDegreeInequationsType0.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"firstDegreeInequationsType0.d.ts","sourceRoot":"","sources":["../../../../src/exercises/calculLitteral/inequations/firstDegreeInequationsType0.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AAGlC,OAAO,EACL,gBAAgB,EAGjB,MAAM,mCAAmC,CAAC;AAW3C,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,QAAQ,EAAE,gBAAgB,CAAC;CAC5B,CAAC;AA6DF,eAAO,MAAM,2BAA2B,EAAE,YAAY,CAAC,WAAW,CAajE,CAAC"}
+{"version":3,"file":"firstDegreeInequationsType0.d.ts","sourceRoot":"","sources":["../../../../src/exercises/calculLitteral/inequations/firstDegreeInequationsType0.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AAGlC,OAAO,EACL,gBAAgB,EAGjB,MAAM,mCAAmC,CAAC;AAW3C,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,QAAQ,EAAE,gBAAgB,CAAC;CAC5B,CAAC;AA8DF,eAAO,MAAM,2BAA2B,EAAE,YAAY,CAAC,WAAW,CAajE,CAAC"}

package/lib/exercises/calculLitteral/inequations/firstDegreeInequationsType0.js

@@ -13,8 +13,9 @@ const numberNode_1 = require("../../../tree/nodes/numbers/numberNode");
 const variableNode_1 = require("../../../tree/nodes/variables/variableNode");
 const coinFlip_1 = require("../../../utils/coinFlip");
 const shuffle_1 = require("../../../utils/shuffle");
+/**x +b < c */
 const getFirstDegreeInequationsQuestion = () => {
-    const affine = new affine_1.Affine(1, (0, randint_1.randint)(-10, 11));
+    const affine = new affine_1.Affine(1, (0, randint_1.randint)(-10, 11, [0]));
     const c = (0, randint_1.randint)(-10, 11);
     const result = c - affine.b;
     const ineqType = inequation_1.InequationSymbolConstructor.random();

package/lib/exercises/calculLitteral/inequations/firstDegreeInequationsType1.js

@@ -13,6 +13,7 @@ const inequationSolutionNode_1 = require("../../../tree/nodes/inequations/inequa
 const variableNode_1 = require("../../../tree/nodes/variables/variableNode");
 const coinFlip_1 = require("../../../utils/coinFlip");
 const shuffle_1 = require("../../../utils/shuffle");
+/**ax<b */
 const getFirstDegreeInequationsQuestion = () => {
     const affine = new affine_1.Affine((0, randint_1.randint)(-10, 10, [0, 1]), 0);
     const b = (0, randint_1.randint)(-10, 11);

package/lib/exercises/calculLitteral/inequations/firstDegreeInequationsType2.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"firstDegreeInequationsType2.d.ts","sourceRoot":"","sources":["../../../../src/exercises/calculLitteral/inequations/firstDegreeInequationsType2.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AAGlC,OAAO,EACL,gBAAgB,EAGjB,MAAM,mCAAmC,CAAC;AAc3C,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAwEF,eAAO,MAAM,2BAA2B,EAAE,YAAY,CAAC,WAAW,CAajE,CAAC"}
+{"version":3,"file":"firstDegreeInequationsType2.d.ts","sourceRoot":"","sources":["../../../../src/exercises/calculLitteral/inequations/firstDegreeInequationsType2.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AAGlC,OAAO,EACL,gBAAgB,EAGjB,MAAM,mCAAmC,CAAC;AAc3C,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAyEF,eAAO,MAAM,2BAA2B,EAAE,YAAY,CAAC,WAAW,CAajE,CAAC"}

package/lib/exercises/calculLitteral/inequations/firstDegreeInequationsType2.js

@@ -13,6 +13,7 @@ const inequationSolutionNode_1 = require("../../../tree/nodes/inequations/inequa
 const variableNode_1 = require("../../../tree/nodes/variables/variableNode");
 const coinFlip_1 = require("../../../utils/coinFlip");
 const shuffle_1 = require("../../../utils/shuffle");
+/**ax+b<c */
 const getFirstDegreeInequationsQuestion = () => {
     const affine = new affine_1.Affine((0, randint_1.randint)(-10, 10, [0, 1]), (0, randint_1.randint)(-10, 10, [0]));
     const c = (0, randint_1.randint)(-10, 11);

package/lib/exercises/calculLitteral/inequations/firstDegreeInequationsType3.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"firstDegreeInequationsType3.d.ts","sourceRoot":"","sources":["../../../../src/exercises/calculLitteral/inequations/firstDegreeInequationsType3.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AAGlC,OAAO,EACL,gBAAgB,EAGjB,MAAM,mCAAmC,CAAC;AAW3C,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAoFF,eAAO,MAAM,2BAA2B,EAAE,YAAY,CAAC,WAAW,CAajE,CAAC"}
+{"version":3,"file":"firstDegreeInequationsType3.d.ts","sourceRoot":"","sources":["../../../../src/exercises/calculLitteral/inequations/firstDegreeInequationsType3.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AAGlC,OAAO,EACL,gBAAgB,EAGjB,MAAM,mCAAmC,CAAC;AAW3C,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAqFF,eAAO,MAAM,2BAA2B,EAAE,YAAY,CAAC,WAAW,CAajE,CAAC"}

package/lib/exercises/calculLitteral/inequations/firstDegreeInequationsType3.js

@@ -13,6 +13,7 @@ const inequationSolutionNode_1 = require("../../../tree/nodes/inequations/inequa
 const variableNode_1 = require("../../../tree/nodes/variables/variableNode");
 const coinFlip_1 = require("../../../utils/coinFlip");
 const shuffle_1 = require("../../../utils/shuffle");
+/**ax+b<cx+d */
 const getFirstDegreeInequationsQuestion = () => {
     const affine1 = new affine_1.Affine((0, randint_1.randint)(-10, 10, [0]), (0, randint_1.randint)(-10, 10));
     const affine2 = new affine_1.Affine((0, randint_1.randint)(-10, 10, [0, affine1.a]), (0, randint_1.randint)(-10, 10));

package/lib/exercises/equaDiff/equaDiffCheckSolutionFirstOrderTrinom.d.ts

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

package/lib/exercises/equaDiff/equaDiffCheckSolutionFirstOrderTrinom.d.ts.map

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

package/lib/exercises/equaDiff/equaDiffCheckSolutionFirstOrderTrinom.js

@@ -0,0 +1,53 @@
+"use strict";
+// import {
+//   MathExercise,
+//   Proposition,
+//   QCMGenerator,
+//   Question,
+//   QuestionGenerator,
+//   VEA,
+//   addValidProp,
+//   shuffleProps,
+//   tryToAddWrongProp,
+// } from "../../exercises/exercise";
+// import { getDistinctQuestions } from "../../exercises/utils/getDistinctQuestions";
+// import { TrinomConstructor } from "../../math/polynomials/trinom";
+// type Identifiers = {};
+// /**y = y' + dx^2+ex+f, alors y = ax^2+bx+c */
+// const getEquaDiffCheckSolutionFirstOrderQuestion: QuestionGenerator<
+//   Identifiers
+// > = () => {
+//   const trinom = TrinomConstructor.random();
+//   const d = trinom.a;
+//   const e = trinom.b - 2 * trinom.a;
+//   const f = trinom.c - trinom.b;
+//   const question: Question<Identifiers> = {
+//     answer,
+//     instruction: ``,
+//     keys: [],
+//     answerFormat: "tex",
+//     identifiers: {},
+//   };
+//   return question;
+// };
+// const getPropositions: QCMGenerator<Identifiers> = (n, { answer }) => {
+//   const propositions: Proposition[] = [];
+//   addValidProp(propositions, answer);
+//   while (propositions.length < n) {}
+//   return shuffleProps(propositions, n);
+// };
+// const isAnswerValid: VEA<Identifiers> = (ans, { answer }) => {};
+// export const equaDiffCheckSolutionFirstOrder: MathExercise<Identifiers> = {
+//   id: "equaDiffCheckSolutionFirstOrder",
+//   connector: "",
+//   label: "",
+//   levels: [],
+//   isSingleStep: true,
+//   sections: [],
+//   generator: (nb: number) =>
+//     getDistinctQuestions(getEquaDiffCheckSolutionFirstOrderQuestion, nb),
+//   qcmTimer: 60,
+//   freeTimer: 60,
+//   getPropositions,
+//   isAnswerValid,
+// };

package/lib/exercises/functions/logarithm/log10Simplifying.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"log10Simplifying.d.ts","sourceRoot":"","sources":["../../../../src/exercises/functions/logarithm/log10Simplifying.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EASb,MAAM,0BAA0B,CAAC;AAalC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,OAAO,EAAE,OAAO,CAAC;CAClB,CAAC;AAsFF,eAAO,MAAM,mBAAmB,EAAE,YAAY,CAAC,WAAW,CAgBzD,CAAC;AACF,eAAO,MAAM,iBAAiB,EAAE,YAAY,CAAC,WAAW,CAgBvD,CAAC"}
+{"version":3,"file":"log10Simplifying.d.ts","sourceRoot":"","sources":["../../../../src/exercises/functions/logarithm/log10Simplifying.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EASb,MAAM,0BAA0B,CAAC;AAalC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,OAAO,EAAE,OAAO,CAAC;CAClB,CAAC;AA0FF,eAAO,MAAM,mBAAmB,EAAE,YAAY,CAAC,WAAW,CAgBzD,CAAC;AACF,eAAO,MAAM,iBAAiB,EAAE,YAAY,CAAC,WAAW,CAgBvD,CAAC"}

package/lib/exercises/functions/logarithm/log10Simplifying.js

@@ -15,6 +15,7 @@ const operatorComposition_1 = require("../../../tree/utilities/operatorCompositi
 const random_1 = require("../../../utils/random");
 const getLog10SumSimplifyingQuestion = (opts) => {
     const nb = (0, randint_1.randint)(2, 10);
+    const trueNb = [2, 4, 8].includes(nb) ? 2 : [3, 9].includes(nb) ? 3 : nb;
     const nbTerms = (0, randint_1.randint)(2, 4);
     const powers = [];
     const signs = [];
@@ -36,7 +37,7 @@ const getLog10SumSimplifyingQuestion = (opts) => {
     const answer = statement.simplify();
     const question = {
         answer: answer.toTex(),
-        instruction: `Simplifier le plus possible l'expression suivante : $${statement.toTex()}$`,
+        instruction: `Exprimer le nombre suivant sous la forme $a${opts?.isLog10 ? "\\log" : "\\ln"}\\left(${trueNb}\\right)$ : $\\newline ${statement.toTex()}$`,
         keys: [opts?.isLog10 ? "log" : "ln"],
         answerFormat: "tex",
         identifiers: { nb, powers, signs, isLog10: opts?.isLog10 ?? false },

package/lib/exercises/functions/logarithm/logSimplifiying.js

@@ -31,7 +31,7 @@ const getExpSimplifiying = () => {
     }
     const answer = simplifiedExpression.toTex();
     const question = {
-        instruction: `Simplifier l'expression suivante : $${expression.toTex()}$.`,
+        instruction: `Ecrire le nombre suivant sous la forme $\\ln\\left(a\\right)$ : $\\newline ${expression.toTex()}$.`,
         answer,
         keys: ["ln"],
         answerFormat: "tex",

package/lib/exercises/geometry/vectors/alignementViaColinearity.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"alignementViaColinearity.d.ts","sourceRoot":"","sources":["../../../../src/exercises/geometry/vectors/alignementViaColinearity.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EASb,MAAM,0BAA0B,CAAC;AASlC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AA8CF,eAAO,MAAM,wBAAwB,EAAE,YAAY,CAAC,WAAW,CAY9D,CAAC"}
+{"version":3,"file":"alignementViaColinearity.d.ts","sourceRoot":"","sources":["../../../../src/exercises/geometry/vectors/alignementViaColinearity.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EASb,MAAM,0BAA0B,CAAC;AAUlC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AAkDF,eAAO,MAAM,wBAAwB,EAAE,YAAY,CAAC,WAAW,CAY9D,CAAC"}

package/lib/exercises/geometry/vectors/alignementViaColinearity.js

@@ -3,24 +3,27 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.alignementViaColinearity = void 0;
 const exercise_1 = require("../../../exercises/exercise");
 const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
-const line_1 = require("../../../math/geometry/line");
 const point_1 = require("../../../math/geometry/point");
+const vector_1 = require("../../../math/geometry/vector");
+const randint_1 = require("../../../math/utils/random/randint");
+const numberNode_1 = require("../../../tree/nodes/numbers/numberNode");
 const coinFlip_1 = require("../../../utils/coinFlip");
 const shuffle_1 = require("../../../utils/shuffle");
 const getAlignementViaColinearityQuestion = () => {
     const points = point_1.PointConstructor.randomDifferent(["A", "B"]);
-    const line = new line_1.Line(points[0], points[1]);
+    const AB = vector_1.VectorConstructor.fromPoints(points[0], points[1]);
     let C;
     const isAligned = (0, coinFlip_1.coinFlip)();
+    const coeff = new numberNode_1.NumberNode((0, randint_1.randint)(-4, 4, [0, 1]));
     if (isAligned) {
-        do {
-            C = line.getRandomPoint("C");
-        } while (C.equals(points[0]) || C.equals(points[1]));
+        console.log("1");
+        C = AB.times(coeff).getEndPoint(points[0], "C");
     }
     else {
         do {
+            console.log(`2 : ${AB.x.toTex()} et ${AB.y.toTex()}`);
             C = point_1.PointConstructor.random("C");
-        } while (C.equals(points[0]) || C.equals(points[1]) || line.includes(C));
+        } while (AB.isColinear(vector_1.VectorConstructor.fromPoints(points[0], C)));
     }
     const answer = isAligned ? "Oui" : "Non";
     const question = {
@@ -49,7 +52,7 @@ const getPropositions = (n, { answer }) => {
 };
 exports.alignementViaColinearity = {
     id: "alignementViaColinearity",
-    label: "",
+    label: "Utiliser la colinéarité pour déterminer un alignement",
     levels: ["2nde", "1reSpé"],
     isSingleStep: true,
     sections: ["Vecteurs", "Droites"],

package/lib/exercises/geometry/vectors/fourthParallelogramPoint.d.ts

@@ -0,0 +1,14 @@
+import { MathExercise } from "../../../exercises/exercise";
+type Identifiers = {
+    xA: number;
+    xB: number;
+    xC: number;
+    xD: number;
+    yA: number;
+    yB: number;
+    yC: number;
+    yD: number;
+};
+export declare const fourthParallelogramPoint: MathExercise<Identifiers>;
+export {};
+//# sourceMappingURL=fourthParallelogramPoint.d.ts.map

package/lib/exercises/geometry/vectors/fourthParallelogramPoint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fourthParallelogramPoint.d.ts","sourceRoot":"","sources":["../../../../src/exercises/geometry/vectors/fourthParallelogramPoint.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AAWlC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AAwDF,eAAO,MAAM,wBAAwB,EAAE,YAAY,CAAC,WAAW,CAY9D,CAAC"}

package/lib/exercises/geometry/vectors/fourthParallelogramPoint.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fourthParallelogramPoint = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const coordinatesKeys_1 = require("../../../exercises/utils/keys/coordinatesKeys");
+const point_1 = require("../../../math/geometry/point");
+const vector_1 = require("../../../math/geometry/vector");
+const randint_1 = require("../../../math/utils/random/randint");
+const numberNode_1 = require("../../../tree/nodes/numbers/numberNode");
+const shuffle_1 = require("../../../utils/shuffle");
+const getFourthParallelogramPointQuestion = () => {
+    const points = point_1.PointConstructor.randomDifferent(["A", "B"]);
+    const AB = vector_1.VectorConstructor.fromPoints(points[0], points[1]);
+    let D;
+    do {
+        D = point_1.PointConstructor.random("D");
+    } while (AB.isColinear(vector_1.VectorConstructor.fromPoints(D, points[0])));
+    const C = AB.getEndPoint(D, "C");
+    const answer = D.toCoords();
+    const question = {
+        answer,
+        instruction: `Soient les points $${points[0].toTexWithCoords()}$, $${points[1].toTexWithCoords()}$, et $${C.toTexWithCoords()}$. Quelles sont les coordonnées du point $D$ tel que $ABCD$ soit un parallélogramme ?`,
+        keys: coordinatesKeys_1.coordinatesKeys,
+        answerFormat: "tex",
+        identifiers: {
+            xA: points[0].x.evaluate({}),
+            xB: points[1].x.evaluate({}),
+            xC: C.x.evaluate({}),
+            xD: D.x.evaluate({}),
+            yA: points[0].y.evaluate({}),
+            yB: points[1].y.evaluate({}),
+            yC: C.y.evaluate({}),
+            yD: D.y.evaluate({}),
+        },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, xA, xB, xC, yA, yB, yC, yD }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer, "tex");
+    const AB = new vector_1.Vector("u", new numberNode_1.NumberNode(xB - xA), new numberNode_1.NumberNode(yB - yA));
+    const C = new point_1.Point("C", new numberNode_1.NumberNode(xC), new numberNode_1.NumberNode(yC));
+    const fakeD = AB.getEndPoint(C);
+    (0, exercise_1.tryToAddWrongProp)(propositions, fakeD.toCoords());
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, `\\left(${(0, randint_1.randint)(-10, 10)};${(0, randint_1.randint)(-10, 10)}\\right)`);
+    }
+    return (0, shuffle_1.shuffle)(propositions);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return [ans, ans.replace(",", ";"), "\\left(" + ans + "\\right)"].includes(answer);
+};
+exports.fourthParallelogramPoint = {
+    id: "fourthParallelogramPoint",
+    label: "Déterminer les coordonnées du quatrième point d'un parallélogramme",
+    levels: ["2nde", "1reSpé"],
+    isSingleStep: true,
+    sections: ["Vecteurs", "Droites"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getFourthParallelogramPointQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+};

package/lib/exercises/geometry/vectors/index.d.ts

@@ -5,4 +5,8 @@ export * from "./scalarProductViaCoords";
 export * from "./vectorCoordinatesFromTwoPoints";
 export * from "./scalarProductViaCos";
 export * from "./colinearity";
+export * from "./alignementViaColinearity";
+export * from "./paralellismViaColinearity";
+export * from "./parallelogramViaEqualVectors";
+export * from "./fourthParallelogramPoint";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/geometry/vectors/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/geometry/vectors/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,cAAc,sBAAsB,CAAC;AACrC,cAAc,eAAe,CAAC;AAC9B,cAAc,0BAA0B,CAAC;AACzC,cAAc,kCAAkC,CAAC;AACjD,cAAc,uBAAuB,CAAC;AACtC,cAAc,eAAe,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/geometry/vectors/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,cAAc,sBAAsB,CAAC;AACrC,cAAc,eAAe,CAAC;AAC9B,cAAc,0BAA0B,CAAC;AACzC,cAAc,kCAAkC,CAAC;AACjD,cAAc,uBAAuB,CAAC;AACtC,cAAc,eAAe,CAAC;AAC9B,cAAc,4BAA4B,CAAC;AAC3C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,4BAA4B,CAAC"}

package/lib/exercises/geometry/vectors/index.js

@@ -21,4 +21,7 @@ __exportStar(require("./scalarProductViaCoords"), exports);
 __exportStar(require("./vectorCoordinatesFromTwoPoints"), exports);
 __exportStar(require("./scalarProductViaCos"), exports);
 __exportStar(require("./colinearity"), exports);
-// export * from "./alignementViaColinearity";
+__exportStar(require("./alignementViaColinearity"), exports);
+__exportStar(require("./paralellismViaColinearity"), exports);
+__exportStar(require("./parallelogramViaEqualVectors"), exports);
+__exportStar(require("./fourthParallelogramPoint"), exports);

package/lib/exercises/geometry/vectors/paralellismViaColinearity.d.ts

@@ -0,0 +1,14 @@
+import { MathExercise } from "../../../exercises/exercise";
+type Identifiers = {
+    xA: number;
+    xB: number;
+    xC: number;
+    xD: number;
+    yA: number;
+    yB: number;
+    yC: number;
+    yD: number;
+};
+export declare const paralellismViaColinearity: MathExercise<Identifiers>;
+export {};
+//# sourceMappingURL=paralellismViaColinearity.d.ts.map

package/lib/exercises/geometry/vectors/paralellismViaColinearity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paralellismViaColinearity.d.ts","sourceRoot":"","sources":["../../../../src/exercises/geometry/vectors/paralellismViaColinearity.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EASb,MAAM,0BAA0B,CAAC;AAalC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AA2DF,eAAO,MAAM,yBAAyB,EAAE,YAAY,CAAC,WAAW,CAY/D,CAAC"}

package/lib/exercises/geometry/vectors/paralellismViaColinearity.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paralellismViaColinearity = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const line_1 = require("../../../math/geometry/line");
+const point_1 = require("../../../math/geometry/point");
+const vector_1 = require("../../../math/geometry/vector");
+const randint_1 = require("../../../math/utils/random/randint");
+const numberNode_1 = require("../../../tree/nodes/numbers/numberNode");
+const coinFlip_1 = require("../../../utils/coinFlip");
+const shuffle_1 = require("../../../utils/shuffle");
+const getParalellismViaColinearityQuestion = () => {
+    let points = [];
+    do {
+        points = point_1.PointConstructor.randomDifferent(["A", "B"]);
+    } while (points[0].x.equals(points[1].x));
+    const line = new line_1.Line(points[0], points[1]);
+    let C;
+    do {
+        C = point_1.PointConstructor.random("C");
+    } while (line.includes(C));
+    let D;
+    const coeff = new numberNode_1.NumberNode((0, randint_1.randint)(-4, 4, [0]));
+    const parallele = line.getParallele(C);
+    const isParallele = (0, coinFlip_1.coinFlip)();
+    if (isParallele) {
+        D = vector_1.VectorConstructor.fromPoints(points[0], points[1])
+            .times(coeff)
+            .getEndPoint(C, "D");
+    }
+    else {
+        do {
+            D = point_1.PointConstructor.random("D");
+        } while (parallele.includes(D));
+    }
+    const answer = isParallele ? "Oui" : "Non";
+    const question = {
+        answer,
+        instruction: `Soient les points $${points[0].toTexWithCoords()}$, $${points[1].toTexWithCoords()}$, $${C.toTexWithCoords()}$ et $${D.toTexWithCoords()}$. Les droites $(AB)$ et $(CD)$ sont-elles parallèles ?`,
+        keys: [],
+        answerFormat: "raw",
+        identifiers: {
+            xA: points[0].x.evaluate({}),
+            xB: points[1].x.evaluate({}),
+            xC: C.x.evaluate({}),
+            xD: D.x.evaluate({}),
+            yA: points[0].y.evaluate({}),
+            yB: points[1].y.evaluate({}),
+            yC: C.y.evaluate({}),
+            yD: D.y.evaluate({}),
+        },
+    };
+    return question;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer, "raw");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "Oui", "raw");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "Non", "raw");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "On ne peut pas savoir", "raw");
+    return (0, shuffle_1.shuffle)(propositions);
+};
+exports.paralellismViaColinearity = {
+    id: "paralellismViaColinearity",
+    label: "Utiliser la colinéarité pour déterminer un parallélisme",
+    levels: ["2nde", "1reSpé"],
+    isSingleStep: true,
+    sections: ["Vecteurs", "Droites"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getParalellismViaColinearityQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    answerType: "QCM",
+};

package/lib/exercises/geometry/vectors/parallelogramViaEqualVectors.d.ts

@@ -0,0 +1,14 @@
+import { MathExercise } from "../../../exercises/exercise";
+type Identifiers = {
+    xA: number;
+    xB: number;
+    xC: number;
+    xD: number;
+    yA: number;
+    yB: number;
+    yC: number;
+    yD: number;
+};
+export declare const parallelogramViaEqualVectors: MathExercise<Identifiers>;
+export {};
+//# sourceMappingURL=parallelogramViaEqualVectors.d.ts.map

package/lib/exercises/geometry/vectors/parallelogramViaEqualVectors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parallelogramViaEqualVectors.d.ts","sourceRoot":"","sources":["../../../../src/exercises/geometry/vectors/parallelogramViaEqualVectors.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EASb,MAAM,0BAA0B,CAAC;AAWlC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AAyDF,eAAO,MAAM,4BAA4B,EAAE,YAAY,CAAC,WAAW,CAYlE,CAAC"}

package/lib/exercises/geometry/vectors/parallelogramViaEqualVectors.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parallelogramViaEqualVectors = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const point_1 = require("../../../math/geometry/point");
+const vector_1 = require("../../../math/geometry/vector");
+const coinFlip_1 = require("../../../utils/coinFlip");
+const shuffle_1 = require("../../../utils/shuffle");
+const getParallelogramViaEqualVectorsQuestion = () => {
+    const points = point_1.PointConstructor.randomDifferent(["A", "B"]);
+    const AB = vector_1.VectorConstructor.fromPoints(points[0], points[1]);
+    let D;
+    do {
+        console.log(`1 : points: ${points.map((p) => p.toCoords())}, vec : ${AB.x.toTex()} et ${AB.y.toTex()}`);
+        D = point_1.PointConstructor.random("D");
+    } while (AB.isColinear(vector_1.VectorConstructor.fromPoints(D, points[0])));
+    let C;
+    const isParallelogram = (0, coinFlip_1.coinFlip)();
+    if (isParallelogram) {
+        C = AB.getEndPoint(D, "C");
+    }
+    else {
+        do {
+            console.log("2");
+            C = point_1.PointConstructor.random("C");
+        } while (AB.equals(vector_1.VectorConstructor.fromPoints(D, C)));
+    }
+    const answer = isParallelogram ? "Oui" : "Non";
+    const question = {
+        answer,
+        instruction: `Soient les points $${points[0].toTexWithCoords()}$, $${points[1].toTexWithCoords()}$, $${C.toTexWithCoords()}$ et $${D.toTexWithCoords()}$. $ABCD$ est-il un parallélogramme ?`,
+        keys: [],
+        answerFormat: "raw",
+        identifiers: {
+            xA: points[0].x.evaluate({}),
+            xB: points[1].x.evaluate({}),
+            xC: C.x.evaluate({}),
+            xD: D.x.evaluate({}),
+            yA: points[0].y.evaluate({}),
+            yB: points[1].y.evaluate({}),
+            yC: C.y.evaluate({}),
+            yD: D.y.evaluate({}),
+        },
+    };
+    return question;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer, "raw");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "Oui", "raw");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "Non", "raw");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "On ne peut pas savoir", "raw");
+    return (0, shuffle_1.shuffle)(propositions);
+};
+exports.parallelogramViaEqualVectors = {
+    id: "parallelogramViaEqualVectors",
+    label: "Utiliser les vecteurs pour reconnaître un parallélogramme",
+    levels: ["2nde", "1reSpé"],
+    isSingleStep: true,
+    sections: ["Vecteurs", "Droites"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getParallelogramViaEqualVectorsQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    answerType: "QCM",
+};

package/lib/exercises/geometry/vectors/vectorCoordinatesFromTwoPoints.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vectorCoordinatesFromTwoPoints.d.ts","sourceRoot":"","sources":["../../../../src/exercises/geometry/vectors/vectorCoordinatesFromTwoPoints.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AAKlC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,EAAE,CAAC;IACZ,CAAC,EAAE,MAAM,EAAE,CAAC;CACb,CAAC;AAuDF,eAAO,MAAM,8BAA8B,EAAE,YAAY,CAAC,WAAW,CAapE,CAAC"}
+{"version":3,"file":"vectorCoordinatesFromTwoPoints.d.ts","sourceRoot":"","sources":["../../../../src/exercises/geometry/vectors/vectorCoordinatesFromTwoPoints.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AAKlC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,EAAE,CAAC;IACZ,CAAC,EAAE,MAAM,EAAE,CAAC;CACb,CAAC;AAyDF,eAAO,MAAM,8BAA8B,EAAE,YAAY,CAAC,WAAW,CAapE,CAAC"}

package/lib/exercises/geometry/vectors/vectorCoordinatesFromTwoPoints.js

@@ -35,7 +35,7 @@ const getPropositions = (n, { answer, A, B }) => {
     return (0, exercise_1.shuffleProps)(propositions, n);
 };
 const isAnswerValid = (ans, { answer }) => {
-    return ans === answer;
+    return [ans, ans.replace(",", ";"), "\\left(" + ans + "\\right)"].includes(answer);
 };
 exports.vectorCoordinatesFromTwoPoints = {
     id: "vectorCoordinatesFromTwoPoints",

package/lib/exercises/sequences/arithmetic/arithmeticFindExplicitFormula.js

@@ -17,7 +17,7 @@ const getArithmeticFindExplicitFormula = () => {
     const question = {
         instruction: `$(u_n)$ est une suite arithmétique de premier terme $u_{${firstRank}} = ${firstValue}$ et de raison $r = ${reason}$. $\\\\$ Donner l'expression de $u_n$ en fonction de $n$.`,
         answer,
-        keys: ["un", "equal", "r", "n", "u", "underscore"],
+        keys: ["un", "equal", "n"],
         answerFormat: "tex",
         identifiers: { firstValue, reason },
     };

package/lib/exercises/sequences/geometric/geometricFindExplicitFormula.js

@@ -19,7 +19,7 @@ const getGeometricFindExplicitFormula = () => {
     const question = {
         instruction: `$(u_n)$ est une suite géométrique de premier terme $u_{${firstRank}} = ${firstValue}$ et de raison $q = ${reason}$. $\\\\$ Donner l'expression de $u_n$ en fonction de $n$.`,
         answer,
-        keys: ["un", "equal", "q", "n", "u", "underscore"],
+        keys: ["un", "equal", "n"],
         answerFormat: "tex",
         identifiers: { reason, firstValue },
     };

package/lib/exercises/utils/keys/coordinatesKeys.d.ts

@@ -0,0 +1,3 @@
+import { KeyId } from "../../../types/keyIds";
+export declare const coordinatesKeys: KeyId[];
+//# sourceMappingURL=coordinatesKeys.d.ts.map

package/lib/exercises/utils/keys/coordinatesKeys.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coordinatesKeys.d.ts","sourceRoot":"","sources":["../../../../src/exercises/utils/keys/coordinatesKeys.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAE3C,eAAO,MAAM,eAAe,EAAE,KAAK,EAAsC,CAAC"}

package/lib/exercises/utils/keys/coordinatesKeys.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.coordinatesKeys = void 0;
+exports.coordinatesKeys = ["lbrace", "semicolon", "rbrace"];

package/lib/geogebra/geogebraConstructor.d.ts

@@ -0,0 +1,7 @@
+export declare class GeogebraConstructor {
+    commands: string[];
+    constructor();
+    addCommand(...s: string[]): void;
+    getCommands(): string[];
+}
+//# sourceMappingURL=geogebraConstructor.d.ts.map

package/lib/geogebra/geogebraConstructor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geogebraConstructor.d.ts","sourceRoot":"","sources":["../../src/geogebra/geogebraConstructor.ts"],"names":[],"mappings":"AAAA,qBAAa,mBAAmB;IAC9B,QAAQ,EAAE,MAAM,EAAE,CAAM;;IAIxB,UAAU,CAAC,GAAG,CAAC,EAAE,MAAM,EAAE;IAGzB,WAAW;CAGZ"}

package/lib/geogebra/geogebraConstructor.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeogebraConstructor = void 0;
+class GeogebraConstructor {
+    constructor() {
+        this.commands = [];
+    }
+    addCommand(...s) {
+        this.commands.push(...s);
+    }
+    getCommands() {
+        return this.commands;
+    }
+}
+exports.GeogebraConstructor = GeogebraConstructor;

package/lib/index.d.ts

@@ -515,6 +515,40 @@ declare const mathExercises: (import("./exercises/exercise").MathExercise<{
     yu: number;
     xv: number;
     yv: number;
+}> | import("./exercises/exercise").MathExercise<{
+    xA: number;
+    xB: number;
+    xC: number;
+    yA: number;
+    yB: number;
+    yC: number;
+}> | import("./exercises/exercise").MathExercise<{
+    xA: number;
+    xB: number;
+    xC: number;
+    xD: number;
+    yA: number;
+    yB: number;
+    yC: number;
+    yD: number;
+}> | import("./exercises/exercise").MathExercise<{
+    xA: number;
+    xB: number;
+    xC: number;
+    xD: number;
+    yA: number;
+    yB: number;
+    yC: number;
+    yD: number;
+}> | import("./exercises/exercise").MathExercise<{
+    xA: number;
+    xB: number;
+    xC: number;
+    xD: number;
+    yA: number;
+    yB: number;
+    yC: number;
+    yD: number;
 }> | import("./exercises/exercise").MathExercise<{
     coeffs: number[];
     to: string;

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAqCA,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAA2B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAqCA,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAA2B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,CAAC"}

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

@@ -7,6 +7,7 @@ export declare class Line {
     a: AlgebraicNode | undefined;
     b: AlgebraicNode | undefined;
     constructor(pointA: Point, pointB: Point);
+    getParallele(point: Point): Line;
     includes(point: Point): boolean;
     getRandomPoint(name?: string): Point;
 }

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

@@ -1 +1 @@
-{"version":3,"file":"line.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/line.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAO/D,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAEhC,qBAAa,IAAI;IACf,MAAM,EAAE,KAAK,CAAC;IACd,MAAM,EAAE,KAAK,CAAC;IACd,UAAU,EAAE,OAAO,CAAC;IACpB,CAAC,EAAE,aAAa,GAAG,SAAS,CAAC;IAC7B,CAAC,EAAE,aAAa,GAAG,SAAS,CAAC;gBACjB,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK;IAkBxC,QAAQ,CAAC,KAAK,EAAE,KAAK;IAWrB,cAAc,CAAC,IAAI,CAAC,EAAE,MAAM;CAY7B"}
+{"version":3,"file":"line.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/line.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAO/D,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAEhC,qBAAa,IAAI;IACf,MAAM,EAAE,KAAK,CAAC;IACd,MAAM,EAAE,KAAK,CAAC;IACd,UAAU,EAAE,OAAO,CAAC;IACpB,CAAC,EAAE,aAAa,GAAG,SAAS,CAAC;IAC7B,CAAC,EAAE,aAAa,GAAG,SAAS,CAAC;gBACjB,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK;IAkBxC,YAAY,CAAC,KAAK,EAAE,KAAK;IAUzB,QAAQ,CAAC,KAAK,EAAE,KAAK;IAarB,cAAc,CAAC,IAAI,CAAC,EAAE,MAAM;CAa7B"}

package/lib/math/geometry/line.js

@@ -22,18 +22,30 @@ class Line {
             this.b = new substractNode_1.SubstractNode(this.pointA.y, new multiplyNode_1.MultiplyNode(this.a, this.pointA.x)).simplify();
         }
     }
+    getParallele(point) {
+        if (this.isVertical) {
+            console.log(this.pointA.toTexWithCoords(), this.pointB.toTexWithCoords());
+            throw Error("Parallel vertical lines not implemented");
+        }
+        const x = new addNode_1.AddNode(point.x, new numberNode_1.NumberNode(1)).simplify();
+        const y = new addNode_1.AddNode(point.y, this.a).simplify();
+        const secondPoint = new point_1.Point("D", x, y);
+        return new Line(point, secondPoint);
+    }
     includes(point) {
         if (this.isVertical) {
             return point.x.equals(this.pointA.x);
         }
         return (new substractNode_1.SubstractNode(point.y, new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(this.a, point.x), this.b)).evaluate({}) === 0);
     }
+    //! caution: simplify ne gère pas bien ici
     getRandomPoint(name) {
         if (this.isVertical) {
             return new point_1.Point(name ?? "A", this.pointA.x, new numberNode_1.NumberNode((0, randint_1.randint)(-10, 10)));
         }
         const x = new numberNode_1.NumberNode((0, randint_1.randint)(-10, 10));
         const y = new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(this.a, x), this.b).simplify();
+        console.log(y.toTex(), this.a.toTex(), x.toTex(), this.b?.toTex());
         return new point_1.Point(name ?? "A", x, y);
     }
 }

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

@@ -1 +1 @@
-{"version":3,"file":"point.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/point.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAI/D,8BAAsB,gBAAgB;IACpC,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,KAAK;IAKlC,MAAM,CAAC,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE;CAevC;AAED,qBAAa,KAAK;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;gBACL,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,aAAa,EAAE,CAAC,EAAE,aAAa;IAM5D,KAAK,IAAI,MAAM;IAIf,eAAe,IAAI,MAAM;IAGzB,QAAQ,IAAI,MAAM;IAIlB,UAAU,IAAI,MAAM;IAMpB,UAAU,IAAI,MAAM;IAMpB,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,IAAI,SAAM,GAAG,KAAK;IAiBrC,UAAU,CAAC,CAAC,EAAE,KAAK,GAAG,MAAM;IAM5B,MAAM,CAAC,CAAC,EAAE,KAAK,GAAG,OAAO;IAGzB,SAAS,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK;CAK7B"}
+{"version":3,"file":"point.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/point.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAI/D,8BAAsB,gBAAgB;IACpC,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,KAAK;IAMlC,MAAM,CAAC,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE;CAevC;AAED,qBAAa,KAAK;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;gBACL,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,aAAa,EAAE,CAAC,EAAE,aAAa;IAM5D,KAAK,IAAI,MAAM;IAIf,eAAe,IAAI,MAAM;IAGzB,QAAQ,IAAI,MAAM;IAIlB,UAAU,IAAI,MAAM;IAMpB,UAAU,IAAI,MAAM;IAMpB,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,IAAI,SAAM,GAAG,KAAK;IAiBrC,UAAU,CAAC,CAAC,EAAE,KAAK,GAAG,MAAM;IAM5B,MAAM,CAAC,CAAC,EAAE,KAAK,GAAG,OAAO;IAGzB,SAAS,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK;CAK7B"}

package/lib/math/geometry/point.js

@@ -22,6 +22,7 @@ class PointConstructor {
                 x = (0, randint_1.randint)(-10, 11);
                 y = (0, randint_1.randint)(-10, 11);
             } while (points.some((point) => point[0] === x && point[1] === y));
+            points.push([x, y]);
             res.push(new Point(names[i], new numberNode_1.NumberNode(x), new numberNode_1.NumberNode(y)));
         }
         return res;

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

@@ -17,5 +17,7 @@ export declare class Vector {
     determinant(v: Vector): AlgebraicNode;
     times(k: AlgebraicNode, name?: string): Vector;
     scalarProduct(v: Vector): Node;
+    getEndPoint(startPoint: Point, name?: string): Point;
+    equals(v: Vector): boolean;
 }
 //# sourceMappingURL=vector.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"vector.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/vector.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAC/D,OAAO,EAAE,IAAI,EAAY,MAAM,uBAAuB,CAAC;AAKvD,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAEhC,8BAAsB,iBAAiB;IACrC,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,GAAG,MAAM;IAOpD,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,UAAO,GAAG,MAAM;CAOtD;AAED,qBAAa,MAAM;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;gBACL,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,aAAa,EAAE,CAAC,EAAE,aAAa;IAO5D,KAAK,IAAI,MAAM;IAIf,eAAe,IAAI,MAAM;IAMzB,UAAU,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO;IAI9B,WAAW,CAAC,CAAC,EAAE,MAAM,GAAG,aAAa;IAcrC,KAAK,CAAC,CAAC,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,MAAM;IAOrC,aAAa,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI;CAa/B"}
+{"version":3,"file":"vector.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/vector.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAC/D,OAAO,EAAE,IAAI,EAAY,MAAM,uBAAuB,CAAC;AAMvD,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAEhC,8BAAsB,iBAAiB;IACrC,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,GAAG,MAAM;IAOpD,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,UAAO,GAAG,MAAM;CAOtD;AAED,qBAAa,MAAM;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;gBACL,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,aAAa,EAAE,CAAC,EAAE,aAAa;IAO5D,KAAK,IAAI,MAAM;IAIf,eAAe,IAAI,MAAM;IAMzB,UAAU,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO;IAI9B,WAAW,CAAC,CAAC,EAAE,MAAM,GAAG,aAAa;IAcrC,KAAK,CAAC,CAAC,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,MAAM;IAOrC,aAAa,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI;IAc9B,WAAW,CAAC,UAAU,EAAE,KAAK,EAAE,IAAI,CAAC,EAAE,MAAM;IAO5C,MAAM,CAAC,CAAC,EAAE,MAAM;CAGjB"}

package/lib/math/geometry/vector.js

@@ -3,9 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Vector = exports.VectorConstructor = void 0;
 const node_1 = require("../../tree/nodes/node");
 const numberNode_1 = require("../../tree/nodes/numbers/numberNode");
+const addNode_1 = require("../../tree/nodes/operators/addNode");
 const multiplyNode_1 = require("../../tree/nodes/operators/multiplyNode");
 const substractNode_1 = require("../../tree/nodes/operators/substractNode");
 const randint_1 = require("../utils/random/randint");
+const point_1 = require("./point");
 class VectorConstructor {
     static fromPoints(origin, end) {
         return new Vector(`${origin.name}${end.name}`, new substractNode_1.SubstractNode(end.x, origin.x).simplify(), new substractNode_1.SubstractNode(end.y, origin.y).simplify());
@@ -55,5 +57,11 @@ class Vector {
         const vyValue = v.y.value;
         return new numberNode_1.NumberNode(xValue * vxValue + yValue * vyValue);
     }
+    getEndPoint(startPoint, name) {
+        return new point_1.Point(name ?? "B", new addNode_1.AddNode(startPoint.x, this.x).simplify(), new addNode_1.AddNode(startPoint.y, this.y).simplify());
+    }
+    equals(v) {
+        return this.x.equals(v.x) && this.y.equals(v.y);
+    }
 }
 exports.Vector = Vector;

package/lib/math/numbers/reals/extendedRingElement.d.ts

@@ -1,3 +1,4 @@
+import { OppositeNode } from '../../../tree/nodes/functions/oppositeNode';
 import { NumberNode } from '../../../tree/nodes/numbers/numberNode';
 import { MultiplyNode } from '../../../tree/nodes/operators/multiplyNode';
 import { SubstractNode } from '../../../tree/nodes/operators/substractNode';
@@ -11,6 +12,6 @@ export declare class ExtendedRingElement {
     b: number;
     algebraicElement: Nombre;
     constructor(a: number, b: number, algebraicElement: Nombre);
-    toTree(): import("../../../tree/nodes/algebraicNode").AlgebraicNode | NumberNode | MultiplyNode | SubstractNode;
+    toTree(): import("../../../tree/nodes/algebraicNode").AlgebraicNode | NumberNode | MultiplyNode | OppositeNode | SubstractNode;
 }
 //# sourceMappingURL=extendedRingElement.d.ts.map

package/lib/math/numbers/reals/extendedRingElement.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"extendedRingElement.d.ts","sourceRoot":"","sources":["../../../../src/math/numbers/reals/extendedRingElement.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,qCAAqC,CAAC;AAEjE,OAAO,EAAE,YAAY,EAAE,MAAM,yCAAyC,CAAC;AACvE,OAAO,EAAE,aAAa,EAAE,MAAM,0CAA0C,CAAC;AACzE,OAAO,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAEnC;;;GAGG;AACH,qBAAa,mBAAmB;IAM9B,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,gBAAgB,EAAE,MAAM,CAAC;gBACb,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM;IAM1D,MAAM;CAeP"}
+{"version":3,"file":"extendedRingElement.d.ts","sourceRoot":"","sources":["../../../../src/math/numbers/reals/extendedRingElement.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,yCAAyC,CAAC;AACvE,OAAO,EAAE,UAAU,EAAE,MAAM,qCAAqC,CAAC;AAEjE,OAAO,EAAE,YAAY,EAAE,MAAM,yCAAyC,CAAC;AACvE,OAAO,EAAE,aAAa,EAAE,MAAM,0CAA0C,CAAC;AACzE,OAAO,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAEnC;;;GAGG;AACH,qBAAa,mBAAmB;IAM9B,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,gBAAgB,EAAE,MAAM,CAAC;gBACb,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM;IAM1D,MAAM;CAeP"}

package/lib/math/utils/arithmetic/maxPowerDecomposition.d.ts

@@ -0,0 +1,11 @@
+/**
+ *
+ * @param n
+ * eg for n = 36 will return 6^2
+ * for n = 12 will return 2^2*3
+ */
+export declare const maxPowerDecomposition: (n: number) => {
+    value: number;
+    power: number;
+}[];
+//# sourceMappingURL=maxPowerDecomposition.d.ts.map

package/lib/math/utils/arithmetic/maxPowerDecomposition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"maxPowerDecomposition.d.ts","sourceRoot":"","sources":["../../../../src/math/utils/arithmetic/maxPowerDecomposition.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,MAAO,MAAM;WAEzB,MAAM;WAAS,MAAM;GAW1C,CAAC"}

package/lib/math/utils/arithmetic/maxPowerDecomposition.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.maxPowerDecomposition = void 0;
+const primeDecomposition_1 = require("./primeDecomposition");
+/**
+ *
+ * @param n
+ * eg for n = 36 will return 6^2
+ * for n = 12 will return 2^2*3
+ */
+const maxPowerDecomposition = (n) => {
+    const decomposition = (0, primeDecomposition_1.primeDecomposition)(n);
+    const res = [];
+    for (const item of decomposition) {
+        const { value, power } = item;
+        const matchingPower = res.find((el) => el.power === power);
+        if (matchingPower) {
+            matchingPower.value *= value;
+        }
+        else {
+            res.push(item);
+        }
+    }
+    return res;
+};
+exports.maxPowerDecomposition = maxPowerDecomposition;

package/lib/math/utils/arithmetic/primeDecomposition.d.ts

@@ -0,0 +1,5 @@
+export declare const primeDecomposition: (n: number) => {
+    value: number;
+    power: number;
+}[];
+//# sourceMappingURL=primeDecomposition.d.ts.map

package/lib/math/utils/arithmetic/primeDecomposition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"primeDecomposition.d.ts","sourceRoot":"","sources":["../../../../src/math/utils/arithmetic/primeDecomposition.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,kBAAkB,MAAO,MAAM;WAEtB,MAAM;WAAS,MAAM;GAa1C,CAAC"}

package/lib/math/utils/arithmetic/primeDecomposition.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.primeDecomposition = void 0;
+const primeFactors_1 = require("./primeFactors");
+const primeDecomposition = (n) => {
+    const factors = (0, primeFactors_1.primeFactors)(n);
+    const res = [];
+    for (const factor of factors) {
+        const data = res.find((el) => el.value === factor);
+        if (data) {
+            data.power++;
+        }
+        else {
+            res.push({
+                value: factor,
+                power: 1,
+            });
+        }
+    }
+    return res;
+};
+exports.primeDecomposition = primeDecomposition;

package/lib/server.js

@@ -35,41 +35,12 @@ const express_1 = __importDefault(require("express"));
 const body_parser_1 = __importDefault(require("body-parser"));
 const dotenv_1 = __importDefault(require("dotenv"));
 const cors_1 = __importDefault(require("cors"));
-const decimal_1 = require("./math/numbers/decimals/decimal");
 const jsonParser = body_parser_1.default.json();
 const allExercises = [...exercises];
 const runServer = () => {
     dotenv_1.default.config();
     const app = (0, express_1.default)();
     app.use((0, cors_1.default)());
-    // const string = "\\frac{9}{12}";
-    // const a = string.match(/^[0-9]+,?[0-9]*/);
-    // const before = Date.now();
-    // const parsed = parseLatex(string);
-    // console.log("res", parsed);
-    // console.log(parsed?.toTex());
-    // console.log(parsed?.simplify().toTex());
-    // console.log(parsed?.evaluate({ x: 1 }));
-    // console.log("time", Date.now() - before);
-    // tokenize(string);
-    // const a = DecimalConstructor.random(-4, 8);
-    // const a = new Decimal(-0.0009343);
-    // console.log(a.value, a.multiplyByPowerOfTen(-2).toTree().toTex());
-    // const b = new Decimal(0.0009343);
-    // console.log(b.value, b.multiplyByPowerOfTen(-2).toTree().toTex());
-    // const c = new Decimal(-2.00009343);
-    // console.log(c.value, c.multiplyByPowerOfTen(-2).toTree().toTex());
-    // const d = new Decimal(2.009343);
-    // console.log(d.value, d.multiplyByPowerOfTen(-2).toTree().toTex());
-    const power = 1;
-    const a = new decimal_1.Decimal(-0.00400250009343);
-    console.log(a.value, a.multiplyByPowerOfTen(power).toTree().toTex());
-    const b = new decimal_1.Decimal(0.04010009343);
-    console.log(b.value, b.multiplyByPowerOfTen(power).toTree().toTex());
-    const c = new decimal_1.Decimal(-23.00009343);
-    console.log(c.value, c.multiplyByPowerOfTen(power).toTree().toTex());
-    const d = new decimal_1.Decimal(20.4009343);
-    console.log(d.value, d.multiplyByPowerOfTen(power).toTree().toTex());
     app.get("/", (req, res) => {
         res.json(allExercises);
     });

package/lib/tree/nodes/functions/log10Node.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"log10Node.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/functions/log10Node.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACtD,OAAO,EAAE,YAAY,EAAE,YAAY,EAAkB,MAAM,gBAAgB,CAAC;AAE5E,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAMjD,wBAAgB,WAAW,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,SAAS,CAEnD;AACD,qBAAa,SAAU,YAAW,YAAY;IAC5C,EAAE,EAAE,YAAY,CAAC;IACjB,KAAK,EAAE,aAAa,CAAC;IACrB,IAAI,EAAE,QAAQ,CAAC;IACf,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,SAAS,EAAE,OAAO,CAAC;gBACP,KAAK,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,WAAW;IAQpD,YAAY,IAAI,MAAM;IAItB,KAAK,IAAI,MAAM;IAaf,iBAAiB,IAAI,aAAa,EAAE;IASpC,cAAc,IAAI,MAAM,EAAE;IAG1B,QAAQ,IAAI,aAAa;IA0BzB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAGrC,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;CAGrC"}
+{"version":3,"file":"log10Node.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/functions/log10Node.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACtD,OAAO,EAAE,YAAY,EAAE,YAAY,EAAkB,MAAM,gBAAgB,CAAC;AAE5E,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAQjD,wBAAgB,WAAW,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,SAAS,CAEnD;AACD,qBAAa,SAAU,YAAW,YAAY;IAC5C,EAAE,EAAE,YAAY,CAAC;IACjB,KAAK,EAAE,aAAa,CAAC;IACrB,IAAI,EAAE,QAAQ,CAAC;IACf,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,SAAS,EAAE,OAAO,CAAC;gBACP,KAAK,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,WAAW;IAQpD,YAAY,IAAI,MAAM;IAItB,KAAK,IAAI,MAAM;IAaf,iBAAiB,IAAI,aAAa,EAAE;IASpC,cAAc,IAAI,MAAM,EAAE;IAG1B,QAAQ,IAAI,aAAa;IAgCzB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAGrC,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;CAGrC"}

package/lib/tree/nodes/functions/log10Node.js

@@ -9,7 +9,7 @@ const numberNode_1 = require("../numbers/numberNode");
 const isInt_1 = require("../../../utils/isInt");
 const powerNode_1 = require("../operators/powerNode");
 const multiplyNode_1 = require("../operators/multiplyNode");
-const primeFactors_1 = require("../../../math/utils/arithmetic/primeFactors");
+const maxPowerDecomposition_1 = require("../../../math/utils/arithmetic/maxPowerDecomposition");
 function isLog10Node(a) {
     return (0, functionNode_1.isFunctionNode)(a) && a.id === functionNode_1.FunctionsIds.log10;
 }
@@ -58,11 +58,18 @@ class Log10Node {
             if ((0, isInt_1.isInt)(log10))
                 return new numberNode_1.NumberNode(log10);
             if ((0, isInt_1.isInt)(value)) {
-                const factors = (0, primeFactors_1.primeFactors)(value);
-                if (factors.length === 1)
-                    return this; //isPrime
-                if (factors.every((nb) => nb === factors[0])) {
-                    return new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(factors.length), new Log10Node(new numberNode_1.NumberNode(factors[0]))).simplify();
+                const decomposition = (0, maxPowerDecomposition_1.maxPowerDecomposition)(value);
+                if (decomposition.length === 1) {
+                    const el = decomposition[0];
+                    if (el.power === 1)
+                        return this; //isPrime
+                    else
+                        return new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(el.power), new Log10Node(new numberNode_1.NumberNode(el.value)));
+                }
+                else {
+                    //! things like log(6) will return themselves
+                    //! even true for log(12). Should they be simplified into 2ln(2)+ln(3) ?
+                    return new Log10Node(simplifiedChild);
                 }
             }
         }

package/lib/tree/nodes/functions/logNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"logNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/functions/logNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACtD,OAAO,EAAE,YAAY,EAAE,YAAY,EAAkB,MAAM,gBAAgB,CAAC;AAE5E,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAOjD,wBAAgB,SAAS,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,OAAO,CAE/C;AACD,qBAAa,OAAQ,YAAW,YAAY;IAC1C,EAAE,EAAE,YAAY,CAAC;IACjB,KAAK,EAAE,aAAa,CAAC;IACrB,IAAI,EAAE,QAAQ,CAAC;IACf,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,SAAS,EAAE,OAAO,CAAC;gBACP,KAAK,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,WAAW;IAQpD,YAAY,IAAI,MAAM;IAItB,KAAK,IAAI,MAAM;IAaf,iBAAiB,IAAI,aAAa,EAAE;IASpC,cAAc,IAAI,MAAM,EAAE;IAG1B,QAAQ,IAAI,aAAa;IA6BzB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAGrC,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;CAGrC"}
+{"version":3,"file":"logNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/functions/logNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACtD,OAAO,EAAE,YAAY,EAAE,YAAY,EAAkB,MAAM,gBAAgB,CAAC;AAE5E,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAQjD,wBAAgB,SAAS,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,OAAO,CAE/C;AACD,qBAAa,OAAQ,YAAW,YAAY;IAC1C,EAAE,EAAE,YAAY,CAAC;IACjB,KAAK,EAAE,aAAa,CAAC;IACrB,IAAI,EAAE,QAAQ,CAAC;IACf,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,SAAS,EAAE,OAAO,CAAC;gBACP,KAAK,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,WAAW;IAQpD,YAAY,IAAI,MAAM;IAItB,KAAK,IAAI,MAAM;IAaf,iBAAiB,IAAI,aAAa,EAAE;IASpC,cAAc,IAAI,MAAM,EAAE;IAG1B,QAAQ,IAAI,aAAa;IAmCzB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAGrC,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;CAGrC"}

package/lib/tree/nodes/functions/logNode.js

@@ -9,8 +9,8 @@ const multiplyNode_1 = require("../operators/multiplyNode");
 const powerNode_1 = require("../operators/powerNode");
 const numberNode_1 = require("../numbers/numberNode");
 const isInt_1 = require("../../../utils/isInt");
-const primeFactors_1 = require("../../../math/utils/arithmetic/primeFactors");
 const expNode_1 = require("./expNode");
+const maxPowerDecomposition_1 = require("../../../math/utils/arithmetic/maxPowerDecomposition");
 function isLogNode(a) {
     return (0, functionNode_1.isFunctionNode)(a) && a.id === functionNode_1.FunctionsIds.log;
 }
@@ -55,15 +55,22 @@ class LogNode {
         const simplifiedChild = this.child.simplify();
         if ((0, numberNode_1.isNumberNode)(simplifiedChild)) {
             const value = simplifiedChild.value;
-            const log = Math.log(value);
-            if ((0, isInt_1.isInt)(log))
-                return new numberNode_1.NumberNode(log);
+            const log10 = Math.log10(value);
+            if ((0, isInt_1.isInt)(log10))
+                return new numberNode_1.NumberNode(log10);
             if ((0, isInt_1.isInt)(value)) {
-                const factors = (0, primeFactors_1.primeFactors)(value);
-                if (factors.length === 1)
-                    return this; //isPrime
-                if (factors.every((nb) => nb === factors[0])) {
-                    return new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(factors.length), new LogNode(new numberNode_1.NumberNode(factors[0]))).simplify();
+                const decomposition = (0, maxPowerDecomposition_1.maxPowerDecomposition)(value);
+                if (decomposition.length === 1) {
+                    const el = decomposition[0];
+                    if (el.power === 1)
+                        return this; //isPrime
+                    else
+                        return new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(el.power), new LogNode(new numberNode_1.NumberNode(el.value)));
+                }
+                else {
+                    //! things like log(6) will return themselves
+                    //! even true for log(12). Should they be simplified into 2ln(2)+ln(3) ?
+                    return new LogNode(simplifiedChild);
                 }
             }
         }

package/lib/tree/nodes/functions/oppositeNode.d.ts

@@ -1,5 +1,6 @@
 import { Node, NodeOptions, NodeType } from "../node";
 import { FunctionNode, FunctionsIds } from "./functionNode";
+import { NumberNode } from "../numbers/numberNode";
 import { AlgebraicNode, SimplifyOptions } from "../algebraicNode";
 export declare function isOppositeNode(a: Node): a is OppositeNode;
 export declare class OppositeNode implements FunctionNode {
@@ -19,7 +20,7 @@ export declare class OppositeNode implements FunctionNode {
      */
     toAllValidTexs(opts?: NodeOptions): string[];
     evaluate(vars: Record<string, number>): number;
-    simplify(opts?: SimplifyOptions): AlgebraicNode;
+    simplify(opts?: SimplifyOptions): AlgebraicNode | NumberNode;
     equals(node: AlgebraicNode): boolean;
 }
 //# sourceMappingURL=oppositeNode.d.ts.map

package/lib/tree/nodes/functions/oppositeNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"oppositeNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/functions/oppositeNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAMtD,OAAO,EAAE,YAAY,EAAE,YAAY,EAAkB,MAAM,gBAAgB,CAAC;AAE5E,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAMlE,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,YAAY,CAEzD;AAGD,qBAAa,YAAa,YAAW,YAAY;IAC/C,EAAE,EAAE,YAAY,CAAC;IACjB,KAAK,EAAE,aAAa,CAAC;IACrB,IAAI,EAAE,QAAQ,CAAC;IACf,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,SAAS,EAAE,OAAO,CAAC;gBACP,KAAK,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,WAAW;IAOpD,YAAY,IAAI,MAAM;IAGtB,KAAK,IAAI,MAAM;IAef,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,aAAa,EAAE;IAgCtD;;;;OAIG;IACH,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAQ5C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAGrC,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe;IAG/B,MAAM,CAAC,IAAI,EAAE,aAAa;CAG3B"}
+{"version":3,"file":"oppositeNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/functions/oppositeNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAMtD,OAAO,EAAE,YAAY,EAAE,YAAY,EAAkB,MAAM,gBAAgB,CAAC;AAC5E,OAAO,EAAE,UAAU,EAAgB,MAAM,uBAAuB,CAAC;AACjE,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAMlE,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,YAAY,CAEzD;AAGD,qBAAa,YAAa,YAAW,YAAY;IAC/C,EAAE,EAAE,YAAY,CAAC;IACjB,KAAK,EAAE,aAAa,CAAC;IACrB,IAAI,EAAE,QAAQ,CAAC;IACf,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,SAAS,EAAE,OAAO,CAAC;gBACP,KAAK,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,WAAW;IAOpD,YAAY,IAAI,MAAM;IAGtB,KAAK,IAAI,MAAM;IAef,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,aAAa,EAAE;IAgCtD;;;;OAIG;IACH,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAQ5C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAGrC,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe;IAI/B,MAAM,CAAC,IAAI,EAAE,aAAa;CAG3B"}

package/lib/tree/nodes/functions/oppositeNode.js

@@ -71,6 +71,8 @@ class OppositeNode {
         return -this.child.evaluate(vars);
     }
     simplify(opts) {
+        if ((0, numberNode_1.isNumberNode)(this.child))
+            return new numberNode_1.NumberNode(-this.child.value);
         return new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(-1), this.child).simplify(opts);
     }
     equals(node) {

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,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACtD,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,UAAU;IAGV,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;IA2BpC,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAI5C,KAAK,IAAI,MAAM;IAaf,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAMrC,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe,GAAG,aAAa;IAmF/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,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACtD,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,UAAU;IAGV,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;IA2BpC,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAI5C,KAAK,IAAI,MAAM;IAaf,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAMrC,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe,GAAG,aAAa;IAyF/C,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;CAOrC"}

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

@@ -78,6 +78,12 @@ class FractionNode {
         const simplifiedNum = this.leftChild.simplify(opts);
         const simplifiedDenum = this.rightChild.simplify(opts);
         const copy = new FractionNode(simplifiedNum, simplifiedDenum, this.opts);
+        if ((0, numberNode_1.isNumberNode)(simplifiedDenum) && simplifiedDenum.value === 1) {
+            return simplifiedNum;
+        }
+        if ((0, numberNode_1.isNumberNode)(simplifiedDenum) && simplifiedDenum.value === -1) {
+            return new oppositeNode_1.OppositeNode(simplifiedNum).simplify(opts);
+        }
         const externalsNums = [];
         const externalsDenums = [];
         const recursiveNums = (node) => {

package/package.json

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