math-exercises 2.2.69 → 2.2.70

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

@@ -1 +1 @@
-{"version":3,"file":"trigonometryAngleCalcul.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/trigonometry/trigonometryAngleCalcul.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,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;AA4EF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAezD,CAAC"}
+{"version":3,"file":"trigonometryAngleCalcul.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/trigonometry/trigonometryAngleCalcul.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,0BAA0B,CAAC;AAIlC,OAAO,EAEL,mBAAmB,EACpB,MAAM,8BAA8B,CAAC;AAOtC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,mBAAmB,EAAE,mBAAmB,CAAC;CAC1C,CAAC;AAyDF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAezD,CAAC"}

package/lib/exercises/math/trigonometry/trigonometryAngleCalcul.js

@@ -4,51 +4,41 @@ exports.trigonometryAngleCalcul = void 0;
 const exercise_1 = require("../../../exercises/exercise");
 const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
 const geogebraConstructor_1 = require("../../../geogebra/geogebraConstructor");
-const triangle_1 = require("../../../math/geometry/triangle");
+const rightTriangle_1 = require("../../../math/geometry/rightTriangle");
 const randint_1 = require("../../../math/utils/random/randint");
 const round_1 = require("../../../math/utils/round");
 const shuffle_1 = require("../../../utils/alea/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 = triangle_1.TriangleConstructor.createRandomRightTriangle({
-        minRapport: 0.5,
-        maxRapport: 1.5,
-        names: vertices,
+    const triangle = rightTriangle_1.RightTriangleConstructor.randomNiceSides({
+        randomName: true,
     });
-    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 randAngle = (0, randint_1.randint)(1, 3);
+    const hiddenSide = (0, randint_1.randint)(0, 3);
+    const givenSides = triangle.sides.filter((s, i) => i !== hiddenSide);
+    triangle.showSidesLength([hiddenSide]);
+    triangle.highlightAngle(randAngle, { color: "red" });
+    const answer = (0, round_1.round)(triangle.angles[randAngle].evaluate(), 0);
     const answerTex = answer + "^{\\circ}";
     const ggb = new geogebraConstructor_1.GeogebraConstructor({
-        commands: triangle.generateCommands({ highlightedAngle: angle[randAngle] }),
+        commands: triangle.commands,
         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.`,
+        instruction: `Le triangle $${triangle.name}$ rectangle en $${triangle.points[0].name}$ est tel que $${givenSides[0].toLengthTex()}$ cm et $${givenSides[1].toLengthTex()}$ cm. 
+    
+Calculer $\\widehat{${triangle.points[randAngle].name}}$ à $1^\\circ$ près.`,
         answer: answerTex,
         keys: ["degree"],
         ggbOptions: ggb.getOptions({
             coords: triangle.generateCoords(),
         }),
         answerFormat: "tex",
-        identifiers: { randAngle, sideLengths, randSides },
+        identifiers: {
+            randAngle,
+            hiddenSide,
+            triangleIdentifiers: triangle.toIdentifiers(),
+        },
     };
     return question;
 };

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

@@ -1,9 +1,10 @@
 import { Exercise } from "../../../exercises/exercise";
+import { TriangleIdentifiers } from "../../../math/geometry/triangle";
 type Identifiers = {
-    sideLengths: number[];
-    randAngle: number;
-    randSide: number;
-    randSideQuestion: number;
+    sideAsked: number;
+    givenSide: number;
+    givenAngle: number;
+    triangleIdentifiers: TriangleIdentifiers;
 };
 export declare const trigonometrySideCalcul: Exercise<Identifiers>;
 export {};

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

@@ -1 +1 @@
-{"version":3,"file":"trigonometrySideCalcul.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/trigonometry/trigonometrySideCalcul.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,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;AAwMF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAgBxD,CAAC"}
+{"version":3,"file":"trigonometrySideCalcul.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/trigonometry/trigonometrySideCalcul.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,0BAA0B,CAAC;AAQlC,OAAO,EAEL,mBAAmB,EACpB,MAAM,8BAA8B,CAAC;AAMtC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,mBAAmB,EAAE,mBAAmB,CAAC;CAC1C,CAAC;AA4KF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAexD,CAAC"}

package/lib/exercises/math/trigonometry/trigonometrySideCalcul.js

@@ -3,66 +3,50 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.trigonometrySideCalcul = void 0;
 const exercise_1 = require("../../../exercises/exercise");
 const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const colors_1 = require("../../../geogebra/colors");
 const geogebraConstructor_1 = require("../../../geogebra/geogebraConstructor");
-const triangle_1 = require("../../../math/geometry/triangle");
+const rightTriangle_1 = require("../../../math/geometry/rightTriangle");
 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/alea/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 = triangle_1.TriangleConstructor.createRandomRightTriangle({
-        minRapport: 0.5,
-        maxRapport: 1.5,
-        names: vertices,
+    const givenAngle = (0, randint_1.randint)(1, 3);
+    const givenSide = (0, randint_1.randint)(0, 3);
+    const sideAsked = (0, randint_1.randint)(0, 3, [givenSide]);
+    const triangle = rightTriangle_1.RightTriangleConstructor.randomNiceAngles({
+        randomName: true,
+        niceSideIndex: givenSide,
     });
-    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],
-        }),
-    ];
+    triangle.showSidesLength([0, 1, 2].filter((i) => i !== givenSide));
+    triangle.highlightAngle(givenAngle, { color: colors_1.greenDark, showValue: true });
+    triangle.highlightSide(sideAsked, { color: "red", caption: "?" });
+    const angleValue = triangle.angles[givenAngle].evaluate().frenchify();
     const ggb = new geogebraConstructor_1.GeogebraConstructor({
-        commands,
+        commands: triangle.commands,
         hideAxes: true,
         hideGrid: true,
     });
-    const answer = `${((0, round_1.round)(sideLengths[randSideQuestion], 1) + "").replace(".", ",")}`;
+    const answer = (0, round_1.round)(triangle.sides[sideAsked].getLength(), 1).frenchify();
+    const identifiers = {
+        givenAngle,
+        givenSide,
+        sideAsked,
+        triangleIdentifiers: triangle.toIdentifiers(),
+    };
     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.`,
+        instruction: `Le triangle $${triangle.name}$ rectangle en $${triangle.points[0].name}$ est tel que $${triangle.sides[givenSide].toLengthTex()}$ cm et $\\widehat{${triangle.points[givenAngle].name}} = ${angleValue}^\\circ$. 
+    
+Calculer $${triangle.sides[sideAsked].toInsideName()}$ à $0,1$ cm près.`,
         answer,
-        hint: getHint(),
-        correction: getCorrection(sides, sideLengths, randSideQuestion, randSide, angle[randAngle], angleValue[randAngle], answer),
+        // hint: getHint(identifiers),
+        // correction: getCorrection(identifiers),
         keys: [],
         ggbOptions: ggb.getOptions({
             coords: triangle.generateCoords(),
         }),
         answerFormat: "tex",
-        identifiers: { randAngle, randSide, randSideQuestion, sideLengths },
+        identifiers,
     };
     return question;
 };
@@ -74,21 +58,42 @@ const getPropositions = (n, { answer }) => {
     }
     return (0, shuffle_1.shuffle)(propositions);
 };
-const getHint = () => {
+const getHint = (identifiers) => {
     return `Identifier le côté opposé, le côté adjacent et l'hypoténuse, puis utiliser la bonne formule de trigonométrie.`;
 };
-const getCorrection = (sides, sideLengths, randSideQuestion, randSide, angle, angleValue, answer) => {
-    const hypothenus = { name: sides[2], length: sideLengths[2] };
-    const sidesWithLentgh = sides.map((value, index) => {
-        return { name: value, length: sideLengths[index] };
-    });
-    const adjacent = sidesWithLentgh.filter((value) => value.name !== hypothenus.name &&
-        [value.name.charAt(0), value.name.charAt(1)].includes(angle))[0];
-    const opposite = sidesWithLentgh.filter((value) => value.name !== hypothenus.name && value.name !== adjacent.name)[0];
-    const correctEquations = getCorrectEquations({ name: sides[randSideQuestion], length: sideLengths[randSideQuestion] }, { name: sides[randSide], length: sideLengths[randSide] }, hypothenus, { name: angle, value: angleValue }, adjacent, opposite, answer);
-    return `On utilise la relation $${correctEquations[0]}$, on a donc :
-    $${correctEquations[1]}$, donc $${correctEquations[2]}$. Ainsi $${correctEquations[3]}$ `;
-};
+// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {
+//   const hypothenus = { name: sides[2], length: sideLengths[2] };
+//   const sidesWithLentgh = sides.map((value, index) => {
+//     return { name: value, length: sideLengths[index] };
+//   });
+//   const adjacent = sidesWithLentgh.filter(
+//     (value) =>
+//       value.name !== hypothenus.name &&
+//       [value.name.charAt(0), value.name.charAt(1)].includes(angle),
+//   )[0];
+//   const opposite = sidesWithLentgh.filter(
+//     (value) => value.name !== hypothenus.name && value.name !== adjacent.name,
+//   )[0];
+//   const correctEquations = getCorrectEquations(
+//     { name: sides[randSideQuestion], length: sideLengths[randSideQuestion] },
+//     { name: sides[randSide], length: sideLengths[randSide] },
+//     hypothenus,
+//     { name: angle, value: angleValue },
+//     adjacent,
+//     opposite,
+//     answer,
+//   );
+//   return `On utilise la relation :
+// $$
+// ${correctEquations[0]}
+// $$
+// On a donc :
+// $$
+// ${correctEquations[1]}
+// $$
+// donc
+// $$${correctEquations[2]}$$. Ainsi $${correctEquations[3]}$ `;
+// };
 const getCorrectEquations = (randSideQuestion, randSide, hypothenus, angle, adjacent, opposite, answer) => {
     let result;
     switch (randSideQuestion.name) {
@@ -157,5 +162,4 @@ exports.trigonometrySideCalcul = {
     isAnswerValid,
     hasGeogebra: true,
     subject: "Mathématiques",
-    hasHintAndCorrection: true,
 };

package/lib/exercises/pc/index.d.ts

@@ -47,8 +47,6 @@ export * from "../math/geometry/vectors/scalarProduct/scalarProductViaCoords";
 export * from "../math/geometry/vectors/scalarProduct/scalarProductViaCos";
 export * from "../math/geometry/vectors/coordinatesReading";
 export * from "../math/functions/affines/affineExpressionReading";
-export * from "../math/geometry/thales/thales";
-export * from "../math/geometry/thales/thalesCalcul";
 export * from "../math/equaDiff/equaDiffCheckSolutionFirstOrder";
 export * from "../math/equaDiff/equaDiffGeneralForme";
 export * from "../math/equaDiff/equaDiffGeneralFormeWithIC";
@@ -57,6 +55,4 @@ export * from "../math/derivation/derivative/usualderivative";
 export { thirdDegreeDerivative } from "../math/derivation/derivative/thirdDegreeDerivative";
 export { firstDegreeDerivative } from "../math/derivation/derivative/firstDegreeDerivative";
 export { secondDegreeDerivative } from "../math/derivation/derivative/secondDegreeDerivative";
-export * from "../math/trigonometry/trigonometrySideCalcul";
-export * from "../math/trigonometry/trigonometryAngleCalcul";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/pc/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/exercises/pc/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,YAAY,CAAC;AAC3B,cAAc,0BAA0B,CAAC;AACzC,cAAc,iBAAiB,CAAC;AAChC,cAAc,iBAAiB,CAAC;AAChC,cAAc,mBAAmB,CAAC;AAClC,cAAc,wBAAwB,CAAC;AACvC,cAAc,MAAM,CAAC;AACrB,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,kBAAkB,CAAC;AACjC,cAAc,SAAS,CAAC;AACxB,cAAc,QAAQ,CAAC;AACvB,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,SAAS,CAAC;AACxB,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC;AACpC,cAAc,QAAQ,CAAC;AACvB,cAAc,kBAAkB,CAAC;AACjC,cAAc,UAAU,CAAC;AACzB,cAAc,eAAe,CAAC;AAC9B,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,8BAA8B,CAAC;AAC7C,cAAc,UAAU,CAAC;AACzB,cAAc,YAAY,CAAC;AAC3B,cAAc,gCAAgC,CAAC;AAC/C,cAAc,yCAAyC,CAAC;AACxD,cAAc,oBAAoB,CAAC;AACnC,cAAc,SAAS,CAAC;AAExB,yBAAyB;AACzB,cAAc,gCAAgC,CAAC;AAC/C,cAAc,qDAAqD,CAAC;AACpE,OAAO,EAAE,mBAAmB,EAAE,MAAM,+BAA+B,CAAC;AACpE,cAAc,oCAAoC,CAAC;AACnD,cAAc,6CAA6C,CAAC;AAC5D,OAAO,EAAE,qBAAqB,EAAE,MAAM,mDAAmD,CAAC;AAC1F,OAAO,EAAE,mBAAmB,EAAE,MAAM,8CAA8C,CAAC;AACnF,OAAO,EAAE,kBAAkB,EAAE,MAAM,8CAA8C,CAAC;AAClF,cAAc,uDAAuD,CAAC;AACtE,cAAc,uDAAuD,CAAC;AACtE,cAAc,uDAAuD,CAAC;AACtE,cAAc,uDAAuD,CAAC;AACtE,cAAc,+DAA+D,CAAC;AAC9E,cAAc,4DAA4D,CAAC;AAC3E,cAAc,6CAA6C,CAAC;AAC5D,cAAc,mDAAmD,CAAC;AAClE,cAAc,gCAAgC,CAAC;AAC/C,cAAc,sCAAsC,CAAC;AACrD,cAAc,kDAAkD,CAAC;AACjE,cAAc,uCAAuC,CAAC;AACtD,cAAc,6CAA6C,CAAC;AAC5D,cAAc,oDAAoD,CAAC;AACnE,cAAc,+CAA+C,CAAC;AAC9D,OAAO,EAAE,qBAAqB,EAAE,MAAM,qDAAqD,CAAC;AAC5F,OAAO,EAAE,qBAAqB,EAAE,MAAM,qDAAqD,CAAC;AAC5F,OAAO,EAAE,sBAAsB,EAAE,MAAM,sDAAsD,CAAC;AAC9F,cAAc,6CAA6C,CAAC;AAC5D,cAAc,8CAA8C,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/exercises/pc/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,YAAY,CAAC;AAC3B,cAAc,0BAA0B,CAAC;AACzC,cAAc,iBAAiB,CAAC;AAChC,cAAc,iBAAiB,CAAC;AAChC,cAAc,mBAAmB,CAAC;AAClC,cAAc,wBAAwB,CAAC;AACvC,cAAc,MAAM,CAAC;AACrB,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,kBAAkB,CAAC;AACjC,cAAc,SAAS,CAAC;AACxB,cAAc,QAAQ,CAAC;AACvB,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,SAAS,CAAC;AACxB,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC;AACpC,cAAc,QAAQ,CAAC;AACvB,cAAc,kBAAkB,CAAC;AACjC,cAAc,UAAU,CAAC;AACzB,cAAc,eAAe,CAAC;AAC9B,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,8BAA8B,CAAC;AAC7C,cAAc,UAAU,CAAC;AACzB,cAAc,YAAY,CAAC;AAC3B,cAAc,gCAAgC,CAAC;AAC/C,cAAc,yCAAyC,CAAC;AACxD,cAAc,oBAAoB,CAAC;AACnC,cAAc,SAAS,CAAC;AAExB,yBAAyB;AACzB,cAAc,gCAAgC,CAAC;AAC/C,cAAc,qDAAqD,CAAC;AACpE,OAAO,EAAE,mBAAmB,EAAE,MAAM,+BAA+B,CAAC;AACpE,cAAc,oCAAoC,CAAC;AACnD,cAAc,6CAA6C,CAAC;AAC5D,OAAO,EAAE,qBAAqB,EAAE,MAAM,mDAAmD,CAAC;AAC1F,OAAO,EAAE,mBAAmB,EAAE,MAAM,8CAA8C,CAAC;AACnF,OAAO,EAAE,kBAAkB,EAAE,MAAM,8CAA8C,CAAC;AAClF,cAAc,uDAAuD,CAAC;AACtE,cAAc,uDAAuD,CAAC;AACtE,cAAc,uDAAuD,CAAC;AACtE,cAAc,uDAAuD,CAAC;AACtE,cAAc,+DAA+D,CAAC;AAC9E,cAAc,4DAA4D,CAAC;AAC3E,cAAc,6CAA6C,CAAC;AAC5D,cAAc,mDAAmD,CAAC;AAIlE,cAAc,kDAAkD,CAAC;AACjE,cAAc,uCAAuC,CAAC;AACtD,cAAc,6CAA6C,CAAC;AAC5D,cAAc,oDAAoD,CAAC;AACnE,cAAc,+CAA+C,CAAC;AAC9D,OAAO,EAAE,qBAAqB,EAAE,MAAM,qDAAqD,CAAC;AAC5F,OAAO,EAAE,qBAAqB,EAAE,MAAM,qDAAqD,CAAC;AAC5F,OAAO,EAAE,sBAAsB,EAAE,MAAM,sDAAsD,CAAC"}

package/lib/exercises/pc/index.js

@@ -68,8 +68,9 @@ __exportStar(require("../math/geometry/vectors/scalarProduct/scalarProductViaCoo
 __exportStar(require("../math/geometry/vectors/scalarProduct/scalarProductViaCos"), exports);
 __exportStar(require("../math/geometry/vectors/coordinatesReading"), exports);
 __exportStar(require("../math/functions/affines/affineExpressionReading"), exports);
-__exportStar(require("../math/geometry/thales/thales"), exports);
-__exportStar(require("../math/geometry/thales/thalesCalcul"), exports);
+//!FIX TRIANGLE
+// export * from "../math/geometry/thales/thales";
+// export * from "../math/geometry/thales/thalesCalcul";
 __exportStar(require("../math/equaDiff/equaDiffCheckSolutionFirstOrder"), exports);
 __exportStar(require("../math/equaDiff/equaDiffGeneralForme"), exports);
 __exportStar(require("../math/equaDiff/equaDiffGeneralFormeWithIC"), exports);
@@ -81,5 +82,6 @@ var firstDegreeDerivative_1 = require("../math/derivation/derivative/firstDegree
 Object.defineProperty(exports, "firstDegreeDerivative", { enumerable: true, get: function () { return firstDegreeDerivative_1.firstDegreeDerivative; } });
 var secondDegreeDerivative_1 = require("../math/derivation/derivative/secondDegreeDerivative");
 Object.defineProperty(exports, "secondDegreeDerivative", { enumerable: true, get: function () { return secondDegreeDerivative_1.secondDegreeDerivative; } });
-__exportStar(require("../math/trigonometry/trigonometrySideCalcul"), exports);
-__exportStar(require("../math/trigonometry/trigonometryAngleCalcul"), exports);
+// export * from "../math/trigonometry/trigonometrySideCalcul";
+// export * from "../math/trigonometry/trigonometryAngleCalcul";
+//!FIX TRIANGLE

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

@@ -5,5 +5,6 @@ export type ToGGBCommandsProps = {
     style?: number;
     size?: number;
     color?: string;
+    showLength?: boolean;
 };
 //# sourceMappingURL=toGGBCommandsProps.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"toGGBCommandsProps.d.ts","sourceRoot":"","sources":["../../../../src/exercises/utils/geogebra/toGGBCommandsProps.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,kBAAkB,GAAG;IAC/B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,yBAAyB,CAAC,EAAE,OAAO,CAAC;IACpC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC"}
+{"version":3,"file":"toGGBCommandsProps.d.ts","sourceRoot":"","sources":["../../../../src/exercises/utils/geogebra/toGGBCommandsProps.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,kBAAkB,GAAG;IAC/B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,yBAAyB,CAAC,EAAE,OAAO,CAAC;IACpC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB,CAAC"}

package/lib/exercises/vea/equationVEA.d.ts

@@ -0,0 +1,2 @@
+export declare const equationVEA: (ans: string, solutionTex: string) => boolean;
+//# sourceMappingURL=equationVEA.d.ts.map

package/lib/exercises/vea/equationVEA.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"equationVEA.d.ts","sourceRoot":"","sources":["../../../src/exercises/vea/equationVEA.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,WAAW,QAAS,MAAM,eAAe,MAAM,YAa3D,CAAC"}

package/lib/exercises/vea/equationVEA.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.equationVEA = void 0;
+const discreteSetParser_1 = require("../../tree/parsers/discreteSetParser");
+const equationSolutionParser_1 = require("../../tree/parsers/equationSolutionParser");
+const rationalVEA_1 = require("./rationalVEA");
+const equationVEA = (ans, solutionTex) => {
+    try {
+        let parsed = (0, equationSolutionParser_1.equationSolutionParser)(ans);
+        if (parsed) {
+            return (0, rationalVEA_1.rationalVEA)(parsed.toTex(), solutionTex);
+        }
+        else {
+            const setParsed = (0, discreteSetParser_1.discreteSetParser)(ans);
+            if (!setParsed || setParsed.length !== 1)
+                return false;
+            return (0, rationalVEA_1.rationalVEA)(setParsed[0].toTex(), solutionTex);
+        }
+    }
+    catch (err) {
+        return false;
+    }
+};
+exports.equationVEA = equationVEA;

package/lib/exercises/vea/rationalVEA.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rationalVEA.d.ts","sourceRoot":"","sources":["../../../src/exercises/vea/rationalVEA.ts"],"names":[],"mappings":"AAKA,KAAK,IAAI,GAAG;IACV,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B,CAAC;AACF,eAAO,MAAM,WAAW,eACV,MAAM,UACV,MAAM,6DAC4C,IAAI,YAqC/D,CAAC"}
+{"version":3,"file":"rationalVEA.d.ts","sourceRoot":"","sources":["../../../src/exercises/vea/rationalVEA.ts"],"names":[],"mappings":"AAKA,KAAK,IAAI,GAAG;IACV,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B,CAAC;AACF,eAAO,MAAM,WAAW,eACV,MAAM,UACV,MAAM,6DAC4C,IAAI,YAoC/D,CAAC"}

package/lib/exercises/vea/sqrtVEA.d.ts

@@ -0,0 +1,6 @@
+type Opts = {
+    allowNonIrreductible?: boolean;
+};
+export declare const sqrtVEA: (studentAns: string, answer: string, { allowNonIrreductible }?: Opts) => boolean;
+export {};
+//# sourceMappingURL=sqrtVEA.d.ts.map

package/lib/exercises/vea/sqrtVEA.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqrtVEA.d.ts","sourceRoot":"","sources":["../../../src/exercises/vea/sqrtVEA.ts"],"names":[],"mappings":"AAMA,KAAK,IAAI,GAAG;IACV,oBAAoB,CAAC,EAAE,OAAO,CAAC;CAChC,CAAC;AACF,eAAO,MAAM,OAAO,eACN,MAAM,UACV,MAAM,6BACY,IAAI,YAmB/B,CAAC"}

package/lib/exercises/vea/sqrtVEA.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sqrtVEA = void 0;
+const numberNode_1 = require("../../tree/nodes/numbers/numberNode");
+const latexParser_1 = require("../../tree/parsers/latexParser");
+const sqrtParser_1 = require("../../tree/parsers/sqrtParser");
+const sqrtVEA = (studentAns, answer, { allowNonIrreductible } = {
+    allowNonIrreductible: true,
+}) => {
+    try {
+        allowNonIrreductible = allowNonIrreductible ?? true;
+        const parsed = (0, sqrtParser_1.sqrtParser)(studentAns);
+        if (!parsed)
+            return false;
+        const parsedAnswer = (0, latexParser_1.parseAlgebraic)(answer);
+        if ((0, numberNode_1.isNumberNode)(parsed)) {
+            return Math.abs(parsed.evaluate() - parsedAnswer.evaluate()) < 0.0000001;
+        }
+        else if (allowNonIrreductible) {
+            return Math.abs(parsed.evaluate() - parsedAnswer.evaluate()) < 0.0000001;
+        }
+        else {
+            return parsed.equals(parsedAnswer);
+        }
+    }
+    catch (err) {
+        return false;
+    }
+};
+exports.sqrtVEA = sqrtVEA;

package/lib/geogebra/geogebraConstructor.d.ts

@@ -1,4 +1,5 @@
 import { GeogebraAxisOptions, GeogebraOptions } from "../exercises/exercise";
+import { Point } from "../math/geometry/point";
 type GetAdaptedCoords = {
     xMin: number;
     xMax: number;
@@ -25,6 +26,7 @@ export declare class GeogebraConstructor {
     xAxis?: GeogebraAxisOptions;
     yAxis?: GeogebraAxisOptions;
     constructor(options: Omit<GeogebraOptions, "coords">);
+    getCoordsForPoints(points: Point[]): number[];
     getAdaptedCoords({ xMin, xMax, yMin, yMax, zMin, zMax, forceShowAxes, }: GetAdaptedCoords): number[];
     getOptions({ coords }: GetOptionsProps): GeogebraOptions;
 }

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

@@ -1 +1 @@
-{"version":3,"file":"geogebraConstructor.d.ts","sourceRoot":"","sources":["../../src/geogebra/geogebraConstructor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAGhF,KAAK,gBAAgB,GAAG;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB,CAAC;AACF,KAAK,eAAe,GAAG;IACrB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AACF,qBAAa,mBAAmB;IAC9B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,YAAY,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,KAAK,CAAC;IACxC,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,eAAe,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC;IACjC,KAAK,CAAC,EAAE,mBAAmB,CAAC;IAC5B,KAAK,CAAC,EAAE,mBAAmB,CAAC;gBAEhB,OAAO,EAAE,IAAI,CAAC,eAAe,EAAE,QAAQ,CAAC;IAepD,gBAAgB,CAAC,EACf,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,aAAa,GACd,EAAE,gBAAgB;IAyCnB,UAAU,CAAC,EAAE,MAAM,EAAE,EAAE,eAAe,GAAG,eAAe;CAiBzD"}
+{"version":3,"file":"geogebraConstructor.d.ts","sourceRoot":"","sources":["../../src/geogebra/geogebraConstructor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAEhF,OAAO,EAAE,KAAK,EAAE,MAAM,2BAA2B,CAAC;AAElD,KAAK,gBAAgB,GAAG;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB,CAAC;AACF,KAAK,eAAe,GAAG;IACrB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AACF,qBAAa,mBAAmB;IAC9B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,YAAY,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,KAAK,CAAC;IACxC,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,eAAe,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC;IACjC,KAAK,CAAC,EAAE,mBAAmB,CAAC;IAC5B,KAAK,CAAC,EAAE,mBAAmB,CAAC;gBAEhB,OAAO,EAAE,IAAI,CAAC,eAAe,EAAE,QAAQ,CAAC;IAcpD,kBAAkB,CAAC,MAAM,EAAE,KAAK,EAAE;IAOlC,gBAAgB,CAAC,EACf,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,aAAa,GACd,EAAE,gBAAgB;IAyCnB,UAAU,CAAC,EAAE,MAAM,EAAE,EAAE,eAAe,GAAG,eAAe;CAiBzD"}

package/lib/geogebra/geogebraConstructor.js

@@ -17,6 +17,13 @@ class GeogebraConstructor {
         this.xAxis = options?.xAxis;
         this.yAxis = options?.yAxis;
     }
+    getCoordsForPoints(points) {
+        const xMin = Math.min(...points.map((p) => p.x.evaluate()));
+        const xMax = Math.max(...points.map((p) => p.x.evaluate()));
+        const yMin = Math.min(...points.map((p) => p.y.evaluate()));
+        const yMax = Math.max(...points.map((p) => p.y.evaluate()));
+        return this.getAdaptedCoords({ xMin, xMax, yMin, yMax });
+    }
     getAdaptedCoords({ xMin, xMax, yMin, yMax, zMin, zMax, forceShowAxes, }) {
         const showAxes = forceShowAxes ?? (this.hideAxes ? false : true);
         const xDelta = xMax - xMin;

package/lib/index.d.ts

@@ -324,6 +324,9 @@ declare const mathExercises: (Exercise<{
     c: number;
     d: number;
     isSubstract: boolean;
+}, {}> | Exercise<{
+    a: number;
+    b: number;
 }, {}> | Exercise<{
     b: number;
     c: number;
@@ -798,11 +801,11 @@ declare const mathExercises: (Exercise<{
     cIdentifiers: import("./tree/nodes/nodeConstructor").NodeIdentifiers;
     isAsking: string;
 }, {}> | Exercise<{
-    trinomIdentifiers: import("./math/polynomials/generalTrinom").GeneralTrinomIdentifiers;
+    trinomIdentifiers: import("./tree/nodes/polynomials/trinomNode").TrinomNodeIdentifiers;
 }, {}> | Exercise<{
-    trinomIdentifiers: import("./math/polynomials/generalTrinom").GeneralTrinomIdentifiers;
+    trinomIdentifiers: import("./tree/nodes/polynomials/trinomNode").TrinomNodeIdentifiers;
 }, {}> | Exercise<{
-    trinomIdentifiers: import("./math/polynomials/generalTrinom").GeneralTrinomIdentifiers;
+    trinomIdentifiers: import("./tree/nodes/polynomials/trinomNode").TrinomNodeIdentifiers;
     firstRootIdentifiers: import("./tree/nodes/nodeConstructor").NodeIdentifiers;
 }, {}> | Exercise<{
     a: number;
@@ -893,10 +896,14 @@ declare const mathExercises: (Exercise<{
     length: number;
     width: number;
 }, {}> | Exercise<{
-    sidesLengths: number[];
+    triangleIdentifiers: import("./math/geometry/triangle").TriangleIdentifiers;
 }, {}> | Exercise<{
     side: number;
-}, {}> | Exercise<{}, {}> | Exercise<{
+}, {}> | Exercise<{
+    triangleIdentifiers: import("./math/geometry/triangle").TriangleIdentifiers;
+    height: number;
+    base: number;
+}, {}> | Exercise<{
     randomSide: number;
 }, {}> | Exercise<{
     area: number;
@@ -982,13 +989,9 @@ declare const mathExercises: (Exercise<{
 }, {}> | Exercise<{
     perimeter: number;
 }, {}> | Exercise<{
-    sideA: string;
-    sideB: string;
-    sideC: string;
     triangleIdentifiers: import("./math/geometry/triangle").TriangleIdentifiers;
 }, {}> | Exercise<{
-    square: number;
-    sideLengths: number[];
+    sideAsked: number;
     triangleIdentifiers: import("./math/geometry/triangle").TriangleIdentifiers;
 }, {}> | Exercise<{
     isRight: boolean;
@@ -1006,9 +1009,10 @@ declare const mathExercises: (Exercise<{
     yC: number;
     factor: number;
 }, {}> | Exercise<{
+    ratio: number;
     triangleIdentifiers: import("./math/geometry/triangle").TriangleIdentifiers;
-    insidePointsIdentifiers: import("./math/geometry/point").PointIdentifiers[];
-    segmentAsked: import("./math/geometry/segment").SegmentIdentifiers;
+    insidePointsNames: string[];
+    segmentAskedName: string;
     isPapillon: boolean;
 }, {
     configurationType: string;
@@ -1166,6 +1170,11 @@ declare const mathExercises: (Exercise<{
 }, {}> | Exercise<{
     startPoint: number[];
     vector: number[];
+}, {}> | Exercise<{
+    shape: string;
+    showDiagonals: boolean;
+    drawAngles: boolean;
+    shapeIdentifiers: import("./math/geometry/parallelogram").ParallelogramIdentifiers | import("./math/geometry/rhombus").RhombusIdentifiers | import("./math/geometry/rectangle").RectangleIdentifiers | import("./math/geometry/square").SquareIdentifiers;
 }, {}> | Exercise<{
     coeffs: number[];
     to: string;
@@ -1618,20 +1627,18 @@ declare const mathExercises: (Exercise<{
     mainValue: number;
     isCos: boolean;
 }, {}> | Exercise<{
-    sideA: string;
-    sideB: string;
-    sideC: string;
     randAngle: number;
     randTrigo: number;
+    triangleIdentifiers: import("./math/geometry/triangle").TriangleIdentifiers;
 }, {}> | Exercise<{
-    sideLengths: number[];
     randAngle: number;
-    randSides: number[];
+    hiddenSide: number;
+    triangleIdentifiers: import("./math/geometry/triangle").TriangleIdentifiers;
 }, {}> | Exercise<{
-    sideLengths: number[];
-    randAngle: number;
-    randSide: number;
-    randSideQuestion: number;
+    sideAsked: number;
+    givenSide: number;
+    givenAngle: number;
+    triangleIdentifiers: import("./math/geometry/triangle").TriangleIdentifiers;
 }, {}> | Exercise<{
     angleValue: number;
     angleIdentifiers: import("./tree/nodes/nodeConstructor").NodeIdentifiers;
@@ -1782,22 +1789,6 @@ declare const pcExercises: (Exercise<{
     signs: number[];
     isLog10: boolean;
 }, {}> | Exercise<{
-    vertices: string[];
-    xA: number;
-    yA: number;
-    xB: number;
-    yB: number;
-    xC: number;
-    yC: number;
-    factor: number;
-}, {}> | Exercise<{
-    triangleIdentifiers: import("./math/geometry/triangle").TriangleIdentifiers;
-    insidePointsIdentifiers: import("./math/geometry/point").PointIdentifiers[];
-    segmentAsked: import("./math/geometry/segment").SegmentIdentifiers;
-    isPapillon: boolean;
-}, {
-    configurationType: string;
-}> | Exercise<{
     xA: number;
     xB: number;
     yA: number;
@@ -1818,15 +1809,6 @@ declare const pcExercises: (Exercise<{
     a: number;
     b: number;
     c: number;
-}, {}> | Exercise<{
-    sideLengths: number[];
-    randAngle: number;
-    randSides: number[];
-}, {}> | Exercise<{
-    sideLengths: number[];
-    randAngle: number;
-    randSide: number;
-    randSideQuestion: number;
 }, {}> | Exercise<{
     reactionArray: import("./pc/constants/molecularChemistry/reaction").ReactionSpecies[];
 }, {}> | 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/math/complex/complex.d.ts

@@ -18,7 +18,7 @@ export declare class Complex {
     times(n: number): Complex;
     opposite(): Complex;
     conjugate(): Complex;
-    toArgumentTree(): NumberNode | import("../../tree/nodes/numbers/constantNode").ConstantNode | OppositeNode | FractionNode | undefined;
+    toArgumentTree(): import("../../tree/nodes/numbers/constantNode").ConstantNode | NumberNode | FractionNode | OppositeNode<FractionNode> | undefined;
     toModuleTree(): import("../../tree/nodes/algebraicNode").AlgebraicNode;
     toTree(): ComplexNode;
 }