math-exercises 3.0.214 → 3.0.215

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

@@ -0,0 +1,86 @@
+import { toolBarConstructor } from "../../../../exercises/utils/geogebra/toolBarConstructor.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { parseGGBPoints } from "../../../../geogebra/parsers/parseGGBPoints.js";
+import { Complex } from "../../../../math/complex/complex.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+const getInstruction = (identifiers) => {
+    const { im, re } = identifiers;
+    const complex = new Complex(re, im);
+    return `Dans le plan complexe ci-dessous, placer le point d'affixe :
+    
+$$
+${complex.toTree().toTex()}
+$$`;
+};
+const getHint = () => {
+    return `Si $z = x+iy$ est l'affixe d'un point du plan complexe, alors ce point a pour coordonnées $(x;y)$ dans le plan complexe.`;
+};
+const getCorrection = (identifiers) => {
+    const { im, re } = identifiers;
+    const complex = new Complex(re, im);
+    return `Si $z = x+iy$ est l'affixe d'un point du plan complexe, alors ce point a pour coordonnées $(x;y)$ dans le plan complexe.
+  
+Ici, le point a pour affixe : 
+
+$$
+${complex.toTree().toTex()}
+$$
+
+On doit donc placer le point d'abscisse $${re}$ et d'ordonnée $${im}$.`;
+};
+const getGGBAnswer = (identifiers) => {
+    const { im, re } = identifiers;
+    return [`(${re},${im})`];
+};
+const getStudentGGBOptions = () => {
+    const studentGGB = new GeogebraConstructor({
+        isGridSimple: true,
+        customToolBar: toolBarConstructor({
+            point: true,
+        }),
+    });
+    return studentGGB.getOptions({
+        coords: [-10, 10, -8, 8],
+    });
+};
+const isGGBAnswerValid = (ans, { re, im }) => {
+    const points = parseGGBPoints(ans);
+    if (points.length !== 1)
+        return false;
+    const [xAns, yAns] = points[0].replace("(", "").replace(")", "").split(",");
+    return Math.abs(Number(xAns) - re) < 0.5 && Math.abs(Number(yAns) - im) < 0.5;
+};
+const getComplexGeomPlaceAffixPointQuestion = () => {
+    const re = randint(-7, 8);
+    const im = randint(-7, 8);
+    const identifiers = { im, re };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        ggbAnswer: getGGBAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        studentGgbOptions: getStudentGGBOptions(identifiers),
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const complexGeomPlaceAffixPoint = {
+    id: "complexGeomPlaceAffixPoint",
+    label: "Placer un point d'affixe donnée dans le plan complexe",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getComplexGeomPlaceAffixPointQuestion(opts), nb),
+    ggbTimer: 60,
+    isGGBAnswerValid,
+    subject: "Mathématiques",
+    getHint,
+    getInstruction,
+    getCorrection,
+    getGGBAnswer,
+    getStudentGGBOptions,
+    answerType: "GGB",
+    hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"complexGeomPlacePointFromZAPlusZ.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/complex/geometric/complexGeomPlacePointFromZAPlusZ.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;AA4F7C,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,gBAAgB,CAAC;IAC5B,cAAc,EAAE,eAAe,CAAC;IAChC,gBAAgB,EAAE,eAAe,CAAC;CACnC,CAAC;AA2UF,eAAO,MAAM,gCAAgC,EAAE,QAAQ,CAAC,WAAW,CAgBlE,CAAC"}

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

@@ -0,0 +1,311 @@
+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";
+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 pointZ = createPointForModuleAndArgument(nodeModuleZ, nodeArgumentZ, "Z");
+        return new Point("B", add(pointA.x, pointZ.x), add(pointA.y, pointZ.y));
+    })();
+    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} + ${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 } = getHydrated(identifiers);
+    return `Soit $O$ l'origine du repère.
+Soit $z = ${nodeAffixZ.toTex()}$.
+Si $M$ est le point d'affixe $z$ alors : 
+
+$$
+z_{B} = z_{A} + z
+$$
+
+signifie :
+
+$$
+\\overrightarrow{OB} = \\overrightarrow{OA} + \\overrightarrow{OM}
+$$
+
+Autrement dit, $B$ est l'image de $A$ par la translation de vecteur $\\overrightarrow{OM}$.`;
+};
+const getCorrection = (identifiers) => {
+    const { nodeModuleZ, nodeAffixZ } = getHydrated(identifiers);
+    return `Soit $O$ l'origine du repère.
+Soit $z = ${nodeAffixZ.toTex()}$.
+Si $M$ est le point d'affixe $z$ alors : 
+
+$$
+z_{B} = z_{A} + z
+$$
+
+signifie :
+
+$$
+\\overrightarrow{OB} = \\overrightarrow{OA} + \\overrightarrow{OM}
+$$
+
+Autrement dit, $B$ est l'image de $A$ par la translation de vecteur $\\overrightarrow{OM}$.
+
+Le module de $z$ est $${nodeModuleZ.toTex()}$ donc $B$ est sur le cercle de centre $A$ et de rayon $${nodeModuleZ.toTex()}$.
+On trouve la position de $B$ sur le cercle en examinant l'argument de $z$.`;
+};
+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 precision = 5;
+    const pointF = new Point("F", add(pointA.x, nodeModuleZ), pointA.y);
+    const arrPointForAngle = arrNodeAngle.map((nodeAngle, i) => rotatePoint(pointF, nodeAngle.evaluate(), pointA, `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,
+            })),
+            //circle
+            ...[
+                `cir = Circle(${pointA.toMathString()}, ${nodeModuleZ.evaluate()})`,
+                `SetLineThickness(cir, 3)`,
+                `SetLineStyle(cir, 2)`,
+            ],
+            //segments (rays)
+            ...arrPointForAngle.flatMap((point, i) => [
+                `segRay${i} = Segment(${pointA.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,
+            })),
+            //segmentAB
+            ...[
+                `segAB = Segment(${pointA.toMathString()}, ${pointB.toMathString()})`,
+                `SetColor(segAB, "${orange}")`,
+                `SetLineThickness(segAB, 4)`,
+                `SetLineStyle(segAB, 0)`,
+                `SetCaption(segAB, "$${nodeModuleZ.toTex()}$")`,
+                `ShowLabel(segAB, true)`,
+            ],
+            //argument
+            ...(() => {
+                const isClockwise = nodeArgumentZ.evaluate() > 0;
+                return [
+                    `rayAF = Ray(${pointA.toMathString()}, ${arrPointForAngle[0].toMathString()})`,
+                    `rayAB = Ray(${pointA.toMathString()}, ${pointB.toMathString()})`,
+                    `SetVisibleInView(rayAF, 1, false)`,
+                    `SetVisibleInView(rayAB, 1, false)`,
+                    `angArg = ${isClockwise ? "Angle(rayAF, rayAB)" : "Angle(rayAB, rayAF)"}`,
+                    `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.37 + distanceBonus);
+};
+const getComplexGeomPlacePointFromZAPlusZQuestion = () => {
+    function createRandomAffixObj() {
+        const nodeModule = (1 + randint(0, lFrame * 2 - 1) * 0.5).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;
+            const pointZ = createPointForModuleAndArgument(nodeModule, nodeArgument, "Z");
+            pointB = new Point("B", add(pointA.x, pointZ.x), add(pointA.y, pointZ.y));
+        } 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 complexGeomPlacePointFromZAPlusZ = {
+    id: "complexGeomPlacePointFromZAPlusZ",
+    label: "Placer le point image d'un nombre de la forme $z_{A} + z$",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getComplexGeomPlacePointFromZAPlusZQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "GGB",
+    isGGBAnswerValid,
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"complexGeomPlacePointFromZATimesZ.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/complex/geometric/complexGeomPlacePointFromZATimesZ.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;AA8F7C,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,gBAAgB,CAAC;IAC5B,cAAc,EAAE,eAAe,CAAC;IAChC,gBAAgB,EAAE,eAAe,CAAC;CACnC,CAAC;AAgYF,eAAO,MAAM,iCAAiC,EAAE,QAAQ,CAAC,WAAW,CAgBnE,CAAC"}