math-exercises 2.1.25 → 2.1.26-beta.2

package/lib/exercises/trigonometry/remarkableValues.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"remarkableValues.d.ts","sourceRoot":"","sources":["../../../src/exercises/trigonometry/remarkableValues.ts"],"names":[],"mappings":"AAOA,OAAO,EACL,YAAY,EAQb,MAAM,aAAa,CAAC;AAerB,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,OAAO,CAAC;CAChB,CAAC;AA4CF,eAAO,MAAM,wBAAwB,EAAE,YAAY,CAAC,WAAW,CAY9D,CAAC"}

package/lib/exercises/trigonometry/remarkableValues.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.remarkableValuesExercise = void 0;
+const remarkableValue_1 = require("../../math/trigonometry/remarkableValue");
+const remarkableValues_1 = require("../../math/trigonometry/remarkableValues");
+const cosNode_1 = require("../../tree/nodes/functions/cosNode");
+const sinNode_1 = require("../../tree/nodes/functions/sinNode");
+const coinFlip_1 = require("../../utils/coinFlip");
+const random_1 = require("../../utils/random");
+const shuffle_1 = require("../../utils/shuffle");
+const exercise_1 = require("../exercise");
+const getDistinctQuestions_1 = require("../utils/getDistinctQuestions");
+const values = [
+    "-1",
+    "-\\frac{\\sqrt 3}{2}",
+    "-\\frac{\\sqrt 2}{2}",
+    "-\\frac{1}{2}",
+    "0",
+    "\\frac{\\sqrt 3}{2}",
+    "\\frac{\\sqrt 2}{2}",
+    "\\frac{1}{2}",
+    "1",
+];
+const getRemarkableValues = () => {
+    const isCos = (0, coinFlip_1.coinFlip)();
+    const remarkableValue = remarkableValue_1.RemarkableValueConstructor.simplifiable();
+    const mainValue = remarkableValue.mainAngle.evaluate({});
+    // const valueIndex = remarkableValue.index;
+    const answer = isCos
+        ? remarkableValue.cos.toTex()
+        : remarkableValue.sin.toTex();
+    const statement = isCos
+        ? new cosNode_1.CosNode(remarkableValue.angle).toTex()
+        : new sinNode_1.SinNode(remarkableValue.angle).toTex();
+    const question = {
+        instruction: `Donner la valeur exacte de : $${statement}$`,
+        startStatement: statement,
+        answer: answer,
+        keys: ["pi", "cos", "sin"],
+        answerFormat: "tex",
+        identifiers: { isCos, mainValue },
+    };
+    return question;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    while (propositions.length < n) {
+        const statement = (0, random_1.random)(values);
+        (0, exercise_1.tryToAddWrongProp)(propositions, statement);
+    }
+    return (0, shuffle_1.shuffle)(propositions);
+};
+const isAnswerValid = (ans, { mainValue, isCos }) => {
+    const remarkableValue = remarkableValues_1.remarkableTrigoValues.find((point) => Math.abs(point.angle.evaluate({}) - mainValue) < 0.0001);
+    const answer = isCos ? remarkableValue.cos : remarkableValue.sin;
+    const texs = answer.toAllValidTexs({
+        allowFractionToDecimal: true,
+        allowMinusAnywhereInFraction: true,
+    });
+    return texs.includes(ans);
+};
+exports.remarkableValuesExercise = {
+    id: "remarkableValues",
+    connector: "=",
+    label: "Valeurs remarquables de $\\cos$ et $\\sin$",
+    levels: ["1reSpé", "TermSpé", "MathComp"],
+    isSingleStep: true,
+    sections: ["Trigonométrie"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getRemarkableValues, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+};

package/lib/exercises/trigonometry/trigonometry.d.ts

@@ -0,0 +1,11 @@
+import { MathExercise } from "../../exercises/exercise";
+type Identifiers = {
+    sideA: string;
+    sideB: string;
+    sideC: string;
+    randAngle: number;
+    randTrigo: number;
+};
+export declare const trigonometry: MathExercise<Identifiers>;
+export {};
+//# sourceMappingURL=trigonometry.d.ts.map

package/lib/exercises/trigonometry/trigonometry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trigonometry.d.ts","sourceRoot":"","sources":["../../../src/exercises/trigonometry/trigonometry.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AAWlC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAqHF,eAAO,MAAM,YAAY,EAAE,YAAY,CAAC,WAAW,CAclD,CAAC"}

package/lib/exercises/trigonometry/trigonometry.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trigonometry = void 0;
+const exercise_1 = require("../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../exercises/utils/getDistinctQuestions");
+const geogebraConstructor_1 = require("../../geogebra/geogebraConstructor");
+const triangles_1 = require("../../math/geometry/triangles");
+const randint_1 = require("../../math/utils/random/randint");
+const lengthNode_1 = require("../../tree/nodes/geometry/lengthNode");
+const fractionNode_1 = require("../../tree/nodes/operators/fractionNode");
+const shuffle_1 = require("../../utils/shuffle");
+const getTrigonometry = () => {
+    const vertices = [];
+    const code = 65 + (0, randint_1.randint)(0, 24); // Générer un code de caractère majuscule aléatoire (A-Z)
+    for (let i = 0; i < 3; i++)
+        vertices.push(String.fromCharCode(code + i));
+    const triangle = triangles_1.TriangleConstructor.createRandomRightTriangle({
+        minRapport: 0.7,
+        maxRapport: 1.3,
+        names: vertices,
+    });
+    const sideA = triangle.getSideAName();
+    const sideB = triangle.getSideBName();
+    const sideC = triangle.getSideCName();
+    const trigo = ["le cosinus", "le sinus", "la tangente"];
+    const randTrigo = (0, randint_1.randint)(0, 3);
+    const angle = [triangle.vertexB.name, triangle.vertexC.name];
+    const randAngle = (0, randint_1.randint)(0, 2);
+    let quotient;
+    switch (randAngle) {
+        case 0:
+            quotient = [
+                `\\frac{${sideC}}{${sideA}}`,
+                `\\frac{${sideB}}{${sideA}}`,
+                `\\frac{${sideB}}{${sideC}}`,
+            ];
+            break;
+        case 1:
+            quotient = [
+                `\\frac{${sideB}}{${sideA}}`,
+                `\\frac{${sideC}}{${sideA}}`,
+                `\\frac{${sideC}}{${sideB}}`,
+            ];
+            break;
+        default:
+            quotient = [""];
+    }
+    const ggb = new geogebraConstructor_1.GeogebraConstructor(triangle.generateCommands({ highlightedAngle: angle[randAngle] }), {
+        hideAxes: true,
+        hideGrid: true,
+    });
+    const answer = quotient[randTrigo];
+    const question = {
+        instruction: `À quel quotient est égal ${trigo[randTrigo]} de l'angle $\\widehat{${angle[randAngle]}}$?`,
+        answer,
+        keys: [...vertices, "equal"],
+        commands: ggb.commands,
+        options: ggb.getOptions(),
+        coords: triangle.generateCoords(),
+        answerFormat: "tex",
+        identifiers: { sideA, sideB, sideC, randAngle, randTrigo },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, sideA, sideB, sideC }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    const wrongQuotients = [
+        `\\frac{${sideC}}{${sideA}}`,
+        `\\frac{${sideB}}{${sideA}}`,
+        `\\frac{${sideB}}{${sideC}}`,
+        `\\frac{${sideB}}{${sideA}}`,
+        `\\frac{${sideC}}{${sideA}}`,
+        `\\frac{${sideC}}{${sideB}}`,
+        `\\frac{${sideA}}{${sideC}}`,
+        `\\frac{${sideA}}{${sideB}}`,
+        `\\frac{${sideC}}{${sideB}}`,
+        `\\frac{${sideA}}{${sideB}}`,
+        `\\frac{${sideA}}{${sideC}}`,
+        `\\frac{${sideB}}{${sideC}}`,
+    ];
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, wrongQuotients[(0, randint_1.randint)(0, 12)]);
+    }
+    return (0, shuffle_1.shuffle)(propositions);
+};
+const isAnswerValid = (ans, { randAngle, randTrigo, sideA, sideB, sideC }) => {
+    let quotients = [];
+    if (randAngle === 0)
+        quotients = [
+            [sideC, sideA],
+            [sideB, sideA],
+            [sideB, sideC],
+        ];
+    else
+        quotients = [
+            [sideB, sideA],
+            [sideC, sideA],
+            [sideC, sideB],
+        ];
+    const quotient = quotients[randTrigo];
+    const answer = new fractionNode_1.FractionNode(new lengthNode_1.LengthNode(quotient[0]), new lengthNode_1.LengthNode(quotient[1]));
+    const texs = answer.toAllValidTexs();
+    return texs.includes(ans);
+};
+exports.trigonometry = {
+    id: "trigonometry",
+    connector: "=",
+    label: "Écrire le quotient égal au cosinus, au sinus ou à la tangente d'un angle dans un triangle rectangle",
+    levels: ["4ème", "3ème", "2nde"],
+    isSingleStep: false,
+    sections: ["Trigonométrie", "Géométrie euclidienne"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getTrigonometry, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    hasGeogebra: true,
+};

package/lib/exercises/trigonometry/trigonometryAngleCalcul.d.ts

@@ -0,0 +1,9 @@
+import { MathExercise } from "../../exercises/exercise";
+type Identifiers = {
+    sideLengths: number[];
+    randAngle: number;
+    randSides: number[];
+};
+export declare const trigonometryAngleCalcul: MathExercise<Identifiers>;
+export {};
+//# sourceMappingURL=trigonometryAngleCalcul.d.ts.map

package/lib/exercises/trigonometry/trigonometryAngleCalcul.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trigonometryAngleCalcul.d.ts","sourceRoot":"","sources":["../../../src/exercises/trigonometry/trigonometryAngleCalcul.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AAUlC,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,EAAE,CAAC;CACrB,CAAC;AA8EF,eAAO,MAAM,uBAAuB,EAAE,YAAY,CAAC,WAAW,CAc7D,CAAC"}

package/lib/exercises/trigonometry/trigonometryAngleCalcul.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trigonometryAngleCalcul = void 0;
+const exercise_1 = require("../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../exercises/utils/getDistinctQuestions");
+const geogebraConstructor_1 = require("../../geogebra/geogebraConstructor");
+const triangles_1 = require("../../math/geometry/triangles");
+const randint_1 = require("../../math/utils/random/randint");
+const round_1 = require("../../math/utils/round");
+const shuffle_1 = require("../../utils/shuffle");
+const getTrigonometryAngleCalcul = () => {
+    const vertices = [];
+    const code = 65 + (0, randint_1.randint)(0, 24); // Générer un code de caractère majuscule aléatoire (A-Z)
+    for (let i = 0; i < 3; i++)
+        vertices.push(String.fromCharCode(code + i));
+    const triangle = triangles_1.TriangleConstructor.createRandomRightTriangle({
+        minRapport: 0.5,
+        maxRapport: 1.5,
+        names: vertices,
+    });
+    const sides = [
+        triangle.getSideCName(),
+        triangle.getSideBName(),
+        triangle.getSideAName(),
+    ];
+    const sideLengths = [
+        triangle.getSideCnumber(),
+        triangle.getSideBnumber(),
+        triangle.getSideAnumber(),
+    ].map((el) => (0, round_1.round)(el / 2, 2));
+    const angle = [triangle.vertexB.name, triangle.vertexC.name];
+    const randAngle = (0, randint_1.randint)(0, 2);
+    const randSides = (0, shuffle_1.shuffle)([0, 1, 2]);
+    const answer = randAngle === 0
+        ? Math.round((Math.acos(sideLengths[0] / sideLengths[2]) * 180) / Math.PI)
+        : Math.round((Math.acos(sideLengths[1] / sideLengths[2]) * 180) / Math.PI);
+    const answerTex = answer + "^{\\circ}";
+    const ggb = new geogebraConstructor_1.GeogebraConstructor(triangle.generateCommands({ highlightedAngle: angle[randAngle] }), {
+        hideAxes: true,
+        hideGrid: true,
+    });
+    const question = {
+        instruction: `Le triangle $${triangle.getTriangleName()}$ rectangle en $${triangle.getRightAngle()}$ est tel que $${sides[randSides[0]]} = ${(sideLengths[randSides[0]] + "").replace(".", ",")}$ cm et $${sides[randSides[1]]} = ${(sideLengths[randSides[1]] + "").replace(".", ",")}$ cm. Calculer $\\widehat{${angle[randAngle]}}$ à $1^\\circ$ près.`,
+        answer: answerTex,
+        keys: ["degree"],
+        commands: ggb.commands,
+        options: ggb.getOptions(),
+        coords: triangle.generateCoords(),
+        answerFormat: "tex",
+        identifiers: { randAngle, sideLengths, randSides },
+    };
+    return question;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, (0, randint_1.randint)(20, 80) + "°");
+    }
+    return (0, shuffle_1.shuffle)(propositions);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return [answer, answer.split("^")[0]].includes(ans);
+};
+exports.trigonometryAngleCalcul = {
+    id: "trigonometryAngleCalcul",
+    connector: "=",
+    label: "Utiliser la trigonométrie pour calculer un angle",
+    levels: ["4ème", "3ème", "2nde"],
+    isSingleStep: false,
+    sections: ["Trigonométrie", "Géométrie euclidienne"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getTrigonometryAngleCalcul, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    hasGeogebra: true,
+};

package/lib/exercises/trigonometry/trigonometrySideCalcul.d.ts

@@ -0,0 +1,10 @@
+import { MathExercise } from "../../exercises/exercise";
+type Identifiers = {
+    sideLengths: number[];
+    randAngle: number;
+    randSide: number;
+    randSideQuestion: number;
+};
+export declare const trigonometrySideCalcul: MathExercise<Identifiers>;
+export {};
+//# sourceMappingURL=trigonometrySideCalcul.d.ts.map

package/lib/exercises/trigonometry/trigonometrySideCalcul.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trigonometrySideCalcul.d.ts","sourceRoot":"","sources":["../../../src/exercises/trigonometry/trigonometrySideCalcul.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AASlC,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,gBAAgB,EAAE,MAAM,CAAC;CAC1B,CAAC;AA4FF,eAAO,MAAM,sBAAsB,EAAE,YAAY,CAAC,WAAW,CAc5D,CAAC"}

package/lib/exercises/trigonometry/trigonometrySideCalcul.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trigonometrySideCalcul = void 0;
+const exercise_1 = require("../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../exercises/utils/getDistinctQuestions");
+const geogebraConstructor_1 = require("../../geogebra/geogebraConstructor");
+const triangles_1 = require("../../math/geometry/triangles");
+const randint_1 = require("../../math/utils/random/randint");
+const round_1 = require("../../math/utils/round");
+const numberNode_1 = require("../../tree/nodes/numbers/numberNode");
+const shuffle_1 = require("../../utils/shuffle");
+const getTrigonometrySideCalcul = () => {
+    const vertices = [];
+    const code = 65 + (0, randint_1.randint)(0, 24); // Générer un code de caractère majuscule aléatoire (A-Z)
+    for (let i = 0; i < 3; i++)
+        vertices.push(String.fromCharCode(code + i));
+    const triangle = triangles_1.TriangleConstructor.createRandomRightTriangle({
+        minRapport: 0.5,
+        maxRapport: 1.5,
+        names: vertices,
+    });
+    const sides = [
+        triangle.getSideCName(),
+        triangle.getSideBName(),
+        triangle.getSideAName(),
+    ];
+    const sideLengths = [
+        triangle.getSideCnumber(),
+        triangle.getSideBnumber(),
+        triangle.getSideAnumber(),
+    ].map((el) => (0, round_1.round)(el / 2, 2));
+    const angle = [triangle.vertexB.name, triangle.vertexC.name];
+    const randAngle = (0, randint_1.randint)(0, 2);
+    const randSide = (0, randint_1.randint)(0, 3); // valeurs possible : 0 1 2
+    const randSideQuestion = (0, randint_1.randint)(0, 3, [randSide]); // si rand = 0, valeurs possible 1 2
+    const angleValue = [
+        (0, round_1.round)((Math.acos(sideLengths[0] / sideLengths[2]) * 180) / Math.PI, 1),
+        (0, round_1.round)((Math.acos(sideLengths[1] / sideLengths[2]) * 180) / Math.PI, 1),
+    ];
+    const commands = [
+        ...triangle.generateCommands({
+            highlightedAngle: angle[randAngle],
+            colorHighlightedAngle: "Black",
+            showLabels: [sides[randSideQuestion]],
+            setCaptions: ["?"],
+            highlightedSide: sides[randSideQuestion],
+        }),
+    ];
+    const ggb = new geogebraConstructor_1.GeogebraConstructor(commands, {
+        hideAxes: true,
+        hideGrid: true,
+    });
+    const answer = `${((0, round_1.round)(sideLengths[randSideQuestion], 1) + "").replace(".", ",")}`;
+    const question = {
+        instruction: `Le triangle $${triangle.getTriangleName()}$ rectangle en $${triangle.getRightAngle()}$ est tel que $${sides[randSide]} = ${(sideLengths[randSide] + "").replace(".", ",")}$ cm et $\\widehat{${angle[randAngle]}} = ${(angleValue[randAngle] + "").replace(".", ",")}^\\circ$. Calculer $${sides[randSideQuestion]}$ à $0,1$ cm près.`,
+        answer,
+        keys: [],
+        commands: ggb.commands,
+        options: ggb.getOptions(),
+        coords: triangle.generateCoords(),
+        answerFormat: "tex",
+        identifiers: { randAngle, randSide, randSideQuestion, sideLengths },
+    };
+    return question;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, `${((0, round_1.round)((0, randint_1.randint)(11, 100) / 10, 1) + "").replace(".", ",")}`);
+    }
+    return (0, shuffle_1.shuffle)(propositions);
+};
+const isAnswerValid = (ans, { answer }) => {
+    const answerTree = new numberNode_1.NumberNode(Number(answer.replace(",", ".")));
+    const texs = answerTree.toAllValidTexs();
+    return texs.includes(ans);
+};
+exports.trigonometrySideCalcul = {
+    id: "trigonometrySideCalcul",
+    connector: "=",
+    label: "Utiliser la trigonométrie pour calculer un côté",
+    levels: ["4ème", "3ème", "2nde"],
+    isSingleStep: false,
+    sections: ["Trigonométrie", "Géométrie euclidienne"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getTrigonometrySideCalcul, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    hasGeogebra: true,
+};

package/lib/exercises/utils/geogebra/getPointFromGGB.d.ts

@@ -0,0 +1,3 @@
+import { Point } from "../../../math/geometry/point";
+export declare function getPointFromGGB(command: string, name: string, isInteger?: boolean): Point;
+//# sourceMappingURL=getPointFromGGB.d.ts.map

package/lib/exercises/utils/geogebra/getPointFromGGB.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getPointFromGGB.d.ts","sourceRoot":"","sources":["../../../../src/exercises/utils/geogebra/getPointFromGGB.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,2BAA2B,CAAC;AAElD,wBAAgB,eAAe,CAC7B,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,EACZ,SAAS,GAAE,OAAc,GACxB,KAAK,CASP"}

package/lib/exercises/utils/geogebra/getPointFromGGB.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPointFromGGB = void 0;
+const point_1 = require("../../../math/geometry/point");
+function getPointFromGGB(command, name, isInteger = true) {
+    const splitted = command.split(";");
+    const x = isInteger
+        ? +(+splitted[0].replace("(", "")).toFixed(0)
+        : +splitted[0].replace("(", "");
+    const y = isInteger
+        ? +(+splitted[1].replace(")", "")).toFixed(0)
+        : +splitted[1].replace(")", "");
+    return new point_1.Point(name, x.toTree(), y.toTree());
+}
+exports.getPointFromGGB = getPointFromGGB;

package/lib/exercises/utils/geogebra/getVectorFromGGB.d.ts

@@ -0,0 +1,3 @@
+import { Vector } from "../../../math/geometry/vector";
+export declare function getVectorFromGGB(command: string, name: string): Vector;
+//# sourceMappingURL=getVectorFromGGB.d.ts.map

package/lib/exercises/utils/geogebra/getVectorFromGGB.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getVectorFromGGB.d.ts","sourceRoot":"","sources":["../../../../src/exercises/utils/geogebra/getVectorFromGGB.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,4BAA4B,CAAC;AAEpD,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAKtE"}

package/lib/exercises/utils/geogebra/getVectorFromGGB.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getVectorFromGGB = void 0;
+const vector_1 = require("../../../math/geometry/vector");
+function getVectorFromGGB(command, name) {
+    const splitted = command.split(";");
+    const x = +splitted[0].replace("(", "");
+    const y = +splitted[1].replace(")", "");
+    return new vector_1.Vector(name, x.toTree(), y.toTree());
+}
+exports.getVectorFromGGB = getVectorFromGGB;

package/lib/exercises/utils/geogebra/isGGBLine.d.ts

@@ -0,0 +1,2 @@
+export declare function isGGBLine(command: string): boolean;
+//# sourceMappingURL=isGGBLine.d.ts.map

package/lib/exercises/utils/geogebra/isGGBLine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isGGBLine.d.ts","sourceRoot":"","sources":["../../../../src/exercises/utils/geogebra/isGGBLine.ts"],"names":[],"mappings":"AAAA,wBAAgB,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAGlD"}

package/lib/exercises/utils/geogebra/isGGBLine.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isGGBLine = void 0;
+function isGGBLine(command) {
+    const regex = /Line\([A-Z],\s[A-Z]\)/;
+    return regex.test(command);
+}
+exports.isGGBLine = isGGBLine;

package/lib/exercises/utils/geogebra/isGGBPoint.d.ts

@@ -0,0 +1,2 @@
+export declare function isGGBPoint(command: string): boolean;
+//# sourceMappingURL=isGGBPoint.d.ts.map

package/lib/exercises/utils/geogebra/isGGBPoint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isGGBPoint.d.ts","sourceRoot":"","sources":["../../../../src/exercises/utils/geogebra/isGGBPoint.ts"],"names":[],"mappings":"AAAA,wBAAgB,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAGnD"}

package/lib/exercises/utils/geogebra/isGGBPoint.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isGGBPoint = void 0;
+function isGGBPoint(command) {
+    const regex = /\(-?\d+(\.\d+)?;-?\d+(\.\d+)?\)/;
+    return regex.test(command);
+}
+exports.isGGBPoint = isGGBPoint;

package/lib/exercises/utils/geogebra/toolBarConstructor.d.ts

@@ -0,0 +1,9 @@
+export declare const toolBarConstructor: (options: {
+    point?: boolean;
+    join?: boolean;
+    parallel?: boolean;
+    orthogonal?: boolean;
+    intersect?: boolean;
+    vector?: boolean;
+}) => string;
+//# sourceMappingURL=toolBarConstructor.d.ts.map

package/lib/exercises/utils/geogebra/toolBarConstructor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toolBarConstructor.d.ts","sourceRoot":"","sources":["../../../../src/exercises/utils/geogebra/toolBarConstructor.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,kBAAkB,YAAa;IAC1C,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB,WASA,CAAC"}

package/lib/exercises/utils/geogebra/toolBarConstructor.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toolBarConstructor = void 0;
+const toolBarConstructor = (options) => {
+    let customToolBar = "0||6";
+    if (options.point)
+        customToolBar += "||1";
+    if (options.join)
+        customToolBar += "||2";
+    if (options.parallel)
+        customToolBar += "||3";
+    if (options.orthogonal)
+        customToolBar += "||4";
+    if (options.intersect)
+        customToolBar += "||5";
+    if (options.vector)
+        customToolBar += "||7";
+    return customToolBar;
+};
+exports.toolBarConstructor = toolBarConstructor;

package/lib/index.d.ts

@@ -782,6 +782,9 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
     xValue: number;
     yValue: number;
 }> | import("./exercises/exercise").Exercise<{
+    correctA: number;
+    correctB: number;
+}> | import("./exercises/exercise").Exercise<{}> | import("./exercises/exercise").Exercise<{
     coin: boolean;
     radius: number;
     diametre: number;
@@ -889,7 +892,7 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
     uY: number;
     aX: number;
     aY: number;
-}> | import("./exercises/exercise").Exercise<{
+}> | import("./exercises/exercise").Exercise<{}> | import("./exercises/exercise").Exercise<{
     trinom: number[];
 }> | import("./exercises/exercise").Exercise<{
     askConvex: boolean;
@@ -1611,6 +1614,9 @@ declare const pcExercises: (import("./exercises/exercise").Exercise<{
 }> | import("./exercises/exercise").Exercise<{
     power: number;
     seconds: number;
+}> | import("./exercises/exercise").Exercise<{
+    epsilon: number;
+    l: number;
 }>)[];
 export { mathExercises, pcExercises };
 //# sourceMappingURL=index.d.ts.map

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAG3D,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;CACF;AAcD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+BE;AAEF,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAjCnB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA+BE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA/BF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA+BE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAEgD,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAG3D,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;CACF;AAcD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+BE;AAEF,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAjCnB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA+BE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA/BF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA+BE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAEgD,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,CAAC"}

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

@@ -0,0 +1,20 @@
+import { Node } from '../../tree/nodes/node';
+import { Point } from './point';
+export declare abstract class DroiteConstructor {
+    static fromTwoPoints(A: Point, B: Point, name?: string): Droite;
+    static fromPointAndSlope(A: Point, m: Node, name?: string): Droite;
+    static fromPointAndAngle(A: Point, theta: Node, name?: string): Droite;
+}
+export declare class Droite {
+    name: string;
+    a: Node;
+    b: Node;
+    constructor(name: string | undefined, a: Node, b: Node);
+    toTex(): string;
+    toEquationForm(): string;
+    toEquationExpression(): string;
+    toPolynome(): string;
+    getLeadingCoefficient(): string;
+    intersection(D: Droite, name?: string): Point | void;
+}
+//# sourceMappingURL=droite.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"droite.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/droite.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,uBAAuB,CAAC;AAQ7C,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAIhC,8BAAsB,iBAAiB;IACrC,MAAM,CAAC,aAAa,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,IAAI,SAAM,GAAG,MAAM;IAM5D,MAAM,CAAC,iBAAiB,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,IAAI,EAAE,IAAI,SAAM,GAAG,MAAM;IAI/D,MAAM,CAAC,iBAAiB,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,SAAM,GAAG,MAAM;CAKpE;AAED,qBAAa,MAAM;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,IAAI,CAAC;IACR,CAAC,EAAE,IAAI,CAAC;gBAEI,IAAI,oBAAM,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI;IAOxC,KAAK,IAAI,MAAM;IAIf,cAAc,IAAI,MAAM;IAIxB,oBAAoB,IAAI,MAAM;IAI9B,UAAU,IAAI,MAAM;IAKpB,qBAAqB,IAAI,MAAM;IAI/B,YAAY,CAAC,CAAC,EAAE,MAAM,EAAE,IAAI,SAAM,GAAG,KAAK,GAAG,IAAI;CAMlD"}