math-exercises 3.0.151 → 3.0.153

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

@@ -0,0 +1,406 @@
+import { GeneratorOptionType, GeneratorOptionTarget, } from "../../../../exercises/exercise.js";
+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 { ggbPointToCoords } from "../../../../geogebra/parsers/ggbPointToCoords.js";
+import { parseGGBPoints } from "../../../../geogebra/parsers/parseGGBPoints.js";
+import { Point, PointConstructor, } from "../../../../math/geometry/point.js";
+import { Vector, VectorConstructor } from "../../../../math/geometry/vector.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { round } from "../../../../math/utils/round.js";
+import { PiNode } from "../../../../tree/nodes/numbers/piNode.js";
+import { add } from "../../../../tree/nodes/operators/addNode.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";
+import { probaFlip } from "../../../../utils/alea/probaFlip.js";
+import { random, randomMany } from "../../../../utils/alea/random.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { arrayRotation } from "../../../../utils/arrays/rotation.js";
+function createSnowflakeDict(namesPool, angleInDegreesOffset = 0) {
+    function* generateNames(namesPool) {
+        let i = 0;
+        while (i < namesPool.length) {
+            yield namesPool[i];
+            i++;
+        }
+    }
+    const nameGen = generateNames(namesPool);
+    const pointOrigin = new Point(nameGen.next().value, 0, 0);
+    const baseLength = 1;
+    const pointsRound1 = (() => {
+        const anglesInDegrees = [...Array(6).keys()].map((i) => 60 * i + 30 + angleInDegreesOffset);
+        const radius = baseLength;
+        return anglesInDegrees.map((angleInDegrees) => PointConstructor.fromPointRadiusAndAngle(nameGen.next().value, pointOrigin, radius, angleInDegrees));
+    })();
+    const pointsRound2 = (() => {
+        const anglesInDegrees = [...Array(6).keys()].map((i) => 60 * i + 0 + angleInDegreesOffset);
+        const radius = (2 * baseLength * (Math.sqrt(3) / 2.0)).toTree();
+        return anglesInDegrees.map((angleInDegrees) => PointConstructor.fromPointRadiusAndAngle(nameGen.next().value, pointOrigin, radius, angleInDegrees));
+    })();
+    const segmentsRound1 = pointsRound1.map((pointRound1) => [
+        pointOrigin,
+        pointRound1,
+    ]);
+    const pointsRound2Rotated1 = arrayRotation(pointsRound2, 1);
+    const segmentsRound2 = pointsRound1.flatMap((pointRound1, i) => [
+        [pointRound1, pointsRound2[i]],
+        [pointRound1, pointsRound2Rotated1[i]],
+    ]);
+    return {
+        points: [pointOrigin, ...pointsRound1, ...pointsRound2],
+        segments: [...segmentsRound1, ...segmentsRound2],
+    };
+}
+const createVector = (from, to, name, precision = 8) => {
+    return new Vector(name, round(substract(to.x, from.x).evaluate(), precision).toTree(), round(substract(to.y, from.y).evaluate(), precision).toTree());
+};
+const createPoint = (x, y, name, precision = 8) => {
+    return new Point(name, round(x, precision), round(y, precision));
+};
+const rotatePoint = (target, angle, center, name, precision = 8) => {
+    const vSrc = createVector(center, target, "vSrc", precision);
+    const vRotated = vSrc.rotate(angle, "vRotated");
+    return createPoint(add(center.x, vRotated.x).evaluate(), add(center.y, vRotated.y).evaluate(), name, precision);
+};
+const getGGBCoreCommands = (identifiers) => {
+    const { pointsDict, segments } = identifiers;
+    const points = Object.values(pointsDict).map((pointIds) => PointConstructor.fromIdentifiers(pointIds));
+    return [
+        ...points.flatMap((point) => [
+            ...point.toGGBCommand(),
+            `SetVisibleInView(${point.name}, 1, false)`,
+            `T_{${point.name}} = Text("${point.name}", (${point.x.evaluate() + 0.15},${point.y.evaluate() + 0.15}), false, true, 0, 0)`,
+        ]),
+        ...segments.flatMap((segment) => {
+            const [A, B] = segment.split("");
+            return [
+                `S_{${segment}} = Segment(${A}, ${B})`,
+                `SetLineThickness(S_{${segment}},3)`,
+            ];
+        }),
+    ];
+};
+const getStrForTransformation = (transformationIds) => {
+    switch (transformationIds.type) {
+        case "axial": {
+            return `la symétrie axiale d'axe $(${transformationIds.point1.name}${transformationIds.point2.name})$`;
+        }
+        case "central": {
+            return `la symétrie centrale de centre $${transformationIds.point1.name}$`;
+        }
+        default:
+            throw new Error("Unsupported transformation type: " + transformationIds.type);
+    }
+};
+const getInstruction = (identifiers) => {
+    const { namePointSrc, transformationIds } = identifiers;
+    return `Sur la figure ci-dessous, tous les losanges sont superposables. 
+Placer l'image du point $${namePointSrc}$ par ${getStrForTransformation(transformationIds)}.`;
+};
+const getHint = (identifiers) => {
+    const { namePointSrc, transformationIds } = identifiers;
+    switch (transformationIds.type) {
+        case "axial": {
+            return `Visualise mentalement la droite $(${transformationIds.point1.name}${transformationIds.point2.name})$.
+Est-ce que $${namePointSrc}$ appartient à cette droite ?`;
+        }
+        case "central": {
+            return `Visualise les points $${namePointSrc}$ et $${transformationIds.point1.name}$. Sont-ils confondus ?`;
+        }
+        default:
+            throw new Error("Unsupported transformation type: " + transformationIds.type);
+    }
+};
+const getCorrection = (identifiers) => {
+    const { namePointSrc, namePointDst, transformationIds } = identifiers;
+    switch (transformationIds.type) {
+        case "axial": {
+            if (namePointSrc === namePointDst) {
+                return `On trace $(${transformationIds.point1.name}${transformationIds.point2.name})$. 
+$${namePointSrc}$ appartient à $(${transformationIds.point1.name}${transformationIds.point2.name})$. 
+Le symétrique est $${namePointSrc}$ lui-même.
+        `;
+            }
+            else {
+                return `On trace $(${transformationIds.point1.name}${transformationIds.point2.name})$. 
+Si on note $${namePointSrc}'$ le symétrique de $${namePointSrc}$, alors $(${transformationIds.point1.name}${transformationIds.point2.name})$ est la médiatrice de $[${namePointSrc}${namePointSrc}']$.
+      Le symétrique de $${namePointSrc}$ est donc $${namePointDst}$.`;
+            }
+        }
+        case "central": {
+            if (namePointSrc === namePointDst) {
+                return `$${namePointSrc}$ et $${transformationIds.point1.name}$ sont confondus. Le symétrique est $${namePointSrc}$ lui-même.`;
+            }
+            else {
+                return `Si on note $${namePointSrc}'$ le symétrique de $${namePointSrc}$, alors $${transformationIds.point1.name}$ est le milieu de $[${namePointSrc}${namePointSrc}']$.
+      Le symétrique de $${namePointSrc}$ est donc $${namePointDst}$.`;
+            }
+        }
+        default:
+            throw new Error("Unsupported transformation type: " + transformationIds.type);
+    }
+};
+const getAnswerPoint = (identifiers) => {
+    const { namePointDst, pointsDict } = identifiers;
+    const pointDst = PointConstructor.fromIdentifiers(pointsDict[namePointDst]);
+    return pointDst;
+};
+const getGGBAnswer = (identifiers) => {
+    const { transformationIds, namePointSrc, pointsDict } = identifiers;
+    const answerPoint = getAnswerPoint(identifiers);
+    const pointSrc = PointConstructor.fromIdentifiers(pointsDict[namePointSrc]);
+    const ggbAnswer = [
+        ...getGGBCoreCommands(identifiers),
+        //pointSrc
+        `SetVisibleInView(T_${pointSrc.name}, 1, false)`,
+        `SetVisibleInView(${pointSrc.name}, 1, true)`,
+        ...pointSrc.toGGBCommand({ color: `${blueMain}`, size: 5 }),
+        //transformation
+        ...(() => {
+            switch (transformationIds.type) {
+                case "axial":
+                    {
+                        const [point1, point2] = [
+                            transformationIds.point1,
+                            transformationIds.point2,
+                        ].map((pointIds) => PointConstructor.fromIdentifiers(pointIds));
+                        return [
+                            //point1
+                            `SetVisibleInView(T_${point1.name}, 1, false)`,
+                            `SetVisibleInView(${point1.name}, 1, true)`,
+                            ...point1.toGGBCommand({ color: `${orange}`, size: 5 }),
+                            //point2
+                            `SetVisibleInView(T_${point2.name}, 1, false)`,
+                            `SetVisibleInView(${point2.name}, 1, true)`,
+                            ...point2.toGGBCommand({ color: `${orange}`, size: 5 }),
+                            //line
+                            `L_{${point1.name}${point2.name}} = Line(${point1.name},${point2.name})`,
+                            `SetColor(L_{${point1.name}${point2.name}}, "${orange}")`,
+                        ];
+                    }
+                    break;
+                case "central":
+                    {
+                        const pointCenter = PointConstructor.fromIdentifiers(transformationIds.point1);
+                        return [
+                            //pointCenter
+                            `SetVisibleInView(T_${pointCenter.name}, 1, false)`,
+                            `SetVisibleInView(${pointCenter.name}, 1, true)`,
+                            ...pointCenter.toGGBCommand({ color: `${orange}`, size: 5 }),
+                        ];
+                    }
+                    break;
+                default:
+                    throw new Error("Unsupported transformation type: " + transformationIds.type);
+            }
+        })(),
+        //answer point
+        `SetVisibleInView(T_${answerPoint.name}, 1, false)`,
+        `SetVisibleInView(${answerPoint.name}, 1, true)`,
+        ...answerPoint.toGGBCommand({ color: `${greenMain}`, size: 10 }),
+    ];
+    return ggbAnswer;
+};
+const getCorrectionGGBOptions = (identifiers) => {
+    const points = Object.values(identifiers.pointsDict).map((p) => PointConstructor.fromIdentifiers(p));
+    const ggb = new GeogebraConstructor({
+        hideAxes: true,
+        isGridSimple: true,
+        commands: getGGBAnswer(identifiers),
+        fontSize: 16,
+    });
+    return ggb.getOptions({
+        coords: ggb.getCoordsForPoints(points),
+    });
+};
+const getStudentGGBOptions = (identifiers) => {
+    const points = Object.values(identifiers.pointsDict).map((p) => PointConstructor.fromIdentifiers(p));
+    const studentGGB = new GeogebraConstructor({
+        commands: getGGBCoreCommands(identifiers),
+        hideGrid: true,
+        hideAxes: true,
+        customToolBar: toolBarConstructor({
+            point: true,
+        }),
+        forbidShiftDragZoom: true,
+    });
+    return studentGGB.getOptions({
+        coords: studentGGB.getCoordsForPoints(points),
+    });
+};
+const isGGBAnswerValid = (ans, { ggbAnswer, ...identifiers }) => {
+    const isPointValid = () => {
+        const points = parseGGBPoints(ans)
+            .map((p) => ggbPointToCoords(p))
+            .map((coords, i) => new Point(`K_${i}`, coords.x, coords.y));
+        const answerPoint = getAnswerPoint(identifiers);
+        return points.some((point) => point.distanceTo(answerPoint) < 0.1);
+    };
+    return isPointValid();
+};
+const getPinPointFromAxialOrCentralSymmetryQuestion = (optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const namesPool = shuffle("ABCDEFGHIJKLMNPQRST".split(""));
+    const snowflakeDict = createSnowflakeDict(namesPool, randint(-30, 30));
+    const pointsDict = Object.fromEntries(snowflakeDict.points.map((point) => [point.name, point.toIdentifiers()]));
+    const segments = snowflakeDict.segments.map(([pointA, pointB]) => `${pointA.name}${pointB.name}`);
+    function createRandomTransformationIds(points) {
+        return random([
+            ...(opts.typeTransformation.includes("axiale")
+                ? [createRandomAxialTransformationIds]
+                : []),
+            ...(opts.typeTransformation.includes("centrale")
+                ? [createRandomCentralTransformationIds]
+                : []),
+        ])(points);
+    }
+    function createRandomAxialTransformationIds(points) {
+        const [point1, point2] = randomMany(points, 2).map((point) => point.toIdentifiers());
+        return {
+            type: "axial",
+            point1,
+            point2,
+        };
+    }
+    function createRandomCentralTransformationIds(points) {
+        const point1 = random(points).toIdentifiers();
+        return {
+            type: "central",
+            point1,
+        };
+    }
+    function applyTransformation(transformationIds, pointSrc) {
+        switch (transformationIds.type) {
+            case "axial":
+                {
+                    const [point1, point2] = [
+                        transformationIds.point1,
+                        transformationIds.point2,
+                    ].map((pointIds) => PointConstructor.fromIdentifiers(pointIds));
+                    const vecURaw = VectorConstructor.fromPoints(point1, point2);
+                    const vecUUnit = vecURaw.times(frac(1, vecURaw.getNorm().evaluate()).evaluate().toTree());
+                    const vecVRaw = VectorConstructor.fromPoints(point1, rotatePoint(point2, frac(PiNode, 2).evaluate(), point1, "N"));
+                    const vecVUnit = vecVRaw.times(frac(1, vecVRaw.getNorm().evaluate()).evaluate().toTree());
+                    const vecSrc = VectorConstructor.fromPoints(point1, pointSrc);
+                    const dotAx = vecSrc.scalarProduct(vecUUnit);
+                    const dotPerp = vecSrc.scalarProduct(vecVUnit);
+                    const vecDst = vecUUnit
+                        .times(dotAx)
+                        .add(vecVUnit.times(multiply(-1, dotPerp)));
+                    const pointDst = vecDst.getEndPoint(point1, `${pointSrc}'`);
+                    return pointDst;
+                }
+                break;
+            case "central":
+                {
+                    const pointCenter = PointConstructor.fromIdentifiers(transformationIds.point1);
+                    const vec = VectorConstructor.fromPoints(pointSrc, pointCenter);
+                    return vec.getEndPoint(pointCenter, `${pointSrc}'`);
+                }
+                break;
+            default:
+                throw new Error("Unsupported transformation type: " + transformationIds.type);
+        }
+    }
+    let transformationIdsCandidate;
+    let pointSrc;
+    let pointDst;
+    let counter = -1;
+    let isValidTransformationIds = false;
+    while (!isValidTransformationIds && counter < 100) {
+        counter++;
+        transformationIdsCandidate = createRandomTransformationIds(snowflakeDict.points);
+        const randomPointFresh = () => random(snowflakeDict.points.filter((point) => point.name !== transformationIdsCandidate.point1.name &&
+            point.name !== transformationIdsCandidate.point2?.name));
+        const randomPoint = () => random(snowflakeDict.points);
+        pointSrc = probaFlip(0.8) ? randomPointFresh() : randomPoint();
+        const pointDstFromTransformation = applyTransformation(transformationIdsCandidate, pointSrc);
+        const pointDstWrtExistingPoints = snowflakeDict.points.find((point) => {
+            const distance = point.distanceTo(pointDstFromTransformation);
+            return distance < 0.0001;
+        });
+        if (pointDstWrtExistingPoints) {
+            pointDst = pointDstWrtExistingPoints;
+            const isPointDstDifferentFromPointSrc = pointDst.name !== pointSrc.name;
+            if (opts.isForceDstDifferentFromSrc) {
+                isValidTransformationIds = isPointDstDifferentFromPointSrc;
+            }
+            else {
+                isValidTransformationIds = probaFlip(0.6)
+                    ? isPointDstDifferentFromPointSrc
+                    : true;
+            }
+        }
+    }
+    if (!isValidTransformationIds) {
+        const defaultTransformationIds = {
+            type: "central",
+            point1: snowflakeDict.points[0].toIdentifiers(),
+        };
+        transformationIdsCandidate = defaultTransformationIds;
+        pointSrc = snowflakeDict.points[1];
+        pointDst = snowflakeDict.points[4];
+    }
+    const identifiers = {
+        pointsDict,
+        segments,
+        transformationIds: transformationIdsCandidate,
+        namePointSrc: pointSrc.name,
+        namePointDst: pointDst.name,
+    };
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        ggbAnswer: getGGBAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        studentGgbOptions: getStudentGGBOptions(identifiers),
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        correctionGgbOptions: getCorrectionGGBOptions(identifiers),
+        options: opts,
+    };
+    return question;
+};
+const options = [
+    {
+        id: "isForceDstDifferentFromSrc",
+        label: "Symétrique différent du point de départ",
+        type: GeneratorOptionType.checkbox,
+        target: GeneratorOptionTarget.generation,
+        defaultValue: false,
+    },
+    {
+        id: "typeTransformation",
+        label: "Type de symétrie",
+        type: GeneratorOptionType.multiselect,
+        target: GeneratorOptionTarget.generation,
+        values: ["axiale", "centrale"],
+        defaultValue: ["axiale", "centrale"],
+    },
+];
+const optsDefault = {
+    isForceDstDifferentFromSrc: false,
+    typeTransformation: ["axiale", "centrale"],
+};
+export const pinPointFromAxialOrCentralSymmetry = {
+    id: "pinPointFromAxialOrCentralSymmetry",
+    connector: "=",
+    label: "Placer l'image d'un point par une symétrie (axiale ou centrale)",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getPinPointFromAxialOrCentralSymmetryQuestion(opts), nb),
+    options,
+    ggbTimer: 60,
+    isGGBAnswerValid,
+    subject: "Mathématiques",
+    answerType: "GGB",
+    getQuestionFromIdentifiers,
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
+};

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

@@ -0,0 +1,18 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { PointIdentifiers } from "../../../../math/geometry/point.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type TransformationIdentifiers = {
+    type: string;
+    point1: PointIdentifiers;
+    angleInDegrees: NodeIdentifiers;
+};
+type Identifiers = {
+    pointsDict: Record<string, PointIdentifiers>;
+    segments: string[];
+    transformationIds: TransformationIdentifiers;
+    namePointSrc: string;
+    namePointDst: string;
+};
+export declare const pinPointFromRotation: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=pinPointFromRotation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pinPointFromRotation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/euclidian/pinPointFromRotation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAOrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAMtC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AA4J7C,KAAK,yBAAyB,GAAG;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,gBAAgB,CAAC;IACzB,cAAc,EAAE,eAAe,CAAC;CACjC,CAAC;AAEF,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;IAC7C,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,iBAAiB,EAAE,yBAAyB,CAAC;IAC7C,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AAqSF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAetD,CAAC"}