math-exercises 3.0.52 → 3.0.54

package/lib/exercises/math/trigonometry/calculateCosSinAndTan.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"calculateCosSinAndTan.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/trigonometry/calculateCosSinAndTan.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAsEF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAWvD,CAAC"}
+{"version":3,"file":"calculateCosSinAndTan.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/trigonometry/calculateCosSinAndTan.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AA6FF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAavD,CAAC"}

package/lib/exercises/math/trigonometry/calculateCosSinAndTan.js

@@ -8,6 +8,20 @@ import { SinNode } from "../../../tree/nodes/functions/sinNode.js";
 import { TanNode } from "../../../tree/nodes/functions/tanNode.js";
 import { DegreeNode } from "../../../tree/nodes/geometry/degree.js";
 import { random } from "../../../utils/alea/random.js";
+const getHint = (identifiers) => {
+    return "Utilise la calculatrice, réglée en mode degrés.";
+};
+const getCorrection = (identifiers) => {
+    const { degree, trigoFunct } = identifiers;
+    const node = trigoFunct === "tan" ? TanNode : trigoFunct === "sin" ? SinNode : CosNode;
+    return `On utilise la calculatrice, réglée en mode degrés.
+  
+On obtient : 
+
+$$
+${new node(new DegreeNode(degree)).toTex()} \\approx ${getAnswer(identifiers)}
+$$`;
+};
 const getInstruction = (identifiers) => {
     const { degree, trigoFunct } = identifiers;
     const node = trigoFunct === "tan" ? TanNode : trigoFunct === "sin" ? SinNode : CosNode;
@@ -44,12 +58,17 @@ const getCalculateCosSinAndTanQuestion = () => {
     const trigoFunct = random(trigo);
     const degree = randint(1, 180);
     const identifiers = { degree, trigoFunct };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
         answer: getAnswer(identifiers),
         instruction: getInstruction(identifiers),
         keys: [],
         answerFormat: "tex",
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -77,4 +96,6 @@ export const calculateCosSinAndTan = {
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
+    hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
 };

package/lib/exercises/math/trigonometry/mainRemarkableValues.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mainRemarkableValues.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/trigonometry/mainRemarkableValues.ts"],"names":[],"mappings":"AAYA,OAAO,EACL,QAAQ,EAaT,MAAM,mBAAmB,CAAC;AAE3B,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,OAAO,CAAC;CAChB,CAAC;AA4FF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,CAiB9D,CAAC"}
+{"version":3,"file":"mainRemarkableValues.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/trigonometry/mainRemarkableValues.ts"],"names":[],"mappings":"AAQA,OAAO,EACL,QAAQ,EAaT,MAAM,mBAAmB,CAAC;AAE3B,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,OAAO,CAAC;CAChB,CAAC;AA4FF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,CAiB9D,CAAC"}

package/lib/exercises/math/trigonometry/mainRemarkableValues.js

@@ -1,4 +1,4 @@
-import { mainTrigoValues, } from "../../../math/trigonometry/remarkableValues.js";
+import { mainTrigoValues } from "../../../math/trigonometry/remarkableValues.js";
 import { randint } from "../../../math/utils/random/randint.js";
 import { cos } from "../../../tree/nodes/functions/cosNode.js";
 import { sin } from "../../../tree/nodes/functions/sinNode.js";

package/lib/exercises/math/trigonometry/remarkableValues.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"remarkableValues.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/trigonometry/remarkableValues.ts"],"names":[],"mappings":"AAIA,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAM7C,OAAO,EACL,QAAQ,EAWT,MAAM,mBAAmB,CAAC;AA2C3B,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,OAAO,CAAC;IACf,gBAAgB,EAAE,eAAe,CAAC;CACnC,CAAC;AA4CF,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,WAAW,CAe1D,CAAC"}
+{"version":3,"file":"remarkableValues.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/trigonometry/remarkableValues.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAM7C,OAAO,EACL,QAAQ,EAYT,MAAM,mBAAmB,CAAC;AA2C3B,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,OAAO,CAAC;IACf,gBAAgB,EAAE,eAAe,CAAC;CACnC,CAAC;AAkDF,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,WAAW,CAe1D,CAAC"}

package/lib/exercises/math/trigonometry/remarkableValues.js

@@ -52,6 +52,9 @@ const getRemarkableValues = () => {
         mainValue,
         angleIdentifiers: remarkableValue.angle.toIdentifiers(),
     };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
         instruction: getInstruction(identifiers),
         startStatement: getStartStatement(identifiers),

package/lib/index.d.ts

@@ -320,9 +320,11 @@ declare const mathExercises: (Exercise<{
         op2?: string;
     };
 }, {}> | Exercise<{
-    solutionNodeIds: any;
-    equationNodeIds: any;
-}, {}> | Exercise<{
+    solutionNodeIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    equationNodeIds: import("./tree/nodes/equations/equalNode.js").EqualNodeIdentifiers;
+}, {
+    degree: string;
+}> | Exercise<{
     type: number;
     a: number;
     b: number;
@@ -420,13 +422,11 @@ declare const mathExercises: (Exercise<{
     b: number;
     monomFirst: boolean;
 }, {}> | Exercise<{
-    coeffs: number[][];
-    isXAsked: boolean;
+    coeffsIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[][];
 }, {}> | Exercise<{
-    coeffs: number[][];
-    isXAsked: boolean;
+    coeffsIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[][];
 }, {}> | Exercise<{
-    sysCoeffs: number[][];
+    sysIds: import("./math/systems/generalSystem.js").GeneralSystemIdentifiers;
     x: number;
     y: number;
 }, {}> | Exercise<{
@@ -1018,8 +1018,10 @@ declare const mathExercises: (Exercise<{
     x: number;
     y: number;
 }, {}> | Exercise<{
-    xValue: number;
-    yValue: number;
+    x1: number;
+    x2: number;
+    y1: number;
+    y2: number;
 }, {}> | Exercise<{
     xValue: number;
     yValue: number;
@@ -1061,6 +1063,12 @@ declare const mathExercises: (Exercise<{
     absciss: number;
     abscissTex: string;
     coeff: number;
+}, {}> | Exercise<{
+    vectorIdentifiers: import("./math/geometry/vector.js").VectorIdentifiers;
+    pointIdentifiers: import("./math/geometry/point.js").PointIdentifiers;
+}, {}> | Exercise<{
+    pointIdentifiers: import("./math/geometry/point.js").PointIdentifiers;
+    pointBIdentifiers: import("./math/geometry/point.js").PointIdentifiers;
 }, {}> | Exercise<{
     coin: boolean;
     radius: number;
@@ -1120,10 +1128,10 @@ declare const mathExercises: (Exercise<{
     A: number[];
     B: number[];
 }, {}> | Exercise<{
-    xu: number;
-    yu: number;
-    xv: number;
-    yv: number;
+    xu: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    yu: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    xv: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    yv: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
 }, {}> | Exercise<{
     xA: number;
     xB: number;
@@ -1353,6 +1361,44 @@ declare const mathExercises: (Exercise<{
     x: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
     y: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
     isOnLine: boolean;
+}, {}> | Exercise<{
+    pointIds: import("./math/geometry/point.js").PointIdentifiers;
+    vectorIds: import("./math/geometry/vector.js").VectorIdentifiers;
+}, {}> | Exercise<{
+    aIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    bIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    xIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+}, {}> | Exercise<{
+    b: number;
+    secondPoint: number[];
+}, {}> | Exercise<{
+    a: number;
+    b: number;
+    isAskingA: boolean;
+}, {}> | Exercise<{
+    xA: number;
+    xB: number;
+    yA: number;
+    yB: number;
+}, {}> | Exercise<{
+    aIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    bIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+}, {}> | Exercise<{
+    aIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    bIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    fakeBIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+}, {}> | Exercise<{
+    aIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    bIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    cIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    colinearityCoeffIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    fakeCIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+}, {}> | Exercise<{
+    pointIds: import("./math/geometry/point.js").PointIdentifiers;
+    vectorIds: import("./math/geometry/vector.js").VectorIdentifiers;
+}, {}> | Exercise<{
+    cartesianCoeffs1: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
+    cartesianCoeffs2: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
 }, {}> | Exercise<{
     triangleIdentifiers: import("./math/geometry/triangles/triangle.js").TriangleIdentifiers;
     type: number;
@@ -1483,7 +1529,9 @@ declare const mathExercises: (Exercise<{
     a: number;
     b: number;
     c: number;
-}, {}> | Exercise<{
+}, {
+    useOnlyPowersOfTen: boolean;
+}> | Exercise<{
     a: number;
     b: number;
     c: number;
@@ -1662,6 +1710,19 @@ declare const mathExercises: (Exercise<{
 }, {
     useFractions?: boolean;
 }> | Exercise<{
+    xValuesIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
+    yValuesIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
+}, {}> | Exercise<{
+    xValuesIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
+    yValuesIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
+}, {}> | Exercise<{
+    xValuesIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
+    yValuesIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
+    isLaw: boolean;
+}, {}> | Exercise<{
+    xValuesIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
+    yValuesIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
+}, {}> | Exercise<{
     firstValue: number;
     askedRank: number;
     reason: number;

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/angle.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"angle.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/angle.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAMlE,OAAO,EAAE,KAAK,EAAoB,gBAAgB,EAAE,MAAM,YAAY,CAAC;AACvE,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAK7C,8BAAsB,gBAAgB;IACpC,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,gBAAgB;CAUrD;AACD,KAAK,UAAU,GAAG;IAChB,eAAe,CAAC,EAAE,aAAa,CAAC;IAChC,eAAe,CAAC,EAAE,aAAa,CAAC;CACjC,CAAC;AAEF,KAAK,qBAAqB,GAAG;IAC3B,eAAe,CAAC,EAAE,eAAe,CAAC;IAClC,eAAe,CAAC,EAAE,eAAe,CAAC;CACnC,CAAC;AACF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,MAAM,EAAE,gBAAgB,EAAE,CAAC;IAC3B,KAAK,CAAC,EAAE,qBAAqB,CAAC;CAC/B,CAAC;AACF,qBAAa,KAAK;IAChB,MAAM,EAAE,KAAK,EAAE,CAAC;IAChB,eAAe,CAAC,EAAE,aAAa,CAAC;IAChC,eAAe,CAAC,EAAE,aAAa,CAAC;IAChC,KAAK,CAAC,EAAE,UAAU,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb;;;OAGG;gBACS,MAAM,EAAE,KAAK,EAAE,EAAE,KAAK,CAAC,EAAE,UAAU;IAmB/C,aAAa,IAAI,gBAAgB;IASjC,WAAW,CAAC,CAAC,EAAE,KAAK;IAIpB,MAAM,CAAC,CAAC,EAAE,KAAK;IAqBf,SAAS,CAAC,CAAC,EAAE,KAAK;IASlB,gBAAgB,CAAC,CAAC,EAAE,KAAK;IAwCzB,MAAM;IAMN,eAAe,CAAC,CAAC,EAAE,KAAK;IAsCxB,gBAAgB,CAAC,CAAC,EAAE,KAAK;IAoBzB,QAAQ,CAAC,QAAQ,UAAQ;IAkBzB,YAAY,CAAC,QAAQ,UAAQ;IAW7B,OAAO;IAIP,KAAK;IAIL,qBAAqB,CAAC,EACpB,IAAI,EACJ,KAAK,EACL,IAAI,GACL,GAAE;QACD,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,IAAI,CAAC,EAAE,YAAY,GAAG,MAAM,GAAG,OAAO,GAAG,OAAO,CAAC;KAC7C;IAgBN,UAAU,CAAC,IAAI,CAAC,EAAE;QAChB,iBAAiB,CAAC,EAAE,OAAO,CAAC;QAC5B,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,SAAS,CAAC,EAAE,OAAO,CAAC;QACpB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,UAAU,CAAC,EAAE,MAAM,CAAC;KACrB;CA2BF"}
+{"version":3,"file":"angle.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/angle.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAMlE,OAAO,EAAE,KAAK,EAAoB,gBAAgB,EAAE,MAAM,YAAY,CAAC;AACvE,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAK7C,8BAAsB,gBAAgB;IACpC,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,gBAAgB;CAUrD;AACD,KAAK,UAAU,GAAG;IAChB,eAAe,CAAC,EAAE,aAAa,CAAC;IAChC,eAAe,CAAC,EAAE,aAAa,CAAC;CACjC,CAAC;AAEF,KAAK,qBAAqB,GAAG;IAC3B,eAAe,CAAC,EAAE,eAAe,CAAC;IAClC,eAAe,CAAC,EAAE,eAAe,CAAC;CACnC,CAAC;AACF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,MAAM,EAAE,gBAAgB,EAAE,CAAC;IAC3B,KAAK,CAAC,EAAE,qBAAqB,CAAC;CAC/B,CAAC;AACF,qBAAa,KAAK;IAChB,MAAM,EAAE,KAAK,EAAE,CAAC;IAChB,eAAe,CAAC,EAAE,aAAa,CAAC;IAChC,eAAe,CAAC,EAAE,aAAa,CAAC;IAChC,KAAK,CAAC,EAAE,UAAU,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb;;;OAGG;gBACS,MAAM,EAAE,KAAK,EAAE,EAAE,KAAK,CAAC,EAAE,UAAU;IAmB/C,aAAa,IAAI,gBAAgB;IASjC,WAAW,CAAC,CAAC,EAAE,KAAK;IAIpB,MAAM,CAAC,CAAC,EAAE,KAAK;IAqBf,SAAS,CAAC,CAAC,EAAE,KAAK;IASlB,gBAAgB,CAAC,CAAC,EAAE,KAAK;IAyCzB,MAAM;IAMN,eAAe,CAAC,CAAC,EAAE,KAAK;IAwCxB,gBAAgB,CAAC,CAAC,EAAE,KAAK;IAqBzB,QAAQ,CAAC,QAAQ,UAAQ;IAkBzB,YAAY,CAAC,QAAQ,UAAQ;IAW7B,OAAO;IAIP,KAAK;IAIL,qBAAqB,CAAC,EACpB,IAAI,EACJ,KAAK,EACL,IAAI,GACL,GAAE;QACD,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,IAAI,CAAC,EAAE,YAAY,GAAG,MAAM,GAAG,OAAO,GAAG,OAAO,CAAC;KAC7C;IAgBN,UAAU,CAAC,IAAI,CAAC,EAAE;QAChB,iBAAiB,CAAC,EAAE,OAAO,CAAC;QAC5B,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,SAAS,CAAC,EAAE,OAAO,CAAC;QACpB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,UAAU,CAAC,EAAE,MAAM,CAAC;KACrB;CA2BF"}

package/lib/math/geometry/angle.js

@@ -91,10 +91,12 @@ export class Angle {
             return false;
         const apexesVec = VectorConstructor.fromPoints(this.points[1], a.points[1]);
         const line = new Line(this.points[1], a.points[1]);
-        const aPointIndexOnLine = a.points.findIndex((p, i) => i !== 1 && line.includes(p, true));
-        const thisPointIndexOnLine = this.points.findIndex((p, i) => i !== 1 && line.includes(p, true));
+        const aPointIndexOnLine = a.points.findIndex((p, i) => i !== 1 && line.includes(p, 0.00000001));
+        const thisPointIndexOnLine = this.points.findIndex((p, i) => i !== 1 && line.includes(p, 0.00000001));
+        console.log(aPointIndexOnLine, thisPointIndexOnLine);
         if (aPointIndexOnLine < 0 || thisPointIndexOnLine < 0)
             return false;
+        console.log("ok so far");
         const vecs = [
             [
                 VectorConstructor.fromPoints(this.points[1], this.points[thisPointIndexOnLine]),
@@ -107,7 +109,7 @@ export class Angle {
         ];
         return (vecs[0][0].hasSameOrientation(apexesVec) &&
             vecs[1][0].hasOppositeOrientation(apexesVec) &&
-            vecs[0][1].scalarProduct(vecs[1][1]).evaluate() < 0);
+            vecs[0][1].scalarProductNumber(vecs[1][1]) < 0);
     }
     isFlat() {
         return VectorConstructor.fromPoints(this.points[1], this.points[2]).isColinear(VectorConstructor.fromPoints(this.points[1], this.points[0]));
@@ -119,13 +121,15 @@ export class Angle {
         if (this.isFlat() || a.isFlat())
             return false;
         const line = new Line(this.points[1], a.points[1]);
-        const aPointIndexOnLine = a.points.findIndex((p, i) => i !== 1 && line.includes(p, true));
-        const thisPointIndexOnLine = this.points.findIndex((p, i) => i !== 1 && line.includes(p, true));
+        const aPointIndexOnLine = a.points.findIndex((p, i) => i !== 1 && line.includes(p, 0.0000001));
+        const thisPointIndexOnLine = this.points.findIndex((p, i) => i !== 1 && line.includes(p, 0.0000001));
+        console.log(aPointIndexOnLine, thisPointIndexOnLine);
         if (aPointIndexOnLine < 0 || thisPointIndexOnLine < 0)
             return false;
         //angle non plat
-        if (line.includes(a.points[2 - aPointIndexOnLine], true))
+        if (line.includes(a.points[2 - aPointIndexOnLine], 0.0000001))
             return false;
+        console.log("ok so far");
         const vecs = [
             [
                 VectorConstructor.fromPoints(this.points[1], this.points[thisPointIndexOnLine]),
@@ -137,11 +141,12 @@ export class Angle {
             ],
         ];
         return (vecs[0][0].hasSameOrientation(vecs[1][0]) &&
-            vecs[0][1].scalarProduct(vecs[1][1]).evaluate() > 0);
+            vecs[0][1].scalarProductNumber(vecs[1][1]) > 0);
     }
     isSummitOpposite(a) {
         if (!this.hasSameApex(a))
             return false;
+        console.log("has same ap");
         const vecs = [
             [
                 VectorConstructor.fromPoints(this.points[1], this.points[0]),

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

@@ -1,8 +1,6 @@
 import { ToGGBCommandsProps } from "../../exercises/utils/geogebra/toGGBCommandsProps.js";
 import { AlgebraicNode } from "../../tree/nodes/algebraicNode.js";
 import { EqualNode } from "../../tree/nodes/equations/equalNode.js";
-import { AddNode } from "../../tree/nodes/operators/addNode.js";
-import { SubstractNode } from "../../tree/nodes/operators/substractNode.js";
 import { Point, PointIdentifiers } from "./point.js";
 import { Segment } from "./segment.js";
 import { Vector } from "./vector.js";
@@ -15,6 +13,8 @@ export declare abstract class LineConstructor {
     static random(name?: string): Line;
     static fromIdentifiers(identifiers: LineIdentifiers): Line;
     static fromSegment(segment: Segment): Line;
+    static fromPointAndVector(point: Point, vector: Vector): Line;
+    static fromCartesian(eq: EqualNode): Line;
 }
 export declare class Line {
     pointA: Point;
@@ -35,18 +35,13 @@ export declare class Line {
     getDirectorVector(): Vector;
     getParallele(point: Point): Line;
     getPerpendicular(point: Point): Line;
-    includes(point: Point, allowApprox?: boolean): boolean;
+    includes(point: Point, margin?: number): boolean;
     getPointWithX(x: AlgebraicNode, name?: string): Point;
     getPointWithY(y: AlgebraicNode, name?: string): Point;
     getRandomPoint(name?: string): Point;
-    getEquation: (u: Vector, a: Point) => EqualNode;
+    getReductEquation: () => EqualNode;
     getCartesianEquation(): EqualNode;
-    toCartesian(): AddNode;
-    toCartesianCoeffs(): {
-        a: AlgebraicNode;
-        b: import("../../tree/nodes/functions/oppositeNode.js").OppositeNode<AlgebraicNode>;
-        c: SubstractNode;
-    };
+    toCartesianCoeffs(): AlgebraicNode[];
     toTex(): string;
     toTexNoLeftRight(): string;
     toGGBCommands(shouldBuildPoints: boolean, { isFixed, showLabel, showUnderlyingPointsLabel, showUnderlyingPoints, color, label, }?: ToGGBCommandsProps): string[];

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,sDAAsD,CAAC;AAG1F,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAClE,OAAO,EAAS,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAG3E,OAAO,EAAE,OAAO,EAAO,MAAM,uCAAuC,CAAC;AAMrE,OAAO,EACL,aAAa,EAEd,MAAM,6CAA6C,CAAC;AAKrD,OAAO,EAAE,KAAK,EAAoB,gBAAgB,EAAE,MAAM,YAAY,CAAC;AACvE,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,OAAO,EAAE,MAAM,EAAqB,MAAM,aAAa,CAAC;AAExD,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;IAgBjC,WAAW;IAMX,iBAAiB;;;;;IAcjB,KAAK;IAGL,gBAAgB;IAIhB,aAAa,CACX,iBAAiB,EAAE,OAAO,EAC1B,EACE,OAAc,EACd,SAAiB,EACjB,yBAAgC,EAChC,oBAA2B,EAC3B,KAAiB,EACjB,KAAiB,GAClB,GAAE,kBAAuB;IA2C5B,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,sDAAsD,CAAC;AAG1F,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAClE,OAAO,EAAS,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAoB3E,OAAO,EAAE,KAAK,EAAoB,gBAAgB,EAAE,MAAM,YAAY,CAAC;AACvE,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,OAAO,EAAE,MAAM,EAAqB,MAAM,aAAa,CAAC;AAExD,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;IAGnC,MAAM,CAAC,kBAAkB,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM;IAItD,MAAM,CAAC,aAAa,CAAC,EAAE,EAAE,SAAS;CAsBnC;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,MAAM,SAAI;IA8BjC,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,iBAAiB,QAAO,SAAS,CAO/B;IAEF,oBAAoB,IAAI,SAAS;IAUjC,iBAAiB;IA2BjB,KAAK;IAGL,gBAAgB;IAIhB,aAAa,CACX,iBAAiB,EAAE,OAAO,EAC1B,EACE,OAAc,EACd,SAAiB,EACjB,yBAAgC,EAChC,oBAA2B,EAC3B,KAAiB,EACjB,KAAiB,GAClB,GAAE,kBAAuB;IA2C5B,SAAS,CAAC,IAAI,EAAE,IAAI,EAAE,aAAa,CAAC,EAAE,MAAM;CAe7C"}

package/lib/math/geometry/line.js

@@ -2,13 +2,16 @@ import { randomSegmentName } from "../../exercises/utils/geometry/randomSegmentN
 import { randomColor } from "../../geogebra/colors.js";
 import { equal, EqualNode } from "../../tree/nodes/equations/equalNode.js";
 import { opposite } from "../../tree/nodes/functions/oppositeNode.js";
+import { hasVariableNode } from "../../tree/nodes/hasVariableNode.js";
 import { NumberNode } from "../../tree/nodes/numbers/numberNode.js";
 import { AddNode, add } from "../../tree/nodes/operators/addNode.js";
 import { FractionNode, frac } from "../../tree/nodes/operators/fractionNode.js";
 import { MultiplyNode, multiply, } from "../../tree/nodes/operators/multiplyNode.js";
 import { SubstractNode, substract, } from "../../tree/nodes/operators/substractNode.js";
 import { VariableNode } from "../../tree/nodes/variables/variableNode.js";
+import { isInt } from "../../utils/isInt.js";
 import { GeneralSystem } from "../systems/generalSystem.js";
+import { gcd } from "../utils/arithmetic/gcd.js";
 import { randint } from "../utils/random/randint.js";
 import { Point, PointConstructor } from "./point.js";
 import { VectorConstructor } from "./vector.js";
@@ -26,6 +29,26 @@ export class LineConstructor {
     static fromSegment(segment) {
         return new Line(segment.pointA, segment.pointB);
     }
+    static fromPointAndVector(point, vector) {
+        const pointB = vector.getEndPoint(point);
+        return new Line(point, pointB);
+    }
+    static fromCartesian(eq) {
+        if (!hasVariableNode(eq.leftChild, "y")) {
+            //vertical
+            const xEq = eq.isolate("x");
+            return new Line(new Point("A", xEq.rightChild, (0).toTree()), new Point("B", xEq.rightChild, (1).toTree()));
+        }
+        const yWithZero = eq
+            .toDetailedEvaluation({ x: (0).toTree() })
+            .isolate("y").rightChild;
+        const pointA = [(0).toTree(), yWithZero];
+        const yWithOne = eq
+            .toDetailedEvaluation({ x: (1).toTree() })
+            .isolate("y").rightChild;
+        const pointB = [(1).toTree(), yWithOne];
+        return new Line(new Point("A", pointA[0], pointA[1]), new Point("B", pointB[0], pointB[1]));
+    }
 }
 export class Line {
     pointA;
@@ -95,20 +118,33 @@ export class Line {
         const secondPoint = ortho.getEndPoint(point);
         return new Line(point, secondPoint);
     }
-    includes(point, allowApprox = false) {
+    includes(point, margin = 0) {
         if (this.isVertical) {
-            if (allowApprox) {
-                return (Math.abs(point.x.evaluate() - this.pointA.x.evaluate()) < 0.0000001);
+            if (margin) {
+                return Math.abs(point.x.evaluate() - this.pointA.x.evaluate()) < margin;
             }
             else
                 return point.x.equals(this.pointA.x);
         }
-        const evaluation = new SubstractNode(point.y, new AddNode(new MultiplyNode(this.a, point.x), this.b)).evaluate({});
-        if (allowApprox) {
-            return Math.abs(evaluation) < 0.0000001;
+        // console.log(
+        //   "y",
+        //   point.y.toTex(),
+        //   "a",
+        //   this.a?.toTex(),
+        //   "x",
+        //   point.x.toTex(),
+        //   "b",
+        //   this.b?.toTex(),
+        // );
+        // console.log("y", this.pointA.y.toTex(), "x", this.pointA.x.toTex());
+        if (margin) {
+            const projOrtho = point.project(this);
+            return projOrtho.distanceTo(point) < margin;
         }
-        else
+        else {
+            const evaluation = new SubstractNode(point.y, new AddNode(new MultiplyNode(this.a, point.x), this.b)).evaluate({});
             return evaluation === 0;
+        }
     }
     getPointWithX(x, name) {
         if (this.isVertical)
@@ -134,42 +170,39 @@ export class Line {
         const y = new AddNode(new MultiplyNode(this.a, x), this.b).simplify();
         return new Point(name ?? "A", x, y);
     }
-    getEquation = (u, a) => {
-        const x = new VariableNode("x");
-        const y = new VariableNode("y");
-        const uYDivuX = new FractionNode(u.y, u.x).simplify();
-        const natural = u.getYAsNumber() % u.getXAsNumber() === 0;
-        const aYuX = new MultiplyNode(a.y, u.x).simplify();
-        const aXuY = new MultiplyNode(a.x, u.y).simplify();
-        const rightSide = new AddNode(natural
-            ? new MultiplyNode(uYDivuX, x).simplify()
-            : new MultiplyNode(uYDivuX, x), new FractionNode(new SubstractNode(aYuX, aXuY).simplify(), u.x).simplify());
-        const equation = new EqualNode(y, rightSide);
-        return equation;
+    getReductEquation = () => {
+        if (this.isVertical)
+            return new EqualNode(new VariableNode("x"), this.pointA.y);
+        return new EqualNode(new VariableNode("y"), add(multiply(this.a, "x"), this.b));
     };
     getCartesianEquation() {
-        const u = VectorConstructor.fromPoints(this.pointA, this.pointB);
-        const b = opposite(u.x);
-        const a = u.y;
-        const c = add(opposite(multiply(a, this.pointA.x)), opposite(multiply(b, this.pointA.y)));
+        const [a, b, c] = this.toCartesianCoeffs();
         return equal(add(add(multiply(a, "x"), multiply(b, "y")), c).simplify({
             forbidFactorize: true,
         }), 0);
     }
-    toCartesian() {
-        const { a, b, c } = this.toCartesianCoeffs();
-        return add(add(multiply(a, "x"), multiply(b, "x")), c);
-    }
     toCartesianCoeffs() {
-        //ax+by+c = 0
-        //u(-b,a)
-        //axA+byA+c = 0 donc c = -axA-byA
         const u = VectorConstructor.fromPoints(this.pointA, this.pointB);
-        const a = u.y;
-        const b = opposite(u.x);
-        // const a = u.getYAsNumber();
-        const c = substract(opposite(multiply(a, this.pointA.x)), multiply(b, this.pointA.y));
-        return { a, b, c };
+        let b = opposite(u.x);
+        let a = u.y;
+        let c = add(opposite(multiply(a, this.pointA.x)), opposite(multiply(b, this.pointA.y)));
+        const aEv = a.evaluate();
+        const bEv = b.evaluate();
+        const cEv = c.evaluate();
+        if (aEv <= 0 && bEv <= 0 && cEv <= 0) {
+            a = opposite(a);
+            b = opposite(b);
+            c = opposite(c);
+        }
+        if (isInt(aEv) && isInt(bEv) && isInt(cEv)) {
+            const pgcd = gcd(aEv, bEv, cEv);
+            if (pgcd !== 1) {
+                a = frac(a, pgcd);
+                b = frac(b, pgcd);
+                c = frac(c, pgcd);
+            }
+        }
+        return [a.simplify(), b.simplify(), c.simplify()];
     }
     toTex() {
         return this.name;
@@ -211,12 +244,13 @@ export class Line {
     intersect(line, intersectName) {
         if (line.isParallele(this))
             throw Error("Lines are parallel");
-        const { a, b, c } = this.toCartesianCoeffs();
-        const { a: a2, b: b2, c: c2 } = line.toCartesianCoeffs();
+        const [a, b, c] = this.toCartesianCoeffs();
+        const [a2, b2, c2] = line.toCartesianCoeffs();
         const sys = new GeneralSystem([
             [a, b, opposite(c)],
             [a2, b2, opposite(c2)],
         ]);
+        console.log("presolve", [a, b, c, a2, b2, c2].map((e) => e.toTex()));
         const solve = sys.solve();
         return new Point(intersectName ?? "I", solve.x, solve.y);
     }

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

@@ -1,4 +1,4 @@
-import { AlgebraicNode } from "../../tree/nodes/algebraicNode.js";
+import { AlgebraicNode, SimplifyOptions } from "../../tree/nodes/algebraicNode.js";
 import { ToGGBCommandsProps } from "../../exercises/utils/geogebra/toGGBCommandsProps.js";
 import { NodeIdentifiers } from "../../tree/nodes/nodeConstructor.js";
 import { Line } from "./line.js";
@@ -49,5 +49,6 @@ export declare class Point {
     centralSymetric(center: Point, name?: string): Point;
     project(line: Line, name?: string): Point;
     axialSymetric(line: Line, name?: string): Point;
+    simplify(opts?: SimplifyOptions): Point;
 }
 //# sourceMappingURL=point.d.ts.map

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":"AAEA,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAGlE,OAAO,EAAE,kBAAkB,EAAE,MAAM,sDAAsD,CAAC;AAC1F,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAM7C,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAEjC,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAIvC,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,OAAO,EAAE,OAAO,EAChB,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,YAAY,CAAC,CAAC,EAAE,KAAK,EAAE,IAAI,SAAM,GAAG,KAAK;IAOzC,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,IAAI,SAAM,GAAG,KAAK;IAQrC,UAAU,CAAC,CAAC,EAAE,KAAK,GAAG,MAAM;IAK5B,cAAc,CAAC,CAAC,EAAE,KAAK,GAAG,aAAa;IAMvC,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;IAIrD,OAAO,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,SAAkB;IAI1C,aAAa,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,SAAkB;CAIjD"}
+{"version":3,"file":"point.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/point.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,aAAa,EACb,eAAe,EAChB,MAAM,mCAAmC,CAAC;AAG3C,OAAO,EAAE,kBAAkB,EAAE,MAAM,sDAAsD,CAAC;AAC1F,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAM7C,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAEjC,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAIvC,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,OAAO,EAAE,OAAO,EAChB,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,YAAY,CAAC,CAAC,EAAE,KAAK,EAAE,IAAI,SAAM,GAAG,KAAK;IAOzC,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,IAAI,SAAM,GAAG,KAAK;IAQrC,UAAU,CAAC,CAAC,EAAE,KAAK,GAAG,MAAM;IAK5B,cAAc,CAAC,CAAC,EAAE,KAAK,GAAG,aAAa;IAMvC,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;IAIrD,OAAO,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,SAAkB;IAI1C,aAAa,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,SAAkB;IAKhD,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe;CAGhC"}

package/lib/math/geometry/point.js

@@ -159,4 +159,7 @@ export class Point {
         const projOrtho = this.project(line);
         return this.centralSymetric(projOrtho, name);
     }
+    simplify(opts) {
+        return new Point(this.name, this.x.simplify(opts), this.y.simplify(opts));
+    }
 }

package/lib/math/geometry/segment.js

@@ -124,7 +124,7 @@ export class Segment {
         const pointVec = VectorConstructor.fromPoints(this.pointA, point);
         if (!vec.isColinear(pointVec))
             return false;
-        const product = vec.scalarProduct(pointVec).evaluate();
+        const product = vec.scalarProductNumber(pointVec);
         return product >= 0 && product <= this.getLength() ** 2;
     }
     toVector() {

package/lib/math/geometry/triangles/triangle.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"triangle.d.ts","sourceRoot":"","sources":["../../../../src/math/geometry/triangles/triangle.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAoB,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAExE,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AACxC,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAKpC,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAClE,OAAO,EAEL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAG7C,MAAM,MAAM,mBAAmB,GAAG;IAChC,MAAM,EAAE,gBAAgB,EAAE,CAAC;IAC3B,KAAK,CAAC,EAAE,wBAAwB,CAAC;CAClC,CAAC;AAEF,8BAAsB,mBAAmB;IACvC,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,mBAAmB,GAAG,QAAQ;IAgBlE,MAAM,CAAC,eAAe,CAAC,EACrB,KAAuB,EACvB,UAAkB,EAClB,QAAgB,EAChB,QAAY,GACb;;;;;KAAA,GAAG,QAAQ;IA+CZ,MAAM,CAAC,UAAU;CAQlB;AAED,MAAM,MAAM,wBAAwB,GAAG;IACrC,YAAY,CAAC,EAAE,CAAC,eAAe,GAAG,SAAS,CAAC,EAAE,CAAC;IAC/C,kBAAkB,CAAC,EAAE,eAAe,EAAE,CAAC;IACvC,kBAAkB,CAAC,EAAE,eAAe,EAAE,CAAC;CACxC,CAAC;AACF,MAAM,MAAM,aAAa,GAAG;IAC1B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,YAAY,CAAC,EAAE,CAAC,aAAa,GAAG,SAAS,CAAC,EAAE,CAAC;IAC7C,kBAAkB,CAAC,EAAE,aAAa,EAAE,CAAC;IACrC,kBAAkB,CAAC,EAAE,aAAa,EAAE,CAAC;CACtC,CAAC;AACF,qBAAa,QAAQ;IACnB,MAAM,EAAE,KAAK,EAAE,CAAC;IAChB,MAAM,EAAE,KAAK,EAAE,CAAC;IAChB,KAAK,EAAE,OAAO,EAAE,CAAC;IACjB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,aAAa,CAAC;gBACV,MAAM,EAAE,KAAK,EAAE,EAAE,KAAK,CAAC,EAAE,aAAa;IA0ClD,aAAa,IAAI,mBAAmB;IAepC,YAAY,IAAI,MAAM;IAItB,OAAO,IAAI,MAAM;IASjB,OAAO,IAAI,OAAO;IAIlB,aAAa,IAAI,OAAO;IAMxB,WAAW,IAAI,OAAO;IAUtB,SAAS,IAAI,OAAO;IASpB,aAAa,CACX,KAAK,EAAE,MAAM,EACb,IAAI,EAAE;QACJ,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,OAAO,CAAC,EAAE,MAAM,CAAC;KAClB;IAcH,cAAc,CACZ,KAAK,EAAE,MAAM,EACb,IAAI,CAAC,EAAE;QACL,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,SAAS,CAAC,EAAE,OAAO,CAAC;KACrB;IAKH,eAAe,CAAC,WAAW,CAAC,EAAE,MAAM,EAAE;IAQtC,SAAS,CACP,WAAW,EAAE,MAAM,EACnB,IAAI,CAAC,EAAE;QACL,QAAQ,CAAC,EAAE,MAAM,CAAC;KACnB;IAYH,UAAU,CACR,WAAW,EAAE,MAAM,EACnB,IAAI,CAAC,EAAE;QACL,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,SAAS,CAAC,EAAE,KAAK,CAAC;KACnB;IAoCH,cAAc,IAAI,MAAM,EAAE;IAkB1B,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,IAAI,CAAC,EAAE;QAAE,UAAU,EAAE,OAAO,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE;CAgB5E"}
+{"version":3,"file":"triangle.d.ts","sourceRoot":"","sources":["../../../../src/math/geometry/triangles/triangle.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAoB,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAExE,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AACxC,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAKpC,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAClE,OAAO,EAEL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAG7C,MAAM,MAAM,mBAAmB,GAAG;IAChC,MAAM,EAAE,gBAAgB,EAAE,CAAC;IAC3B,KAAK,CAAC,EAAE,wBAAwB,CAAC;CAClC,CAAC;AAEF,8BAAsB,mBAAmB;IACvC,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,mBAAmB,GAAG,QAAQ;IAgBlE,MAAM,CAAC,eAAe,CAAC,EACrB,KAAuB,EACvB,UAAkB,EAClB,QAAgB,EAChB,QAAY,GACb;;;;;KAAA,GAAG,QAAQ;IA+CZ,MAAM,CAAC,UAAU;CAQlB;AAED,MAAM,MAAM,wBAAwB,GAAG;IACrC,YAAY,CAAC,EAAE,CAAC,eAAe,GAAG,SAAS,CAAC,EAAE,CAAC;IAC/C,kBAAkB,CAAC,EAAE,eAAe,EAAE,CAAC;IACvC,kBAAkB,CAAC,EAAE,eAAe,EAAE,CAAC;CACxC,CAAC;AACF,MAAM,MAAM,aAAa,GAAG;IAC1B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,YAAY,CAAC,EAAE,CAAC,aAAa,GAAG,SAAS,CAAC,EAAE,CAAC;IAC7C,kBAAkB,CAAC,EAAE,aAAa,EAAE,CAAC;IACrC,kBAAkB,CAAC,EAAE,aAAa,EAAE,CAAC;CACtC,CAAC;AACF,qBAAa,QAAQ;IACnB,MAAM,EAAE,KAAK,EAAE,CAAC;IAChB,MAAM,EAAE,KAAK,EAAE,CAAC;IAChB,KAAK,EAAE,OAAO,EAAE,CAAC;IACjB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,aAAa,CAAC;gBACV,MAAM,EAAE,KAAK,EAAE,EAAE,KAAK,CAAC,EAAE,aAAa;IA0ClD,aAAa,IAAI,mBAAmB;IAepC,YAAY,IAAI,MAAM;IAItB,OAAO,IAAI,MAAM;IASjB,OAAO,IAAI,OAAO;IAIlB,aAAa,IAAI,OAAO;IAMxB,WAAW,IAAI,OAAO;IAUtB,SAAS,IAAI,OAAO;IASpB,aAAa,CACX,KAAK,EAAE,MAAM,EACb,IAAI,EAAE;QACJ,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,OAAO,CAAC,EAAE,MAAM,CAAC;KAClB;IAcH,cAAc,CACZ,KAAK,EAAE,MAAM,EACb,IAAI,CAAC,EAAE;QACL,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,SAAS,CAAC,EAAE,OAAO,CAAC;KACrB;IAKH,eAAe,CAAC,WAAW,CAAC,EAAE,MAAM,EAAE;IAQtC,SAAS,CACP,WAAW,EAAE,MAAM,EACnB,IAAI,CAAC,EAAE;QACL,QAAQ,CAAC,EAAE,MAAM,CAAC;KACnB;IAYH,UAAU,CACR,WAAW,EAAE,MAAM,EACnB,IAAI,CAAC,EAAE;QACL,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,SAAS,CAAC,EAAE,KAAK,CAAC;KACnB;IAuCH,cAAc,IAAI,MAAM,EAAE;IAkB1B,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,IAAI,CAAC,EAAE;QAAE,UAAU,EAAE,OAAO,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE;CAgB5E"}

package/lib/math/geometry/triangles/triangle.js

@@ -195,17 +195,17 @@ export class Triangle {
             this.points[(summitIndex + 1) % 3],
         ]);
         this.commands.push(...foot.toGGBCommand(), ...height.toGGBCommands(false, { style: 2 }), ...angle.toCommands());
-        if (!this.sides[summitIndex].includes(foot)) {
-            const distancesToSideSummits = [
-                this.sides[summitIndex].pointA,
-                this.sides[summitIndex].pointB,
-            ].map((p) => p.distanceTo(foot));
-            const closestPoint = distancesToSideSummits[0] < distancesToSideSummits[1]
-                ? this.sides[summitIndex].pointA
-                : this.sides[summitIndex].pointB;
-            const prolongement = new Segment(closestPoint, foot);
-            this.commands.push(...prolongement.toGGBCommands(false, { style: 2 }));
-        }
+        // if (!this.sides[summitIndex].includes(foot)) {
+        const distancesToSideSummits = [
+            this.sides[summitIndex].pointA,
+            this.sides[summitIndex].pointB,
+        ].map((p) => p.distanceTo(foot));
+        const closestPoint = distancesToSideSummits[0] < distancesToSideSummits[1]
+            ? this.sides[summitIndex].pointA
+            : this.sides[summitIndex].pointB;
+        const prolongement = new Segment(closestPoint, foot);
+        this.commands.push(...prolongement.toGGBCommands(false, { style: 2 }));
+        // }
     }
     generateCoords() {
         const coords = this.points.map((p) => [p.x.evaluate(), p.y.evaluate()]);