math-exercises 3.0.46 → 3.0.48

package/lib/exercises/math/dataRepresentations/barChartReading.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"barChartReading.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/dataRepresentations/barChartReading.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAqHF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAgBjD,CAAC;;AAgFF,oBAAoB;AACpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmFG"}
+{"version":3,"file":"barChartReading.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/dataRepresentations/barChartReading.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAsHF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAgBjD,CAAC;;AAgFF,oBAAoB;AACpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmFG"}

package/lib/exercises/math/dataRepresentations/barChartReading.js

@@ -50,7 +50,7 @@ const getGGBOptions = (identifiers) => {
     const { labels, data } = identifiers;
     const commands = [
         `B = BarChart({1,2,3,4,5}, {${data.join(",")}}, 0.5)`,
-        ...labels.map((l, i) => `Text("\\footnotesize ${l}", (${i + 1}, 0), true, true, 0, -1)`),
+        ...labels.map((l, i) => `Text("\\footnotesize ${l}", (${i + 1}, 50), true, true, 0, -1)`),
         `Text("\\footnotesize Diamètre\\ (en \\ cm)", (3, -100), true, true, 0, -1)`,
         `ShowLabel(B,false)`,
         `SetColor(B, "#FE0045AB")`,
@@ -59,7 +59,7 @@ const getGGBOptions = (identifiers) => {
         commands,
         gridDistance: [10000, 50],
         fontSize: 16,
-        lockedAxesRatio: 1 / 250,
+        lockedAxesRatio: 1 / 400,
         xAxis: {
             // hideNumbers: true,
             showPositive: true,
@@ -72,7 +72,7 @@ const getGGBOptions = (identifiers) => {
         },
     });
     return ggb.getOptions({
-        coords: [-1, 6, -100, 1000],
+        coords: [-0.2, 5.2, -300, 1100],
     });
 };
 const getBarChartReadingQuestion = (ops) => {
@@ -80,7 +80,8 @@ const getBarChartReadingQuestion = (ops) => {
     const labels = ["11", "12", "13", "15", "16"];
     for (let i = 0; i < labels.length; i++) {
         data.push(50 *
-            randint(1, 20, data.map((d) => d / 50)));
+            randint(1, i < 3 ? 18 : 20, //pour ne pas que les 2 premieres barres touchent le label de l'axe
+            data.map((d) => d / 50)));
     }
     const itemAsked = randint(0, 5);
     const identifiers = {

package/lib/exercises/math/geometry/quadrilaterals/index.d.ts

@@ -1,2 +1,3 @@
 export * from "./quadrilateralRecognition.js";
+export * from "./parallelogramAngles.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/geometry/quadrilaterals/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/quadrilaterals/index.ts"],"names":[],"mappings":"AAAA,cAAc,+BAA+B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/quadrilaterals/index.ts"],"names":[],"mappings":"AAAA,cAAc,+BAA+B,CAAC;AAC9C,cAAc,0BAA0B,CAAC"}

package/lib/exercises/math/geometry/quadrilaterals/index.js

@@ -1 +1,2 @@
 export * from "./quadrilateralRecognition.js";
+export * from "./parallelogramAngles.js";

package/lib/exercises/math/geometry/quadrilaterals/parallelogramAngles.d.ts

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { ParallelogramIdentifiers } from "../../../../math/geometry/quadrilaterals/parallelogram.js";
+type Identifiers = {
+    paraIdentifiers: ParallelogramIdentifiers;
+    givenAngleIndex: number;
+    askedAngleIndex: number;
+};
+export declare const parallelogramAngles: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=parallelogramAngles.d.ts.map

package/lib/exercises/math/geometry/quadrilaterals/parallelogramAngles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parallelogramAngles.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/quadrilaterals/parallelogramAngles.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAGrC,OAAO,EAEL,wBAAwB,EACzB,MAAM,qDAAqD,CAAC;AAO7D,KAAK,WAAW,GAAG;IACjB,eAAe,EAAE,wBAAwB,CAAC;IAC1C,eAAe,EAAE,MAAM,CAAC;IACxB,eAAe,EAAE,MAAM,CAAC;CACzB,CAAC;AAuIF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAmBrD,CAAC"}

package/lib/exercises/math/geometry/quadrilaterals/parallelogramAngles.js

@@ -0,0 +1,128 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { ParallelogramConstructor, } from "../../../../math/geometry/quadrilaterals/parallelogram.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { round } from "../../../../math/utils/round.js";
+import { degreeParser } from "../../../../tree/parsers/degreeParser.js";
+import { doWhile } from "../../../../utils/doWhile.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    const para = ParallelogramConstructor.fromIdentifiers(identifiers.paraIdentifiers);
+    const value = round(para.angles[identifiers.givenAngleIndex].evaluate(), 0);
+    addValidProp(propositions, answer);
+    tryToAddWrongProp(propositions, "180^{\\circ}");
+    tryToAddWrongProp(propositions, (180 - value).frenchify() + "^{\\circ}");
+    tryToAddWrongProp(propositions, value.frenchify() + "^{\\circ}");
+    while (propositions.length < n) {
+        tryToAddWrongProp(propositions, randint(20, 160) + "^{\\circ}");
+    }
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const para = ParallelogramConstructor.fromIdentifiers(identifiers.paraIdentifiers);
+    const value = round(para.angles[identifiers.givenAngleIndex].evaluate(), 0);
+    const askedAngle = para.angles[identifiers.askedAngleIndex];
+    const isOpposite = identifiers.askedAngleIndex === (identifiers.givenAngleIndex + 2) % 4;
+    return (isOpposite ? value : 180 - value).frenchify() + "^{\\circ}";
+};
+const getInstruction = (identifiers) => {
+    const para = ParallelogramConstructor.fromIdentifiers(identifiers.paraIdentifiers);
+    const value = round(para.angles[identifiers.givenAngleIndex].evaluate(), 0);
+    return `On considère le parallélogramme $ABCD$ ci-dessous. 
+  
+L'angle $${para.angles[identifiers.givenAngleIndex].toTex()}$ vaut $${value}^{\\circ}$.
+
+Que vaut l'angle $${para.angles[identifiers.askedAngleIndex].toTex()}$ ?`;
+};
+const getHint = (identifiers) => {
+    return "Dans un parallélogramme, la somme totale des angles vaut $360^{\\circ}$. Les angles opposés sont égaux, et la somme de deux angles consécutifs est égale à $180^{\\circ}$.";
+};
+const getCorrection = (identifiers) => {
+    const para = ParallelogramConstructor.fromIdentifiers(identifiers.paraIdentifiers);
+    const value = round(para.angles[identifiers.givenAngleIndex].evaluate(), 0);
+    const askedAngle = para.angles[identifiers.askedAngleIndex];
+    const isOpposite = identifiers.askedAngleIndex === (identifiers.givenAngleIndex + 2) % 4;
+    return isOpposite
+        ? `Dans un parallélogramme, les angles opposés sont égaux. 
+  
+On a donc : 
+
+$$
+${askedAngle.toTex()} = ${getAnswer(identifiers)}
+$$`
+        : `Dans un parallélogramme, la somme de deux angles consécutifs vaut $180^{\\circ}$.
+
+Ainsi, 
+
+${alignTex([
+            [askedAngle.toTex(), "=", `180 - ${value}`],
+            ["", "=", getAnswer(identifiers)],
+        ])}`;
+};
+const getGGBOptions = (identifiers) => {
+    const para = ParallelogramConstructor.fromIdentifiers(identifiers.paraIdentifiers);
+    para.drawAngle(identifiers.givenAngleIndex, { showValue: false });
+    const ggb = new GeogebraConstructor({
+        commands: [
+            ...para.toGGBCommands(),
+            ...para.angles[identifiers.givenAngleIndex].toCommands({}),
+            // ...para.angles[identifiers.givenAngleIndex].getFitCaptionCommands({
+            //   size: "scriptsize",
+            //   color: "black",
+            //   text: `${value}`,
+            // }),
+            ...para.angles[identifiers.askedAngleIndex].toCommands({ color: "red" }),
+        ],
+        hideAxes: true,
+        hideGrid: true,
+    });
+    return ggb.getOptions({ coords: ggb.getCoordsForPoints(para.points) });
+};
+const getKeys = (identifiers) => {
+    return ["degree"];
+};
+const isAnswerValid = (ans, { answer }) => {
+    return degreeParser(ans) === answer;
+};
+const getParallelogramAnglesQuestion = (opts) => {
+    const givenAngleIndex = randint(0, 3);
+    const askedAngleIndex = randint(0, 3, [givenAngleIndex]);
+    const para = doWhile(() => ParallelogramConstructor.random(), (p) => round(p.angles[givenAngleIndex].evaluate(), 0) === 90); //ParallelogramConstructor.random();
+    const identifiers = {
+        paraIdentifiers: para.toIdentifiers(),
+        givenAngleIndex,
+        askedAngleIndex,
+    };
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        ggbOptions: getGGBOptions(identifiers),
+    };
+    return question;
+};
+export const parallelogramAngles = {
+    id: "parallelogramAngles",
+    connector: "=",
+    label: "Angles opposés et consécutifs dans un parallélogramme",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getParallelogramAnglesQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getHint,
+    getCorrection,
+    getInstruction,
+    getAnswer,
+    getGGBOptions,
+    hasGeogebra: true,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/geometry/triangles/triangleThirdAngleValue.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"triangleThirdAngleValue.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/triangles/triangleThirdAngleValue.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAGrC,OAAO,EAGL,mBAAmB,EAEpB,MAAM,2CAA2C,CAAC;AAQnD,KAAK,WAAW,GAAG;IACjB,mBAAmB,EAAE,mBAAmB,CAAC;IACzC,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAkIF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAmBzD,CAAC"}
+{"version":3,"file":"triangleThirdAngleValue.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/triangles/triangleThirdAngleValue.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAmBT,MAAM,6BAA6B,CAAC;AAGrC,OAAO,EAGL,mBAAmB,EAEpB,MAAM,2CAA2C,CAAC;AASnD,KAAK,WAAW,GAAG;IACjB,mBAAmB,EAAE,mBAAmB,CAAC;IACzC,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AA8IF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAoBzD,CAAC"}

package/lib/exercises/math/geometry/triangles/triangleThirdAngleValue.js

@@ -6,6 +6,7 @@ import { randint } from "../../../../math/utils/random/randint.js";
 import { round } from "../../../../math/utils/round.js";
 import { DegreeNode } from "../../../../tree/nodes/geometry/degree.js";
 import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
 import { degreeParser } from "../../../../tree/parsers/degreeParser.js";
 import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
 const getPropositions = (n, { answer }) => {
@@ -20,7 +21,13 @@ const getPropositions = (n, { answer }) => {
 const getAnswer = (identifiers) => {
     const { triangleIdentifiers, angleAsked } = identifiers;
     const triangle = TriangleConstructor.fromIdentifiers(triangleIdentifiers);
-    return triangle.angles[angleAsked].getValueNode(true).toTex() + "^{\\circ}";
+    const angles = [
+        triangle.angles[(angleAsked + 1) % 3].getValueNode(true),
+        triangle.angles[(angleAsked + 2) % 3].getValueNode(true),
+    ];
+    const addAngles = add(angles[0], angles[1]);
+    const simp = addAngles.simplify();
+    return substract(180, simp).simplify().toTex() + "^{\\circ}";
 };
 const getInstruction = (identifiers) => {
     const { triangleIdentifiers, angleAsked } = identifiers;
@@ -66,7 +73,9 @@ $$`;
 const getGGBOptions = (identifiers) => {
     const { triangleIdentifiers, angleAsked } = identifiers;
     const triangle = TriangleConstructor.fromIdentifiers(triangleIdentifiers);
-    triangle.drawAngles([angleAsked], { fitCaption: true, color: "red" });
+    // triangle.drawAngles([angleAsked], { fitCaption: true, color: "black" });
+    triangle.drawAngles([angleAsked]);
+    triangle.highlightAngle(angleAsked, { color: "red" });
     const ggb = new GeogebraConstructor({
         commands: [...triangle.commands],
         hideAxes: true,
@@ -101,7 +110,10 @@ const getTriangleThirdAngleValueQuestion = (opts) => {
         triangleIdentifiers: triangle.toIdentifiers(),
         angleAsked: randint(0, 3),
     };
-    const question = {
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
         answer: getAnswer(identifiers),
         instruction: getInstruction(identifiers),
         keys: getKeys(identifiers),
@@ -111,7 +123,6 @@ const getTriangleThirdAngleValueQuestion = (opts) => {
         correction: getCorrection(identifiers),
         ggbOptions: getGGBOptions(identifiers),
     };
-    return question;
 };
 export const triangleThirdAngleValue = {
     id: "triangleThirdAngleValue",
@@ -131,4 +142,5 @@ export const triangleThirdAngleValue = {
     getGGBOptions,
     hasGeogebra: true,
     hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
 };

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

@@ -1 +1 @@
-{"version":3,"file":"trigonometry.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/trigonometry/trigonometry.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAEL,mBAAmB,EACpB,MAAM,2CAA2C,CAAC;AASnD,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,mBAAmB,EAAE,mBAAmB,CAAC;CAC1C,CAAC;AAsHF,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,CAe9C,CAAC"}
+{"version":3,"file":"trigonometry.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/trigonometry/trigonometry.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAEL,mBAAmB,EACpB,MAAM,2CAA2C,CAAC;AASnD,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,mBAAmB,EAAE,mBAAmB,CAAC;CAC1C,CAAC;AAyJF,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,CAmB9C,CAAC"}

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

@@ -7,17 +7,18 @@ import { LengthNode } from "../../../tree/nodes/geometry/lengthNode.js";
 import { FractionNode } from "../../../tree/nodes/operators/fractionNode.js";
 import { random } from "../../../utils/alea/random.js";
 import { shuffle } from "../../../utils/alea/shuffle.js";
-const getTrigonometry = () => {
-    const triangle = RightTriangleConstructor.randomNiceSides({
-        randomName: true,
-    });
+const getInstruction = (identifiers) => {
+    const { randAngle, triangleIdentifiers, randTrigo } = identifiers;
+    const triangle = RightTriangleConstructor.fromIdentifiers(triangleIdentifiers);
     const trigo = ["le cosinus", "le sinus", "la tangente"];
-    const randTrigo = randint(0, 3);
-    const randAngle = random([1, 2]);
-    triangle.highlightAngle(randAngle, { color: "red" });
-    const [sideA, sideB, sideC] = triangle.sides.map((s) => s.toInsideName());
     const angleSummit = triangle.points[randAngle].name;
+    return `À quel quotient est égal ${trigo[randTrigo]} de l'angle $${triangle.angles[randAngle].toTex()}$ ?`;
+};
+const getAnswer = (identifiers) => {
+    const { randAngle, triangleIdentifiers, randTrigo } = identifiers;
+    const triangle = RightTriangleConstructor.fromIdentifiers(triangleIdentifiers);
     let quotient;
+    const [sideA, sideB, sideC] = triangle.sides.map((s) => s.toInsideName());
     switch (randAngle) {
         case 1: //angle B
             quotient = [
@@ -35,27 +36,49 @@ const getTrigonometry = () => {
             ];
             break;
     }
+    const answer = quotient[randTrigo];
+    return answer;
+};
+const getKeys = (identifiers) => {
+    const { randAngle, triangleIdentifiers, randTrigo } = identifiers;
+    const triangle = RightTriangleConstructor.fromIdentifiers(triangleIdentifiers);
+    return [...triangle.points.map((p) => p.name), "equal"];
+};
+const getGGBOptions = (identifiers) => {
+    const { randAngle, triangleIdentifiers, randTrigo } = identifiers;
+    const triangle = RightTriangleConstructor.fromIdentifiers(triangleIdentifiers);
+    triangle.highlightAngle(randAngle, { color: "red" });
     const ggb = new GeogebraConstructor({
         commands: triangle.commands,
         hideAxes: true,
         hideGrid: true,
     });
-    const answer = quotient[randTrigo];
-    const question = {
-        instruction: `À quel quotient est égal ${trigo[randTrigo]} de l'angle $\\widehat{${angleSummit}}$ ?`,
-        answer,
-        keys: [...triangle.points.map((p) => p.name), "equal"],
-        ggbOptions: ggb.getOptions({
-            coords: triangle.generateCoords(),
-        }),
+    return ggb.getOptions({
+        coords: triangle.generateCoords(),
+    });
+};
+const getTrigonometry = () => {
+    const triangle = RightTriangleConstructor.randomNiceSides({
+        randomName: true,
+    });
+    const randTrigo = randint(0, 3);
+    const randAngle = random([1, 2]);
+    const identifiers = {
+        triangleIdentifiers: triangle.toIdentifiers(),
+        randAngle,
+        randTrigo,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        instruction: getInstruction(identifiers),
+        answer: getAnswer(identifiers),
+        keys: getKeys(identifiers),
+        ggbOptions: getGGBOptions(identifiers),
         answerFormat: "tex",
-        identifiers: {
-            triangleIdentifiers: triangle.toIdentifiers(),
-            randAngle,
-            randTrigo,
-        },
+        identifiers,
     };
-    return question;
 };
 const getPropositions = (n, { answer, triangleIdentifiers }) => {
     const propositions = [];
@@ -116,4 +139,8 @@ export const trigonometry = {
     isAnswerValid,
     hasGeogebra: true,
     subject: "Mathématiques",
+    getAnswer,
+    getInstruction,
+    getGGBOptions,
+    getQuestionFromIdentifiers,
 };

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,6BAA6B,CAAC;AAIrC,OAAO,EAEL,mBAAmB,EACpB,MAAM,2CAA2C,CAAC;AAOnD,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"}
+{"version":3,"file":"trigonometryAngleCalcul.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/trigonometry/trigonometryAngleCalcul.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAEL,mBAAmB,EACpB,MAAM,2CAA2C,CAAC;AAOnD,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,mBAAmB,EAAE,mBAAmB,CAAC;CAC1C,CAAC;AA+EF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAmBzD,CAAC"}

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

@@ -5,39 +5,57 @@ import { RightTriangleConstructor } from "../../../math/geometry/triangles/right
 import { randint } from "../../../math/utils/random/randint.js";
 import { round } from "../../../math/utils/round.js";
 import { shuffle } from "../../../utils/alea/shuffle.js";
-const getTrigonometryAngleCalcul = () => {
-    const triangle = RightTriangleConstructor.randomNiceSides({
-        randomName: true,
-    });
-    const randAngle = randint(1, 3);
-    const hiddenSide = randint(0, 3);
+const getInstruction = (identifiers) => {
+    const { randAngle, hiddenSide, triangleIdentifiers } = identifiers;
+    const triangle = RightTriangleConstructor.fromIdentifiers(triangleIdentifiers);
     const givenSides = triangle.sides.filter((s, i) => i !== hiddenSide);
+    return `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.`;
+};
+const getAnswer = (identifiers) => {
+    const { randAngle, hiddenSide, triangleIdentifiers } = identifiers;
+    const triangle = RightTriangleConstructor.fromIdentifiers(triangleIdentifiers);
+    const answer = round(triangle.angles[randAngle].evaluate(), 0);
+    return answer + "^{\\circ}";
+};
+const getGGBOptions = (identifiers) => {
+    const { randAngle, hiddenSide, triangleIdentifiers } = identifiers;
+    const triangle = RightTriangleConstructor.fromIdentifiers(triangleIdentifiers);
     triangle.showSidesLength([hiddenSide]);
     triangle.highlightAngle(randAngle, { color: "red" });
-    const answer = round(triangle.angles[randAngle].evaluate(), 0);
-    const answerTex = answer + "^{\\circ}";
     const ggb = new GeogebraConstructor({
         commands: triangle.commands,
         hideAxes: true,
         hideGrid: true,
     });
-    const question = {
-        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,
+    return ggb.getOptions({
+        coords: triangle.generateCoords(),
+    });
+};
+const getTrigonometryAngleCalcul = () => {
+    const triangle = RightTriangleConstructor.randomNiceSides({
+        randomName: true,
+    });
+    const randAngle = randint(1, 3);
+    const hiddenSide = randint(0, 3);
+    const identifiers = {
+        randAngle,
+        hiddenSide,
+        triangleIdentifiers: triangle.toIdentifiers(),
+    };
+    const question = getQuestionFromIdentifiers(identifiers);
+    return question;
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        instruction: getInstruction(identifiers),
+        answer: getAnswer(identifiers),
         keys: ["degree"],
-        ggbOptions: ggb.getOptions({
-            coords: triangle.generateCoords(),
-        }),
+        ggbOptions: getGGBOptions(identifiers),
         answerFormat: "tex",
-        identifiers: {
-            randAngle,
-            hiddenSide,
-            triangleIdentifiers: triangle.toIdentifiers(),
-        },
+        identifiers,
     };
-    return question;
 };
 const getPropositions = (n, { answer }) => {
     const propositions = [];
@@ -64,4 +82,8 @@ export const trigonometryAngleCalcul = {
     isAnswerValid,
     hasGeogebra: true,
     subject: "Mathématiques",
+    getAnswer,
+    getInstruction,
+    getGGBOptions,
+    getQuestionFromIdentifiers,
 };

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,EAaT,MAAM,6BAA6B,CAAC;AASrC,OAAO,EAEL,mBAAmB,EACpB,MAAM,2CAA2C,CAAC;AAMnD,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;AA8OF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAmBxD,CAAC"}
+{"version":3,"file":"trigonometrySideCalcul.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/trigonometry/trigonometrySideCalcul.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AASrC,OAAO,EAEL,mBAAmB,EACpB,MAAM,2CAA2C,CAAC;AAMnD,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;AAiPF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAoBxD,CAAC"}

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

@@ -12,7 +12,7 @@ const getInstruction = (identifiers) => {
     const { givenAngle, givenSide, sideAsked, triangleIdentifiers } = identifiers;
     const triangle = TriangleConstructor.fromIdentifiers(triangleIdentifiers);
     const angleValue = triangle.angles[givenAngle].evaluate().frenchify();
-    return `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$. 
+    return `Le triangle $${triangle.name}$ rectangle en $${triangle.points[0].name}$ est tel que $${triangle.sides[givenSide].toLengthTex()}$ cm et $${triangle.angles[givenAngle].toTex()} = ${angleValue}^\\circ$. 
     
 Calculer $${triangle.sides[sideAsked].toInsideName()}$ à $0,1$ cm près.`;
 };
@@ -51,7 +51,10 @@ const getTrigonometrySideCalcul = () => {
         sideAsked,
         triangleIdentifiers: triangle.toIdentifiers(),
     };
-    const question = {
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
         instruction: getInstruction(identifiers),
         answer: getAnswer(identifiers),
         hint: getHint(identifiers),
@@ -61,7 +64,6 @@ const getTrigonometrySideCalcul = () => {
         answerFormat: "tex",
         identifiers,
     };
-    return question;
 };
 const getPropositions = (n, { answer }) => {
     const propositions = [];
@@ -223,4 +225,5 @@ export const trigonometrySideCalcul = {
     getGGBOptions,
     getCorrection,
     hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
 };

package/lib/index.d.ts

@@ -1305,6 +1305,10 @@ declare const mathExercises: (Exercise<{
     showDiagonals: boolean;
     drawAngles: boolean;
     shapeIdentifiers: import("./math/geometry/quadrilaterals/rectangle.js").RectangleIdentifiers | import("./math/geometry/quadrilaterals/square.js").SquareIdentifiers | import("./math/geometry/quadrilaterals/rhombus.js").RhombusIdentifiers | import("./math/geometry/quadrilaterals/parallelogram.js").ParallelogramIdentifiers;
+}, {}> | Exercise<{
+    paraIdentifiers: import("./math/geometry/quadrilaterals/parallelogram.js").ParallelogramIdentifiers;
+    givenAngleIndex: number;
+    askedAngleIndex: number;
 }, {}> | Exercise<{
     points: import("./math/geometry/point.js").PointIdentifiers[];
     angleType: string;

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":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAG7D,OAAO,4BAA4B,CAAC;AACpC,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAE/D,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,QAAQ,EAAE,QAAQ,EAAE,cAAc,EAAE,CAAC"}

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

@@ -1 +1 @@
-{"version":3,"file":"angle.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/angle.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAMlE,OAAO,EAAE,KAAK,EAAoB,gBAAgB,EAAE,MAAM,YAAY,CAAC;AACvE,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAK7C,8BAAsB,gBAAgB;IACpC,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,gBAAgB;CAUrD;AACD,KAAK,UAAU,GAAG;IAChB,eAAe,CAAC,EAAE,aAAa,CAAC;IAChC,eAAe,CAAC,EAAE,aAAa,CAAC;CACjC,CAAC;AAEF,KAAK,qBAAqB,GAAG;IAC3B,eAAe,CAAC,EAAE,eAAe,CAAC;IAClC,eAAe,CAAC,EAAE,eAAe,CAAC;CACnC,CAAC;AACF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,MAAM,EAAE,gBAAgB,EAAE,CAAC;IAC3B,KAAK,CAAC,EAAE,qBAAqB,CAAC;CAC/B,CAAC;AACF,qBAAa,KAAK;IAChB,MAAM,EAAE,KAAK,EAAE,CAAC;IAChB,eAAe,CAAC,EAAE,aAAa,CAAC;IAChC,eAAe,CAAC,EAAE,aAAa,CAAC;IAChC,KAAK,CAAC,EAAE,UAAU,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb;;;OAGG;gBACS,MAAM,EAAE,KAAK,EAAE,EAAE,KAAK,CAAC,EAAE,UAAU;IAmB/C,aAAa,IAAI,gBAAgB;IASjC,WAAW,CAAC,CAAC,EAAE,KAAK;IAIpB,MAAM,CAAC,CAAC,EAAE,KAAK;IAqBf,SAAS,CAAC,CAAC,EAAE,KAAK;IASlB,gBAAgB,CAAC,CAAC,EAAE,KAAK;IAwCzB,MAAM;IAMN,eAAe,CAAC,CAAC,EAAE,KAAK;IAsCxB,gBAAgB,CAAC,CAAC,EAAE,KAAK;IAoBzB,QAAQ,CAAC,QAAQ,UAAQ;IAiBzB,YAAY,CAAC,QAAQ,UAAQ;IAW7B,OAAO;IAIP,KAAK;IAIL,qBAAqB,CAAC,EACpB,IAAI,EACJ,KAAK,EACL,IAAI,GACL,GAAE;QACD,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,IAAI,CAAC,EAAE,YAAY,GAAG,MAAM,GAAG,OAAO,GAAG,OAAO,CAAC;KAC7C;IAgBN,UAAU,CAAC,IAAI,CAAC,EAAE;QAChB,iBAAiB,CAAC,EAAE,OAAO,CAAC;QAC5B,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,SAAS,CAAC,EAAE,OAAO,CAAC;QACpB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,UAAU,CAAC,EAAE,MAAM,CAAC;KACrB;CA2BF"}
+{"version":3,"file":"angle.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/angle.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAMlE,OAAO,EAAE,KAAK,EAAoB,gBAAgB,EAAE,MAAM,YAAY,CAAC;AACvE,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAK7C,8BAAsB,gBAAgB;IACpC,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,gBAAgB;CAUrD;AACD,KAAK,UAAU,GAAG;IAChB,eAAe,CAAC,EAAE,aAAa,CAAC;IAChC,eAAe,CAAC,EAAE,aAAa,CAAC;CACjC,CAAC;AAEF,KAAK,qBAAqB,GAAG;IAC3B,eAAe,CAAC,EAAE,eAAe,CAAC;IAClC,eAAe,CAAC,EAAE,eAAe,CAAC;CACnC,CAAC;AACF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,MAAM,EAAE,gBAAgB,EAAE,CAAC;IAC3B,KAAK,CAAC,EAAE,qBAAqB,CAAC;CAC/B,CAAC;AACF,qBAAa,KAAK;IAChB,MAAM,EAAE,KAAK,EAAE,CAAC;IAChB,eAAe,CAAC,EAAE,aAAa,CAAC;IAChC,eAAe,CAAC,EAAE,aAAa,CAAC;IAChC,KAAK,CAAC,EAAE,UAAU,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb;;;OAGG;gBACS,MAAM,EAAE,KAAK,EAAE,EAAE,KAAK,CAAC,EAAE,UAAU;IAmB/C,aAAa,IAAI,gBAAgB;IASjC,WAAW,CAAC,CAAC,EAAE,KAAK;IAIpB,MAAM,CAAC,CAAC,EAAE,KAAK;IAqBf,SAAS,CAAC,CAAC,EAAE,KAAK;IASlB,gBAAgB,CAAC,CAAC,EAAE,KAAK;IAwCzB,MAAM;IAMN,eAAe,CAAC,CAAC,EAAE,KAAK;IAsCxB,gBAAgB,CAAC,CAAC,EAAE,KAAK;IAoBzB,QAAQ,CAAC,QAAQ,UAAQ;IAkBzB,YAAY,CAAC,QAAQ,UAAQ;IAW7B,OAAO;IAIP,KAAK;IAIL,qBAAqB,CAAC,EACpB,IAAI,EACJ,KAAK,EACL,IAAI,GACL,GAAE;QACD,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,IAAI,CAAC,EAAE,YAAY,GAAG,MAAM,GAAG,OAAO,GAAG,OAAO,CAAC;KAC7C;IAgBN,UAAU,CAAC,IAAI,CAAC,EAAE;QAChB,iBAAiB,CAAC,EAAE,OAAO,CAAC;QAC5B,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,SAAS,CAAC,EAAE,OAAO,CAAC;QACpB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,UAAU,CAAC,EAAE,MAAM,CAAC;KACrB;CA2BF"}

package/lib/math/geometry/angle.js

@@ -176,7 +176,8 @@ export class Angle {
         }
         if (inRadian)
             return round(angleRadians, 4);
-        return round(angleRadians * (180 / Math.PI), 4);
+        const value = angleRadians * (180 / Math.PI);
+        return round(value > 180 ? 360 - value : value, 4);
     }
     getValueNode(inDegree = false) {
         if (this.degreeValueNode || this.radianValueNode) {

package/lib/math/geometry/quadrilaterals/parallelogram.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parallelogram.d.ts","sourceRoot":"","sources":["../../../../src/math/geometry/quadrilaterals/parallelogram.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAoB,gBAAgB,EAAE,MAAM,aAAa,CAAC;AACxE,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAEnD,8BAAsB,wBAAwB;IAC5C,MAAM,CAAC,MAAM;IA2Bb,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,wBAAwB;CAO7D;AAED,MAAM,MAAM,wBAAwB,GAAG;IACrC,MAAM,EAAE,gBAAgB,EAAE,CAAC;CAC5B,CAAC;AAEF,qBAAa,aAAc,SAAQ,aAAa;gBAClC,MAAM,EAAE,KAAK,EAAE;IAG3B,aAAa,IAAI,wBAAwB;IAKzC,aAAa,CAAC,EACZ,UAAU,EACV,eAAe,EACf,WAAW,EACX,SAAS,GACV,EAAE;QACD,UAAU,EAAE,OAAO,CAAC;QACpB,eAAe,EAAE,OAAO,CAAC;QACzB,WAAW,CAAC,EAAE,OAAO,CAAC;QACtB,SAAS,CAAC,EAAE,OAAO,CAAC;KACrB,GAAG,IAAI;IA6BR,mBAAmB,CAAC,EAAE,SAAS,EAAE,EAAE;QAAE,SAAS,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,IAAI;CAclE"}
+{"version":3,"file":"parallelogram.d.ts","sourceRoot":"","sources":["../../../../src/math/geometry/quadrilaterals/parallelogram.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,EAAoB,gBAAgB,EAAE,MAAM,aAAa,CAAC;AACxE,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAEnD,8BAAsB,wBAAwB;IAC5C,MAAM,CAAC,MAAM;IA2Bb,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,wBAAwB;CAO7D;AAED,MAAM,MAAM,wBAAwB,GAAG;IACrC,MAAM,EAAE,gBAAgB,EAAE,CAAC;CAC5B,CAAC;AAEF,qBAAa,aAAc,SAAQ,aAAa;gBAClC,MAAM,EAAE,KAAK,EAAE;IAG3B,aAAa,IAAI,wBAAwB;IAKzC,aAAa,CAAC,EACZ,UAAU,EACV,eAAe,EACf,WAAW,EACX,SAAS,GACV,EAAE;QACD,UAAU,EAAE,OAAO,CAAC;QACpB,eAAe,EAAE,OAAO,CAAC;QACzB,WAAW,CAAC,EAAE,OAAO,CAAC;QACtB,SAAS,CAAC,EAAE,OAAO,CAAC;KACrB,GAAG,IAAI;IA6BR,mBAAmB,CAAC,EAAE,SAAS,EAAE,EAAE;QAAE,SAAS,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,IAAI;CAclE"}

package/lib/math/geometry/quadrilaterals/parallelogram.js

@@ -1,10 +1,12 @@
 import { randfloat } from "../../../math/utils/random/randfloat.js";
+import { coinFlip } from "../../../utils/alea/coinFlip.js";
 import { Point, PointConstructor } from "../point.js";
 import { Quadrilateral } from "./quadrilateral.js";
 export class ParallelogramConstructor {
     static random() {
         const angle = randfloat(0, Math.PI / 2);
-        const additionalAngle = randfloat(Math.PI / 4, (3 * Math.PI) / 4);
+        const additionalAngleDeg = 90 + (coinFlip() ? 1 : -1) * randfloat(10, 60);
+        const additionalAngle = additionalAngleDeg * (Math.PI / 180);
         const xRand = randfloat(5, 8);
         const xRand2 = randfloat(3, 8);
         const origin = new Point("O", (0).toTree(), (0).toTree());

package/lib/math/geometry/quadrilaterals/quadrilateral.d.ts

@@ -1,9 +1,11 @@
+import { Angle } from "../angle.js";
 import { Point } from "../point.js";
 import { Segment } from "../segment.js";
 export declare class Quadrilateral {
     commands: string[];
     points: Point[];
     sides: Segment[];
+    angles: Angle[];
     name: string;
     constructor(points: Point[]);
     drawDiagonals({ drawCenter, drawDecorations, }: {
@@ -11,5 +13,9 @@ export declare class Quadrilateral {
         drawDecorations: boolean;
     }): void;
     toGGBCommands(): string[];
+    drawAngle(index: number, opts?: {
+        color?: string;
+        showValue?: boolean;
+    }): void;
 }
 //# sourceMappingURL=quadrilateral.d.ts.map

package/lib/math/geometry/quadrilaterals/quadrilateral.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"quadrilateral.d.ts","sourceRoot":"","sources":["../../../../src/math/geometry/quadrilaterals/quadrilateral.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACpC,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAExC,qBAAa,aAAa;IACxB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,MAAM,EAAE,KAAK,EAAE,CAAC;IAChB,KAAK,EAAE,OAAO,EAAE,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;gBACD,MAAM,EAAE,KAAK,EAAE;IAuB3B,aAAa,CAAC,EACZ,UAAkB,EAClB,eAAuB,GACxB,EAAE;QACD,UAAU,EAAE,OAAO,CAAC;QACpB,eAAe,EAAE,OAAO,CAAC;KAC1B;IAcD,aAAa;CAGd"}
+{"version":3,"file":"quadrilateral.d.ts","sourceRoot":"","sources":["../../../../src/math/geometry/quadrilaterals/quadrilateral.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACpC,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACpC,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAExC,qBAAa,aAAa;IACxB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,MAAM,EAAE,KAAK,EAAE,CAAC;IAChB,KAAK,EAAE,OAAO,EAAE,CAAC;IACjB,MAAM,EAAE,KAAK,EAAE,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;gBACD,MAAM,EAAE,KAAK,EAAE;IA6B3B,aAAa,CAAC,EACZ,UAAkB,EAClB,eAAuB,GACxB,EAAE;QACD,UAAU,EAAE,OAAO,CAAC;QACpB,eAAe,EAAE,OAAO,CAAC;KAC1B;IAcD,aAAa;IAIb,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,OAAO,CAAA;KAAE;CAGxE"}

package/lib/math/geometry/quadrilaterals/quadrilateral.js

@@ -1,8 +1,10 @@
+import { Angle } from "../angle.js";
 import { Segment } from "../segment.js";
 export class Quadrilateral {
     commands;
     points;
     sides;
+    angles;
     name;
     constructor(points) {
         if (points.length !== 4)
@@ -15,6 +17,12 @@ export class Quadrilateral {
             new Segment(points[2], points[3]),
             new Segment(points[3], points[0]),
         ];
+        this.angles = [
+            new Angle([points[3], points[0], points[1]]),
+            new Angle([points[0], points[1], points[2]]),
+            new Angle([points[1], points[2], points[3]]),
+            new Angle([points[2], points[3], points[0]]),
+        ];
         this.commands = [
             ...points.flatMap((p) => p.toGGBCommand({
                 isFixed: true,
@@ -35,4 +43,7 @@ export class Quadrilateral {
     toGGBCommands() {
         return this.commands;
     }
+    drawAngle(index, opts) {
+        this.commands.push(...this.angles[index].toCommands(opts));
+    }
 }

package/lib/math/geometry/triangles/triangle.js

@@ -78,7 +78,7 @@ export class Triangle {
         this.props = props;
         this.name = points.map((p) => p.name).join("");
         this.points = points;
-        const anglePoints = [points[0], points[2], points[1]];
+        const anglePoints = [points[0], points[1], points[2]];
         this.angles = [
             new Angle(arrayRotation(anglePoints, 2), {
                 radianValueNode: props?.anglesRadianValues?.[0],
@@ -166,7 +166,7 @@ export class Triangle {
     showSidesLength(hiddenSides) {
         this.commands.push(...this.sides
             .filter((s, i) => !hiddenSides?.includes(i))
-            .flatMap((s) => s.getFitCaptionCommands()));
+            .flatMap((s) => s.getFitCaptionCommands({ size: "scriptsize" })));
     }
     getHeight(summitIndex, opts) {
         const base = LineConstructor.fromSegment(this.sides[summitIndex]);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "math-exercises",
   "type": "module",
-  "version": "3.0.46",
+  "version": "3.0.48",
   "description": "Math exercises generator for middle school and high school",
   "main": "lib/index.js",
   "files": [