math-exercises 3.0.21 → 3.0.23

package/lib/exercises/math/spaceGeometry/basis/spaceCoordinatesInPrism.js

@@ -0,0 +1,141 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { SpacePoint } from "../../../../math/geometry/spacePoint.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { random } from "../../../../utils/alea/random.js";
+const getPoints = (identifiers) => {
+    const { l, L, h } = identifiers;
+    const zeroTree = (0).toTree();
+    const lTree = l.toTree();
+    const LTree = L.toTree();
+    const hTree = h.toTree();
+    return [
+        new SpacePoint("A", zeroTree, zeroTree, zeroTree),
+        new SpacePoint("B", zeroTree, lTree, zeroTree),
+        new SpacePoint("C", LTree, lTree, zeroTree),
+        new SpacePoint("D", LTree, zeroTree, zeroTree),
+        new SpacePoint("E", zeroTree, zeroTree, hTree),
+        new SpacePoint("F", zeroTree, lTree, hTree),
+        new SpacePoint("G", LTree, lTree, hTree),
+        new SpacePoint("H", LTree, zeroTree, hTree),
+    ];
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    const points = getPoints(identifiers);
+    addValidProp(propositions, answer);
+    while (propositions.length < n) {
+        tryToAddWrongProp(propositions, random(points).toCoords());
+    }
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const points = getPoints(identifiers);
+    return points.find((p) => p.name === identifiers.askedPoint).toCoords();
+};
+const getInstruction = (identifiers) => {
+    const { askedPoint, givenPoints } = identifiers;
+    const points = getPoints(identifiers);
+    return `On donne ci-dessous un parallélépipède rectangle dans l'espace rapporté à un repère. 
+  
+Les coordonnées du point $${givenPoints[0]}$ sont $${points
+        .find((p) => p.name === givenPoints[0])
+        .toCoords()}$.
+
+Les coordonnées du point $${givenPoints[1]}$ sont $${points
+        .find((p) => p.name === givenPoints[1])
+        .toCoords()}$.
+
+Quelles sont les coordonnées du point $${askedPoint}$ ?`;
+};
+// const getHint : GetHint<Identifiers> = (identifiers)=>{
+// }
+// const getCorrection : GetCorrection<Identifiers> = (identifiers)=>{
+// }
+const getGGBOptions = (identifiers) => {
+    const { askedPoint, givenPoints, L, l, h } = identifiers;
+    const points = getPoints(identifiers);
+    const commands = [
+        ...points.flatMap((p) => p.toGGBCommand({ color: "black", size: 2 })),
+        `P = Prism(${points
+            .slice(0, 5)
+            .map((p) => p.name)
+            .join(",")})`,
+        `SetVisibleInView(J, -1, false)`,
+        `SetVisibleInView(K, -1, false)`,
+        `SetVisibleInView(I, -1, false)`,
+        `SetColor(P, "#20000000")`,
+        `SetLineThickness(P, 1)`,
+    ];
+    const ggb = new GeogebraConstructor({
+        commands,
+        is3D: true,
+        xAxis: {
+            hideNumbers: true,
+            showPositive: true,
+        },
+        yAxis: {
+            hideNumbers: true,
+            showPositive: true,
+        },
+        zAxis: {
+            hideNumbers: true,
+            showPositive: true,
+        },
+        viewDirectionVector: [-1, -1, -1],
+    });
+    return ggb.getOptions({
+        coords: [0, L + 3, 0, l + 3, 0, h + 3],
+    });
+};
+const getKeys = (identifiers) => {
+    return ["semicolon"];
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+const getSpaceCoordinatesInPrismQuestion = (opts) => {
+    const l = randint(2, 10);
+    const L = randint(2, 10);
+    const h = randint(2, 10);
+    const letters = ["A", "B", "C", "D", "E", "F", "G", "H"];
+    const askedPoint = random(letters, ["A"]);
+    const givenPointOne = random(letters, ["A", askedPoint]);
+    const givenPointTwo = random(letters, ["A", askedPoint, givenPointOne]);
+    const identifiers = {
+        askedPoint,
+        givenPoints: [givenPointOne, givenPointTwo],
+        l,
+        L,
+        h,
+    };
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        // hint: getHint(identifiers),
+        // correction: getCorrection(identifiers),
+        ggbOptions: getGGBOptions(identifiers),
+    };
+    return question;
+};
+export const spaceCoordinatesInPrism = {
+    id: "spaceCoordinatesInPrism",
+    label: "Lire les coordonnées d'un point dans un parallélépipède",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getSpaceCoordinatesInPrismQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    // getHint,
+    // getCorrection,
+    getInstruction,
+    getAnswer,
+    getGGBOptions,
+    hasGeogebra: true,
+};

package/lib/exercises/math/spaceGeometry/index.d.ts

@@ -1,2 +1,3 @@
 export * from "./vectors/index.js";
+export * from "./basis/index.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/spaceGeometry/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/spaceGeometry/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/spaceGeometry/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,kBAAkB,CAAC"}

package/lib/exercises/math/spaceGeometry/index.js

@@ -1 +1,2 @@
 export * from "./vectors/index.js";
+export * from "./basis/index.js";

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,EAST,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AA0DF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAavD,CAAC"}
+{"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"}

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

@@ -1,5 +1,6 @@
 import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { numberVEA } from "../../../exercises/vea/numberVEA.js";
 import { randfloat } from "../../../math/utils/random/randfloat.js";
 import { randint } from "../../../math/utils/random/randint.js";
 import { CosNode } from "../../../tree/nodes/functions/cosNode.js";
@@ -7,16 +8,48 @@ 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 trigo = ["sin", "tan", "cos"];
+const getInstruction = (identifiers) => {
+    const { degree, trigoFunct } = identifiers;
+    const node = trigoFunct === "tan" ? TanNode : trigoFunct === "sin" ? SinNode : CosNode;
+    return `Calculer :
+  
+$$
+${new node(new DegreeNode(degree)).toTex()}
+$$
+
+Arrondir le résultat au centième.`;
+};
+const getAnswer = (identifiers) => {
+    let ans;
+    const { degree, trigoFunct } = identifiers;
+    switch (trigoFunct) {
+        case "cos":
+            const cos = new CosNode(degree.toTree());
+            ans = +cos.evaluate({}, { degreeMode: true }).toFixed(2);
+            return ans.toTree().toTex();
+        case "sin":
+            const sin = new SinNode(degree.toTree());
+            ans = +sin.evaluate({}, { degreeMode: true }).toFixed(2);
+            return ans.toTree().toTex();
+        case "tan":
+            const tan = new TanNode(degree.toTree());
+            ans = +tan.evaluate({}, { degreeMode: true }).toFixed(2);
+            return ans.toTree().toTex();
+        default:
+            return "";
+    }
+};
 const getCalculateCosSinAndTanQuestion = () => {
+    const trigo = ["sin", "tan", "cos"];
     const trigoFunct = random(trigo);
     const degree = randint(1, 180);
+    const identifiers = { degree, trigoFunct };
     const question = {
-        answer: getCorrectAnswer(degree, trigoFunct),
-        instruction: `Calculer $\\${trigoFunct}(${new DegreeNode(degree).toTex()})$, arrondir le résultat au dixième.`,
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
         keys: [],
         answerFormat: "tex",
-        identifiers: { degree, trigoFunct },
+        identifiers,
     };
     return question;
 };
@@ -32,33 +65,12 @@ const getPropositions = (n, { answer, degree }) => {
     return shuffleProps(propositions, n);
 };
 const isAnswerValid = (ans, { answer }) => {
-    return ans === answer;
-};
-const getCorrectAnswer = (degree, trigoFunct) => {
-    let ans;
-    switch (trigoFunct) {
-        case "cos":
-            const cos = new CosNode(degree.toTree());
-            ans = +cos.evaluate({}).toFixed(2);
-            return ans.toTree().toTex();
-        case "sin":
-            const sin = new SinNode(degree.toTree());
-            ans = +sin.evaluate({}).toFixed(2);
-            return ans.toTree().toTex();
-        case "tan":
-            const tan = new TanNode(degree.toTree());
-            ans = +tan.evaluate({}).toFixed(2);
-            return ans.toTree().toTex();
-        default:
-            return "";
-    }
+    return numberVEA(ans, answer);
 };
 export const calculateCosSinAndTan = {
     id: "calculateCosSinAndTan",
     label: "Calculer le cosinus/sinus/tangente d'un angle en degrés",
-    levels: ["3ème"],
     isSingleStep: true,
-    sections: ["Trigonométrie"],
     generator: (nb) => getDistinctQuestions(getCalculateCosSinAndTanQuestion, nb),
     qcmTimer: 60,
     freeTimer: 60,

package/lib/exercises/utils/geogebra/toGGBCommandsProps.d.ts

@@ -8,5 +8,6 @@ export type ToGGBCommandsProps = {
     color?: string;
     showLength?: boolean;
     label?: string;
+    thickness?: number;
 };
 //# sourceMappingURL=toGGBCommandsProps.d.ts.map

package/lib/exercises/utils/geogebra/toGGBCommandsProps.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"toGGBCommandsProps.d.ts","sourceRoot":"","sources":["../../../../src/exercises/utils/geogebra/toGGBCommandsProps.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,kBAAkB,GAAG;IAC/B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,yBAAyB,CAAC,EAAE,OAAO,CAAC;IACpC,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC"}
+{"version":3,"file":"toGGBCommandsProps.d.ts","sourceRoot":"","sources":["../../../../src/exercises/utils/geogebra/toGGBCommandsProps.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,kBAAkB,GAAG;IAC/B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,yBAAyB,CAAC,EAAE,OAAO,CAAC;IACpC,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC"}

package/lib/geogebra/geogebraConstructor.d.ts

@@ -25,6 +25,8 @@ export declare class GeogebraConstructor {
     lockedAxesRatio?: number | false;
     xAxis?: GeogebraAxisOptions;
     yAxis?: GeogebraAxisOptions;
+    zAxis?: GeogebraAxisOptions;
+    viewDirectionVector?: number[];
     constructor(options: Omit<GeogebraOptions, "coords">);
     getCoordsForPoints(points: Point[]): number[];
     getAdaptedCoords({ xMin, xMax, yMin, yMax, zMin, zMax, forceShowAxes, }: GetAdaptedCoords): number[];

package/lib/geogebra/geogebraConstructor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"geogebraConstructor.d.ts","sourceRoot":"","sources":["../../src/geogebra/geogebraConstructor.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,mBAAmB,EACnB,eAAe,EAChB,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAAE,KAAK,EAAE,MAAM,8BAA8B,CAAC;AAErD,KAAK,gBAAgB,GAAG;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB,CAAC;AACF,KAAK,eAAe,GAAG;IACrB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AACF,qBAAa,mBAAmB;IAC9B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,YAAY,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,KAAK,CAAC;IACxC,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,eAAe,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC;IACjC,KAAK,CAAC,EAAE,mBAAmB,CAAC;IAC5B,KAAK,CAAC,EAAE,mBAAmB,CAAC;gBAEhB,OAAO,EAAE,IAAI,CAAC,eAAe,EAAE,QAAQ,CAAC;IAcpD,kBAAkB,CAAC,MAAM,EAAE,KAAK,EAAE;IAOlC,gBAAgB,CAAC,EACf,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,aAAa,GACd,EAAE,gBAAgB;IAiDnB,UAAU,CAAC,EAAE,MAAM,EAAE,EAAE,eAAe,GAAG,eAAe;CAiBzD"}
+{"version":3,"file":"geogebraConstructor.d.ts","sourceRoot":"","sources":["../../src/geogebra/geogebraConstructor.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,mBAAmB,EACnB,eAAe,EAChB,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAAE,KAAK,EAAE,MAAM,8BAA8B,CAAC;AAErD,KAAK,gBAAgB,GAAG;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB,CAAC;AACF,KAAK,eAAe,GAAG;IACrB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AACF,qBAAa,mBAAmB;IAC9B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,YAAY,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,KAAK,CAAC;IACxC,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,eAAe,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC;IACjC,KAAK,CAAC,EAAE,mBAAmB,CAAC;IAC5B,KAAK,CAAC,EAAE,mBAAmB,CAAC;IAC5B,KAAK,CAAC,EAAE,mBAAmB,CAAC;IAC5B,mBAAmB,CAAC,EAAE,MAAM,EAAE,CAAC;gBAEnB,OAAO,EAAE,IAAI,CAAC,eAAe,EAAE,QAAQ,CAAC;IAgBpD,kBAAkB,CAAC,MAAM,EAAE,KAAK,EAAE;IAOlC,gBAAgB,CAAC,EACf,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,aAAa,GACd,EAAE,gBAAgB;IAiDnB,UAAU,CAAC,EAAE,MAAM,EAAE,EAAE,eAAe,GAAG,eAAe;CAmBzD"}

package/lib/geogebra/geogebraConstructor.js

@@ -12,6 +12,8 @@ export class GeogebraConstructor {
     lockedAxesRatio;
     xAxis;
     yAxis;
+    zAxis;
+    viewDirectionVector;
     constructor(options) {
         this.customToolBar = options?.customToolBar ?? toolBarConstructor({});
         this.forbidShiftDragZoom = options?.forbidShiftDragZoom ?? false;
@@ -25,6 +27,8 @@ export class GeogebraConstructor {
         this.lockedAxesRatio = options?.lockedAxesRatio ?? 1;
         this.xAxis = options?.xAxis;
         this.yAxis = options?.yAxis;
+        this.zAxis = options?.zAxis;
+        this.viewDirectionVector = options?.viewDirectionVector;
     }
     getCoordsForPoints(points) {
         const xMin = Math.min(...points.map((p) => p.x.evaluate()));
@@ -97,6 +101,8 @@ export class GeogebraConstructor {
             lockedAxesRatio: this.lockedAxesRatio,
             xAxis: this.xAxis,
             yAxis: this.yAxis,
+            zAxis: this.zAxis,
+            viewDirectionVector: this.viewDirectionVector,
         };
     }
 }

package/lib/index.d.ts

@@ -1260,6 +1260,11 @@ declare const mathExercises: (Exercise<{
 }, {}> | Exercise<{
     type: number;
     commands: string[];
+}, {}> | Exercise<{
+    isAskingLength: boolean;
+    isSegmentHeight: boolean;
+    pointsIdentifiers: import("./math/geometry/point.js").PointIdentifiers[];
+    lengths: number[];
 }, {}> | Exercise<{
     startPoint: number[];
     vector: number[];
@@ -1720,6 +1725,12 @@ declare const mathExercises: (Exercise<{
     y: number;
     z: number;
 }, {}> | Exercise<{}, {}> | Exercise<{}, {}> | Exercise<{
+    l: number;
+    L: number;
+    h: number;
+    askedPoint: string;
+    givenPoints: string[];
+}, {}> | Exercise<{
     sqrtOperand: number;
 }, {}> | Exercise<{
     k: 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/segment.d.ts

@@ -35,8 +35,12 @@ export declare class Segment {
     toTex(): string;
     toInsideName(): string;
     toLengthTex(): string;
-    getFitCaptionCommands(text?: string, color?: string): string[];
-    toGGBCommands(shouldBuildPoints: boolean, { isFixed, showLabel, showUnderlyingPointsLabel, showLength, style, }?: ToGGBCommandsProps): string[];
+    getFitCaptionCommands({ text, color, size, }?: {
+        text?: string;
+        color?: string;
+        size?: "scriptsize" | "tiny" | "small" | "large";
+    }): string[];
+    toGGBCommands(shouldBuildPoints: boolean, { isFixed, showLabel, showUnderlyingPointsLabel, showLength, style, thickness, }?: ToGGBCommandsProps): string[];
     includes(point: Point): boolean;
     toVector(): Vector;
 }

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,sDAAsD,CAAC;AAE1F,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAElE,OAAO,EAEL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAK7C,OAAO,EAAE,KAAK,EAAoB,gBAAgB,EAAE,MAAM,YAAY,CAAC;AACvE,OAAO,EAAE,MAAM,EAAqB,MAAM,aAAa,CAAC;AAExD,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"}
+{"version":3,"file":"segment.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/segment.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,sDAAsD,CAAC;AAE1F,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAElE,OAAO,EAEL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAK7C,OAAO,EAAE,KAAK,EAAoB,gBAAgB,EAAE,MAAM,YAAY,CAAC;AACvE,OAAO,EAAE,MAAM,EAAqB,MAAM,aAAa,CAAC;AAExD,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,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;IAiBN,aAAa,CACX,iBAAiB,EAAE,OAAO,EAC1B,EACE,OAAc,EACd,SAAiB,EACjB,yBAAgC,EAChC,UAAkB,EAClB,KAAK,EACL,SAAS,GACV,GAAE,kBAAuB;IAgC5B,QAAQ,CAAC,KAAK,EAAE,KAAK;IAOrB,QAAQ;CAGT"}

package/lib/math/geometry/segment.js

@@ -74,20 +74,22 @@ export class Segment {
     toLengthTex() {
         return `${this.toInsideName()} = ${this.getLengthNode().toTex()}`;
     }
-    getFitCaptionCommands(text, color) {
+    getFitCaptionCommands({ text, color, size, } = {}) {
         const txt = text ?? this.getLength().frenchify();
         const midPoint = this.getMidpoint().toMathString();
         const cmds = [
-            `angle_{${this.name}} = Angle(Vector(${this.pointA.name}, ${this.pointB.name}))`,
-            `SetVisibleInView(angle_{${this.name}}, 1, false)`,
-            `text_{${this.name}} = Text(RotateText("${txt}", If(angle_{${this.name}} > 90° ∧ angle_{${this.name}} < 270°, angle_{${this.name}} + 180°, angle_{${this.name}})), ${midPoint}, true, true, 0, 0)`,
+            // `angle_{${this.name}} = Angle(Vector(${this.pointA.name}, ${this.pointB.name}))`,
+            // `SetVisibleInView(angle_{${this.name}}, 1, false)`,
+            // `text_{${this.name}} = Text(RotateText("${txt}", If(angle_{${this.name}} > 90° ∧ angle_{${this.name}} < 270°, angle_{${this.name}} + 180°, angle_{${this.name}})), ${midPoint}, true, true, 0, 0)`,
+            `text_{${this.name}} = Text("${size ? `\\${size}` : ""} ${txt}", ${midPoint}, true, true, 0, 0)`,
+            // `SetBackgroundColor(text_{${this.name}}, "white")`,
         ];
         if (color) {
             cmds.push(`SetColor(text_{${this.name}}, "${color}")`);
         }
         return cmds;
     }
-    toGGBCommands(shouldBuildPoints, { isFixed = true, showLabel = false, showUnderlyingPointsLabel = true, showLength = false, style, } = {}) {
+    toGGBCommands(shouldBuildPoints, { isFixed = true, showLabel = false, showUnderlyingPointsLabel = true, showLength = false, style, thickness, } = {}) {
         const commands = [
             `${this.ggbName}=Segment(${this.pointA.name},${this.pointB.name})`,
             `SetFixed(${this.ggbName},${isFixed ? "true" : "false"})`,
@@ -98,9 +100,12 @@ export class Segment {
         }
         if (showLength) {
             const length = this.getLengthNode().toTex();
-            commands.push(`SetCaption(${this.ggbName}, ${length})`);
+            commands.push(`SetCaption(${this.ggbName}, "${length}")`);
             commands.push(`ShowLabel(${this.ggbName}, true)`);
         }
+        if (thickness !== undefined) {
+            commands.push(`SetLineThickness(${this.ggbName}, ${thickness})`);
+        }
         if (shouldBuildPoints) {
             const ACommands = this.pointA.toGGBCommand({
                 isFixed,

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

@@ -1,4 +1,5 @@
 import { AlgebraicNode } from "../../tree/nodes/algebraicNode.js";
+import { ToGGBCommandsProps } from "../../exercises/utils/geogebra/toGGBCommandsProps.js";
 type AleaBound = {
     min?: number;
     max?: number;
@@ -24,7 +25,7 @@ export declare class SpacePoint {
     distanceTo(B: SpacePoint): number;
     equals(B: SpacePoint): boolean;
     isAligned(B: SpacePoint, C: SpacePoint): void;
-    toGGBCommand(): string;
+    toGGBCommand({ isFixed, showLabel, style, size, color, }?: ToGGBCommandsProps): string[];
 }
 export {};
 //# sourceMappingURL=spacePoint.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"spacePoint.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/spacePoint.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAIlE,KAAK,SAAS,GAAG;IAAE,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC;AACrE,8BAAsB,qBAAqB;IACzC,MAAM,CAAC,MAAM,CACX,IAAI,EAAE,MAAM,EACZ,KAAK,CAAC,EAAE,SAAS,EACjB,KAAK,CAAC,EAAE,SAAS,EACjB,KAAK,CAAC,EAAE,SAAS,GAChB,UAAU;IAyBb,MAAM,CAAC,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE;IA4BtC,MAAM,CAAC,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE,IAAI,GAAE,MAAY;CAWrD;AAED,qBAAa,UAAU;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;gBAEf,IAAI,EAAE,MAAM,EACZ,CAAC,EAAE,aAAa,EAChB,CAAC,EAAE,aAAa,EAChB,CAAC,EAAE,aAAa;IAQlB,SAAS;IAGT,kBAAkB;IAIlB,KAAK,IAAI,MAAM;IAIf,eAAe,IAAI,MAAM;IAKzB,QAAQ,IAAI,MAAM;IAIlB,QAAQ,CAAC,CAAC,EAAE,UAAU,EAAE,IAAI,SAAM,GAAG,UAAU;IAkB/C,UAAU,CAAC,CAAC,EAAE,UAAU,GAAG,MAAM;IAIjC,MAAM,CAAC,CAAC,EAAE,UAAU,GAAG,OAAO;IAG9B,SAAS,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,UAAU;IAOtC,YAAY;CAKb"}
+{"version":3,"file":"spacePoint.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/spacePoint.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAGlE,OAAO,EAAE,kBAAkB,EAAE,MAAM,sDAAsD,CAAC;AAE1F,KAAK,SAAS,GAAG;IAAE,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC;AACrE,8BAAsB,qBAAqB;IACzC,MAAM,CAAC,MAAM,CACX,IAAI,EAAE,MAAM,EACZ,KAAK,CAAC,EAAE,SAAS,EACjB,KAAK,CAAC,EAAE,SAAS,EACjB,KAAK,CAAC,EAAE,SAAS,GAChB,UAAU;IAyBb,MAAM,CAAC,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE;IA4BtC,MAAM,CAAC,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE,IAAI,GAAE,MAAY;CAWrD;AAED,qBAAa,UAAU;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;gBAEf,IAAI,EAAE,MAAM,EACZ,CAAC,EAAE,aAAa,EAChB,CAAC,EAAE,aAAa,EAChB,CAAC,EAAE,aAAa;IAQlB,SAAS;IAGT,kBAAkB;IAIlB,KAAK,IAAI,MAAM;IAIf,eAAe,IAAI,MAAM;IAKzB,QAAQ,IAAI,MAAM;IAIlB,QAAQ,CAAC,CAAC,EAAE,UAAU,EAAE,IAAI,SAAM,GAAG,UAAU;IAkB/C,UAAU,CAAC,CAAC,EAAE,UAAU,GAAG,MAAM;IAIjC,MAAM,CAAC,CAAC,EAAE,UAAU,GAAG,OAAO;IAG9B,SAAS,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,UAAU;IAOtC,YAAY,CAAC,EACX,OAAc,EACd,SAAgB,EAChB,KAAK,EACL,IAAI,EACJ,KAAK,GACN,GAAE,kBAAuB;CAmB3B"}

package/lib/math/geometry/spacePoint.js

@@ -85,7 +85,21 @@ export class SpacePoint {
         // return AB.isColinear(AC);
         throw Error("unimplemented");
     }
-    toGGBCommand() {
-        return `${this.name} = (${this.x.toMathString()}, ${this.y.toMathString()}, ${this.z.toMathString()}})`;
+    toGGBCommand({ isFixed = true, showLabel = true, style, size, color, } = {}) {
+        const commands = [
+            `${this.name} = (${this.x.toMathString()}, ${this.y.toMathString()}, ${this.z.toMathString()})`,
+            `SetFixed(${this.name},${isFixed ? "true" : "false"})`,
+            `ShowLabel(${this.name},${showLabel ? "true" : "false"})`,
+        ];
+        if (style !== undefined) {
+            commands.push(`SetPointStyle(${this.name}, ${style})`);
+        }
+        if (size) {
+            commands.push(`SetPointSize(${this.name}, ${size})`);
+        }
+        if (color) {
+            commands.push(`SetColor(${this.name}, "${color}")`);
+        }
+        return commands;
     }
 }

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

@@ -9,10 +9,11 @@ export type TriangleIdentifiers = {
 };
 export declare abstract class TriangleConstructor {
     static fromIdentifiers(identifiers: TriangleIdentifiers): Triangle;
-    static randomNiceSides({ names, randomName, intSides, }: {
+    static randomNiceSides({ names, randomName, intSides, minAngle, }: {
         names?: string[] | undefined;
         randomName?: boolean | undefined;
         intSides?: boolean | undefined;
+        minAngle?: number | undefined;
     }): Triangle;
     static randomName(): string[];
 }

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

@@ -1 +1 @@
-{"version":3,"file":"triangle.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/triangle.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAoB,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAEvE,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAKnC,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,GACjB;;;;KAAA,GAAG,QAAQ;IA8BZ,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;IAyClD,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;IAWH,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;CAkB3B"}
+{"version":3,"file":"triangle.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/triangle.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAoB,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAEvE,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAKnC,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;IAyClD,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;CAkB3B"}

package/lib/math/geometry/triangle.js

@@ -16,23 +16,38 @@ export class TriangleConstructor {
             sidesLengths: identifiers.props?.sidesLengths?.map((n) => n ? reifyAlgebraic(n) : undefined),
         });
     }
-    static randomNiceSides({ names = ["A", "B", "C"], randomName = false, intSides = false, }) {
+    static randomNiceSides({ names = ["A", "B", "C"], randomName = false, intSides = false, minAngle = 0, }) {
         let vertices = [];
         if (randomName)
             vertices = TriangleConstructor.randomName();
         else
             vertices = names;
-        const angle = randfloat(0, 2 * Math.PI);
-        const addAngle = randfloat(Math.PI / 4, (3 * Math.PI) / 4);
-        //on construit [AC] sur (Ox) de milieu O et de taille 2*xRand
-        //puis [AB] sur (Ox) qu'on rotate
-        const xRand = intSides ? randint(5, 9) : randfloat(5, 8, 1);
-        const xRand2 = intSides ? randint(-5, 5) : randfloat(-5, 5, 1);
-        const origin = new Point("O", (0).toTree(), (0).toTree());
-        const startA = new Point(vertices[0], (-xRand).toTree(), (0).toTree());
-        const A = startA.rotate(angle, origin);
-        const C = new Point(vertices[2], xRand.toTree(), (0).toTree()).rotate(angle, origin);
-        const B = new Point(vertices[1], (-xRand + xRand2).toTree(), (0).toTree()).rotate(angle + addAngle, startA);
+        let A;
+        let B;
+        let C;
+        const anglesAreNice = () => {
+            const values = [
+                new Angle([C, B, A]).evaluate(),
+                new Angle([A, C, B]).evaluate(),
+                new Angle([B, A, C]).evaluate(),
+            ];
+            if (minAngle)
+                return values.every((v) => v > minAngle && v < 180 - minAngle);
+            return values.every((v) => v > 20 && v < 110);
+        };
+        do {
+            const angle = randfloat(0, 2 * Math.PI);
+            const addAngle = randfloat(Math.PI / 4, (3 * Math.PI) / 4);
+            //on construit [AC] sur (Ox) de milieu O et de taille 2*xRand
+            //puis [AB] sur (Ox) qu'on rotate
+            const xRand = intSides ? randint(5, 9) : randfloat(5, 8, 1);
+            const xRand2 = intSides ? randint(-5, 5) : randfloat(-5, 5, 1);
+            const origin = new Point("O", (0).toTree(), (0).toTree());
+            const startA = new Point(vertices[0], (-xRand).toTree(), (0).toTree());
+            A = startA.rotate(angle, origin);
+            C = new Point(vertices[2], xRand.toTree(), (0).toTree()).rotate(angle, origin);
+            B = new Point(vertices[1], (-xRand + xRand2).toTree(), (0).toTree()).rotate(angle + addAngle, startA);
+        } while (!anglesAreNice());
         return new Triangle([A, B, C], {
             sidesLengths: [
                 round(B.distanceTo(C), intSides ? 0 : 1).toTree(),
@@ -138,7 +153,10 @@ export class Triangle {
         if (opts.color)
             this.commands.push(`SetColor(${side.ggbName}, "${opts.color}")`);
         if (opts.caption) {
-            this.commands.push(...side.getFitCaptionCommands(opts.caption, opts.color));
+            this.commands.push(...side.getFitCaptionCommands({
+                text: opts.caption,
+                color: opts.color,
+            }));
         }
     }
     highlightAngle(index, opts) {

package/lib/math/spaceGeometry/prism.d.ts

@@ -0,0 +1,4 @@
+export declare class Prism {
+    constructor();
+}
+//# sourceMappingURL=prism.d.ts.map

package/lib/math/spaceGeometry/prism.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prism.d.ts","sourceRoot":"","sources":["../../../src/math/spaceGeometry/prism.ts"],"names":[],"mappings":"AAAA,qBAAa,KAAK;;CAEjB"}

package/lib/math/spaceGeometry/prism.js

@@ -0,0 +1,3 @@
+export class Prism {
+    constructor() { }
+}

package/lib/tree/nodes/algebraicNode.d.ts

@@ -12,8 +12,11 @@ export type SimplifyOptions = {
     forbidAdditions?: boolean;
     forbidTrigo?: boolean;
 };
+export type EvaluateOptions = {
+    degreeMode?: boolean;
+};
 export interface AlgebraicNode extends Node {
-    evaluate: (vars?: Record<string, number>) => number;
+    evaluate: (vars?: Record<string, number>, opts?: EvaluateOptions) => number;
     toDetailedEvaluation: (vars: Record<string, AlgebraicNode>) => AlgebraicNode;
     toEquivalentNodes: (opts?: NodeOptions) => AlgebraicNode[];
     simplify: (opts?: SimplifyOptions) => AlgebraicNode;

package/lib/tree/nodes/algebraicNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"algebraicNode.d.ts","sourceRoot":"","sources":["../../../src/tree/nodes/algebraicNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAE9C,MAAM,MAAM,eAAe,GAAG;IAC5B,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,wBAAwB,CAAC,EAAE,OAAO,CAAC;IACnC,UAAU,CAAC,EAAE,OAAO,CAAC;IAErB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,kCAAkC,CAAC,EAAE,OAAO,CAAC;IAC7C,uBAAuB,CAAC,EAAE,OAAO,CAAC;IAClC,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB,CAAC;AACF,MAAM,WAAW,aAAc,SAAQ,IAAI;IACzC,QAAQ,EAAE,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK,MAAM,CAAC;IACpD,oBAAoB,EAAE,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,KAAK,aAAa,CAAC;IAC7E,iBAAiB,EAAE,CAAC,IAAI,CAAC,EAAE,WAAW,KAAK,aAAa,EAAE,CAAC;IAC3D,QAAQ,EAAE,CAAC,IAAI,CAAC,EAAE,eAAe,KAAK,aAAa,CAAC;IACpD,MAAM,EAAE,CAAC,IAAI,EAAE,aAAa,KAAK,OAAO,CAAC;IACzC,SAAS,EAAE,OAAO,CAAC;IACnB,UAAU,EAAE,CAAC,OAAO,CAAC,EAAE,MAAM,KAAK,aAAa,CAAC;CACjD;AACD,8BAAsB,cAAc;;IAElC,OAAO,CAAC,MAAM,CAAC,QAAQ;CAGxB;AACD,eAAO,MAAM,eAAe,SAAU,IAAI,KAAG,IAAI,IAAI,aACX,CAAC"}
+{"version":3,"file":"algebraicNode.d.ts","sourceRoot":"","sources":["../../../src/tree/nodes/algebraicNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAE9C,MAAM,MAAM,eAAe,GAAG;IAC5B,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,wBAAwB,CAAC,EAAE,OAAO,CAAC;IACnC,UAAU,CAAC,EAAE,OAAO,CAAC;IAErB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,kCAAkC,CAAC,EAAE,OAAO,CAAC;IAC7C,uBAAuB,CAAC,EAAE,OAAO,CAAC;IAClC,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG;IAC5B,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB,CAAC;AACF,MAAM,WAAW,aAAc,SAAQ,IAAI;IACzC,QAAQ,EAAE,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,IAAI,CAAC,EAAE,eAAe,KAAK,MAAM,CAAC;IAC5E,oBAAoB,EAAE,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,KAAK,aAAa,CAAC;IAC7E,iBAAiB,EAAE,CAAC,IAAI,CAAC,EAAE,WAAW,KAAK,aAAa,EAAE,CAAC;IAC3D,QAAQ,EAAE,CAAC,IAAI,CAAC,EAAE,eAAe,KAAK,aAAa,CAAC;IACpD,MAAM,EAAE,CAAC,IAAI,EAAE,aAAa,KAAK,OAAO,CAAC;IACzC,SAAS,EAAE,OAAO,CAAC;IACnB,UAAU,EAAE,CAAC,OAAO,CAAC,EAAE,MAAM,KAAK,aAAa,CAAC;CACjD;AACD,8BAAsB,cAAc;;IAElC,OAAO,CAAC,MAAM,CAAC,QAAQ;CAGxB;AACD,eAAO,MAAM,eAAe,SAAU,IAAI,KAAG,IAAI,IAAI,aACX,CAAC"}

package/lib/tree/nodes/functions/cosNode.d.ts

@@ -1,6 +1,6 @@
 import { Node, NodeIds, NodeType } from "../node.js";
 import { FunctionNode, FunctionsIds } from "./functionNode.js";
-import { AlgebraicNode, SimplifyOptions } from "../algebraicNode.js";
+import { AlgebraicNode, EvaluateOptions, SimplifyOptions } from "../algebraicNode.js";
 export declare function isCosNode(a: Node): a is CosNode;
 export declare const cos: (a: AlgebraicNode | number | string) => CosNode;
 export declare class CosNode implements FunctionNode {
@@ -20,7 +20,7 @@ export declare class CosNode implements FunctionNode {
     toEquivalentNodes(): AlgebraicNode[];
     toAllValidTexs(): string[];
     simplify(opts?: SimplifyOptions): AlgebraicNode;
-    evaluate(vars?: Record<string, number>): number;
+    evaluate(vars?: Record<string, number>, opts?: EvaluateOptions): number;
     equals(node: AlgebraicNode): boolean;
     toDetailedEvaluation(vars: Record<string, AlgebraicNode>): CosNode;
     derivative(varName?: string | undefined): AlgebraicNode;

package/lib/tree/nodes/functions/cosNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cosNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/functions/cosNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACrD,OAAO,EAAE,YAAY,EAAE,YAAY,EAAkB,MAAM,mBAAmB,CAAC;AAC/E,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAIrE,wBAAgB,SAAS,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,OAAO,CAE/C;AAED,eAAO,MAAM,GAAG,MAAO,aAAa,GAAG,MAAM,GAAG,MAAM,YAIrD,CAAC;AAEF,qBAAa,OAAQ,YAAW,YAAY;IAC1C,EAAE,EAAE,YAAY,CAAC;IACjB,KAAK,EAAE,aAAa,CAAC;IACrB,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;gBAEP,KAAK,EAAE,aAAa;IAMhC,aAAa;;;;;;IAMb,YAAY,IAAI,MAAM;IAItB,KAAK,IAAI,MAAM;IAIf,iBAAiB,IAAI,aAAa,EAAE;IASpC,cAAc,IAAI,MAAM,EAAE;IAI1B,QAAQ,CAAC,IAAI,GAAE,eAAoB,GAAG,aAAa;IAyBnD,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAItC,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAGpC,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAGxD,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,aAAa;CAGxD"}
+{"version":3,"file":"cosNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/functions/cosNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACrD,OAAO,EAAE,YAAY,EAAE,YAAY,EAAkB,MAAM,mBAAmB,CAAC;AAC/E,OAAO,EACL,aAAa,EACb,eAAe,EACf,eAAe,EAChB,MAAM,qBAAqB,CAAC;AAI7B,wBAAgB,SAAS,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,OAAO,CAE/C;AAED,eAAO,MAAM,GAAG,MAAO,aAAa,GAAG,MAAM,GAAG,MAAM,YAIrD,CAAC;AAEF,qBAAa,OAAQ,YAAW,YAAY;IAC1C,EAAE,EAAE,YAAY,CAAC;IACjB,KAAK,EAAE,aAAa,CAAC;IACrB,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;gBAEP,KAAK,EAAE,aAAa;IAMhC,aAAa;;;;;;IAMb,YAAY,IAAI,MAAM;IAItB,KAAK,IAAI,MAAM;IAIf,iBAAiB,IAAI,aAAa,EAAE;IASpC,cAAc,IAAI,MAAM,EAAE;IAI1B,QAAQ,CAAC,IAAI,GAAE,eAAoB,GAAG,aAAa;IAyBnD,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,IAAI,CAAC,EAAE,eAAe;IAO9D,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAGpC,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAGxD,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,aAAa;CAGxD"}