math-exercises 3.0.99 → 3.0.100

package/lib/exercises/math/geometry/areas/calculateAreaFromCodedShape.d.ts

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    shape: number;
+    height: number;
+    width: number;
+};
+export declare const calculateAreaFromCodedShape: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=calculateAreaFromCodedShape.d.ts.map

package/lib/exercises/math/geometry/areas/calculateAreaFromCodedShape.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"calculateAreaFromCodedShape.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/areas/calculateAreaFromCodedShape.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AA8KF,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAAC,WAAW,CAsB7D,CAAC"}

package/lib/exercises/math/geometry/areas/calculateAreaFromCodedShape.js

@@ -0,0 +1,156 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { numberVEA } from "../../../../exercises/vea/numberVEA.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+const getPropositions = (n, { answer, height, shape, width }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    tryToAddWrongProp(propositions, (height * width).frenchify());
+    tryToAddWrongProp(propositions, ((height * width) / 2).frenchify());
+    while (propositions.length < n) {
+        tryToAddWrongProp(propositions, ((3 / 4) * height * width + randint(-3, 3, [0])).frenchify());
+    }
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    return multiply(0.75, identifiers.height * identifiers.width)
+        .simplify()
+        .toTex();
+};
+const getInstruction = (identifiers) => {
+    return `On considère la figure ci-dessous.
+    
+Quelle est l'aire de la surface colorée ?`;
+};
+const getHint = (identifiers) => {
+    return `L'aire de la surface colorée est égale à l'aire du rectangle $ABCD$ moins l'aire du triangle $CED$.`;
+};
+const getCorrection = (identifiers) => {
+    //rectangle - triangle
+    //moitié rectangle + triangle
+    //moitié reactangle + moitié moitié reactalge
+    const { height, shape, width } = identifiers;
+    return `Pour calculer l'aire de la surface colorée, on remarque qu'elle est égale à l'aire du rectangle $ABCD$ moins l'aire du triangle $CED$.
+  
+L'aire du rectangle $ABCD$ est égale à :
+
+$$
+${multiply(height, width).toTex({ forceNoSimplification: true })}=${(height * width).frenchify()}
+$$
+
+On calcule ensuite l'aire du triangle $CED$. Puisqu'il est rectangle en $D$, son aire vaut : 
+
+$$
+${frac(multiply("CD", "DE"), 2).toTex({ forceTimesSign: true })}
+$$
+
+Or $CD = ${height.frenchify()}$ et $DE = ${(width / 2).frenchify()}$. L'aire de $CED$ vaut donc : 
+
+$$
+${frac(multiply(height, width / 2), 2).toTex()}=${((height * width) /
+        4).frenchify()}
+$$
+
+L'aire de la surface colorée vaut donc : 
+
+$$
+${substract(height * width, (height * width) / 4).toTex()} = ${getAnswer(identifiers)}
+$$
+
+
+
+`;
+};
+const getGGBOptions = (identifiers) => {
+    const { height, shape, width } = identifiers;
+    const ggb = new GeogebraConstructor({
+        commands: [
+            `B = (0,0)`,
+            `C = (${width},0)`,
+            `D = (${width},${height})`,
+            `A = (0,${height})`,
+            `E = (${width / 2},${height})`,
+            ...["A", "B", "C", "D", "E"].flatMap((e) => [
+                `SetVisibleInView(${e},1, false)`,
+                `SetFixed(${e}, true)`,
+            ]),
+            `Segment(E, C)`,
+            `Segment(D, C)`,
+            `se1 = Segment(A, E)`,
+            `se2 = Segment(E,D)`,
+            `SetDecoration(se1, 2)`,
+            `SetDecoration(se2, 2)`,
+            `a = Angle(C,B,A)`,
+            `ShowLabel(a, false)`,
+            `b = Angle(B,A,D)`,
+            `ShowLabel(b, false)`,
+            `c = Angle(A,D,C)`,
+            `ShowLabel(c, false)`,
+            `P = Polygon(B,A,E,C)`,
+            `SetFixed(P, true)`,
+            `Text("$\\scriptsize B$", (0, -0.1*${height}), true, true, 0, 0)`,
+            `Text("$\\scriptsize C$", (${width}, -0.1*${height}), true, true, 0, 0)`,
+            `Text("$\\scriptsize D$", (${width}, ${height}+0.3+${Math.min(1, 0.1 * height)}), true, true, 0, 0)`,
+            `Text("$\\scriptsize E$", (${width / 2}, ${height}+0.3+${Math.min(1, 0.1 * height)}), true, true, 0, 0)`,
+            `Text("$\\scriptsize A$", (0, ${height}+0.3+${Math.min(1, 0.1 * height)}), true, true, 0, 0)`,
+            `Text("$\\scriptsize ${height}$", (-0.4, ${height / 2}), true, true, 0, 0)`,
+            `Text("$\\scriptsize ${width}$", (${width / 2}, -0.1*${height}), true, true, 0, 0)`,
+        ],
+        hideAxes: true,
+        hideGrid: true,
+    });
+    return ggb.getOptions({
+        coords: [-1, width + 1, -1.5, height + 1.5],
+    });
+};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    return numberVEA(ans, answer);
+};
+const getCalculateAreaFromCodedShapeQuestion = (opts) => {
+    const width = randint(3, 11);
+    const height = randint(1, width);
+    const identifiers = {
+        shape: 1,
+        height,
+        width,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        ggbOptions: getGGBOptions(identifiers),
+    };
+};
+export const calculateAreaFromCodedShape = {
+    id: "calculateAreaFromCodedShape",
+    label: "Calculer l'aire d'une figure codée",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getCalculateAreaFromCodedShapeQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getHint,
+    getCorrection,
+    getInstruction,
+    getAnswer,
+    getGGBOptions,
+    hasGeogebra: true,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -7,4 +7,5 @@ export * from "./triangleAreaV2.js";
 export * from "./squareSideFromArea.js";
 export * from "./rectangleSideFromArea.js";
 export * from "./circleRadiusFromArea.js";
+export * from "./calculateAreaFromCodedShape.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/areas/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,oBAAoB,CAAC;AACnC,cAAc,wBAAwB,CAAC;AACvC,cAAc,iBAAiB,CAAC;AAChC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,yBAAyB,CAAC;AACxC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,2BAA2B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/areas/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,oBAAoB,CAAC;AACnC,cAAc,wBAAwB,CAAC;AACvC,cAAc,iBAAiB,CAAC;AAChC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,yBAAyB,CAAC;AACxC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,kCAAkC,CAAC"}

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

@@ -7,3 +7,4 @@ export * from "./triangleAreaV2.js";
 export * from "./squareSideFromArea.js";
 export * from "./rectangleSideFromArea.js";
 export * from "./circleRadiusFromArea.js";
+export * from "./calculateAreaFromCodedShape.js";

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/euclidian/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/euclidian/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,mCAAmC,CAAC"}

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

@@ -1 +1,2 @@
 export * from "./pythagoreOrThales.js";
+export * from "./orthogonalProjectFromPicture.js";

package/lib/exercises/math/geometry/euclidian/orthogonalProjectFromPicture.d.ts

@@ -0,0 +1,8 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    point: string;
+    line: string;
+};
+export declare const orthogonalProjectFromPicture: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=orthogonalProjectFromPicture.d.ts.map

package/lib/exercises/math/geometry/euclidian/orthogonalProjectFromPicture.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"orthogonalProjectFromPicture.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/euclidian/orthogonalProjectFromPicture.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAkMF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,CAoB9D,CAAC"}

package/lib/exercises/math/geometry/euclidian/orthogonalProjectFromPicture.js

@@ -0,0 +1,197 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { Point } from "../../../../math/geometry/point.js";
+import { random } from "../../../../utils/alea/random.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getPoints = () => {
+    const points = [
+        new Point("A", 0, 0),
+        new Point("B", 4, 0),
+        new Point("C", 4, 4),
+        new Point("D", 0, 4),
+        new Point("E", 0, 2),
+        new Point("F", 4, 2),
+        new Point("G", 2, 4),
+        new Point("H", 2, 0),
+        new Point("I", 1, 3),
+        new Point("J", 3, 1),
+        new Point("K", 1, 1),
+        new Point("L", 3, 3),
+        new Point("P", 2, 2),
+    ];
+    return points;
+};
+const getNames = () => {
+    const names = [
+        "A",
+        "B",
+        "C",
+        "D",
+        "E",
+        "F",
+        "G",
+        "H",
+        "I",
+        "J",
+        "K",
+        "L",
+        "P",
+    ];
+    return names;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const names = getNames();
+    while (propositions.length < n) {
+        tryToAddWrongProp(propositions, random(names));
+    }
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const projs = [
+        { line: "AB", A: ["A", "E", "D"], H: ["G", "P", "H"], B: ["C", "F", "B"] },
+        { line: "EF", E: ["A", "E", "D"], P: ["G", "P", "H"], F: ["C", "F", "B"] },
+        { line: "DC", D: ["A", "E", "D"], G: ["G", "P", "H"], C: ["C", "F", "B"] },
+        { line: "DA", A: ["A", "H", "B"], E: ["E", "P", "F"], D: ["D", "G", "C"] },
+        { line: "GH", H: ["A", "H", "B"], P: ["E", "P", "F"], G: ["D", "G", "C"] },
+        { line: "CB", B: ["A", "H", "B"], F: ["E", "P", "F"], C: ["D", "G", "C"] },
+        {
+            line: "DB",
+            D: ["D"],
+            I: ["E", "I", "G"],
+            P: ["A", "K", "P", "L", "C"],
+            J: ["H", "J", "F"],
+            B: ["B"],
+        },
+        {
+            line: "AC",
+            C: ["C"],
+            K: ["E", "K", "H"],
+            P: ["D", "I", "P", "J", "B"],
+            L: ["G", "L", "F"],
+            A: ["A"],
+        },
+        {
+            line: "EH",
+            E: ["E", "I", "G"],
+            H: ["H", "J", "F"],
+            K: ["A", "K", "P", "L", "C"],
+        },
+        {
+            line: "GF",
+            G: ["E", "I", "G"],
+            F: ["H", "J", "F"],
+            L: ["A", "K", "P", "L", "C"],
+        },
+        {
+            line: "EG",
+            E: ["E", "K", "H"],
+            G: ["G", "L", "F"],
+            I: ["D", "I", "P", "J", "B"],
+        },
+        {
+            line: "HF",
+            H: ["E", "K", "H"],
+            F: ["G", "L", "F"],
+            J: ["D", "I", "P", "J", "B"],
+        },
+    ];
+    const dataSet = projs.find((e) => e.line === identifiers.line);
+    for (const [key, value] of Object.entries(dataSet)) {
+        if (key === "line")
+            continue;
+        if (value.includes(identifiers.point)) {
+            return key;
+        }
+    }
+    return "";
+};
+const getInstruction = (identifiers) => {
+    const { line, point } = identifiers;
+    return `On considère le carré $ABCD$ ci-dessous :
+  
+![](https://heureuxhasarddocsbucket.s3.eu-west-3.amazonaws.com/mathliveV2/activities/quizzes/generator/pointsOnSquare.png)
+
+Quel est le projeté orthogonal de $${point}$ sur la droite $\\left(${line}\\right)$ ?
+`;
+};
+const getHint = (identifiers) => {
+    return `- Si $A$ est un point sur une droite $d$, alors le projeté orthogonal de $A$ sur $d$ est $A$.
+  
+- Si $A$ n'appartient pas à la droite $d$, alors le projeté orthogonal de $A$ sur $d$ est le point $H$ sur $d$ tel que la droite $(AH)$ est perpendiculaire à $d$.`;
+};
+const getCorrection = (identifiers) => {
+    const { line, point } = identifiers;
+    //si point sur droite
+    //sinon
+    const points = getPoints();
+    const pointAnswer = getAnswer(identifiers);
+    const pointObj = points.find((e) => e.name === point);
+    const linePoints = points.filter((e) => line.includes(e.name));
+    const isOnLine = pointObj.isAligned(linePoints[0], linePoints[1]);
+    if (isOnLine) {
+        return `Puisque $${point}$ appartient à la droite $\\left(${line}\\right)$, le projeté orthogonal de $${point}$ sur $\\left(${line}\\right)$ est $${point}$.`;
+    }
+    else {
+        return `Les droites $\\left(${line}\\right)$ et $\\left(${point}${pointAnswer}\\right)$ sont perpendiculaires. De plus, le point $${pointAnswer}$ appartient à la droite $${line}$. Le projeté orthogonal de $${point}$ sur $\\left(${line}\\right)$ est donc $${pointAnswer}$.`;
+    }
+};
+const getKeys = (identifiers) => {
+    const names = getNames();
+    return names;
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return ans === answer;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getOrthogonalProjectFromPictureQuestion = (ops) => {
+    const data = [
+        { lines: ["AB", "EF", "DC"], excludes: ["I", "J", "K", "L"] },
+        { lines: ["DA", "GH", "CB"], excludes: ["I", "J", "K", "L"] },
+        { lines: ["DB", "AC"], excludes: [] },
+        { lines: ["EH", "GF"], excludes: ["B", "D"] },
+        { lines: ["EG", "HF"], excludes: ["A", "C"] },
+    ];
+    const names = getNames();
+    const dataSet = random(data);
+    const line = random(dataSet.lines);
+    const point = random(names, dataSet.excludes);
+    const identifiers = {
+        line,
+        point,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const orthogonalProjectFromPicture = {
+    id: "orthogonalProjectFromPicture",
+    label: "Identifier le projeté orthogonal d'un point sur une figure codée",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getOrthogonalProjectFromPictureQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/geometry/euclidianConstructions/pointImageFromTranslation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pointImageFromTranslation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/euclidianConstructions/pointImageFromTranslation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAOrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAMtC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,gBAAgB,EAAE,CAAC;IAC3B,UAAU,EAAE,MAAM,CAAC;IACnB,iBAAiB,EAAE,MAAM,EAAE,CAAC;CAC7B,CAAC;AAEF,KAAK,OAAO,GAAG;IACb,SAAS,EAAE,OAAO,CAAC;CACpB,CAAC;AA0IF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAgBpE,CAAC"}
+{"version":3,"file":"pointImageFromTranslation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/euclidianConstructions/pointImageFromTranslation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAOrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAMtC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,gBAAgB,EAAE,CAAC;IAC3B,UAAU,EAAE,MAAM,CAAC;IACnB,iBAAiB,EAAE,MAAM,EAAE,CAAC;CAC7B,CAAC;AAEF,KAAK,OAAO,GAAG;IACb,SAAS,EAAE,OAAO,CAAC;CACpB,CAAC;AA8IF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAiBpE,CAAC"}

package/lib/exercises/math/geometry/euclidianConstructions/pointImageFromTranslation.js

@@ -23,8 +23,12 @@ const getEndPoint = (identifiers) => {
     const end = vector.getEndPoint(startPoint, identifiers.startPoint + "'");
     return end;
 };
-// const getHint: GetHint<Identifiers> = (identifiers) => {};
-// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {};
+const getHint = (identifiers) => {
+    return ``;
+};
+const getCorrection = (identifiers) => {
+    return ``;
+};
 const getGGBAnswer = (identifiers) => {
     return getEndPoint(identifiers).toGGBCommand();
 };
@@ -108,11 +112,12 @@ export const pointImageFromTranslation = {
     ggbTimer: 60,
     isGGBAnswerValid,
     subject: "Mathématiques",
-    // getHint,
-    // getCorrection,
+    getHint,
+    getCorrection,
     getGGBAnswer,
     getStudentGGBOptions,
     answerType: "GGB",
     options,
     getQuestionFromIdentifiers,
+    // hasHintAndCorrection: true,
 };

package/lib/exercises/math/geometry/pythagore/calculateDiagonalFromSides.d.ts

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    shape: "square" | "rectangle";
+    side: number;
+    side2?: number;
+};
+export declare const calculateDiagonalFromSides: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=calculateDiagonalFromSides.d.ts.map

package/lib/exercises/math/geometry/pythagore/calculateDiagonalFromSides.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"calculateDiagonalFromSides.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/pythagore/calculateDiagonalFromSides.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAerC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,QAAQ,GAAG,WAAW,CAAC;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAqJF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAkB5D,CAAC"}

package/lib/exercises/math/geometry/pythagore/calculateDiagonalFromSides.js

@@ -0,0 +1,155 @@
+import { addValidProp, shuffleProps, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { round } from "../../../../math/utils/round.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { tryToAddWrongProp } from "../../../../exercises/exercise.js";
+import { sqrt } from "../../../../tree/nodes/functions/sqrtNode.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { numberVEA } from "../../../../exercises/vea/numberVEA.js";
+import { numberParser } from "../../../../tree/parsers/numberParser.js";
+const getPropositions = (n, { answer, side, side2, shape }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    if (shape === "square") {
+        tryToAddWrongProp(propositions, frac(side, 2).simplify().toTex());
+        tryToAddWrongProp(propositions, multiply(side, 2).simplify().toTex());
+    }
+    else {
+        tryToAddWrongProp(propositions, frac(multiply(side, side2), 2).simplify().toTex());
+        tryToAddWrongProp(propositions, multiply(side, side2).simplify().toTex());
+    }
+    while (propositions.length < n) {
+        tryToAddWrongProp(propositions, sqrt(2 * randint(2, 15) ** 2)
+            .simplify()
+            .toTex());
+    }
+    return shuffleProps(propositions, n);
+};
+const getAnswerNode = (identifiers) => {
+    const { shape, side, side2 } = identifiers;
+    if (shape === "square") {
+        return sqrt(2 * side ** 2).simplify();
+    }
+    else {
+        return sqrt(side ** 2 + side2 ** 2).simplify();
+    }
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).toTex();
+};
+const getInstruction = ({ shape, side, side2, }) => {
+    if (shape === "square") {
+        return `On considère un carré de côté $${side}$.
+
+Calculer la longueur de la diagonale de ce carré.`;
+    }
+    else {
+        return `On considère un rectangle de largeur $${side}$ et de longueur $${side2}$.
+    
+Calculer la longueur de la diagonale de ce rectangle.`;
+    }
+};
+const getHint = ({ shape }) => {
+    return `Utilise le théorème de Pythagore : dans un triangle $ABC$ rectangle en $A$, 
+
+$$
+BC^2 = AB^2 + AC^2
+$$
+`;
+};
+const getCorrection = ({ shape, side, side2 }) => {
+    const answer = getAnswer({ shape, side, side2 });
+    if (shape === "square") {
+        return `Dans un carré, tous les côtés sont égaux, et deux côtés consécutifs forment un angle droit. 
+    
+Le triangle formé par une diagonale du carré et deux côtés consécutifs est donc un triangle rectangle, dont la diagonale est l'hypoténuse. Les deux autres côtés mesurent $${side}$. 
+
+D'après le théorème de Pythagore, le carré de l'hypoténuse est donc égal à :
+
+$$
+${side}^2 + ${side}^2 = ${2 * side ** 2}
+$$
+
+La diagonale du carré a donc une longueur de : 
+
+$$
+${sqrt(2 * side ** 2).toSimplificationTex()}
+$$`;
+    }
+    else {
+        return `Dans un rectangle, tous les angles sont des angles droits.
+    
+Le triangle formé par une diagonale du rectangle et deux côtés consécutifs est donc un triangle rectangle, dont la diagonale est l'hypoténuse. Les deux autres côtés mesurent $${side}$ et $${side2}$. 
+
+D'après le théorème de Pythagore, le carré de l'hypoténuse est donc égal à :
+
+$$
+${side}^2 + ${side2}^2 = ${side ** 2 + side2 ** 2}
+$$
+
+La diagonale du rectangle a donc une longueur de : 
+
+$$
+${sqrt(side ** 2 + side2 ** 2).toSimplificationTex()}
+$$`;
+    }
+};
+const getKeys = () => [];
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
+    try {
+        const nbParse = numberParser(ans, 2);
+        if (nbParse !== false) {
+            const ev = round(getAnswerNode(identifiers).evaluate(), 2).frenchify();
+            return numberVEA(ans, ev, 2);
+        }
+        else {
+            const ansNode = parseAlgebraic(ans);
+            const answerNode = parseAlgebraic(answer);
+            return ansNode.simplify().equals(answerNode.simplify());
+        }
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getCalculateDiagonalFromSidesQuestion = () => {
+    const caseType = coinFlip() ? "square" : "rectangle";
+    let side = randint(2, 15);
+    let side2 = undefined;
+    if (caseType === "rectangle") {
+        side2 = randint(2, 15);
+    }
+    return getQuestionFromIdentifiers({ shape: caseType, side, side2 });
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const calculateDiagonalFromSides = {
+    id: "calculateDiagonalFromSides",
+    label: "Calculer la longueur de la diagonale d'un carré ou d'un rectangle à partir de la longueur de ses côtés",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getCalculateDiagonalFromSidesQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -1,4 +1,5 @@
 export * from "./pythagore.js";
 export * from "./pythagoreCalcul.js";
 export * from "./isTriangleRight.js";
+export * from "./calculateDiagonalFromSides.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/pythagore/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/pythagore/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,iCAAiC,CAAC"}

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

@@ -1,3 +1,5 @@
 export * from "./pythagore.js";
 export * from "./pythagoreCalcul.js";
 export * from "./isTriangleRight.js";
+export * from "./calculateDiagonalFromSides.js";
+// export * from "./triangleHeight.js";

package/lib/exercises/math/geometry/pythagore/pythagoreCalcul.js

@@ -93,7 +93,7 @@ $$
 const getGGBOptions = (identifiers) => {
     const { sideAsked, triangleIdentifiers } = identifiers;
     const triangle = RightTriangleConstructor.fromIdentifiers(triangleIdentifiers);
-    triangle.showSidesLength([sideAsked]);
+    // triangle.showSidesLength([sideAsked]);
     const commands = [...triangle.commands];
     const ggb = new GeogebraConstructor({
         commands,

package/lib/exercises/math/geometry/pythagore/triangleHeight.d.ts

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    isEqui: boolean;
+    side: number;
+    base?: number;
+};
+export declare const triangleHeight: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=triangleHeight.d.ts.map

package/lib/exercises/math/geometry/pythagore/triangleHeight.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"triangleHeight.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/pythagore/triangleHeight.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,OAAO,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,CAAC;AAyFF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAkBhD,CAAC"}