math-exercises 3.0.214 → 3.0.215

package/lib/exercises/math/conversion/clock/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./clockReading.js";
+export * from "./dateTimeOperationAdd.js";
+//# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/conversion/clock/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/conversion/clock/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAGlC,cAAc,2BAA2B,CAAC"}

package/lib/exercises/math/conversion/clock/index.js

@@ -0,0 +1,4 @@
+export * from "./clockReading.js";
+// export * from "./clockReadingPlusTimeOperation.js";
+// export * from "./clockWritingByManipulatingNeedles.js";
+export * from "./dateTimeOperationAdd.js";

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

@@ -10,4 +10,5 @@ export * from "./minutesToHours.js";
 export * from "./kmPerMinToKmPerHourConversion.js";
 export * from "./secondsToHours.js";
 export * from "./prefixToNumber.js";
+export * from "./clock/index.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/conversion/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,yBAAyB,CAAC;AACxC,cAAc,uBAAuB,CAAC;AACtC,cAAc,qBAAqB,CAAC;AACpC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,uBAAuB,CAAC;AACtC,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC;AACpC,cAAc,oCAAoC,CAAC;AACnD,cAAc,qBAAqB,CAAC;AACpC,cAAc,qBAAqB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/conversion/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,yBAAyB,CAAC;AACxC,cAAc,uBAAuB,CAAC;AACtC,cAAc,qBAAqB,CAAC;AACpC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,uBAAuB,CAAC;AACtC,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC;AACpC,cAAc,oCAAoC,CAAC;AACnD,cAAc,qBAAqB,CAAC;AACpC,cAAc,qBAAqB,CAAC;AAEpC,cAAc,kBAAkB,CAAC"}

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

@@ -10,3 +10,4 @@ export * from "./minutesToHours.js";
 export * from "./kmPerMinToKmPerHourConversion.js";
 export * from "./secondsToHours.js";
 export * from "./prefixToNumber.js";
+export * from "./clock/index.js";

package/lib/exercises/math/geometry/angles/angleNatureFromFigure.d.ts

@@ -0,0 +1,11 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { AngleIdentifiers } from "../../../../math/geometry/angle.js";
+type Identifiers = {
+    angleIds: AngleIdentifiers;
+};
+type Options = {
+    availableAngleNature: string;
+};
+export declare const angleNatureFromFigure: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=angleNatureFromFigure.d.ts.map

package/lib/exercises/math/geometry/angles/angleNatureFromFigure.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"angleNatureFromFigure.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/angles/angleNatureFromFigure.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAiBT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAuEtC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,gBAAgB,CAAC;CAC5B,CAAC;AAqNF,KAAK,OAAO,GAAG;IACb,oBAAoB,EAAE,MAAM,CAAC;CAC9B,CAAC;AAqBF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAuBhE,CAAC"}

package/lib/exercises/math/geometry/angles/angleNatureFromFigure.js

@@ -0,0 +1,233 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, GeneratorOptionTarget, GeneratorOptionType, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { defaultArrayedOptsWhereNeeded } from "../../../../exercises/utils/options/arrayedOptions.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { Angle, AngleConstructor, } from "../../../../math/geometry/angle.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 { PiNode } from "../../../../tree/nodes/numbers/piNode.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { random } from "../../../../utils/alea/random.js";
+import { mdTable } from "../../../../utils/markdown/mdTable.js";
+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 getInstruction = (_identifiers) => {
+    return `Donner la nature de l'angle codé sur la figure ci-dessous.`;
+};
+const getAnswer = (identifiers) => {
+    const { angleIds } = identifiers;
+    const angle = AngleConstructor.fromIdentifiers(angleIds);
+    const measure = angle.evaluate();
+    if (measure < 0) {
+        throw new Error("Unsupported measure: " + measure);
+    }
+    else if (measure === 0) {
+        return "nul";
+    }
+    else if (measure < 90) {
+        return "aigu";
+    }
+    else if (measure === 90) {
+        return "droit";
+    }
+    else if (measure < 180) {
+        return "obtus";
+    }
+    else if (measure === 180) {
+        return "plat";
+    }
+    else if (measure === 360) {
+        return "plein";
+    }
+    else {
+        throw new Error("Unsupported measure: " + measure);
+    }
+};
+const getHint = () => {
+    return `Si on range les mesures d'angle par ordre croissant, un angle est soit nul, soit aigu, soit droit, soit obtus, soit plat, soit plein.`;
+};
+const getCorrection = (identifiers) => {
+    const { angleIds } = identifiers;
+    const angle = AngleConstructor.fromIdentifiers(angleIds);
+    const measure = angle.evaluate();
+    return `Voici un tableau récapitulatif : 
+  
+${mdTable([
+        ["\\text{Mesure } m", "\\text{Nature}"],
+        ["m=0°", "\\text{nul}"],
+        ["0°<m<90°", "\\text{aigu}"],
+        ["m=90°", "\\text{droit}"],
+        ["90°<m<180°", "\\text{obtus}"],
+        ["m=180°", "\\text{plat}"],
+        ["m=360°", "\\text{plein}"],
+    ], true)}
+
+Ici l'angle fait $${measure.frenchify()}°$ donc c'est un angle ${getAnswer(identifiers)}.`;
+};
+const getCorrectionGGBOptions = (identifiers) => {
+    const { angleIds } = identifiers;
+    const angle = AngleConstructor.fromIdentifiers(angleIds);
+    const ggb = new GeogebraConstructor({
+        hideAxes: true,
+        isGridSimple: true,
+        commands: [
+            ...angle.points.flatMap((point) => point.toGGBCommand({ isVisible: false })),
+            ...angle.toCommands({ pointsAreNotBuilt: false, showValue: true }),
+        ],
+        fontSize: 16,
+    });
+    return ggb.getOptions({
+        coords: ggb.getCoordsForPoints([...angle.points]),
+    });
+};
+const getGGBOptions = (identifiers) => {
+    const { angleIds } = identifiers;
+    const angle = AngleConstructor.fromIdentifiers(angleIds);
+    const measure = angle.evaluate();
+    const [pointA, pointB, pointC] = angle.points;
+    const ggb = new GeogebraConstructor({
+        hideAxes: true,
+        isGridSimple: true,
+        commands: [
+            ...angle.points.flatMap((point) => point.toGGBCommand({ isVisible: false })),
+            `ray1 = Ray(${pointB.toMathString()}, ${pointA.toMathString()})`,
+            `ray2 = Ray(${pointB.toMathString()}, ${pointC.toMathString()})`,
+            //we must display a right angle when measure is equal to 90 degrees
+            ...(() => {
+                if (measure === 90) {
+                    return [
+                        `per = PerpendicularLine(${pointB.name}, ray1)`,
+                        `SetVisibleInView(per, 1, false)`,
+                        `ang = Angle(ray1, per)`,
+                        `ShowLabel(ang, false)`,
+                    ];
+                }
+                else {
+                    return angle.toCommands({ pointsAreNotBuilt: false });
+                }
+            })(),
+        ],
+        fontSize: 16,
+    });
+    return ggb.getOptions({
+        coords: ggb.getCoordsForPoints([...angle.points]),
+    });
+};
+const getPropositions = (n, { answer }, _optsIn) => {
+    const propositions = [];
+    addValidProp(propositions, answer, "raw");
+    ["aigu", "obtus", "droit", "plat", "plein" /*,"nul"*/].forEach((strNatureOfAngle) => {
+        tryToAddWrongProp(propositions, strNatureOfAngle, "raw");
+    });
+    return shuffleProps(propositions, n);
+};
+const getAngleNatureFromFigureQuestion = (optsIn) => {
+    const arrayedOpts = defaultArrayedOptsWhereNeeded(optsIn, arrayedOptsDefault);
+    const opts = {
+        availableAngleNature: random(arrayedOpts.availableAngleNature),
+    };
+    const measure = (() => {
+        switch (opts.availableAngleNature) {
+            // case "nul":
+            //   return 0;
+            case "aigu":
+                return randint(15, 75);
+            case "droit":
+                return 90;
+            case "obtus":
+                return randint(105, 165);
+            case "plat":
+                return 180;
+            case "plein":
+                return 360;
+            default:
+                throw new Error("Unsupported opts.availableAngleNature: " + opts.availableAngleNature);
+        }
+    })();
+    const pointB = new Point("B", 0, 0);
+    const pointA = (() => {
+        const angleOffset = randint(0, 360);
+        const pointARaw = new Point("A", 15, 0);
+        return rotatePoint(pointARaw, degreesToRadians(angleOffset, 5), pointB, "A", 5);
+    })();
+    const pointC = rotatePoint(pointA, degreesToRadians(measure, 5), pointB, "C", 5);
+    const angle = new Angle([pointA, pointB, pointC], {
+        degreeValueNode: measure.toTree(),
+    });
+    const identifiers = {
+        angleIds: angle.toIdentifiers(),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "raw",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        correctionGgbOptions: getCorrectionGGBOptions(identifiers),
+        ggbOptions: getGGBOptions(identifiers),
+    };
+    return question;
+};
+const arrayedOptsDefault = {
+    availableAngleNature: ["aigu", "droit", "obtus", "plat"],
+};
+const options = [
+    {
+        id: "availableAngleNature",
+        label: "Mesure minimum",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        values: [/*"nul",*/ "aigu", "droit", "obtus", "plat", "plein"],
+        defaultValue: arrayedOptsDefault.availableAngleNature,
+    },
+];
+export const angleNatureFromFigure = {
+    id: "angleNatureFromFigure",
+    label: "Déterminer la nature d'un angle à partir d'une figure",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getAngleNatureFromFigureQuestion(opts), nb),
+    options,
+    validateOptions: (opts) => {
+        return {
+            valid: !!(opts?.availableAngleNature && opts?.availableAngleNature.length > 0),
+            message: "Veuillez choisir au moins une nature d'angle.",
+        };
+    },
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    answerType: "QCU",
+    hasHintAndCorrection: true,
+    hasGeogebra: true,
+};

package/lib/exercises/math/geometry/angles/angleNatureFromMeasure.d.ts

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    measure: number;
+};
+type Options = {
+    availableAngleNature: string;
+};
+export declare const angleNatureFromMeasure: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=angleNatureFromMeasure.d.ts.map

package/lib/exercises/math/geometry/angles/angleNatureFromMeasure.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"angleNatureFromMeasure.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/angles/angleNatureFromMeasure.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AA8HF,KAAK,OAAO,GAAG;IACb,oBAAoB,EAAE,MAAM,CAAC;CAC9B,CAAC;AAqBF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAsBjE,CAAC"}

package/lib/exercises/math/geometry/angles/angleNatureFromMeasure.js

@@ -0,0 +1,137 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, GeneratorOptionTarget, GeneratorOptionType, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { defaultArrayedOptsWhereNeeded } from "../../../../exercises/utils/options/arrayedOptions.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { random } from "../../../../utils/alea/random.js";
+import { mdTable } from "../../../../utils/markdown/mdTable.js";
+const getInstruction = (identifiers) => {
+    const { measure } = identifiers;
+    return `Donner la nature d'un angle mesurant $${measure.frenchify()}°$.`;
+};
+const getAnswer = (identifiers) => {
+    const { measure } = identifiers;
+    if (measure < 0) {
+        throw new Error("Unsupported measure: " + measure);
+    }
+    else if (measure === 0) {
+        return "nul";
+    }
+    else if (measure < 90) {
+        return "aigu";
+    }
+    else if (measure === 90) {
+        return "droit";
+    }
+    else if (measure < 180) {
+        return "obtus";
+    }
+    else if (measure === 180) {
+        return "plat";
+    }
+    else if (measure === 360) {
+        return "plein";
+    }
+    else {
+        throw new Error("Unsupported measure: " + measure);
+    }
+};
+const getHint = () => {
+    return `Si on range les mesures d'angle par ordre croissant, un angle est soit nul, soit aigu, soit droit, soit obtus, soit plat, soit plein.`;
+};
+const getCorrection = (identifiers) => {
+    const { measure } = identifiers;
+    return `Voici un tableau récapitulatif : 
+  
+${mdTable([
+        ["\\text{Mesure } m", "\\text{Nature}"],
+        ["m=0°", "\\text{nul}"],
+        ["0°<m<90°", "\\text{aigu}"],
+        ["m=90°", "\\text{droit}"],
+        ["90°<m<180°", "\\text{obtus}"],
+        ["m=180°", "\\text{plat}"],
+        ["m=360°", "\\text{plein}"],
+    ], true)}
+
+Ici l'angle fait $${measure.frenchify()}°$ donc c'est un angle ${getAnswer(identifiers)}.`;
+};
+const getPropositions = (n, { answer }, _optsIn) => {
+    const propositions = [];
+    addValidProp(propositions, answer, "raw");
+    ["aigu", "obtus", "droit", "plat", "plein", "nul"].forEach((strNatureOfAngle) => {
+        tryToAddWrongProp(propositions, strNatureOfAngle, "raw");
+    });
+    return shuffleProps(propositions, n);
+};
+const getAngleNatureFromMeasureQuestion = (optsIn) => {
+    const arrayedOpts = defaultArrayedOptsWhereNeeded(optsIn, arrayedOptsDefault);
+    const opts = {
+        availableAngleNature: random(arrayedOpts.availableAngleNature),
+    };
+    const measure = (() => {
+        switch (opts.availableAngleNature) {
+            case "nul":
+                return 0;
+            case "aigu":
+                return randint(1, 90);
+            case "droit":
+                return 90;
+            case "obtus":
+                return randint(90, 180);
+            case "plat":
+                return 180;
+            case "plein":
+                return 360;
+            default:
+                throw new Error("Unsupported opts.availableAngleNature: " + opts.availableAngleNature);
+        }
+    })();
+    const identifiers = {
+        measure,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "raw",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+const arrayedOptsDefault = {
+    availableAngleNature: ["aigu", "droit", "obtus", "plat"],
+};
+const options = [
+    {
+        id: "availableAngleNature",
+        label: "Mesure minimum",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        values: ["nul", "aigu", "droit", "obtus", "plat", "plein"],
+        defaultValue: arrayedOptsDefault.availableAngleNature,
+    },
+];
+export const angleNatureFromMeasure = {
+    id: "angleNatureFromMeasure",
+    label: "Déterminer la nature d'un angle à partir de sa mesure",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getAngleNatureFromMeasureQuestion(opts), nb),
+    options,
+    validateOptions: (opts) => {
+        return {
+            valid: !!(opts?.availableAngleNature && opts?.availableAngleNature.length > 0),
+            message: "Veuillez choisir au moins une nature d'angle.",
+        };
+    },
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    answerType: "QCU",
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/geometry/angles/index.d.ts

@@ -1,4 +1,6 @@
 export * from "./recognizeAngleType.js";
 export * from "./parallelogramFourthAngle.js";
 export * from "./anglesUsingIsParallel.js";
+export * from "./angleNatureFromMeasure.js";
+export * from "./angleNatureFromFigure.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/geometry/angles/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/angles/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC;AACxC,cAAc,+BAA+B,CAAC;AAE9C,cAAc,4BAA4B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/angles/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC;AACxC,cAAc,+BAA+B,CAAC;AAE9C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,4BAA4B,CAAC"}

package/lib/exercises/math/geometry/angles/index.js

@@ -2,3 +2,5 @@ export * from "./recognizeAngleType.js";
 export * from "./parallelogramFourthAngle.js";
 //export * from "./isParallelUsingAngles.js";
 export * from "./anglesUsingIsParallel.js";
+export * from "./angleNatureFromMeasure.js";
+export * from "./angleNatureFromFigure.js";

package/lib/exercises/math/geometry/circles/buildCircleFromRadius.d.ts

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    radius: number;
+    isGivenDiameter: boolean;
+    randPositionRadius: number;
+};
+export declare const buildCircleFromRadius: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=buildCircleFromRadius.d.ts.map

package/lib/exercises/math/geometry/circles/buildCircleFromRadius.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildCircleFromRadius.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/circles/buildCircleFromRadius.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAerC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,eAAe,EAAE,OAAO,CAAC;IACzB,kBAAkB,EAAE,MAAM,CAAC;CAC5B,CAAC;AAyMF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAevD,CAAC"}

package/lib/exercises/math/geometry/circles/buildCircleFromRadius.js

@@ -0,0 +1,187 @@
+import { toolBarConstructor } from "../../../../exercises/utils/geogebra/toolBarConstructor.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { blueMain, greenMain, orange } from "../../../../geogebra/colors.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { GeogebraParser } from "../../../../geogebra/parsers/geogebraParser.js";
+import { Point, PointConstructor } from "../../../../math/geometry/point.js";
+import { Segment } from "../../../../math/geometry/segment.js";
+import { Vector } from "../../../../math/geometry/vector.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { abs } from "../../../../tree/nodes/functions/absNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { random } from "../../../../utils/alea/random.js";
+const getInstruction = (identifiers) => {
+    const { radius, isGivenDiameter } = identifiers;
+    if (isGivenDiameter) {
+        const diameter = 2 * radius;
+        return `Avec les outils disponibles, construire un cercle de diamètre $${diameter}$.`;
+    }
+    else {
+        return `Avec les outils disponibles, construire un cercle de rayon $${radius}$.`;
+    }
+};
+const getAnswerPoints = (identifiers) => {
+    const { radius, randPositionRadius } = identifiers;
+    const pointCenter = new Point("A", (0).toTree(), (0).toTree());
+    const vectorOffset = (() => {
+        switch (randPositionRadius) {
+            case 0:
+            case 5:
+                return new Vector("vOffset", radius.toTree(), (0).toTree());
+            case 1:
+            case 4:
+                return new Vector("vOffset", (-radius).toTree(), (0).toTree());
+            case 2:
+            case 7:
+                return new Vector("vOffset", (0).toTree(), radius.toTree());
+            case 3:
+            case 6:
+                return new Vector("vOffset", (0).toTree(), (-radius).toTree());
+            default:
+                throw new Error("Unsupported randPositionRadius: " + randPositionRadius);
+        }
+    })();
+    const pointOnCircle = vectorOffset.getEndPoint(pointCenter, "B");
+    return [pointCenter, pointOnCircle];
+};
+const getGGBAnswer = (identifiers) => {
+    const [pointCenter, pointOnCircle] = getAnswerPoints(identifiers);
+    const ggbAnswer = [
+        ...pointCenter.toGGBCommand({ showLabel: false }),
+        ...pointOnCircle.toGGBCommand({ showLabel: false }),
+        `C_1 = Circle(${pointCenter.name},${pointOnCircle.name})`,
+        `SetColor(C_1, "${greenMain}")`,
+    ];
+    return ggbAnswer;
+};
+const getHint = () => {
+    return `La longueur d'un diamètre est le double de celle d'un rayon. L'énoncé ne précise pas de centre donc on peut tracer un cercle où l'on veut.`;
+};
+const getCorrection = (identifiers) => {
+    const { radius } = identifiers;
+    return `On sélectionne l'outil Cercle dans la barre d'outils Geogebra et on trace un cercle de rayon $${radius}$.`;
+};
+const getCorrectionGGBOptions = (identifiers) => {
+    const [pointCenter, pointOnCircle1] = getAnswerPoints(identifiers);
+    const pointOnCircle2 = (() => {
+        const [_, pointOnCircle2] = getAnswerPoints({
+            ...identifiers,
+            randPositionRadius: identifiers.randPositionRadius + 4,
+        });
+        pointOnCircle2.name = "D";
+        return pointOnCircle2;
+    })();
+    const segmentR = new Segment(pointCenter, pointOnCircle1);
+    const segmentD = new Segment(pointOnCircle1, pointOnCircle2);
+    const ggb = new GeogebraConstructor({
+        commands: [
+            ...getGGBAnswer(identifiers),
+            ...pointOnCircle2.toGGBCommand({ showLabel: false }),
+            //segmentR
+            ...segmentR.toGGBCommands(false, {
+                showLength: true,
+                thickness: 5,
+                color: `"${orange}"`,
+            }),
+            //segmentD
+            ...segmentD.toGGBCommands(false, {
+                showLength: true,
+                thickness: 2,
+                color: `"${blueMain}"`,
+            }),
+        ],
+        hideAxes: true,
+        isGridSimple: true,
+        fontSize: 16,
+    });
+    return ggb.getOptions({
+        coords: ggb.getCoordsForPoints([
+            pointCenter,
+            pointOnCircle1,
+            pointOnCircle2,
+        ]),
+    });
+};
+const getStudentGGBOptions = (_identifiers) => {
+    const studentGGB = new GeogebraConstructor({
+        commands: [],
+        hideGrid: false,
+        hideAxes: true,
+        customToolBar: toolBarConstructor({
+            circleTwoPoints: true,
+        }),
+    });
+    const xMin = -5;
+    const xMax = 5;
+    const yMin = -5;
+    const yMax = 5;
+    return studentGGB.getOptions({
+        coords: [xMin, xMax, yMin, yMax],
+    });
+};
+const isGGBAnswerValid = (ans, { ggbAnswer, ...identifiers }) => {
+    const { radius } = identifiers;
+    const commands = ans;
+    const ggbParser = new GeogebraParser(commands);
+    const objectDict = ggbParser.objectDict();
+    const arrStrCircle = Object.entries(objectDict)
+        .filter(([_, strObj]) => strObj.startsWith("Circle"))
+        .map(([_, strObj]) => strObj);
+    if (arrStrCircle.length !== 1) {
+        return false;
+    }
+    const [strCircle] = arrStrCircle;
+    const [namePoint1, namePoint2] = GeogebraParser.pointNamesForCircleObj(strCircle);
+    const [coordsPoint1, coordsPoint2] = [namePoint1, namePoint2].map((name) => ggbParser.pointCoords(name));
+    const [point1, point2] = [coordsPoint1, coordsPoint2].map((coords, i) => PointConstructor.fromCoords(coords, `P${i}`));
+    const isRadiusValid = abs(substract(point1.distanceTo(point2), radius)).evaluate() < 0.01;
+    return isRadiusValid;
+};
+const getBuildCircleFromRadiusQuestion = () => {
+    const isGivenDiameter = coinFlip();
+    const radius = (() => {
+        if (isGivenDiameter) {
+            return random([2, 4, 6, 8, 10, 12, 14]);
+        }
+        else {
+            return randint(2, 9);
+        }
+    })();
+    const randPositionRadius = randint(0, 4);
+    const identifiers = {
+        radius,
+        isGivenDiameter,
+        randPositionRadius,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        ggbAnswer: getGGBAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        studentGgbOptions: getStudentGGBOptions(identifiers),
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        correctionGgbOptions: getCorrectionGGBOptions(identifiers),
+    };
+    return question;
+};
+export const buildCircleFromRadius = {
+    id: "buildCircleFromRadius",
+    connector: "=",
+    label: "Tracer un cercle de rayon ou de diamètre donné",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getBuildCircleFromRadiusQuestion, nb),
+    ggbTimer: 60,
+    isGGBAnswerValid,
+    subject: "Mathématiques",
+    answerType: "GGB",
+    getQuestionFromIdentifiers,
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/geometry/circles/index.d.ts

@@ -4,4 +4,5 @@ export * from "./circleCenterAndRadiusFromEquation.js";
 export * from "./circleCanonicalEquationFromDevEquation.js";
 export * from "./circleEquationFromDiameter.js";
 export * from "./circleRadiusOrCenterFromDevEquation.js";
+export * from "./buildCircleFromRadius.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/geometry/circles/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/circles/index.ts"],"names":[],"mappings":"AAAA,cAAc,2CAA2C,CAAC;AAC1D,cAAc,uCAAuC,CAAC;AACtD,cAAc,wCAAwC,CAAC;AACvD,cAAc,6CAA6C,CAAC;AAC5D,cAAc,iCAAiC,CAAC;AAChD,cAAc,0CAA0C,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/circles/index.ts"],"names":[],"mappings":"AAAA,cAAc,2CAA2C,CAAC;AAC1D,cAAc,uCAAuC,CAAC;AACtD,cAAc,wCAAwC,CAAC;AACvD,cAAc,6CAA6C,CAAC;AAC5D,cAAc,iCAAiC,CAAC;AAChD,cAAc,0CAA0C,CAAC;AACzD,cAAc,4BAA4B,CAAC"}