pimath 0.0.132 → 0.0.134

package/lib/maths/algebra/rational.ts

@@ -1,244 +0,0 @@
-/**
- * Rational polynom module contains everything necessary to handle rational polynoms.
- * @module Polynom
- */
-
-import {IEuclidian, Polynom} from "./polynom";
-import {Fraction} from "../coefficients/fraction";
-import {literalType} from "./monom";
-import {PARTICULAR_SOLUTION} from "./equation";
-import {RationalStudy} from "./study/rationalStudy";
-import {StudyConfig} from "./study";
-
-/**
- * Rational class can handle rational polynoms
- */
-export class Rational {
-    private _denominator: Polynom;
-    private _numerator: Polynom;
-    private _rawString: string;
-
-    /**
-     *
-     * @param numerator
-     * @param denominator
-     */
-    constructor(numerator?: Polynom | string, denominator?: Polynom | string) {
-        if (numerator instanceof Polynom) {
-            this._numerator = numerator.clone()
-        } else if (typeof numerator === 'string') {
-            this._numerator = new Polynom(numerator)
-        } else {
-            this._numerator = new Polynom()
-        }
-
-        if (denominator instanceof Polynom) {
-            this._denominator = denominator.clone()
-        } else if (typeof denominator === 'string') {
-            this._denominator = new Polynom(denominator)
-        } else {
-            this._denominator = new Polynom()
-        }
-
-    }
-
-    get numerator(): Polynom {
-        return this._numerator
-    }
-
-    get denominator(): Polynom {
-        return this._denominator
-    }
-
-    get tex(): string {
-        return `\\frac{ ${this._numerator.tex} }{ ${this._denominator.tex} }`;
-    }
-
-    get display(): string {
-        return `(${this._numerator.display})/(${this._denominator.display})`;
-    }
-
-    get texFactors(): string {
-        return `\\frac{ ${this._numerator.texFactors} }{ ${this._denominator.texFactors} }`
-    }
-
-    get displayFactors(): string {
-        return `(${this._numerator.displayFactors})/(${this._denominator.displayFactors})`;
-    }
-
-    get plotFunction(): string {
-        return `(${this._numerator.plotFunction})/(${this._denominator.plotFunction})`
-    }
-
-    clone = (): Rational => {
-        return new Rational(
-            this._numerator.clone(),
-            this._denominator.clone()
-        )
-    }
-
-    domain = (): string => {
-        let zeroes = this._denominator.getZeroes();
-
-        if (zeroes.length === 0 || zeroes[0].tex === PARTICULAR_SOLUTION.real) {
-            return PARTICULAR_SOLUTION.varnothing
-        } else if (zeroes[0].tex === PARTICULAR_SOLUTION.varnothing) {
-            return PARTICULAR_SOLUTION.real
-        } else {
-            return '\\mathbb{R}\\setminus\\left\\{' +
-                zeroes.map(x => x.tex).join(';') + '\\right\\}'
-        }
-    }
-
-    amplify = (P: Polynom): Rational => {
-        this._numerator.multiply(P);
-        this._denominator.multiply(P);
-
-        return this;
-    }
-
-    derivative = (letter?: string): Rational => {
-        let N = this._numerator.clone(),
-            D = this._denominator.clone(),
-            dN = N.clone().derivative(letter),
-            dD = D.clone().derivative(letter)
-
-        this._numerator = dN.clone().multiply(D).subtract(N.clone().multiply(dD))
-        this._denominator = D.clone().pow(2)
-
-        return this
-    }
-
-    factorize = (letter?: string): Rational => {
-        this._numerator.factorize(letter)
-        this._denominator.factorize(letter)
-        return this
-    }
-
-    simplify = (P: Polynom): Rational => {
-        let NumeratorEuclidien = this._numerator.euclidian(P);
-        if (!NumeratorEuclidien.reminder.isZero()) {
-            return this;
-        }
-
-        let DenominatorEuclidien = this._denominator.euclidian(P);
-        if (!DenominatorEuclidien.reminder.isZero()) {
-            return this;
-        }
-
-        this._numerator = NumeratorEuclidien.quotient;
-        this._denominator = DenominatorEuclidien.quotient;
-        return this;
-    }
-
-    reduce = (): Rational => {
-        this._numerator.factorize();
-        for (let f of this._numerator.factors) {
-
-            if (f.degree().isZero()) {
-                // Do the simplify only if the factor can divide the denominator
-                if (this._denominator.commonMonom().coefficient.clone().divide(f.monomByDegree().coefficient).isNatural()) {
-                    this.simplify(f);
-                }
-            } else {
-                this.simplify(f);
-            }
-        }
-
-        return this;
-    }
-
-    opposed = (): Rational => {
-        this._numerator.opposed();
-        return this;
-    }
-
-    add = (R: Rational): Rational => {
-        // 1. Make sure both rational are at the same denominator
-        // 2. Add the numerators.
-        // 3. Simplify
-
-        // Store the adding denominator
-        let denominator = this._denominator.clone()
-
-        // Amplif the main rational polynom by the adding denominator
-        this.amplify(R._denominator)
-
-        // Add to the numerator the adding value...
-        this._numerator.add(R._numerator.clone().multiply(denominator));
-
-        return this;
-    }
-
-    subtract = (R: Rational): Rational => {
-        return this.add(R.clone().opposed())
-    }
-
-    euclidian = (): IEuclidian => {
-        return this._numerator.euclidian(this._denominator)
-    }
-
-    // TODO : where and how is used limits ?
-    limits = (value: Fraction | number, offset?: string, letter?: string): Fraction => {
-        if (value === Infinity || value === -Infinity) {
-            let {quotient, reminder} = this._numerator.clone().euclidian(this._denominator)
-
-            // quotient is positive => it will be infinite.
-            if (quotient.degree(letter).isStrictlyPositive()) {
-                return value === Infinity ? quotient.limitToInfinity(letter) : quotient.limitToNegativeInfinity(letter)
-                // return quotient.monomByDegree(undefined, letter).coefficient.sign()===1?(new Fraction()).infinite():(new Fraction()).infinite().opposed()
-            } else {
-                return quotient.monomByDegree(undefined, letter).coefficient
-            }
-        } else {
-            let evalValues: literalType = {},
-                evalValuesOffset: literalType = {},
-                theLimit: Fraction | number,
-                theSign: number,
-                FR = this.clone().reduce()
-
-            evalValues[letter === undefined ? 'x' : letter] = new Fraction(value)
-
-            if (offset !== 'above' && offset !== 'below') {
-                theLimit = FR._numerator.evaluate(evalValues)
-                    .divide(FR._denominator.evaluate(evalValues))
-
-                return theLimit.isInfinity() ? theLimit.abs() : theLimit
-            } else {
-                if (offset === 'above') {
-                    evalValuesOffset[letter === undefined ? 'x' : letter] = (new Fraction(value)).add(0.000001)
-                } else if (offset === 'below') {
-                    evalValuesOffset[letter === undefined ? 'x' : letter] = (new Fraction(value)).subtract(0.000001)
-                }
-
-                theLimit = FR._numerator.evaluate(evalValues)
-                    .divide(FR._denominator.evaluate(evalValues))
-                theSign = FR._numerator.evaluate(evalValuesOffset)
-                    .divide(FR._denominator.evaluate(evalValuesOffset)).sign()
-
-                if (theLimit.isInfinity()) {
-                    return theSign === 1 ? theLimit.abs() : theLimit.abs().opposed()
-                } else {
-                    return theLimit
-                }
-            }
-        }
-    }
-
-    evaluate = (values: literalType | Fraction | number): Fraction => {
-        const r = new Fraction().zero();
-
-        let N = this._numerator.evaluate(values),
-            D = this._denominator.evaluate(values)
-
-        return N.divide(D)
-    };
-
-    evaluateAsNumeric = (values: { [Key: string]: number } | number): number => {
-        return this._numerator.evaluateAsNumeric(values) / this._denominator.evaluateAsNumeric(values)
-    }
-
-    study = (config?: StudyConfig | string): RationalStudy => {
-        return new RationalStudy(this, config)
-    }
-}

package/lib/maths/algebra/study/rationalStudy.ts

@@ -1,287 +0,0 @@
-/**
- * The study class is a "function study" class that will get:
- * fx               : get the function
- * domain           : string
- * zeroes           : Object (tex, IZero)
- * signs            : table of signs + tex output  using tkz-tab
- * av               : vertical asymptotic
- * ah               : horizontal asymptotic
- * ao               : obliques
- * deltaX           : position relative
- * dx               : derivative
- * grows            : growing table + tex output  using tkz-tab
- * ddx              : dérivée seconde
- * variations       : variation table + tex output  using tkz-tab
- */
-import {
-    ASYMPTOTE,
-    ASYMPTOTE_POSITION,
-    FUNCTION_EXTREMA,
-    IAsymptote,
-    ITableOfSigns,
-    IZero,
-    Study,
-    StudyableFunction, StudyConfig,
-    TABLE_OF_SIGNS,
-    ZEROTYPE
-} from "../study";
-import {Rational} from "../rational";
-import {Fraction} from "../../coefficients/fraction";
-import {Polynom} from "../polynom";
-
-export class RationalStudy extends Study {
-    constructor(fx: StudyableFunction, config?: StudyConfig|string) {
-        super(fx, config)
-
-        return this
-    }
-
-    makeZeroes(): IZero[] {
-        return this._getZeroes(this.fx)
-    };
-
-    makeSigns(): ITableOfSigns {
-        return this._getSigns(this.fx, this.zeroes)
-    };
-
-    makeAsymptotes(): IAsymptote[] {
-        const reduced: Rational = this.fx.clone().reduce()
-
-        // Vertical
-        let asymptotes: IAsymptote[] = []
-        this.zeroes.filter(x => x.type === ZEROTYPE.DEFENCE).forEach(zero => {
-            // Check if it's a hole or an asymptote
-            let Ztype = ASYMPTOTE.VERTICAL,
-                tex = `x=${zero.tex}`,
-                display = `x=${zero.display}`
-
-            // Check if it's a hole: the reduced polynom should not be null
-            if (zero.exact instanceof Fraction) {
-                if (reduced.denominator.evaluate(zero.exact).isNotZero()) {
-                    Ztype = ASYMPTOTE.HOLE
-                    tex = `(${zero.tex};${reduced.evaluate(zero.exact).tex})`
-                    display = `(${zero.display};${reduced.evaluate(zero.exact).display})`
-                }
-            } else {
-                if (reduced.denominator.evaluate(zero.value).isNotZero()) {
-                    Ztype = ASYMPTOTE.HOLE
-                    tex = `(${zero.tex};${reduced.evaluate(zero.value).tex})`
-                    display = `(${zero.display};${reduced.evaluate(zero.value).display})`
-                }
-            }
-
-            // Get the position before and after the asymptote.
-            const delta = 0.000001
-            let before = this.fx.evaluateAsNumeric(zero.value - delta),
-                after = this.fx.evaluateAsNumeric(zero.value + delta),
-                position: ASYMPTOTE_POSITION[] = [],
-                pm = ""
-
-            if (after < -10000) {
-                position.push(ASYMPTOTE_POSITION.RB)
-                pm += "m"
-            } else if (after > 10000) {
-                position.push(ASYMPTOTE_POSITION.RT)
-                pm += "p"
-            }
-
-            if (before < -10000) {
-                position.push(ASYMPTOTE_POSITION.LB)
-                pm += "m"
-            } else if (before > 10000) {
-                position.push(ASYMPTOTE_POSITION.LT)
-                pm += "p"
-            }
-
-            // Left and right are to infinity
-            // TODO: handle the case were one side of the asymptote isn't infinity (not possible in rational study?!)
-            if (pm === "pp") {
-                pm = "+"
-            } else if (pm === "mm") {
-                pm = "-"
-            } else {
-                pm = `\\${pm}`
-            }
-
-            asymptotes.push({
-                fx: null,
-                type: Ztype,
-                tex,
-                display,
-                zero: zero,
-                limits: `\\lim_{x\\to${zero.tex} }\\ f(x) = ${pm}\\infty`,
-                deltaX: null,
-                tableOfSign: null,
-                position
-            })
-        })
-
-        // Sloped asymptote
-        let NDegree = this.fx.numerator.degree(),
-            DDegree = this.fx.denominator.degree()
-        if (NDegree.isEqual(DDegree)) {
-            let H = this.fx.numerator.monomByDegree().coefficient.clone().divide(this.fx.denominator.monomByDegree().coefficient),
-                Htex = H.tex
-
-            let {reminder} = reduced.euclidian(),
-                deltaX = new Rational(reminder, reduced.denominator)
-
-            // Determine the position above or below on the left / right of the asymptote.
-            asymptotes.push({
-                fx: new Polynom(H),
-                type: ASYMPTOTE.HORIZONTAL,
-                tex: `y=${Htex}`,
-                display: `y=${H.display}`,
-                zero: null,
-                limits: `\\lim_{x\\to\\infty}\\ f(x) = ${Htex}`,
-                deltaX,
-                tableOfSign: this._getSigns(deltaX),
-                position: this._getHorizontalAsymptoteRelativePositon(deltaX)
-            })
-        } else if (DDegree.greater(NDegree)) {
-            asymptotes.push({
-                fx: new Polynom('0'),
-                type: ASYMPTOTE.HORIZONTAL,
-                tex: `y=0`,
-                display: `y=0`,
-                zero: null,
-                limits: `\\lim_{x\\to\\infty}\\ f(x) = ${0}`,
-                deltaX: null,
-                tableOfSign: null,
-                position: this._getHorizontalAsymptoteRelativePositon(this.fx)
-            })
-        } else if (NDegree.value - 1 === DDegree.value) {
-            // Calculate the slope
-            let {quotient, reminder} = reduced.euclidian(),
-                deltaX = new Rational(reminder, reduced.denominator)
-
-            asymptotes.push({
-                fx: quotient.clone(),
-                type: ASYMPTOTE.SLOPE,
-                tex: `y=${quotient.tex}`,
-                display: `y=${quotient.display}`,
-                zero: null,
-                limits: ``,
-                deltaX: new Rational(reminder, reduced.denominator),
-                tableOfSign: this._getSigns(deltaX),
-                position: this._getHorizontalAsymptoteRelativePositon(deltaX)
-            })
-        }
-
-        return asymptotes
-    };
-
-    _getHorizontalAsymptoteRelativePositon(deltaX: Rational, delta: number = 1000000): ASYMPTOTE_POSITION[] {
-
-        let position: ASYMPTOTE_POSITION[] = [],
-            before = deltaX.evaluateAsNumeric(-delta),
-            after = deltaX.evaluateAsNumeric(delta)
-
-        if (before >= 0) {
-            position.push(ASYMPTOTE_POSITION.LT)
-        } else {
-            position.push(ASYMPTOTE_POSITION.LB)
-        }
-
-        if (after >= 0) {
-            position.push(ASYMPTOTE_POSITION.RT)
-        } else {
-            position.push(ASYMPTOTE_POSITION.RB)
-        }
-
-        return position
-    }
-
-    makeDerivative(): ITableOfSigns {
-        let dx = this.fx.clone().derivative(),
-            tos = this._getSigns(dx, this._getZeroes(dx), TABLE_OF_SIGNS.GROWS)
-
-        let result = this.makeGrowsResult(tos)
-        tos.signs.push(result.growsLine)
-        tos.extremes = result.extremes
-        return tos
-    };
-
-    makeVariation(): ITableOfSigns {
-        // Get the zeroes, make signs.
-        let dx = this.derivative.fx.clone().derivative(),
-            tos = this._getSigns(dx, this._getZeroes(dx), TABLE_OF_SIGNS.VARIATIONS)
-
-        let result = this.makeVariationsResult(tos)
-        tos.signs.push(result.varsLine)
-        tos.extremes = result.extremes
-        return tos
-    };
-
-    private _getZeroes(fx: StudyableFunction) {
-        // All zeroes.
-        let zeroes: IZero[] = []
-
-        fx.numerator.getZeroes().filter(x => !isNaN(x.value)).forEach(z => {
-            // add the item
-            zeroes.push({
-                tex: z.tex,
-                display: z.display,
-                value: z.value,
-                exact: z.exact,
-                extrema: FUNCTION_EXTREMA.NOTHING,
-                type: ZEROTYPE.ZERO
-            })
-        })
-
-        fx.denominator.getZeroes().filter(x => !isNaN(x.value)).forEach(z => {
-            let idx = this.indexOfZero(zeroes, z)
-
-            if (idx !== -1) {
-                zeroes[idx].type = ZEROTYPE.DEFENCE
-            } else {
-                // Add the item
-                zeroes.push({
-                    tex: z.tex,
-                    display: z.display,
-                    value: z.value,
-                    exact: z.exact,
-                    extrema: FUNCTION_EXTREMA.NOTHING,
-                    type: ZEROTYPE.DEFENCE
-                })
-            }
-        })
-
-        // sort all zeroes
-        zeroes.sort((a, b) => a.value - b.value)
-
-        return zeroes
-    }
-
-    private _getSigns(fx: Rational, zeroes?: IZero[], typeOfTable?: TABLE_OF_SIGNS): ITableOfSigns {
-        // Factorize the rational
-        let signs: (string[])[] = [],
-            factors: Polynom[] = []
-
-        if (zeroes === undefined) {
-            zeroes = this._getZeroes(fx)
-        }
-
-        fx.numerator.factors.forEach(factor => {
-            signs.push(this.makeOneLineForSigns(factor, zeroes, ZEROTYPE.ZERO))
-            factors.push(factor.clone())
-        })
-
-        fx.denominator.factors.forEach(factor => {
-            signs.push(this.makeOneLineForSigns(factor, zeroes, ZEROTYPE.DEFENCE))
-            factors.push(factor.clone())
-        })
-
-        signs.push(this.makeSignsResult(signs))
-
-        return {
-            type: typeOfTable,
-            fx,
-            factors,
-            zeroes,
-            signs,
-            extremes: {},
-            tex: ''
-        }
-    }
-}