math-exercises 2.2.6 → 2.2.7

package/lib/exercises/math/sequences/arithmetic/arithmeticFindExplicitFormula.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"arithmeticFindExplicitFormula.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/arithmetic/arithmeticFindExplicitFormula.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,0BAA0B,CAAC;AASlC,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAsDF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,CAc/D,CAAC"}
+{"version":3,"file":"arithmeticFindExplicitFormula.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/arithmetic/arithmeticFindExplicitFormula.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,0BAA0B,CAAC;AASlC,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAsEF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,CAe/D,CAAC"}

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

@@ -20,6 +20,22 @@ const getArithmeticFindExplicitFormula = () => {
         keys: ["un", "equal", "n"],
         answerFormat: "tex",
         identifiers: { firstValue, reason },
+        hint: `Utilise la formule générale d'une suite arithmétique : 
+    
+$u_n = u_0 + n \\times r $,
+
+où $u_0$ est le premier terme et $r$ la raison.`,
+        correction: `La formule générale d'une suite arithmétique est :
+    
+$u_n = u_0 + n \\times r $, 
+
+où $u_0$ est le premier terme et $r$ la raison.
+    
+Ici, puisque $u_0 = ${firstValue}$ et $r = ${reason}$, on a : 
+
+$${answer}$
+
+`,
     };
     return question;
 };
@@ -56,4 +72,5 @@ exports.arithmeticFindExplicitFormula = {
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/sequences/geometric/geometricExplicitFormulaUsage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"geometricExplicitFormulaUsage.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/geometric/geometricExplicitFormulaUsage.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,0BAA0B,CAAC;AASlC,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAgDF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,CAc/D,CAAC"}
+{"version":3,"file":"geometricExplicitFormulaUsage.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/geometric/geometricExplicitFormulaUsage.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,0BAA0B,CAAC;AAUlC,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AA8DF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,CAe/D,CAAC"}

package/lib/exercises/math/sequences/geometric/geometricExplicitFormulaUsage.js

@@ -8,6 +8,7 @@ const numberNode_1 = require("../../../../tree/nodes/numbers/numberNode");
 const multiplyNode_1 = require("../../../../tree/nodes/operators/multiplyNode");
 const powerNode_1 = require("../../../../tree/nodes/operators/powerNode");
 const variableNode_1 = require("../../../../tree/nodes/variables/variableNode");
+const alignTex_1 = require("../../../../utils/alignTex");
 const shuffle_1 = require("../../../../utils/shuffle");
 const getGeometricExplicitFormulaUsage = () => {
     const askedRank = (0, randint_1.randint)(0, 10);
@@ -23,6 +24,17 @@ const getGeometricExplicitFormulaUsage = () => {
         keys: ["u", "underscore", "equal"],
         answerFormat: "tex",
         identifiers: { firstValue, reason, askedRank },
+        hint: `Il suffit de remplacer $n$ par $${askedRank}$ dans la formule donnée.`,
+        correction: `On remplace $n$ par $${askedRank}$ dans la formule donnée : 
+    
+${(0, alignTex_1.alignTex)([
+            [
+                `u_{${askedRank}}`,
+                "=",
+                new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(firstValue), new powerNode_1.PowerNode(new numberNode_1.NumberNode(reason), askedRank.toTree())).toTex(),
+            ],
+            ["", "=", answer],
+        ])}`,
     };
     return question;
 };
@@ -54,4 +66,5 @@ exports.geometricExplicitFormulaUsage = {
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/sequences/geometric/geometricFindExplicitFormula.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"geometricFindExplicitFormula.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/geometric/geometricFindExplicitFormula.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,0BAA0B,CAAC;AASlC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAmEF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,CAc9D,CAAC"}
+{"version":3,"file":"geometricFindExplicitFormula.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/geometric/geometricFindExplicitFormula.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,0BAA0B,CAAC;AASlC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAiFF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,CAe9D,CAAC"}

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

@@ -22,6 +22,20 @@ const getGeometricFindExplicitFormula = () => {
         keys: ["un", "equal", "n"],
         answerFormat: "tex",
         identifiers: { reason, firstValue },
+        hint: `Utilise la formule générale d'une suite géométrique : 
+    
+$u_n = u_0 \\times r^n $,
+
+où $u_0$ est le premier terme et $r$ la raison.`,
+        correction: `La formule générale d'une suite géométrique est :
+    
+$u_n = u_0 \\times r^n $,
+
+où $u_0$ est le premier terme et $r$ la raison.
+    
+Ici, puisque $u_0 = ${firstValue}$ et $r = ${reason}$, on a : 
+
+$${answer}$`,
     };
     return question;
 };
@@ -58,4 +72,5 @@ exports.geometricFindExplicitFormula = {
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/spaceGeometry/vectors/spaceVectorCoordinatesFromPoints.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"spaceVectorCoordinatesFromPoints.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/vectors/spaceVectorCoordinatesFromPoints.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,0BAA0B,CAAC;AAQlC,KAAK,WAAW,GAAG,EAAE,CAAC;AA6CtB,eAAO,MAAM,gCAAgC,EAAE,QAAQ,CAAC,WAAW,CAelE,CAAC"}
+{"version":3,"file":"spaceVectorCoordinatesFromPoints.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/vectors/spaceVectorCoordinatesFromPoints.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,0BAA0B,CAAC;AAUlC,KAAK,WAAW,GAAG,EAAE,CAAC;AAmEtB,eAAO,MAAM,gCAAgC,EAAE,QAAQ,CAAC,WAAW,CAgBlE,CAAC"}

package/lib/exercises/math/spaceGeometry/vectors/spaceVectorCoordinatesFromPoints.js

@@ -5,6 +5,8 @@ const exercise_1 = require("../../../../exercises/exercise");
 const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
 const spacePoint_1 = require("../../../../math/geometry/spacePoint");
 const spaceVector_1 = require("../../../../math/geometry/spaceVector");
+const substractNode_1 = require("../../../../tree/nodes/operators/substractNode");
+const alignTex_1 = require("../../../../utils/alignTex");
 const getSpaceVectorCoordinatesFromPointsQuestion = () => {
     const points = spacePoint_1.SpacePointConstructor.randomDifferent(["A", "B"]);
     const vector = spaceVector_1.SpaceVectorConstructor.fromPoints(points[0], points[1]);
@@ -22,6 +24,18 @@ const getSpaceVectorCoordinatesFromPointsQuestion = () => {
             by: points[1].y.evaluate({}),
             bz: points[1].z.evaluate({}),
         },
+        hint: `Soient deux points $M(x_M;y_M;z_M)$ et $N(x_N;y_N;z_N)$, alors le vecteur $\\overrightarrow{MN}$ a pour coordonnées :
+    
+$\\overrightarrow{MN} \\begin{pmatrix} x_N - x_M \\\\ y_N - y_M \\\\ z_N - z_M \\end{pmatrix}$`,
+        correction: `Les coordonnées du vecteur $\\overrightarrow{AB}$ sont : 
+
+${(0, alignTex_1.alignTex)([
+            [
+                `\\begin{pmatrix} ${new substractNode_1.SubstractNode(points[1].x, points[0].x).toTex()} \\\\ ${new substractNode_1.SubstractNode(points[1].y, points[0].y).toTex()} \\\\ ${new substractNode_1.SubstractNode(points[1].z, points[0].z).toTex()} \\end{pmatrix}`,
+                "=",
+                vector.toCoordsTex(),
+            ],
+        ])}`,
     };
     return question;
 };
@@ -49,4 +63,5 @@ exports.spaceVectorCoordinatesFromPoints = {
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/spaceGeometry/vectors/spaceVectorNormCalculation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"spaceVectorNormCalculation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/vectors/spaceVectorNormCalculation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAWlC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA2CF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAa5D,CAAC"}
+{"version":3,"file":"spaceVectorNormCalculation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/vectors/spaceVectorNormCalculation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAYlC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAwEF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAc5D,CAAC"}

package/lib/exercises/math/spaceGeometry/vectors/spaceVectorNormCalculation.js

@@ -6,11 +6,15 @@ const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQ
 const spaceVector_1 = require("../../../../math/geometry/spaceVector");
 const real_1 = require("../../../../math/numbers/reals/real");
 const sqrtNode_1 = require("../../../../tree/nodes/functions/sqrtNode");
+const addNode_1 = require("../../../../tree/nodes/operators/addNode");
+const powerNode_1 = require("../../../../tree/nodes/operators/powerNode");
+const alignTex_1 = require("../../../../utils/alignTex");
 const getSpaceVectorNormCalculationQuestion = () => {
     const u = spaceVector_1.SpaceVectorConstructor.random("u", false);
     const correctAnswer = u.getNorm();
+    const answer = correctAnswer.simplify().toTex();
     const question = {
-        answer: correctAnswer.simplify().toTex(),
+        answer,
         instruction: `Cacluler la norme du vecteur $${u.toTexWithCoords()}$`,
         keys: [],
         answerFormat: "tex",
@@ -19,6 +23,26 @@ const getSpaceVectorNormCalculationQuestion = () => {
             y: u.y.evaluate({}),
             z: u.z.evaluate({}),
         },
+        hint: "La norme d'un vecteur de l'espace est la racine carrée de la somme des carrés de ses coordonnées.",
+        correction: `La norme d'un vecteur de l'espace est la racine carrée de la somme des carrés de ses coordonnées. Ici, on a donc : 
+ 
+${(0, alignTex_1.alignTex)([
+            [
+                "\\lVert \\overrightarrow u \\rVert",
+                "=",
+                new sqrtNode_1.SqrtNode(new addNode_1.AddNode(new powerNode_1.SquareNode(u.x), new addNode_1.AddNode(new powerNode_1.SquareNode(u.y), new powerNode_1.SquareNode(u.z)))).toTex(),
+            ],
+            [
+                "",
+                "=",
+                new sqrtNode_1.SqrtNode((u.x.evaluate({}) ** 2 +
+                    u.y.evaluate({}) ** 2 +
+                    u.z.evaluate({}) ** 2).toTree()).toTex(),
+            ],
+        ])}
+
+Donc $\\lVert \\overrightarrow u \\rVert = ${answer}$.
+`,
     };
     return question;
 };
@@ -51,4 +75,5 @@ exports.spaceVectorNormCalculation = {
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/suites/sequenceEvaluation.js

@@ -130,7 +130,7 @@ const isAnswerValid = (ans, { affine, termeid, termeAdd, termeMult }) => {
 };
 exports.sequenceEvaluation = {
     id: "sequenceEvaluation",
-    label: "Évaluer un terme d'une suite",
+    label: "Exprimer $u_{f(n)}$ en connaissant $u_n$",
     levels: ["1reSpé"],
     isSingleStep: true,
     sections: ["Suites"],

package/lib/exercises/math/suites/sequencePlot.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sequencePlot.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/suites/sequencePlot.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAOlC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC;IACnB,YAAY,EAAE,OAAO,CAAC;CACvB,CAAC;AAqFF,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,CAc9C,CAAC"}
+{"version":3,"file":"sequencePlot.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/suites/sequencePlot.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAOlC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC;IACnB,YAAY,EAAE,OAAO,CAAC;CACvB,CAAC;AA2FF,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,CAe9C,CAAC"}

package/lib/exercises/math/suites/sequencePlot.js

@@ -16,11 +16,11 @@ const getSequencePlotQuestion = () => {
     for (let n = 0; n <= nMax; n++) {
         let u_n;
         if (isArithmetic) {
-            const noise = (0, randfloat_1.randfloat)(-1, 1, 1);
+            const noise = (0, randfloat_1.randfloat)(-2, 2, 1);
             u_n = a * n + b + noise;
         }
         else {
-            const noise = (0, randfloat_1.randfloat)(-1, 1, 1);
+            const noise = (0, randfloat_1.randfloat)(-2, 2, 1);
             u_n = b * Math.pow(a, n) + noise;
         }
         points.push([n, Math.round(u_n)]);
@@ -41,8 +41,9 @@ const getSequencePlotQuestion = () => {
         isXAxesNatural: true,
         isGridSimple: true,
     });
+    const answer = u_nValue.toString();
     const question = {
-        answer: u_nValue.toString(),
+        answer,
         instruction: `Ci-dessous est tracé un nuage de points représentant les valeurs d'une suite $(u_n)$. Quelle est la valeur de $u_{${nValue}}$ ?`,
         commands: ggb.commands,
         options: ggb.getOptions(),
@@ -55,6 +56,11 @@ const getSequencePlotQuestion = () => {
         keys: [],
         answerFormat: "raw",
         identifiers: { nValue, points, isArithmetic },
+        hint: `$u_{${nValue}}$ est l'ordonnée du point d'absicsse $${nValue}$ dans le nuage de points.`,
+        correction: `$u_{${nValue}}$ est l'ordonnée du point d'absicsse $${nValue}$ dans le nuage de points.
+
+On lit donc : $u_{${nValue}}=${answer}$.
+    `,
     };
     return question;
 };
@@ -84,4 +90,5 @@ exports.sequencePlot = {
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
+    hasHintAndCorrection: true,
 };

package/lib/index.d.ts

@@ -7,6 +7,7 @@ declare global {
     }
     interface String {
         toTree: () => AlgebraicNode;
+        unfrenchify: () => number;
     }
 }
 /**
@@ -105,6 +106,10 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
     rand: number;
     a: number;
     b: number;
+}> | import("./exercises/exercise").Exercise<{
+    numbers: number[];
+}> | import("./exercises/exercise").Exercise<{
+    numbers: number[];
 }> | import("./exercises/exercise").Exercise<{
     type: number;
     a: number;
@@ -594,6 +599,38 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
     ineqSymbol: import("./math/inequations/inequation").InegalitySymbols;
     intervals: {
         a: number;
+        /**
+         * TODO
+         * Décimal : permettre facilement -0.xxx
+         * Tree shaking export
+         *
+         * VEA:
+         *  -> -3x est bien transofmré en -3*x, x*(-3) mais pas en -x*3
+         *      ->> faire le meme delire que pour les power mais pour les opposite ?
+         *          c'est à dire créer toutes les permuts en déplacant le moins qquepart
+         *  -> faire des nodes pour les Ensembles de nombre
+         *
+         * !-> choses pour lesquelles la v1 ne marchera pas :
+         *  !-- fractions non réduites
+         *  !-- nbs décimaux avec des 0
+         *  !-- nb quelconque de moins, genre -3*-4 ou -x/-y
+         * !-> pour ces choses là il faut obligatoirement parser la rpéonse élève ?
+         *
+         * Passer les sqrtNode en tree-iable
+         *
+         *
+         *
+         * !!!à fix :
+         * ! fraction réductible
+         * ! 0,20 au lieu de 0,2
+         * ! moins partout dans fraction
+         * !puissances négatives vers inverse fraction
+         * ! simplification du ln
+         * ! meileure gestion des [] : le clavier devriat pouvoir produire des left/right ;
+         *      !aussi en tapant [ puis diviser, le crochet passe en numérateur
+         * ! espace tous les 3 chiffres dans un nb (le clavier doit le fournir aussi!)
+        
+        */
         b: number;
         closure: import("./tree/nodes/sets/closure").ClosureType;
     }[];
@@ -800,7 +837,10 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
 }> | import("./exercises/exercise").Exercise<{
     correctA: number;
     correctB: number;
-}> | import("./exercises/exercise").Exercise<{}> | import("./exercises/exercise").Exercise<{
+}> | import("./exercises/exercise").Exercise<{
+    x: number;
+    y: number;
+}> | import("./exercises/exercise").Exercise<{
     coin: boolean;
     radius: number;
     diametre: number;
@@ -999,7 +1039,6 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
     rate: number;
     nbMois: number;
 }> | import("./exercises/exercise").Exercise<{
-    isFromEvolutionToCM: boolean;
     evolution: number;
 }> | import("./exercises/exercise").Exercise<{
     evolutions: string[];
@@ -1016,6 +1055,8 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
     total: number;
     lefties: number;
 }> | import("./exercises/exercise").Exercise<{}> | import("./exercises/exercise").Exercise<{
+    evolution: number;
+}> | import("./exercises/exercise").Exercise<{
     int: number;
     power: number;
 }> | import("./exercises/exercise").Exercise<{

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/lib/index.js

@@ -31,6 +31,9 @@ const PCExercises = __importStar(require("./exercises/pc"));
 const infiniteNode_1 = require("./tree/nodes/numbers/infiniteNode");
 const toScientific_1 = require("./utils/numberPrototype/toScientific");
 const variableNode_1 = require("./tree/nodes/variables/variableNode");
+String.prototype.unfrenchify = function () {
+    return Number(this.valueOf().replace(",", "."));
+};
 String.prototype.toTree = function () {
     return new variableNode_1.VariableNode(this.valueOf());
 };

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

@@ -14,6 +14,7 @@ export declare class SpaceVector {
     z: AlgebraicNode;
     constructor(name: string, x: AlgebraicNode, y: AlgebraicNode, z: AlgebraicNode);
     toTex(): string;
+    toCoordsTex(): string;
     toInlineCoordsTex(): string;
     toTexWithCoords(): string;
     isColinear(v: SpaceVector): boolean;

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

@@ -1 +1 @@
-{"version":3,"file":"spaceVector.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/spaceVector.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAE/D,OAAO,EAAE,IAAI,EAAY,MAAM,uBAAuB,CAAC;AAQvD,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE1C,8BAAsB,sBAAsB;IAC1C,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,UAAU,EAAE,GAAG,EAAE,UAAU,GAAG,WAAW;IAQnE,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,UAAO,GAAG,WAAW;IAY1D,MAAM,CAAC,gBAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,SAAS,UAAO,GAAG,WAAW,EAAE;CAW1E;AAED,qBAAa,WAAW;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;gBAEf,IAAI,EAAE,MAAM,EACZ,CAAC,EAAE,aAAa,EAChB,CAAC,EAAE,aAAa,EAChB,CAAC,EAAE,aAAa;IASlB,KAAK,IAAI,MAAM;IAIf,iBAAiB,IAAI,MAAM;IAK3B,eAAe,IAAI,MAAM;IAMzB,UAAU,CAAC,CAAC,EAAE,WAAW,GAAG,OAAO;IAGnC,WAAW,CAAC,CAAC,EAAE,WAAW,GAAG,aAAa;IAI1C,KAAK,CAAC,CAAC,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,MAAM;IAQrC,aAAa,CAAC,CAAC,EAAE,WAAW,GAAG,IAAI;IAInC,GAAG,CAAC,CAAC,EAAE,WAAW,GAAG,WAAW;IAShC,OAAO,IAAI,aAAa;IAYxB,WAAW,CAAC,UAAU,EAAE,UAAU,EAAE,IAAI,CAAC,EAAE,MAAM;IAQjD,MAAM,CAAC,CAAC,EAAE,WAAW;CAGtB"}
+{"version":3,"file":"spaceVector.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/spaceVector.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAE/D,OAAO,EAAE,IAAI,EAAY,MAAM,uBAAuB,CAAC;AAQvD,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE1C,8BAAsB,sBAAsB;IAC1C,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,UAAU,EAAE,GAAG,EAAE,UAAU,GAAG,WAAW;IAQnE,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,UAAO,GAAG,WAAW;IAY1D,MAAM,CAAC,gBAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,SAAS,UAAO,GAAG,WAAW,EAAE;CAW1E;AAED,qBAAa,WAAW;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;gBAEf,IAAI,EAAE,MAAM,EACZ,CAAC,EAAE,aAAa,EAChB,CAAC,EAAE,aAAa,EAChB,CAAC,EAAE,aAAa;IASlB,KAAK,IAAI,MAAM;IAIf,WAAW,IAAI,MAAM;IAGrB,iBAAiB,IAAI,MAAM;IAK3B,eAAe,IAAI,MAAM;IAMzB,UAAU,CAAC,CAAC,EAAE,WAAW,GAAG,OAAO;IAGnC,WAAW,CAAC,CAAC,EAAE,WAAW,GAAG,aAAa;IAI1C,KAAK,CAAC,CAAC,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,MAAM;IAQrC,aAAa,CAAC,CAAC,EAAE,WAAW,GAAG,IAAI;IAInC,GAAG,CAAC,CAAC,EAAE,WAAW,GAAG,WAAW;IAShC,OAAO,IAAI,aAAa;IAYxB,WAAW,CAAC,UAAU,EAAE,UAAU,EAAE,IAAI,CAAC,EAAE,MAAM;IAQjD,MAAM,CAAC,CAAC,EAAE,WAAW;CAGtB"}

package/lib/math/geometry/spaceVector.js

@@ -47,6 +47,9 @@ class SpaceVector {
     toTex() {
         return `\\overrightarrow{${this.name}}`;
     }
+    toCoordsTex() {
+        return `\\begin{pmatrix}${this.x.toTex()} \\\\ ${this.y.toTex()} \\\\ ${this.z.toTex()} \\end{pmatrix}`;
+    }
     toInlineCoordsTex() {
         return `\\left(${this.x.simplify().toTex()};${this.y
             .simplify()

package/lib/math/polynomials/trinom.js

@@ -179,14 +179,14 @@ class Trinom extends polynomial_1.Polynomial {
         const alpha = this.getAlpha();
         let square;
         if (alpha !== 0) {
-            square = new powerNode_1.SquareNode(new addNode_1.AddNode(new variableNode_1.VariableNode(this.variable), new oppositeNode_1.OppositeNode(this.getAlphaNode())));
+            square = new powerNode_1.SquareNode(new addNode_1.AddNode(new variableNode_1.VariableNode(this.variable), new oppositeNode_1.OppositeNode(this.getAlphaNode()).simplify()));
         }
         else {
             square = new powerNode_1.SquareNode(new variableNode_1.VariableNode(this.variable));
         }
         const beta = this.getBeta();
         return beta !== 0
-            ? new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(this.a), square), new numberNode_1.NumberNode(this.getBeta()))
+            ? new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(this.a), square), this.getBetaNode())
             : new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(this.a), square);
     }
     getSommet() {

package/lib/playground.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"playground.d.ts","sourceRoot":"","sources":["../src/playground.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,UAAU,YAgBtB,CAAC"}
+{"version":3,"file":"playground.d.ts","sourceRoot":"","sources":["../src/playground.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,UAAU,YAEtB,CAAC"}

package/lib/playground.js

@@ -1,20 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.playground = void 0;
-const affine_1 = require("./math/polynomials/affine");
-const randTupleInt_1 = require("./math/utils/random/randTupleInt");
-const addNode_1 = require("./tree/nodes/operators/addNode");
-const multiplyNode_1 = require("./tree/nodes/operators/multiplyNode");
-const random_1 = require("./utils/random");
-const shuffle_1 = require("./utils/shuffle");
+const toSeparatedThousands_1 = require("./utils/numberPrototype/toSeparatedThousands");
 const playground = () => {
-    const affines = affine_1.AffineConstructor.differentRandoms(3);
-    const permut = [
-        (0, shuffle_1.shuffle)([affines[0], affines[1]]),
-        (0, shuffle_1.shuffle)([affines[0], affines[2]]),
-    ];
-    const operation = (0, random_1.random)(["add", "substract"]);
-    const statementTree = 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()));
-    console.log((0, randTupleInt_1.distinctRandTupleInt)(3, 2, { from: 1, to: 10 }));
+    console.log((0, toSeparatedThousands_1.toSeperatedThousands)("12345,6789"));
 };
 exports.playground = playground;

package/lib/server.d.ts

@@ -7,6 +7,7 @@ declare global {
     }
     interface String {
         toTree: () => AlgebraicNode;
+        unfrenchify: () => number;
     }
 }
 //# sourceMappingURL=server.d.ts.map

package/lib/server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAuC3D,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,MAAM;QACd,MAAM,EAAE,MAAM,aAAa,CAAC;QAC5B,SAAS,EAAE,MAAM,MAAM,CAAC;QACxB,YAAY,EAAE,CAAC,QAAQ,CAAC,EAAE,MAAM,KAAK,aAAa,CAAC;KACpD;IACD,UAAU,MAAM;QACd,MAAM,EAAE,MAAM,aAAa,CAAC;KAC7B;CACF"}
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAuC3D,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,MAAM;QACd,MAAM,EAAE,MAAM,aAAa,CAAC;QAC5B,SAAS,EAAE,MAAM,MAAM,CAAC;QACxB,YAAY,EAAE,CAAC,QAAQ,CAAC,EAAE,MAAM,KAAK,aAAa,CAAC;KACpD;IACD,UAAU,MAAM;QACd,MAAM,EAAE,MAAM,aAAa,CAAC;QAC5B,WAAW,EAAE,MAAM,MAAM,CAAC;KAC3B;CACF"}

package/lib/server.js

@@ -45,6 +45,9 @@ const allExercises = [...mathExercises, ...pcExercises];
 String.prototype.toTree = function () {
     return new variableNode_1.VariableNode(this.valueOf());
 };
+String.prototype.unfrenchify = function () {
+    return Number(this.valueOf().replace(",", "."));
+};
 Number.prototype.toTree = function () {
     const value = this.valueOf();
     if (value === Infinity)
@@ -65,7 +68,7 @@ const runServer = () => {
     app.use((0, cors_1.default)());
     console.log("math exos", mathExercises.length);
     console.log("math hints", mathExercises.filter((exo) => exo.hasHintAndCorrection).length);
-    console.log("pc exos", pcExercises.length);
+    console.log("pc exos", `${pcExercises.length}`);
     (0, playground_1.playground)();
     app.get("/", (req, res) => {
         res.json(allExercises);

package/lib/utils/numberPrototype/toSeparatedThousands.d.ts

@@ -0,0 +1,2 @@
+export declare const toSeperatedThousands: (t: string) => string;
+//# sourceMappingURL=toSeparatedThousands.d.ts.map

package/lib/utils/numberPrototype/toSeparatedThousands.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toSeparatedThousands.d.ts","sourceRoot":"","sources":["../../../src/utils/numberPrototype/toSeparatedThousands.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,oBAAoB,MAAO,MAAM,WAQ7C,CAAC"}

package/lib/utils/numberPrototype/toSeparatedThousands.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toSeperatedThousands = void 0;
+const toSeperatedThousands = (t) => {
+    const n = t.unfrenchify();
+    if (isNaN(n))
+        throw Error("NaN passed to toSeperatedThousands");
+    const [intPart, fracPart] = t.split(",");
+    return (intPart.replace(/\B(?=(\d{3})+(?!\d))/g, "\\ ") +
+        (fracPart !== undefined ? "," + fracPart : ""));
+};
+exports.toSeperatedThousands = toSeperatedThousands;

package/package.json

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