math-exercises 1.3.55 → 1.3.57

package/lib/math/numbers/rationals/rational.d.ts

@@ -1,26 +1,26 @@
-import { Node } from '../../../tree/nodes/node';
-import { Nombre, NumberType } from '../nombre';
-export declare abstract class RationalConstructor {
-    /**
-     * @param maxGcd max number by which the fraction is simplifiable
-     */
-    static randomSimplifiable(maxGcd?: number): Rational;
-    static randomIrreductible(max?: number): Rational;
-}
-export declare class Rational implements Nombre {
-    num: number;
-    denum: number;
-    tex: string;
-    value: number;
-    isSimplified: boolean;
-    type: NumberType;
-    constructor(numerator: number, denumerator: number);
-    toTex(): string;
-    add(nb: Nombre): Nombre;
-    multiply(nb: Nombre): Nombre;
-    divide(nb: Nombre): Nombre;
-    opposite(): Rational;
-    toTree(): Node;
-    simplify(): Nombre;
-}
+import { Node } from '../../../tree/nodes/node';
+import { Nombre, NumberType } from '../nombre';
+export declare abstract class RationalConstructor {
+    /**
+     * @param maxGcd max number by which the fraction is simplifiable
+     */
+    static randomSimplifiable(maxGcd?: number): Rational;
+    static randomIrreductible(max?: number): Rational;
+}
+export declare class Rational implements Nombre {
+    num: number;
+    denum: number;
+    tex: string;
+    value: number;
+    isSimplified: boolean;
+    type: NumberType;
+    constructor(numerator: number, denumerator: number);
+    toTex(): string;
+    add(nb: Nombre): Nombre;
+    multiply(nb: Nombre): Nombre;
+    divide(nb: Nombre): Nombre;
+    opposite(): Rational;
+    toTree(): Node;
+    simplify(): Nombre;
+}
 //# sourceMappingURL=rational.d.ts.map

package/lib/math/numbers/rationals/rational.js

@@ -1,113 +1,113 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Rational = exports.RationalConstructor = void 0;
-const coprimesOf_1 = require("../../../math/utils/arithmetic/coprimesOf");
-const gcd_1 = require("../../../math/utils/arithmetic/gcd");
-const lcd_1 = require("../../../math/utils/arithmetic/lcd");
-const randint_1 = require("../../../math/utils/random/randint");
-const numberNode_1 = require("../../../tree/nodes/numbers/numberNode");
-const fractionNode_1 = require("../../../tree/nodes/operators/fractionNode");
-const random_1 = require("../../../utils/random");
-const shuffle_1 = require("../../../utils/shuffle");
-const integer_1 = require("../integer/integer");
-const nombre_1 = require("../nombre");
-class RationalConstructor {
-    /**
-     * @param maxGcd max number by which the fraction is simplifiable
-     */
-    static randomSimplifiable(maxGcd = 10) {
-        const gcd = (0, randint_1.randint)(2, maxGcd);
-        const max = (0, randint_1.randint)(3, 11);
-        const min = (0, random_1.random)((0, coprimesOf_1.coprimesOf)(max));
-        let [num, denum] = (0, shuffle_1.shuffle)([gcd * min, gcd * max]);
-        if (denum === gcd) {
-            //si 10/2 on transforme en 2/10
-            return new Rational(denum, num);
-        }
-        return new Rational(num, denum);
-    }
-    static randomIrreductible(max = 11) {
-        const a = (0, randint_1.randint)(2, max);
-        const b = (0, random_1.random)([...(0, coprimesOf_1.coprimesOf)(a), 1]);
-        if (b === 1)
-            return new Rational(b, a);
-        const [num, denum] = (0, shuffle_1.shuffle)([a, b]);
-        return new Rational(num, denum);
-    }
-}
-exports.RationalConstructor = RationalConstructor;
-class Rational {
-    constructor(numerator, denumerator) {
-        if (denumerator === 0)
-            throw Error('division by zero');
-        this.num = numerator;
-        this.denum = denumerator;
-        this.value = numerator / denumerator;
-        this.isSimplified = Math.abs((0, gcd_1.gcd)(numerator, denumerator)) === 1;
-        this.tex = `\\frac{${this.num}}{${this.denum}}`;
-        this.type = nombre_1.NumberType.Rational;
-    }
-    toTex() {
-        return `\\frac{${this.num}}{${this.denum}}`;
-    }
-    add(nb) {
-        switch (nb.type) {
-            case nombre_1.NumberType.Integer: {
-                const num = this.num + this.denum * nb.value;
-                return new Rational(num, this.denum).simplify();
-            }
-            case nombre_1.NumberType.Rational: {
-                const rational = nb;
-                const ppcm = (0, lcd_1.lcd)(rational.denum, this.denum);
-                const num = this.num * (ppcm / this.denum) + rational.num * (ppcm / rational.denum);
-                return new Rational(num, ppcm).simplify();
-            }
-        }
-        throw Error('not implemented yet');
-    }
-    multiply(nb) {
-        switch (nb.type) {
-            case nombre_1.NumberType.Integer: {
-                const num = this.num * nb.value;
-                const denum = this.denum;
-                return new Rational(num, denum).simplify();
-            }
-            case nombre_1.NumberType.Rational: {
-                const rational = nb;
-                const num = this.num * rational.num;
-                const denum = this.denum * rational.denum;
-                return new Rational(num, denum).simplify();
-            }
-        }
-        throw Error('not implemented yet');
-    }
-    divide(nb) {
-        switch (nb.type) {
-            case nombre_1.NumberType.Integer: {
-                const denum = this.denum * nb.value;
-                return new Rational(this.num, denum).simplify();
-            }
-            case nombre_1.NumberType.Rational: {
-                const rational = nb;
-                const num = this.num * rational.denum;
-                const denum = this.denum * rational.num;
-                return new Rational(num, denum).simplify();
-            }
-        }
-        throw Error('not implemented yet');
-    }
-    opposite() {
-        return new Rational(-this.num, this.denum);
-    }
-    toTree() {
-        return new fractionNode_1.FractionNode(new numberNode_1.NumberNode(this.num), new numberNode_1.NumberNode(this.denum));
-    }
-    simplify() {
-        const sign = (this.num > 0 && this.denum > 0) || (this.num < 0 && this.denum < 0) ? 1 : -1;
-        const div = Math.abs((0, gcd_1.gcd)(this.num, this.denum));
-        if (Math.abs(this.denum) === div)
-            return new integer_1.Integer(this.num / this.denum);
-        return new Rational((sign * Math.abs(this.num)) / div, Math.abs(this.denum) / div);
-    }
-}
-exports.Rational = Rational;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Rational = exports.RationalConstructor = void 0;
+const coprimesOf_1 = require("../../../math/utils/arithmetic/coprimesOf");
+const gcd_1 = require("../../../math/utils/arithmetic/gcd");
+const lcd_1 = require("../../../math/utils/arithmetic/lcd");
+const randint_1 = require("../../../math/utils/random/randint");
+const numberNode_1 = require("../../../tree/nodes/numbers/numberNode");
+const fractionNode_1 = require("../../../tree/nodes/operators/fractionNode");
+const random_1 = require("../../../utils/random");
+const shuffle_1 = require("../../../utils/shuffle");
+const integer_1 = require("../integer/integer");
+const nombre_1 = require("../nombre");
+class RationalConstructor {
+    /**
+     * @param maxGcd max number by which the fraction is simplifiable
+     */
+    static randomSimplifiable(maxGcd = 10) {
+        const gcd = (0, randint_1.randint)(2, maxGcd);
+        const max = (0, randint_1.randint)(3, 11);
+        const min = (0, random_1.random)((0, coprimesOf_1.coprimesOf)(max));
+        let [num, denum] = (0, shuffle_1.shuffle)([gcd * min, gcd * max]);
+        if (denum === gcd) {
+            //si 10/2 on transforme en 2/10
+            return new Rational(denum, num);
+        }
+        return new Rational(num, denum);
+    }
+    static randomIrreductible(max = 11) {
+        const a = (0, randint_1.randint)(2, max);
+        const b = (0, random_1.random)([...(0, coprimesOf_1.coprimesOf)(a), 1]);
+        if (b === 1)
+            return new Rational(b, a);
+        const [num, denum] = (0, shuffle_1.shuffle)([a, b]);
+        return new Rational(num, denum);
+    }
+}
+exports.RationalConstructor = RationalConstructor;
+class Rational {
+    constructor(numerator, denumerator) {
+        if (denumerator === 0)
+            throw Error('division by zero');
+        this.num = numerator;
+        this.denum = denumerator;
+        this.value = numerator / denumerator;
+        this.isSimplified = Math.abs((0, gcd_1.gcd)(numerator, denumerator)) === 1;
+        this.tex = `\\frac{${this.num}}{${this.denum}}`;
+        this.type = nombre_1.NumberType.Rational;
+    }
+    toTex() {
+        return `\\frac{${this.num}}{${this.denum}}`;
+    }
+    add(nb) {
+        switch (nb.type) {
+            case nombre_1.NumberType.Integer: {
+                const num = this.num + this.denum * nb.value;
+                return new Rational(num, this.denum).simplify();
+            }
+            case nombre_1.NumberType.Rational: {
+                const rational = nb;
+                const ppcm = (0, lcd_1.lcd)(rational.denum, this.denum);
+                const num = this.num * (ppcm / this.denum) + rational.num * (ppcm / rational.denum);
+                return new Rational(num, ppcm).simplify();
+            }
+        }
+        throw Error('not implemented yet');
+    }
+    multiply(nb) {
+        switch (nb.type) {
+            case nombre_1.NumberType.Integer: {
+                const num = this.num * nb.value;
+                const denum = this.denum;
+                return new Rational(num, denum).simplify();
+            }
+            case nombre_1.NumberType.Rational: {
+                const rational = nb;
+                const num = this.num * rational.num;
+                const denum = this.denum * rational.denum;
+                return new Rational(num, denum).simplify();
+            }
+        }
+        throw Error('not implemented yet');
+    }
+    divide(nb) {
+        switch (nb.type) {
+            case nombre_1.NumberType.Integer: {
+                const denum = this.denum * nb.value;
+                return new Rational(this.num, denum).simplify();
+            }
+            case nombre_1.NumberType.Rational: {
+                const rational = nb;
+                const num = this.num * rational.denum;
+                const denum = this.denum * rational.num;
+                return new Rational(num, denum).simplify();
+            }
+        }
+        throw Error('not implemented yet');
+    }
+    opposite() {
+        return new Rational(-this.num, this.denum);
+    }
+    toTree() {
+        return new fractionNode_1.FractionNode(new numberNode_1.NumberNode(this.num), new numberNode_1.NumberNode(this.denum));
+    }
+    simplify() {
+        const sign = (this.num > 0 && this.denum > 0) || (this.num < 0 && this.denum < 0) ? 1 : -1;
+        const div = Math.abs((0, gcd_1.gcd)(this.num, this.denum));
+        if (Math.abs(this.denum) === div)
+            return new integer_1.Integer(this.num / this.denum);
+        return new Rational((sign * Math.abs(this.num)) / div, Math.abs(this.denum) / div);
+    }
+}
+exports.Rational = Rational;

package/lib/math/numbers/reals/real.d.ts

@@ -1,10 +1,10 @@
-import { Node } from '../../../tree/nodes/node';
-import { Nombre, NumberType } from '../nombre';
-export declare class Real implements Nombre {
-    value: number;
-    tex: string;
-    type: NumberType;
-    constructor(value: number, tex: string);
-    toTree(): Node;
-}
+import { Node } from '../../../tree/nodes/node';
+import { Nombre, NumberType } from '../nombre';
+export declare class Real implements Nombre {
+    value: number;
+    tex: string;
+    type: NumberType;
+    constructor(value: number, tex: string);
+    toTree(): Node;
+}
 //# sourceMappingURL=real.d.ts.map

package/lib/math/numbers/reals/real.js

@@ -1,16 +1,16 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Real = void 0;
-const numberNode_1 = require("../../../tree/nodes/numbers/numberNode");
-const nombre_1 = require("../nombre");
-class Real {
-    constructor(value, tex) {
-        this.value = value;
-        this.tex = tex;
-        this.type = nombre_1.NumberType.Real;
-    }
-    toTree() {
-        return new numberNode_1.NumberNode(this.value);
-    }
-}
-exports.Real = Real;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Real = void 0;
+const numberNode_1 = require("../../../tree/nodes/numbers/numberNode");
+const nombre_1 = require("../nombre");
+class Real {
+    constructor(value, tex) {
+        this.value = value;
+        this.tex = tex;
+        this.type = nombre_1.NumberType.Real;
+    }
+    toTree() {
+        return new numberNode_1.NumberNode(this.value);
+    }
+}
+exports.Real = Real;

package/lib/math/numbers/reals/squareRoot.d.ts

@@ -1,19 +1,19 @@
-import { Node } from '../../../tree/nodes/node';
-import { Real } from './real';
-export declare abstract class SquareRootConstructor {
-    /**
-     * @returns simplifiable square root type sqrt(c)=a*sqrt(b)
-     */
-    static randomSimplifiable({ allowPerfectSquare, maxSquare }: {
-        allowPerfectSquare?: boolean | undefined;
-        maxSquare?: number | undefined;
-    }): SquareRoot;
-}
-export declare class SquareRoot extends Real {
-    operand: number;
-    constructor(operand: number);
-    simplify(): Real;
-    toTex(): string;
-    toTree(): Node;
-}
+import { Node } from '../../../tree/nodes/node';
+import { Real } from './real';
+export declare abstract class SquareRootConstructor {
+    /**
+     * @returns simplifiable square root type sqrt(c)=a*sqrt(b)
+     */
+    static randomSimplifiable({ allowPerfectSquare, maxSquare }: {
+        allowPerfectSquare?: boolean | undefined;
+        maxSquare?: number | undefined;
+    }): SquareRoot;
+}
+export declare class SquareRoot extends Real {
+    operand: number;
+    constructor(operand: number);
+    simplify(): Real;
+    toTex(): string;
+    toTree(): Node;
+}
 //# sourceMappingURL=squareRoot.d.ts.map

package/lib/math/numbers/reals/squareRoot.js

@@ -1,63 +1,63 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SquareRoot = exports.SquareRootConstructor = void 0;
-const isSquare_1 = require("../../../math/utils/arithmetic/isSquare");
-const primeFactors_1 = require("../../../math/utils/arithmetic/primeFactors");
-const randint_1 = require("../../../math/utils/random/randint");
-const sqrtNode_1 = require("../../../tree/nodes/functions/sqrtNode");
-const numberNode_1 = require("../../../tree/nodes/numbers/numberNode");
-const multiplyNode_1 = require("../../../tree/nodes/operators/multiplyNode");
-const real_1 = require("./real");
-class SquareRootConstructor {
-    /**
-     * @returns simplifiable square root type sqrt(c)=a*sqrt(b)
-     */
-    static randomSimplifiable({ allowPerfectSquare = false, maxSquare = 11 }) {
-        const a = (0, randint_1.randint)(2, maxSquare);
-        let b;
-        let bMin = allowPerfectSquare ? 1 : 2;
-        do {
-            b = (0, randint_1.randint)(bMin, maxSquare);
-        } while (b % (a * a) === 0 || (0, isSquare_1.isSquare)(b));
-        return new SquareRoot(a * a * b);
-    }
-}
-exports.SquareRootConstructor = SquareRootConstructor;
-class SquareRoot extends real_1.Real {
-    constructor(operand) {
-        super(Math.sqrt(operand), `\\sqrt{${operand}}`);
-        this.operand = operand;
-    }
-    simplify() {
-        const factors = (0, primeFactors_1.primeFactors)(this.operand);
-        // finds primes with even exponents
-        const multiples = [1];
-        for (let i = 0; i < factors.length - 1; i++) {
-            if (factors[i] === factors[i + 1]) {
-                multiples.push(factors[i]);
-                factors.splice(i, 2);
-                i--;
-            }
-        }
-        const outsideSqrt = multiples.reduce((x, y) => x * y);
-        const insideSqrt = factors.length === 0 ? 1 : factors.reduce((x, y) => x * y);
-        const simplified = insideSqrt !== 1
-            ? new real_1.Real(outsideSqrt * Math.sqrt(insideSqrt), `${outsideSqrt === 1 ? '' : `${outsideSqrt}`}\\sqrt{${insideSqrt}}`)
-            : new real_1.Real(outsideSqrt, outsideSqrt + '');
-        simplified.toTree = () => {
-            return insideSqrt !== 1
-                ? outsideSqrt === 1
-                    ? new sqrtNode_1.SqrtNode(new numberNode_1.NumberNode(insideSqrt))
-                    : new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(outsideSqrt), new sqrtNode_1.SqrtNode(new numberNode_1.NumberNode(insideSqrt)))
-                : new numberNode_1.NumberNode(outsideSqrt);
-        };
-        return simplified;
-    }
-    toTex() {
-        return this.tex;
-    }
-    toTree() {
-        return new sqrtNode_1.SqrtNode(new numberNode_1.NumberNode(this.operand));
-    }
-}
-exports.SquareRoot = SquareRoot;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SquareRoot = exports.SquareRootConstructor = void 0;
+const isSquare_1 = require("../../../math/utils/arithmetic/isSquare");
+const primeFactors_1 = require("../../../math/utils/arithmetic/primeFactors");
+const randint_1 = require("../../../math/utils/random/randint");
+const sqrtNode_1 = require("../../../tree/nodes/functions/sqrtNode");
+const numberNode_1 = require("../../../tree/nodes/numbers/numberNode");
+const multiplyNode_1 = require("../../../tree/nodes/operators/multiplyNode");
+const real_1 = require("./real");
+class SquareRootConstructor {
+    /**
+     * @returns simplifiable square root type sqrt(c)=a*sqrt(b)
+     */
+    static randomSimplifiable({ allowPerfectSquare = false, maxSquare = 11 }) {
+        const a = (0, randint_1.randint)(2, maxSquare);
+        let b;
+        let bMin = allowPerfectSquare ? 1 : 2;
+        do {
+            b = (0, randint_1.randint)(bMin, maxSquare);
+        } while (b % (a * a) === 0 || (0, isSquare_1.isSquare)(b));
+        return new SquareRoot(a * a * b);
+    }
+}
+exports.SquareRootConstructor = SquareRootConstructor;
+class SquareRoot extends real_1.Real {
+    constructor(operand) {
+        super(Math.sqrt(operand), `\\sqrt{${operand}}`);
+        this.operand = operand;
+    }
+    simplify() {
+        const factors = (0, primeFactors_1.primeFactors)(this.operand);
+        // finds primes with even exponents
+        const multiples = [1];
+        for (let i = 0; i < factors.length - 1; i++) {
+            if (factors[i] === factors[i + 1]) {
+                multiples.push(factors[i]);
+                factors.splice(i, 2);
+                i--;
+            }
+        }
+        const outsideSqrt = multiples.reduce((x, y) => x * y);
+        const insideSqrt = factors.length === 0 ? 1 : factors.reduce((x, y) => x * y);
+        const simplified = insideSqrt !== 1
+            ? new real_1.Real(outsideSqrt * Math.sqrt(insideSqrt), `${outsideSqrt === 1 ? '' : `${outsideSqrt}`}\\sqrt{${insideSqrt}}`)
+            : new real_1.Real(outsideSqrt, outsideSqrt + '');
+        simplified.toTree = () => {
+            return insideSqrt !== 1
+                ? outsideSqrt === 1
+                    ? new sqrtNode_1.SqrtNode(new numberNode_1.NumberNode(insideSqrt))
+                    : new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(outsideSqrt), new sqrtNode_1.SqrtNode(new numberNode_1.NumberNode(insideSqrt)))
+                : new numberNode_1.NumberNode(outsideSqrt);
+        };
+        return simplified;
+    }
+    toTex() {
+        return this.tex;
+    }
+    toTree() {
+        return new sqrtNode_1.SqrtNode(new numberNode_1.NumberNode(this.operand));
+    }
+}
+exports.SquareRoot = SquareRoot;

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

@@ -1,16 +1,16 @@
-import { Nombre } from '../numbers/nombre';
-import { MathSet } from '../sets/mathSet';
-import { Polynomial } from './polynomial';
-export declare abstract class AffineConstructor {
-    static random(domainA?: MathSet, domainB?: MathSet): Affine;
-    static differentRandoms(nb: number, domainA?: MathSet, domainB?: MathSet): Affine[];
-}
-export declare class Affine extends Polynomial {
-    a: number;
-    b: number;
-    variable: string;
-    constructor(a: number, b: number, variable?: string);
-    getRoot(): Nombre;
-    toString(): string;
-}
+import { Nombre } from '../numbers/nombre';
+import { MathSet } from '../sets/mathSet';
+import { Polynomial } from './polynomial';
+export declare abstract class AffineConstructor {
+    static random(domainA?: MathSet, domainB?: MathSet): Affine;
+    static differentRandoms(nb: number, domainA?: MathSet, domainB?: MathSet): Affine[];
+}
+export declare class Affine extends Polynomial {
+    a: number;
+    b: number;
+    variable: string;
+    constructor(a: number, b: number, variable?: string);
+    getRoot(): Nombre;
+    toString(): string;
+}
 //# sourceMappingURL=affine.d.ts.map

package/lib/math/polynomials/affine.js

@@ -1,42 +1,42 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Affine = exports.AffineConstructor = void 0;
-const integer_1 = require("../numbers/integer/integer");
-const rational_1 = require("../numbers/rationals/rational");
-const discreteSet_1 = require("../sets/discreteSet");
-const intervals_1 = require("../sets/intervals/intervals");
-const polynomial_1 = require("./polynomial");
-class AffineConstructor {
-    static random(domainA = new intervals_1.Interval('[[-10; 10]]').difference(new discreteSet_1.DiscreteSet([new integer_1.Integer(0)])), domainB = new intervals_1.Interval('[[-10; 10]]')) {
-        const a = domainA.getRandomElement();
-        const b = domainB.getRandomElement();
-        return new Affine(a.value, b.value);
-    }
-    static differentRandoms(nb, domainA = new intervals_1.Interval('[[-10; 10]]').difference(new discreteSet_1.DiscreteSet([new integer_1.Integer(0)])), domainB = new intervals_1.Interval('[[-10; 10]]')) {
-        const res = [];
-        for (let i = 0; i < nb; i++) {
-            let aff;
-            do {
-                aff = AffineConstructor.random(domainA, domainB);
-            } while (res.some((affine) => affine.equals(aff)));
-            res.push(aff);
-        }
-        return res;
-    }
-}
-exports.AffineConstructor = AffineConstructor;
-class Affine extends polynomial_1.Polynomial {
-    constructor(a, b, variable = 'x') {
-        super([b, a], variable);
-        this.a = a;
-        this.b = b;
-        this.variable = variable;
-    }
-    getRoot() {
-        return new rational_1.Rational(-this.b, this.a).simplify();
-    }
-    toString() {
-        return super.toTex();
-    }
-}
-exports.Affine = Affine;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Affine = exports.AffineConstructor = void 0;
+const integer_1 = require("../numbers/integer/integer");
+const rational_1 = require("../numbers/rationals/rational");
+const discreteSet_1 = require("../sets/discreteSet");
+const intervals_1 = require("../sets/intervals/intervals");
+const polynomial_1 = require("./polynomial");
+class AffineConstructor {
+    static random(domainA = new intervals_1.Interval('[[-10; 10]]').difference(new discreteSet_1.DiscreteSet([new integer_1.Integer(0)])), domainB = new intervals_1.Interval('[[-10; 10]]')) {
+        const a = domainA.getRandomElement();
+        const b = domainB.getRandomElement();
+        return new Affine(a.value, b.value);
+    }
+    static differentRandoms(nb, domainA = new intervals_1.Interval('[[-10; 10]]').difference(new discreteSet_1.DiscreteSet([new integer_1.Integer(0)])), domainB = new intervals_1.Interval('[[-10; 10]]')) {
+        const res = [];
+        for (let i = 0; i < nb; i++) {
+            let aff;
+            do {
+                aff = AffineConstructor.random(domainA, domainB);
+            } while (res.some((affine) => affine.equals(aff)));
+            res.push(aff);
+        }
+        return res;
+    }
+}
+exports.AffineConstructor = AffineConstructor;
+class Affine extends polynomial_1.Polynomial {
+    constructor(a, b, variable = 'x') {
+        super([b, a], variable);
+        this.a = a;
+        this.b = b;
+        this.variable = variable;
+    }
+    getRoot() {
+        return new rational_1.Rational(-this.b, this.a).simplify();
+    }
+    toString() {
+        return super.toTex();
+    }
+}
+exports.Affine = Affine;