math-exercises 3.0.214 → 3.0.216

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

@@ -0,0 +1,11 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    nodeIdsModuleA: NodeIdentifiers;
+    nodeIdsArgumentA: NodeIdentifiers;
+    nodeIdsModuleB: NodeIdentifiers;
+    nodeIdsArgumentB: NodeIdentifiers;
+};
+export declare const complexGeomPlacePointWithAffixInU: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=complexGeomPlacePointWithAffixInU.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"complexGeomPlacePointWithAffixInU.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/complex/geometric/complexGeomPlacePointWithAffixInU.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAerC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAiF7C,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,eAAe,CAAC;IAChC,gBAAgB,EAAE,eAAe,CAAC;IAClC,cAAc,EAAE,eAAe,CAAC;IAChC,gBAAgB,EAAE,eAAe,CAAC;CACnC,CAAC;AAkRF,eAAO,MAAM,iCAAiC,EAAE,QAAQ,CAAC,WAAW,CAgBnE,CAAC"}

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

@@ -0,0 +1,253 @@
+import { toolBarConstructor } from "../../../../exercises/utils/geogebra/toolBarConstructor.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { greenMain } 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 { valueAngleBetweenPoints } from "../../../../math/utils/geometry/angleBetweenPoints.js";
+import { randfloat } from "../../../../math/utils/random/randfloat.js";
+import { round } from "../../../../math/utils/round.js";
+import { cos } from "../../../../tree/nodes/functions/cosNode.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 } from "../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { random, randomMany } from "../../../../utils/alea/random.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+const pointO = new Point("O", 0, 0);
+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 { nodeIdsModuleA, nodeIdsArgumentA, nodeIdsModuleB, nodeIdsArgumentB } = identifiers;
+    const [nodeModuleA, nodeArgumentA, nodeModuleB, nodeArgumentB] = [
+        nodeIdsModuleA,
+        nodeIdsArgumentA,
+        nodeIdsModuleB,
+        nodeIdsArgumentB,
+    ].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const pointA = createPointForModuleAndArgument(nodeModuleA, nodeArgumentA, "A");
+    const pointB = createPointForModuleAndArgument(nodeModuleB, nodeArgumentB, "B");
+    const pointAU = createPointForModuleAndArgument((1).toTree(), nodeArgumentA, "A");
+    const pointBU = createPointForModuleAndArgument((1).toTree(), nodeArgumentB, "B");
+    return {
+        nodeModuleA,
+        nodeArgumentA,
+        nodeModuleB,
+        nodeArgumentB,
+        pointA,
+        pointB,
+        pointAU,
+        pointBU,
+    };
+};
+const getInstruction = () => {
+    return `Sur la figure ci-dessous, le point $A$ a pour affixe $z_{A}$. 
+Le point $B$ a pour affixe $z_{B}$.
+
+Placer un point $M$ d'affixe $z$ tel que : 
+
+$$
+z \\in \\mathbb{U}
+$$
+
+et
+
+$$
+\\arg(a) < \\arg(z) < \\arg(b)
+$$
+
+`;
+};
+const getGGBAnswer = (identifiers) => {
+    const { pointAU, pointBU } = getHydrated(identifiers);
+    return [
+        `arcAUBU = CircleArc(${pointO.toMathString()}, ${pointAU.toMathString()}, ${pointBU.toMathString()})`,
+    ];
+};
+const getHint = () => {
+    return `Les points dont l'affixe est dans $\\mathbb{U}$ sont les points dont l'affixe a pour module $1$.`;
+};
+const getCorrection = () => {
+    return `Les points dont l'affixe est dans $\\mathbb{U}$ sont les points dont l'affixe a pour module $1$.
+Le point $M$ appartient donc au cercle trigonométrique.
+Les points solutions sont les points d'affixe $z = e^{i \\theta}$ avec : 
+
+$$
+\\arg(a) < \\theta < \\arg(b)
+$$
+
+`;
+};
+const getCorrectionGGBOptions = (identifiers) => {
+    const { pointA, pointB, pointAU, pointBU } = getHydrated(identifiers);
+    const ggb = new GeogebraConstructor({
+        isGridSimple: true,
+        commands: [
+            ...[pointA, pointB].flatMap((point) => point.toGGBCommand({
+                isFixed: true,
+                isSelectionnable: true,
+                showLabel: true,
+                // style: 1,
+            })),
+            //circle
+            ...[
+                `cir = Circle(${pointO.toMathString()}, 1)`,
+                `SetLineThickness(cir, 2)`,
+                `SetLineStyle(cir, 2)`,
+            ],
+            //rays
+            ...[
+                `rayA = Ray(${pointO.toMathString()}, ${pointA.toMathString()})`,
+                `SetLineThickness(rayA, 1)`,
+                `SetLineStyle(rayA, 2)`,
+                `rayB = Ray(${pointO.toMathString()}, ${pointB.toMathString()})`,
+                `SetLineThickness(rayB, 1)`,
+                `SetLineStyle(rayB, 2)`,
+            ],
+            //arc
+            ...[
+                `arcAUBU = CircleArc(${pointO.toMathString()}, ${pointAU.toMathString()}, ${pointBU.toMathString()})`,
+                `SetLineThickness(arcAUBU, 4)`,
+                `SetColor(arcAUBU, "${greenMain}")`,
+            ],
+        ],
+        fontSize: 16,
+    });
+    return ggb.getOptions({
+        coords: ggb.getCoordsForPoints([pointA, pointB, pointAU, pointBU, pointO]),
+    });
+};
+const getStudentGGBOptions = (identifiers) => {
+    const { pointA, pointB, pointAU, pointBU } = getHydrated(identifiers);
+    const ggb = new GeogebraConstructor({
+        customToolBar: toolBarConstructor({ point: true }),
+        isGridSimple: true,
+        commands: [
+            ...[pointA, pointB].flatMap((point) => point.toGGBCommand({
+                isFixed: true,
+                isSelectionnable: true,
+                showLabel: true,
+                // style: 1,
+            })),
+        ],
+        fontSize: 16,
+    });
+    return ggb.getOptions({
+        coords: ggb.getCoordsForPoints([pointA, pointB, pointAU, pointBU, pointO]),
+    });
+};
+const isGGBAnswerValid = (ggbAns, { ggbAnswer, ...identifiers }) => {
+    const { nodeArgumentA, nodeArgumentB } = getHydrated(identifiers);
+    const arrPointCoords = parseGGBPoints(ggbAns).map((p) => ggbPointToCoords(p));
+    if (arrPointCoords.length !== 1)
+        return false;
+    const [pointCoords] = arrPointCoords;
+    const pointAns = PointConstructor.fromCoords([pointCoords.x, pointCoords.y]);
+    //point is not on unit circle
+    {
+        const valueModuleAns = pointAns.distanceTo(pointO);
+        if (!(0.88 < valueModuleAns && valueModuleAns < 1.12)) {
+            return false;
+        }
+    }
+    //point is not on target arc
+    {
+        const pointAxisXPlus = new Point("AxisXPlus", 1, 0);
+        const valueAngleAns = valueAngleBetweenPoints(pointAxisXPlus, pointO, pointAns);
+        const [valueAngleA, valueAngleB] = [nodeArgumentA, nodeArgumentB].map((nodeArgument) => nodeArgument.evaluate());
+        if (!(valueAngleA < valueAngleAns && valueAngleAns < valueAngleB)) {
+            return false;
+        }
+    }
+    return true;
+};
+const getComplexGeomPlacePointFromZAPlusZQuestion = () => {
+    const [nodeModuleA, nodeArgumentA, nodeModuleB, nodeArgumentB] = (() => {
+        const nodeAngleOffset = multiply(random([-2, -1, 0, 1]), frac(PiNode, 2));
+        const createRandomModule = (typeModule) => {
+            switch (typeModule) {
+                case "belowU":
+                    return randfloat(0.65, 0.85, 2).toTree();
+                case "U":
+                    return (1).toTree();
+                case "beyondU":
+                    return randfloat(1.4, 3, 1).toTree();
+                default:
+                    throw new Error("Unsupported typeModule: " + typeModule);
+            }
+        };
+        const [typeModuleA, typeModuleB] = shuffle(random([
+            randomMany(["belowU", "U", "beyondU"], 2),
+            ["beyondU", "beyondU"],
+        ]));
+        const [nodeModuleA, nodeModuleB] = [typeModuleA, typeModuleB].map(createRandomModule);
+        const progressSeparator = randfloat(0.3, 0.7);
+        const progressMaxA = progressSeparator - 0.1;
+        const progressMinB = progressSeparator + 0.1;
+        const progressA = randfloat(0.1, progressMaxA, 2);
+        const progressB = randfloat(progressMinB, 0.9, 2);
+        const [nodeArgumentA, nodeArgumentB] = [progressA, progressB]
+            .map((progress) => multiply(progress, frac(PiNode, 2)))
+            .map((nodeArgumentRaw) => add(nodeArgumentRaw, nodeAngleOffset));
+        return [nodeModuleA, nodeArgumentA, nodeModuleB, nodeArgumentB];
+    })();
+    const identifiers = {
+        nodeIdsModuleA: nodeModuleA.toIdentifiers(),
+        nodeIdsArgumentA: nodeArgumentA.toIdentifiers(),
+        nodeIdsModuleB: nodeModuleB.toIdentifiers(),
+        nodeIdsArgumentB: nodeArgumentB.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 complexGeomPlacePointWithAffixInU = {
+    id: "complexGeomPlacePointWithAffixInU",
+    label: "Placer un point dont l'affixe appartient à $\\mathbb{U}$",
+    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/index.d.ts

@@ -0,0 +1,12 @@
+export * from "./complexGeomAffixAlgFromPoint.js";
+export * from "./complexDistance.js";
+export * from "./complexGeomPlaceAffixPoint.js";
+export * from "./complexGeomAffixTrigFromPoint.js";
+export * from "./complexGeomApproxOfCosArgOrSinArgFromPointAndAffixTrig.js";
+export * from "./complexAlgebraicFromModuloAndArg.js";
+export * from "./complexGeomAffixExpFromPoint.js";
+export * from "./complexGeomFindPointFromAffixExp.js";
+export * from "./complexGeomAffixExpFromCenteredRegularPolygon.js";
+export * from "./complexGeomFindPointFromPowerOfUnitRootFromFigure.js";
+export * from "./complexGeomArgumentOfFracCBABFromFigure.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/complex/geometric/index.ts"],"names":[],"mappings":"AACA,cAAc,mCAAmC,CAAC;AAClD,cAAc,sBAAsB,CAAC;AACrC,cAAc,iCAAiC,CAAC;AAGhD,cAAc,oCAAoC,CAAC;AACnD,cAAc,6DAA6D,CAAC;AAC5E,cAAc,uCAAuC,CAAC;AAGtD,cAAc,mCAAmC,CAAC;AAClD,cAAc,uCAAuC,CAAC;AACtD,cAAc,oDAAoD,CAAC;AAInE,cAAc,wDAAwD,CAAC;AACvE,cAAc,8CAA8C,CAAC"}

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

@@ -0,0 +1,19 @@
+//alg
+export * from "./complexGeomAffixAlgFromPoint.js";
+export * from "./complexDistance.js";
+export * from "./complexGeomPlaceAffixPoint.js";
+//trig
+export * from "./complexGeomAffixTrigFromPoint.js";
+export * from "./complexGeomApproxOfCosArgOrSinArgFromPointAndAffixTrig.js";
+export * from "./complexAlgebraicFromModuloAndArg.js";
+//exp
+export * from "./complexGeomAffixExpFromPoint.js";
+export * from "./complexGeomFindPointFromAffixExp.js";
+export * from "./complexGeomAffixExpFromCenteredRegularPolygon.js";
+// export * from "./complexGeomPlacePointFromZAPlusZ.js";//TODO : à fix
+// export * from "./complexGeomPlacePointFromZATimesZ.js";//TODO : à fix
+// export * from "./complexGeomPlacePointFromZATransformed.js"; //TODO : à fix
+export * from "./complexGeomFindPointFromPowerOfUnitRootFromFigure.js";
+export * from "./complexGeomArgumentOfFracCBABFromFigure.js";
+//sets
+// export * from "./complexGeomPlacePointWithAffixInU.js"; //TODO : à fix

package/lib/exercises/math/complex/index.d.ts

@@ -1,13 +1,7 @@
-export * from "./addComplex.js";
-export * from "./conjugateComplex.js";
-export * from "./conjugateDivideComplex.js";
-export * from "./conjugateMultiplyComplex.js";
-export * from "./divideComplex.js";
-export * from "./inverseComplex.js";
-export * from "./linearCombinaisonComplex.js";
-export * from "./moduloFromAlgebraicComplex.js";
-export * from "./mutiplyComplex.js";
-export * from "./reAndIm.js";
 export * from "./argumentFromAlgebraicComplex.js";
 export * from "./exp/index.js";
+export * from "./geometric/index.js";
+export * from "./polynomials/index.js";
+export * from "./unitRoots/index.js";
+export * from "./algebraic/index.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/complex/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/complex/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAEhC,cAAc,uBAAuB,CAAC;AACtC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC;AACpC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,iCAAiC,CAAC;AAChD,cAAc,qBAAqB,CAAC;AACpC,cAAc,cAAc,CAAC;AAC7B,cAAc,mCAAmC,CAAC;AAClD,cAAc,gBAAgB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/complex/index.ts"],"names":[],"mappings":"AAAA,cAAc,mCAAmC,CAAC;AAClD,cAAc,gBAAgB,CAAC;AAC/B,cAAc,sBAAsB,CAAC;AACrC,cAAc,wBAAwB,CAAC;AACvC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC"}

package/lib/exercises/math/complex/index.js

@@ -1,13 +1,6 @@
-export * from "./addComplex.js";
-// export * from "./argumentFromAlgebraicComplex";
-export * from "./conjugateComplex.js";
-export * from "./conjugateDivideComplex.js";
-export * from "./conjugateMultiplyComplex.js";
-export * from "./divideComplex.js";
-export * from "./inverseComplex.js";
-export * from "./linearCombinaisonComplex.js";
-export * from "./moduloFromAlgebraicComplex.js";
-export * from "./mutiplyComplex.js";
-export * from "./reAndIm.js";
 export * from "./argumentFromAlgebraicComplex.js";
 export * from "./exp/index.js";
+export * from "./geometric/index.js";
+export * from "./polynomials/index.js";
+export * from "./unitRoots/index.js";
+export * from "./algebraic/index.js";

package/lib/exercises/math/complex/polynomials/factorizePolynomialInC.d.ts

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    aIds: NodeIdentifiers;
+    z1ReIds: NodeIdentifiers;
+    z1ImIds: NodeIdentifiers;
+};
+export declare const factorizePolynomialInC: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=factorizePolynomialInC.d.ts.map

package/lib/exercises/math/complex/polynomials/factorizePolynomialInC.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"factorizePolynomialInC.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/complex/polynomials/factorizePolynomialInC.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAQrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAU7C,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,eAAe,CAAC;IACtB,OAAO,EAAE,eAAe,CAAC;IACzB,OAAO,EAAE,eAAe,CAAC;CAC1B,CAAC;AAwLF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAkBxD,CAAC"}

package/lib/exercises/math/complex/polynomials/factorizePolynomialInC.js

@@ -0,0 +1,176 @@
+import { addValidProp, shuffleProps, propWhile, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { ComplexNode } from "../../../../tree/nodes/complex/complexNode.js";
+import { isOppositeNode, opposite, } from "../../../../tree/nodes/functions/oppositeNode.js";
+import { reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { isMultiplyNode, multiply, } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const { aIds, z1ImIds, z1ReIds } = identifiers;
+    const z1Re = reifyAlgebraic(z1ReIds);
+    const z1Im = reifyAlgebraic(z1ImIds);
+    const complex = add(z1Re, multiply(z1Im, "i"));
+    const conj = add(z1Re, multiply(opposite(z1Im), "i"));
+    tryToAddWrongProp(propositions, multiply(substract("z", complex).simplify({
+        towardsDistribute: true,
+        forbidFactorize: true,
+        noAddOrder: true,
+    }), substract("z", conj).simplify({
+        towardsDistribute: true,
+        forbidFactorize: true,
+        noAddOrder: true,
+    })).toTex());
+    propWhile(propositions, n, () => {
+        const z1ReIds = randint(-5, 6).toTree().toIdentifiers();
+        const z1ImIds = randint(-5, 6, [0]).toTree().toIdentifiers();
+        tryToAddWrongProp(propositions, getAnswer({ aIds, z1ImIds, z1ReIds }));
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { aIds, z1ImIds, z1ReIds } = identifiers;
+    const a = reifyAlgebraic(aIds);
+    const z1Re = reifyAlgebraic(z1ReIds);
+    const z1Im = reifyAlgebraic(z1ImIds);
+    const complex = add(z1Re, multiply(z1Im, "i"));
+    const conj = add(z1Re, multiply(opposite(z1Im), "i"));
+    return multiply(a, multiply(substract("z", complex).simplify({
+        towardsDistribute: true,
+        forbidFactorize: true,
+        noAddOrder: true,
+    }), substract("z", conj).simplify({
+        towardsDistribute: true,
+        forbidFactorize: true,
+        noAddOrder: true,
+    }))).toTex();
+};
+const getInstruction = (identifiers) => {
+    const { aIds, z1ImIds, z1ReIds } = identifiers;
+    const a = reifyAlgebraic(aIds);
+    const z1Re = reifyAlgebraic(z1ReIds);
+    const z1Im = reifyAlgebraic(z1ImIds);
+    const complex = new ComplexNode(z1Re, z1Im);
+    return `Soit $P$ un polynôme tel que pour tout $z\\in\\mathbb{C}$ :
+  
+$$
+P(z) = ${multiply(a, "z^2").toTex()}+bz+c
+$$
+
+On sait de plus que $P(${complex.toTex()}) = 0$.
+
+Écrire $P(z)$ sous forme factorisée.`;
+};
+const getHint = () => {
+    return `$P(z)$ peut se factoriser sous la forme :
+  
+$$
+P(z) = a(z-z_1)(z-z_2)
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { z1ImIds, z1ReIds } = identifiers;
+    const z1Re = reifyAlgebraic(z1ReIds);
+    const z1Im = reifyAlgebraic(z1ImIds);
+    const complex = new ComplexNode(z1Re, z1Im);
+    const conj = new ComplexNode(z1Re, opposite(z1Im).simplify());
+    return `Tout polynôme $P$ de la forme $az^2 +bz+c$ où $z\\in\\mathbb{C}$ et $a$,$b$,$c$ sont des réels (avec $a\\neq 0$) peut se réécrire sous forme factorisée : 
+  
+$$
+P(z)= a(z-z_1)(z-z_2)
+$$
+
+où $z_1$ et $z_2$ sont les racines de $P$ (avec éventuellement $z_1 = z_2$).
+
+Ici, on connaît une racine : $z_1 = ${complex.toTex()}$.
+
+On peut en déduire la deuxième : en effet, 
+
+$$
+z_2 = \\overline{z_1} = ${conj.toTex()}
+$$
+
+On en déduit la forme factorisée de $P(z)$ : 
+
+$$
+P(z) = ${getAnswer(identifiers)}
+$$`;
+};
+const getKeys = () => {
+    return ["z", "i"];
+};
+const isAnswerValid = (ans, { answer: _answer, ...identifiers }) => {
+    try {
+        const { aIds, z1ImIds, z1ReIds } = identifiers;
+        const a = reifyAlgebraic(aIds);
+        const z1Re = reifyAlgebraic(z1ReIds);
+        const z1Im = reifyAlgebraic(z1ImIds);
+        const complex = add(z1Re, multiply(z1Im, "i"));
+        const conj = add(z1Re, multiply(opposite(z1Im), "i"));
+        const parsed = parseAlgebraic(ans);
+        return ((isMultiplyNode(parsed) ||
+            (isOppositeNode(parsed) && isMultiplyNode(parsed.child))) &&
+            multiply(a, multiply(substract("z", complex), substract("z", conj)))
+                .simplify({
+                towardsDistribute: true,
+                forbidFactorize: true,
+            })
+                .toTex()
+                .replaceAll("zi", "iz") === //replaceAll parce que sortMultiply ne sort pas et j'ai pas le temps de faire mieux
+                parsed
+                    .simplify({
+                    towardsDistribute: true,
+                    forbidFactorize: true,
+                })
+                    .toTex()
+                    .replaceAll("zi", "iz"));
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getFactorizePolynomialInCQuestion = () => {
+    const a = randint(-9, 10, [-1, 1, 0]);
+    const z1Re = randint(-5, 6);
+    const z1Im = randint(-5, 6, [0]);
+    const identifiers = {
+        aIds: a.toTree().toIdentifiers(),
+        z1ImIds: z1Im.toTree().toIdentifiers(),
+        z1ReIds: z1Re.toTree().toIdentifiers(),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const factorizePolynomialInC = {
+    id: "factorizePolynomialInC",
+    connector: "=",
+    label: "Factoriser un polynôme dans $\\mathbb{C}$ en connaissant une racine",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getFactorizePolynomialInCQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/complex/polynomials/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./solveZSquareEqualsA.js";
+export * from "./solveSecondDegreeInComplex.js";
+export * from "./factorizePolynomialInC.js";
+//# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/complex/polynomials/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/complex/polynomials/index.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAC;AACzC,cAAc,iCAAiC,CAAC;AAChD,cAAc,6BAA6B,CAAC"}

package/lib/exercises/math/complex/polynomials/index.js

@@ -0,0 +1,3 @@
+export * from "./solveZSquareEqualsA.js";
+export * from "./solveSecondDegreeInComplex.js";
+export * from "./factorizePolynomialInC.js";

package/lib/exercises/math/complex/polynomials/solveSecondDegreeInComplex.d.ts

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    aIds: NodeIdentifiers;
+    bIds: NodeIdentifiers;
+    cIds: NodeIdentifiers;
+};
+export declare const solveSecondDegreeInComplex: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=solveSecondDegreeInComplex.d.ts.map

package/lib/exercises/math/complex/polynomials/solveSecondDegreeInComplex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"solveSecondDegreeInComplex.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/complex/polynomials/solveSecondDegreeInComplex.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAOrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAc7C,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,eAAe,CAAC;IACtB,IAAI,EAAE,eAAe,CAAC;IACtB,IAAI,EAAE,eAAe,CAAC;CACvB,CAAC;AAkMF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAmB5D,CAAC"}