math-exercises 3.0.214 → 3.0.216

package/lib/exercises/math/complex/geometric/complexGeomPlacePointFromZATimesZ.js

@@ -0,0 +1,345 @@
+import { toolBarConstructor } from "../../../../exercises/utils/geogebra/toolBarConstructor.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { colorWithOpacity, 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 } 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 { cos } from "../../../../tree/nodes/functions/cosNode.js";
+import { exp } from "../../../../tree/nodes/functions/expNode.js";
+import { sin } from "../../../../tree/nodes/functions/sinNode.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, isFractionNode, } from "../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { VariableNode } from "../../../../tree/nodes/variables/variableNode.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { random } from "../../../../utils/alea/random.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const lFrame = 4;
+const coordsFrame = (() => {
+    const lFrameMore = lFrame + 0.1;
+    return [-lFrameMore, lFrameMore, -lFrameMore, lFrameMore];
+})();
+//TODO: frac does not simplify "i"
+// const nodeI = new ComplexNode((0).toTree(), (1).toTree());
+const nodeI = new VariableNode("i");
+const _degreesToRadians = (angleInDegrees, precision) => {
+    const oneOver180 = 0.00555555555555555;
+    return round(multiply(multiply(angleInDegrees, PiNode), oneOver180).evaluate(), precision);
+};
+const rotateVector = (vec, angle, name) => {
+    //x' = cos(t)*x -sin(t)*y
+    //y' = sin(t)*x + cos(t)*y
+    const cos = Math.cos(angle);
+    const sin = Math.sin(angle);
+    return new Vector(name, substract(multiply(cos, vec.x), multiply(sin, vec.y)).evaluate().toTree(), add(multiply(sin, vec.x), multiply(cos, vec.y)).evaluate().toTree());
+};
+const rotatePoint = (target, angle, center, name, precision = 2) => {
+    const vSrc = createVector(center, target, "vSrc", precision);
+    const vRotated = rotateVector(vSrc, angle, "vRotated");
+    return createPoint(add(center.x, vRotated.x).evaluate(), add(center.y, vRotated.y).evaluate(), name, precision);
+};
+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 _createPointForModuleAndArgument = (nodeModule, nodeArgument, name) => new Point(name, multiply(nodeModule, cos(nodeArgument)), multiply(nodeModule, sin(nodeArgument)));
+const getHydrated = (identifiers) => {
+    const { pointIdsA, nodeIdsModuleZ, nodeIdsArgumentZ } = identifiers;
+    const [nodeModuleZ, nodeArgumentZ] = [nodeIdsModuleZ, nodeIdsArgumentZ].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const pointA = PointConstructor.fromIdentifiers(pointIdsA);
+    const pointB = (() => {
+        const pointO = new Point("O", 0, 0);
+        const pointARotated = rotatePoint(pointA, nodeArgumentZ.evaluate(), pointO, "ARotated");
+        const pointARotatedAndScaled = new Point("B", multiply(nodeModuleZ, pointARotated.x), multiply(nodeModuleZ, pointARotated.y));
+        return pointARotatedAndScaled;
+    })();
+    const nodeAffixZ = multiply(nodeModuleZ, exp(multiply(nodeI, nodeArgumentZ.simplify({ towardsDistribute: true }))));
+    return {
+        pointA,
+        nodeModuleZ,
+        nodeArgumentZ,
+        pointB,
+        nodeAffixZ,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { nodeAffixZ } = getHydrated(identifiers);
+    return `Sur la figure ci-dessous, le point $A$ a pour affixe $z_{A}$. 
+Placer le point $B$ d'affixe $z_{B}$ tel que : 
+
+$$
+z_{B} = z_{A} \\times ${nodeAffixZ.toTex()}
+$$
+
+`;
+};
+const getGGBAnswer = (identifiers) => {
+    const { pointB } = getHydrated(identifiers);
+    return [
+        ...[pointB].flatMap((point) => point.toGGBCommand({
+            isFixed: true,
+            isSelectionnable: true,
+            showLabel: true,
+            // style: 1,
+            color: greenMain,
+        })),
+    ];
+};
+const getHint = (identifiers) => {
+    const { nodeAffixZ, nodeModuleZ, nodeArgumentZ } = getHydrated(identifiers);
+    return `Soit $O$ l'origine du repère.
+Soit $z = ${nodeAffixZ.toTex()}$.
+Si $M$ est le point d'affixe $z$ alors : 
+
+${alignTex([
+        ["z_{B}", "=", "z_{A} \\times z"],
+        [
+            "",
+            "=",
+            "(\\lvert z_{A} \\rvert e^{i \\arg(z_{A})} ) (\\lvert z \\rvert e^{i \\arg(z)} )",
+        ],
+        [
+            "",
+            "=",
+            "(\\lvert z_{A} \\rvert \\lvert z \\rvert  ) ( e^{i \\arg(z_{A})} e^{i \\arg(z)} )",
+        ],
+        [
+            "",
+            "=",
+            `(\\lvert z_{A} \\rvert \\times ${nodeModuleZ.toTex()}  ) ( e^{i (\\arg(z_{A}) + (${nodeArgumentZ.toTex()})) } )`,
+        ],
+    ])} 
+
+La forme exponentielle est particulièrement adaptée à ce cas de figure :
+- Le module de $z_{B}$ est le module de $z_{A}$ multiplié par $${nodeModuleZ.toTex()}$.
+- L'argument de $z_{B}$ est l'argument de $z_{A}$ auquel on a ajouté $${nodeArgumentZ.toTex()}$.
+
+`;
+};
+const getCorrection = (identifiers) => {
+    const { nodeAffixZ, nodeModuleZ, nodeArgumentZ } = getHydrated(identifiers);
+    return `Soit $O$ l'origine du repère.
+Soit $z = ${nodeAffixZ.toTex()}$.
+Si $M$ est le point d'affixe $z$ alors : 
+
+${alignTex([
+        ["z_{B}", "=", "z_{A} \\times z"],
+        [
+            "",
+            "=",
+            "(\\lvert z_{A} \\rvert e^{i \\arg(z_{A})} ) (\\lvert z \\rvert e^{i \\arg(z)} )",
+        ],
+        [
+            "",
+            "=",
+            "(\\lvert z_{A} \\rvert \\lvert z \\rvert  ) ( e^{i \\arg(z_{A})} e^{i \\arg(z)} )",
+        ],
+        [
+            "",
+            "=",
+            `(\\lvert z_{A} \\rvert \\times ${nodeModuleZ.toTex()}  ) ( e^{i (\\arg(z_{A}) + (${nodeArgumentZ.toTex()})) } )`,
+        ],
+    ])} 
+
+La forme exponentielle est particulièrement adaptée à ce cas de figure :
+- Le module de $z_{B}$ est le module de $z_{A}$ multiplié par $${nodeModuleZ.toTex()}$.
+- L'argument de $z_{B}$ est l'argument de $z_{A}$ auquel on a ajouté $${nodeArgumentZ.toTex()}$.
+
+Ce qui signifie géométriquement que l'on opère sur le point $A$ 
+une homothétie de centre $O$ et de rapport $${nodeModuleZ.toTex()}$ 
+puis une rotation de centre $O$ et d'angle $${nodeArgumentZ.toTex()}$.`;
+};
+const getCorrectionGGBOptions = (identifiers) => {
+    const { pointA, pointB, nodeModuleZ, nodeArgumentZ } = getHydrated(identifiers);
+    const nodeAngleBase = (() => {
+        const nodeAbsArgumentZ = abs(nodeArgumentZ).simplify({
+            towardsDistribute: false,
+        });
+        if (isFractionNode(nodeAbsArgumentZ)) {
+            const nodeDen = nodeAbsArgumentZ.rightChild;
+            return frac(PiNode, nodeDen);
+        }
+        else {
+            throw new Error("isFractionNode(nodeAbsArgumentZ) === false");
+        }
+    })();
+    const nbRays = frac(multiply(2, PiNode), nodeAngleBase)
+        .simplify({ towardsDistribute: false })
+        .evaluate();
+    const arrNodeAngle = [...Array(nbRays).keys()].map((i) => multiply(i, nodeAngleBase));
+    const pointAScaled = new Point("AScaled", multiply(nodeModuleZ, pointA.x), multiply(nodeModuleZ, pointA.y));
+    const precision = 5;
+    const pointO = new Point("O", 0, 0);
+    const arrPointForAngle = arrNodeAngle.map((nodeAngle, i) => rotatePoint(pointAScaled, nodeAngle.evaluate(), pointO, `PF${i}`, precision));
+    const strLineColor = `"${colorWithOpacity("#000000", 26)}"`;
+    const ggb = new GeogebraConstructor({
+        isGridSimple: true,
+        commands: [
+            ...[pointA].flatMap((point) => point.toGGBCommand({
+                isFixed: true,
+                isSelectionnable: true,
+                showLabel: true,
+                // style: 1,
+            })),
+            //circles
+            ...[
+                `cirA = Circle(${pointO.toMathString()}, ${pointA.toMathString()})`,
+                `SetLineThickness(cirA, 1)`,
+                `SetLineStyle(cirA, 2)`,
+            ],
+            ...[
+                `cirB = Circle(${pointO.toMathString()}, ${pointB.toMathString()})`,
+                `SetLineThickness(cirB, 1)`,
+                `SetLineStyle(cirB, 2)`,
+            ],
+            //segments (rays)
+            ...arrPointForAngle.flatMap((point, i) => [
+                `segRay${i} = Segment(${pointO.toMathString()}, ${point.toMathString()})`,
+                `SetColor(segRay${i}, ${strLineColor})`,
+                `SetLineThickness(segRay${i}, 1)`,
+                `SetLineStyle(segRay${i}, 0)`,
+            ]),
+            //pointB
+            ...[pointB].flatMap((point) => point.toGGBCommand({
+                isFixed: true,
+                isSelectionnable: true,
+                showLabel: true,
+                // style: 1,
+                color: greenMain,
+            })),
+            //argument
+            ...(() => {
+                const isClockwise = nodeArgumentZ.evaluate() > 0;
+                return [
+                    `rayOA = Ray(${pointO.toMathString()}, ${pointA.toMathString()})`,
+                    `rayOB = Ray(${pointO.toMathString()}, ${pointB.toMathString()})`,
+                    `SetVisibleInView(rayOA, 1, false)`,
+                    `SetVisibleInView(rayOB, 1, false)`,
+                    `angArg = ${isClockwise ? "Angle(rayOA, rayOB)" : "Angle(rayOB, rayOA)"}`,
+                    `SetDecoration(angArg, ${isClockwise ? 6 : 7})`,
+                    `SetColor(angArg, "${orange}")`,
+                    `SetCaption(angArg, "$\\\\ \\\\ \\ \\ ${nodeArgumentZ.toTex()}$")`,
+                    `ShowLabel(angArg, true)`,
+                ];
+            })(),
+        ],
+        fontSize: 16,
+    });
+    return ggb.getOptions({
+        coords: ggb.getCoordsForPoints(arrPointForAngle),
+    });
+};
+const getStudentGGBOptions = (identifiers) => {
+    const { pointA } = getHydrated(identifiers);
+    const studentGgb = new GeogebraConstructor({
+        customToolBar: toolBarConstructor({ point: true }),
+        isGridSimple: true,
+        commands: [
+            //points
+            ...[pointA].flatMap((point) => point.toGGBCommand({
+                isFixed: true,
+                isSelectionnable: true,
+                showLabel: true,
+                // style: 1,
+            })),
+        ],
+        fontSize: 16,
+    });
+    return studentGgb.getOptions({
+        coords: coordsFrame,
+    });
+};
+const isGGBAnswerValid = (ggbAns, { ggbAnswer, ...identifiers }) => {
+    const { pointB, nodeModuleZ } = getHydrated(identifiers);
+    const pointCoords = parseGGBPoints(ggbAns).map((p) => ggbPointToCoords(p));
+    if (pointCoords.length !== 1)
+        return false;
+    const distanceBonus = nodeModuleZ.evaluate() * 0.2;
+    return (new Point("K", pointCoords[0].x, pointCoords[0].y).distanceTo(pointB) <
+        0.47 + distanceBonus);
+};
+const getComplexGeomPlacePointFromZATimesZQuestion = () => {
+    function createRandomAffixObj() {
+        const nodeModule = random([
+            frac(1, 3),
+            frac(1, 2),
+            frac(3, 2),
+            ...[1, 2, 3].map((v) => v.toTree()),
+        ]);
+        const nodeArgument = (() => {
+            const den = random([3, 4, 6, 8]);
+            const num = (coinFlip() ? +1 : -1) * randint(1, Math.ceil(den / 2));
+            return multiply(multiply(2, PiNode), frac(num, den)).simplify({
+                towardsDistribute: false,
+            });
+        })();
+        const affixObj = { nodeModule, nodeArgument };
+        return affixObj;
+    }
+    function isPointBInFrame(pointB, coordsFrame) {
+        const [xMin, xMax, yMin, yMax] = coordsFrame;
+        const [vX, vY] = [pointB.x, pointB.y].map((node) => node.evaluate());
+        return xMin <= vX && vX <= xMax && yMin <= vY && vY <= yMax;
+    }
+    const pointA = (() => {
+        const lFrameA = lFrame - 1;
+        return new Point("A", (randint(-(lFrameA * 2), lFrameA * 2 + 1) * 0.5).toTree(), (randint(-(lFrameA * 2), lFrameA * 2 + 1) * 0.5).toTree());
+    })();
+    const { nodeModule: nodeModuleZ, nodeArgument: nodeArgumentZ } = (() => {
+        let affixObj;
+        let pointB;
+        do {
+            affixObj = createRandomAffixObj();
+            const { nodeModule, nodeArgument } = affixObj;
+            pointB = (() => {
+                const pointO = new Point("O", 0, 0);
+                const pointARotated = rotatePoint(pointA, nodeArgument.evaluate(), pointO, "ARotated");
+                const pointARotatedAndScaled = new Point("B", multiply(nodeModule, pointARotated.x), multiply(nodeModule, pointARotated.y));
+                return pointARotatedAndScaled;
+            })();
+        } while (!isPointBInFrame(pointB, coordsFrame));
+        return affixObj;
+    })();
+    const identifiers = {
+        pointIdsA: pointA.toIdentifiers(),
+        nodeIdsModuleZ: nodeModuleZ.toIdentifiers(),
+        nodeIdsArgumentZ: nodeArgumentZ.toIdentifiers(),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        ggbAnswer: getGGBAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        correctionGgbOptions: getCorrectionGGBOptions(identifiers),
+        studentGgbOptions: getStudentGGBOptions(identifiers, opts),
+    };
+    return question;
+};
+export const complexGeomPlacePointFromZATimesZ = {
+    id: "complexGeomPlacePointFromZATimesZ",
+    label: "Placer le point image d'un nombre de la forme $z_{A} \\times z$",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getComplexGeomPlacePointFromZATimesZQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "GGB",
+    isGGBAnswerValid,
+};

package/lib/exercises/math/complex/geometric/complexGeomPlacePointFromZATransformed.d.ts

@@ -0,0 +1,16 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { PointIdentifiers } from "../../../../math/geometry/point.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    pointIdsA: PointIdentifiers;
+    typeExpr: string;
+    nodeIdsModuleZ: NodeIdentifiers;
+    nodeIdsArgumentZ: NodeIdentifiers;
+    typeAffixObjZ: string;
+    nodeIdsModuleZPrime: NodeIdentifiers;
+    nodeIdsArgumentZPrime: NodeIdentifiers;
+    typeAffixObjZPrime: string;
+};
+export declare const complexGeomPlacePointFromZATransformed: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=complexGeomPlacePointFromZATransformed.d.ts.map

package/lib/exercises/math/complex/geometric/complexGeomPlacePointFromZATransformed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"complexGeomPlacePointFromZATransformed.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/complex/geometric/complexGeomPlacePointFromZATransformed.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAOrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAStC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAgG7C,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,gBAAgB,CAAC;IAC5B,QAAQ,EAAE,MAAM,CAAC;IAEjB,cAAc,EAAE,eAAe,CAAC;IAChC,gBAAgB,EAAE,eAAe,CAAC;IAClC,aAAa,EAAE,MAAM,CAAC;IAEtB,mBAAmB,EAAE,eAAe,CAAC;IACrC,qBAAqB,EAAE,eAAe,CAAC;IACvC,kBAAkB,EAAE,MAAM,CAAC;CAC5B,CAAC;AA84BF,eAAO,MAAM,sCAAsC,EAAE,QAAQ,CAAC,WAAW,CAiBxE,CAAC"}