math-exercises 3.0.152 → 3.0.154

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

@@ -0,0 +1,387 @@
+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 { Point, PointConstructor, } from "../../../../math/geometry/point.js";
+import { Segment } from "../../../../math/geometry/segment.js";
+import { Vector } from "../../../../math/geometry/vector.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { round } from "../../../../math/utils/round.js";
+import { abs } from "../../../../tree/nodes/functions/absNode.js";
+import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.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 { 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 "rotation": {
+            const nodeAngleInDegrees = NodeConstructor.fromIdentifiers(transformationIds.angleInDegrees);
+            const isPositiveAngle = nodeAngleInDegrees.evaluate() >= 0;
+            const strClockwise = isPositiveAngle ? "anti-horaire" : "horaire";
+            const absAngleInDegrees = abs(nodeAngleInDegrees).simplify();
+            return `la rotation de centre $${transformationIds.point1.name}$ et d'angle $${absAngleInDegrees.toTex()}°$ dans le sens ${strClockwise}`;
+        }
+        default:
+            throw new Error("Unsupported transformation type: " + transformationIds.type);
+    }
+};
+const getObjectWithName = (nameObj, pointsDict) => {
+    const namePoints = nameObj.split("");
+    const points = namePoints.map((namePoint) => PointConstructor.fromIdentifiers(pointsDict[namePoint]));
+    return new Segment(points[0], points[1]);
+};
+const getInstruction = (identifiers) => {
+    const { nameObjSrc, transformationIds } = identifiers;
+    return `Sur la figure ci-dessous, tous les losanges sont superposables. 
+Placer l'image du segment $[${nameObjSrc}]$ par ${getStrForTransformation(transformationIds)}.`;
+};
+const getHint = (identifiers) => {
+    const { nameObjSrc, transformationIds } = identifiers;
+    const [namePointA, namePointB] = nameObjSrc.split("");
+    return `Cherche l'image de $${namePointA}$ par ${getStrForTransformation(transformationIds)}. Même chose pour  $${namePointB}$.`;
+};
+const getCorrection = (identifiers) => {
+    const { nameObjSrc, nameObjDst, transformationIds, pointsDict } = identifiers;
+    const pointsIds = Object.values(pointsDict);
+    return `L'angle $\\widehat{${pointsIds[1].name}${pointsIds[0].name}${pointsIds[2].name}}$ vaut $60°$.
+L'image de $${nameObjSrc[0]}$ par ${getStrForTransformation(transformationIds)} est $${nameObjDst[1]}$ et celle de $${nameObjSrc[0]}$ est $${nameObjDst[1]}$.
+L'image de $[${nameObjSrc}]$ par ${getStrForTransformation(transformationIds)} est donc $[${nameObjDst}]$.`;
+};
+const getSegmentSrc = (identifiers) => {
+    const { nameObjSrc, pointsDict } = identifiers;
+    return getObjectWithName(nameObjSrc, pointsDict);
+};
+const getSegmentDst = (identifiers) => {
+    const { nameObjDst, pointsDict } = identifiers;
+    return getObjectWithName(nameObjDst, pointsDict);
+};
+const getGGBAnswer = (identifiers) => {
+    const { transformationIds } = identifiers;
+    const nodeAngleInDegrees = NodeConstructor.fromIdentifiers(transformationIds.angleInDegrees);
+    const isPositiveAngle = nodeAngleInDegrees.evaluate() >= 0;
+    const absAngleInDegrees = abs(nodeAngleInDegrees).simplify();
+    const segmentSrc = getSegmentSrc(identifiers);
+    const segmentDst = getSegmentDst(identifiers);
+    let [pointSrc, pointDst] = [segmentSrc, segmentDst].map((segment) => segment.pointA);
+    const isBothPointsSameAsCenter = [pointSrc, pointDst].every((point) => point.name === transformationIds.point1.name);
+    if (isBothPointsSameAsCenter) {
+        [pointSrc, pointDst] = [segmentSrc, segmentDst].map((segment) => segment.pointB);
+    }
+    const ggbAnswer = [
+        ...getGGBCoreCommands(identifiers),
+        //transformation
+        ...(() => {
+            switch (transformationIds.type) {
+                case "rotation":
+                    {
+                        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 }),
+                            //segment1
+                            `S1_{${pointCenter.name}${pointSrc.name}} = Segment(${pointCenter.name},${pointSrc.name})`,
+                            `SetColor(S1_{${pointCenter.name}${pointSrc.name}},"${orange}")`,
+                            //segment2
+                            `S1_{${pointCenter.name}${pointDst.name}} = Segment(${pointCenter.name},${pointDst.name})`,
+                            `SetColor(S1_{${pointCenter.name}${pointDst.name}},"${orange}")`,
+                            //angle
+                            isPositiveAngle
+                                ? `AA_{${pointSrc.name}${pointCenter.name}${pointDst.name}} = Angle(${pointSrc.name},${pointCenter.name},${pointDst.name})`
+                                : `AA_{${pointSrc.name}${pointCenter.name}${pointDst.name}} = Angle(${pointDst.name},${pointCenter.name},${pointSrc.name})`,
+                            `SetColor(AA_{${pointSrc.name}${pointCenter.name}${pointDst.name}},"${orange}")`,
+                            `SetCaption(AA_{${pointSrc.name}${pointCenter.name}${pointDst.name}},"$${absAngleInDegrees.toTex()}°$")`,
+                            `ShowLabel(AA_{${pointSrc.name}${pointCenter.name}${pointDst.name}}, true)`,
+                            //arc
+                            `C_{${pointCenter.name}${pointSrc.name}} = Circle(${pointCenter.name},${pointSrc.name})`,
+                            `SetVisibleInView(C_{${pointCenter.name}${pointSrc.name}}, 1, false)`,
+                            isPositiveAngle
+                                ? `AR_{${pointCenter.name}${pointSrc.name}} = Arc( C_{${pointCenter.name}${pointSrc.name}} , ${pointSrc.name}    , ${pointDst.name} )`
+                                : `AR_{${pointCenter.name}${pointSrc.name}} = Arc( C_{${pointCenter.name}${pointSrc.name}} , ${pointDst.name} , ${pointSrc.name}    )`,
+                            `SetColor(AR_{${pointCenter.name}${pointSrc.name}},"${orange}")`,
+                        ];
+                    }
+                    break;
+                default:
+                    throw new Error("Unsupported transformation type: " + transformationIds.type);
+            }
+        })(),
+        //segmentSrc
+        `S_{src}=Segment(${segmentSrc.pointA.name},${segmentSrc.pointB.name})`,
+        `SetFixed(S_{src},true)`,
+        `ShowLabel(S_{src},false)`,
+        `SetColor(S_{src},"${blueMain}")`,
+        //segmentSrc.pointA
+        `SetVisibleInView(T_${segmentSrc.pointA.name}, 1, false)`,
+        `SetVisibleInView(${segmentSrc.pointA.name}, 1, true)`,
+        `SetColor(${segmentSrc.pointA.name}, "${blueMain}")`,
+        //segmentSrc.pointB
+        `SetVisibleInView(T_${segmentSrc.pointB.name}, 1, false)`,
+        `SetVisibleInView(${segmentSrc.pointB.name}, 1, true)`,
+        `SetColor(${segmentSrc.pointB.name}, "${blueMain}")`,
+        //segmentDst
+        `S_{dst}=Segment(${segmentDst.pointA.name},${segmentDst.pointB.name})`,
+        `SetFixed(S_{dst},true)`,
+        `ShowLabel(S_{dst},false)`,
+        `SetColor(S_{dst},"${greenMain}")`,
+        //segmentDst.pointA
+        `SetVisibleInView(T_${segmentDst.pointA.name}, 1, false)`,
+        `SetVisibleInView(${segmentDst.pointA.name}, 1, true)`,
+        `SetColor(${segmentDst.pointA.name}, "${greenMain}")`,
+        //segmentDst.pointB
+        `SetVisibleInView(T_${segmentDst.pointB.name}, 1, false)`,
+        `SetVisibleInView(${segmentDst.pointB.name}, 1, true)`,
+        `SetColor(${segmentDst.pointB.name}, "${greenMain}")`,
+    ];
+    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({
+            segment: true,
+        }),
+        forbidShiftDragZoom: true,
+    });
+    return studentGGB.getOptions({
+        coords: studentGGB.getCoordsForPoints(points),
+    });
+};
+const isGGBAnswerValid = (ans, { ggbAnswer, ...identifiers }) => {
+    const studentCommands = ans;
+    function getStudentPointsDictFromStudentCommands(commands) {
+        const regexPoint = new RegExp(`(?<name>\\w+)\\s?=\\s?\\((?<strX>-?\\d+(\\.\\d+)?),\\s?(?<strY>-?\\d+(\\.\\d+)?)\\)`);
+        const pointsDict = commands.reduce((acc, command) => {
+            const match = command.match(regexPoint);
+            if (match && match.groups) {
+                const { name, strX, strY } = match.groups;
+                const [x, y] = [strX, strY].map((strZ) => parseFloat(strZ));
+                const point = new Point(name, x, y);
+                acc[name] = point;
+            }
+            return acc;
+        }, {});
+        console.log("pointsDict", pointsDict);
+        return pointsDict;
+    }
+    function getStudentSegmentsDictFromStudentCommands(commands) {
+        const studentPointsDict = getStudentPointsDictFromStudentCommands(commands);
+        const regexSegment = new RegExp(`(?<name>\\w+)\\s?=\\s?Segment\\[(?<namePointA>\\w+),\\s?(?<namePointB>\\w+)\\]`);
+        const segmentsDict = studentCommands.reduce((acc, command) => {
+            const match = command.match(regexSegment);
+            if (match && match.groups) {
+                const { name, namePointA, namePointB } = match.groups;
+                const segment = new Segment(studentPointsDict[namePointA], studentPointsDict[namePointB]);
+                acc[name] = segment;
+            }
+            return acc;
+        }, {});
+        console.log("segmentsDict", segmentsDict);
+        return segmentsDict;
+    }
+    const isSegmentValid = () => {
+        const studentSegmentDict = getStudentSegmentsDictFromStudentCommands(studentCommands);
+        if (Object.keys(studentSegmentDict).length !== 1) {
+            return false;
+        }
+        const segmentStudent = Object.values(studentSegmentDict)[0];
+        const segmentDst = getSegmentDst(identifiers);
+        return ((segmentStudent.pointA.distanceTo(segmentDst.pointA) < 0.1 &&
+            segmentStudent.pointB.distanceTo(segmentDst.pointB) < 0.1) ||
+            (segmentStudent.pointB.distanceTo(segmentDst.pointA) < 0.1 &&
+                segmentStudent.pointA.distanceTo(segmentDst.pointB) < 0.1));
+    };
+    return isSegmentValid();
+};
+const getPinSegmentFromRotationQuestion = () => {
+    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 createRandomRotateTransformationIds(points);
+    }
+    const angleInDegreesPool = [
+        ...new Set([...Array(4).keys()]
+            .map((i) => (i + 1) * 60)
+            .flatMap((angleInDegrees) => [angleInDegrees, -angleInDegrees])),
+    ];
+    function createRandomRotateTransformationIds(points) {
+        const [point1] = [random(points)].map((point) => point.toIdentifiers());
+        return {
+            type: "rotation",
+            point1,
+            angleInDegrees: random(angleInDegreesPool).toTree().toIdentifiers(),
+        };
+    }
+    function applyTransformation(transformationIds, pointSrc) {
+        switch (transformationIds.type) {
+            case "rotation":
+                {
+                    const pointCenter = PointConstructor.fromIdentifiers(transformationIds.point1);
+                    const angleInDegrees = NodeConstructor.fromIdentifiers(transformationIds.angleInDegrees);
+                    return rotatePoint(pointSrc, multiply(PiNode, frac(angleInDegrees, 180)).evaluate(), pointCenter, "N");
+                }
+                break;
+            default:
+                throw new Error("Unsupported transformation type: " + transformationIds.type);
+        }
+    }
+    function findCorrespondingSnowflakePoint(point) {
+        return snowflakeDict.points.find((pointSnowflake) => {
+            const distance = point.distanceTo(pointSnowflake);
+            return distance < 0.0001;
+        });
+    }
+    let transformationIdsCandidate;
+    let pointsSrc;
+    let pointsDst;
+    let counter = -1;
+    let isValidTransformationIds = false;
+    while (!isValidTransformationIds && counter < 100) {
+        counter++;
+        transformationIdsCandidate = createRandomTransformationIds(snowflakeDict.points);
+        pointsSrc = randomMany(snowflakeDict.points, 2);
+        const pointsDstFromTransformation = pointsSrc.map((pointSrc) => applyTransformation(transformationIdsCandidate, pointSrc));
+        const pointsDstWrtExistingPoints = pointsDstFromTransformation
+            .map(findCorrespondingSnowflakePoint)
+            .filter((p) => p !== undefined);
+        if (pointsDstWrtExistingPoints.length === pointsSrc.length) {
+            pointsDst = pointsDstWrtExistingPoints;
+            isValidTransformationIds = true;
+        }
+    }
+    if (!isValidTransformationIds) {
+        const defaultTransformationIds = {
+            type: "rotation",
+            point1: snowflakeDict.points[0].toIdentifiers(),
+            angleInDegrees: (120).toTree().toIdentifiers(),
+        };
+        transformationIdsCandidate = defaultTransformationIds;
+        pointsSrc = [snowflakeDict.points[2], snowflakeDict.points[3]];
+        pointsDst = [snowflakeDict.points[4], snowflakeDict.points[5]];
+    }
+    const [nameObjSrc, nameObjDst] = [pointsSrc, pointsDst].map((points) => points.map((point) => point.name).join(""));
+    const identifiers = {
+        pointsDict,
+        segments,
+        transformationIds: transformationIdsCandidate,
+        nameObjSrc,
+        nameObjDst,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        ggbAnswer: getGGBAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        studentGgbOptions: getStudentGGBOptions(identifiers),
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        correctionGgbOptions: getCorrectionGGBOptions(identifiers),
+    };
+    return question;
+};
+export const pinSegmentFromRotation = {
+    id: "pinSegmentFromRotation",
+    connector: "=",
+    label: "Placer l'image d'un segment par une rotation",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getPinSegmentFromRotationQuestion(opts), nb),
+    ggbTimer: 60,
+    isGGBAnswerValid,
+    subject: "Mathématiques",
+    answerType: "GGB",
+    getQuestionFromIdentifiers,
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/geometry/euclidian/recognizeAngleFromRotation.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 recognizeAngleFromRotation: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=recognizeAngleFromRotation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"recognizeAngleFromRotation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/euclidian/recognizeAngleFromRotation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,6BAA6B,CAAC;AAKrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAMtC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAuI7C,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;AA8SF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAgB5D,CAAC"}