pimath 0.0.113 → 0.0.115

package/src/maths/geometry/line.ts

@@ -8,30 +8,21 @@ import {Numeric} from "../numeric";
 import {Fraction} from "../coefficients/fraction";
 import {Equation} from "../algebra/equation";
 import {Polynom} from "../algebra/polynom";
+import {Random} from "../randomization/random";
 
 export enum LinePropriety {
     None,
-    Parallel='parallel',
+    Parallel = 'parallel',
     Perpendicular = 'perpendicular',
     Tangent = 'tangent'
 }
 
 export class Line {
     // A line is defined as the canonical form
-    // ax + by + c = 0
-    private _a: Fraction;
-    private _b: Fraction;
-    private _c: Fraction;
-    private _OA: Point;
-    private _d: Vector;
-    private _n: Vector;
-    private _exists: boolean
-
-    private _referencePropriety: LinePropriety
-    private _referenceLine: Line
-
     static PERPENDICULAR = LinePropriety.Perpendicular
     static PARALLEL = LinePropriety.Parallel
+    private _referencePropriety: LinePropriety
+    private _referenceLine: Line
 
     constructor(...values: unknown[]) {
 
@@ -44,31 +35,88 @@ export class Line {
         return this;
     }
 
-    get exists(): boolean {
-        return this._exists;
+    // ax + by + c = 0
+    private _a: Fraction;
+
+    get a(): Fraction {
+        return this._a;
+    }
+
+    set a(value: Fraction) {
+        this._a = value;
+    }
+
+    private _b: Fraction;
+
+    get b(): Fraction {
+        return this._b;
+    }
+
+    set b(value: Fraction) {
+        this._b = value;
+    }
+
+    private _c: Fraction;
+
+    get c(): Fraction {
+        return this._c;
     }
 
     // ------------------------------------------
     // Getter and setter
+
+    set c(value: Fraction) {
+        this._c = value;
+    }
+
+    private _OA: Point;
+
+    get OA(): Point {
+        return this._OA;
+    }
+
+    set OA(value: Point) {
+        this._OA = value;
+    }
+
+    private _d: Vector;
+
+    get d(): Vector {
+        return this._d;
+    }
+
+    set d(value: Vector) {
+        this._d = value;
+    }
+
+    private _n: Vector;
+
+    get n(): Vector {
+        return this._n;
+    }
+
+    private _exists: boolean
+
+    get exists(): boolean {
+        return this._exists;
+    }
+
     // ------------------------------------------
     get equation(): Equation {
         return new Equation(new Polynom().parse('xy', this._a, this._b, this._c), new Polynom('0')).simplify();
     }
 
-    get tex(): { canonical: string, mxh: string, parametric: string , equation: string} {
+    get tex(): { canonical: string, mxh: string, parametric: string, equation: string } {
         // canonical    =>  ax + by + c = 0
         // mxh          =>  y = -a/b x - c/b
         // parametric   =>  (xy) = OA + k*d
         // equation     => ax + by = -c
 
-        console.log('BEFORE', this.equation.tex)
         let canonical = this.equation.clone().reorder(true);
-        console.log('CANONCIAL', canonical.tex)
         // Make sur the first item is positive.
         if (this._a.isNegative()) {
             canonical.multiply(-1);
         }
-        console.log('CANONCIAL (multiply)', canonical.tex)
 
         const d = this._d.clone().simplifyDirection()
 
@@ -98,46 +146,6 @@ export class Line {
         }
     }
 
-    get a(): Fraction {
-        return this._a;
-    }
-
-    set a(value: Fraction) {
-        this._a = value;
-    }
-
-    get b(): Fraction {
-        return this._b;
-    }
-
-    set b(value: Fraction) {
-        this._b = value;
-    }
-
-    get c(): Fraction {
-        return this._c;
-    }
-
-    set c(value: Fraction) {
-        this._c = value;
-    }
-
-    get OA(): Point {
-        return this._OA;
-    }
-
-    set OA(value: Point) {
-        this._OA = value;
-    }
-
-    get d(): Vector {
-        return this._d;
-    }
-
-    get n(): Vector {
-        return this._n;
-    }
-
     get normal(): Vector {
         return new Vector(this._a, this._b);
     }
@@ -146,10 +154,6 @@ export class Line {
         return this._d.clone()
     }
 
-    set d(value: Vector) {
-        this._d = value;
-    }
-
     get slope(): Fraction {
         return this._a.clone().opposed().divide(this._b);
     }
@@ -158,8 +162,30 @@ export class Line {
         return this._c.clone().opposed().divide(this._b);
     }
 
+    randomPoint = (k?: number): Point => {
+        // Return a random point on the line.
+        return this._d
+            .clone()
+            .multiplyByScalar(Random.numberSym((k===undefined || k<=1)?3:k, false))
+            .add(this._OA.asVector)
+            .asPoint
+    }
+    randomNearPoint = (k?: number): Point => {
+        let pt = this.randomPoint(k)
+
+        let maxIterationTest = 10
+        while(this.isOnLine(pt) && maxIterationTest>0){
+            pt.x.add(Random.numberSym(1, false))
+            pt.y.add(Random.numberSym(1, false))
+            maxIterationTest--
+
+        }
+        return pt
+    }
+
 // ------------------------------------------
     // Creation / parsing functions
+
     // ------------------------------------------
     /**
      * Parse data to a line
@@ -212,18 +238,18 @@ export class Line {
                 (values[2] instanceof Fraction || typeof values[2] === 'number')
             ) {
                 return this.parseByCoefficient(values[0], values[1], values[2]);
-            }else if (
+            } else if (
                 values[0] instanceof Point && values[1] instanceof Vector
-            ){
-                if(values[2] === LinePropriety.Perpendicular){
+            ) {
+                if (values[2] === LinePropriety.Perpendicular) {
                     return this.parseByPointAndNormal(values[0], values[1])
-                }else if (values[2] === LinePropriety.Parallel){
+                } else if (values[2] === LinePropriety.Parallel) {
                     return this.parseByPointAndVector(values[0], values[1])
                 }
-            }else if (values[0] instanceof Point && values[1] instanceof Line ) {
-                if(values[2]===LinePropriety.Parallel || values[2]===null) {
+            } else if (values[0] instanceof Point && values[1] instanceof Line) {
+                if (values[2] === LinePropriety.Parallel || values[2] === null) {
                     return this.parseByPointAndLine(values[0], values[1], LinePropriety.Parallel)
-                }else{
+                } else {
                     return this.parseByPointAndLine(values[0], values[1], LinePropriety.Perpendicular)
                 }
             }
@@ -338,13 +364,27 @@ export class Line {
     // ------------------------------------------
     // Mathematical operations
     // ------------------------------------------
-    isParellelTo = (line: Line): Boolean => {
+    isOnLine = (pt: Point): Boolean => {
+        return this._a.clone()
+            .multiply(pt.x)
+            .add(
+                this._b.clone()
+                    .multiply(pt.y)
+            )
+            .add(this._c)
+            .isZero()
+    }
+
+    isParallelTo = (line: Line): Boolean => {
         // Do they have the isSame direction ?
         return this.slope.isEqual(line.slope) && this.height.isNotEqual(line.height);
     }
     isSameAs = (line: Line): Boolean => {
         return this.slope.isEqual(line.slope) && this.height.isEqual(line.height);
     }
+    isPerpendicularTo = (line: Line): Boolean => {
+        return this.d.isNormalTo(line.d)
+    }
     isVertical = (): Boolean => {
         return this.slope.isInfinity()
     }
@@ -388,7 +428,7 @@ export class Line {
             // TODO : handle no y in the line canonical form
         }
 
-        if (this.isParellelTo(line)) {
+        if (this.isParallelTo(line)) {
             Pt.x = null;
             Pt.y = null;
             isParallel = true;
@@ -460,20 +500,20 @@ export class Line {
         return false;
     }
 
-    getValueAtX = (value: Fraction|number): Fraction => {
+    getValueAtX = (value: Fraction | number): Fraction => {
         const equ = this.equation.clone().isolate('y'),
             F = new Fraction(value)
 
-        if(equ instanceof Equation){
+        if (equ instanceof Equation) {
             return equ.right.evaluate({x: F})
         }
         return
     }
-    getValueAtY = (value: Fraction|number): Fraction => {
+    getValueAtY = (value: Fraction | number): Fraction => {
         const equ = this.equation.clone().isolate('x'),
             F = new Fraction(value)
 
-        if(equ instanceof Equation){
+        if (equ instanceof Equation) {
             return equ.right.evaluate({y: F})
         }
         return

package/src/maths/geometry/point.ts

@@ -67,6 +67,10 @@ export class Point {
         return `(${pts.join(';')})`
     }
 
+    get asVector(): Vector {
+        return new Vector(this.x, this.y)
+    }
+
     // ------------------------------------------
     // Creation / parsing functions
     // ------------------------------------------

package/src/maths/geometry/vector.ts

@@ -50,6 +50,10 @@ export class Vector {
         return `\\begin{pmatrix}${this._x.tex} \\\\\ ${this._y.tex} \\end{pmatrix}`
     }
 
+    get asPoint(): Point {
+        return new Point(this.x, this.y)
+    }
+
     // ------------------------------------------
     // Creation / parsing functions
     // ------------------------------------------
@@ -162,13 +166,12 @@ export class Vector {
     }
 
     scalarProductWithVector = (V: Vector): Fraction => {
-        // TODO: Add the scalar factor !!!!
-        return this._x.clone().multiply(V.x).add(this._y.clone().multiply(V.y));
+        return Vector.scalarProduct(this, V)
+        // return this._x.clone().multiply(V.x).add(this._y.clone().multiply(V.y));
     }
 
-    static scalarProduct = (v1: Vector, v2: Vector): number => {
-        // TODO: Transform to fraction with nthroot.
-        return v1.x.value * v2.x.value + v1.y.value * v2.y.value;
+    static scalarProduct = (v1: Vector, v2: Vector): Fraction => {
+        return v1.x.clone().multiply(v2.x).add(v1.y.clone().multiply(v2.y));
     };
 
     normal = (): Vector => {

package/src/maths/randomization/random.ts

@@ -1,13 +1,21 @@
 import {rndPolynom} from "./rndPolynom";
 import {rndMonom} from "./rndMonom";
 import {rndHelpers} from "./rndHelpers";
-import {randomCoefficientConfig, randomGeometryLineConfig, randomMonomConfig, randomPolynomConfig} from "./rndTypes";
+import {
+    randomCoefficientConfig,
+    randomGeometryLineConfig,
+    randomGeometryPointConfig,
+    randomMonomConfig,
+    randomPolynomConfig
+} from "./rndTypes";
 import {rndFraction} from "./rndFraction";
 import {Polynom} from "../algebra/polynom";
 import {Monom} from "../algebra/monom";
 import {Fraction} from "../coefficients/fraction";
 import {Line} from "../geometry/line";
 import {rndGeometryLine} from "./rndGeometryLine";
+import {Point} from "../geometry/point";
+import {rndGeometryPoint} from "./rndGeometryPoint";
 
 export * from "./rndTypes"
 
@@ -56,5 +64,10 @@ export namespace Random {
         export function line(config?: randomGeometryLineConfig): Line {
             return (new rndGeometryLine(config).generate())
         }
+
+        export function point(config?: randomGeometryPointConfig): Point {
+            return (new rndGeometryPoint(config).generate())
+        }
+
     }
 }

package/src/maths/randomization/rndGeometryLine.ts

@@ -2,7 +2,6 @@ import {randomCore} from "./randomCore";
 import {Random, randomGeometryLineConfig} from "./random";
 import {Line} from "../geometry/line";
 import {Vector} from "../geometry/vector";
-import {PiMath} from "../../index";
 import {Point} from "../geometry/point";
 
 /**
@@ -34,17 +33,17 @@ export class rndGeometryLine extends randomCore {
             Random.numberSym(10)
         )
 
-        while(d.isNull){
+        while (d.isNull) {
             d.x = Random.numberSym(10)
             d.y = Random.numberSym(10)
         }
 
-        if(this._config.slope===1){
-            if(d.x.sign()!==d.y.sign()){
+        if (this._config.slope === 1) {
+            if (d.x.sign() !== d.y.sign()) {
                 d.y.opposed()
             }
-        }else if(this._config.slope===-1){
-            if(d.x.sign()!==d.y.sign()){
+        } else if (this._config.slope === -1) {
+            if (d.x.sign() !== d.y.sign()) {
                 d.y.opposed()
             }
         }

package/src/maths/randomization/rndGeometryPoint.ts

@@ -0,0 +1,69 @@
+import {randomCore} from "./randomCore";
+import {Random, randomGeometryPointConfig} from "./random";
+import {Point} from "../geometry/point";
+import {Fraction} from "../coefficients/fraction";
+
+/**
+ * Create a random monom based on a based configuration
+ */
+export class rndGeometryPoint extends randomCore {
+    declare protected _config: randomGeometryPointConfig
+    declare protected _defaultConfig: randomGeometryPointConfig
+
+    constructor(userConfig?: randomGeometryPointConfig) {
+        super();
+
+        this._defaultConfig = {
+            axis: true,
+            fraction: false,
+            max: 10
+        }
+
+        this._config = this.mergeConfig(userConfig, this._defaultConfig)
+    }
+
+    generate = (): Point => {
+        let x: Fraction, y: Fraction,
+            zeroX = this._config.axis === true || this._config.axis === 'x',
+            zeroY = this._config.axis === true || this._config.axis === 'y'
+
+        x = this._config.fraction ?
+            Random.fraction({max: this._config.max, zero: zeroX}) :
+            new Fraction(Random.numberSym(this._config.max, zeroX))
+
+        y = this._config.fraction ?
+            Random.fraction({max: this._config.max, zero: zeroY}) :
+            new Fraction(Random.numberSym(this._config.max, zeroY))
+
+        if (+this._config.quadrant === 1) {
+            x.abs()
+            y.abs()
+        }
+        if (+this._config.quadrant === 2) {
+            if (x.isPositive()) {
+                x.opposed()
+            }
+            if (y.isNegative()) {
+                y.opposed()
+            }
+        }
+        if (+this._config.quadrant === 3) {
+            if (x.isPositive()) {
+                x.opposed()
+            }
+            if (y.isPositive()) {
+                y.opposed()
+            }
+        }
+        if (+this._config.quadrant === 4) {
+            if (x.isNegative()) {
+                x.opposed()
+            }
+            if (y.isPositive()) {
+                y.opposed()
+            }
+        }
+
+        return new Point(x, y)
+    }
+}

package/src/maths/randomization/rndTypes.ts

@@ -27,3 +27,11 @@ export type randomGeometryLineConfig = {
     A: { x: number | Fraction, y: number | Fraction },
     slope?: Fraction | string | number,
 }
+
+
+export type randomGeometryPointConfig  = {
+    quadrant?: number,
+    axis?: string | boolean,
+    fraction?: boolean,
+    max?: number
+}

package/tests/geometry/line.test.ts

@@ -1,5 +1,7 @@
 import {describe} from "mocha";
 import {Line} from "../../src/maths/geometry/line";
+import {Point} from "../../src/maths/geometry/point";
+import {expect} from "chai";
 
 describe('Geometry Line', function () {
     it('should evaluate coordinates', function () {
@@ -19,4 +21,15 @@ describe('Geometry Line', function () {
         console.log(tex.parametric)
     });
 
+    it('should parse line from canonical coefficient', function () {
+        let L = new Line(3, 2, 1)
+
+        let P1 = new Point(-2, 3),
+            P2 = new Point(-3, 4)
+        expect(L.isOnLine(P1)).to.be.false
+        expect(L.isOnLine(P2)).to.be.true
+
+        console.log(L.randomNearPoint(20).display)
+    })
+
 });