math-exercises 2.2.75 → 2.2.77

package/lib/exercises/math/functions/absolute/absolueValueInequationsSup.js

@@ -84,7 +84,7 @@ const getAbsolueValueInequationsSupQuestion = (ops) => {
 exports.absolueValueInequationsSup = {
     id: "absolueValueInequationsSup",
     connector: "\\iff",
-    label: "Résoudre une inéquation avec valeur absolue du type $|ax+b| > c",
+    label: "Résoudre une inéquation avec valeur absolue du type $|ax+b| > c$",
     isSingleStep: true,
     generator: (nb, opts) => (0, getDistinctQuestions_1.getDistinctQuestions)(() => getAbsolueValueInequationsSupQuestion(opts), nb),
     qcmTimer: 60,

package/lib/exercises/math/functions/basics/graphicInequation.js

@@ -76,8 +76,8 @@ const getGraphicInequationQuestion = () => {
     const yMax = Math.max(...splinePoints.map((point) => point[1]));
     const intervalsNodes = intervals.map((i) => new intervalNode_1.IntervalNode(new numberNode_1.NumberNode(i.a), new numberNode_1.NumberNode(i.b), i.closure));
     const answer = intervalsNodes.length === 1
-        ? `S=${intervalsNodes[0].toTex()}`
-        : `S=${new unionIntervalNode_1.UnionIntervalNode(intervalsNodes).toTex()}`;
+        ? `S=\\ ${intervalsNodes[0].toTex()}`
+        : `S=\\ ${new unionIntervalNode_1.UnionIntervalNode(intervalsNodes).toTex()}`;
     const commands = [
         `S =Spline(${splinePoints
             .map((point) => `(${point[0]},${point[1]})`)
@@ -121,20 +121,20 @@ const getPropositions = (n, { answer, intervals, splinePoints, yValue }) => {
         (0, exercise_1.tryToAddWrongProp)(propositions, `S=\\varnothing`);
     if (intervals.length === 1) {
         const interval = new intervalNode_1.IntervalNode(intervals[0].a.toTree(), intervals[0].b.toTree(), intervals[0].closure);
-        (0, exercise_1.tryToAddWrongProp)(propositions, `S=${interval.toRandomDifferentClosure().toTex()}`);
+        (0, exercise_1.tryToAddWrongProp)(propositions, `S=\\ ${interval.toRandomDifferentClosure().toTex()}`);
     }
     else if (intervals.length === 2) {
         const rightIntervals = intervals.map((i) => new intervalNode_1.IntervalNode(i.a.toTree(), i.b.toTree(), i.closure));
         const fakeIntervals = intervals.map((i) => new intervalNode_1.IntervalNode(i.a.toTree(), i.b.toTree(), i.closure));
-        (0, exercise_1.tryToAddWrongProp)(propositions, `S=${rightIntervals[(0, coinFlip_1.coinFlip)() ? 0 : 1].toTex()}`);
-        (0, exercise_1.tryToAddWrongProp)(propositions, `S=${new unionIntervalNode_1.UnionIntervalNode(fakeIntervals.map((i) => i.toRandomDifferentClosure())).toTex()}`);
+        (0, exercise_1.tryToAddWrongProp)(propositions, `S=\\ ${rightIntervals[(0, coinFlip_1.coinFlip)() ? 0 : 1].toTex()}`);
+        (0, exercise_1.tryToAddWrongProp)(propositions, `S=\\ ${new unionIntervalNode_1.UnionIntervalNode(fakeIntervals.map((i) => i.toRandomDifferentClosure())).toTex()}`);
     }
     while (propositions.length < n) {
         let a = (0, randint_1.randint)(splinePoints[0][0], splinePoints[splinePoints.length - 1][0] + 1);
         let b = (0, randint_1.randint)(splinePoints[0][0], splinePoints[splinePoints.length - 1][0] + 1, [a]);
         if (a > b)
             [a, b] = [b, a];
-        (0, exercise_1.tryToAddWrongProp)(propositions, `S=${new intervalNode_1.IntervalNode(new numberNode_1.NumberNode(a), new numberNode_1.NumberNode(b), closure_1.ClosureType.FF).toTex()}`);
+        (0, exercise_1.tryToAddWrongProp)(propositions, `S=\\ ${new intervalNode_1.IntervalNode(new numberNode_1.NumberNode(a), new numberNode_1.NumberNode(b), closure_1.ClosureType.FF).toTex()}`);
     }
     return (0, exercise_1.shuffleProps)(propositions, n);
 };

package/lib/exercises/math/functions/basics/graphicInequationAffine.js

@@ -76,7 +76,7 @@ const getKeys = (identifiers) => {
 };
 const isAnswerValid = (ans, { answer }) => {
     const inter = answer;
-    return ans === inter || ans === "S=" + inter;
+    return ans === inter || ans === "S=\\ " + inter;
     throw Error("VEA not implemented");
 };
 const getGraphicInequationAffineQuestion = (opts) => {

package/lib/exercises/math/functions/basics/twoFunctionsInequation.js

@@ -108,8 +108,8 @@ const getTwoFunctionsInequationQuestion = () => {
     const ggb = new geogebraConstructor_1.GeogebraConstructor({ commands });
     const intervalsNodes = intervals.map((i) => new intervalNode_1.IntervalNode(new numberNode_1.NumberNode(i.a), new numberNode_1.NumberNode(i.b), i.closure));
     const answer = intervalsNodes.length === 1
-        ? `S=${intervalsNodes[0].toTex()}`
-        : `S=${new unionIntervalNode_1.UnionIntervalNode(intervalsNodes).toTex()}`;
+        ? `S=\\ ${intervalsNodes[0].toTex()}`
+        : `S=\\ ${new unionIntervalNode_1.UnionIntervalNode(intervalsNodes).toTex()}`;
     const question = {
         answer,
         instruction: `Déterminer graphiquement les solutions de l'inéquation $f(x) ${ineq.symbol} g(x)$ où $f$ et $g$ sont les fonctions représentées ci-dessous.`,
@@ -145,13 +145,13 @@ const getPropositions = (n, { answer, intervals, fSplinePoints, ineqSymbol }) =>
         (0, exercise_1.tryToAddWrongProp)(propositions, `S=\\varnothing`);
     if (intervals.length === 1) {
         const interval = new intervalNode_1.IntervalNode(intervals[0].a.toTree(), intervals[0].b.toTree(), intervals[0].closure);
-        (0, exercise_1.tryToAddWrongProp)(propositions, `S=${interval.toRandomDifferentClosure().toTex()}`);
+        (0, exercise_1.tryToAddWrongProp)(propositions, `S=\\ ${interval.toRandomDifferentClosure().toTex()}`);
     }
     else {
         const rightIntervals = intervals.map((i) => new intervalNode_1.IntervalNode(i.a.toTree(), i.b.toTree(), i.closure));
         const fakeIntervals = intervals.map((i) => new intervalNode_1.IntervalNode(i.a.toTree(), i.b.toTree(), i.closure));
-        (0, exercise_1.tryToAddWrongProp)(propositions, `S=${rightIntervals[(0, coinFlip_1.coinFlip)() ? 0 : 1].toTex()}`);
-        (0, exercise_1.tryToAddWrongProp)(propositions, `S=${new unionIntervalNode_1.UnionIntervalNode(fakeIntervals.map((i) => i.toRandomDifferentClosure())).toTex()}`);
+        (0, exercise_1.tryToAddWrongProp)(propositions, `S=\\ ${rightIntervals[(0, coinFlip_1.coinFlip)() ? 0 : 1].toTex()}`);
+        (0, exercise_1.tryToAddWrongProp)(propositions, `S=\\ ${new unionIntervalNode_1.UnionIntervalNode(fakeIntervals.map((i) => i.toRandomDifferentClosure())).toTex()}`);
     }
     while (propositions.length < n) {
         const isStrict = ineqSymbol === "<" || ineqSymbol === ">";
@@ -159,7 +159,7 @@ const getPropositions = (n, { answer, intervals, fSplinePoints, ineqSymbol }) =>
         const x2 = (0, randint_1.randint)(x1 + 1, x1 + 5);
         const x3 = (0, randint_1.randint)(x2 + 3, x2 + 6);
         const x4 = (0, randint_1.randint)(x3 + 1, x3 + 3);
-        (0, exercise_1.tryToAddWrongProp)(propositions, `S=${new unionIntervalNode_1.UnionIntervalNode([
+        (0, exercise_1.tryToAddWrongProp)(propositions, `S=\\ ${new unionIntervalNode_1.UnionIntervalNode([
             new intervalNode_1.IntervalNode(x1.toTree(), x2.toTree(), isStrict ? closure_1.ClosureType.FO : closure_1.ClosureType.FF),
             new intervalNode_1.IntervalNode(x3.toTree(), x4.toTree(), isStrict ? closure_1.ClosureType.OF : closure_1.ClosureType.FF),
         ]).toTex()}`);

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

@@ -69,7 +69,7 @@ const getPointImageFromTranslationQuestion = (opts) => {
     const points = [];
     for (let i = 0; i < 4; i++) {
         const name = String.fromCharCode(65 + i);
-        const newPoint = (0, doWhile_1.doWhile)(() => point_1.PointConstructor.random(name, -4, 5), (p) => points.some((p2) => p.equals(p2)));
+        const newPoint = (0, doWhile_1.doWhile)(() => point_1.PointConstructor.random(name, -4, 5), (p) => points.some((p2) => p.distanceTo(p2) < 2));
         points.push(newPoint);
     }
     const startPoint = (0, random_1.random)(points).name;

package/lib/exercises/math/geometry/vectors/alignementViaColinearity.js

@@ -10,7 +10,7 @@ const numberNode_1 = require("../../../../tree/nodes/numbers/numberNode");
 const coinFlip_1 = require("../../../../utils/alea/coinFlip");
 const shuffle_1 = require("../../../../utils/alea/shuffle");
 const getAlignementViaColinearityQuestion = () => {
-    const points = point_1.PointConstructor.randomDifferent(["A", "B"]);
+    const points = point_1.PointConstructor.randomDifferent(2, { names: ["A", "B"] });
     const AB = vector_1.VectorConstructor.fromPoints(points[0], points[1]);
     let C;
     const isAligned = (0, coinFlip_1.coinFlip)();

package/lib/exercises/math/geometry/vectors/fourthParallelogramPoint.js

@@ -10,7 +10,7 @@ const randint_1 = require("../../../../math/utils/random/randint");
 const numberNode_1 = require("../../../../tree/nodes/numbers/numberNode");
 const shuffle_1 = require("../../../../utils/alea/shuffle");
 const getFourthParallelogramPointQuestion = () => {
-    const points = point_1.PointConstructor.randomDifferent(["A", "B"]);
+    const points = point_1.PointConstructor.randomDifferent(2, { names: ["A", "B"] });
     const AB = vector_1.VectorConstructor.fromPoints(points[0], points[1]);
     let D;
     do {

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

@@ -13,4 +13,8 @@ export * from "./vectorNormCalculation";
 export * from "./lineFromDirectorVector";
 export * from "./drawAVectorInGGB";
 export * from "./scalarProduct";
+export * from "./traceVectorSum";
+export * from "./traceVectorDifference";
+export * from "./traceOppositeVector";
+export * from "./traceVectorMultiple";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/vectors/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,cAAc,sBAAsB,CAAC;AACrC,cAAc,eAAe,CAAC;AAC9B,cAAc,kCAAkC,CAAC;AACjD,cAAc,eAAe,CAAC;AAC9B,cAAc,4BAA4B,CAAC;AAC3C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,yBAAyB,CAAC;AACxC,cAAc,0BAA0B,CAAC;AACzC,cAAc,oBAAoB,CAAC;AACnC,cAAc,iBAAiB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/vectors/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,cAAc,sBAAsB,CAAC;AACrC,cAAc,eAAe,CAAC;AAC9B,cAAc,kCAAkC,CAAC;AACjD,cAAc,eAAe,CAAC;AAC9B,cAAc,4BAA4B,CAAC;AAC3C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,yBAAyB,CAAC;AACxC,cAAc,0BAA0B,CAAC;AACzC,cAAc,oBAAoB,CAAC;AACnC,cAAc,iBAAiB,CAAC;AAChC,cAAc,kBAAkB,CAAC;AACjC,cAAc,yBAAyB,CAAC;AACxC,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC"}

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

@@ -29,3 +29,7 @@ __exportStar(require("./vectorNormCalculation"), exports);
 __exportStar(require("./lineFromDirectorVector"), exports);
 __exportStar(require("./drawAVectorInGGB"), exports);
 __exportStar(require("./scalarProduct"), exports);
+__exportStar(require("./traceVectorSum"), exports);
+__exportStar(require("./traceVectorDifference"), exports);
+__exportStar(require("./traceOppositeVector"), exports);
+__exportStar(require("./traceVectorMultiple"), exports);

package/lib/exercises/math/geometry/vectors/paralellismViaColinearity.js

@@ -13,7 +13,7 @@ const shuffle_1 = require("../../../../utils/alea/shuffle");
 const getParalellismViaColinearityQuestion = () => {
     let points = [];
     do {
-        points = point_1.PointConstructor.randomDifferent(["A", "B"]);
+        points = point_1.PointConstructor.randomDifferent(2, { names: ["A", "B"] });
     } while (points[0].x.equals(points[1].x));
     const line = new line_1.Line(points[0], points[1]);
     let C;

package/lib/exercises/math/geometry/vectors/parallelogramViaEqualVectors.js

@@ -8,7 +8,7 @@ const vector_1 = require("../../../../math/geometry/vector");
 const coinFlip_1 = require("../../../../utils/alea/coinFlip");
 const shuffle_1 = require("../../../../utils/alea/shuffle");
 const getParallelogramViaEqualVectorsQuestion = () => {
-    const points = point_1.PointConstructor.randomDifferent(["A", "B"]);
+    const points = point_1.PointConstructor.randomDifferent(2, { names: ["A", "B"] });
     const AB = vector_1.VectorConstructor.fromPoints(points[0], points[1]);
     let D;
     do {

package/lib/exercises/math/geometry/vectors/traceOppositeVector.d.ts

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../../exercises/exercise";
+import { PointIdentifiers } from "../../../../math/geometry/point";
+type Identifiers = {
+    points: PointIdentifiers[];
+    startPointIndex: number;
+    vectorPointsIndexes: number[];
+};
+export declare const traceOppositeVector: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=traceOppositeVector.d.ts.map

package/lib/exercises/math/geometry/vectors/traceOppositeVector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"traceOppositeVector.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/vectors/traceOppositeVector.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAMlC,OAAO,EAGL,gBAAgB,EACjB,MAAM,2BAA2B,CAAC;AAOnC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,gBAAgB,EAAE,CAAC;IAC3B,eAAe,EAAE,MAAM,CAAC;IACxB,mBAAmB,EAAE,MAAM,EAAE,CAAC;CAC/B,CAAC;AAqHF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAgBrD,CAAC"}

package/lib/exercises/math/geometry/vectors/traceOppositeVector.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.traceOppositeVector = void 0;
+const toolBarConstructor_1 = require("../../../../exercises/utils/geogebra/toolBarConstructor");
+const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
+const geogebraConstructor_1 = require("../../../../geogebra/geogebraConstructor");
+const ggbPointToCoords_1 = require("../../../../geogebra/parsers/ggbPointToCoords");
+const parseGGBPoints_1 = require("../../../../geogebra/parsers/parseGGBPoints");
+const point_1 = require("../../../../math/geometry/point");
+const vector_1 = require("../../../../math/geometry/vector");
+const randint_1 = require("../../../../math/utils/random/randint");
+const random_1 = require("../../../../utils/alea/random");
+const getSolutionPoint = (identifiers) => {
+    const points = identifiers.points.map(point_1.PointConstructor.fromIdentifiers);
+    const origin = points[identifiers.startPointIndex];
+    const vec = vector_1.VectorConstructor.fromPoints(points[identifiers.vectorPointsIndexes[0]], points[identifiers.vectorPointsIndexes[1]]);
+    return vec.opposite().getEndPoint(origin, "K");
+};
+const getInstruction = (identifiers) => {
+    const { startPointIndex, vectorPointsIndexes } = identifiers;
+    const origin = identifiers.points[startPointIndex].name;
+    const vec = `${identifiers.points[vectorPointsIndexes[0]].name}${identifiers.points[vectorPointsIndexes[1]].name}`;
+    return `Placer le point $K$ tel que : 
+      
+$$
+\\overrightarrow{${origin}K} = -\\overrightarrow{${vec}}
+$$`;
+};
+// const getHint: GetHint<Identifiers> = (identifiers) => {};
+// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {};
+const getGGBAnswer = (identifiers) => {
+    return getSolutionPoint(identifiers).toGGBCommand();
+};
+const getStudentGGBOptions = (identifiers) => {
+    const commands = identifiers.points.flatMap((p) => point_1.PointConstructor.fromIdentifiers(p).toGGBCommand());
+    const ggb = new geogebraConstructor_1.GeogebraConstructor({
+        commands,
+        customToolBar: (0, toolBarConstructor_1.toolBarConstructor)({
+            point: true,
+        }),
+        hideAxes: true,
+    });
+    const points = identifiers.points.map((p) => point_1.PointConstructor.fromIdentifiers(p));
+    const solutionPoint = getSolutionPoint(identifiers);
+    return ggb.getOptions({
+        coords: ggb.getCoordsForPoints([...points, solutionPoint]),
+    });
+};
+const isGGBAnswerValid = (ans, { ggbAnswer, ...identifiers }) => {
+    const studentAns = ans.filter((c) => !["A", "B", "C"].includes(c[0]));
+    if (studentAns.length !== 1)
+        return false;
+    const solutionPoint = getSolutionPoint(identifiers);
+    const pointCoords = (0, parseGGBPoints_1.parseGGBPoints)(studentAns).map((p) => (0, ggbPointToCoords_1.ggbPointToCoords)(p));
+    if (pointCoords.length !== 1)
+        return false;
+    return (new point_1.Point("K", pointCoords[0].x, pointCoords[0].y).distanceTo(solutionPoint) < 1);
+};
+const getTraceOppositeVectorQuestion = () => {
+    const names = ["A", "B", "C"];
+    let points = [];
+    let startPointIndex;
+    let vectorPointsIndexes;
+    while (true) {
+        points = [];
+        points.push(...point_1.PointConstructor.randomDifferent(3, {
+            minDistance: 2,
+            names,
+            minDistanceToOrigin: 3,
+        }));
+        startPointIndex = (0, randint_1.randint)(0, names.length);
+        vectorPointsIndexes = (0, random_1.randomMany)([0, 1, 2], 2);
+        const vec = vector_1.VectorConstructor.fromPoints(points[vectorPointsIndexes[0]], points[vectorPointsIndexes[1]]);
+        const endPoint = vec.opposite().getEndPoint(points[startPointIndex], "K");
+        if (endPoint.distanceTo(new point_1.Point("O", 0, 0)) > 10 ||
+            points.some((p) => p.equals(endPoint)))
+            continue;
+        break;
+    }
+    const identifiers = {
+        vectorPointsIndexes,
+        points: points.map((p) => p.toIdentifiers()),
+        startPointIndex,
+    };
+    const question = {
+        ggbAnswer: getGGBAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        studentGgbOptions: getStudentGGBOptions(identifiers),
+        identifiers,
+        // hint: getHint(identifiers),
+        // correction: getCorrection(identifiers),
+    };
+    return question;
+};
+exports.traceOppositeVector = {
+    id: "traceOppositeVector",
+    label: "Placer un point $K$ tel que $\\overrightarrow{AK} = -\\overrightarrow{BC}$",
+    isSingleStep: true,
+    generator: (nb, opts) => (0, getDistinctQuestions_1.getDistinctQuestions)(() => getTraceOppositeVectorQuestion(opts), nb),
+    ggbTimer: 60,
+    isGGBAnswerValid,
+    subject: "Mathématiques",
+    // getHint,
+    getInstruction,
+    // getCorrection,
+    getGGBAnswer,
+    getStudentGGBOptions,
+    answerType: "GGB",
+};

package/lib/exercises/math/geometry/vectors/traceVectorDifference.d.ts

@@ -0,0 +1,11 @@
+import { Exercise } from "../../../../exercises/exercise";
+import { PointIdentifiers } from "../../../../math/geometry/point";
+type Identifiers = {
+    points: PointIdentifiers[];
+    startPointIndex: number;
+    firstVectorPointsIndexes: number[];
+    secondVectorPointsIndexes: number[];
+};
+export declare const traceVectorDifference: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=traceVectorDifference.d.ts.map

package/lib/exercises/math/geometry/vectors/traceVectorDifference.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"traceVectorDifference.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/vectors/traceVectorDifference.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAMlC,OAAO,EAGL,gBAAgB,EACjB,MAAM,2BAA2B,CAAC;AAMnC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,gBAAgB,EAAE,CAAC;IAC3B,eAAe,EAAE,MAAM,CAAC;IACxB,wBAAwB,EAAE,MAAM,EAAE,CAAC;IACnC,yBAAyB,EAAE,MAAM,EAAE,CAAC;CACrC,CAAC;AAgJF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAevD,CAAC"}

package/lib/exercises/math/geometry/vectors/traceVectorDifference.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.traceVectorDifference = void 0;
+const toolBarConstructor_1 = require("../../../../exercises/utils/geogebra/toolBarConstructor");
+const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
+const geogebraConstructor_1 = require("../../../../geogebra/geogebraConstructor");
+const ggbPointToCoords_1 = require("../../../../geogebra/parsers/ggbPointToCoords");
+const parseGGBPoints_1 = require("../../../../geogebra/parsers/parseGGBPoints");
+const point_1 = require("../../../../math/geometry/point");
+const vector_1 = require("../../../../math/geometry/vector");
+const randint_1 = require("../../../../math/utils/random/randint");
+const random_1 = require("../../../../utils/alea/random");
+const doWhile_1 = require("../../../../utils/doWhile");
+const getSolutionPoint = (identifiers) => {
+    const points = identifiers.points.map(point_1.PointConstructor.fromIdentifiers);
+    const origin = points[identifiers.startPointIndex];
+    const vecs = [
+        vector_1.VectorConstructor.fromPoints(points[identifiers.firstVectorPointsIndexes[0]], points[identifiers.firstVectorPointsIndexes[1]]),
+        vector_1.VectorConstructor.fromPoints(points[identifiers.secondVectorPointsIndexes[0]], points[identifiers.secondVectorPointsIndexes[1]]),
+    ];
+    return vecs[0].substract(vecs[1]).getEndPoint(origin, "K");
+};
+const getInstruction = (identifiers) => {
+    const { startPointIndex, firstVectorPointsIndexes, secondVectorPointsIndexes, } = identifiers;
+    const origin = identifiers.points[startPointIndex].name;
+    const firstVec = `${identifiers.points[firstVectorPointsIndexes[0]].name}${identifiers.points[firstVectorPointsIndexes[1]].name}`;
+    const secondVec = `${identifiers.points[secondVectorPointsIndexes[0]].name}${identifiers.points[secondVectorPointsIndexes[1]].name}`;
+    return `Placer le point $K$ tel que : 
+    
+  $$
+  \\overrightarrow{${origin}K} = \\overrightarrow{${firstVec}} - \\overrightarrow{${secondVec}}
+  $$`;
+};
+// const getHint: GetHint<Identifiers> = (identifiers) => {};
+// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {};
+const getGGBAnswer = (identifiers) => {
+    return getSolutionPoint(identifiers).toGGBCommand();
+};
+const getStudentGGBOptions = (identifiers) => {
+    const commands = identifiers.points.flatMap((p) => point_1.PointConstructor.fromIdentifiers(p).toGGBCommand());
+    const ggb = new geogebraConstructor_1.GeogebraConstructor({
+        commands,
+        customToolBar: (0, toolBarConstructor_1.toolBarConstructor)({
+            point: true,
+        }),
+        hideAxes: true,
+    });
+    const points = identifiers.points.map((p) => point_1.PointConstructor.fromIdentifiers(p));
+    const solutionPoint = getSolutionPoint(identifiers);
+    return ggb.getOptions({
+        coords: ggb.getCoordsForPoints([...points, solutionPoint]),
+    });
+};
+const isGGBAnswerValid = (ans, { ggbAnswer, ...identifiers }) => {
+    const studentAns = ans.filter((c) => !["A", "B", "C", "D"].includes(c[0]));
+    if (studentAns.length !== 1)
+        return false;
+    const solutionPoint = getSolutionPoint(identifiers);
+    const pointCoords = (0, parseGGBPoints_1.parseGGBPoints)(studentAns).map((p) => (0, ggbPointToCoords_1.ggbPointToCoords)(p));
+    if (pointCoords.length !== 1)
+        return false;
+    return (new point_1.Point("K", pointCoords[0].x, pointCoords[0].y).distanceTo(solutionPoint) < 1);
+};
+const getTraceVectorDifferenceQuestion = () => {
+    const names = ["A", "B", "C", "D"];
+    let points = [];
+    let startPointIndex;
+    let firstVectorPointsIndexes;
+    let secondVectorPointsIndexes;
+    while (true) {
+        points = [];
+        points.push(...point_1.PointConstructor.randomDifferent(4, {
+            minDistance: 2,
+            names,
+            minDistanceToOrigin: 3,
+        }));
+        startPointIndex = (0, randint_1.randint)(0, names.length);
+        firstVectorPointsIndexes = (0, random_1.randomMany)([0, 1, 2, 3], 2);
+        secondVectorPointsIndexes = (0, doWhile_1.doWhile)(() => (0, random_1.randomMany)([0, 1, 2, 3], 2), (arr) => arr[0] === firstVectorPointsIndexes[0] &&
+            arr[1] === firstVectorPointsIndexes[1]);
+        //AC = AB+BC
+        const firstVec = vector_1.VectorConstructor.fromPoints(points[firstVectorPointsIndexes[0]], points[firstVectorPointsIndexes[1]]);
+        const second = vector_1.VectorConstructor.fromPoints(points[secondVectorPointsIndexes[0]], points[secondVectorPointsIndexes[1]]);
+        const endPoint = firstVec
+            .substract(second)
+            .getEndPoint(points[startPointIndex], "K");
+        if (endPoint.distanceTo(new point_1.Point("O", 0, 0)) > 10 ||
+            points.some((p) => p.equals(endPoint)))
+            continue;
+        break;
+    }
+    const identifiers = {
+        firstVectorPointsIndexes,
+        points: points.map((p) => p.toIdentifiers()),
+        secondVectorPointsIndexes,
+        startPointIndex,
+    };
+    const question = {
+        ggbAnswer: getGGBAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        studentGgbOptions: getStudentGGBOptions(identifiers),
+        identifiers,
+        // hint: getHint(identifiers),
+        // correction: getCorrection(identifiers),
+    };
+    return question;
+};
+exports.traceVectorDifference = {
+    id: "traceVectorDifference",
+    label: "Placer un point défini par une différence de vecteurs",
+    isSingleStep: true,
+    generator: (nb, opts) => (0, getDistinctQuestions_1.getDistinctQuestions)(() => getTraceVectorDifferenceQuestion(opts), nb),
+    ggbTimer: 60,
+    isGGBAnswerValid,
+    subject: "Mathématiques",
+    // getHint,
+    getInstruction,
+    // getCorrection,
+    getGGBAnswer,
+    getStudentGGBOptions,
+    answerType: "GGB",
+};

package/lib/exercises/math/geometry/vectors/traceVectorMultiple.d.ts

@@ -0,0 +1,11 @@
+import { Exercise } from "../../../../exercises/exercise";
+import { PointIdentifiers } from "../../../../math/geometry/point";
+type Identifiers = {
+    points: PointIdentifiers[];
+    startPointIndex: number;
+    vectorPointsIndexes: number[];
+    coeff: number;
+};
+export declare const traceVectorMultiple: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=traceVectorMultiple.d.ts.map

package/lib/exercises/math/geometry/vectors/traceVectorMultiple.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"traceVectorMultiple.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/vectors/traceVectorMultiple.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAMlC,OAAO,EAGL,gBAAgB,EACjB,MAAM,2BAA2B,CAAC;AAOnC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,gBAAgB,EAAE,CAAC;IAC3B,eAAe,EAAE,MAAM,CAAC;IACxB,mBAAmB,EAAE,MAAM,EAAE,CAAC;IAC9B,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AA0HF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAgBrD,CAAC"}

package/lib/exercises/math/geometry/vectors/traceVectorMultiple.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.traceVectorMultiple = void 0;
+const toolBarConstructor_1 = require("../../../../exercises/utils/geogebra/toolBarConstructor");
+const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
+const geogebraConstructor_1 = require("../../../../geogebra/geogebraConstructor");
+const ggbPointToCoords_1 = require("../../../../geogebra/parsers/ggbPointToCoords");
+const parseGGBPoints_1 = require("../../../../geogebra/parsers/parseGGBPoints");
+const point_1 = require("../../../../math/geometry/point");
+const vector_1 = require("../../../../math/geometry/vector");
+const randint_1 = require("../../../../math/utils/random/randint");
+const random_1 = require("../../../../utils/alea/random");
+const getSolutionPoint = (identifiers) => {
+    const points = identifiers.points.map(point_1.PointConstructor.fromIdentifiers);
+    const origin = points[identifiers.startPointIndex];
+    const vec = vector_1.VectorConstructor.fromPoints(points[identifiers.vectorPointsIndexes[0]], points[identifiers.vectorPointsIndexes[1]]);
+    return vec.times(identifiers.coeff.toTree()).getEndPoint(origin, "K");
+};
+const getInstruction = (identifiers) => {
+    const { startPointIndex, vectorPointsIndexes } = identifiers;
+    const origin = identifiers.points[startPointIndex].name;
+    const vec = `${identifiers.points[vectorPointsIndexes[0]].name}${identifiers.points[vectorPointsIndexes[1]].name}`;
+    return `Placer le point $K$ tel que : 
+        
+$$
+\\overrightarrow{${origin}K} = ${identifiers.coeff}\\overrightarrow{${vec}}
+$$`;
+};
+// const getHint: GetHint<Identifiers> = (identifiers) => {};
+// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {};
+const getGGBAnswer = (identifiers) => {
+    return getSolutionPoint(identifiers).toGGBCommand();
+};
+const getStudentGGBOptions = (identifiers) => {
+    const commands = identifiers.points.flatMap((p) => point_1.PointConstructor.fromIdentifiers(p).toGGBCommand());
+    const ggb = new geogebraConstructor_1.GeogebraConstructor({
+        commands,
+        customToolBar: (0, toolBarConstructor_1.toolBarConstructor)({
+            point: true,
+        }),
+        hideAxes: true,
+    });
+    const points = identifiers.points.map((p) => point_1.PointConstructor.fromIdentifiers(p));
+    const solutionPoint = getSolutionPoint(identifiers);
+    return ggb.getOptions({
+        coords: ggb.getCoordsForPoints([...points, solutionPoint]),
+    });
+};
+const isGGBAnswerValid = (ans, { ggbAnswer, ...identifiers }) => {
+    const studentAns = ans.filter((c) => !["A", "B", "C"].includes(c[0]));
+    if (studentAns.length !== 1)
+        return false;
+    const solutionPoint = getSolutionPoint(identifiers);
+    const pointCoords = (0, parseGGBPoints_1.parseGGBPoints)(studentAns).map((p) => (0, ggbPointToCoords_1.ggbPointToCoords)(p));
+    if (pointCoords.length !== 1)
+        return false;
+    return (new point_1.Point("K", pointCoords[0].x, pointCoords[0].y).distanceTo(solutionPoint) < 1);
+};
+const getTraceVectorMultipleQuestion = () => {
+    const names = ["A", "B", "C"];
+    let points = [];
+    let startPointIndex;
+    let vectorPointsIndexes;
+    let coeff = 0;
+    while (true) {
+        points = [];
+        coeff = (0, random_1.random)([-3, -2, 2, 3]);
+        points.push(...point_1.PointConstructor.randomDifferent(3, {
+            minDistance: 2,
+            names,
+            minDistanceToOrigin: 3,
+        }));
+        startPointIndex = (0, randint_1.randint)(0, names.length);
+        vectorPointsIndexes = (0, random_1.randomMany)([0, 1, 2], 2);
+        const vec = vector_1.VectorConstructor.fromPoints(points[vectorPointsIndexes[0]], points[vectorPointsIndexes[1]]);
+        const endPoint = vec
+            .times(coeff.toTree())
+            .getEndPoint(points[startPointIndex], "K");
+        if (endPoint.distanceTo(new point_1.Point("O", 0, 0)) > 10 ||
+            points.some((p) => p.equals(endPoint)))
+            continue;
+        break;
+    }
+    const identifiers = {
+        vectorPointsIndexes,
+        points: points.map((p) => p.toIdentifiers()),
+        startPointIndex,
+        coeff,
+    };
+    const question = {
+        ggbAnswer: getGGBAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        studentGgbOptions: getStudentGGBOptions(identifiers),
+        identifiers,
+        // hint: getHint(identifiers),
+        // correction: getCorrection(identifiers),
+    };
+    return question;
+};
+exports.traceVectorMultiple = {
+    id: "traceVectorMultiple",
+    label: "Placer un point $M$ tel que $\\overrightarrow{AM} = k\\overrightarrow{BC}$",
+    isSingleStep: true,
+    generator: (nb, opts) => (0, getDistinctQuestions_1.getDistinctQuestions)(() => getTraceVectorMultipleQuestion(opts), nb),
+    ggbTimer: 60,
+    isGGBAnswerValid,
+    subject: "Mathématiques",
+    // getHint,
+    getInstruction,
+    // getCorrection,
+    getGGBAnswer,
+    getStudentGGBOptions,
+    answerType: "GGB",
+};

package/lib/exercises/math/geometry/vectors/traceVectorSum.d.ts

@@ -0,0 +1,11 @@
+import { Exercise } from "../../../../exercises/exercise";
+import { PointIdentifiers } from "../../../../math/geometry/point";
+type Identifiers = {
+    points: PointIdentifiers[];
+    startPointIndex: number;
+    firstVectorPointsIndexes: number[];
+    secondVectorPointsIndexes: number[];
+};
+export declare const traceVectorSum: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=traceVectorSum.d.ts.map

package/lib/exercises/math/geometry/vectors/traceVectorSum.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"traceVectorSum.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/vectors/traceVectorSum.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAMlC,OAAO,EAGL,gBAAgB,EACjB,MAAM,2BAA2B,CAAC;AAMnC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,gBAAgB,EAAE,CAAC;IAC3B,eAAe,EAAE,MAAM,CAAC;IACxB,wBAAwB,EAAE,MAAM,EAAE,CAAC;IACnC,yBAAyB,EAAE,MAAM,EAAE,CAAC;CACrC,CAAC;AAgJF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAehD,CAAC"}

package/lib/exercises/math/geometry/vectors/traceVectorSum.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.traceVectorSum = void 0;
+const toolBarConstructor_1 = require("../../../../exercises/utils/geogebra/toolBarConstructor");
+const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
+const geogebraConstructor_1 = require("../../../../geogebra/geogebraConstructor");
+const ggbPointToCoords_1 = require("../../../../geogebra/parsers/ggbPointToCoords");
+const parseGGBPoints_1 = require("../../../../geogebra/parsers/parseGGBPoints");
+const point_1 = require("../../../../math/geometry/point");
+const vector_1 = require("../../../../math/geometry/vector");
+const randint_1 = require("../../../../math/utils/random/randint");
+const random_1 = require("../../../../utils/alea/random");
+const doWhile_1 = require("../../../../utils/doWhile");
+const getSolutionPoint = (identifiers) => {
+    const points = identifiers.points.map(point_1.PointConstructor.fromIdentifiers);
+    const origin = points[identifiers.startPointIndex];
+    const vecs = [
+        vector_1.VectorConstructor.fromPoints(points[identifiers.firstVectorPointsIndexes[0]], points[identifiers.firstVectorPointsIndexes[1]]),
+        vector_1.VectorConstructor.fromPoints(points[identifiers.secondVectorPointsIndexes[0]], points[identifiers.secondVectorPointsIndexes[1]]),
+    ];
+    return vecs[0].add(vecs[1]).getEndPoint(origin, "K");
+};
+const getInstruction = (identifiers) => {
+    const { startPointIndex, firstVectorPointsIndexes, secondVectorPointsIndexes, } = identifiers;
+    const origin = identifiers.points[startPointIndex].name;
+    const firstVec = `${identifiers.points[firstVectorPointsIndexes[0]].name}${identifiers.points[firstVectorPointsIndexes[1]].name}`;
+    const secondVec = `${identifiers.points[secondVectorPointsIndexes[0]].name}${identifiers.points[secondVectorPointsIndexes[1]].name}`;
+    return `Placer le point $K$ tel que : 
+  
+$$
+\\overrightarrow{${origin}K} = \\overrightarrow{${firstVec}} + \\overrightarrow{${secondVec}}
+$$`;
+};
+// const getHint: GetHint<Identifiers> = (identifiers) => {};
+// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {};
+const getGGBAnswer = (identifiers) => {
+    return getSolutionPoint(identifiers).toGGBCommand();
+};
+const getStudentGGBOptions = (identifiers) => {
+    const commands = identifiers.points.flatMap((p) => point_1.PointConstructor.fromIdentifiers(p).toGGBCommand());
+    const ggb = new geogebraConstructor_1.GeogebraConstructor({
+        commands,
+        customToolBar: (0, toolBarConstructor_1.toolBarConstructor)({
+            point: true,
+        }),
+        hideAxes: true,
+    });
+    const points = identifiers.points.map((p) => point_1.PointConstructor.fromIdentifiers(p));
+    const solutionPoint = getSolutionPoint(identifiers);
+    return ggb.getOptions({
+        coords: ggb.getCoordsForPoints([...points, solutionPoint]),
+    });
+};
+const isGGBAnswerValid = (ans, { ggbAnswer, ...identifiers }) => {
+    const studentAns = ans.filter((c) => !["A", "B", "C", "D"].includes(c[0]));
+    if (studentAns.length !== 1)
+        return false;
+    const solutionPoint = getSolutionPoint(identifiers);
+    const pointCoords = (0, parseGGBPoints_1.parseGGBPoints)(studentAns).map((p) => (0, ggbPointToCoords_1.ggbPointToCoords)(p));
+    if (pointCoords.length !== 1)
+        return false;
+    return (new point_1.Point("K", pointCoords[0].x, pointCoords[0].y).distanceTo(solutionPoint) < 1);
+};
+const getTraceVectorSumQuestion = () => {
+    const names = ["A", "B", "C", "D"];
+    let points = [];
+    let startPointIndex;
+    let firstVectorPointsIndexes;
+    let secondVectorPointsIndexes;
+    while (true) {
+        points = [];
+        points.push(...point_1.PointConstructor.randomDifferent(4, {
+            minDistance: 2,
+            names,
+            minDistanceToOrigin: 3,
+        }));
+        startPointIndex = (0, randint_1.randint)(0, names.length);
+        firstVectorPointsIndexes = (0, random_1.randomMany)([0, 1, 2, 3], 2);
+        secondVectorPointsIndexes = (0, doWhile_1.doWhile)(() => (0, random_1.randomMany)([0, 1, 2, 3], 2), (arr) => arr[0] === firstVectorPointsIndexes[0] &&
+            arr[1] === firstVectorPointsIndexes[1]);
+        //AC = AB+BC
+        const firstVec = vector_1.VectorConstructor.fromPoints(points[firstVectorPointsIndexes[0]], points[firstVectorPointsIndexes[1]]);
+        const second = vector_1.VectorConstructor.fromPoints(points[secondVectorPointsIndexes[0]], points[secondVectorPointsIndexes[1]]);
+        const endPoint = firstVec
+            .add(second)
+            .getEndPoint(points[startPointIndex], "K");
+        if (endPoint.distanceTo(new point_1.Point("O", 0, 0)) > 10 ||
+            points.some((p) => p.equals(endPoint)))
+            continue;
+        break;
+    }
+    const identifiers = {
+        firstVectorPointsIndexes,
+        points: points.map((p) => p.toIdentifiers()),
+        secondVectorPointsIndexes,
+        startPointIndex,
+    };
+    const question = {
+        ggbAnswer: getGGBAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        studentGgbOptions: getStudentGGBOptions(identifiers),
+        identifiers,
+        // hint: getHint(identifiers),
+        // correction: getCorrection(identifiers),
+    };
+    return question;
+};
+exports.traceVectorSum = {
+    id: "traceVectorSum",
+    label: "Placer un point défini par une somme de vecteurs",
+    isSingleStep: true,
+    generator: (nb, opts) => (0, getDistinctQuestions_1.getDistinctQuestions)(() => getTraceVectorSumQuestion(opts), nb),
+    ggbTimer: 60,
+    isGGBAnswerValid,
+    subject: "Mathématiques",
+    // getHint,
+    getInstruction,
+    // getCorrection,
+    getGGBAnswer,
+    getStudentGGBOptions,
+    answerType: "GGB",
+};

package/lib/index.d.ts

@@ -1117,6 +1117,25 @@ declare const mathExercises: (Exercise<{
     AB: number;
     AC: number;
     trigoPoint: string;
+}, {}> | Exercise<{
+    points: import("./math/geometry/point").PointIdentifiers[];
+    startPointIndex: number;
+    firstVectorPointsIndexes: number[];
+    secondVectorPointsIndexes: number[];
+}, {}> | Exercise<{
+    points: import("./math/geometry/point").PointIdentifiers[];
+    startPointIndex: number;
+    firstVectorPointsIndexes: number[];
+    secondVectorPointsIndexes: number[];
+}, {}> | Exercise<{
+    points: import("./math/geometry/point").PointIdentifiers[];
+    startPointIndex: number;
+    vectorPointsIndexes: number[];
+}, {}> | Exercise<{
+    points: import("./math/geometry/point").PointIdentifiers[];
+    startPointIndex: number;
+    vectorPointsIndexes: number[];
+    coeff: number;
 }, {}> | Exercise<{
     trinom: number[];
 }, {}> | Exercise<{

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/math/geometry/CloudPoints.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CloudPoints.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/CloudPoints.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAoB,gBAAgB,EAAE,MAAM,SAAS,CAAC;AACpE,OAAO,EAAE,SAAS,EAAE,MAAM,sCAAsC,CAAC;AAGjE,OAAO,EAAE,UAAU,EAAgB,MAAM,qCAAqC,CAAC;AAM/E,MAAM,MAAM,sBAAsB,GAAG;IACnC,iBAAiB,EAAE,gBAAgB,EAAE,CAAC;CACvC,CAAC;AACF,8BAAsB,sBAAsB;IAC1C,MAAM,CAAC,MAAM,CAAC,QAAQ,EAAE,MAAM;IAQ9B,MAAM,CAAC,YAAY,CAAC,QAAQ,EAAE,MAAM;CAyBrC;AAED,qBAAa,WAAW;IACtB,MAAM,EAAE,KAAK,EAAE,CAAC;gBAEJ,MAAM,EAAE,KAAK,EAAE;IAI3B,aAAa,IAAI,sBAAsB;IAMvC,kBAAkB,IAAI,SAAS;IA8C/B,mBAAmB;CAsBpB"}
+{"version":3,"file":"CloudPoints.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/CloudPoints.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAoB,gBAAgB,EAAE,MAAM,SAAS,CAAC;AACpE,OAAO,EAAE,SAAS,EAAE,MAAM,sCAAsC,CAAC;AAGjE,OAAO,EAAE,UAAU,EAAgB,MAAM,qCAAqC,CAAC;AAM/E,MAAM,MAAM,sBAAsB,GAAG;IACnC,iBAAiB,EAAE,gBAAgB,EAAE,CAAC;CACvC,CAAC;AACF,8BAAsB,sBAAsB;IAC1C,MAAM,CAAC,MAAM,CAAC,QAAQ,EAAE,MAAM;IAU9B,MAAM,CAAC,YAAY,CAAC,QAAQ,EAAE,MAAM;CAyBrC;AAED,qBAAa,WAAW;IACtB,MAAM,EAAE,KAAK,EAAE,CAAC;gBAEJ,MAAM,EAAE,KAAK,EAAE;IAI3B,aAAa,IAAI,sBAAsB;IAMvC,kBAAkB,IAAI,SAAS;IA8C/B,mBAAmB;CAsBpB"}

package/lib/math/geometry/CloudPoints.js

@@ -16,7 +16,7 @@ class CloudPointsConstructor {
         for (let i = 0; i < nbPoints; i++) {
             names.push(`a${i}`);
         }
-        return new CloudPoints(point_1.PointConstructor.randomDifferent(names));
+        return new CloudPoints(point_1.PointConstructor.randomDifferent(nbPoints, { names }));
     }
     static randomLinear(nbPoints) {
         const points = [];

package/lib/math/geometry/line.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"line.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/line.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,mDAAmD,CAAC;AAEvF,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAC/D,OAAO,EAAE,SAAS,EAAE,MAAM,sCAAsC,CAAC;AAGjE,OAAO,EAAE,OAAO,EAAO,MAAM,oCAAoC,CAAC;AAMlE,OAAO,EACL,aAAa,EAEd,MAAM,0CAA0C,CAAC;AAKlD,OAAO,EAAE,KAAK,EAAoB,gBAAgB,EAAE,MAAM,SAAS,CAAC;AACpE,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,MAAM,EAAqB,MAAM,UAAU,CAAC;AAErD,MAAM,MAAM,eAAe,GAAG;IAC5B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,gBAAgB,CAAC;IACzB,MAAM,EAAE,gBAAgB,CAAC;CAC1B,CAAC;AACF,8BAAsB,eAAe;IACnC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,MAAM;IAK3B,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,eAAe;IAOnD,MAAM,CAAC,WAAW,CAAC,OAAO,EAAE,OAAO;CAGpC;AACD,qBAAa,IAAI;IACf,MAAM,EAAE,KAAK,CAAC;IACd,MAAM,EAAE,KAAK,CAAC;IACd,UAAU,EAAE,OAAO,CAAC;IACpB,CAAC,EAAE,aAAa,GAAG,SAAS,CAAC;IAC7B,CAAC,EAAE,aAAa,GAAG,SAAS,CAAC;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;gBACJ,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,CAAC,EAAE,MAAM;IAsBvD,aAAa;;;;;IAOb,WAAW,CAAC,IAAI,EAAE,IAAI;IAYtB,iBAAiB;IAIjB,YAAY,CAAC,KAAK,EAAE,KAAK;IAYzB,gBAAgB,CAAC,KAAK,EAAE,KAAK;IAW7B,QAAQ,CAAC,KAAK,EAAE,KAAK,EAAE,WAAW,GAAE,OAAe;IAgBnD,aAAa,CAAC,CAAC,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,MAAM;IAK7C,aAAa,CAAC,CAAC,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,MAAM;IAW7C,cAAc,CAAC,IAAI,CAAC,EAAE,MAAM;IAa5B,WAAW,MAAO,MAAM,KAAK,KAAK,KAAG,SAAS,CAmB5C;IAEF,oBAAoB,IAAI,SAAS;IAuBjC,WAAW;IAMX,iBAAiB;;;;;IAcjB,KAAK;IAGL,gBAAgB;IAIhB,aAAa,CACX,iBAAiB,EAAE,OAAO,EAC1B,EACE,OAAc,EACd,SAAiB,EACjB,yBAAgC,GACjC,GAAE,kBAAuB;IAqB5B,SAAS,CAAC,IAAI,EAAE,IAAI,EAAE,aAAa,CAAC,EAAE,MAAM;CAW7C"}
+{"version":3,"file":"line.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/line.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,mDAAmD,CAAC;AAEvF,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAC/D,OAAO,EAAE,SAAS,EAAE,MAAM,sCAAsC,CAAC;AAGjE,OAAO,EAAE,OAAO,EAAO,MAAM,oCAAoC,CAAC;AAMlE,OAAO,EACL,aAAa,EAEd,MAAM,0CAA0C,CAAC;AAKlD,OAAO,EAAE,KAAK,EAAoB,gBAAgB,EAAE,MAAM,SAAS,CAAC;AACpE,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,MAAM,EAAqB,MAAM,UAAU,CAAC;AAErD,MAAM,MAAM,eAAe,GAAG;IAC5B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,gBAAgB,CAAC;IACzB,MAAM,EAAE,gBAAgB,CAAC;CAC1B,CAAC;AACF,8BAAsB,eAAe;IACnC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,MAAM;IAO3B,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,eAAe;IAOnD,MAAM,CAAC,WAAW,CAAC,OAAO,EAAE,OAAO;CAGpC;AACD,qBAAa,IAAI;IACf,MAAM,EAAE,KAAK,CAAC;IACd,MAAM,EAAE,KAAK,CAAC;IACd,UAAU,EAAE,OAAO,CAAC;IACpB,CAAC,EAAE,aAAa,GAAG,SAAS,CAAC;IAC7B,CAAC,EAAE,aAAa,GAAG,SAAS,CAAC;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;gBACJ,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,CAAC,EAAE,MAAM;IAsBvD,aAAa;;;;;IAOb,WAAW,CAAC,IAAI,EAAE,IAAI;IAYtB,iBAAiB;IAIjB,YAAY,CAAC,KAAK,EAAE,KAAK;IAYzB,gBAAgB,CAAC,KAAK,EAAE,KAAK;IAW7B,QAAQ,CAAC,KAAK,EAAE,KAAK,EAAE,WAAW,GAAE,OAAe;IAgBnD,aAAa,CAAC,CAAC,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,MAAM;IAK7C,aAAa,CAAC,CAAC,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,MAAM;IAW7C,cAAc,CAAC,IAAI,CAAC,EAAE,MAAM;IAa5B,WAAW,MAAO,MAAM,KAAK,KAAK,KAAG,SAAS,CAmB5C;IAEF,oBAAoB,IAAI,SAAS;IAuBjC,WAAW;IAMX,iBAAiB;;;;;IAcjB,KAAK;IAGL,gBAAgB;IAIhB,aAAa,CACX,iBAAiB,EAAE,OAAO,EAC1B,EACE,OAAc,EACd,SAAiB,EACjB,yBAAgC,GACjC,GAAE,kBAAuB;IAqB5B,SAAS,CAAC,IAAI,EAAE,IAAI,EAAE,aAAa,CAAC,EAAE,MAAM;CAW7C"}

package/lib/math/geometry/line.js

@@ -17,7 +17,9 @@ const vector_1 = require("./vector");
 class LineConstructor {
     static random(name) {
         const names = (0, randomSegmentName_1.randomSegmentName)();
-        const points = point_1.PointConstructor.randomDifferent(names.split(""));
+        const points = point_1.PointConstructor.randomDifferent(2, {
+            names: names.split(""),
+        });
         return new Line(points[0], points[1], name);
     }
     static fromIdentifiers(identifiers) {

package/lib/math/geometry/point.d.ts

@@ -8,6 +8,8 @@ export type PointIdentifiers = {
     y: NodeIdentifiers;
 };
 export declare abstract class PointConstructor {
+    static randomName(excludes?: string[]): string;
+    static randomNames(count: number): string[];
     static origin(name?: string): Point;
     static random(name: string, min?: number, max?: number): Point;
     static fromIdentifiers(identifiers: PointIdentifiers): Point;
@@ -15,14 +17,18 @@ export declare abstract class PointConstructor {
         spacing?: number;
         coefficient?: number;
     }): Point;
-    static randomDifferent(names: string[]): Point[];
+    static randomDifferent(count: number, { names, minDistance, minDistanceToOrigin, }: {
+        names?: string[];
+        minDistance?: number;
+        minDistanceToOrigin?: number;
+    }): Point[];
     static fromGGBCommand(str: string): Point;
 }
 export declare class Point {
     name: string;
     x: AlgebraicNode;
     y: AlgebraicNode;
-    constructor(name: string, x: AlgebraicNode, y: AlgebraicNode);
+    constructor(name: string, x: AlgebraicNode | number, y: AlgebraicNode | number);
     toTex(): string;
     toIdentifiers(): PointIdentifiers;
     toTexWithCoords(): string;

package/lib/math/geometry/point.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"point.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/point.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAG/D,OAAO,EAAE,kBAAkB,EAAE,MAAM,mDAAmD,CAAC;AACvF,OAAO,EAEL,eAAe,EAChB,MAAM,kCAAkC,CAAC;AAM1C,MAAM,MAAM,gBAAgB,GAAG;IAC7B,EAAE,EAAE,OAAO,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,eAAe,CAAC;IACnB,CAAC,EAAE,eAAe,CAAC;CACpB,CAAC;AACF,8BAAsB,gBAAgB;IACpC,MAAM,CAAC,MAAM,CAAC,IAAI,SAAM;IAGxB,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,SAAM,EAAE,GAAG,SAAK,GAAG,KAAK;IAMvD,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,gBAAgB;IAQpD,MAAM,CAAC,SAAS,CACd,CAAC,EAAE,KAAK,EACR,CAAC,EAAE,KAAK,EACR,IAAI,EAAE,MAAM,EACZ,EACE,OAAa,EACb,WAAW,GACZ,GAAE;QAAE,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,WAAW,CAAC,EAAE,MAAM,CAAA;KAAO;IAQpD,MAAM,CAAC,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE;IAetC,MAAM,CAAC,cAAc,CAAC,GAAG,EAAE,MAAM;CAclC;AAED,qBAAa,KAAK;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;gBACL,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,aAAa,EAAE,CAAC,EAAE,aAAa;IAM5D,KAAK,IAAI,MAAM;IAGf,aAAa,IAAI,gBAAgB;IAQjC,eAAe,IAAI,MAAM;IAGzB,QAAQ,IAAI,MAAM;IAIlB,UAAU,IAAI,MAAM;IAIpB,UAAU,IAAI,MAAM;IAIpB,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,IAAI,SAAM,GAAG,KAAK;IAiBrC,UAAU,CAAC,CAAC,EAAE,KAAK,GAAG,MAAM;IAM5B,MAAM,CAAC,CAAC,EAAE,KAAK,GAAG,OAAO;IAGzB,SAAS,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK;IAK5B,YAAY;IAGZ,YAAY,CAAC,EACX,OAAc,EACd,SAAgB,EAChB,KAAK,EACL,IAAI,EACJ,KAAK,GACN,GAAE,kBAAuB;IAiB1B,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK;IAiBnC,eAAe,CAAC,MAAM,EAAE,KAAK,EAAE,IAAI,SAAkB;CAItD"}
+{"version":3,"file":"point.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/point.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAG/D,OAAO,EAAE,kBAAkB,EAAE,MAAM,mDAAmD,CAAC;AACvF,OAAO,EAEL,eAAe,EAChB,MAAM,kCAAkC,CAAC;AAQ1C,MAAM,MAAM,gBAAgB,GAAG;IAC7B,EAAE,EAAE,OAAO,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,eAAe,CAAC;IACnB,CAAC,EAAE,eAAe,CAAC;CACpB,CAAC;AACF,8BAAsB,gBAAgB;IACpC,MAAM,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE,MAAM,EAAE;IAGrC,MAAM,CAAC,WAAW,CAAC,KAAK,EAAE,MAAM;IAKhC,MAAM,CAAC,MAAM,CAAC,IAAI,SAAM;IAGxB,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,SAAM,EAAE,GAAG,SAAK,GAAG,KAAK;IAMvD,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,gBAAgB;IAQpD,MAAM,CAAC,SAAS,CACd,CAAC,EAAE,KAAK,EACR,CAAC,EAAE,KAAK,EACR,IAAI,EAAE,MAAM,EACZ,EACE,OAAa,EACb,WAAW,GACZ,GAAE;QAAE,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,WAAW,CAAC,EAAE,MAAM,CAAA;KAAO;IAQpD,MAAM,CAAC,eAAe,CACpB,KAAK,EAAE,MAAM,EACb,EACE,KAAK,EACL,WAAW,EACX,mBAAmB,GACpB,EAAE;QACD,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;QACjB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,mBAAmB,CAAC,EAAE,MAAM,CAAC;KAC9B;IA4BH,MAAM,CAAC,cAAc,CAAC,GAAG,EAAE,MAAM;CAclC;AAED,qBAAa,KAAK;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;gBAEf,IAAI,EAAE,MAAM,EACZ,CAAC,EAAE,aAAa,GAAG,MAAM,EACzB,CAAC,EAAE,aAAa,GAAG,MAAM;IAO3B,KAAK,IAAI,MAAM;IAGf,aAAa,IAAI,gBAAgB;IAQjC,eAAe,IAAI,MAAM;IAGzB,QAAQ,IAAI,MAAM;IAIlB,UAAU,IAAI,MAAM;IAIpB,UAAU,IAAI,MAAM;IAIpB,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,IAAI,SAAM,GAAG,KAAK;IAiBrC,UAAU,CAAC,CAAC,EAAE,KAAK,GAAG,MAAM;IAM5B,MAAM,CAAC,CAAC,EAAE,KAAK,GAAG,OAAO;IAGzB,SAAS,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK;IAK5B,YAAY;IAGZ,YAAY,CAAC,EACX,OAAc,EACd,SAAgB,EAChB,KAAK,EACL,IAAI,EACJ,KAAK,GACN,GAAE,kBAAuB;IAiB1B,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK;IAiBnC,eAAe,CAAC,MAAM,EAAE,KAAK,EAAE,IAAI,SAAkB;CAItD"}

package/lib/math/geometry/point.js

@@ -11,7 +11,17 @@ const randfloat_1 = require("../utils/random/randfloat");
 const substractNode_1 = require("../../tree/nodes/operators/substractNode");
 const multiplyNode_1 = require("../../tree/nodes/operators/multiplyNode");
 const addNode_1 = require("../../tree/nodes/operators/addNode");
+const randomLetter_1 = require("../../utils/strings/randomLetter");
 class PointConstructor {
+    static randomName(excludes) {
+        return (0, randomLetter_1.randomLetter)(true, ["O", ...(excludes ?? [])]);
+    }
+    static randomNames(count) {
+        const res = [];
+        for (let i = 0; i < count; i++)
+            res.push(PointConstructor.randomName(res));
+        return res;
+    }
     static origin(name = "O") {
         return new Point(name, new numberNode_1.NumberNode(0), new numberNode_1.NumberNode(0));
     }
@@ -29,18 +39,19 @@ class PointConstructor {
         const point = vector.getEndPoint(A, name);
         return point;
     }
-    static randomDifferent(names) {
+    static randomDifferent(count, { names, minDistance, minDistanceToOrigin, }) {
         const res = [];
         const points = [];
-        for (let i = 0; i < names.length; i++) {
+        const pointNames = names ?? PointConstructor.randomNames(count);
+        for (let i = 0; i < count; i++) {
             let x;
             let y;
             do {
-                x = (0, randint_1.randint)(-10, 11);
-                y = (0, randint_1.randint)(-10, 11);
-            } while (points.some((point) => point[0] === x && point[1] === y));
+                x = (0, randint_1.randint)(-(minDistanceToOrigin ?? 10), (minDistanceToOrigin ?? 10) + 1);
+                y = (0, randint_1.randint)(-(minDistanceToOrigin ?? 10), (minDistanceToOrigin ?? 10) + 1);
+            } while (points.some((point) => Math.hypot(point[0] - x, point[1] - y) < (minDistance ?? 1)));
             points.push([x, y]);
-            res.push(new Point(names[i], new numberNode_1.NumberNode(x), new numberNode_1.NumberNode(y)));
+            res.push(new Point(pointNames[i], new numberNode_1.NumberNode(x), new numberNode_1.NumberNode(y)));
         }
         return res;
     }
@@ -59,8 +70,8 @@ exports.PointConstructor = PointConstructor;
 class Point {
     constructor(name, x, y) {
         this.name = name;
-        this.x = x;
-        this.y = y;
+        this.x = typeof x === "number" ? x.toTree() : x;
+        this.y = typeof y === "number" ? y.toTree() : y;
     }
     toTex() {
         return `${this.name}`;

package/lib/math/geometry/ray.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ray.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/ray.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,mDAAmD,CAAC;AAEvF,OAAO,EAAE,KAAK,EAAoB,MAAM,SAAS,CAAC;AAElD,8BAAsB,cAAc;IAClC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,MAAM;CAK5B;AAED,qBAAa,GAAG;IACd,UAAU,EAAE,KAAK,CAAC;IAClB,WAAW,EAAE,KAAK,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;gBACJ,UAAU,EAAE,KAAK,EAAE,WAAW,EAAE,KAAK,EAAE,IAAI,CAAC,EAAE,MAAM;IAOhE,KAAK;IAGL,aAAa,CACX,iBAAiB,EAAE,OAAO,EAC1B,EACE,OAAc,EACd,SAAiB,EACjB,yBAAgC,GACjC,GAAE,kBAAuB;CAoB7B"}
+{"version":3,"file":"ray.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/ray.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,mDAAmD,CAAC;AAEvF,OAAO,EAAE,KAAK,EAAoB,MAAM,SAAS,CAAC;AAElD,8BAAsB,cAAc;IAClC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,MAAM;CAO5B;AAED,qBAAa,GAAG;IACd,UAAU,EAAE,KAAK,CAAC;IAClB,WAAW,EAAE,KAAK,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;gBACJ,UAAU,EAAE,KAAK,EAAE,WAAW,EAAE,KAAK,EAAE,IAAI,CAAC,EAAE,MAAM;IAOhE,KAAK;IAGL,aAAa,CACX,iBAAiB,EAAE,OAAO,EAC1B,EACE,OAAc,EACd,SAAiB,EACjB,yBAAgC,GACjC,GAAE,kBAAuB;CAoB7B"}

package/lib/math/geometry/ray.js

@@ -6,7 +6,9 @@ const point_1 = require("./point");
 class RayConstructor {
     static random(name) {
         const names = (0, randomSegmentName_1.randomSegmentName)();
-        const points = point_1.PointConstructor.randomDifferent(names.split(""));
+        const points = point_1.PointConstructor.randomDifferent(2, {
+            names: names.split(""),
+        });
         return new Ray(points[0], points[1], name);
     }
 }

package/lib/math/geometry/segment.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"segment.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/segment.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,mDAAmD,CAAC;AAEvF,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAE/D,OAAO,EAEL,eAAe,EAEhB,MAAM,kCAAkC,CAAC;AAK1C,OAAO,EAAE,KAAK,EAAoB,gBAAgB,EAAE,MAAM,SAAS,CAAC;AACpE,OAAO,EAAE,MAAM,EAAqB,MAAM,UAAU,CAAC;AAErD,MAAM,MAAM,kBAAkB,GAAG;IAC/B,MAAM,EAAE,gBAAgB,CAAC;IACzB,MAAM,EAAE,gBAAgB,CAAC;IACzB,KAAK,CAAC,EAAE,uBAAuB,CAAC;CACjC,CAAC;AACF,8BAAsB,kBAAkB;IACtC,MAAM,CAAC,MAAM;IAKb,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,kBAAkB;CAYvD;AAED,KAAK,uBAAuB,GAAG;IAC7B,UAAU,CAAC,EAAE,eAAe,CAAC;IAC7B,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB,CAAC;AACF,KAAK,YAAY,GAAG;IAAE,UAAU,CAAC,EAAE,aAAa,CAAC;IAAC,aAAa,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAC3E,qBAAa,OAAO;IAClB,MAAM,EAAE,KAAK,CAAC;IACd,MAAM,EAAE,KAAK,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,aAAa,CAAC;IAC3B,KAAK,CAAC,EAAE,YAAY,CAAC;gBACT,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,CAAC,EAAE,YAAY;IAS9D,aAAa,IAAI,kBAAkB;IAUnC,WAAW;IAGX,SAAS;IAST,aAAa;IAYb,KAAK;IAGL,YAAY;IAGZ,WAAW;IAGX,qBAAqB,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM;IAanD,aAAa,CACX,iBAAiB,EAAE,OAAO,EAC1B,EACE,OAAc,EACd,SAAiB,EACjB,yBAAgC,EAChC,UAAkB,EAClB,KAAK,GACN,GAAE,kBAAuB;IA8B5B,QAAQ,CAAC,KAAK,EAAE,KAAK;IAOrB,QAAQ;CAGT"}
+{"version":3,"file":"segment.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/segment.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,mDAAmD,CAAC;AAEvF,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAE/D,OAAO,EAEL,eAAe,EAEhB,MAAM,kCAAkC,CAAC;AAK1C,OAAO,EAAE,KAAK,EAAoB,gBAAgB,EAAE,MAAM,SAAS,CAAC;AACpE,OAAO,EAAE,MAAM,EAAqB,MAAM,UAAU,CAAC;AAErD,MAAM,MAAM,kBAAkB,GAAG;IAC/B,MAAM,EAAE,gBAAgB,CAAC;IACzB,MAAM,EAAE,gBAAgB,CAAC;IACzB,KAAK,CAAC,EAAE,uBAAuB,CAAC;CACjC,CAAC;AACF,8BAAsB,kBAAkB;IACtC,MAAM,CAAC,MAAM;IAOb,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,kBAAkB;CAYvD;AAED,KAAK,uBAAuB,GAAG;IAC7B,UAAU,CAAC,EAAE,eAAe,CAAC;IAC7B,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB,CAAC;AACF,KAAK,YAAY,GAAG;IAAE,UAAU,CAAC,EAAE,aAAa,CAAC;IAAC,aAAa,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAC3E,qBAAa,OAAO;IAClB,MAAM,EAAE,KAAK,CAAC;IACd,MAAM,EAAE,KAAK,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,aAAa,CAAC;IAC3B,KAAK,CAAC,EAAE,YAAY,CAAC;gBACT,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,CAAC,EAAE,YAAY;IAS9D,aAAa,IAAI,kBAAkB;IAUnC,WAAW;IAGX,SAAS;IAST,aAAa;IAYb,KAAK;IAGL,YAAY;IAGZ,WAAW;IAGX,qBAAqB,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM;IAanD,aAAa,CACX,iBAAiB,EAAE,OAAO,EAC1B,EACE,OAAc,EACd,SAAiB,EACjB,yBAAgC,EAChC,UAAkB,EAClB,KAAK,GACN,GAAE,kBAAuB;IA8B5B,QAAQ,CAAC,KAAK,EAAE,KAAK;IAOrB,QAAQ;CAGT"}

package/lib/math/geometry/segment.js

@@ -13,7 +13,9 @@ const vector_1 = require("./vector");
 class SegmentConstructor {
     static random() {
         const name = (0, randomSegmentName_1.randomSegmentName)();
-        const points = point_1.PointConstructor.randomDifferent(name.split(""));
+        const points = point_1.PointConstructor.randomDifferent(2, {
+            names: name.split(""),
+        });
         return new Segment(points[0], points[1]);
     }
     static fromIdentifiers(identifiers) {

package/lib/math/geometry/vector.d.ts

@@ -21,6 +21,7 @@ export declare class Vector {
     opposite(): Vector;
     scalarProduct(v: Vector): AlgebraicNode;
     add(v: Vector): Vector;
+    substract(v: Vector): Vector;
     getNorm(): AlgebraicNode;
     getEndPoint(startPoint: Point, name?: string): Point;
     equals(v: Vector): boolean;

package/lib/math/geometry/vector.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vector.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/vector.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAgB/D,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAEhC,8BAAsB,iBAAiB;IACrC,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,GAAG,MAAM;IAOpD,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,UAAO,GAAG,MAAM;CAOtD;AAED,qBAAa,MAAM;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;gBACL,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,aAAa,EAAE,CAAC,EAAE,aAAa;IAO5D,KAAK,IAAI,MAAM;IAIf,eAAe,IAAI,MAAM;IAMzB,iBAAiB,IAAI,MAAM;IAM3B,UAAU,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO;IAK9B,sBAAsB,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO;IAI1C,kBAAkB,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO;IAItC,WAAW,CAAC,CAAC,EAAE,MAAM,GAAG,aAAa;IAIrC,KAAK,CAAC,CAAC,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,MAAM;IAOrC,QAAQ;IAGR,aAAa,CAAC,CAAC,EAAE,MAAM;IAgBvB,GAAG,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM;IAYtB,OAAO,IAAI,aAAa;IAUxB,WAAW,CAAC,UAAU,EAAE,KAAK,EAAE,IAAI,CAAC,EAAE,MAAM;IAO5C,MAAM,CAAC,CAAC,EAAE,MAAM;IAIhB,YAAY;IAMZ,YAAY;IAOZ,aAAa;CAGd"}
+{"version":3,"file":"vector.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/vector.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAgB/D,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAEhC,8BAAsB,iBAAiB;IACrC,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,GAAG,MAAM;IAOpD,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,UAAO,GAAG,MAAM;CAOtD;AAED,qBAAa,MAAM;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;gBACL,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,aAAa,EAAE,CAAC,EAAE,aAAa;IAO5D,KAAK,IAAI,MAAM;IAIf,eAAe,IAAI,MAAM;IAMzB,iBAAiB,IAAI,MAAM;IAM3B,UAAU,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO;IAK9B,sBAAsB,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO;IAI1C,kBAAkB,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO;IAItC,WAAW,CAAC,CAAC,EAAE,MAAM,GAAG,aAAa;IAIrC,KAAK,CAAC,CAAC,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,MAAM;IAOrC,QAAQ;IAGR,aAAa,CAAC,CAAC,EAAE,MAAM;IAgBvB,GAAG,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM;IAWtB,SAAS,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM;IAG5B,OAAO,IAAI,aAAa;IAUxB,WAAW,CAAC,UAAU,EAAE,KAAK,EAAE,IAAI,CAAC,EAAE,MAAM;IAO5C,MAAM,CAAC,CAAC,EAAE,MAAM;IAIhB,YAAY;IAMZ,YAAY;IAOZ,aAAa;CAGd"}

package/lib/math/geometry/vector.js

@@ -80,6 +80,9 @@ class Vector {
         const resultY = new addNode_1.AddNode(this.y, y);
         return new Vector(`${this.name}+${v.name}`, resultX.simplify(), resultY.simplify());
     }
+    substract(v) {
+        return this.add(v.opposite());
+    }
     getNorm() {
         const xValue = this.x.simplify().value;
         const yValue = this.y.simplify().value;

package/lib/tree/nodes/inequations/inequationSolutionNode.js

@@ -55,7 +55,7 @@ class InequationSolutionNode {
         return `S={${this.intervalSolution.toMathjs()}}`;
     }
     toTex() {
-        return `S=${this.intervalSolution.toTex()}`;
+        return `S=\\ ${this.intervalSolution.toTex()}`;
     }
     simplify() {
         return this;

package/lib/tree/nodes/sets/unionIntervalNode.js

@@ -49,7 +49,7 @@ class UnionIntervalNode {
         return this.toTex();
     }
     toTex() {
-        return this.sets.map((set) => set.toTex()).join("\\cup");
+        return this.sets.map((set) => set.toTex()).join("\\cup\\ ");
     }
     toIdentifiers() {
         return {

package/lib/utils/alea/random.d.ts

@@ -1,2 +1,3 @@
 export declare function random<t>(array: t[], excludes?: t[]): t;
+export declare function randomMany<t>(array: t[], count: number, excludes?: t[]): t[];
 //# sourceMappingURL=random.d.ts.map

package/lib/utils/alea/random.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"random.d.ts","sourceRoot":"","sources":["../../../src/utils/alea/random.ts"],"names":[],"mappings":"AAEA,wBAAgB,MAAM,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,QAAQ,CAAC,EAAE,CAAC,EAAE,KAMnD"}
+{"version":3,"file":"random.d.ts","sourceRoot":"","sources":["../../../src/utils/alea/random.ts"],"names":[],"mappings":"AAEA,wBAAgB,MAAM,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,QAAQ,CAAC,EAAE,CAAC,EAAE,KAMnD;AAED,wBAAgB,UAAU,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,CAAC,EAAE,OAUtE"}

package/lib/utils/alea/random.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.random = void 0;
+exports.randomMany = exports.random = void 0;
 function random(array, excludes) {
     if (excludes?.length) {
         const filtered = array.filter((t) => !excludes.includes(t));
@@ -9,3 +9,15 @@ function random(array, excludes) {
     return array[Math.floor(Math.random() * array.length)];
 }
 exports.random = random;
+function randomMany(array, count, excludes) {
+    const res = [];
+    let i = 0;
+    while (res.length < count) {
+        if (i > 10000)
+            throw new Error("randomMany malformed");
+        i++;
+        res.push(random(array, [...res, ...(excludes ?? [])]));
+    }
+    return res;
+}
+exports.randomMany = randomMany;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "math-exercises",
-  "version": "2.2.75",
+  "version": "2.2.77",
   "description": "Math exercises generator for middle school and high school",
   "main": "lib/index.js",
   "files": [