math-exercises 3.0.213 → 3.0.215

package/lib/exercises/math/geometry/vectors/constructions/traceVectorSumFromVecs.js

@@ -0,0 +1,165 @@
+import { toolBarConstructor } from "../../../../../exercises/utils/geogebra/toolBarConstructor.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { blueMain, greenMain, orange } from "../../../../../geogebra/colors.js";
+import { GeogebraConstructor } from "../../../../../geogebra/geogebraConstructor.js";
+import { GeogebraParser } from "../../../../../geogebra/parsers/geogebraParser.js";
+import { PointConstructor, } from "../../../../../math/geometry/point.js";
+import { VectorConstructor } from "../../../../../math/geometry/vector.js";
+const getHydrated = (identifiers) => {
+    const { pointIds } = identifiers;
+    const points = pointIds.map((pointIds) => PointConstructor.fromIdentifiers(pointIds));
+    const vec1 = (() => {
+        const vec = VectorConstructor.fromPoints(points[0], points[1]);
+        vec.name = "u";
+        return vec;
+    })();
+    const vec2 = (() => {
+        const vec = VectorConstructor.fromPoints(points[2], points[3]);
+        vec.name = "v";
+        return vec;
+    })();
+    const vecSum = vec1.add(vec2);
+    return {
+        points,
+        vec1,
+        vec2,
+        vecSum,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { vec1, vec2 } = getHydrated(identifiers);
+    return `Construire le vecteur $\\overrightarrow{w}$ tel que : 
+  
+$$
+\\overrightarrow{w} = ${vec1.toTex()} + ${vec2.toTex()}
+$$`;
+};
+const getGGBAnswer = (identifiers) => {
+    const { points, vecSum } = getHydrated(identifiers);
+    const pointStart = points[0];
+    const pointEnd = vecSum.getEndPoint(pointStart);
+    return [
+        ...getStudentGGBCommands(points),
+        `PEnd = Point({${pointEnd.getXnumber()},${pointEnd.getYnumber()}})`,
+        `w = Vector(${points[0].name}, PEnd)`,
+        `SetColor(w, "${greenMain}")`,
+        `ShowLabel(w, true)`,
+    ];
+};
+const getHint = () => {
+    return `Avec l'outil vecteur, choisis un point sur la grille et, en partant de ce point, déplace toi suivant le vecteur $\\overrightarrow{u}$ puis suivant le vecteur $\\overrightarrow{v}$ et clique sur le point où tu es arrivé.`;
+};
+const getCorrection = (_identifiers) => {
+    return `Avec l'outil vecteur, on choisit un point sur la grille et, en partant de ce point, on se déplace suivant le vecteur $\\overrightarrow{u}$ puis suivant le vecteur $\\overrightarrow{v}$ et on clique sur le point où l'on est arrivé.`;
+};
+const getCorrectionGGBOptions = (identifiers) => {
+    const { points, vecSum } = getHydrated(identifiers);
+    const pointStart = points[0];
+    const pointEnd = vecSum.getEndPoint(pointStart);
+    const commands = [
+        ...getStudentGGBCommands(points),
+        `PEnd = Point({${pointEnd.getXnumber()},${pointEnd.getYnumber()}})`,
+        `w = Vector(${points[0].name}, PEnd)`,
+        `SetColor(w, "${greenMain}")`,
+        `ShowLabel(w, true)`,
+    ];
+    const ggb = new GeogebraConstructor({
+        commands,
+        customToolBar: toolBarConstructor({
+            vector: true,
+        }),
+        hideAxes: true,
+        fontSize: 16,
+    });
+    return ggb.getOptions({
+        coords: ggb.getCoordsForPoints([...points, pointEnd]),
+    });
+};
+const getStudentGGBCommands = (points) => {
+    return [
+        ...points.flatMap((point) => point.toGGBCommand({ isFixed: true, isVisible: false })),
+        `u = Vector(${points[0].name}, ${points[1].name})`,
+        `SetColor(u, "${orange}")`,
+        `ShowLabel(u, true)`,
+        `v = Vector(${points[2].name}, ${points[3].name})`,
+        `SetColor(v, "${blueMain}")`,
+        `ShowLabel(v, true)`,
+    ];
+};
+const getStudentGGBOptions = (identifiers) => {
+    const { points, vecSum } = getHydrated(identifiers);
+    const pointStart = points[0];
+    const pointEnd = vecSum.getEndPoint(pointStart);
+    const commands = [...getStudentGGBCommands(points)];
+    const ggb = new GeogebraConstructor({
+        commands,
+        customToolBar: toolBarConstructor({
+            vector: true,
+        }),
+        hideAxes: true,
+        fontSize: 16,
+    });
+    return ggb.getOptions({
+        coords: ggb.getCoordsForPoints([...points, pointEnd]),
+    });
+};
+const isGGBAnswerValid = (ans, { ggbAnswer, ...identifiers }) => {
+    const commands = ans;
+    const ggbParser = new GeogebraParser(commands);
+    const objectDict = ggbParser.objectDict();
+    const arrStrVector = Object.entries(objectDict)
+        .filter(([_, strObj]) => strObj.startsWith("Vector"))
+        .map(([_, strObj]) => strObj);
+    //required: only one vector
+    if (arrStrVector.length !== 1) {
+        return false;
+    }
+    const [strVector] = arrStrVector;
+    const [namePointStart, namePointEnd] = GeogebraParser.argNamesForVectorObj(strVector);
+    const [pointStart, pointEnd] = [namePointStart, namePointEnd].map((namePoint) => PointConstructor.fromCoords(ggbParser.pointCoords(namePoint)));
+    const vecAns = VectorConstructor.fromPoints(pointStart, pointEnd);
+    const { vecSum } = getHydrated(identifiers);
+    const isSameVecs = vecAns.substract(vecSum).getNorm().evaluate() < 0.2;
+    return isSameVecs;
+};
+const getTraceVectorSumFromVecsQuestion = () => {
+    const names = ["A", "B", "C", "D"];
+    const points = PointConstructor.randomDifferent(4, {
+        minDistance: 2,
+        names,
+        minDistanceToOrigin: 3,
+    });
+    const identifiers = {
+        pointIds: points.map((point) => point.toIdentifiers()),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        ggbAnswer: getGGBAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        studentGgbOptions: getStudentGGBOptions(identifiers),
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        correctionGgbOptions: getCorrectionGGBOptions(identifiers),
+    };
+    return question;
+};
+export const traceVectorSumFromVecs = {
+    id: "traceVectorSumFromVecs",
+    label: "Construire un vecteur défini par une somme de vecteurs",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getTraceVectorSumFromVecsQuestion(opts), nb),
+    ggbTimer: 60,
+    isGGBAnswerValid,
+    subject: "Mathématiques",
+    getHint,
+    getInstruction,
+    getCorrection,
+    getGGBAnswer,
+    getStudentGGBOptions,
+    answerType: "GGB",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -6,4 +6,5 @@ export * from "./coneVolume.js";
 export * from "./sphereVolume.js";
 export * from "./parallelepipedVolume.js";
 export * from "./variableVolume.js";
+export * from "./volumeOfCylinder.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/volumes/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,0CAA0C,CAAC;AACzD,cAAc,0CAA0C,CAAC;AACzD,cAAc,sCAAsC,CAAC;AACrD,cAAc,iBAAiB,CAAC;AAChC,cAAc,mBAAmB,CAAC;AAClC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,qBAAqB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/volumes/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,0CAA0C,CAAC;AACzD,cAAc,0CAA0C,CAAC;AACzD,cAAc,sCAAsC,CAAC;AACrD,cAAc,iBAAiB,CAAC;AAChC,cAAc,mBAAmB,CAAC;AAClC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,qBAAqB,CAAC;AACpC,cAAc,uBAAuB,CAAC"}

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

@@ -6,3 +6,4 @@ export * from "./coneVolume.js";
 export * from "./sphereVolume.js";
 export * from "./parallelepipedVolume.js";
 export * from "./variableVolume.js";
+export * from "./volumeOfCylinder.js";

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"volumeOfCylinder.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/volumes/volumeOfCylinder.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AA2KF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAelD,CAAC"}

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

@@ -0,0 +1,157 @@
+import { addValidProp, propWhile, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { round } from "../../../../math/utils/round.js";
+import { numberParser } from "../../../../tree/parsers/numberParser.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const getInstruction = (identifiers) => {
+    const { radius, height } = identifiers;
+    return `Le cylindre ci-dessous a une base de rayon $${radius}$ et une hauteur de $${height}$. 
+  
+Calculer son volume (arrondir au centième).`;
+};
+const getHint = (identifiers) => {
+    const { radius } = identifiers;
+    return `Le volume d'un cylindre se calcule avec la formule : 
+  
+$$
+\\mathcal{V} = \\text{aire de la base} \\times \\text{hauteur}
+$$
+
+La base est un disque de rayon $${radius}$. Il faut donc commencer par calculer son aire. 
+`;
+};
+const getCorrection = (identifiers) => {
+    const { radius, height } = identifiers;
+    round((1 / 3) * Math.PI * Math.pow(radius, 2) * height, 2).toTree();
+    const area = round(Math.PI * radius ** 2, 2).frenchify();
+    return `Le volume d'un cylindre se calcule avec la formule : 
+  
+$$
+\\mathcal{V} = \\text{aire de la base} \\times \\text{hauteur}
+$$
+
+Ici, la base est un disque de rayon $${radius}$. Son aire est donc : 
+
+$$
+\\mathcal{A} = \\pi\\times ${radius}^2 \\approx ${area}
+$$
+
+Le volume du cylindre est donc : 
+
+${alignTex([
+        [
+            "\\mathcal{V}",
+            "\\approx",
+            `${area} \\times ${height} = ${getAnswer(identifiers)}`,
+        ],
+        ["", "\\approx", getAnswer(identifiers)],
+    ])}
+`;
+};
+const getAnswer = (identifiers) => {
+    const { radius, height } = identifiers;
+    const volume = round(Math.PI * Math.pow(radius, 2) * height, 2)
+        .toTree()
+        .toTex();
+    return volume;
+};
+const getGGBOptions = (identifiers) => {
+    const { radius, height } = identifiers;
+    const xMin = -radius - 5;
+    const xMax = radius + 5;
+    const yMin = -radius - 5;
+    const yMax = radius + 5;
+    const zMax = height + 5;
+    const commands = [
+        `A = (0, 0, 0)`,
+        `B = (0, 0, ${height})`,
+        `SetFixed(A, true, false)`,
+        `SetFixed(B, true, false)`,
+        `SetVisibleInView(A, -1, false)`,
+        `SetVisibleInView(B, -1, false)`,
+        `Cylinder(A, B, ${radius})`,
+    ];
+    const ggb = new GeogebraConstructor({
+        commands,
+        lockedAxesRatio: false,
+        hideAxes: true,
+        hideGrid: true,
+        is3D: true,
+    });
+    return ggb.getOptions({
+        coords: [xMin, xMax, yMin, yMax, 0, zMax],
+    });
+};
+const getPropositions = (n, { answer, radius, height }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const wrongVolume1 = round(Math.PI * Math.pow(radius, 2) * height, 2)
+        .toTree()
+        .toTex();
+    tryToAddWrongProp(propositions, wrongVolume1);
+    const wrongVolume2 = round(Math.PI * radius * height, 2)
+        .toTree()
+        .toTex();
+    tryToAddWrongProp(propositions, wrongVolume2);
+    const wrongVolume3 = round((1 / 3) * Math.PI * Math.pow(radius, 2) * height, 2)
+        .toTree()
+        .toTex();
+    tryToAddWrongProp(propositions, wrongVolume3);
+    propWhile(propositions, n, () => {
+        let wrongRadius, wrongHeight;
+        do {
+            wrongRadius = randint(1, 5);
+            wrongHeight = randint(2, 10);
+        } while (wrongHeight <= wrongRadius);
+        const wrongVolume = round(Math.PI * Math.pow(wrongRadius, 2) * wrongHeight, 2)
+            .toTree()
+            .toTex();
+        tryToAddWrongProp(propositions, wrongVolume);
+    });
+    return shuffleProps(propositions, n);
+};
+const isAnswerValid = (ans, { answer }) => {
+    const parsed = numberParser(ans);
+    if (!parsed)
+        return false;
+    return parsed === answer;
+};
+const getVolumeOfCylinderQuestion = () => {
+    let radius, height;
+    do {
+        radius = randint(1, 11);
+        height = randint(2, 12);
+    } while (height <= radius);
+    const identifiers = { radius, height };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        ggbOptions: getGGBOptions(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const volumeOfCylinder = {
+    id: "volumeOfCylinder",
+    label: "Calculer le volume d'un cylindre de hauteur et de rayon donnés",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getVolumeOfCylinderQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    hasGeogebra: true,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    shouldHaveCalculator: true,
+};

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

@@ -6,4 +6,5 @@ export * from "./spaceCoordinatesOfPointInCubeCoordSystemFromVecPath.js";
 export * from "./spaceVectorLinearCombinationFromCoords.js";
 export * from "./lineLineRelativePositionsFromCubeOuterPoints.js";
 export * from "./linePlaneRelativePositionsFromCubeOuterPoints.js";
+export * from "./spaceSegmentLengthInRectangularPrism.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/basis/index.ts"],"names":[],"mappings":"AAAA,cAAc,8BAA8B,CAAC;AAC7C,cAAc,uCAAuC,CAAC;AACtD,cAAc,+CAA+C,CAAC;AAC9D,cAAc,gDAAgD,CAAC;AAC/D,cAAc,0DAA0D,CAAC;AACzE,cAAc,6CAA6C,CAAC;AAC5D,cAAc,mDAAmD,CAAC;AAClE,cAAc,oDAAoD,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/basis/index.ts"],"names":[],"mappings":"AAAA,cAAc,8BAA8B,CAAC;AAC7C,cAAc,uCAAuC,CAAC;AACtD,cAAc,+CAA+C,CAAC;AAC9D,cAAc,gDAAgD,CAAC;AAC/D,cAAc,0DAA0D,CAAC;AACzE,cAAc,6CAA6C,CAAC;AAC5D,cAAc,mDAAmD,CAAC;AAClE,cAAc,oDAAoD,CAAC;AACnE,cAAc,2CAA2C,CAAC"}

package/lib/exercises/math/spaceGeometry/basis/index.js

@@ -6,3 +6,4 @@ export * from "./spaceCoordinatesOfPointInCubeCoordSystemFromVecPath.js";
 export * from "./spaceVectorLinearCombinationFromCoords.js";
 export * from "./lineLineRelativePositionsFromCubeOuterPoints.js";
 export * from "./linePlaneRelativePositionsFromCubeOuterPoints.js";
+export * from "./spaceSegmentLengthInRectangularPrism.js";

package/lib/exercises/math/spaceGeometry/basis/spaceSegmentLengthInRectangularPrism.d.ts

@@ -0,0 +1,18 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { SpacePointIdentifiers } from "../../../../math/geometry/spacePoint.js";
+/**********/
+type Identifiers = {
+    rectangularPrismOrigin: SpacePointIdentifiers;
+    L: number;
+    l: number;
+    h: number;
+    arrSegmentSpacePointIds: SpacePointIdentifiers[];
+    acceptedInputType: string;
+};
+type Options = {
+    acceptedInputType: string;
+    nbComponents: string;
+};
+export declare const spaceSegmentLengthInRectangularPrism: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=spaceSegmentLengthInRectangularPrism.d.ts.map

package/lib/exercises/math/spaceGeometry/basis/spaceSegmentLengthInRectangularPrism.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spaceSegmentLengthInRectangularPrism.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/basis/spaceSegmentLengthInRectangularPrism.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAoBT,MAAM,6BAA6B,CAAC;AASrC,OAAO,EAGL,qBAAqB,EACtB,MAAM,mCAAmC,CAAC;AA2N3C,YAAY;AAEZ,KAAK,WAAW,GAAG;IAEjB,sBAAsB,EAAE,qBAAqB,CAAC;IAC9C,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IAEV,uBAAuB,EAAE,qBAAqB,EAAE,CAAC;IACjD,iBAAiB,EAAE,MAAM,CAAC;CAC3B,CAAC;AAojBF,KAAK,OAAO,GAAG;IACb,iBAAiB,EAAE,MAAM,CAAC;IAC1B,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AAmCF,eAAO,MAAM,oCAAoC,EAAE,QAAQ,CACzD,WAAW,EACX,OAAO,CAsBR,CAAC"}