math-exercises 3.0.27 → 3.0.29

package/lib/exercises/math/dataRepresentations/pieChartReading.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pieChartReading.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/dataRepresentations/pieChartReading.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAuBrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC;IACnB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AAoLF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAiBjD,CAAC"}
+{"version":3,"file":"pieChartReading.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/dataRepresentations/pieChartReading.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAuBrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC;IACnB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AAkLF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAiBjD,CAAC"}

package/lib/exercises/math/dataRepresentations/pieChartReading.js

@@ -56,18 +56,16 @@ const getGGBOptions = (identifiers) => {
         const angleM = angleA +
             Math.atan2(Math.sin(angleB - angleA), Math.cos(angleB - angleA)) / 2;
         return [1.2 * Math.cos(angleM), 1.2 * Math.sin(angleM)];
-        return [
-            (1.2 * (xA + xB)) / Math.sqrt((xA + xB) ** 2 + (yA + yB) ** 2 + 0.1),
-            (1.2 * (yA + yB)) / Math.sqrt((xA + xB) ** 2 + (yA + yB) ** 2 + 0.1),
-        ];
     };
     const ggb = new GeogebraConstructor({
         commands: [
             `C = Circle((0,0), 1)`,
+            `SetFixed(C, true)`,
             `SetLineThickness(C, 1)`,
             // ...pointsObj.flatMap((p) => p.toGGBCommand()),
             ...pointsObj.flatMap((p, i) => [
                 `C_${i} = CircularSector((0,0), ${pointsObj[(i + 1 + pointsObj.length) % pointsObj.length].toMathString()}, ${p.toMathString()})`,
+                `SetFixed(C_${i}, true)`,
                 `SetColor(C_${i}, "${colorWithOpacity(colors[i], 80)}")`,
                 `SetLineThickness(C_${i}, 0)`,
                 // `SetCaption(C_${i}, "$\\tiny \\text{${labels[i]}}$")`,

package/lib/exercises/math/geometry/thales/thales.d.ts

@@ -1,14 +1,14 @@
 import { Exercise } from "../../../../exercises/exercise.js";
+import { TriangleIdentifiers } from "../../../../math/geometry/triangle.js";
 type Identifiers = {
-    vertices: string[];
-    xA: number;
-    yA: number;
-    xB: number;
-    yB: number;
-    xC: number;
-    yC: number;
-    factor: number;
+    ratio: number;
+    triangleIdentifiers: TriangleIdentifiers;
+    insidePointsNames: string[];
+    isPapillon: boolean;
 };
-export declare const thales: Exercise<Identifiers>;
+type Options = {
+    configurationType: string;
+};
+export declare const thales: Exercise<Identifiers, Options>;
 export {};
 //# sourceMappingURL=thales.d.ts.map

package/lib/exercises/math/geometry/thales/thales.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"thales.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/thales/thales.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AA2IF,eAAO,MAAM,MAAM,EAAE,QAAQ,CAAC,WAAW,CAcxC,CAAC"}
+{"version":3,"file":"thales.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/thales/thales.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAGL,mBAAmB,EACpB,MAAM,iCAAiC,CAAC;AAuBzC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,mBAAmB,EAAE,mBAAmB,CAAC;IACzC,iBAAiB,EAAE,MAAM,EAAE,CAAC;IAC5B,UAAU,EAAE,OAAO,CAAC;CACrB,CAAC;AAyFF,KAAK,OAAO,GAAG;IACb,iBAAiB,EAAE,MAAM,CAAC;CAC3B,CAAC;AAoIF,eAAO,MAAM,MAAM,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAgBjD,CAAC"}

package/lib/exercises/math/geometry/thales/thales.js

@@ -1,113 +1,176 @@
-import { addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
-import { randint } from "../../../../math/utils/random/randint.js";
+import { Segment } from "../../../../math/geometry/segment.js";
+import { Triangle, TriangleConstructor, } from "../../../../math/geometry/triangle.js";
+import { VectorConstructor } from "../../../../math/geometry/vector.js";
+import { randfloat } from "../../../../math/utils/random/randfloat.js";
 import { MultiEqualNode } from "../../../../tree/nodes/equations/multiEqualNode.js";
-import { LengthNode } from "../../../../tree/nodes/geometry/lengthNode.js";
+import { length } from "../../../../tree/nodes/geometry/lengthNode.js";
 import { FractionNode } from "../../../../tree/nodes/operators/fractionNode.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
 import { shuffle } from "../../../../utils/alea/shuffle.js";
-const getThales = () => {
-    const vertices = [];
-    const code = 65 + randint(0, 22); // Générer un code de caractère majuscule aléatoire (A-Z)
-    for (let i = 0; i < 5; i++)
-        vertices.push(String.fromCharCode(code + i));
-    const [xA, yA] = [randint(-10, 11), randint(-10, 11)];
-    let xB, yB, xC, yC;
-    let d1, d2; // distance entre le point A et B
-    let theta = 0; // angle entre AB et AC
-    do {
-        [xB, yB, xC, yC] = [
-            randint(-10, 11),
-            randint(-10, 11),
-            randint(-10, 11),
-            randint(-10, 11),
-        ];
-        d1 = Math.hypot(xB - xA, yB - yA); // Calculer la distance entre A et B
-        d2 = Math.hypot(xC - xA, yC - yA); // Calculer la distance entre A et C
-        theta = Math.acos(((xB - xA) * (xC - xA) + (yB - yA) * (yC - yA)) / (d1 * d2));
-    } while (!theta ||
-        theta < 0.35 ||
-        theta > 2.1 ||
-        d1 / d2 > 1.3 ||
-        d1 / d2 < 0.7);
-    const factor = randint(-5, 6, [-2, -1, 0, 1, 2]) / 10; // facteur = AB/AE, Pour que l'affichage soit acceptable, les valeurs de factor sont +- 0.5 0.4 0.3
-    const [xD, yD] = [xA + factor * (xB - xA), yA + factor * (yB - yA)];
-    const [xE, yE] = [xA + factor * (xC - xA), yA + factor * (yC - yA)];
-    const xMin = Math.min(xA, xB, xC, xD, xE);
-    const xMax = Math.max(xA, xB, xC, xD, xE);
-    const yMin = Math.min(yA, yB, yC, yD, yE);
-    const yMax = Math.max(yA, yB, yC, yD, yE);
+import { randomLetter } from "../../../../utils/strings/randomLetter.js";
+const getSubTriangle = ({ triangle, insidePointsNames, ratio, isPapillon, }) => {
+    const [A, B, C] = triangle.points;
+    const [dName, eName] = insidePointsNames;
+    const vecAC = VectorConstructor.fromPoints(A, C).times((1 - ratio).toTree());
+    const pointD = vecAC.getEndPoint(A, dName);
+    const vecBC = VectorConstructor.fromPoints(B, C).times((1 - ratio).toTree());
+    const pointE = vecBC.getEndPoint(B, eName);
+    return new Triangle([pointD, pointE, triangle.points[2]]);
+};
+const getInstruction = (identifiers) => {
+    const { triangleIdentifiers, insidePointsNames } = identifiers;
+    const triangle = TriangleConstructor.fromIdentifiers(triangleIdentifiers);
+    return `En utilisant le théoreme de Thalès, écrire l'égalité des quotients sachant que  $\\left(${insidePointsNames.join("")}\\right)//\\left(${triangle.sides[2].toInsideName()}\\right)$.`;
+};
+const getAnswer = (identifiers) => {
+    const { triangleIdentifiers, insidePointsNames, isPapillon, ratio } = identifiers;
+    const triangle = TriangleConstructor.fromIdentifiers(triangleIdentifiers);
+    const subTriangle = getSubTriangle({
+        triangle,
+        insidePointsNames,
+        ratio,
+        isPapillon,
+    });
+    const answer = `\\frac{${triangle.sides[0].toInsideName()}}{${subTriangle.sides[0].toInsideName()}}=\\frac{${triangle.sides[1].toInsideName()}}{${subTriangle.sides[1].toInsideName()}}=\\frac{${triangle.sides[2].toInsideName()}}{${subTriangle.sides[2].toInsideName()}}`;
+    return answer;
+};
+const getGGBOptions = (identifiers) => {
+    const triangle = TriangleConstructor.fromIdentifiers(identifiers.triangleIdentifiers);
+    const subTriangle = getSubTriangle({
+        triangle,
+        insidePointsNames: identifiers.insidePointsNames,
+        ratio: identifiers.ratio,
+        isPapillon: identifiers.isPapillon,
+    });
+    const points = [subTriangle.points[0], subTriangle.points[1]];
+    const seg = new Segment(points[0], points[1]);
     const commands = [
-        `${vertices[0]} = Point({${xA}, ${yA}})`,
-        `${vertices[1]} = Point({${xB}, ${yB}})`,
-        `${vertices[2]} = Point({${xC}, ${yC}})`,
-        `${vertices[3]} = Point(${vertices[0]}, Vector(${factor}Vector(${vertices[0]},${vertices[1]})))`,
-        `${vertices[4]} = Intersect(Line(${vertices[3]}, Line(${vertices[1]}, ${vertices[2]})) , Line(${vertices[0]}, ${vertices[2]}))`,
-        `l = Segment(${vertices[0]}, ${vertices[1]})`,
-        `i = Segment(${vertices[0]}, ${vertices[2]})`,
-        `j = Segment(${vertices[1]}, ${vertices[2]})`,
-        `k = Segment(${vertices[3]}, ${vertices[4]})`,
-        `If(${factor} < 0, Segment(${vertices[0]}, ${vertices[3]}))`,
-        `If(${factor} < 0, Segment(${vertices[0]}, ${vertices[4]}))`,
-        `ShowLabel(${vertices[0]}, true)`,
-        `ShowLabel(${vertices[1]}, true)`,
-        `ShowLabel(${vertices[2]}, true)`,
-        `ShowLabel(${vertices[3]}, true)`,
-        `ShowLabel(${vertices[4]}, true)`,
+        ...triangle.commands,
+        ...points.flatMap((p) => p.toGGBCommand({ color: "#444444", size: 4 })),
+        ...seg.toGGBCommands(false),
     ];
-    const answer = `\\frac{${vertices[0]}${vertices[3]}}{${vertices[0]}${vertices[1]}}=\\frac{${vertices[0]}${vertices[4]}}{${vertices[0]}${vertices[2]}}=\\frac{${vertices[3]}${vertices[4]}}{${vertices[1]}${vertices[2]}}`;
+    if (identifiers.isPapillon) {
+        commands.push(...new Segment(points[0], triangle.points[2]).toGGBCommands(false));
+        commands.push(...new Segment(points[1], triangle.points[2]).toGGBCommands(false));
+    }
     const ggb = new GeogebraConstructor({
         commands,
         hideAxes: true,
         hideGrid: true,
     });
+    let coords = triangle.generateCoords();
+    if (identifiers.isPapillon) {
+        const subCoords = subTriangle.generateCoords();
+        coords = [
+            Math.min(subCoords[0], coords[0]),
+            Math.max(subCoords[1], coords[1]),
+            Math.min(subCoords[2], coords[2]),
+            Math.max(subCoords[3], coords[3]),
+        ];
+    }
+    return ggb.getOptions({
+        coords: coords,
+    });
+};
+const options = [
+    {
+        id: "configurationType",
+        label: "Types de figure",
+        defaultValue: "Toutes",
+        values: ["Toutes", "Uniquement papillon", "Uniquement non papillon"],
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.select,
+    },
+];
+const getThales = (opts) => {
+    const triangle = TriangleConstructor.randomNiceSides({
+        randomName: true,
+    });
+    const summitNames = triangle.points.map((p) => p.name);
+    const isPapillon = !opts || opts?.configurationType === "Toutes"
+        ? coinFlip()
+        : opts.configurationType === "Uniquement papillon"
+            ? true
+            : false;
+    //homothety rapport
+    const ratio = !isPapillon ? randfloat(0.2, 0.8, 1) : randfloat(-0.2, -0.8, 1);
+    // const ratio = 0.5;
+    const dName = randomLetter(true, summitNames);
+    const eName = randomLetter(true, [...summitNames, dName]);
+    const identifiers = {
+        triangleIdentifiers: triangle.toIdentifiers(),
+        insidePointsNames: [dName, eName],
+        isPapillon,
+        ratio,
+    };
     const question = {
-        instruction: `En utilisant le théoreme de Thalès, écrire l'égalité des quotients sachant que  $(${vertices[3]}${vertices[4]})//(${vertices[1]}${vertices[2]})$.`,
-        answer,
-        keys: [...vertices, "equal"],
-        ggbOptions: ggb.getOptions({
-            coords: [xMin - 1, xMax + 1, yMin - 1, yMax + 1],
-        }),
+        instruction: getInstruction(identifiers),
+        answer: getAnswer(identifiers),
+        keys: [
+            "equal",
+            ...triangle.points.map((p) => p.name),
+            ...[dName, eName],
+        ],
+        ggbOptions: getGGBOptions(identifiers),
         answerFormat: "tex",
-        identifiers: { vertices, xA, yA, xB, yB, xC, yC, factor },
+        identifiers,
     };
     return question;
 };
-const getPropositions = (n, { answer, vertices }) => {
+const getPropositions = (n, { answer, ...identifiers }) => {
     const propositions = [];
-    const wrongQuotients = [
-        vertices[0] + vertices[3],
-        vertices[0] + vertices[1],
-        vertices[0] + vertices[4],
-        vertices[0] + vertices[2],
-        vertices[3] + vertices[4],
-        vertices[1] + vertices[2],
-        vertices[1] + vertices[3],
-        vertices[2] + vertices[4],
+    const { triangleIdentifiers, insidePointsNames, isPapillon, ratio } = identifiers;
+    const triangle = TriangleConstructor.fromIdentifiers(triangleIdentifiers);
+    const subTriangle = getSubTriangle({
+        triangle,
+        insidePointsNames,
+        ratio,
+        isPapillon,
+    });
+    const lengths = [
+        ...triangle.sides.map((s) => s.toInsideName()),
+        ...subTriangle.sides.map((s) => s.toInsideName()),
     ];
     addValidProp(propositions, answer);
-    const indexRange = Array.from({ length: 8 }, (_, i) => i);
+    const indexRange = Array.from({ length: 6 }, (_, i) => i);
     while (propositions.length < n) {
-        const rands = shuffle(indexRange).slice(0, 6);
-        tryToAddWrongProp(propositions, `\\frac{${wrongQuotients[rands[0]]}}{${wrongQuotients[rands[1]]}} =
-    \\frac{${wrongQuotients[rands[2]]}}{${wrongQuotients[rands[3]]}} =
-    \\frac{${wrongQuotients[rands[4]]}}{${wrongQuotients[rands[5]]}}`);
+        let rands = [];
+        do {
+            rands = shuffle(indexRange);
+        } while ((rands[0] - rands[1] === 3 &&
+            rands[2] - rands[3] === 3 &&
+            rands[4] - rands[5] === 3) ||
+            (rands[0] - rands[1] === -3 &&
+                rands[2] - rands[3] === -3 &&
+                rands[4] - rands[5] === -3));
+        //a,b,c,d,e,f
+        //interdire distance = 3 entre a,b c,d e,f
+        tryToAddWrongProp(propositions, `\\frac{${lengths[rands[0]]}}{${lengths[rands[1]]}} =
+    \\frac{${lengths[rands[2]]}}{${lengths[rands[3]]}} =
+    \\frac{${lengths[rands[4]]}}{${lengths[rands[5]]}}`);
     }
     return shuffle(propositions);
 };
-const isAnswerValid = (ans, { vertices }) => {
+const isAnswerValid = (ans, { ...identifiers }) => {
+    const { triangleIdentifiers, insidePointsNames, isPapillon, ratio } = identifiers;
+    const triangle = TriangleConstructor.fromIdentifiers(triangleIdentifiers);
+    const subTriangle = getSubTriangle({
+        triangle,
+        insidePointsNames,
+        ratio,
+        isPapillon,
+    });
     const lengths = [
-        new LengthNode(`${vertices[0]}${vertices[3]}`),
-        new LengthNode(`${vertices[0]}${vertices[1]}`),
-        new LengthNode(`${vertices[0]}${vertices[4]}`),
-        new LengthNode(`${vertices[0]}${vertices[2]}`),
-        new LengthNode(`${vertices[3]}${vertices[4]}`),
-        new LengthNode(`${vertices[1]}${vertices[2]}`),
-    ];
+        ...triangle.sides.map((s) => s.toInsideName()),
+        ...subTriangle.sides.map((s) => s.toInsideName()),
+    ].map((s) => length(s));
     const fractions = [
-        new FractionNode(lengths[0], lengths[1]),
-        new FractionNode(lengths[2], lengths[3]),
-        new FractionNode(lengths[4], lengths[5]),
+        new FractionNode(lengths[0], lengths[3]),
+        new FractionNode(lengths[1], lengths[4]),
+        new FractionNode(lengths[2], lengths[5]),
     ];
     const answers = [
         new MultiEqualNode(fractions),
@@ -119,15 +182,17 @@ const isAnswerValid = (ans, { vertices }) => {
 export const thales = {
     id: "thales",
     connector: "=",
-    label: "Ecrire l'égalité de Thalès",
-    levels: ["5ème", "4ème", "3ème", "2nde"],
+    label: "Écrire l'égalité de Thalès",
     isSingleStep: false,
-    sections: ["Théorème de Thalès", "Géométrie euclidienne"],
-    generator: (nb) => getDistinctQuestions(getThales, nb),
+    generator: (nb, opts) => getDistinctQuestions(() => getThales(opts), nb),
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
     isAnswerValid,
     hasGeogebra: true,
     subject: "Mathématiques",
+    getAnswer,
+    getInstruction,
+    getGGBOptions,
+    options,
 };

package/lib/exercises/math/geometry/thales/thalesCalcul.js

@@ -137,8 +137,8 @@ const getThalesFindSideQuestion = (opts) => {
             ? true
             : false;
     //homothety rapport
-    // const ratio = !isPapillon ? randfloat(0.2, 0.8, 1) : randfloat(-0.2, -0.8, 1);
-    const ratio = 0.5;
+    const ratio = !isPapillon ? randfloat(0.2, 0.8, 1) : randfloat(-0.2, -0.8, 1);
+    // const ratio = 0.5;
     const dName = randomLetter(true, summitNames);
     const eName = randomLetter(true, [...summitNames, dName]);
     const subTriangle = getSubTriangle({

package/lib/index.d.ts

@@ -1071,15 +1071,13 @@ declare const mathExercises: (Exercise<{
     c: number;
     vertices: string[];
 }, {}> | Exercise<{
-    vertices: string[];
-    xA: number;
-    yA: number;
-    xB: number;
-    yB: number;
-    xC: number;
-    yC: number;
-    factor: number;
-}, {}> | Exercise<{
+    ratio: number;
+    triangleIdentifiers: import("./math/geometry/triangle.js").TriangleIdentifiers;
+    insidePointsNames: string[];
+    isPapillon: boolean;
+}, {
+    configurationType: string;
+}> | Exercise<{
     ratio: number;
     triangleIdentifiers: import("./math/geometry/triangle.js").TriangleIdentifiers;
     insidePointsNames: string[];
@@ -1971,15 +1969,13 @@ declare const pcExercises: (Exercise<{
 }, {
     isLog10: boolean;
 }> | Exercise<{
-    vertices: string[];
-    xA: number;
-    yA: number;
-    xB: number;
-    yB: number;
-    xC: number;
-    yC: number;
-    factor: number;
-}, {}> | Exercise<{
+    ratio: number;
+    triangleIdentifiers: import("./math/geometry/triangle.js").TriangleIdentifiers;
+    insidePointsNames: string[];
+    isPapillon: boolean;
+}, {
+    configurationType: string;
+}> | Exercise<{
     ratio: number;
     triangleIdentifiers: import("./math/geometry/triangle.js").TriangleIdentifiers;
     insidePointsNames: string[];

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/lib/tree/nodes/geometry/lengthNode.d.ts

@@ -1,6 +1,7 @@
 import { AlgebraicNode } from "../algebraicNode.js";
 import { Node, NodeIds, NodeOptions, NodeType } from "../node.js";
 export declare function isLengthNode(a: Node): a is LengthNode;
+export declare const length: (a: string) => LengthNode;
 export declare class LengthNode implements AlgebraicNode {
     opts?: NodeOptions | undefined;
     segmentName: string;
@@ -17,7 +18,7 @@ export declare class LengthNode implements AlgebraicNode {
     toMathjs(): string;
     toTex(): string;
     evaluate(vars?: Record<string, number>): number;
-    simplify(): this;
+    simplify(): LengthNode;
     equals(node: AlgebraicNode): boolean;
     toDetailedEvaluation(vars: Record<string, AlgebraicNode>): this;
     derivative(varName?: string | undefined): AlgebraicNode;

package/lib/tree/nodes/geometry/lengthNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lengthNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/geometry/lengthNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAClE,wBAAgB,YAAY,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,UAAU,CAErD;AACD,qBAAa,UAAW,YAAW,aAAa;IAC9C,IAAI,CAAC,EAAE,WAAW,GAAG,SAAS,CAAC;IAC/B,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;gBACP,WAAW,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,WAAW;IAUnD,cAAc;IAGd,aAAa;;;;IAMb,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;IAOpC,YAAY;IAGZ,QAAQ;IAIR,KAAK;IAIL,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAQtC,QAAQ;IAGR,MAAM,CAAC,IAAI,EAAE,aAAa;IAG1B,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAGxD,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,aAAa;CAGxD"}
+{"version":3,"file":"lengthNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/geometry/lengthNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAClE,wBAAgB,YAAY,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,UAAU,CAErD;AAED,eAAO,MAAM,MAAM,MAAO,MAAM,eAE/B,CAAC;AACF,qBAAa,UAAW,YAAW,aAAa;IAC9C,IAAI,CAAC,EAAE,WAAW,GAAG,SAAS,CAAC;IAC/B,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;gBACP,WAAW,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,WAAW;IAUnD,cAAc;IAGd,aAAa;;;;IAMb,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;IAOpC,YAAY;IAGZ,QAAQ;IAIR,KAAK;IAIL,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAQtC,QAAQ;IAOR,MAAM,CAAC,IAAI,EAAE,aAAa;IAG1B,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAGxD,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,aAAa;CAGxD"}

package/lib/tree/nodes/geometry/lengthNode.js

@@ -2,6 +2,9 @@ import { NodeIds, NodeType } from "../node.js";
 export function isLengthNode(a) {
     return a.type === NodeType.mesure;
 }
+export const length = (a) => {
+    return new LengthNode(a);
+};
 export class LengthNode {
     opts;
     segmentName;
@@ -48,7 +51,10 @@ export class LengthNode {
         return value;
     }
     simplify() {
-        return this;
+        const isAlphabeticallyOrdered = (str) => [...str].every((c, i, arr) => i === 0 || arr[i - 1] <= c);
+        return isAlphabeticallyOrdered(this.segmentName)
+            ? this
+            : new LengthNode(this.segmentName.split("").reverse().join(""));
     }
     equals(node) {
         return isLengthNode(node) && node.segmentName === this.segmentName;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "math-exercises",
   "type": "module",
-  "version": "3.0.27",
+  "version": "3.0.29",
   "description": "Math exercises generator for middle school and high school",
   "main": "lib/index.js",
   "files": [