math-exercises 2.1.21 → 2.1.24

package/lib/exercises/math/geometry/volumes/volumeOfCube.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.volumeOfCube = void 0;
+const exercise_1 = require("../../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
+const geogebraConstructor_1 = require("../../../../geogebra/geogebraConstructor");
+const randint_1 = require("../../../../math/utils/random/randint");
+const powerNode_1 = require("../../../../tree/nodes/operators/powerNode");
+const getVolumeOfCubeQuestion = () => {
+    const cubeSide = (0, randint_1.randint)(1, 21);
+    const commands = [
+        `A=Point({0,0,0})`,
+        `B=Point({0,0,${cubeSide}})`,
+        `C=Point({${cubeSide},0,${cubeSide}})`,
+        `ShowLabel(A,true)`,
+        `ShowLabel(B,true)`,
+        `ShowLabel(C,true)`,
+        `P=Cube(A,B,C)`,
+    ];
+    const ggb = new geogebraConstructor_1.GeogebraConstructor(commands, {
+        is3D: true,
+        hideAxes: true,
+        hideGrid: true,
+    });
+    const question = {
+        answer: Math.pow(cubeSide, 3) + "",
+        instruction: `$ABCDEFGH$ est un cube d'arête $${cubeSide}$. Calculer son volume.`,
+        keys: [],
+        answerFormat: "tex",
+        commands: ggb.commands,
+        options: ggb.getOptions(),
+        coords: [0, cubeSide + 1, 0, cubeSide + 1, 0, cubeSide + 1],
+        identifiers: { cubeSide },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, cubeSide }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    generatePropositions(cubeSide).forEach((value) => (0, exercise_1.tryToAddWrongProp)(propositions, value));
+    const correctAns = Math.pow(cubeSide, 3);
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, (0, randint_1.randint)(correctAns - 10, correctAns + 10, [correctAns]) + "");
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { answer, cubeSide }) => {
+    const powerNode = new powerNode_1.PowerNode(cubeSide.toTree(), (3).toTree());
+    return [answer, ...powerNode.toAllValidTexs()].includes(ans);
+};
+const generatePropositions = (cubeSide) => {
+    const firstProposition = Math.pow(cubeSide, 2) * 6;
+    const secondProposition = Math.pow(cubeSide, 2);
+    return [firstProposition + "", secondProposition + ""];
+};
+exports.volumeOfCube = {
+    id: "volumeOfCube",
+    label: "Calcul du volume d'un cube",
+    levels: ["2nde"],
+    isSingleStep: true,
+    sections: ["Géométrie euclidienne"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getVolumeOfCubeQuestion, nb, 15),
+    maxAllowedQuestions: 15,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    hasGeogebra: true,
+    subject: "Mathématiques",
+};

package/lib/exercises/math/geometry/volumes/volumeOfPyramidWithSquareOrRectBase.d.ts

@@ -0,0 +1,12 @@
+import { Exercise } from "../../../../exercises/exercise";
+type Identifiers = {
+    h: number;
+    baseOfPyramid: Polygon;
+};
+type Polygon = {
+    type: string;
+    sideSizes: number[];
+};
+export declare const volumeOfPyramidWithSquareOrRectBase: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=volumeOfPyramidWithSquareOrRectBase.d.ts.map

package/lib/exercises/math/geometry/volumes/volumeOfPyramidWithSquareOrRectBase.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"volumeOfPyramidWithSquareOrRectBase.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/volumes/volumeOfPyramidWithSquareOrRectBase.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAclC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,aAAa,EAAE,OAAO,CAAC;CACxB,CAAC;AAQF,KAAK,OAAO,GAAG;IACb,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,EAAE,CAAC;CACrB,CAAC;AA0JF,eAAO,MAAM,mCAAmC,EAAE,QAAQ,CAAC,WAAW,CAcrE,CAAC"}

package/lib/exercises/math/geometry/volumes/volumeOfPyramidWithSquareOrRectBase.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.volumeOfPyramidWithSquareOrRectBase = void 0;
+const exercise_1 = require("../../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
+const geogebraConstructor_1 = require("../../../../geogebra/geogebraConstructor");
+const rational_1 = require("../../../../math/numbers/rationals/rational");
+const randint_1 = require("../../../../math/utils/random/randint");
+const numberNode_1 = require("../../../../tree/nodes/numbers/numberNode");
+const fractionNode_1 = require("../../../../tree/nodes/operators/fractionNode");
+const multiplyNode_1 = require("../../../../tree/nodes/operators/multiplyNode");
+const random_1 = require("../../../../utils/random");
+const polygonTypes = ["Square", "Rectangular"];
+const getVolumeOfPyramidWithSquareOrRectBaseQuestion = () => {
+    const exercise = generateExercise();
+    const baseOfPyramid = exercise.baseOfPyramid;
+    const commands = exercise.ggbCommands;
+    const ggb = new geogebraConstructor_1.GeogebraConstructor(commands, {
+        hideAxes: true,
+        hideGrid: true,
+        is3D: true,
+    });
+    const h = exercise.h;
+    const instruction = `$ABCDH$ est une pyramide à base ${getPolygonNameInFr(baseOfPyramid.type)} de hauteur $${h}$. Calculer son volume en sachant que : ${baseOfPyramid.type === "Square"
+        ? `$AB=${baseOfPyramid.sideSizes[0]}$`
+        : `$AB=${baseOfPyramid.sideSizes[0]}$ et $BC=${baseOfPyramid.sideSizes[1]}$`}.`;
+    const volume = calculateVolume(baseOfPyramid.sideSizes, h).simplify();
+    const maxCoord = Math.max(baseOfPyramid.sideSizes[0], baseOfPyramid.sideSizes[1]);
+    const question = {
+        answer: volume.toTex(),
+        instruction: instruction,
+        keys: [],
+        answerFormat: "tex",
+        commands: ggb.commands,
+        coords: [-2, maxCoord + 1, -2, maxCoord + 1, -2, exercise.h + 1],
+        options: ggb.getOptions(),
+        identifiers: { h, baseOfPyramid },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, h, baseOfPyramid }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    generatePropositions(baseOfPyramid, h).forEach((value) => (0, exercise_1.tryToAddWrongProp)(propositions, value));
+    const volume = calculateVolume(baseOfPyramid.sideSizes, h).simplify();
+    let random;
+    while (propositions.length < n) {
+        random = (0, numberNode_1.isNumberNode)(volume)
+            ? (0, randint_1.randint)(volume.value - 5, volume.value + 5, [volume.value]).toTree()
+            : rational_1.RationalConstructor.randomIrreductible();
+        (0, exercise_1.tryToAddWrongProp)(propositions, random.toTex());
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { baseOfPyramid, h }) => {
+    const volume = calculateVolume(baseOfPyramid.sideSizes, h);
+    return volume.simplify().toAllValidTexs().includes(ans);
+};
+const generatePropositions = (baseOfPyramid, h) => {
+    const firstProposition = h * baseOfPyramid.sideSizes[0] * baseOfPyramid.sideSizes[1] + "";
+    const secondProposition = new fractionNode_1.FractionNode(((baseOfPyramid.sideSizes[0] + baseOfPyramid.sideSizes[1]) *
+        2 *
+        h).toTree(), (3).toTree())
+        .simplify()
+        .toTex();
+    return [firstProposition, secondProposition];
+};
+const generateExercise = () => {
+    const h = (0, randint_1.randint)(1, 11);
+    const polygonType = (0, random_1.random)(polygonTypes);
+    const base = generatePolygonWithGgbCmnds(polygonType);
+    const ggbCommands = base.commands.concat([
+        `H=Point({${base.sideSizes[0] / 2},${base.sideSizes[1] / 2},${h}})`,
+        `SetFixed(H,true)`,
+        `ShowLabel(H,true)`,
+        `Pyra=Pyramid(Poly,H)`,
+    ]);
+    return {
+        ggbCommands,
+        h,
+        baseOfPyramid: { sideSizes: base.sideSizes, type: polygonType },
+    };
+};
+const calculateVolume = (baseOfPyramidSides, h) => {
+    return new multiplyNode_1.MultiplyNode(new fractionNode_1.FractionNode((1).toTree(), (3).toTree()), (baseOfPyramidSides[0] * baseOfPyramidSides[1] * h).toTree());
+};
+const generatePolygonWithGgbCmnds = (polygonType) => {
+    let sideOne = 0;
+    let sideTwo = 0;
+    switch (polygonType) {
+        case "Square":
+            const randomSide = (0, randint_1.randint)(1, 10);
+            sideOne = randomSide;
+            sideTwo = randomSide;
+            break;
+        case "Rectangular":
+            sideOne = (0, randint_1.randint)(1, 11);
+            sideTwo = (0, randint_1.randint)(1, 11, [sideOne]);
+            break;
+    }
+    return {
+        commands: [
+            `A=Point({0,0,0})`,
+            `B=Point({${sideOne},0,0})`,
+            `C=Point({${sideOne},${sideTwo},0})`,
+            `D=Point({0,${sideTwo},0})`,
+            `ShowLabel(A,true)`,
+            `ShowLabel(B,true)`,
+            `ShowLabel(C,true)`,
+            `ShowLabel(D,true)`,
+            `SetFixed(A,true)`,
+            `SetFixed(B,true)`,
+            `SetFixed(C,true)`,
+            `SetFixed(D,true)`,
+            `Poly=Polygon(A,B,C,D)`,
+        ],
+        sideSizes: [sideOne, sideTwo],
+    };
+};
+const getPolygonNameInFr = (polygonType) => {
+    switch (polygonType) {
+        case "Square":
+            return "carrée";
+        case "Rectangular":
+            return "rectangulaire";
+        default:
+            return "";
+    }
+};
+exports.volumeOfPyramidWithSquareOrRectBase = {
+    id: "volumeOfPyramidWithSquareOrRectBase",
+    label: "Calcul de volume d'une pyramide à base carrée ou rectangulaire",
+    levels: ["2nde"],
+    isSingleStep: true,
+    sections: ["Géométrie euclidienne"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getVolumeOfPyramidWithSquareOrRectBaseQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    hasGeogebra: true,
+    subject: "Mathématiques",
+};

package/lib/exercises/math/geometry/volumes/volumeOfPyramidWithTriangleBase.d.ts

@@ -0,0 +1,13 @@
+import { Exercise } from "../../../../exercises/exercise";
+type Identifiers = {
+    h: number;
+    baseOfPyramidSides: TriangleSides;
+};
+type TriangleSides = {
+    ABSide: number;
+    ACSide: number;
+    BCSide: number;
+};
+export declare const volumeOfPyramidWithTriangleBase: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=volumeOfPyramidWithTriangleBase.d.ts.map

package/lib/exercises/math/geometry/volumes/volumeOfPyramidWithTriangleBase.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"volumeOfPyramidWithTriangleBase.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/volumes/volumeOfPyramidWithTriangleBase.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAWlC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,kBAAkB,EAAE,aAAa,CAAC;CACnC,CAAC;AASF,KAAK,aAAa,GAAG;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAiKF,eAAO,MAAM,+BAA+B,EAAE,QAAQ,CAAC,WAAW,CAcjE,CAAC"}

package/lib/exercises/math/geometry/volumes/volumeOfPyramidWithTriangleBase.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.volumeOfPyramidWithTriangleBase = void 0;
+const exercise_1 = require("../../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
+const geogebraConstructor_1 = require("../../../../geogebra/geogebraConstructor");
+const rational_1 = require("../../../../math/numbers/rationals/rational");
+const randint_1 = require("../../../../math/utils/random/randint");
+const numberNode_1 = require("../../../../tree/nodes/numbers/numberNode");
+const fractionNode_1 = require("../../../../tree/nodes/operators/fractionNode");
+const multiplyNode_1 = require("../../../../tree/nodes/operators/multiplyNode");
+const random_1 = require("../../../../utils/random");
+const pythagoreTriplet = [
+    [5, 12, 13],
+    [8, 15, 17],
+    [7, 24, 25],
+    [20, 21, 29],
+    [12, 35, 37],
+    [9, 40, 41],
+    [28, 45, 53],
+    [11, 60, 61],
+    [16, 63, 65],
+];
+const getVolumeOfPyramidWithTriangleBaseQuestion = () => {
+    const exercise = generateExercise();
+    const commands = exercise.ggbCommands;
+    const baseOfPyramidSides = exercise.baseOfPyramidSides;
+    const volume = calculateVolume(baseOfPyramidSides, exercise.h);
+    const ggb = new geogebraConstructor_1.GeogebraConstructor(commands, {
+        hideAxes: true,
+        hideGrid: true,
+        is3D: true,
+    });
+    const maxCoord = Math.max(baseOfPyramidSides.ABSide, baseOfPyramidSides.ACSide);
+    const question = {
+        answer: volume.simplify().toTex(),
+        instruction: `$ABCH$ est une pyramide à base triangulaire de hauteur $${exercise.h}$. Le point $D$ est le pied de la hauteur issue de $C$ dans le triangle $ABC$.
+    Calculer le volume de la pyramide en sachant que $AB=${baseOfPyramidSides.ABSide}$ et $CD=${baseOfPyramidSides.ACSide}$.`,
+        keys: [],
+        answerFormat: "tex",
+        commands: ggb.commands,
+        options: ggb.getOptions(),
+        coords: [
+            exercise.originX,
+            maxCoord + 1,
+            -2,
+            maxCoord + 1,
+            -2,
+            exercise.h + 1,
+        ],
+        identifiers: { h: exercise.h, baseOfPyramidSides },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, baseOfPyramidSides, h }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    generatePropositions(baseOfPyramidSides, h).forEach((value) => (0, exercise_1.tryToAddWrongProp)(propositions, value));
+    const volume = calculateVolume(baseOfPyramidSides, h).simplify();
+    let random;
+    while (propositions.length < n) {
+        random = (0, numberNode_1.isNumberNode)(volume)
+            ? (0, randint_1.randint)(volume.value - 5, volume.value + 5, [volume.value]).toTree()
+            : rational_1.RationalConstructor.randomIrreductible();
+        (0, exercise_1.tryToAddWrongProp)(propositions, random.toTex());
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { h, baseOfPyramidSides }) => {
+    const volume = calculateVolume(baseOfPyramidSides, h);
+    return volume
+        .simplify()
+        .toAllValidTexs({ allowFractionToDecimal: true })
+        .includes(ans);
+};
+const generatePropositions = (baseOfPyramidSides, h) => {
+    const firstProposition = new fractionNode_1.FractionNode((baseOfPyramidSides.ABSide * baseOfPyramidSides.ACSide).toTree(), (3).toTree())
+        .simplify()
+        .toTex();
+    const secondProposition = new fractionNode_1.FractionNode((baseOfPyramidSides.ABSide * baseOfPyramidSides.ACSide * h).toTree(), (2).toTree())
+        .simplify()
+        .toTex();
+    return [firstProposition, secondProposition];
+};
+const calculateVolume = (sideSize, h) => {
+    return new fractionNode_1.FractionNode(new multiplyNode_1.MultiplyNode(new fractionNode_1.FractionNode((sideSize.ABSide * sideSize.ACSide).toTree(), (2).toTree()), h.toTree()), (3).toTree());
+};
+const generateExercise = () => {
+    const h = (0, randint_1.randint)(3, 21);
+    const triangle = generateTriangleWithGGBCommands();
+    const ggbCommands = triangle.commands.concat([
+        `H=Point({0,${triangle.sideSizes.ACSide / 4},${h}})`,
+        `D=Point({0,0,0})`,
+        `ShowLabel(D,true)`,
+        `ShowLabel(H,true)`,
+        `SetFixed(H,true)`,
+        `SetFixed(D,true)`,
+        `Pyra=Pyramid(Poly,H)`,
+    ]);
+    return {
+        ggbCommands,
+        h,
+        baseOfPyramidSides: triangle.sideSizes,
+        originX: triangle.originX,
+    };
+};
+const generateTriangleWithGGBCommands = () => {
+    const rectTriangle = (0, random_1.random)(pythagoreTriplet);
+    const ABSide = rectTriangle[0];
+    const originX = (0, randint_1.randint)(-ABSide + 4, -2);
+    const ACSide = rectTriangle[1];
+    const BCSide = rectTriangle[2];
+    return {
+        commands: [
+            `A=Point({${originX},0,0})`,
+            `B=Point({${ABSide + originX},0,0})`,
+            `C=Point({0,${ACSide},0})`,
+            `ShowLabel(A,True)`,
+            `ShowLabel(B,True)`,
+            `ShowLabel(C,True)`,
+            `SetFixed(A,true)`,
+            `SetFixed(B,true)`,
+            `SetFixed(C,true)`,
+            `Poly=Polygon(A,B,C)`,
+        ],
+        sideSizes: { ABSide, ACSide, BCSide },
+        originX,
+    };
+};
+exports.volumeOfPyramidWithTriangleBase = {
+    id: "volumeOfPyramidWithTriangleBase",
+    label: "Calcul de volume d'une pyramide à base triangulaire",
+    levels: ["2nde"],
+    isSingleStep: true,
+    sections: ["Géométrie euclidienne"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getVolumeOfPyramidWithTriangleBaseQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    hasGeogebra: true,
+    subject: "Mathématiques",
+};

package/lib/exercises/math/geometry/volumes/volumeOfPyramidWithTriangleRectBase.d.ts

@@ -0,0 +1,13 @@
+import { Exercise } from "../../../../exercises/exercise";
+type Identifiers = {
+    h: number;
+    baseOfPyramidSides: TriangleSides;
+};
+type TriangleSides = {
+    ABSide: number;
+    ACSide: number;
+    BCSide: number;
+};
+export declare const volumeOfPyramid: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=volumeOfPyramidWithTriangleRectBase.d.ts.map

package/lib/exercises/math/geometry/volumes/volumeOfPyramidWithTriangleRectBase.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"volumeOfPyramidWithTriangleRectBase.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/volumes/volumeOfPyramidWithTriangleRectBase.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAYlC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,kBAAkB,EAAE,aAAa,CAAC;CACnC,CAAC;AAQF,KAAK,aAAa,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AA0JxE,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAejD,CAAC"}

package/lib/exercises/math/geometry/volumes/volumeOfPyramidWithTriangleRectBase.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.volumeOfPyramid = void 0;
+const exercise_1 = require("../../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
+const geogebraConstructor_1 = require("../../../../geogebra/geogebraConstructor");
+const rational_1 = require("../../../../math/numbers/rationals/rational");
+const randint_1 = require("../../../../math/utils/random/randint");
+const numberNode_1 = require("../../../../tree/nodes/numbers/numberNode");
+const fractionNode_1 = require("../../../../tree/nodes/operators/fractionNode");
+const multiplyNode_1 = require("../../../../tree/nodes/operators/multiplyNode");
+const random_1 = require("../../../../utils/random");
+const pythagoreTriplet = [
+    [3, 4, 5],
+    [5, 12, 13],
+    [8, 15, 17],
+    [7, 24, 25],
+    [20, 21, 29],
+    [12, 35, 37],
+    [9, 40, 41],
+    [28, 45, 53],
+    [11, 60, 61],
+    [16, 63, 65],
+];
+const getVolumeOfPyramidWithTriangleRectBase = () => {
+    const exercise = generateExercise();
+    const commands = exercise.commands;
+    const baseOfPyramidSides = exercise.baseOfPyramidSides;
+    const volume = calculateVolume(baseOfPyramidSides, exercise.h);
+    const ggb = new geogebraConstructor_1.GeogebraConstructor(commands, {
+        hideAxes: true,
+        hideGrid: true,
+        is3D: true,
+    });
+    const maxCoord = Math.max(baseOfPyramidSides.ABSide, baseOfPyramidSides.ACSide);
+    const question = {
+        answer: volume.simplify().toTex(),
+        instruction: `$ABCH$ est une pyramide à base triangulaire de hauteur $${exercise.h}$. 
+    Calculer le volume de la pyramide en sachant que : $AB=${baseOfPyramidSides.ABSide}$, $AC=${baseOfPyramidSides.ACSide}$, $BC=${baseOfPyramidSides.BCSide}$ et $(AC)\\perp(AB)$.`,
+        keys: [],
+        answerFormat: "tex",
+        commands: ggb.commands,
+        options: ggb.getOptions(),
+        coords: [-2, maxCoord + 1, -2, maxCoord + 1, -2, exercise.h + 1],
+        identifiers: { h: exercise.h, baseOfPyramidSides },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, baseOfPyramidSides, h }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    generatePropositions(baseOfPyramidSides, h).forEach((value) => (0, exercise_1.tryToAddWrongProp)(propositions, value));
+    const volume = calculateVolume(baseOfPyramidSides, h).simplify();
+    let random;
+    while (propositions.length < n) {
+        random = (0, numberNode_1.isNumberNode)(volume)
+            ? (0, randint_1.randint)(volume.value - 5, volume.value + 5, [volume.value]).toTree()
+            : rational_1.RationalConstructor.randomIrreductible();
+        (0, exercise_1.tryToAddWrongProp)(propositions, random.toTex());
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { h, baseOfPyramidSides }) => {
+    const volume = calculateVolume(baseOfPyramidSides, h);
+    return volume
+        .simplify()
+        .toAllValidTexs({ allowFractionToDecimal: true })
+        .includes(ans);
+};
+const generatePropositions = (baseOfPyramidSides, h) => {
+    const firstProposition = new fractionNode_1.FractionNode((baseOfPyramidSides.ABSide +
+        baseOfPyramidSides.ACSide +
+        baseOfPyramidSides.BCSide).toTree(), (3).toTree())
+        .simplify()
+        .toTex();
+    const secondProposition = new fractionNode_1.FractionNode((baseOfPyramidSides.ABSide * baseOfPyramidSides.ACSide).toTree(), (2).toTree())
+        .simplify()
+        .toTex();
+    return [firstProposition, secondProposition];
+};
+const generateExercise = () => {
+    const h = (0, randint_1.randint)(1, 11);
+    const base = generatePolygonWithGgbCmnds();
+    const commands = base.commands.concat([
+        `H=Point({${base.sideSizes.ABSide / 4},${base.sideSizes.ACSide / 4},${h}})`,
+        `SetFixed(H,true)`,
+        `ShowLabel(H,true)`,
+        `Pyra=Pyramid(Poly,H)`,
+    ]);
+    return {
+        commands,
+        h,
+        baseOfPyramidSides: base.sideSizes,
+    };
+};
+const calculateVolume = (sideSize, h) => {
+    return new fractionNode_1.FractionNode(new multiplyNode_1.MultiplyNode(new fractionNode_1.FractionNode((sideSize.ABSide * sideSize.ACSide).toTree(), (2).toTree()), h.toTree()), (3).toTree());
+};
+const generatePolygonWithGgbCmnds = () => {
+    const values = (0, random_1.random)(pythagoreTriplet);
+    const ABSide = values[0];
+    const ACSide = values[1];
+    return {
+        commands: [
+            `A=Point({0,0,0})`,
+            `B=Point({${ABSide},0,0})`,
+            `C=Point({0,${ACSide},0})`,
+            `ang=Angle(C,A,B)`,
+            `ShowLabel(ang,false)`,
+            `ShowLabel(A,True)`,
+            `ShowLabel(B,True)`,
+            `ShowLabel(C,True)`,
+            `SetFixed(A,true)`,
+            `SetFixed(B,true)`,
+            `SetFixed(C,true)`,
+            `Poly=Polygon(A,B,C)`,
+        ],
+        sideSizes: { ABSide, ACSide, BCSide: values[2] },
+    };
+};
+exports.volumeOfPyramid = {
+    id: "volumeOfPyramidWithTriangleRectBase",
+    label: "Calcul du volume d'une pyramide dont la base est un triangle rectangle",
+    levels: ["2nde"],
+    isSingleStep: true,
+    sections: ["Géométrie euclidienne"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getVolumeOfPyramidWithTriangleRectBase, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    hasGeogebra: true,
+    subject: "Mathématiques",
+};

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

@@ -18,4 +18,5 @@ export * from "./sets";
 export * from "./squareRoots";
 export * from "./trigonometry";
 export * from "./python";
+export * from "./suites";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/exercises/math/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,kBAAkB,CAAC;AACjC,cAAc,eAAe,CAAC;AAC9B,cAAc,WAAW,CAAC;AAC1B,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAC7B,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC;AAC3B,cAAc,UAAU,CAAC;AACzB,cAAc,YAAY,CAAC;AAC3B,cAAc,WAAW,CAAC;AAC1B,cAAc,UAAU,CAAC;AACzB,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,QAAQ,CAAC;AACvB,cAAc,eAAe,CAAC;AAC9B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,UAAU,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/exercises/math/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,kBAAkB,CAAC;AACjC,cAAc,eAAe,CAAC;AAC9B,cAAc,WAAW,CAAC;AAC1B,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAC7B,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC;AAC3B,cAAc,UAAU,CAAC;AACzB,cAAc,YAAY,CAAC;AAC3B,cAAc,WAAW,CAAC;AAC1B,cAAc,UAAU,CAAC;AACzB,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,QAAQ,CAAC;AACvB,cAAc,eAAe,CAAC;AAC9B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC"}

package/lib/exercises/math/index.js

@@ -34,3 +34,4 @@ __exportStar(require("./sets"), exports);
 __exportStar(require("./squareRoots"), exports);
 __exportStar(require("./trigonometry"), exports);
 __exportStar(require("./python"), exports);
+__exportStar(require("./suites"), exports);

package/lib/exercises/math/suites/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./sequenceEvaluation";
+export * from "./sequencePlot";
+//# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/suites/index.d.ts.map

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

package/lib/exercises/{calcul/rounding → math/suites}/index.js

@@ -14,4 +14,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./rounding"), exports);
+__exportStar(require("./sequenceEvaluation"), exports);
+__exportStar(require("./sequencePlot"), exports);

package/lib/exercises/math/suites/sequenceEvaluation.d.ts

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../exercises/exercise";
+type Identifiers = {
+    termeid: number;
+    affine: number[];
+    termeAdd: number;
+    termeMult: number;
+};
+export declare const sequenceEvaluation: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=sequenceEvaluation.d.ts.map

package/lib/exercises/math/suites/sequenceEvaluation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sequenceEvaluation.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/suites/sequenceEvaluation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAYlC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAoLF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAapD,CAAC"}