math-exercises 2.2.70 → 2.2.71

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"}

package/lib/math/geometry/point.js

@@ -136,5 +136,9 @@ class Point {
         const sin = Math.sin(angle);
         return new Point(this.name, (0, substractNode_1.substract)((0, multiplyNode_1.multiply)(cos, this.x).simplify(), (0, multiplyNode_1.multiply)(sin, this.y).simplify()).simplify(), (0, addNode_1.add)((0, multiplyNode_1.multiply)(sin, this.x).simplify(), (0, multiplyNode_1.multiply)(cos, this.y).simplify()).simplify());
     }
+    centralSymetric(center, name = this.name + "'") {
+        const vec = vector_1.VectorConstructor.fromPoints(this, center).opposite();
+        return vec.getEndPoint(center, name);
+    }
 }
 exports.Point = Point;

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

@@ -14,8 +14,11 @@ export declare class Vector {
     toTexWithCoords(): string;
     toInlineCoordsTex(): string;
     isColinear(v: Vector): boolean;
+    hasOppositeOrientation(v: Vector): boolean;
+    hasSameOrientation(v: Vector): boolean;
     determinant(v: Vector): AlgebraicNode;
     times(k: AlgebraicNode, name?: string): Vector;
+    opposite(): Vector;
     scalarProduct(v: Vector): AlgebraicNode;
     add(v: Vector): Vector;
     getNorm(): AlgebraicNode;

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

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

package/lib/math/geometry/vector.js

@@ -44,12 +44,21 @@ class Vector {
         const ev = det.evaluate();
         return Math.abs(ev) < 0.000001;
     }
+    hasOppositeOrientation(v) {
+        return this.isColinear(v) && this.scalarProduct(v).evaluate() < 0;
+    }
+    hasSameOrientation(v) {
+        return this.isColinear(v) && this.scalarProduct(v).evaluate() > 0;
+    }
     determinant(v) {
         return (0, substractNode_1.substract)((0, multiplyNode_1.multiply)(this.x, v.y), (0, multiplyNode_1.multiply)(this.y, v.x)).simplify();
     }
     times(k, name) {
         return new Vector(name ?? "v", new multiplyNode_1.MultiplyNode(this.x, k).simplify(), new multiplyNode_1.MultiplyNode(this.y, k).simplify());
     }
+    opposite() {
+        return this.times((-1).toTree());
+    }
     scalarProduct(v) {
         // if (
         //   [this.x.type, this.y.type, v.x.type, v.y.type].some(

package/lib/math/polynomials/generalAffine.d.ts

@@ -2,6 +2,9 @@ import { AlgebraicNode } from "../../tree/nodes/algebraicNode";
 import { NodeIdentifiers } from "../../tree/nodes/nodeConstructor";
 export declare abstract class GeneralAffineConstructor {
     static fromIdentifiers(identifiers: GeneralAffineIdentifiers): GeneralAffine;
+    static randomInts({ allowBNull }: {
+        allowBNull?: boolean | undefined;
+    }, variable?: string): GeneralAffine;
 }
 export type GeneralAffineIdentifiers = {
     id: "affine";

package/lib/math/polynomials/generalAffine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"generalAffine.d.ts","sourceRoot":"","sources":["../../../src/math/polynomials/generalAffine.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAG/D,OAAO,EAEL,eAAe,EAEhB,MAAM,kCAAkC,CAAC;AAQ1C,8BAAsB,wBAAwB;IAC5C,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,wBAAwB;CAM7D;AACD,MAAM,MAAM,wBAAwB,GAAG;IACrC,EAAE,EAAE,QAAQ,CAAC;IACb,CAAC,EAAE,eAAe,CAAC;IACnB,CAAC,EAAE,eAAe,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AACF,qBAAa,aAAa;IACxB,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;gBAGf,CAAC,EAAE,MAAM,GAAG,aAAa,EACzB,CAAC,EAAE,MAAM,GAAG,aAAa,EACzB,QAAQ,GAAE,MAAY;IAUxB,aAAa,IAAI,wBAAwB;IAQzC,OAAO,IAAI,aAAa;IAIxB,MAAM;IAMN,UAAU,CAAC,GAAG,EAAE,aAAa;IAI7B,QAAQ;CAMT"}
+{"version":3,"file":"generalAffine.d.ts","sourceRoot":"","sources":["../../../src/math/polynomials/generalAffine.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAG/D,OAAO,EAEL,eAAe,EAEhB,MAAM,kCAAkC,CAAC;AAS1C,8BAAsB,wBAAwB;IAC5C,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,wBAAwB;IAM5D,MAAM,CAAC,UAAU,CAAC,EAAE,UAAiB,EAAE;;KAAA,EAAE,QAAQ,SAAM;CAOxD;AACD,MAAM,MAAM,wBAAwB,GAAG;IACrC,EAAE,EAAE,QAAQ,CAAC;IACb,CAAC,EAAE,eAAe,CAAC;IACnB,CAAC,EAAE,eAAe,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AACF,qBAAa,aAAa;IACxB,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;gBAGf,CAAC,EAAE,MAAM,GAAG,aAAa,EACzB,CAAC,EAAE,MAAM,GAAG,aAAa,EACzB,QAAQ,GAAE,MAAY;IAUxB,aAAa,IAAI,wBAAwB;IAQzC,OAAO,IAAI,aAAa;IAIxB,MAAM;IAMN,UAAU,CAAC,GAAG,EAAE,aAAa;IAI7B,QAAQ;CAMT"}

package/lib/math/polynomials/generalAffine.js

@@ -7,10 +7,14 @@ const addNode_1 = require("../../tree/nodes/operators/addNode");
 const fractionNode_1 = require("../../tree/nodes/operators/fractionNode");
 const multiplyNode_1 = require("../../tree/nodes/operators/multiplyNode");
 const substractNode_1 = require("../../tree/nodes/operators/substractNode");
+const randint_1 = require("../utils/random/randint");
 class GeneralAffineConstructor {
     static fromIdentifiers(identifiers) {
         return new GeneralAffine((0, nodeConstructor_1.reifyAlgebraic)(identifiers.a), (0, nodeConstructor_1.reifyAlgebraic)(identifiers.b));
     }
+    static randomInts({ allowBNull = true }, variable = "x") {
+        return new GeneralAffine((0, randint_1.randint)(-10, 11, [0]), (0, randint_1.randint)(-10, 11, allowBNull ? [] : [0]), variable);
+    }
 }
 exports.GeneralAffineConstructor = GeneralAffineConstructor;
 class GeneralAffine {

package/lib/playground.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"playground.d.ts","sourceRoot":"","sources":["../src/playground.ts"],"names":[],"mappings":"AAgDA,eAAO,MAAM,UAAU,YAAW,CAAC"}
+{"version":3,"file":"playground.d.ts","sourceRoot":"","sources":["../src/playground.ts"],"names":[],"mappings":"AAoDA,eAAO,MAAM,UAAU,YAAW,CAAC"}

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

@@ -11,7 +11,8 @@ export declare enum NodeType {
     belongs = 9,
     vector = 10,
     set = 11,
-    trinom = 12
+    trinom = 12,
+    monom = 13
 }
 export type NodeOptions = {
     forceTimesSign?: boolean;
@@ -80,7 +81,8 @@ export declare enum NodeIds {
     inequation = 36,
     inequationSolution = 37,
     binomialCoefficient = 38,
-    trinom = 39
+    trinom = 39,
+    monom = 40
 }
 export interface Node {
     type: NodeType;

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

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

package/lib/tree/nodes/node.js

@@ -16,6 +16,7 @@ var NodeType;
     NodeType[NodeType["vector"] = 10] = "vector";
     NodeType[NodeType["set"] = 11] = "set";
     NodeType[NodeType["trinom"] = 12] = "trinom";
+    NodeType[NodeType["monom"] = 13] = "monom";
 })(NodeType || (exports.NodeType = NodeType = {}));
 var NodeIds;
 (function (NodeIds) {
@@ -59,4 +60,5 @@ var NodeIds;
     NodeIds[NodeIds["inequationSolution"] = 37] = "inequationSolution";
     NodeIds[NodeIds["binomialCoefficient"] = 38] = "binomialCoefficient";
     NodeIds[NodeIds["trinom"] = 39] = "trinom";
+    NodeIds[NodeIds["monom"] = 40] = "monom";
 })(NodeIds || (exports.NodeIds = NodeIds = {}));

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

@@ -1 +1 @@
-{"version":3,"file":"nodeConstructor.d.ts","sourceRoot":"","sources":["../../../src/tree/nodes/nodeConstructor.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAwBhD,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,QAAQ,CAAC;AAmBvC,eAAO,MAAM,cAAc,gBAAiB,eAAe,kBACI,CAAC;AAChE,eAAO,MAAM,SAAS,gBAAiB,eAAe,SACR,CAAC;AAC/C,MAAM,MAAM,eAAe,GAAG;IAAE,EAAE,EAAE,OAAO,CAAA;CAAE,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;AACpE,8BAAsB,eAAe;IACnC,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,eAAe,GAAG,IAAI;CA6R3D"}
+{"version":3,"file":"nodeConstructor.d.ts","sourceRoot":"","sources":["../../../src/tree/nodes/nodeConstructor.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAwBhD,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,QAAQ,CAAC;AAoBvC,eAAO,MAAM,cAAc,gBAAiB,eAAe,kBACI,CAAC;AAChE,eAAO,MAAM,SAAS,gBAAiB,eAAe,SACR,CAAC;AAE/C,MAAM,MAAM,eAAe,GAAG;IAAE,EAAE,EAAE,OAAO,CAAA;CAAE,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;AACpE,8BAAsB,eAAe;IACnC,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,eAAe,GAAG,IAAI;CAoS3D"}

package/lib/tree/nodes/nodeConstructor.js

@@ -38,6 +38,7 @@ const limitNode_1 = require("./operators/limitNode");
 const multiplyNode_1 = require("./operators/multiplyNode");
 const powerNode_1 = require("./operators/powerNode");
 const substractNode_1 = require("./operators/substractNode");
+const monomNode_1 = require("./polynomials/monomNode");
 const belongsNode_1 = require("./sets/belongsNode");
 const discreteSetNode_1 = require("./sets/discreteSetNode");
 const intervalNode_1 = require("./sets/intervalNode");
@@ -173,6 +174,9 @@ class NodeConstructor {
             case node_1.NodeIds.trinom: {
                 return new trinomNode_1.TrinomNode(NodeConstructor.fromIdentifiers(identifiers.a), NodeConstructor.fromIdentifiers(identifiers.b), NodeConstructor.fromIdentifiers(identifiers.c));
             }
+            case node_1.NodeIds.monom: {
+                return new monomNode_1.MonomNode(NodeConstructor.fromIdentifiers(identifiers.a), identifiers.degree, identifiers.opts);
+            }
             case node_1.NodeIds.binomialCoefficient: {
                 return new binomialCoefficientNode_1.BinomialCoefficientNode(NodeConstructor.fromIdentifiers(identifiers.leftChild), NodeConstructor.fromIdentifiers(identifiers.rightChild));
             }

package/lib/tree/nodes/operators/addNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"addNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/addNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAC7E,OAAO,EACL,uBAAuB,EACvB,WAAW,EAGZ,MAAM,gBAAgB,CAAC;AAKxB,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AASlE,wBAAgB,SAAS,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,OAAO,CAE/C;AAED,eAAO,MAAM,GAAG,MACX,aAAa,GAAG,MAAM,GAAG,MAAM,KAC/B,aAAa,GAAG,MAAM,GAAG,MAAM,YAOnC,CAAC;AAEF,qBAAa,OAAQ,YAAW,uBAAuB;IACrD,EAAE,EAAE,WAAW,CAAC;IAChB,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,aAAa,CAAC;IAC1B,IAAI,EAAE,QAAQ,CAAC;IACf,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,SAAS,EAAE,OAAO,CAAC;gBAEjB,SAAS,EAAE,aAAa,EACxB,UAAU,EAAE,aAAa,EACzB,IAAI,CAAC,EAAE,WAAW;IASpB,OAAO,aAGL;IAEF,YAAY,IAAI,MAAM;IAItB,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,aAAa,EAAE;IAoCtD,SAAS,IAAI,MAAM,EAAE;IAIrB,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAK5C,KAAK,CAAC,OAAO,CAAC,EAAE,YAAY,GAAG,MAAM;IAerC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAMtC,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe,GAAG,aAAa;IAqQ/C,aAAa;;;;;;;;;IAOb,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAUpC,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAMxD,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,aAAa;CAMxD"}
+{"version":3,"file":"addNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/addNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAC7E,OAAO,EACL,uBAAuB,EACvB,WAAW,EAGZ,MAAM,gBAAgB,CAAC;AAKxB,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAYlE,wBAAgB,SAAS,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,OAAO,CAE/C;AAED,eAAO,MAAM,GAAG,MACX,aAAa,GAAG,MAAM,GAAG,MAAM,KAC/B,aAAa,GAAG,MAAM,GAAG,MAAM,YAOnC,CAAC;AAEF,qBAAa,OAAQ,YAAW,uBAAuB;IACrD,EAAE,EAAE,WAAW,CAAC;IAChB,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,aAAa,CAAC;IAC1B,IAAI,EAAE,QAAQ,CAAC;IACf,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,SAAS,EAAE,OAAO,CAAC;gBAEjB,SAAS,EAAE,aAAa,EACxB,UAAU,EAAE,aAAa,EACzB,IAAI,CAAC,EAAE,WAAW;IASpB,OAAO,aAGL;IAEF,YAAY,IAAI,MAAM;IAItB,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,aAAa,EAAE;IAoCtD,SAAS,IAAI,MAAM,EAAE;IAIrB,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAK5C,KAAK,CAAC,OAAO,CAAC,EAAE,YAAY,GAAG,MAAM;IAerC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAMtC,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe,GAAG,aAAa;IAmI/C,aAAa;;;;;;;;;IAOb,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAUpC,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAMxD,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,aAAa;CAMxD"}

package/lib/tree/nodes/operators/addNode.js

@@ -15,6 +15,7 @@ const multiplyNode_1 = require("./multiplyNode");
 const fractionNode_1 = require("./fractionNode");
 const colorize_1 = require("../../../utils/latex/colorize");
 const round_1 = require("../../../math/utils/round");
+const monomNode_1 = require("../polynomials/monomNode");
 function isAddNode(a) {
     return (0, operatorNode_1.isOperatorNode)(a) && a.id === operatorNode_1.OperatorIds.add;
 }
@@ -130,96 +131,17 @@ class AddNode {
         if (externals.length === 1)
             return externals[0];
         const simplifyExternalNodes = (a, b) => {
-            if (!opts?.towardsDistribute && (0, fractionNode_1.isFractionNode)(a) && (0, fractionNode_1.isFractionNode)(b)) {
-                //c/d + e/f   =  cf+ed / df
-                const c = a.leftChild;
-                const d = a.rightChild;
-                const e = b.leftChild;
-                const f = b.rightChild;
-                return new fractionNode_1.FractionNode(new AddNode(new multiplyNode_1.MultiplyNode(c, f), new multiplyNode_1.MultiplyNode(e, d)), new multiplyNode_1.MultiplyNode(d, f)).simplify(opts);
-            }
-            if (!opts?.towardsDistribute &&
-                (0, oppositeNode_1.isOppositeNode)(a) &&
-                (0, fractionNode_1.isFractionNode)(a.child) &&
-                (0, fractionNode_1.isFractionNode)(b)) {
-                //-(c/d) + e/f   =  -cf+ed / df
-                const c = a.child.leftChild;
-                const d = a.child.rightChild;
-                const e = b.leftChild;
-                const f = b.rightChild;
-                return new fractionNode_1.FractionNode(new AddNode(new multiplyNode_1.MultiplyNode(new oppositeNode_1.OppositeNode(c), f), new multiplyNode_1.MultiplyNode(e, d)), new multiplyNode_1.MultiplyNode(d, f)).simplify(opts);
-            }
-            if (!opts?.towardsDistribute &&
-                (0, oppositeNode_1.isOppositeNode)(b) &&
-                (0, fractionNode_1.isFractionNode)(b.child) &&
-                (0, fractionNode_1.isFractionNode)(a)) {
-                //(c/d) + (-e/f)   =  cf-ed / df
-                const c = a.leftChild;
-                const d = a.rightChild;
-                const e = b.child.leftChild;
-                const f = b.child.rightChild;
-                return new fractionNode_1.FractionNode(new AddNode(new multiplyNode_1.MultiplyNode(c, f), new multiplyNode_1.MultiplyNode(new oppositeNode_1.OppositeNode(e), d)), new multiplyNode_1.MultiplyNode(d, f)).simplify(opts);
-            }
-            if (!opts?.towardsDistribute &&
-                (0, oppositeNode_1.isOppositeNode)(b) &&
-                (0, fractionNode_1.isFractionNode)(b.child) &&
-                (0, oppositeNode_1.isOppositeNode)(a) &&
-                (0, fractionNode_1.isFractionNode)(a.child)) {
-                //-(c/d) + (-e/f)   =  -cf-ed / df
-                const c = a.child.leftChild;
-                const d = a.child.rightChild;
-                const e = b.child.leftChild;
-                const f = b.child.rightChild;
-                return new fractionNode_1.FractionNode(new AddNode(new multiplyNode_1.MultiplyNode(new oppositeNode_1.OppositeNode(c), f), new multiplyNode_1.MultiplyNode(new oppositeNode_1.OppositeNode(e), d)), new multiplyNode_1.MultiplyNode(d, f)).simplify(opts);
-            }
-            if (!opts?.towardsDistribute && (0, fractionNode_1.isFractionNode)(a)) {
-                //c/d + b
-                const c = a.leftChild;
-                const d = a.rightChild;
-                return new fractionNode_1.FractionNode(new AddNode(c, new multiplyNode_1.MultiplyNode(d, b)), d).simplify(opts);
-            }
-            if (!opts?.towardsDistribute &&
-                (0, oppositeNode_1.isOppositeNode)(a) &&
-                (0, fractionNode_1.isFractionNode)(a.child)) {
-                //-(c/d) + b = (-c+bd)/d
-                const c = a.child.leftChild;
-                const d = a.child.rightChild;
-                return new fractionNode_1.FractionNode(new AddNode(new oppositeNode_1.OppositeNode(c), new multiplyNode_1.MultiplyNode(d, b)), d).simplify(opts);
-            }
-            if (!opts?.towardsDistribute &&
-                (0, fractionNode_1.isFractionNode)(b) &&
-                !opts?.forceDistributeFractions) {
-                //a+c/d
-                const c = b.leftChild;
-                const d = b.rightChild;
-                return new fractionNode_1.FractionNode(new AddNode(c, new multiplyNode_1.MultiplyNode(d, a)), d).simplify(opts);
-            }
-            if (!opts?.towardsDistribute &&
-                (0, oppositeNode_1.isOppositeNode)(b) &&
-                (0, fractionNode_1.isFractionNode)(b.child) &&
-                !opts?.forceDistributeFractions) {
-                //a+-(c/d) = (da-c)/d
-                const c = b.child.leftChild;
-                const d = b.child.rightChild;
-                return new fractionNode_1.FractionNode(new AddNode(new oppositeNode_1.OppositeNode(c), new multiplyNode_1.MultiplyNode(d, a)), d).simplify(opts);
-            }
-            if ((0, numberNode_1.isNumberNode)(a) && (0, numberNode_1.isNumberNode)(b)) {
-                //geogebra rounds to 12, il faut mettre <12
-                return new numberNode_1.NumberNode((0, round_1.round)(a.value + b.value, 10));
-            }
-            if ((0, oppositeNode_1.isOppositeNode)(a) && (0, numberNode_1.isNumberNode)(a.child) && (0, numberNode_1.isNumberNode)(b)) {
-                return new numberNode_1.NumberNode(-a.child.value + b.value);
-            }
-            if ((0, oppositeNode_1.isOppositeNode)(b) && (0, numberNode_1.isNumberNode)(b.child) && (0, numberNode_1.isNumberNode)(a)) {
-                return new numberNode_1.NumberNode(-b.child.value + a.value);
-            }
-            if ((0, oppositeNode_1.isOppositeNode)(a) &&
-                (0, numberNode_1.isNumberNode)(a.child) &&
-                (0, oppositeNode_1.isOppositeNode)(b) &&
-                (0, numberNode_1.isNumberNode)(b.child)) {
-                return new numberNode_1.NumberNode(a.child.value + b.child.value);
-            }
-            //gérer opposites, fractions
+            const fracSimplify = addSimplifyFrac(a, b, opts);
+            if (fracSimplify)
+                return fracSimplify;
+            const nbSimplify = addSimplifyNumbers(a, b, opts);
+            if (nbSimplify)
+                return nbSimplify;
+            const monomSimplify = addSimplifyMonoms(a, b, opts);
+            if (monomSimplify)
+                return monomSimplify;
+            //TODO gérer le reste
+            //la suite s'occupe des factorisations
             if (opts?.forbidFactorize)
                 return null;
             const aSubExternals = [];
@@ -338,3 +260,114 @@ class AddNode {
     }
 }
 exports.AddNode = AddNode;
+const addSimplifyFrac = (a, b, opts) => {
+    if (!opts?.towardsDistribute && (0, fractionNode_1.isFractionNode)(a) && (0, fractionNode_1.isFractionNode)(b)) {
+        //c/d + e/f   =  cf+ed / df
+        const c = a.leftChild;
+        const d = a.rightChild;
+        const e = b.leftChild;
+        const f = b.rightChild;
+        return new fractionNode_1.FractionNode(new AddNode(new multiplyNode_1.MultiplyNode(c, f), new multiplyNode_1.MultiplyNode(e, d)), new multiplyNode_1.MultiplyNode(d, f)).simplify(opts);
+    }
+    if (!opts?.towardsDistribute &&
+        (0, oppositeNode_1.isOppositeNode)(a) &&
+        (0, fractionNode_1.isFractionNode)(a.child) &&
+        (0, fractionNode_1.isFractionNode)(b)) {
+        //-(c/d) + e/f   =  -cf+ed / df
+        const c = a.child.leftChild;
+        const d = a.child.rightChild;
+        const e = b.leftChild;
+        const f = b.rightChild;
+        return new fractionNode_1.FractionNode(new AddNode(new multiplyNode_1.MultiplyNode(new oppositeNode_1.OppositeNode(c), f), new multiplyNode_1.MultiplyNode(e, d)), new multiplyNode_1.MultiplyNode(d, f)).simplify(opts);
+    }
+    if (!opts?.towardsDistribute &&
+        (0, oppositeNode_1.isOppositeNode)(b) &&
+        (0, fractionNode_1.isFractionNode)(b.child) &&
+        (0, fractionNode_1.isFractionNode)(a)) {
+        //(c/d) + (-e/f)   =  cf-ed / df
+        const c = a.leftChild;
+        const d = a.rightChild;
+        const e = b.child.leftChild;
+        const f = b.child.rightChild;
+        return new fractionNode_1.FractionNode(new AddNode(new multiplyNode_1.MultiplyNode(c, f), new multiplyNode_1.MultiplyNode(new oppositeNode_1.OppositeNode(e), d)), new multiplyNode_1.MultiplyNode(d, f)).simplify(opts);
+    }
+    if (!opts?.towardsDistribute &&
+        (0, oppositeNode_1.isOppositeNode)(b) &&
+        (0, fractionNode_1.isFractionNode)(b.child) &&
+        (0, oppositeNode_1.isOppositeNode)(a) &&
+        (0, fractionNode_1.isFractionNode)(a.child)) {
+        //-(c/d) + (-e/f)   =  -cf-ed / df
+        const c = a.child.leftChild;
+        const d = a.child.rightChild;
+        const e = b.child.leftChild;
+        const f = b.child.rightChild;
+        return new fractionNode_1.FractionNode(new AddNode(new multiplyNode_1.MultiplyNode(new oppositeNode_1.OppositeNode(c), f), new multiplyNode_1.MultiplyNode(new oppositeNode_1.OppositeNode(e), d)), new multiplyNode_1.MultiplyNode(d, f)).simplify(opts);
+    }
+    if (!opts?.towardsDistribute && (0, fractionNode_1.isFractionNode)(a)) {
+        //c/d + b
+        const c = a.leftChild;
+        const d = a.rightChild;
+        return new fractionNode_1.FractionNode(new AddNode(c, new multiplyNode_1.MultiplyNode(d, b)), d).simplify(opts);
+    }
+    if (!opts?.towardsDistribute &&
+        (0, oppositeNode_1.isOppositeNode)(a) &&
+        (0, fractionNode_1.isFractionNode)(a.child)) {
+        //-(c/d) + b = (-c+bd)/d
+        const c = a.child.leftChild;
+        const d = a.child.rightChild;
+        return new fractionNode_1.FractionNode(new AddNode(new oppositeNode_1.OppositeNode(c), new multiplyNode_1.MultiplyNode(d, b)), d).simplify(opts);
+    }
+    if (!opts?.towardsDistribute &&
+        (0, fractionNode_1.isFractionNode)(b) &&
+        !opts?.forceDistributeFractions) {
+        //a+c/d
+        const c = b.leftChild;
+        const d = b.rightChild;
+        return new fractionNode_1.FractionNode(new AddNode(c, new multiplyNode_1.MultiplyNode(d, a)), d).simplify(opts);
+    }
+    if (!opts?.towardsDistribute &&
+        (0, oppositeNode_1.isOppositeNode)(b) &&
+        (0, fractionNode_1.isFractionNode)(b.child) &&
+        !opts?.forceDistributeFractions) {
+        //a+-(c/d) = (da-c)/d
+        const c = b.child.leftChild;
+        const d = b.child.rightChild;
+        return new fractionNode_1.FractionNode(new AddNode(new oppositeNode_1.OppositeNode(c), new multiplyNode_1.MultiplyNode(d, a)), d).simplify(opts);
+    }
+};
+const addSimplifyNumbers = (a, b, opts) => {
+    if ((0, numberNode_1.isNumberNode)(a) && (0, numberNode_1.isNumberNode)(b)) {
+        //geogebra rounds to 12, il faut mettre <12
+        return new numberNode_1.NumberNode((0, round_1.round)(a.value + b.value, 10));
+    }
+    if ((0, oppositeNode_1.isOppositeNode)(a) && (0, numberNode_1.isNumberNode)(a.child) && (0, numberNode_1.isNumberNode)(b)) {
+        return new numberNode_1.NumberNode(-a.child.value + b.value);
+    }
+    if ((0, oppositeNode_1.isOppositeNode)(b) && (0, numberNode_1.isNumberNode)(b.child) && (0, numberNode_1.isNumberNode)(a)) {
+        return new numberNode_1.NumberNode(-b.child.value + a.value);
+    }
+    if ((0, oppositeNode_1.isOppositeNode)(a) &&
+        (0, numberNode_1.isNumberNode)(a.child) &&
+        (0, oppositeNode_1.isOppositeNode)(b) &&
+        (0, numberNode_1.isNumberNode)(b.child)) {
+        return new numberNode_1.NumberNode(a.child.value + b.child.value);
+    }
+};
+const addSimplifyMonoms = (a, b, opts) => {
+    const aMonom = (0, monomNode_1.parseToMonomNode)(a);
+    if (!aMonom)
+        return;
+    const bMonom = (0, monomNode_1.parseToMonomNode)(b);
+    if (!bMonom)
+        return;
+    if (aMonom.degree === bMonom.degree) {
+        if (aMonom.variable !== bMonom.variable)
+            return;
+        const sum = (0, exports.add)(aMonom.a, bMonom.a).simplify(opts);
+        if (sum.evaluate() === 0)
+            return new numberNode_1.NumberNode(0);
+        return new monomNode_1.MonomNode(sum, aMonom.degree, {
+            variable: aMonom.variable,
+        }).toTree();
+    }
+};