math-exercises 3.0.213 → 3.0.215

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

@@ -0,0 +1,729 @@
+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 { NodeComparator } from "../../../../tree/utilities/nodeComparator.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];
+})();
+const pointO = new Point("O", 0, 0);
+//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, typeAffixObjZ, nodeIdsModuleZPrime, nodeIdsArgumentZPrime, typeAffixObjZPrime, typeExpr, } = identifiers;
+    const [nodeModuleZ, nodeArgumentZ, nodeModuleZPrime, nodeArgumentZPrime] = [
+        nodeIdsModuleZ,
+        nodeIdsArgumentZ,
+        nodeIdsModuleZPrime,
+        nodeIdsArgumentZPrime,
+    ].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const pointA = PointConstructor.fromIdentifiers(pointIdsA);
+    const affixObjZ = {
+        nodeModule: nodeModuleZ,
+        nodeArgument: nodeArgumentZ,
+        typeAffixObj: typeAffixObjZ,
+    };
+    const affixObjZPrime = {
+        nodeModule: nodeModuleZPrime,
+        nodeArgument: nodeArgumentZPrime,
+        typeAffixObj: typeAffixObjZPrime,
+    };
+    const [pointI, pointB] = (() => {
+        switch (typeExpr) {
+            case "(z_{A} + z) \\times z'": {
+                const pointTranslated = (() => {
+                    const pointZ = createPointForModuleAndArgument(affixObjZ.nodeModule, affixObjZ.nodeArgument, "Z");
+                    return new Point("ATranslated", add(pointA.x, pointZ.x), add(pointA.y, pointZ.y));
+                })();
+                const pointI = new Point("I", pointTranslated.x, pointTranslated.y);
+                const pointScaledOrRotated = (() => {
+                    switch (affixObjZPrime.typeAffixObj) {
+                        case "integer": {
+                            const nodeK = (() => {
+                                const isNegative = NodeComparator.isEqualViaSub(affixObjZPrime.nodeArgument, PiNode);
+                                return isNegative
+                                    ? multiply(-1, affixObjZPrime.nodeModule)
+                                    : affixObjZPrime.nodeModule;
+                            })();
+                            const pointScaled = new Point("ATranslatedScaled", multiply(nodeK, pointTranslated.x), multiply(nodeK, pointTranslated.y));
+                            return pointScaled;
+                        }
+                        case "exp(ia)": {
+                            const pointRotated = rotatePoint(pointTranslated, affixObjZPrime.nodeArgument.evaluate(), pointO, "ATranslatedRotated");
+                            return pointRotated;
+                        }
+                        default:
+                            throw new Error("Unsupported ");
+                    }
+                })();
+                const pointB = new Point("B", pointScaledOrRotated.x, pointScaledOrRotated.y);
+                return [pointI, pointB];
+            }
+            case "(z_{A} \\times z) + z'": {
+                const pointScaledOrRotated = (() => {
+                    switch (affixObjZ.typeAffixObj) {
+                        case "integer": {
+                            const nodeK = (() => {
+                                const isNegative = NodeComparator.isEqualViaSub(affixObjZ.nodeArgument, PiNode);
+                                return isNegative
+                                    ? multiply(-1, affixObjZ.nodeModule)
+                                    : affixObjZ.nodeModule;
+                            })();
+                            const pointScaled = new Point("AScaled", multiply(nodeK, pointA.x), multiply(nodeK, pointA.y));
+                            return pointScaled;
+                        }
+                        case "exp(ia)": {
+                            const pointRotated = rotatePoint(pointA, affixObjZ.nodeArgument.evaluate(), pointO, "ARotated");
+                            return pointRotated;
+                        }
+                        default:
+                            throw new Error("Unsupported ");
+                    }
+                })();
+                const pointI = new Point("I", pointScaledOrRotated.x, pointScaledOrRotated.y);
+                const pointScaledOrRotatedTranslated = (() => {
+                    const pointZPrime = createPointForModuleAndArgument(affixObjZPrime.nodeModule, affixObjZPrime.nodeArgument, "Z");
+                    return new Point("ATranslatedScaledOrRotated", add(pointScaledOrRotated.x, pointZPrime.x), add(pointScaledOrRotated.y, pointZPrime.y));
+                })();
+                const pointB = new Point("B", pointScaledOrRotatedTranslated.x, pointScaledOrRotatedTranslated.y);
+                return [pointI, pointB];
+            }
+            default:
+                throw new Error("Unsupported typeExpr: " + typeExpr);
+        }
+    })();
+    const [nodeAffixZ, nodeAffixZPrime] = [affixObjZ, affixObjZPrime].map((affixObj) => {
+        if (NodeComparator.isEqualViaSub(affixObj.nodeArgument, (0).toTree())) {
+            return affixObj.nodeModule;
+        }
+        else {
+            return multiply(affixObj.nodeModule, exp(multiply(nodeI, affixObj.nodeArgument.simplify({ towardsDistribute: true }))));
+        }
+    });
+    return {
+        pointA,
+        affixObjZ,
+        affixObjZPrime,
+        nodeAffixZ,
+        nodeAffixZPrime,
+        pointI,
+        pointB,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { typeExpr } = identifiers;
+    const { nodeAffixZ, nodeAffixZPrime } = 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 : 
+
+${(() => {
+        switch (typeExpr) {
+            case "(z_{A} + z) \\times z'": {
+                return `
+
+$$
+z_{B} = (z_{A} + (${nodeAffixZ.toTex()})) \\times (${nodeAffixZPrime.toTex()}) 
+$$
+
+`;
+            }
+            case "(z_{A} \\times z) + z'": {
+                return `
+
+$$
+z_{B} = (z_{A} \\times (${nodeAffixZ.toTex()})) + (${nodeAffixZPrime.toTex()}) 
+$$
+
+`;
+            }
+            default:
+                throw new Error("Unsupported typeExpr: " + typeExpr);
+        }
+    })()}
+
+
+`;
+};
+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 = () => {
+    return `Le point $B$ est l'image du point $A$ par un enchaînement de $2$ transformations.
+Dans l'expression de l'affixe de $z_{B}$, identifie la sous-expression la plus interne pour déterminer quelle est la transformation qui se produit en premier,
+et ainsi pouvoir placer mentalement un point intermédiaire qui va subir la dernière transformation.`;
+};
+const getCorrection = (identifiers) => {
+    const { typeExpr } = identifiers;
+    const { affixObjZ, affixObjZPrime, nodeAffixZ, nodeAffixZPrime } = getHydrated(identifiers);
+    switch (typeExpr) {
+        case "(z_{A} + z) \\times z'": {
+            const isZPrimeIntegerNegative = affixObjZPrime.typeAffixObj === "integer" &&
+                NodeComparator.isEqualViaSub(affixObjZPrime.nodeArgument, PiNode);
+            return `Soit $O$ l'origine du repère.
+Soit $M$ le point d'affixe $z = ${nodeAffixZ.toTex()}$.
+Soit $I$ le point d'abscisse $z_{I}$ tel que :
+
+$$
+z_{I} = z_{A} + (${nodeAffixZ.toTex()})
+$$
+
+$I$ est l'image du point $A$ par la translation de vecteur $\\overrightarrow{OM}$.
+
+${alignTex([
+                ["z_{B}", "=", `z_{I} \\times (${nodeAffixZPrime.toTex()})`],
+                ...(isZPrimeIntegerNegative
+                    ? [["", "=", `z_{I} \\times (-${affixObjZPrime.nodeModule.toTex()})`]]
+                    : [[]]),
+            ])}
+
+${(() => {
+                switch (affixObjZPrime.typeAffixObj) {
+                    case "integer": {
+                        const nodeK = isZPrimeIntegerNegative
+                            ? multiply(-1, affixObjZPrime.nodeModule)
+                            : affixObjZPrime.nodeModule;
+                        return `$B$ est l'image du point $I$ par l'homothétie de centre $O$ et de rapport $${nodeK.toTex()}$.`;
+                    }
+                    case "exp(ia)":
+                        return `$B$ est l'image du point $I$ par la rotation de centre $O$ et d'angle $${affixObjZPrime.nodeArgument.toTex()}$.`;
+                    default:
+                        throw new Error("Unsupported typeAffixObj: " + affixObjZPrime.typeAffixObj);
+                }
+            })()}
+
+`;
+        }
+        case "(z_{A} \\times z) + z'": {
+            const isZIntegerNegative = affixObjZ.typeAffixObj === "integer" &&
+                NodeComparator.isEqualViaSub(affixObjZ.nodeArgument, PiNode);
+            return `Soit $O$ l'origine du repère.
+Soit $I$ le point d'abscisse $z_{I}$ tel que :
+
+${alignTex([
+                ["z_{I}", "=", `z_{A} \\times (${nodeAffixZ.toTex()})`],
+                ...(isZIntegerNegative
+                    ? [["", "=", `z_{A} \\times (-${affixObjZ.nodeModule.toTex()})`]]
+                    : [[]]),
+            ])}
+
+
+${(() => {
+                switch (affixObjZ.typeAffixObj) {
+                    case "integer": {
+                        const nodeK = isZIntegerNegative
+                            ? multiply(-1, affixObjZ.nodeModule)
+                            : affixObjZ.nodeModule;
+                        return `$I$ est l'image du point $A$ par l'homothétie de centre $O$ et de rapport $${nodeK.toTex()}$.`;
+                    }
+                    case "exp(ia)":
+                        return `$I$ est l'image du point $A$ par la rotation de centre $O$ et d'angle $${affixObjZ.nodeArgument.toTex()}$.`;
+                    default:
+                        throw new Error("Unsupported typeAffixObj: " + affixObjZ.typeAffixObj);
+                }
+            })()}
+
+Soit $M'$ le point d'affixe $z' = ${nodeAffixZPrime.toTex()}$.
+
+$$
+z_{B} = z_{I} + (${nodeAffixZPrime.toTex()})
+$$
+
+$B$ est l'image du point $I$ par la translation de vecteur $\\overrightarrow{OM'}$.
+
+`;
+        }
+        default:
+            throw new Error("Unsupported typeExpr: " + typeExpr);
+    }
+};
+const getCorrectionGGBOptions = (identifiers) => {
+    const { typeExpr } = identifiers;
+    const { affixObjZ, affixObjZPrime, pointA, pointB, pointI } = getHydrated(identifiers);
+    const strLineColor = `"${colorWithOpacity("#000000", 26)}"`;
+    const commands = (() => {
+        switch (typeExpr) {
+            case "(z_{A} + z) \\times z'": {
+                return [
+                    ...[pointA].flatMap((point) => point.toGGBCommand({
+                        isFixed: true,
+                        isSelectionnable: true,
+                        showLabel: true,
+                        // style: 1,
+                    })),
+                    //vecAI
+                    ...[
+                        `vecAI = Vector(${pointA.toMathString()}, ${pointI.toMathString()})`,
+                        `SetColor(vecAI, "${orange}")`,
+                    ],
+                    //pointI
+                    ...[pointI].flatMap((point) => point.toGGBCommand({
+                        isFixed: true,
+                        isSelectionnable: true,
+                        showLabel: true,
+                        // style: 1,
+                        color: orange,
+                    })),
+                    ...(() => {
+                        switch (affixObjZPrime.typeAffixObj) {
+                            case "integer": {
+                                return [
+                                    //circles
+                                    ...[
+                                        `cirI = Circle(${pointO.toMathString()}, ${pointI.toMathString()})`,
+                                        `SetLineThickness(cirI, 1)`,
+                                        `SetLineStyle(cirI, 2)`,
+                                    ],
+                                    ...[
+                                        `cirB = Circle(${pointO.toMathString()}, ${pointB.toMathString()})`,
+                                        `SetLineThickness(cirB, 1)`,
+                                        `SetLineStyle(cirB, 2)`,
+                                    ],
+                                ];
+                            }
+                            case "exp(ia)": {
+                                const nodeAngleBase = (() => {
+                                    const nodeAbsArgumentZPrime = abs(affixObjZPrime.nodeArgument).simplify({
+                                        towardsDistribute: false,
+                                    });
+                                    if (isFractionNode(nodeAbsArgumentZPrime)) {
+                                        const nodeDen = nodeAbsArgumentZPrime.rightChild;
+                                        return frac(PiNode, nodeDen);
+                                    }
+                                    else {
+                                        throw new Error("isFractionNode(nodeAbsArgumentZPrime) === false");
+                                    }
+                                })();
+                                const nbRays = frac(multiply(2, PiNode), nodeAngleBase)
+                                    .simplify({ towardsDistribute: false })
+                                    .evaluate();
+                                const arrNodeAngle = [...Array(nbRays).keys()].map((i) => multiply(i, nodeAngleBase));
+                                const precision = 5;
+                                const pointO = new Point("O", 0, 0);
+                                const arrPointForAngle = arrNodeAngle.map((nodeAngle, i) => rotatePoint(pointI, nodeAngle.evaluate(), pointO, `PF${i}`, precision));
+                                return [
+                                    //circles
+                                    ...[
+                                        `cirI = Circle(${pointO.toMathString()}, ${pointI.toMathString()})`,
+                                        `SetLineThickness(cirI, 1)`,
+                                        `SetLineStyle(cirI, 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)`,
+                                    ]),
+                                    //argument
+                                    ...(() => {
+                                        const isClockwise = affixObjZPrime.nodeArgument.evaluate() > 0;
+                                        return [
+                                            `rayOI = Ray(${pointO.toMathString()}, ${pointI.toMathString()})`,
+                                            `rayOB = Ray(${pointO.toMathString()}, ${pointB.toMathString()})`,
+                                            `SetVisibleInView(rayOI, 1, false)`,
+                                            `SetVisibleInView(rayOB, 1, false)`,
+                                            `angArg = ${isClockwise
+                                                ? "Angle(rayOI, rayOB)"
+                                                : "Angle(rayOB, rayOI)"}`,
+                                            `SetDecoration(angArg, ${isClockwise ? 6 : 7})`,
+                                            `SetColor(angArg, "${orange}")`,
+                                            `SetCaption(angArg, "$\\\\ \\\\ \\ \\ ${affixObjZPrime.nodeArgument.toTex()}$")`,
+                                            `ShowLabel(angArg, true)`,
+                                        ];
+                                    })(),
+                                ];
+                            }
+                            default:
+                                throw new Error("Unsupported typeAffixObj: " + affixObjZPrime.typeAffixObj);
+                        }
+                    })(),
+                    //pointB
+                    ...[pointB].flatMap((point) => point.toGGBCommand({
+                        isFixed: true,
+                        isSelectionnable: true,
+                        showLabel: true,
+                        // style: 1,
+                        color: greenMain,
+                    })),
+                ];
+            }
+            case "(z_{A} \\times z) + z'": {
+                return [
+                    ...[pointA].flatMap((point) => point.toGGBCommand({
+                        isFixed: true,
+                        isSelectionnable: true,
+                        showLabel: true,
+                        // style: 1,
+                    })),
+                    ...(() => {
+                        switch (affixObjZ.typeAffixObj) {
+                            case "integer": {
+                                return [
+                                    //circles
+                                    ...[
+                                        `cirA = Circle(${pointO.toMathString()}, ${pointA.toMathString()})`,
+                                        `SetLineThickness(cirA, 1)`,
+                                        `SetLineStyle(cirA, 2)`,
+                                    ],
+                                    ...[
+                                        `cirI = Circle(${pointO.toMathString()}, ${pointI.toMathString()})`,
+                                        `SetLineThickness(cirI, 1)`,
+                                        `SetLineStyle(cirI, 2)`,
+                                    ],
+                                ];
+                            }
+                            case "exp(ia)": {
+                                const nodeAngleBase = (() => {
+                                    const nodeAbsArgumentZ = abs(affixObjZ.nodeArgument).simplify({
+                                        towardsDistribute: false,
+                                    });
+                                    if (isFractionNode(nodeAbsArgumentZ)) {
+                                        const nodeDen = nodeAbsArgumentZ.rightChild;
+                                        return frac(PiNode, nodeDen);
+                                    }
+                                    else {
+                                        throw new Error("isFractionNode(nodeAbsArgumentZPrime) === false");
+                                    }
+                                })();
+                                const nbRays = frac(multiply(2, PiNode), nodeAngleBase)
+                                    .simplify({ towardsDistribute: false })
+                                    .evaluate();
+                                const arrNodeAngle = [...Array(nbRays).keys()].map((i) => multiply(i, nodeAngleBase));
+                                const precision = 5;
+                                const pointO = new Point("O", 0, 0);
+                                const arrPointForAngle = arrNodeAngle.map((nodeAngle, i) => rotatePoint(pointA, nodeAngle.evaluate(), pointO, `PF${i}`, precision));
+                                return [
+                                    //circles
+                                    ...[
+                                        `cirA = Circle(${pointO.toMathString()}, ${pointA.toMathString()})`,
+                                        `SetLineThickness(cirA, 1)`,
+                                        `SetLineStyle(cirA, 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)`,
+                                    ]),
+                                    //argument
+                                    ...(() => {
+                                        const isClockwise = affixObjZPrime.nodeArgument.evaluate() > 0;
+                                        return [
+                                            `rayOA = Ray(${pointO.toMathString()}, ${pointA.toMathString()})`,
+                                            `rayOI = Ray(${pointO.toMathString()}, ${pointI.toMathString()})`,
+                                            `SetVisibleInView(rayOA, 1, false)`,
+                                            `SetVisibleInView(rayOI, 1, false)`,
+                                            `angArg = ${isClockwise
+                                                ? "Angle(rayOA, rayOI)"
+                                                : "Angle(rayOI, rayOA)"}`,
+                                            `SetDecoration(angArg, ${isClockwise ? 6 : 7})`,
+                                            `SetColor(angArg, "${orange}")`,
+                                            `SetCaption(angArg, "$\\\\ \\\\ \\ \\ ${affixObjZPrime.nodeArgument.toTex()}$")`,
+                                            `ShowLabel(angArg, true)`,
+                                        ];
+                                    })(),
+                                ];
+                            }
+                            default:
+                                throw new Error("Unsupported typeAffixObj: " + affixObjZPrime.typeAffixObj);
+                        }
+                    })(),
+                    //pointI
+                    ...[pointI].flatMap((point) => point.toGGBCommand({
+                        isFixed: true,
+                        isSelectionnable: true,
+                        showLabel: true,
+                        // style: 1,
+                        color: orange,
+                    })),
+                    //vecIB
+                    ...[
+                        `vecIB = Vector(${pointI.toMathString()}, ${pointB.toMathString()})`,
+                        `SetColor(vecIB, "${orange}")`,
+                    ],
+                    //pointB
+                    ...[pointB].flatMap((point) => point.toGGBCommand({
+                        isFixed: true,
+                        isSelectionnable: true,
+                        showLabel: true,
+                        // style: 1,
+                        color: greenMain,
+                    })),
+                ];
+            }
+            default:
+                throw new Error("Unsupported typeExpr: " + typeExpr);
+        }
+    })();
+    const ggb = new GeogebraConstructor({
+        isGridSimple: true,
+        commands,
+        fontSize: 16,
+    });
+    return ggb.getOptions({
+        coords: coordsFrame,
+    });
+};
+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 } = getHydrated(identifiers);
+    const pointCoords = parseGGBPoints(ggbAns).map((p) => ggbPointToCoords(p));
+    if (pointCoords.length !== 1)
+        return false;
+    const distanceBonus = 0;
+    return (new Point("K", pointCoords[0].x, pointCoords[0].y).distanceTo(pointB) <
+        0.67 + distanceBonus);
+};
+const getComplexGeomPlacePointFromZATransformedQuestion = () => {
+    const pointO = new Point("O", 0, 0);
+    const typeExpr = random(["(z_{A} + z) \\times z'", "(z_{A} \\times z) + z'"]);
+    function createRandomAffixObj(typeAffixObj) {
+        let nodeModule;
+        let nodeArgument;
+        switch (typeAffixObj) {
+            case "integer":
+                {
+                    nodeArgument = random([(0).toTree(), PiNode]);
+                    nodeModule = (() => {
+                        if (NodeComparator.isEqualViaSub(nodeArgument, (0).toTree())) {
+                            return randint(2, 4).toTree();
+                        }
+                        else {
+                            return randint(1, 4).toTree();
+                        }
+                    })();
+                }
+                break;
+            case "cross":
+                {
+                    nodeModule = randint(1, 3).toTree();
+                    nodeArgument = (() => {
+                        const den = 4;
+                        const num = (coinFlip() ? +1 : -1) * randint(0, Math.ceil(den / 2));
+                        return multiply(multiply(2, PiNode), frac(num, den)).simplify({
+                            towardsDistribute: false,
+                        });
+                    })();
+                }
+                break;
+            case "exp(ia)":
+                {
+                    nodeModule = (1).toTree();
+                    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,
+                        });
+                    })();
+                }
+                break;
+            default:
+                throw new Error("Unsupported typeAffixObj: " + typeAffixObj);
+        }
+        const affixObj = { nodeModule, nodeArgument, typeAffixObj };
+        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, affixObjZ, affixObjZPrime } = (() => {
+        let pointA;
+        let affixObjZ;
+        let affixObjZPrime;
+        let pointB;
+        do {
+            const lFrameA = lFrame - 1;
+            pointA = new Point("A", (randint(-(lFrameA * 2), lFrameA * 2 + 1) * 0.5).toTree(), (randint(-(lFrameA * 2), lFrameA * 2 + 1) * 0.5).toTree());
+            [affixObjZ, affixObjZPrime] = (() => {
+                switch (typeExpr) {
+                    case "(z_{A} + z) \\times z'": {
+                        const typeAffixObjZ = random(["cross", "exp(ia)"]);
+                        const typeAffixObjZPrime = random(["integer", "exp(ia)"]);
+                        const [affixObjZ, affixObjZPrime] = [
+                            typeAffixObjZ,
+                            typeAffixObjZPrime,
+                        ].map((typeAffixObj) => createRandomAffixObj(typeAffixObj));
+                        return [affixObjZ, affixObjZPrime];
+                    }
+                    case "(z_{A} \\times z) + z'": {
+                        const typeAffixObjZ = random(["integer", "exp(ia)"]);
+                        const typeAffixObjZPrime = random(["cross", "exp(ia)"]);
+                        const [affixObjZ, affixObjZPrime] = [
+                            typeAffixObjZ,
+                            typeAffixObjZPrime,
+                        ].map((typeAffixObj) => createRandomAffixObj(typeAffixObj));
+                        return [affixObjZ, affixObjZPrime];
+                    }
+                    default:
+                        throw new Error("Unsupported typeExpr: " + typeExpr);
+                }
+            })();
+            pointB = (() => {
+                switch (typeExpr) {
+                    case "(z_{A} + z) \\times z'": {
+                        const pointTranslated = (() => {
+                            const pointZ = createPointForModuleAndArgument(affixObjZ.nodeModule, affixObjZ.nodeArgument, "Z");
+                            return new Point("ATranslated", add(pointA.x, pointZ.x), add(pointA.y, pointZ.y));
+                        })();
+                        const pointScaledOrRotated = (() => {
+                            switch (affixObjZPrime.typeAffixObj) {
+                                case "integer": {
+                                    const pointScaled = new Point("ATranslatedScaled", multiply(affixObjZPrime.nodeModule, pointTranslated.x), multiply(affixObjZPrime.nodeModule, pointTranslated.y));
+                                    return pointScaled;
+                                }
+                                case "exp(ia)": {
+                                    const pointRotated = rotatePoint(pointTranslated, affixObjZPrime.nodeArgument.evaluate(), pointO, "ATranslatedRotated");
+                                    return pointRotated;
+                                }
+                                default:
+                                    throw new Error("Unsupported ");
+                            }
+                        })();
+                        const pointB = new Point("B", pointScaledOrRotated.x, pointScaledOrRotated.y);
+                        return pointB;
+                    }
+                    case "(z_{A} \\times z) + z'": {
+                        const pointScaledOrRotated = (() => {
+                            switch (affixObjZ.typeAffixObj) {
+                                case "integer": {
+                                    const pointScaled = new Point("AScaled", multiply(affixObjZ.nodeModule, pointA.x), multiply(affixObjZ.nodeModule, pointA.y));
+                                    return pointScaled;
+                                }
+                                case "exp(ia)": {
+                                    const pointRotated = rotatePoint(pointA, affixObjZ.nodeArgument.evaluate(), pointO, "ARotated");
+                                    return pointRotated;
+                                }
+                                default:
+                                    throw new Error("Unsupported ");
+                            }
+                        })();
+                        const pointScaledOrRotatedTranslated = (() => {
+                            const pointZPrime = createPointForModuleAndArgument(affixObjZPrime.nodeModule, affixObjZPrime.nodeArgument, "Z");
+                            return new Point("ATranslatedScaledOrRotated", add(pointScaledOrRotated.x, pointZPrime.x), add(pointScaledOrRotated.y, pointZPrime.y));
+                        })();
+                        const pointB = new Point("B", pointScaledOrRotatedTranslated.x, pointScaledOrRotatedTranslated.y);
+                        return pointB;
+                    }
+                    default:
+                        throw new Error("Unsupported typeExpr: " + typeExpr);
+                }
+            })();
+        } while (!isPointBInFrame(pointB, coordsFrame));
+        return { pointA, affixObjZ, affixObjZPrime };
+    })();
+    const identifiers = {
+        pointIdsA: pointA.toIdentifiers(),
+        typeExpr,
+        nodeIdsModuleZ: affixObjZ.nodeModule.toIdentifiers(),
+        nodeIdsArgumentZ: affixObjZ.nodeArgument.toIdentifiers(),
+        typeAffixObjZ: affixObjZ.typeAffixObj,
+        nodeIdsModuleZPrime: affixObjZPrime.nodeModule.toIdentifiers(),
+        nodeIdsArgumentZPrime: affixObjZPrime.nodeArgument.toIdentifiers(),
+        typeAffixObjZPrime: affixObjZPrime.typeAffixObj,
+    };
+    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 complexGeomPlacePointFromZATransformed = {
+    id: "complexGeomPlacePointFromZATransformed",
+    label: "Placer le point image d'un nombre de la forme $(z_{A} + z) \\times z'$ ou $(z_{A} \\times z) + z'$",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getComplexGeomPlacePointFromZATransformedQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "GGB",
+    isGGBAnswerValid,
+};