math-exercises 2.0.35 → 2.0.36

package/lib/exercises/functions/trinoms/factorizedFormFromRoots.js

@@ -27,7 +27,7 @@ const getFactorizedFormFromRootsQuestion = () => {
     const answerTex = answer.toTex();
     const question = {
         answer: answerTex,
-        instruction: `Soit $f$ un polynôme du second degré avec $a = ${a}$ et qui a ${roots.length === 1
+        instruction: `Soit $f(x) = ax^2 + bx + c$ un polynôme du second degré avec $a = ${a}$ et qui a ${roots.length === 1
             ? `une racine : $${roots[0]}$`
             : `deux racines : $${roots[0]}$ et $${roots[1]}$`}. Déterminer la forme factorisée de $f$.`,
         keys: ["x"],

package/lib/exercises/functions/trinoms/index.d.ts

@@ -12,4 +12,6 @@ export * from "./secondDegreeInequation";
 export * from "./rootsReading";
 export * from "./factorizedFormFromRoots";
 export * from "./summitReading";
+export * from "./summitAbscissFromRoots";
+export * from "./summitAbscissFromDevForm";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/functions/trinoms/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/functions/trinoms/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,wBAAwB,CAAC;AACvC,cAAc,eAAe,CAAC;AAC9B,cAAc,6BAA6B,CAAC;AAC5C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,wBAAwB,CAAC;AACvC,cAAc,oBAAoB,CAAC;AACnC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,0BAA0B,CAAC;AACzC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,2BAA2B,CAAC;AAC1C,cAAc,iBAAiB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/functions/trinoms/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,wBAAwB,CAAC;AACvC,cAAc,eAAe,CAAC;AAC9B,cAAc,6BAA6B,CAAC;AAC5C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,wBAAwB,CAAC;AACvC,cAAc,oBAAoB,CAAC;AACnC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,0BAA0B,CAAC;AACzC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,2BAA2B,CAAC;AAC1C,cAAc,iBAAiB,CAAC;AAChC,cAAc,0BAA0B,CAAC;AACzC,cAAc,4BAA4B,CAAC"}

package/lib/exercises/functions/trinoms/index.js

@@ -28,3 +28,5 @@ __exportStar(require("./secondDegreeInequation"), exports);
 __exportStar(require("./rootsReading"), exports);
 __exportStar(require("./factorizedFormFromRoots"), exports);
 __exportStar(require("./summitReading"), exports);
+__exportStar(require("./summitAbscissFromRoots"), exports);
+__exportStar(require("./summitAbscissFromDevForm"), exports);

package/lib/exercises/functions/trinoms/summitAbscissFromDevForm.d.ts

@@ -0,0 +1,9 @@
+import { MathExercise } from "../../../exercises/exercise";
+type Identifiers = {
+    a: number;
+    b: number;
+    c: number;
+};
+export declare const summitAbscissFromDevForm: MathExercise<Identifiers>;
+export {};
+//# sourceMappingURL=summitAbscissFromDevForm.d.ts.map

package/lib/exercises/functions/trinoms/summitAbscissFromDevForm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"summitAbscissFromDevForm.d.ts","sourceRoot":"","sources":["../../../../src/exercises/functions/trinoms/summitAbscissFromDevForm.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EASb,MAAM,0BAA0B,CAAC;AAOlC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA8CF,eAAO,MAAM,wBAAwB,EAAE,YAAY,CAAC,WAAW,CAc9D,CAAC"}

package/lib/exercises/functions/trinoms/summitAbscissFromDevForm.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.summitAbscissFromDevForm = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const rational_1 = require("../../../math/numbers/rationals/rational");
+const trinom_1 = require("../../../math/polynomials/trinom");
+const randint_1 = require("../../../math/utils/random/randint");
+const getSummitAbscissFromDevFormQuestion = () => {
+    const trinom = trinom_1.TrinomConstructor.random();
+    const alpha = trinom.getAlphaNode();
+    const answer = alpha.toTex();
+    const question = {
+        answer,
+        instruction: `Soit $f(x) = ${trinom
+            .toTree()
+            .toTex()}$ une fonction polynôme du second degré. Quelle est l'abscisse du sommet de la parabole représentant $f$ ?`,
+        keys: [],
+        answerFormat: "tex",
+        identifiers: { a: trinom.a, b: trinom.b, c: trinom.c },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, a, b, c }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    (0, exercise_1.tryToAddWrongProp)(propositions, new rational_1.Rational(-b, a).simplify().toTree().toTex());
+    (0, exercise_1.tryToAddWrongProp)(propositions, new rational_1.Rational(b, a).simplify().toTree().toTex());
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, (0, randint_1.randint)(-10, 10) + "");
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { a, b, c }) => {
+    const node = new rational_1.Rational(-b, 2 * a).simplify().toTree();
+    const texs = node.toAllValidTexs({
+        allowFractionToDecimal: true,
+        allowMinusAnywhereInFraction: true,
+    });
+    return texs.includes(ans);
+};
+exports.summitAbscissFromDevForm = {
+    id: "summitAbscissFromDevForm",
+    connector: "=",
+    label: "Déterminer l'abscisse du sommet d'une parabole en connaissant la forme développée",
+    levels: ["1rePro", "1reSpé", "1reTech"],
+    isSingleStep: true,
+    sections: ["Second degré"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getSummitAbscissFromDevFormQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+};

package/lib/exercises/functions/trinoms/summitAbscissFromRoots.d.ts

@@ -0,0 +1,9 @@
+import { MathExercise } from "../../../exercises/exercise";
+type Identifiers = {
+    a: number;
+    b: number;
+    c: number;
+};
+export declare const summitAbscissFromRoots: MathExercise<Identifiers>;
+export {};
+//# sourceMappingURL=summitAbscissFromRoots.d.ts.map

package/lib/exercises/functions/trinoms/summitAbscissFromRoots.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"summitAbscissFromRoots.d.ts","sourceRoot":"","sources":["../../../../src/exercises/functions/trinoms/summitAbscissFromRoots.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EASb,MAAM,0BAA0B,CAAC;AAOlC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAgDF,eAAO,MAAM,sBAAsB,EAAE,YAAY,CAAC,WAAW,CAc5D,CAAC"}

package/lib/exercises/functions/trinoms/summitAbscissFromRoots.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.summitAbscissFromRoots = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const rational_1 = require("../../../math/numbers/rationals/rational");
+const trinom_1 = require("../../../math/polynomials/trinom");
+const randint_1 = require("../../../math/utils/random/randint");
+const getSummitAbscissFromRootsQuestion = () => {
+    const trinom = trinom_1.TrinomConstructor.randomNiceRoots(2);
+    const roots = trinom.getRoots();
+    console.log("roots", roots);
+    const answer = new rational_1.Rational(roots[0] + roots[1], 2)
+        .simplify()
+        .toTree()
+        .toTex();
+    const question = {
+        answer,
+        instruction: `Soit $f(x) = ax^2+bx+c$ une fonction polynôme du second degé, dont les racines sont $${roots[0]}$ et $${roots[1]}$. Quelle est l'abscisse du sommet de la parabole représentant $f$ ?`,
+        keys: [],
+        answerFormat: "tex",
+        identifiers: { a: trinom.a, b: trinom.b, c: trinom.c },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, a, b, c }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    const roots = new trinom_1.Trinom(a, b, c).getRoots();
+    (0, exercise_1.tryToAddWrongProp)(propositions, roots[0] + roots[1] + "");
+    (0, exercise_1.tryToAddWrongProp)(propositions, new rational_1.Rational(roots[0] - roots[1], 2).simplify().toTree().toTex());
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, (0, randint_1.randint)(-10, 11) + "");
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { answer, a, b, c }) => {
+    const trinom = new trinom_1.Trinom(a, b, c);
+    console.log(ans, answer);
+    const node = trinom.getAlphaNode();
+    const texs = node.toAllValidTexs({
+        allowFractionToDecimal: true,
+        allowMinusAnywhereInFraction: true,
+    });
+    return texs.includes(ans);
+};
+exports.summitAbscissFromRoots = {
+    id: "summitAbscissFromRoots",
+    connector: "=",
+    label: "Déterminer l'abscisse du sommet d'une parabole en connaissant ses racines",
+    levels: ["1reSpé", "1rePro", "1reTech"],
+    isSingleStep: true,
+    sections: ["Second degré"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getSummitAbscissFromRootsQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+};

package/lib/exercises/matrices/index.js

@@ -16,3 +16,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./matrixInversibilityDomain"), exports);
 __exportStar(require("./productCell"), exports);
+// export * from "./matrixGeneralTerm";

package/lib/exercises/matrices/matrixGeneralTerm.d.ts

@@ -0,0 +1,10 @@
+import { MathExercise } from "../../exercises/exercise";
+type Identifiers = {
+    n: number;
+    p: number;
+    alpha: number;
+    beta: number;
+};
+export declare const matrixGeneralTerm: MathExercise<Identifiers>;
+export {};
+//# sourceMappingURL=matrixGeneralTerm.d.ts.map

package/lib/exercises/matrices/matrixGeneralTerm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"matrixGeneralTerm.d.ts","sourceRoot":"","sources":["../../../src/exercises/matrices/matrixGeneralTerm.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EASb,MAAM,0BAA0B,CAAC;AASlC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAsDF,eAAO,MAAM,iBAAiB,EAAE,YAAY,CAAC,WAAW,CAavD,CAAC"}

package/lib/exercises/matrices/matrixGeneralTerm.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matrixGeneralTerm = void 0;
+const exercise_1 = require("../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../exercises/utils/getDistinctQuestions");
+const matrix_1 = require("../../math/matrices/matrix");
+const randint_1 = require("../../math/utils/random/randint");
+const addNode_1 = require("../../tree/nodes/operators/addNode");
+const multiplyNode_1 = require("../../tree/nodes/operators/multiplyNode");
+const variableNode_1 = require("../../tree/nodes/variables/variableNode");
+const doWhile_1 = require("../../utils/doWhile");
+//A d'ordre nxp avec a_(i,j) = alpha*i + beta*j
+const getMatrixGeneralTermQuestion = () => {
+    const n = (0, randint_1.randint)(1, 5);
+    const p = (0, doWhile_1.doWhile)(() => (0, randint_1.randint)(1, 5), (res) => n === 1 && res === 1);
+    const alpha = (0, randint_1.randint)(-5, 6, [0]);
+    const beta = (0, randint_1.randint)(-5, 6, [0]);
+    const aij = new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(alpha.toTree(), new variableNode_1.VariableNode("i")), new multiplyNode_1.MultiplyNode(beta.toTree(), new variableNode_1.VariableNode("j"))).simplify();
+    const elements = Array.from(Array(n), (_, rowIndex) => Array.from(Array(p), (__, colIndex) => (alpha * (rowIndex + 1) + beta * (colIndex + 1)).toTree()));
+    const matrix = new matrix_1.Matrix(elements);
+    const answer = matrix.toTex();
+    const question = {
+        answer,
+        instruction: `Soit $A = (a_{i,j})$ une matrice d'ordre $n \\times p$ telle que : $n = ${n}$, $p = ${p}$ et pour tout $1\\leq i \\leq n$ et $1\\leq j \\leq p$, $a_{i,j} = ${aij.toTex()}$. Quelle est l'expression de la matrice $A$ ? `,
+        keys: [],
+        answerFormat: "tex",
+        identifiers: { n, p, alpha, beta },
+    };
+    return question;
+};
+const getPropositions = (nb, { answer, n, p, alpha, beta }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    const transposedElements = Array.from(Array(p), (_, rowIndex) => Array.from(Array(n), (__, colIndex) => (alpha * (rowIndex + 1) + beta * (colIndex + 1)).toTree()));
+    const matrix = new matrix_1.Matrix(transposedElements);
+    (0, exercise_1.tryToAddWrongProp)(propositions, matrix.toTex());
+    while (propositions.length < nb) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, matrix_1.MatrixConstructor.random(n, p).toTex());
+    }
+    return (0, exercise_1.shuffleProps)(propositions, nb);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+exports.matrixGeneralTerm = {
+    id: "matrixGeneralTerm",
+    label: "Déterminer l'expression d'une matrice",
+    levels: ["MathExp"],
+    isSingleStep: true,
+    sections: ["Matrices"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getMatrixGeneralTermQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    answerType: "QCM",
+};

package/lib/exercises/probaStat/probaFromTableWithContext.js

@@ -29,7 +29,7 @@ const getProbaFromTableWithContextQuestion = () => {
             [event, proba] = (0, random_1.random)([
                 ["une fille", [aTotal, total]],
                 ["une élève qui porte des lunettes", [bTotal, total]],
-                ["un garçons", [aBarreTotal, total]],
+                ["un garçon", [aBarreTotal, total]],
                 ["une élève qui ne porte pas de lunettes", [bBarreTotal, total]],
             ]);
             break;

package/lib/index.d.ts

@@ -486,6 +486,14 @@ declare const mathExercises: (import("./exercises/exercise").MathExercise<{
     a: number;
     b: number;
     c: number;
+}> | import("./exercises/exercise").MathExercise<{
+    a: number;
+    b: number;
+    c: number;
+}> | import("./exercises/exercise").MathExercise<{
+    a: number;
+    b: number;
+    c: number;
 }> | import("./exercises/exercise").MathExercise<{
     a: number;
     k: number;

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAGA,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,MAAM;QACd,MAAM,EAAE,MAAM,aAAa,CAAC;KAC7B;CACF;AA6CD,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAC3D,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAtCnB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA+BE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA/BF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA+BE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCA/BF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA+BE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAO4C,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAGA,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,MAAM;QACd,MAAM,EAAE,MAAM,aAAa,CAAC;KAC7B;CACF;AA6CD,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAC3D,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAtCnB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA+BE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA/BF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA+BE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCA/BF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA+BE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAO4C,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,CAAC"}

package/lib/math/matrices/matrix.d.ts

@@ -1,4 +1,7 @@
 import { AlgebraicNode } from "../../tree/nodes/algebraicNode";
+export declare abstract class MatrixConstructor {
+    static random(rows: number, cols: number): Matrix;
+}
 export declare class Matrix {
     elements: AlgebraicNode[][];
     rows: number;

package/lib/math/matrices/matrix.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"matrix.d.ts","sourceRoot":"","sources":["../../../src/math/matrices/matrix.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAI/D,qBAAa,MAAM;IACjB,QAAQ,EAAE,aAAa,EAAE,EAAE,CAAC;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;gBACJ,QAAQ,EAAE,aAAa,EAAE,EAAE;IAKvC,WAAW;IAUX,KAAK;CAKN"}
+{"version":3,"file":"matrix.d.ts","sourceRoot":"","sources":["../../../src/math/matrices/matrix.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAK/D,8BAAsB,iBAAiB;IACrC,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM;CAMzC;AACD,qBAAa,MAAM;IACjB,QAAQ,EAAE,aAAa,EAAE,EAAE,CAAC;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;gBACJ,QAAQ,EAAE,aAAa,EAAE,EAAE;IAKvC,WAAW;IAUX,KAAK;CAUN"}

package/lib/math/matrices/matrix.js

@@ -1,8 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Matrix = void 0;
+exports.Matrix = exports.MatrixConstructor = void 0;
 const multiplyNode_1 = require("../../tree/nodes/operators/multiplyNode");
 const substractNode_1 = require("../../tree/nodes/operators/substractNode");
+const randint_1 = require("../utils/random/randint");
+class MatrixConstructor {
+    static random(rows, cols) {
+        const elts = Array.from(Array(rows), (_, rowIndex) => Array.from(Array(cols), (__, colIndex) => (0, randint_1.randint)(-10, 11).toTree()));
+        return new Matrix(elts);
+    }
+}
+exports.MatrixConstructor = MatrixConstructor;
 class Matrix {
     constructor(elements) {
         this.elements = elements;
@@ -17,7 +25,7 @@ class Matrix {
     }
     toTex() {
         return `\\begin{pmatrix}${this.elements
-            .map((row) => `${row.map((cell) => cell.toTex()).join("&")} \\\\[6pt]`)
+            .map((row, index) => `${row.map((cell) => cell.toTex()).join("&")} ${index < this.elements.length - 1 ? "\\\\[6pt]" : ""}`)
             .join("")}\\end{pmatrix}`;
     }
 }

package/lib/math/polynomials/trinom.d.ts.map

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

package/lib/math/polynomials/trinom.js

@@ -56,7 +56,10 @@ class TrinomConstructor {
             return new Trinom(a, -2 * a * root, a * root ** 2);
         }
         else {
-            return TrinomConstructor.randomFactorized();
+            const a = (0, randint_1.randint)(-9, 10, [0]);
+            const x1 = (0, randint_1.randint)(-9, 10, []);
+            const x2 = (0, randint_1.randint)(-9, 10, [x1]);
+            return new Trinom(a, -a * (x1 + x2), a * x1 * x2);
         }
     }
 }

package/package.json

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