math-exercises 3.0.213 → 3.0.215

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

@@ -0,0 +1,459 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, propWhile, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { blueExtraDark, colorWithOpacity } from "../../../../geogebra/colors.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { Point } 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 { exp, isExpNode } from "../../../../tree/nodes/functions/expNode.js";
+import { isOppositeNode } from "../../../../tree/nodes/functions/oppositeNode.js";
+import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
+import { isNumberNode } from "../../../../tree/nodes/numbers/numberNode.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 { isMultiplyNode, multiply, } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { VariableNode } from "../../../../tree/nodes/variables/variableNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { NodeComparator } from "../../../../tree/utilities/nodeComparator.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { probaFlip } from "../../../../utils/alea/probaFlip.js";
+import { random } from "../../../../utils/alea/random.js";
+import { zip } from "../../../../utils/arrays/arrayZip.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+//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 getHydrated = (identifiers) => {
+    const { nodeIdsModule, vFactor, nbSides } = identifiers;
+    const [nodeModule] = [nodeIdsModule].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const nodeAngleBase = frac(multiply(2, PiNode), nbSides);
+    const nodeArgument = multiply(vFactor, nodeAngleBase);
+    const nodeAffix = multiply(nodeModule, exp(multiply(nodeI, nodeArgument)));
+    const nodeAffixSimplified = multiply(nodeModule, exp(multiply(nodeI, nodeArgument.simplify({ towardsDistribute: true }))));
+    return {
+        nodeAngleBase,
+        nodeModule,
+        nodeArgument,
+        vFactor,
+        nodeAffix,
+        nodeAffixSimplified,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { nbSides } = identifiers;
+    return `Un polygone régulier à $${nbSides}$ côtés centré en l'origine est représenté ci-dessous.
+Donner l'affixe du point $M$, sous forme exponentielle.'`;
+};
+const getAnswerNode = (identifiers) => {
+    const { nodeAffixSimplified } = getHydrated(identifiers);
+    return nodeAffixSimplified;
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).toTex();
+};
+const getHint = (identifiers) => {
+    const { nbSides } = identifiers;
+    const { nodeModule } = getHydrated(identifiers);
+    return `Soit $z$ l'affixe du point $M$. 
+L'écriture sous forme exponentielle de $z$ est :
+  
+$$
+m \\ e^{i \\alpha}
+$$
+
+avec $m$ le module de $z$ et $\\alpha$ un argument de $z$.
+
+Le module de $z$ est la distance du point $M$ à l'origine $O$.
+L'argument principal de $z$ est l'angle orienté $(\\overrightarrow{OM}, \\overrightarrow{u})$, avec $\\overrightarrow{u}$ le vecteur unitaire de l'axe des réels.
+
+Tu peux remarquer que le polygone est inscrit dans un cercle de rayon $${nodeModule.toTex()}$.
+Tu peux aussi remarquer que l'angle plein ($2 \\pi$) est divisé en $${nbSides}$.`;
+};
+const getCorrection = (identifiers) => {
+    const { nbSides } = identifiers;
+    const { nodeModule, nodeArgument, nodeAffixSimplified } = getHydrated(identifiers);
+    const nodeArgumentSimplified = nodeArgument.simplify({
+        towardsDistribute: false,
+    });
+    const [texArgument, texArgumentSimplified] = [
+        nodeArgument,
+        nodeArgumentSimplified,
+    ].map((node) => node.toTex());
+    return `Le point $M$ appartient au polygone régulier à $${nbSides}$ côtés inscrit dans le cercle centré sur l'origine et de rayon $${nodeModule.toTex()}$. 
+Son module est donc $${nodeModule.toTex()}$.
+On remarque que l'angle plein ($2 \\pi$) est divisé en $${nbSides}$. 
+On peut calculer l'argument principal de l'affixe de $M$ : 
+
+$$
+${texArgument} = ${texArgumentSimplified}
+$$
+  
+L'affixe du point $M$ est donc $${nodeAffixSimplified.toTex()}$.`;
+};
+const getCorrectionGGBOptions = (identifiers) => {
+    const { vFactor } = identifiers;
+    const { nodeAngleBase, nodeArgument, nodeModule } = getHydrated(identifiers);
+    const nbRays = frac(multiply(2, PiNode), nodeAngleBase)
+        .simplify({ towardsDistribute: false })
+        .evaluate();
+    const arrNodeAngle = [...Array(nbRays).keys()].map((i) => multiply(i, nodeAngleBase));
+    const pointO = new Point("O", 0, 0);
+    const pointA = new Point("A", nodeModule, 0);
+    const precision = 5;
+    const arrPointForAngle = arrNodeAngle.map((nodeAngle, i) => rotatePoint(pointA, nodeAngle.evaluate(), pointO, `PA${i}`, precision));
+    const strLineColor = `"${colorWithOpacity("#000000", 26)}"`;
+    const pointAM = new Point("AM", nodeModule, 0);
+    const pointM = rotatePoint(pointAM, nodeArgument.evaluate(), pointO, "M", precision);
+    const pointRadius = (() => {
+        const vFactorRadius = vFactor === 1 ? 2 : 1;
+        const nodeArgumentRadius = multiply(vFactorRadius, nodeAngleBase);
+        return rotatePoint(pointAM, nodeArgumentRadius.evaluate(), pointO, "PR", precision);
+    })();
+    const ggb = new GeogebraConstructor({
+        isGridSimple: true,
+        commands: [
+            //circle
+            ...[
+                `cir = Circle((0,0), ${pointM.toMathString()})`,
+                `SetLineThickness(cir, 1)`,
+            ],
+            //angle
+            ...[
+                `ray0 = Ray(${pointO.toMathString()}, ${arrPointForAngle[0].toMathString()})`,
+                `SetVisibleInView(ray0, 1, false)`,
+                `rayM = Ray(${pointO.toMathString()}, ${arrPointForAngle[1].toMathString()})`,
+                `SetVisibleInView(rayM, 1, false)`,
+                `segAng = Segment(${pointO.toMathString()}, ${arrPointForAngle[1].toMathString()})`,
+                `SetColor(segAng, ${strLineColor})`,
+                `SetLineThickness(segAng, 1)`,
+                `ang = Angle(ray0, rayM)`,
+                `SetCaption(ang, "$\\\\ \\\\ \\ \\ \\footnotesize{${nodeAngleBase.toTex()}}$")`,
+                `ShowLabel(ang, true)`,
+            ],
+            //segments (rays)
+            ...arrPointForAngle
+                .slice(2)
+                .flatMap((point, i) => [
+                `segRay${i} = Segment(${pointO.toMathString()}, ${point.toMathString()})`,
+                `SetColor(segRay${i}, ${strLineColor})`,
+                `SetLineThickness(segRay${i}, 1)`,
+                `SetLineStyle(segRay${i}, 1)`,
+            ]),
+            //segments
+            ...zip(arrPointForAngle, [
+                ...arrPointForAngle.slice(1),
+                arrPointForAngle[0],
+            ]).flatMap(([pointStart, pointEnd], i) => [
+                `segPol${i} = Segment(${pointStart.toMathString()}, ${pointEnd.toMathString()})`,
+                `SetColor(segPol${i}, "${blueExtraDark}")`,
+                `SetLineThickness(segPol${i}, 3)`,
+            ]),
+            //radius
+            ...[
+                // `PR = ${pointRadius.toMathString()}`,
+                // `SetFixed(PR, true, false)`,
+                // `SetVisibleInView(PR, 1, false)`,
+                `segRadius = Segment(${pointO.toMathString()}, ${pointRadius.toMathString()})`,
+                `SetColor(segRadius, ${strLineColor})`,
+                `SetLineThickness(segRadius, 2)`,
+                `SetLineStyle(segRadius, 1)`,
+                `SetCaption(segRadius, "$\\footnotesize{${nodeModule.toTex()}}$")`,
+                `ShowLabel(segRadius, true)`,
+            ],
+            //pointM
+            ...[
+                `M = ${pointM.toMathString()}`,
+                `SetFixed(M, true, false)`,
+                `ShowLabel(M, true)`,
+            ],
+            //pointO
+            ...[
+                `O = ${pointO.toMathString()}`,
+                `SetFixed(O, true, false)`,
+                `ShowLabel(O, true)`,
+            ],
+        ],
+        fontSize: 16,
+        xAxis: {
+            hideNumbers: true,
+        },
+        yAxis: {
+            hideNumbers: true,
+        },
+    });
+    const radius = nodeModule.evaluate();
+    const lForFrame = radius + 0.1;
+    return ggb.getOptions({
+        coords: [-lForFrame, lForFrame, -lForFrame, lForFrame],
+    });
+};
+const getGGBOptions = (identifiers) => {
+    const { nodeAngleBase, nodeArgument, nodeModule, vFactor } = getHydrated(identifiers);
+    const nbRays = frac(multiply(2, PiNode), nodeAngleBase)
+        .simplify({ towardsDistribute: false })
+        .evaluate();
+    const arrNodeAngle = [...Array(nbRays).keys()].map((i) => multiply(i, nodeAngleBase));
+    const pointO = new Point("O", 0, 0);
+    const pointA = new Point("A", nodeModule, 0);
+    const precision = 5;
+    const arrPointForAngle = arrNodeAngle.map((nodeAngle, i) => rotatePoint(pointA, nodeAngle.evaluate(), pointO, `PA${i}`, precision));
+    const strLineColor = `"${colorWithOpacity("#000000", 26)}"`;
+    const pointAM = new Point("AM", nodeModule, 0);
+    const pointM = rotatePoint(pointAM, nodeArgument.evaluate(), pointO, "M", precision);
+    const pointRadius = (() => {
+        const vFactorRadius = vFactor === 1 ? 2 : 1;
+        const nodeArgumentRadius = multiply(vFactorRadius, nodeAngleBase);
+        return rotatePoint(pointAM, nodeArgumentRadius.evaluate(), pointO, "PR", precision);
+    })();
+    const ggb = new GeogebraConstructor({
+        isGridSimple: true,
+        commands: [
+            //segments
+            ...zip(arrPointForAngle, [
+                ...arrPointForAngle.slice(1),
+                arrPointForAngle[0],
+            ]).flatMap(([pointStart, pointEnd], i) => [
+                `segPol${i} = Segment(${pointStart.toMathString()}, ${pointEnd.toMathString()})`,
+                `SetColor(segPol${i}, "${blueExtraDark}")`,
+                `SetLineThickness(segPol${i}, 3)`,
+            ]),
+            //radius
+            ...[
+                `segRadius = Segment(${pointO.toMathString()}, ${pointRadius.toMathString()})`,
+                `SetColor(segRadius, ${strLineColor})`,
+                `SetLineThickness(segRadius, 2)`,
+                `SetLineStyle(segRadius, 1)`,
+                `SetCaption(segRadius, "$${nodeModule.toTex()}$")`,
+                `ShowLabel(segRadius, true)`,
+            ],
+            //pointM
+            ...[
+                `M = ${pointM.toMathString()}`,
+                `SetFixed(M, true, false)`,
+                `ShowLabel(M, true)`,
+            ],
+        ],
+        fontSize: 16,
+        xAxis: {
+            hideNumbers: true,
+        },
+        yAxis: {
+            hideNumbers: true,
+        },
+    });
+    const radius = nodeModule.evaluate();
+    const lForFrame = radius + 0.1;
+    return ggb.getOptions({
+        coords: [-lForFrame, lForFrame, -lForFrame, lForFrame],
+    });
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const { nbSides } = identifiers;
+    const { nodeModule: nodeModulePure, nodeArgument, nodeAngleBase, vFactor, } = getHydrated(identifiers);
+    function createNodeAffixSimplified(nodeModule, nodeArgument) {
+        const nodeAffixSimplified = multiply(nodeModule, exp(multiply(nodeI, nodeArgument.simplify({ towardsDistribute: true }))));
+        return nodeAffixSimplified;
+    }
+    const isTerrorWrtModule = probaFlip(0.39);
+    const nodeModule = (() => {
+        if (isTerrorWrtModule) {
+            return (1).toTree();
+        }
+        else {
+            return nodeModulePure;
+        }
+    })();
+    //student: reads wrong angle: offset
+    if (Math.abs(vFactor) > 2) {
+        const nodeArgumentWrong = add(nodeArgument, multiply(coinFlip() ? +1 : -1, nodeAngleBase)).simplify({ towardsDistribute: false });
+        const nodeAffixSimplified = createNodeAffixSimplified(nodeModule, nodeArgumentWrong);
+        tryToAddWrongProp(propositions, nodeAffixSimplified.toTex());
+    }
+    //student: pi instead of 2 pi
+    {
+        const nodeArgumentWrong = frac(nodeArgument, 2).simplify({
+            towardsDistribute: false,
+        });
+        const nodeAffixSimplified = createNodeAffixSimplified(nodeModule, nodeArgumentWrong);
+        tryToAddWrongProp(propositions, nodeAffixSimplified.toTex());
+    }
+    //student: mistake wrt base angle
+    {
+        const nbSidesWrong = nbSides + (coinFlip() ? +1 : -1);
+        const identifiersWrong = {
+            ...identifiers,
+            nbSides: nbSidesWrong,
+        };
+        tryToAddWrongProp(propositions, getAnswer(identifiersWrong));
+    }
+    //filler
+    propWhile(propositions, n, () => {
+        //student: pi instead of 2 pi
+        const vFactorWrong = (coinFlip() ? +1 : -1) * randint(1, Math.ceil(nbSides / 2));
+        const nodeAngleBaseWrong = frac(PiNode, nbSides);
+        const nodeArgumentWrong = multiply(vFactorWrong, nodeAngleBaseWrong);
+        const nodeAffixSimplified = createNodeAffixSimplified(nodeModule, nodeArgumentWrong);
+        tryToAddWrongProp(propositions, nodeAffixSimplified.toTex());
+    });
+    return shuffleProps(propositions, n);
+};
+const getKeys = () => {
+    return ["epower", "i", "pi"];
+};
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
+    try {
+        const nodeAns = parseAlgebraic(ans);
+        const [nodeModuleAns, nodeArgumentAns] = (() => {
+            if (isMultiplyNode(nodeAns)) {
+                if (isExpNode(nodeAns.leftChild)) {
+                    if (isNumberNode(nodeAns.rightChild) ||
+                        isOppositeNode(nodeAns.rightChild) ||
+                        isFractionNode(nodeAns.rightChild)) {
+                        const nodeModule = nodeAns.rightChild;
+                        const nodeExp = nodeAns.leftChild;
+                        const nodeArgument = frac(nodeExp.child, nodeI).simplify({
+                            towardsDistribute: false,
+                        });
+                        return [nodeModule, nodeArgument];
+                    }
+                    else {
+                        return [undefined, nodeAns.leftChild];
+                    }
+                }
+                else if (isExpNode(nodeAns.rightChild)) {
+                    if (isNumberNode(nodeAns.leftChild) ||
+                        isOppositeNode(nodeAns.leftChild) ||
+                        isFractionNode(nodeAns.leftChild)) {
+                        const nodeModule = nodeAns.leftChild;
+                        const nodeExp = nodeAns.rightChild;
+                        const nodeArgument = frac(nodeExp.child, nodeI).simplify({
+                            towardsDistribute: false,
+                        });
+                        return [nodeModule, nodeArgument];
+                    }
+                    else {
+                        return [undefined, nodeAns.leftChild];
+                    }
+                }
+                else {
+                    return [undefined, nodeAns.leftChild];
+                }
+            }
+            else if (isExpNode(nodeAns)) {
+                const nodeExp = nodeAns;
+                const nodeArgument = frac(nodeExp.child, nodeI).simplify({
+                    towardsDistribute: false,
+                });
+                const nodeModule = (1).toTree();
+                return [nodeModule, nodeArgument];
+            }
+            else {
+                return [undefined, undefined];
+            }
+        })();
+        if (nodeModuleAns === undefined || nodeArgumentAns === undefined) {
+            return false;
+        }
+        const { nodeModule: nodeModuleAnswer, nodeArgument: nodeArgumentAnswer } = getHydrated(identifiers);
+        const isModuleValid = (nodeModule) => {
+            return (NodeComparator.isEqualViaSub(nodeModule, nodeModuleAnswer) ||
+                NodeComparator.isEqualViaFrac(nodeModule, nodeModuleAnswer));
+        };
+        const isArgumentValid = (nodeArgument) => {
+            const nodeSub = substract(nodeArgument, nodeArgumentAnswer).simplify({
+                towardsDistribute: false,
+            });
+            const nodeFrac = frac(nodeSub, PiNode).simplify({
+                towardsDistribute: false,
+            });
+            const vFrac = nodeFrac.evaluate();
+            return vFrac % 2 === 0;
+        };
+        const isValid = (nodeModule, nodeArgument) => {
+            return isModuleValid(nodeModule) && isArgumentValid(nodeArgument);
+        };
+        return isValid(nodeModuleAns, nodeArgumentAns);
+        //uncomment if you want to allow: m.exp(ia) === (-m).exp(i(a+Pi))
+        // ||isValid(
+        //   multiply(-1, nodeModuleAns).simplify(),
+        //   add(PiNode, nodeArgumentAns),
+        // )
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+// const createRandomIdentifiers = (opts: Options) => {};
+const getComplexGeomAffixExpFromCenteredRegularPolygonQuestion = () => {
+    //pas de 0, 1/4, 1/2, 3/2
+    const nbSides = random([5, 7, 9, 11]);
+    const vFactor = (coinFlip() ? +1 : -1) * randint(1, Math.ceil(nbSides / 2));
+    const nodeModuleM = (() => {
+        const vDenModuleM = randint(1, 5);
+        const vNumModuleM = randint(1, vDenModuleM + 1);
+        return frac(vNumModuleM, vDenModuleM).simplify({
+            towardsDistribute: false,
+        });
+    })();
+    const identifiers = {
+        nbSides,
+        vFactor,
+        nodeIdsModule: nodeModuleM.toIdentifiers(),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers, opts),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        correctionGgbOptions: getCorrectionGGBOptions(identifiers),
+        ggbOptions: getGGBOptions(identifiers, opts),
+    };
+    return question;
+};
+export const complexGeomAffixExpFromCenteredRegularPolygon = {
+    id: "complexGeomAffixExpFromCenteredRegularPolygon",
+    label: "Déterminer l'affixe d'un point sur un polygone régulier centré en l'origine sous forme exponentielle",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getComplexGeomAffixExpFromCenteredRegularPolygonQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    isAnswerValid,
+    getPropositions,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    hasGeogebra: true,
+};

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

@@ -0,0 +1,14 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    nodeIdsModule: NodeIdentifiers;
+    nodeIdsArgument: NodeIdentifiers;
+    nodeIdsAngleBase: NodeIdentifiers;
+};
+type Options = {
+    texAngleBase: string;
+    isShouldDisplayAngleBase: boolean;
+};
+export declare const complexGeomAffixExpFromPoint: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=complexGeomAffixExpFromPoint.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"complexGeomAffixExpFromPoint.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/complex/geometric/complexGeomAffixExpFromPoint.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAmBT,MAAM,6BAA6B,CAAC;AAcrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAiF7C,KAAK,WAAW,GAAG;IACjB,aAAa,EAAE,eAAe,CAAC;IAC/B,eAAe,EAAE,eAAe,CAAC;IACjC,gBAAgB,EAAE,eAAe,CAAC;CACnC,CAAC;AAulBF,KAAK,OAAO,GAAG;IACb,YAAY,EAAE,MAAM,CAAC;IACrB,wBAAwB,EAAE,OAAO,CAAC;CACnC,CAAC;AA0CF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAkBvE,CAAC"}