math-exercises 3.0.124 → 3.0.126

package/lib/exercises/math/geometry/angles/anglesUsingIsParallel.js

@@ -0,0 +1,448 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, GeneratorOptionTarget, GeneratorOptionType, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { Angle } from "../../../../math/geometry/angle.js";
+import { Line, LineConstructor, } from "../../../../math/geometry/line.js";
+import { Point, PointConstructor, } from "../../../../math/geometry/point.js";
+import { Vector } from "../../../../math/geometry/vector.js";
+import { randfloat } from "../../../../math/utils/random/randfloat.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 { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { random } from "../../../../utils/alea/random.js";
+const createVector = (from, to, name, precision = 5) => {
+    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 = 5) => {
+    return new Point(name, round(x, precision), round(y, precision));
+};
+const midPoint = (pointA, pointB, name, precision = 2) => {
+    return createPoint(multiply(add(pointA.x, pointB.x), 0.5).evaluate(), multiply(add(pointA.y, pointB.y), 0.5).evaluate(), name, precision);
+};
+const degreesToRadians = (angleInDegrees, precision) => {
+    const oneOver180 = 0.00555555555555555;
+    return round(multiply(multiply(angleInDegrees, PiNode), oneOver180).evaluate(), precision);
+};
+const rotatePoint = (target, angle, center, name, precision = 2) => {
+    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 buildLines = (cAngleInDegreesTop, cAngleInDegreesBottom) => {
+    //we build the quasiparallels using corresponding angles
+    /*
+             cAngleTop/
+    topLine------------------------
+                    /
+                   /
+      cAngleBottom/
+    bottomLine----------------------
+                /
+  */
+    const precision = 5;
+    const [cAngleTop, cAngleBottom] = [
+        cAngleInDegreesTop,
+        cAngleInDegreesBottom,
+    ].map((angleInDegrees) => degreesToRadians(angleInDegrees, precision));
+    //build top line
+    const heightAvgTopLine = 2;
+    const lineTop = new Line(new Point("A", (-4 + randfloat(-1, 1, 1)).toTree(), (heightAvgTopLine + randfloat(-1, 1, 1)).toTree()), new Point("B", (4 + randfloat(-1, 1, 1)).toTree(), (heightAvgTopLine + randfloat(-1, 1, 1)).toTree()), "d_1");
+    //build secant line
+    const pointSTop = midPoint(lineTop.pointA, lineTop.pointB, "C", 5);
+    const lineSecant = new Line(pointSTop, rotatePoint(lineTop.pointA, PiNode.value - cAngleTop, pointSTop, "D", 5), "s");
+    //build bottom line
+    const lineBottom = new Line(lineSecant.pointB, rotatePoint(lineSecant.pointA, cAngleBottom, lineSecant.pointB, "E", 5), "d_2");
+    return {
+        lineTop,
+        lineSecant,
+        lineBottom,
+    };
+};
+class IntersectionConstructor {
+    static fromBaselines(pointName, lineHBase, lineVBase) {
+        const center = lineHBase.intersect(lineVBase, pointName);
+        const lineH = Intersection.createLineBothSideOfPoint(lineHBase, center, lineVBase, "x");
+        const lineV = Intersection.createLineBothSideOfPoint(lineVBase, center, lineHBase, "y");
+        return new Intersection(center, lineH, lineV);
+    }
+    static fromIdentifiers(intersectionIds) {
+        const center = PointConstructor.fromIdentifiers(intersectionIds.center);
+        const lineH = LineConstructor.fromIdentifiers(intersectionIds.lineH);
+        const lineV = LineConstructor.fromIdentifiers(intersectionIds.lineV);
+        return new Intersection(center, lineH, lineV);
+    }
+    static byRotatingIntersection(intersectionSrc, rotationCenter, rotationAngle, precision = 5) {
+        const arrPointSrc = [
+            intersectionSrc.center,
+            intersectionSrc.lineH.pointA,
+            intersectionSrc.lineH.pointB,
+            intersectionSrc.lineV.pointA,
+            intersectionSrc.lineV.pointB,
+        ];
+        const arrPointRotated = arrPointSrc.map((p) => {
+            return rotatePoint(p, rotationAngle, rotationCenter, p.name, precision);
+        });
+        return new Intersection(arrPointRotated[0], new Line(arrPointRotated[1], arrPointRotated[2], intersectionSrc.lineH.name), new Line(arrPointRotated[3], arrPointRotated[4], intersectionSrc.lineV.name));
+    }
+}
+class Intersection {
+    center;
+    lineH;
+    lineV;
+    constructor(center, lineH, lineV) {
+        this.center = center;
+        this.lineH = lineH;
+        this.lineV = lineV;
+    }
+    static createLineBothSideOfPoint(lineBase, pointCenter, lineIntersector, wrtAxis) {
+        switch (wrtAxis) {
+            case "x":
+                return new Line(lineBase.intersect(lineIntersector.translate(-1, 0), pointCenter.name + "_xm"), lineBase.intersect(lineIntersector.translate(+1, 0), pointCenter.name + "_xM"), lineBase.name);
+            case "y":
+                return new Line(lineBase.intersect(lineIntersector.translate(0, -1), pointCenter.name + "_ym"), lineBase.intersect(lineIntersector.translate(0, +1), pointCenter.name + "_yM"), lineBase.name);
+        }
+    }
+    getAngle(angleIndex) {
+        /*
+              lineV.pointB
+                  0 | 1
+    lineH.pointA--center--lineH.pointB
+                  3 | 2
+              lineV.pointA
+    */
+        switch ((angleIndex % 4)) {
+            case 0:
+                return new Angle([this.lineH.pointA, this.center, this.lineV.pointB]);
+            case 1:
+                return new Angle([this.lineV.pointB, this.center, this.lineH.pointB]);
+            case 2:
+                return new Angle([this.lineH.pointB, this.center, this.lineV.pointA]);
+            case 3:
+                return new Angle([this.lineV.pointA, this.center, this.lineH.pointA]);
+        }
+    }
+    toIdentifiers() {
+        return {
+            center: this.center.toIdentifiers(),
+            lineH: this.lineH.toIdentifiers(),
+            lineV: this.lineV.toIdentifiers(),
+        };
+    }
+}
+const getUsedAngles = (identifiers) => {
+    const { arrAngleForLabel } = identifiers;
+    const arrNodeFakeDisplay = arrAngleForLabel?.map((value) => value.toTree());
+    return arrNodeFakeDisplay ?? getGeomAngles(identifiers);
+};
+const getGeomAngles = (identifiers) => {
+    const { arrAngleIndex, arrIntersectionIds } = identifiers;
+    return arrIntersectionIds
+        .map(IntersectionConstructor.fromIdentifiers)
+        .map((inter, i) => inter.getAngle(arrAngleIndex[i]).getValueNode(true));
+};
+const getPropositions = (n, { answer, ...identifiers }, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const propositions = [];
+    addValidProp(propositions, answer, "tex");
+    const arrAngleUsed = getUsedAngles(identifiers);
+    tryToAddWrongProp(propositions, arrAngleUsed[0].toTex(), "tex");
+    tryToAddWrongProp(propositions, substract(180, arrAngleUsed[0]).toTex(), "tex");
+    const arrAngleGeom = getGeomAngles(identifiers);
+    //l'élève fait une mesure sur la figure
+    tryToAddWrongProp(propositions, round(arrAngleGeom[1].evaluate(), opts.nbDigits).frenchify(), "tex");
+    tryToAddWrongProp(propositions, "\\text{On ne peut pas savoir.}", "tex");
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    return !identifiers.isParallel
+        ? "\\text{On ne peut pas savoir.}"
+        : getUsedAngles(identifiers)[1].toTex();
+};
+const getInstruction = (identifiers) => {
+    const { isParallel } = identifiers;
+    return `Les droites $d_{1}$ et $d_{2}$ ${isParallel ? "sont" : "ne sont pas"} parallèles.
+Déterminer, si c'est possible, la mesure de l’angle cherché.`;
+};
+const getHint = () => {
+    return `Trouve la relation entre les deux angles et déduis-en, si c'est possible, la mesure de l'angle cherché.`;
+};
+const getCorrection = (identifiers) => {
+    const { isParallel, angleType } = identifiers;
+    return `Les deux angles sont ${(() => {
+        switch (angleType) {
+            case "alternes-internes":
+                return `alternes-internes`;
+            case "correspondants":
+                return `correspondants`;
+                break;
+            case "alternes-externes":
+                return `alternes-externes`;
+            case "autres":
+                return "tels que l'un repose sur l'intersection de la sécante avec $d_1$ et l'autre repose sur l'intersection de la sécante avec $d_2$";
+        }
+    })()}.
+${(() => {
+        if (!isParallel) {
+            return `Malheureusement, les droites $d_{1}$ et $d_{2}$ ne sont pas parallèles. On ne peut donc rien conclure.`;
+        }
+        else if (angleType !== "autres") {
+            return `Puisque les droites $d_{1}$ et $d_{2}$ sont parallèles, 
+ils ont la même mesure donc la mesure de l'angle cherché est $${getUsedAngles(identifiers)[1].toTex()}$°.`;
+        }
+        else {
+            return `Puisque les droites $d_{1}$ et $d_{2}$ sont parallèles, 
+on peut retrouver toutes les mesures des angles des deux intersections.
+La mesure de l'angle cherché est $${getUsedAngles(identifiers)[1].toTex()}$°.`;
+        }
+    })()}`;
+};
+const getGGBOptions = (identifiers, opts) => {
+    const { isParallel, arrIntersectionIds, arrAngleIndex, arrAngleForLabel } = identifiers;
+    const nbDigits = opts?.nbDigits ?? 1;
+    const arrIntersection = arrIntersectionIds.map(IntersectionConstructor.fromIdentifiers);
+    const arrAngle = arrAngleIndex.map((angleIndex, i) => arrIntersection[i].getAngle(angleIndex));
+    const arrCommandPoints = arrAngle
+        .flatMap((a) => a.points)
+        .flatMap((p) => [
+        ...p.toGGBCommand({
+            isFixed: true,
+            showLabel: false,
+            showUnderlyingPoints: false,
+            showUnderlyingPointsLabel: false,
+        }),
+        //hide points
+        `SetVisibleInView(${p.name}, 1, false)`,
+    ]);
+    const arrCommandLines = [
+        arrIntersectionIds[0].lineH, //top
+        arrIntersectionIds[1].lineH, //bottom
+        arrIntersectionIds[0].lineV, //secant
+    ]
+        .map((lIds) => LineConstructor.fromIdentifiers(lIds))
+        .flatMap((l, i) => l.toGGBCommands(false, {
+        color: "black",
+        showLabel: i < 2,
+    }));
+    const arrCommandAngles = arrAngle
+        .map((angle, i) => {
+        angle.name = `angle_${i}`;
+        return angle;
+    })
+        .flatMap((a, i) => [
+        ...a.toCommands({
+            pointsAreNotBuilt: false,
+            color: ["red", "blue"][i],
+            showValue: false,
+        }),
+        //fake or real label
+        `ShowLabel(${a.name}, false)`,
+        ...a.getFitCaptionCommands({
+            text: [
+                round(arrAngleForLabel ? arrAngleForLabel[i] : a.evaluate(), nbDigits).frenchify(),
+                "?",
+            ][i],
+            size: "small",
+            color: ["red", "blue"][i],
+        }),
+    ]);
+    const arrCommandOther = [
+        `lb_parallel = Text("\\tex$d_1$${isParallel ? "∥" : "∦"}$d_2$", (${-4.5},${-3.1}), false, true, -1, -1)`,
+    ];
+    const ggb = new GeogebraConstructor({
+        commands: [
+            ...arrCommandPoints,
+            ...arrCommandLines,
+            ...arrCommandAngles,
+            ...arrCommandOther,
+        ],
+        hideAxes: true,
+        hideGrid: true,
+        forbidShiftDragZoom: true,
+    });
+    return ggb.getOptions({
+        coords: [-5, 5, -5, 5],
+    });
+};
+const getKeys = () => {
+    return [
+        {
+            id: "custom",
+            label: "On ne peut pas savoir.",
+            labelType: "raw",
+            mathfieldInstructions: {
+                method: "write",
+                content: "\\text{On ne peut pas savoir.}",
+            },
+        },
+    ];
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+const optsDefault = {
+    angleTypes: ["alternes-internes"],
+    isFakeDisplay: true,
+    nbDigits: 0,
+};
+const options = [
+    {
+        id: "angleTypes",
+        label: "Type d'angles",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        values: [
+            "alternes-internes",
+            "correspondants",
+            "alternes-externes",
+            "autres",
+        ],
+        defaultValue: optsDefault.angleTypes,
+    },
+    {
+        id: "isFakeDisplay",
+        label: "Affichage trompeur",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.checkbox,
+        defaultValue: optsDefault.isFakeDisplay,
+    },
+    {
+        id: "nbDigits",
+        label: "Nombre de décimales",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.select,
+        values: [0, 1, 2],
+        defaultValue: optsDefault.nbDigits,
+    },
+];
+const getAnglesUsingIsParallelQuestion = (optsIn) => {
+    const isParallel = coinFlip();
+    const opts = optsIn ?? optsDefault;
+    //---create intersections---
+    //this config will be used to create ggb lines
+    function createConfigGeom(isParallelInGeom, isLookingParallel) {
+        const deviation = isLookingParallel ? 1 : 5;
+        const cAngleInDegreesMin = 30;
+        const cAngleInDegreesTop = randfloat(cAngleInDegreesMin, 180 - cAngleInDegreesMin, opts.nbDigits);
+        const cAngleInDegreesBottom = isParallelInGeom
+            ? cAngleInDegreesTop
+            : cAngleInDegreesTop +
+                randfloat(-deviation, deviation, opts.nbDigits, [0]);
+        return {
+            cAngleInDegreesTop,
+            cAngleInDegreesBottom,
+        };
+    }
+    const configGeom = createConfigGeom(opts.isFakeDisplay ? coinFlip() : isParallel, opts.isFakeDisplay ? coinFlip() : isParallel);
+    const dictLine = buildLines(configGeom.cAngleInDegreesTop, configGeom.cAngleInDegreesBottom);
+    const arrIntersectionRaw = [
+        //intersection: top
+        IntersectionConstructor.fromBaselines("I", dictLine.lineTop, dictLine.lineSecant),
+        //intersection: bottom
+        IntersectionConstructor.fromBaselines("J", dictLine.lineBottom, dictLine.lineSecant),
+    ];
+    //rotate randomly around center
+    const rotationCenter = midPoint(arrIntersectionRaw[0].center, arrIntersectionRaw[1].center, "K", 5);
+    const rotationAngle = randfloat(-PiNode.value, PiNode.value);
+    const arrIntersection = arrIntersectionRaw.map((intersection) => IntersectionConstructor.byRotatingIntersection(intersection, rotationCenter, rotationAngle));
+    //---create angles---
+    const angleType = random(opts.angleTypes);
+    function randomArrAngleIndex(angleType) {
+        /*
+          0 | 1
+          -----
+          3 | 2
+            |
+          0 | 1
+          -----
+          3 | 2
+    */
+        switch (angleType) {
+            case "alternes-internes":
+                return random([
+                    [2, 0],
+                    [3, 1],
+                ]);
+            case "correspondants":
+                return random([
+                    [0, 0],
+                    [1, 1],
+                    [2, 2],
+                    [3, 3],
+                ]);
+            case "alternes-externes":
+                return random([
+                    [0, 2],
+                    [1, 3],
+                ]);
+            case "autres":
+                return random([
+                    [0, 1],
+                    [0, 3],
+                    [1, 2],
+                    [1, 0],
+                    [2, 1],
+                    [2, 3],
+                    [3, 0],
+                    [3, 2],
+                ]);
+        }
+    }
+    const arrAngleIndex = randomArrAngleIndex(angleType);
+    //this is the fake display part:
+    let arrAngleForLabel;
+    if (opts.isFakeDisplay) {
+        const angleInDegreesMin = 25;
+        const cAngleInDegreesTop = round(randfloat(angleInDegreesMin, 180 - angleInDegreesMin, opts.nbDigits), opts.nbDigits);
+        const cAngleInDegreesBottom = isParallel
+            ? cAngleInDegreesTop
+            : round(cAngleInDegreesTop + randfloat(-25, 50, opts.nbDigits, [0]), opts.nbDigits);
+        //angles at angleIndexes 0 and 2 have same value. Same for angleIndexes 1 and 3.
+        arrAngleForLabel = [cAngleInDegreesTop, cAngleInDegreesBottom].map((angle, i) => {
+            return arrAngleIndex[i] % 2 == 0
+                ? angle
+                : round(180 - angle, opts.nbDigits);
+        });
+    }
+    const identifiers = {
+        isParallel,
+        arrIntersectionIds: arrIntersection.map((intersection) => intersection.toIdentifiers()),
+        angleType,
+        arrAngleIndex,
+        arrAngleForLabel,
+    };
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        ggbOptions: getGGBOptions(identifiers, opts),
+    };
+    return question;
+};
+export const anglesUsingIsParallel = {
+    id: "anglesUsingIsParallel",
+    label: "Déterminer un angle issu d'une sécante en utilisant le parallélisme",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getAnglesUsingIsParallelQuestion(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+    getQuestionFromIdentifiers,
+    hasGeogebra: true,
+};

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

@@ -1,2 +1,4 @@
 export * from "./recognizeAngleType.js";
 export * from "./parallelogramFourthAngle.js";
+//export * from "./isParallelUsingAngles.js";
+// export * from "./anglesUsingIsParallel.js";

package/lib/exercises/math/geometry/angles/isParallelUsingAngles.d.ts

@@ -0,0 +1,23 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { LineIdentifiers } from "../../../../math/geometry/line.js";
+import { PointIdentifiers } from "../../../../math/geometry/point.js";
+type IntersectionIds = {
+    center: PointIdentifiers;
+    lineH: LineIdentifiers;
+    lineV: LineIdentifiers;
+};
+type Identifiers = {
+    isParralel: boolean;
+    angleType: "alternes-internes" | "correspondants" | "alternes-externes" | "autres";
+    arrIntersectionIds: IntersectionIds[];
+    arrAngleIndex: number[];
+    arrAngleForLabel: number[] | undefined;
+};
+type Options = {
+    angleTypes: ("alternes-internes" | "correspondants" | "alternes-externes" | "autres")[];
+    isFakeDisplay: boolean;
+    nbDigits: 0 | 1 | 2;
+};
+export declare const isParallelUsingAngles: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=isParallelUsingAngles.d.ts.map

package/lib/exercises/math/geometry/angles/isParallelUsingAngles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isParallelUsingAngles.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/angles/isParallelUsingAngles.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAmBT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAGL,eAAe,EAChB,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAuItC,KAAK,eAAe,GAAG;IACrB,MAAM,EAAE,gBAAgB,CAAC;IACzB,KAAK,EAAE,eAAe,CAAC;IACvB,KAAK,EAAE,eAAe,CAAC;CACxB,CAAC;AA6HF,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,OAAO,CAAC;IACpB,SAAS,EACL,mBAAmB,GACnB,gBAAgB,GAChB,mBAAmB,GACnB,QAAQ,CAAC;IAGb,kBAAkB,EAAE,eAAe,EAAE,CAAC;IACtC,aAAa,EAAE,MAAM,EAAE,CAAC;IAGxB,gBAAgB,EAAE,MAAM,EAAE,GAAG,SAAS,CAAC;CACxC,CAAC;AAuIF,KAAK,OAAO,GAAG;IACb,UAAU,EAAE,CACR,mBAAmB,GACnB,gBAAgB,GAChB,mBAAmB,GACnB,QAAQ,CACX,EAAE,CAAC;IACJ,aAAa,EAAE,OAAO,CAAC;IACvB,QAAQ,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;CACrB,CAAC;AAuNF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAmBhE,CAAC"}