math-exercises 2.2.70 → 2.2.72

package/lib/exercises/math/probaStat/stats1var/varianceList.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.varianceList = void 0;
+const exercise_1 = require("../../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
+const rationalVEA_1 = require("../../../../exercises/vea/rationalVEA");
+const randfloat_1 = require("../../../../math/utils/random/randfloat");
+const randint_1 = require("../../../../math/utils/random/randint");
+const round_1 = require("../../../../math/utils/round");
+const variance_1 = require("../../../../math/utils/variance");
+const average_1 = require("../../../../utils/average");
+const alignTex_1 = require("../../../../utils/latex/alignTex");
+const approxOrEqual_1 = require("../../../../utils/latex/approxOrEqual");
+const getPropositions = (n, { answer, sortedValues }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    (0, exercise_1.tryToAddWrongProp)(propositions, (0, round_1.round)((0, average_1.average)(sortedValues), 2).frenchify());
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, (0, randfloat_1.randfloat)(3, 10, 2).frenchify());
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const vrc = (0, variance_1.variance)(identifiers.sortedValues, (0, average_1.average)(identifiers.sortedValues));
+    return (0, round_1.round)(vrc, 2).frenchify();
+};
+const getInstruction = (identifiers) => {
+    return `Calculer la variance de la série statistique suivante : 
+  
+$$
+${identifiers.sortedValues.map((e) => e.frenchify()).join("\\ ; \\ ")}
+$$
+
+Arrondir au centième.`;
+};
+const getHint = (identifiers) => {
+    return `Si on note $N$ le nombre de valeurs, $\\overline x$ la moyenne de cette liste, et $x_1$, $x_2$, $\\ldots$, $x_N$ les valeurs de la liste, alors la variance est : 
+
+$$
+V = \\frac{(x_1-\\overline{x})^2 + (x_2-\\overline{x})^2 + \\ldots + (x_N-\\overline{x})^2}{N}
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const n = identifiers.sortedValues.length;
+    const avg = (0, average_1.average)(identifiers.sortedValues);
+    const roundedAvg = (0, round_1.round)(avg, 2);
+    const vce = (0, variance_1.variance)(identifiers.sortedValues, (0, average_1.average)(identifiers.sortedValues));
+    return `La moyenne $\\overline{x}$ de cette série vaut : 
+  
+${(0, alignTex_1.alignTex)([
+        [
+            `\\overline{x}`,
+            "=",
+            `\\frac{${identifiers.sortedValues
+                .map((e) => e.frenchify())
+                .join("+")}}{${n}}`,
+        ],
+        ["", ...(0, approxOrEqual_1.approxOrEqual)(avg, 2)],
+    ])}
+
+La variance est  donc : 
+
+${(0, alignTex_1.alignTex)([
+        [
+            "V",
+            "=",
+            `\\frac{(x_1-\\overline{x})^2 + (x_2-\\overline{x})^2 + \\ldots + (x_n-\\overline{x})^2}{N}`,
+        ],
+        [
+            "",
+            "=",
+            `\\frac{${identifiers.sortedValues
+                .map((e) => `(${e.frenchify()} - ${roundedAvg.frenchify()})^2`)
+                .join("+")}}{${n}}`,
+        ],
+        ["", ...(0, approxOrEqual_1.approxOrEqual)(vce, 2)],
+    ])}`;
+};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    return (0, rationalVEA_1.rationalVEA)(ans, answer);
+};
+const getVarianceListQuestion = (ops) => {
+    const nbValues = (0, randint_1.randint)(4, 7);
+    const values = [];
+    for (let i = 0; i < nbValues; i++) {
+        values.push((0, randint_1.randint)(1, 15));
+    }
+    const identifiers = {
+        sortedValues: values.sort((a, b) => a - b),
+    };
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+exports.varianceList = {
+    id: "varianceList",
+    connector: "=",
+    label: "Calcul de la variance d'une liste de valeurs",
+    isSingleStep: true,
+    generator: (nb, opts) => (0, getDistinctQuestions_1.getDistinctQuestions)(() => getVarianceListQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/probaStat/stats1var/varianceTable.d.ts

@@ -0,0 +1,8 @@
+import { Exercise } from "../../../../exercises/exercise";
+type Identifiers = {
+    sortedValues: number[];
+    effectifs: number[];
+};
+export declare const varianceTable: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=varianceTable.d.ts.map

package/lib/exercises/math/probaStat/stats1var/varianceTable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"varianceTable.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/varianceTable.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,0BAA0B,CAAC;AAYlC,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,SAAS,EAAE,MAAM,EAAE,CAAC;CACrB,CAAC;AAuHF,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,WAAW,CAiB/C,CAAC"}

package/lib/exercises/math/probaStat/stats1var/varianceTable.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.varianceTable = void 0;
+const exercise_1 = require("../../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
+const rationalVEA_1 = require("../../../../exercises/vea/rationalVEA");
+const randfloat_1 = require("../../../../math/utils/random/randfloat");
+const randint_1 = require("../../../../math/utils/random/randint");
+const round_1 = require("../../../../math/utils/round");
+const variance_1 = require("../../../../math/utils/variance");
+const average_1 = require("../../../../utils/average");
+const alignTex_1 = require("../../../../utils/latex/alignTex");
+const approxOrEqual_1 = require("../../../../utils/latex/approxOrEqual");
+const mdTable_1 = require("../../../../utils/markdown/mdTable");
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, (0, randfloat_1.randfloat)(3, 10, 2).frenchify());
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const vce = (0, variance_1.varianceWithEffectifs)(identifiers.sortedValues, identifiers.effectifs);
+    return (0, round_1.round)(vce, 2).frenchify();
+};
+const getInstruction = (identifiers) => {
+    return `Calculer la variance de la série statistique suivante : 
+
+${(0, mdTable_1.mdTable)([
+        ["$x_i$", ...identifiers.sortedValues.map((e) => `$${e.frenchify()}$`)],
+        ["$n_i$", ...identifiers.effectifs.map((e) => `$${e.frenchify()}$`)],
+    ])}
+
+Arrondir au centième.`;
+};
+const getHint = (identifiers) => {
+    return `On note : 
+  
+- $N$ le nombre de valeurs de la liste, 
+- $\\overline x$ la moyenne de la liste,
+- $x_1$, $x_2$, $\\ldots$, $x_N$ les valeurs de la liste,
+- $n_1$, $n_2$, $\\ldots$, $n_N$ les effectifs de la liste.
+
+Alors la variance est égale à : 
+
+$$
+V = \\frac{n_1(x_1-\\overline{x})^2  + \\ldots + n_N(x_N-\\overline{x})^2}{N}
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { sortedValues, effectifs } = identifiers;
+    const n = effectifs.reduce((acc, curr) => acc + curr, 0);
+    const avg = (0, average_1.averageWithEffectifs)(sortedValues, effectifs);
+    const roundedAvg = (0, round_1.round)(avg, 2);
+    const vce = (0, variance_1.varianceWithEffectifs)(sortedValues, effectifs);
+    return `La moyenne $\\overline{x}$ de cette série vaut : 
+  
+${(0, alignTex_1.alignTex)([
+        [
+            `\\overline{x}`,
+            "=",
+            `\\frac{${sortedValues
+                .map((e, i) => `${effectifs[i].frenchify()}\\times ${e.frenchify()}`)
+                .join("+")}}{${n}}`,
+        ],
+        ["", ...(0, approxOrEqual_1.approxOrEqual)(avg, 2)],
+    ])}
+
+La variance est  donc : 
+
+${(0, alignTex_1.alignTex)([
+        [
+            "V",
+            "=",
+            `\\frac{n_1(x_1-\\overline{x})^2 +  \\ldots + n_N(x_N-\\overline{x})^2}{N}`,
+        ],
+        [
+            "",
+            "=",
+            `\\frac{${sortedValues
+                .map((e, i) => `${effectifs[i].frenchify()}\\times(${e.frenchify()} - ${roundedAvg.frenchify()})^2`)
+                .join("+")}}{${n}}`,
+        ],
+        ["", ...(0, approxOrEqual_1.approxOrEqual)(vce, 2)],
+    ])}`;
+};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    return (0, rationalVEA_1.rationalVEA)(ans, answer);
+};
+const getVarianceTableQuestion = (ops) => {
+    const nbValues = (0, randint_1.randint)(4, 7);
+    const values = [];
+    const effectifs = [];
+    for (let i = 0; i < nbValues; i++) {
+        values.push((0, randint_1.randint)(1, 15, values));
+        effectifs.push((0, randint_1.randint)(1, 7));
+    }
+    const identifiers = {
+        sortedValues: values.sort((a, b) => a - b),
+        effectifs,
+    };
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+exports.varianceTable = {
+    id: "varianceTable",
+    connector: "=",
+    label: "Calculer la variance d'un tableau d'effectifs",
+    isSingleStep: true,
+    generator: (nb, opts) => (0, getDistinctQuestions_1.getDistinctQuestions)(() => getVarianceTableQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/vea/sqrtVEA.d.ts

@@ -1,6 +1,7 @@
 type Opts = {
     allowNonIrreductible?: boolean;
+    decimalApproxAllowed?: number;
 };
-export declare const sqrtVEA: (studentAns: string, answer: string, { allowNonIrreductible }?: Opts) => boolean;
+export declare const sqrtVEA: (studentAns: string, answer: string, { allowNonIrreductible, decimalApproxAllowed }?: Opts) => boolean;
 export {};
 //# sourceMappingURL=sqrtVEA.d.ts.map

package/lib/exercises/vea/sqrtVEA.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sqrtVEA.d.ts","sourceRoot":"","sources":["../../../src/exercises/vea/sqrtVEA.ts"],"names":[],"mappings":"AAMA,KAAK,IAAI,GAAG;IACV,oBAAoB,CAAC,EAAE,OAAO,CAAC;CAChC,CAAC;AACF,eAAO,MAAM,OAAO,eACN,MAAM,UACV,MAAM,6BACY,IAAI,YAmB/B,CAAC"}
+{"version":3,"file":"sqrtVEA.d.ts","sourceRoot":"","sources":["../../../src/exercises/vea/sqrtVEA.ts"],"names":[],"mappings":"AAMA,KAAK,IAAI,GAAG;IACV,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,oBAAoB,CAAC,EAAE,MAAM,CAAC;CAC/B,CAAC;AACF,eAAO,MAAM,OAAO,eACN,MAAM,UACV,MAAM,mDACkC,IAAI,YA0BrD,CAAC"}

package/lib/exercises/vea/sqrtVEA.js

@@ -4,20 +4,23 @@ exports.sqrtVEA = void 0;
 const numberNode_1 = require("../../tree/nodes/numbers/numberNode");
 const latexParser_1 = require("../../tree/parsers/latexParser");
 const sqrtParser_1 = require("../../tree/parsers/sqrtParser");
-const sqrtVEA = (studentAns, answer, { allowNonIrreductible } = {
+const sqrtVEA = (studentAns, answer, { allowNonIrreductible, decimalApproxAllowed } = {
     allowNonIrreductible: true,
 }) => {
     try {
         allowNonIrreductible = allowNonIrreductible ?? true;
+        decimalApproxAllowed = decimalApproxAllowed ?? 0.0000001;
         const parsed = (0, sqrtParser_1.sqrtParser)(studentAns);
         if (!parsed)
             return false;
         const parsedAnswer = (0, latexParser_1.parseAlgebraic)(answer);
         if ((0, numberNode_1.isNumberNode)(parsed)) {
-            return Math.abs(parsed.evaluate() - parsedAnswer.evaluate()) < 0.0000001;
+            return (Math.abs(parsed.evaluate() - parsedAnswer.evaluate()) <
+                decimalApproxAllowed);
         }
         else if (allowNonIrreductible) {
-            return Math.abs(parsed.evaluate() - parsedAnswer.evaluate()) < 0.0000001;
+            return (Math.abs(parsed.evaluate() - parsedAnswer.evaluate()) <
+                decimalApproxAllowed);
         }
         else {
             return parsed.equals(parsedAnswer);

package/lib/index.d.ts

@@ -230,6 +230,16 @@ declare const mathExercises: (Exercise<{
     a: number;
     b: number;
     c: number;
+}, {}> | Exercise<{
+    type: number;
+    affine1: import("./math/polynomials/generalAffine").GeneralAffineIdentifiers;
+    affine2: import("./math/polynomials/generalAffine").GeneralAffineIdentifiers;
+    affine3: import("./math/polynomials/generalAffine").GeneralAffineIdentifiers;
+    affine4?: import("./math/polynomials/generalAffine").GeneralAffineIdentifiers | undefined;
+}, {}> | Exercise<{
+    type: number;
+    a: import("./tree/nodes/nodeConstructor").NodeIdentifiers;
+    b: import("./tree/nodes/nodeConstructor").NodeIdentifiers;
 }, {}> | Exercise<{
     randNbr: number;
 }, {}> | Exercise<{
@@ -1175,6 +1185,11 @@ declare const mathExercises: (Exercise<{
     showDiagonals: boolean;
     drawAngles: boolean;
     shapeIdentifiers: import("./math/geometry/parallelogram").ParallelogramIdentifiers | import("./math/geometry/rhombus").RhombusIdentifiers | import("./math/geometry/rectangle").RectangleIdentifiers | import("./math/geometry/square").SquareIdentifiers;
+}, {}> | Exercise<{
+    points: import("./math/geometry/point").PointIdentifiers[];
+    angleType: string;
+    angleIndex: number;
+    apexIndex: number;
 }, {}> | Exercise<{
     coeffs: number[];
     to: string;
@@ -1378,6 +1393,21 @@ declare const mathExercises: (Exercise<{
     sortedValues: number[];
 }, {}> | Exercise<{
     sortedValues: number[];
+}, {}> | Exercise<{
+    sortedValues: number[];
+}, {}> | Exercise<{
+    sortedValues: number[];
+    effectifs: number[];
+}, {}> | Exercise<{
+    sortedValues: number[];
+}, {}> | Exercise<{
+    sortedValues: number[];
+    effectifs: number[];
+}, {}> | Exercise<{
+    sortedValues: number[];
+}, {}> | Exercise<{
+    sortedValues: number[];
+    effectifs: number[];
 }, {}> | Exercise<{
     xValues: number[];
     yValues: 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

@@ -1,18 +1,39 @@
 import { AlgebraicNode } from "../../tree/nodes/algebraicNode";
-import { Point } from "./point";
+import { Point, PointIdentifiers } from "./point";
+import { NodeIdentifiers } from "../../tree/nodes/nodeConstructor";
+export declare abstract class AngleConstructor {
+    static fromIdentifiers(identifiers: AngleIdentifiers): Angle;
+}
 type AngleProps = {
     radianValueNode?: AlgebraicNode;
     degreeValueNode?: AlgebraicNode;
 };
+type AnglePropsIdentifiers = {
+    radianValueNode?: NodeIdentifiers;
+    degreeValueNode?: NodeIdentifiers;
+};
+export type AngleIdentifiers = {
+    points: PointIdentifiers[];
+    props?: AnglePropsIdentifiers;
+};
 export declare class Angle {
     points: Point[];
     radianValueNode?: AlgebraicNode;
     degreeValueNode?: AlgebraicNode;
+    props?: AngleProps;
     /**
      *
      * @param points [pointA, pointB, pointC] with apex = B
      */
     constructor(points: Point[], props?: AngleProps);
+    toIdentifiers(): AngleIdentifiers;
+    hasSameApex(a: Angle): boolean;
+    equals(a: Angle): boolean;
+    isAlterne(a: Angle): boolean;
+    isAlterneInterne(a: Angle): boolean;
+    isFlat(): boolean;
+    isCorrespondant(a: Angle): boolean;
+    isSummitOpposite(a: Angle): boolean;
     evaluate(inRadian?: boolean): number;
     getValueNode(inDegree?: boolean): AlgebraicNode | import("../../tree/nodes/numbers/constantNode").ConstantNode | import("../../tree/nodes/numbers/numberNode").NumberNode;
     isRight(): boolean;

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,gCAAgC,CAAC;AAM/D,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAEhC,KAAK,UAAU,GAAG;IAChB,eAAe,CAAC,EAAE,aAAa,CAAC;IAChC,eAAe,CAAC,EAAE,aAAa,CAAC;CACjC,CAAC;AACF,qBAAa,KAAK;IAChB,MAAM,EAAE,KAAK,EAAE,CAAC;IAChB,eAAe,CAAC,EAAE,aAAa,CAAC;IAChC,eAAe,CAAC,EAAE,aAAa,CAAC;IAEhC;;;OAGG;gBACS,MAAM,EAAE,KAAK,EAAE,EAAE,KAAK,CAAC,EAAE,UAAU;IAkB/C,QAAQ,CAAC,QAAQ,UAAQ;IAiBzB,YAAY,CAAC,QAAQ,UAAQ;IAW7B,OAAO;IAIP,KAAK;IAGL,UAAU,CAAC,IAAI,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,OAAO,CAAA;KAAE;CAgB1D"}
+{"version":3,"file":"angle.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/angle.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAM/D,OAAO,EAAE,KAAK,EAAoB,gBAAgB,EAAE,MAAM,SAAS,CAAC;AACpE,OAAO,EACL,eAAe,EAEhB,MAAM,kCAAkC,CAAC;AAI1C,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;;;OAGG;gBACS,MAAM,EAAE,KAAK,EAAE,EAAE,KAAK,CAAC,EAAE,UAAU;IAkB/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;IAiBzB,YAAY,CAAC,QAAQ,UAAQ;IAW7B,OAAO;IAIP,KAAK;IAGL,UAAU,CAAC,IAAI,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,OAAO,CAAA;KAAE;CAgB1D"}

package/lib/math/geometry/angle.js

@@ -1,10 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Angle = void 0;
+exports.Angle = exports.AngleConstructor = void 0;
 const piNode_1 = require("../../tree/nodes/numbers/piNode");
 const fractionNode_1 = require("../../tree/nodes/operators/fractionNode");
 const multiplyNode_1 = require("../../tree/nodes/operators/multiplyNode");
 const round_1 = require("../utils/round");
+const point_1 = require("./point");
+const nodeConstructor_1 = require("../../tree/nodes/nodeConstructor");
+const vector_1 = require("./vector");
+const line_1 = require("./line");
+class AngleConstructor {
+    static fromIdentifiers(identifiers) {
+        return new Angle(identifiers.points.map(point_1.PointConstructor.fromIdentifiers), {
+            degreeValueNode: identifiers.props?.degreeValueNode
+                ? (0, nodeConstructor_1.reifyAlgebraic)(identifiers.props.degreeValueNode)
+                : undefined,
+            radianValueNode: identifiers.props?.radianValueNode
+                ? (0, nodeConstructor_1.reifyAlgebraic)(identifiers.props.radianValueNode)
+                : undefined,
+        });
+    }
+}
+exports.AngleConstructor = AngleConstructor;
 class Angle {
     /**
      *
@@ -12,6 +29,7 @@ class Angle {
      */
     constructor(points, props) {
         this.points = points;
+        this.props = props;
         this.radianValueNode = props?.radianValueNode;
         this.degreeValueNode = props?.degreeValueNode;
         if (props?.radianValueNode && !props.degreeValueNode) {
@@ -21,6 +39,125 @@ class Angle {
             this.radianValueNode = (0, fractionNode_1.frac)((0, multiplyNode_1.multiply)(props.degreeValueNode, piNode_1.PiNode), (180).toTree());
         }
     }
+    toIdentifiers() {
+        return {
+            points: this.points.map((p) => p.toIdentifiers()),
+            props: {
+                degreeValueNode: this.degreeValueNode?.toIdentifiers(),
+                radianValueNode: this.radianValueNode?.toIdentifiers(),
+            },
+        };
+    }
+    hasSameApex(a) {
+        return this.points[1].equals(a.points[1]);
+    }
+    equals(a) {
+        if (!this.hasSameApex(a))
+            return false;
+        const vecs = [
+            [
+                vector_1.VectorConstructor.fromPoints(this.points[1], this.points[0]),
+                vector_1.VectorConstructor.fromPoints(this.points[1], this.points[2]),
+            ],
+            [
+                vector_1.VectorConstructor.fromPoints(a.points[1], a.points[0]),
+                vector_1.VectorConstructor.fromPoints(a.points[1], a.points[2]),
+            ],
+        ];
+        if (vecs[0][0].hasSameOrientation(vecs[1][0])) {
+            return vecs[0][1].hasSameOrientation(vecs[1][1]);
+        }
+        if (vecs[0][0].hasSameOrientation(vecs[1][1])) {
+            return vecs[0][1].hasSameOrientation(vecs[1][0]);
+        }
+        return false;
+    }
+    isAlterne(a) {
+        if (this.hasSameApex(a))
+            return false;
+        const symetric = new Angle([
+            a.points[0].centralSymetric(a.points[1]),
+            a.points[1],
+            a.points[2].centralSymetric(a.points[1]),
+        ]);
+        return symetric.isCorrespondant(this);
+    }
+    isAlterneInterne(a) {
+        if (this.hasSameApex(a))
+            return false;
+        if (this.isFlat() || a.isFlat())
+            return false;
+        const apexesVec = vector_1.VectorConstructor.fromPoints(this.points[1], a.points[1]);
+        const line = new line_1.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));
+        if (aPointIndexOnLine < 0 || thisPointIndexOnLine < 0)
+            return false;
+        const vecs = [
+            [
+                vector_1.VectorConstructor.fromPoints(this.points[1], this.points[thisPointIndexOnLine]),
+                vector_1.VectorConstructor.fromPoints(this.points[1], this.points[2 - thisPointIndexOnLine]),
+            ],
+            [
+                vector_1.VectorConstructor.fromPoints(a.points[1], a.points[aPointIndexOnLine]),
+                vector_1.VectorConstructor.fromPoints(a.points[1], a.points[2 - aPointIndexOnLine]),
+            ],
+        ];
+        return (vecs[0][0].hasSameOrientation(apexesVec) &&
+            vecs[1][0].hasOppositeOrientation(apexesVec) &&
+            vecs[0][1].scalarProduct(vecs[1][1]).evaluate() < 0);
+    }
+    isFlat() {
+        return vector_1.VectorConstructor.fromPoints(this.points[1], this.points[2]).isColinear(vector_1.VectorConstructor.fromPoints(this.points[1], this.points[0]));
+    }
+    isCorrespondant(a) {
+        if (this.hasSameApex(a))
+            return false;
+        //angles plats ne sont pas créés par intersections de droites donc ne peuvent pas etre correspondants
+        if (this.isFlat() || a.isFlat())
+            return false;
+        const line = new line_1.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));
+        if (aPointIndexOnLine < 0 || thisPointIndexOnLine < 0)
+            return false;
+        //angle non plat
+        if (line.includes(a.points[2 - aPointIndexOnLine], true))
+            return false;
+        const vecs = [
+            [
+                vector_1.VectorConstructor.fromPoints(this.points[1], this.points[thisPointIndexOnLine]),
+                vector_1.VectorConstructor.fromPoints(this.points[1], this.points[2 - thisPointIndexOnLine]),
+            ],
+            [
+                vector_1.VectorConstructor.fromPoints(a.points[1], a.points[aPointIndexOnLine]),
+                vector_1.VectorConstructor.fromPoints(a.points[1], a.points[2 - aPointIndexOnLine]),
+            ],
+        ];
+        return (vecs[0][0].hasSameOrientation(vecs[1][0]) &&
+            vecs[0][1].scalarProduct(vecs[1][1]).evaluate() > 0);
+    }
+    isSummitOpposite(a) {
+        if (!this.hasSameApex(a))
+            return false;
+        const vecs = [
+            [
+                vector_1.VectorConstructor.fromPoints(this.points[1], this.points[0]),
+                vector_1.VectorConstructor.fromPoints(this.points[1], this.points[2]),
+            ],
+            [
+                vector_1.VectorConstructor.fromPoints(a.points[1], a.points[0]),
+                vector_1.VectorConstructor.fromPoints(a.points[1], a.points[2]),
+            ],
+        ];
+        if (vecs[0][0].hasOppositeOrientation(vecs[1][0])) {
+            return vecs[0][1].hasOppositeOrientation(vecs[1][1]);
+        }
+        if (vecs[0][0].hasOppositeOrientation(vecs[1][1])) {
+            return vecs[0][1].hasOppositeOrientation(vecs[1][0]);
+        }
+        return false;
+    }
     evaluate(inRadian = false) {
         if (this.degreeValueNode || this.radianValueNode) {
             if (inRadian)

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

@@ -36,6 +36,8 @@ export declare class Line {
     getParallele(point: Point): Line;
     getPerpendicular(point: Point): Line;
     includes(point: Point, allowApprox?: boolean): boolean;
+    getPointWithX(x: AlgebraicNode, name?: string): Point;
+    getPointWithY(y: AlgebraicNode, name?: string): Point;
     getRandomPoint(name?: string): Point;
     getEquation: (u: Vector, a: Point) => EqualNode;
     getCartesianEquation(): EqualNode;

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;IAenD,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;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"}

package/lib/math/geometry/line.js

@@ -104,6 +104,7 @@ class Line {
     includes(point, allowApprox = false) {
         if (this.isVertical) {
             if (allowApprox) {
+                return (Math.abs(point.x.evaluate() - this.pointA.x.evaluate()) < 0.0000001);
             }
             else
                 return point.x.equals(this.pointA.x);
@@ -115,6 +116,21 @@ class Line {
         else
             return evaluation === 0;
     }
+    getPointWithX(x, name) {
+        if (this.isVertical)
+            return this.pointA.midpoint(this.pointB, name);
+        const y = (0, addNode_1.add)((0, multiplyNode_1.multiply)(this.a, x), this.b).simplify();
+        return new point_1.Point(name ?? "P", x, y);
+    }
+    getPointWithY(y, name) {
+        if (this.a?.evaluate() === 0)
+            return this.pointA.midpoint(this.pointB, name);
+        if (this.isVertical) {
+            return new point_1.Point(name ?? "P", this.pointA.x, y);
+        }
+        const x = (0, fractionNode_1.frac)((0, substractNode_1.substract)(y, this.b), this.a).simplify();
+        return new point_1.Point(name ?? "P", x, y);
+    }
     //! caution: simplify ne gère pas bien ici
     getRandomPoint(name) {
         if (this.isVertical) {

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

@@ -36,5 +36,6 @@ export declare class Point {
     toMathString(): string;
     toGGBCommand({ isFixed, showLabel, style, size, color, }?: ToGGBCommandsProps): string[];
     rotate(angle: number, center: Point): Point;
+    centralSymetric(center: Point, name?: string): 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":"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;CAiBpC"}
+{"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"}