math-exercises 3.0.135 → 3.0.137

package/lib/exercises/math/geometry/euclidianConstructions/pointImageFromHomothety.js

@@ -0,0 +1,241 @@
+import { GeneratorOptionType, GeneratorOptionTarget, } from "../../../../exercises/exercise.js";
+import { toolBarConstructor } from "../../../../exercises/utils/geogebra/toolBarConstructor.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { red } from "../../../../geogebra/colors.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { approxEqual } from "../../../../geogebra/parsers/approxEqual.js";
+import { ggbPointToCoords } from "../../../../geogebra/parsers/ggbPointToCoords.js";
+import { Point, PointConstructor, } from "../../../../math/geometry/point.js";
+import { VectorConstructor } from "../../../../math/geometry/vector.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { round } from "../../../../math/utils/round.js";
+import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { random, randomMany } from "../../../../utils/alea/random.js";
+import { doWhile } from "../../../../utils/doWhile.js";
+const getDivisorsOfVector = (vec) => {
+    return [2, 3, 4, 5, 7, 8, 9].filter((n) => [vec.x, vec.y].every((z) => z.evaluate() % n === 0));
+};
+const getRandomFactorNodeForVector = (vec, isPositiveFactorOnly = false, excludes = [], factorType) => {
+    let factorNode;
+    const divisorsOfVec = getDivisorsOfVector(vec);
+    if (divisorsOfVec.length > 0) {
+        switch (factorType) {
+            case "nombre à virgule":
+                {
+                    let counter = -1;
+                    let isFound = false;
+                    while (!isFound && counter < 100) {
+                        counter++;
+                        const den = random(divisorsOfVec);
+                        const num = randint(1, 3 * den, [den]);
+                        const fracNode = frac(num, den);
+                        const value = fracNode.evaluate();
+                        if (round(value, 3) === value) {
+                            factorNode = value.toTree();
+                            isFound = true;
+                        }
+                    }
+                    if (!isFound) {
+                        factorNode = (2).toTree();
+                    }
+                }
+                break;
+            default:
+            case "fraction":
+                {
+                    const den = random(divisorsOfVec);
+                    const num = randint(1, 3 * den, [den]);
+                    factorNode = frac(num, den);
+                }
+                break;
+        }
+    }
+    else {
+        factorNode = randint(1, 5, excludes).toTree();
+    }
+    return multiply(isPositiveFactorOnly ? 1 : coinFlip() ? 1 : -1, factorNode);
+};
+const getInstruction = (identifiers) => {
+    const { nameTargetPoint, nameCenterPoint, factor } = identifiers;
+    const factorNode = NodeConstructor.fromIdentifiers(factor);
+    return `Placer l'image du point $${nameTargetPoint}$ par l'homothétie de centre $${nameCenterPoint}$ et de rapport $${factorNode.toTex()}$.`;
+};
+const getStartPoint = (identifiers) => {
+    const { pointsDict, nameCenterPoint } = identifiers;
+    return PointConstructor.fromIdentifiers(pointsDict[nameCenterPoint]);
+};
+const getEndPoint = (identifiers) => {
+    const { pointsDict, nameCenterPoint, nameTargetPoint, factor } = identifiers;
+    const [pointCenter, pointTarget] = [nameCenterPoint, nameTargetPoint].map((name) => PointConstructor.fromIdentifiers(pointsDict[name]));
+    const factorNode = NodeConstructor.fromIdentifiers(factor);
+    const vec1 = VectorConstructor.fromPoints(pointCenter, pointTarget);
+    const vec2 = vec1.times(factorNode);
+    return vec2.getEndPoint(pointCenter, "K");
+};
+const getHint = (identifiers) => {
+    const { factor, nameCenterPoint, nameTargetPoint } = identifiers;
+    const factorNode = NodeConstructor.fromIdentifiers(factor);
+    const isPositiveFactor = factorNode.evaluate() > 0;
+    return isPositiveFactor
+        ? `Le rapport de l'homothétie est positif.
+On se place à partir du centre de l'homothétie, le point $${nameCenterPoint}$. 
+On se déplace dans le même sens que le déplacement de $${nameCenterPoint}$ vers $${nameTargetPoint}$.`
+        : `Le rapport de l'homothétie est négatif.
+On se place à partir du centre de l'homothétie, le point $${nameCenterPoint}$. 
+On se déplace dans le même sens que le déplacement de $${nameTargetPoint}$ vers $${nameCenterPoint}$.`;
+};
+const getCorrection = (identifiers) => {
+    const { factor, nameCenterPoint, nameTargetPoint } = identifiers;
+    const factorNode = NodeConstructor.fromIdentifiers(factor);
+    const isPositiveFactor = factorNode.evaluate() > 0;
+    return isPositiveFactor
+        ? `On se place à partir du centre de l'homothétie, le point $${nameCenterPoint}$. 
+On se déplace dans le même sens que le déplacement de $${nameCenterPoint}$ vers $${nameTargetPoint}$.
+On s'arrête quand on a parcouru la distance $${factorNode.toTex()} \\times ${nameCenterPoint}${nameTargetPoint}$.`
+        : `On se place à partir du centre de l'homothétie, le point $${nameCenterPoint}$. 
+On se déplace dans le même sens que le déplacement de $${nameTargetPoint}$ vers $${nameCenterPoint}$.
+On s'arrête quand on a parcouru la distance $${multiply(-1, factorNode)
+            .simplify()
+            .toTex()} \\times ${nameCenterPoint}${nameTargetPoint}$.`;
+};
+const getGGBAnswer = (identifiers) => {
+    const startPoint = getStartPoint(identifiers);
+    const endPoint = getEndPoint(identifiers);
+    return [
+        ...endPoint.toGGBCommand(),
+        `a = Vector(${startPoint.name}, ${endPoint.name})`,
+        `SetColor(a, "${red}")`,
+    ];
+};
+const getStudentGGBOptions = (identifiers) => {
+    const points = Object.values(identifiers.pointsDict).map((p) => PointConstructor.fromIdentifiers(p));
+    const ggb = new GeogebraConstructor({
+        hideAxes: true,
+        isGridSimple: true,
+        customToolBar: toolBarConstructor({ point: true }),
+        commands: points.flatMap((p) => p.toGGBCommand({
+            size: 3,
+            style: 1,
+        })),
+        fontSize: 16,
+    });
+    const endPoint = getEndPoint(identifiers);
+    return ggb.getOptions({
+        coords: ggb.getCoordsForPoints([...points, endPoint]),
+    });
+};
+const isGGBAnswerValid = (ans, { ggbAnswer }) => {
+    const studentAns = ans;
+    if (studentAns.length !== 1)
+        return false;
+    const studentPoint = studentAns[0].split("=")[1];
+    if (studentPoint === undefined)
+        return false;
+    const coords = ggbPointToCoords(studentPoint);
+    const coordsAns = ggbPointToCoords(ggbAnswer[0].split("=")[1]);
+    return (approxEqual(coords.x, coordsAns.x, 0.2) &&
+        approxEqual(coords.y, coordsAns.y, 0.2));
+};
+const getPointImageFromHomothetyQuestion = (optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const { isPositiveFactorOnly, factorTypes } = opts;
+    const factorType = random(factorTypes);
+    function createRandomPoints() {
+        const points = [];
+        for (let i = 0; i < 4; i++) {
+            const name = String.fromCharCode(65 + i);
+            const newPoint = doWhile(() => PointConstructor.random(name, -3, 4), (p) => points.some((p2) => p.distanceTo(p2) < 2));
+            points.push(newPoint);
+        }
+        return points;
+    }
+    function createRandomIdentifiers(points) {
+        const [pointCenter, pointTarget] = randomMany(points, 2);
+        const vec1 = VectorConstructor.fromPoints(pointCenter, pointTarget);
+        const factorNode = getRandomFactorNodeForVector(vec1, isPositiveFactorOnly, [1], factorType).simplify();
+        const identifiers = {
+            pointsDict: Object.fromEntries(points.map((p) => [p.name, p.toIdentifiers()])),
+            nameTargetPoint: pointTarget.name,
+            nameCenterPoint: pointCenter.name,
+            factor: factorNode.toIdentifiers(),
+        };
+        return identifiers;
+    }
+    const pointOrigin = new Point("O", 0, 0);
+    const points = createRandomPoints();
+    let identifiers;
+    let counter = -1;
+    let isValidIdentifiers = false;
+    while (!isValidIdentifiers && counter < 100) {
+        counter++;
+        identifiers = createRandomIdentifiers(points);
+        isValidIdentifiers = (() => {
+            const endPoint = getEndPoint(identifiers);
+            return endPoint.distanceTo(pointOrigin) < 10;
+        })();
+    }
+    const defaultIdentifiers = {
+        pointsDict: Object.fromEntries([
+            new Point("A", 5, 0),
+            new Point("B", 0, 5),
+            new Point("C", -5, 0),
+            new Point("D", 0, -5),
+        ].map((point) => [point.name, point.toIdentifiers()])),
+        nameTargetPoint: "A",
+        nameCenterPoint: "B",
+        factor: frac(3, 5).toIdentifiers(),
+    };
+    return getQuestionFromIdentifiers(identifiers ?? defaultIdentifiers, opts);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        ggbAnswer: getGGBAnswer(identifiers, opts),
+        instruction: getInstruction(identifiers, opts),
+        studentGgbOptions: getStudentGGBOptions(identifiers, opts),
+        identifiers,
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+    };
+    return question;
+};
+const options = [
+    {
+        id: "isPositiveFactorOnly",
+        label: "Rapports positifs uniquement",
+        type: GeneratorOptionType.checkbox,
+        target: GeneratorOptionTarget.generation,
+        defaultValue: false,
+    },
+    {
+        id: "factorTypes",
+        label: "Rapport: type de nombre",
+        type: GeneratorOptionType.multiselect,
+        target: GeneratorOptionTarget.generation,
+        values: ["fraction", "nombre à virgule"],
+        defaultValue: ["fraction", "nombre à virgule"],
+    },
+];
+const optsDefault = {
+    isPositiveFactorOnly: false,
+    factorTypes: ["fraction", "nombre à virgule"],
+};
+export const pointImageFromHomothety = {
+    id: "pointImageFromHomothety",
+    label: "Placer l'image d'un point par une homothétie",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getPointImageFromHomothetyQuestion(opts), nb),
+    ggbTimer: 60,
+    isGGBAnswerValid,
+    subject: "Mathématiques",
+    getHint,
+    getCorrection,
+    getGGBAnswer,
+    getStudentGGBOptions,
+    answerType: "GGB",
+    options,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/geometry/euclidianConstructions/segmentImageFromHomothety.d.ts

@@ -0,0 +1,16 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { PointIdentifiers } from "../../../../math/geometry/point.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    pointsDict: Record<string, PointIdentifiers>;
+    nameTargetPoints: string[];
+    nameCenterPoint: string;
+    factor: NodeIdentifiers;
+};
+type Options = {
+    isPositiveFactorOnly: boolean;
+    factorTypes: string[];
+};
+export declare const segmentImageFromHomothety: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=segmentImageFromHomothety.d.ts.map

package/lib/exercises/math/geometry/euclidianConstructions/segmentImageFromHomothety.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"segmentImageFromHomothety.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/euclidianConstructions/segmentImageFromHomothety.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAYrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAKtC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AA4D7C,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;IAC7C,gBAAgB,EAAE,MAAM,EAAE,CAAC;IAC3B,eAAe,EAAE,MAAM,CAAC;IACxB,MAAM,EAAE,eAAe,CAAC;CACzB,CAAC;AAgOF,KAAK,OAAO,GAAG;IACb,oBAAoB,EAAE,OAAO,CAAC;IAC9B,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB,CAAC;AAyBF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAiBpE,CAAC"}

package/lib/exercises/math/geometry/euclidianConstructions/segmentImageFromHomothety.js

@@ -0,0 +1,258 @@
+import { GeneratorOptionType, GeneratorOptionTarget, } from "../../../../exercises/exercise.js";
+import { toolBarConstructor } from "../../../../exercises/utils/geogebra/toolBarConstructor.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { greenDark, greenMain, orange, purpleLight, } 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 { VectorConstructor } from "../../../../math/geometry/vector.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { round } from "../../../../math/utils/round.js";
+import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { random, randomMany } from "../../../../utils/alea/random.js";
+import { intersect } from "../../../../utils/arrays/arrayIntersection.js";
+import { doWhile } from "../../../../utils/doWhile.js";
+const getDivisorsOfVector = (vec) => {
+    return [2, 3, 4, 5, 7, 8, 9].filter((n) => [vec.x, vec.y].every((z) => z.evaluate() % n === 0));
+};
+const getRandomFactorNodeForVectors = (vecs, isPositiveFactorOnly = false, excludes = [], factorType) => {
+    let factorNode;
+    const divisorsOfVecs = intersect(vecs.map((vec) => getDivisorsOfVector(vec)));
+    if (divisorsOfVecs.length > 0) {
+        switch (factorType) {
+            case "nombre à virgule":
+                {
+                    let counter = -1;
+                    let isFound = false;
+                    while (!isFound && counter < 100) {
+                        counter++;
+                        const den = random(divisorsOfVecs);
+                        const num = randint(1, 3 * den, [den]);
+                        const fracNode = frac(num, den);
+                        const value = fracNode.evaluate();
+                        if (round(value, 3) === value) {
+                            factorNode = value.toTree();
+                            isFound = true;
+                        }
+                    }
+                    if (!isFound) {
+                        factorNode = (2).toTree();
+                    }
+                }
+                break;
+            default:
+            case "fraction":
+                {
+                    const den = random(divisorsOfVecs);
+                    const num = randint(1, 3 * den, [den]);
+                    factorNode = frac(num, den);
+                }
+                break;
+        }
+    }
+    else {
+        factorNode = randint(1, 5, excludes).toTree();
+    }
+    return multiply(isPositiveFactorOnly ? 1 : coinFlip() ? 1 : -1, factorNode);
+};
+const getInstruction = (identifiers) => {
+    const { nameTargetPoints, nameCenterPoint, factor } = identifiers;
+    const factorNode = NodeConstructor.fromIdentifiers(factor);
+    return `Placer l'image du segment $[${nameTargetPoints[0]}${nameTargetPoints[1]}]$ par l'homothétie de centre $${nameCenterPoint}$ et de rapport $${factorNode.toTex()}$.`;
+};
+const getStartPoint = (identifiers) => {
+    const { pointsDict, nameCenterPoint } = identifiers;
+    return PointConstructor.fromIdentifiers(pointsDict[nameCenterPoint]);
+};
+const getEndPoints = (identifiers) => {
+    const { pointsDict, nameCenterPoint, nameTargetPoints, factor } = identifiers;
+    const [pointCenter, pointTarget1, pointTarget2] = [
+        nameCenterPoint,
+        ...nameTargetPoints,
+    ].map((name) => PointConstructor.fromIdentifiers(pointsDict[name]));
+    const factorNode = NodeConstructor.fromIdentifiers(factor);
+    return [pointTarget1, pointTarget2].map((pointTarget, i) => {
+        const vec1 = VectorConstructor.fromPoints(pointCenter, pointTarget);
+        const vec2 = vec1.times(factorNode);
+        return vec2.getEndPoint(pointCenter, `${nameTargetPoints[i]}'`);
+    });
+};
+const getHint = (identifiers) => {
+    const { nameTargetPoints } = identifiers;
+    return `Construis l'image de $${nameTargetPoints[0]}$, puis construis l'image de $${nameTargetPoints[1]}$ et enfin, relie les deux points.`;
+};
+const getCorrection = (identifiers) => {
+    const { factor, nameCenterPoint, nameTargetPoints } = identifiers;
+    const factorNode = NodeConstructor.fromIdentifiers(factor);
+    const isPositiveFactor = factorNode.evaluate() > 0;
+    return isPositiveFactor
+        ? `Pour placer l'image du segment, on place les images des deux extrémités.
+On va placer l'image du point $${nameTargetPoints[0]}$.
+On se place à partir du centre de l'homothétie, le point $${nameCenterPoint}$. 
+On se déplace dans le même sens que le déplacement de $${nameCenterPoint}$ vers $${nameTargetPoints[0]}$.
+On s'arrête quand on a parcouru la distance $${factorNode.toTex()} \\times ${nameCenterPoint}${nameTargetPoints[0]}$.
+On procède de la même façon pour $${nameTargetPoints[1]}$.`
+        : `Pour placer l'image du segment, on place les images des deux extrémités.
+On va placer l'image du point $${nameTargetPoints[0]}$.
+On se place à partir du centre de l'homothétie, le point $${nameCenterPoint}$. 
+On se déplace dans le même sens que le déplacement de $${nameTargetPoints[0]}$ vers $${nameCenterPoint}$.
+On s'arrête quand on a parcouru la distance $${multiply(-1, factorNode)
+            .simplify()
+            .toTex()} \\times ${nameCenterPoint}${nameTargetPoints[0]}$.
+On procède de la même façon pour $${nameTargetPoints[1]}$.`;
+};
+const getGGBAnswer = (identifiers) => {
+    const startPoint = getStartPoint(identifiers);
+    const endPoints = getEndPoints(identifiers);
+    return [
+        ...endPoints.flatMap((endPoint, i) => [
+            ...endPoint.toGGBCommand({ color: greenDark }),
+            `a_${i} = Vector(${startPoint.name}, ${endPoint.name})`,
+            `SetColor(a_${i}, "${purpleLight}")`,
+        ]),
+        `s2 = Segment(${endPoints.map((endPoint) => endPoint.name).join(",")})`,
+        `SetColor(s2, "${greenMain}")`,
+    ];
+};
+const getStudentGGBOptions = (identifiers) => {
+    const { nameTargetPoints } = identifiers;
+    const points = Object.values(identifiers.pointsDict).map((p) => PointConstructor.fromIdentifiers(p));
+    const ggb = new GeogebraConstructor({
+        hideAxes: true,
+        isGridSimple: true,
+        customToolBar: toolBarConstructor({ point: true, segment: true }),
+        commands: [
+            ...points.flatMap((p) => p.toGGBCommand({
+                size: 3,
+                style: 1,
+            })),
+            `s = Segment(${nameTargetPoints.join(",")})`,
+            `SetColor(s, "${orange}")`,
+        ],
+        fontSize: 16,
+    });
+    const endPoints = getEndPoints(identifiers);
+    return ggb.getOptions({
+        coords: ggb.getCoordsForPoints([...points, ...endPoints]),
+    });
+};
+const isGGBAnswerValid = (ans, { ggbAnswer, ...identifiers }) => {
+    const endPoints = getEndPoints(identifiers);
+    const commands = ans;
+    const ggbParser = new GeogebraParser(commands);
+    const arrArrCoords = ggbParser.segmentsAsArrayOfCoords();
+    return arrArrCoords.some((arrCoords) => {
+        const [point1, point2] = arrCoords.map((coords, i) => new Point(`Z_${i}`, coords[0], coords[1]));
+        return [endPoints, endPoints.toReversed()].some((endPoints) => point1.distanceTo(endPoints[0]) < 0.5 &&
+            point2.distanceTo(endPoints[1]) < 0.5);
+    });
+};
+const getSegmentImageFromHomothetyQuestion = (optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const { isPositiveFactorOnly, factorTypes } = opts;
+    const factorType = random(factorTypes);
+    function createRandomPoints() {
+        const points = [];
+        for (let i = 0; i < 4; i++) {
+            const name = String.fromCharCode(65 + i);
+            const newPoint = doWhile(() => PointConstructor.random(name, -3, 4), (p) => points.some((p2) => p.distanceTo(p2) < 2));
+            points.push(newPoint);
+        }
+        return points;
+    }
+    function createRandomIdentifiers(points) {
+        const [pointCenter, pointTarget1, pointTarget2] = randomMany(points, 3);
+        const vec1 = VectorConstructor.fromPoints(pointCenter, pointTarget1);
+        const vec2 = VectorConstructor.fromPoints(pointCenter, pointTarget2);
+        const factorNode = getRandomFactorNodeForVectors([vec1, vec2], isPositiveFactorOnly, [1], factorType).simplify();
+        const identifiers = {
+            pointsDict: Object.fromEntries(points.map((p) => [p.name, p.toIdentifiers()])),
+            nameTargetPoints: [pointTarget1, pointTarget2].map((point) => point.name),
+            nameCenterPoint: pointCenter.name,
+            factor: factorNode.toIdentifiers(),
+        };
+        return identifiers;
+    }
+    const pointOrigin = new Point("O", 0, 0);
+    const points = createRandomPoints();
+    let identifiers;
+    let counter = -1;
+    let isValidIdentifiers = false;
+    while (!isValidIdentifiers && counter < 100) {
+        counter++;
+        identifiers = createRandomIdentifiers(points);
+        isValidIdentifiers = (() => {
+            if (counter < 50) {
+                const factorNode = NodeConstructor.fromIdentifiers(identifiers.factor);
+                const isIntegerFactor = factorNode.evaluate() % 1 === 0;
+                return !isIntegerFactor;
+            }
+            const endPoints = getEndPoints(identifiers);
+            return endPoints.every((endPoint) => endPoint.distanceTo(pointOrigin) < 10);
+        })();
+    }
+    const defaultIdentifiers = {
+        pointsDict: Object.fromEntries([
+            new Point("A", 4, 0),
+            new Point("B", 0, 4),
+            new Point("C", 0, 0),
+            new Point("D", 0, -4),
+        ].map((point) => [point.name, point.toIdentifiers()])),
+        nameTargetPoints: ["A", "D"],
+        nameCenterPoint: "B",
+        factor: (-2).toTree().toIdentifiers(),
+    };
+    return getQuestionFromIdentifiers(identifiers ?? defaultIdentifiers, opts);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        ggbAnswer: getGGBAnswer(identifiers, opts),
+        instruction: getInstruction(identifiers, opts),
+        studentGgbOptions: getStudentGGBOptions(identifiers, opts),
+        identifiers,
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+    };
+    return question;
+};
+const options = [
+    {
+        id: "isPositiveFactorOnly",
+        label: "Rapports positifs uniquement",
+        type: GeneratorOptionType.checkbox,
+        target: GeneratorOptionTarget.generation,
+        defaultValue: false,
+    },
+    {
+        id: "factorTypes",
+        label: "Rapport: type de nombre",
+        type: GeneratorOptionType.multiselect,
+        target: GeneratorOptionTarget.generation,
+        values: ["fraction", "nombre à virgule"],
+        defaultValue: ["fraction", "nombre à virgule"],
+    },
+];
+const optsDefault = {
+    isPositiveFactorOnly: false,
+    factorTypes: ["fraction", "nombre à virgule"],
+};
+export const segmentImageFromHomothety = {
+    id: "segmentImageFromHomothety",
+    label: "Placer l'image d'un segment par une homothétie",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getSegmentImageFromHomothetyQuestion(opts), nb),
+    ggbTimer: 60,
+    isGGBAnswerValid,
+    subject: "Mathématiques",
+    getHint,
+    getCorrection,
+    getGGBAnswer,
+    getStudentGGBOptions,
+    answerType: "GGB",
+    options,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/geogebra/parsers/geogebraParser.d.ts

@@ -3,6 +3,7 @@ export declare class GeogebraParser {
     constructor(studentCommands: string[]);
     pointCoords(name: string): number[] | undefined;
     vectors(): number[][];
+    segmentsAsArrayOfCoords(): number[][][];
     objectDict(): {
         [k: string]: string;
     };

package/lib/geogebra/parsers/geogebraParser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"geogebraParser.d.ts","sourceRoot":"","sources":["../../../src/geogebra/parsers/geogebraParser.ts"],"names":[],"mappings":"AAAA,qBAAa,cAAc;IACzB,QAAQ,EAAE,MAAM,EAAE,CAAC;gBACP,eAAe,EAAE,MAAM,EAAE;IAIrC,WAAW,CAAC,IAAI,EAAE,MAAM;IAWxB,OAAO;IAyCP,UAAU;;;IAWV,MAAM,CAAC,oBAAoB,CAAC,OAAO,EAAE,MAAM;CAS5C"}
+{"version":3,"file":"geogebraParser.d.ts","sourceRoot":"","sources":["../../../src/geogebra/parsers/geogebraParser.ts"],"names":[],"mappings":"AAAA,qBAAa,cAAc;IACzB,QAAQ,EAAE,MAAM,EAAE,CAAC;gBACP,eAAe,EAAE,MAAM,EAAE;IAIrC,WAAW,CAAC,IAAI,EAAE,MAAM;IAWxB,OAAO;IAyCP,uBAAuB;IAsCvB,UAAU;;;IAWV,MAAM,CAAC,oBAAoB,CAAC,OAAO,EAAE,MAAM;CAS5C"}

package/lib/geogebra/parsers/geogebraParser.js

@@ -56,6 +56,44 @@ export class GeogebraParser {
         }
         return res;
     }
+    segmentsAsArrayOfCoords() {
+        //regex find string that starts with a undercase letter and then =Segment
+        const res = [];
+        const segments = this.commands.filter((cmd) => !!cmd.match(/^[a-z]=Segment/)?.length);
+        if (!segments)
+            return [];
+        for (const segment of segments) {
+            const pointCoords = [];
+            let command = segment.split("=Segment")[1];
+            command.replace("]", "").replace("[", "").replaceAll(" ", "");
+            let pointMatch = command.match(/[A-Z]|\(\d+(\.\d+)?,\s*\d+(\.\d+)?\)/);
+            let counter = 0;
+            while (pointMatch?.length) {
+                counter++;
+                if (counter > 1000)
+                    throw new Error("Too many iterations in geogebraparser");
+                const name = pointMatch[0];
+                if (name.match(/[A-Z]/)?.length) {
+                    const point = this.pointCoords(name);
+                    if (point)
+                        pointCoords.push(point);
+                }
+                else {
+                    //point is (xxx,yyy)
+                    const [x, y] = name
+                        .replace("(", "")
+                        .replace(")", "")
+                        .split(",")
+                        .map(parseFloat);
+                    pointCoords.push([x, y]);
+                }
+                command = command.substring(pointMatch.index + 1);
+                pointMatch = command.match(/[A-Z]|\(\d+(\.\d+)?,\s*\d+(\.\d+)?\)/);
+            }
+            res.push(pointCoords);
+        }
+        return res;
+    }
     objectDict() {
         return Object.fromEntries(this.commands
             .filter((command) => command.includes("="))

package/lib/index.d.ts

@@ -517,6 +517,20 @@ declare const mathExercises: (Exercise<{
 }, Record<string, string | boolean | string[]>> | Exercise<{
     a: number;
     b: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    a: number;
+    b: number;
+    c: number;
+    d: number;
+    k: number;
+    isSubstract: boolean;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    a: number;
+    b: number;
+    c: number;
+    d: number;
+    k: number;
+    isSubstract: boolean;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     b: number;
     c: number;
@@ -839,6 +853,9 @@ declare const mathExercises: (Exercise<{
     affineB: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     a: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    a: number;
+    b: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     nodeUIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
     nodeVIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
@@ -1590,14 +1607,6 @@ declare const mathExercises: (Exercise<{
     abscissTex: string;
     coeff: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
-    abscissType: import("./math/numbers/nombre.js").NumberType;
-    axisUnit: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
-    absciss1: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
-    absciss2: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
-}, {
-    questionType: "standard" | "\u00E9viter le comptage";
-    numberType: "Entiers" | "Rationnels" | "D\u00E9cimaux";
-}> | Exercise<{
     vectorIdentifiers: import("./math/geometry/vector.js").VectorIdentifiers;
     pointIdentifiers: import("./math/geometry/point.js").PointIdentifiers;
 }, Record<string, string | boolean | string[]>> | Exercise<{

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,KAAK,aAAa,MAAM,2BAA2B,CAAC;AAE3D,OAAO,4BAA4B,CAAC;AACpC,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,QAAQ,EAAE,QAAQ,EAAE,cAAc,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,KAAK,aAAa,MAAM,2BAA2B,CAAC;AAE3D,OAAO,4BAA4B,CAAC;AACpC,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,QAAQ,EAAE,QAAQ,EAAE,cAAc,EAAE,CAAC"}

package/lib/latexTester.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"latexTester.d.ts","sourceRoot":"","sources":["../src/latexTester.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,WAAW,GAAI,OAAO,MAAM,EAAE,6BAA2B,YAiLrE,CAAC"}
+{"version":3,"file":"latexTester.d.ts","sourceRoot":"","sources":["../src/latexTester.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,WAAW,GAAI,OAAO,MAAM,EAAE,6BAA2B,YAgLrE,CAAC"}

package/lib/latexTester.js

@@ -259,4 +259,5 @@ const validCmds = [
     "\\not",
     "\\nearrow",
     "\\searrow",
+    "\\mapsto",
 ];

package/lib/math/utils/functions/functionComparison.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"functionComparison.d.ts","sourceRoot":"","sources":["../../../../src/math/utils/functions/functionComparison.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAsElE,eAAO,MAAM,iBAAiB,GAC5B,OAAO,aAAa,EACpB,OAAO,aAAa,YAarB,CAAC"}
+{"version":3,"file":"functionComparison.d.ts","sourceRoot":"","sources":["../../../../src/math/utils/functions/functionComparison.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAkElE,eAAO,MAAM,iBAAiB,GAC5B,OAAO,aAAa,EACpB,OAAO,aAAa,YAarB,CAAC"}