pimath 0.0.126 → 0.0.128

package/src/maths/randomization/rndGeometryCircle.ts

@@ -0,0 +1,50 @@
+import {randomCore} from "./randomCore";
+import {Random, randomGeometryCircleConfig} from "./random";
+import {Circle} from "../geometry/circle";
+
+/**
+ * Create a random monom based on a based configuration
+ */
+export class rndGeometryCircle extends randomCore {
+    declare protected _config: randomGeometryCircleConfig
+    declare protected _defaultConfig: randomGeometryCircleConfig
+
+    generate = (): Circle => {
+        const center = Random.Geometry.point(this._config.center)
+
+        let rv, r
+        if (this._config.pointsOnCircle === 8) {
+            rv = Random.number(1, 3),
+                r = rv ** 2 + (rv + 1) ** 2
+        } else {
+            r = Random.number(1, 20)
+        }
+
+        const c = new Circle(center, r, true)
+
+
+        // let pts = c.getPointsOnCircle(true)
+        //
+        // pts = Random.shuffle(pts)
+        // let ptt = pts.shift(),
+        //     pt1 = pts.shift(),
+        //     pt2
+        //
+        // for (let pt of pts) {
+        //     if (!pt1.x.isEqual(pt.x) && !pt1.y.isEqual(pt.y) && !A.isEqual(new Point().middleOf(pt1, pt))) {
+        //         pt2 = pt.clone()
+        //         break
+        //     }
+        // }
+
+        return c
+
+    }
+
+    constructor(userConfig?: randomGeometryCircleConfig) {
+        super();
+
+        this._defaultConfig = {}
+        this._config = this.mergeConfig(userConfig, this._defaultConfig)
+    }
+}

package/src/maths/randomization/rndTypes.ts

@@ -4,14 +4,14 @@ export type randomCoefficientConfig = {
     negative?: boolean,
     max?: number,
     reduced?: boolean,
-    zero?:boolean,
-    natural?:boolean
+    zero?: boolean,
+    natural?: boolean
 }
 
 export type randomMonomConfig = {
     letters?: string,
     degree?: number,
-    fraction?: boolean|randomCoefficientConfig,
+    fraction?: boolean | randomCoefficientConfig,
     zero?: boolean
 }
 
@@ -29,9 +29,15 @@ export type randomGeometryLineConfig = {
 }
 
 
-export type randomGeometryPointConfig  = {
+export type randomGeometryPointConfig = {
     quadrant?: number,
     axis?: string | boolean,
     fraction?: boolean,
     max?: number
+}
+
+export type randomGeometryCircleConfig = {
+    center?: randomGeometryPointConfig,
+    radius?: number,
+    pointsOnCircle?: number
 }

package/tests/algebra/polynom.test.ts

@@ -67,6 +67,16 @@ describe('Polynom tests', () => {
         expect(euclidian.reminder.tex).to.be.equal('12')
     });
 
+    it('should calculate the quotient and reminder with similar polynom', () => {
+        let P = new Polynom('6x^5+12x^4+3x^3+x^2-7x+6'),
+            D = new Polynom('x^3+2x^2-2x-4')
+
+        let euclidian = P.euclidian(D);
+
+        expect(euclidian.quotient.display).to.be.equal('6x^(2)+15')
+        expect(euclidian.reminder.display).to.be.equal('-5x^(2)+23x+66')
+    })
+
     it('should reduce', () => {
         let P = new Polynom('15x-19x+24+4x-12')
         P.reduce()

package/tests/geometry/circle.test.ts

@@ -4,6 +4,8 @@ import {Circle} from "../../src/maths/geometry/circle";
 import {Line} from "../../src/maths/geometry/line";
 import {Point} from "../../src/maths/geometry/point";
 import {Fraction} from "../../src/maths/coefficients/fraction";
+import {Random} from "../../src/maths/randomization/random";
+import {Vector} from "../../src/maths/geometry/vector";
 
 describe('Circle', function () {
     it('should calculate the intersection of a circle and a line', function () {
@@ -67,7 +69,226 @@ describe('Circle', function () {
         // console.log(circle.tex)
     })
 
-    
+    it('tangentes pt ext', () => {
+        function makeCircle(): { circle: Circle, point: Point, tangents: Line[] } {
+            let A = Random.Geometry.point({axis: false}),
+                rv = Random.number(1, 3),
+                r = rv ** 2 + (rv + 1) ** 2
+            let c = new Circle(A, r, true)
+            let pts = c.getPointsOnCircle(true)
+
+            pts = Random.shuffle(pts)
+            let pt1: Point, pt2: Point, t1: Line, t2: Line, I: Point, n: Vector
+
+            pt1 = pts.shift()
+            for (let pt of pts) {
+                // Pas vertical / horizontal
+                n = new Vector(A, pt)
+
+                if (!n.x.isZero() && !n.y.isZero() &&   // pas vertical / horizontal
+                    !pt1.x.isEqual(pt.x) && !pt1.y.isEqual(pt.y) &&  // pas le même point
+                    !A.isEqual(new Point().middleOf(pt1, pt)) // pas l'un en face de l'autre
+                ) {
+                    pt2 = pt.clone()
+
+                    t1 = c.tangents(pt1)[0]
+                    t2 = c.tangents(pt2)[0]
+                    const intersection = t1.intersection(t2)
+
+                    if (intersection.hasIntersection && intersection.point.x.isRelative()) {
+                        I = intersection.point
+                        break
+                    }
+                }
+            }
+
+
+            return {
+                circle: c,
+                tangents: [t1, t2],
+                point: I
+            }
+        }
+
+        for (let i = 0; i < 30; i++) {
+            let {circle, tangents, point} = makeCircle()
+            console.log(`\\textbf{(exercice ${i + 1})}
+        
+        Calculer l'équation cartésiennes des tangentes au cercle \\( (\\Gamma): ${circle.tex} \\) passant par le point \\(P=${point.tex} \\)
+            \\iftoggle{master}{
+            (I) \\( ${tangents[0].tex.canonical} \\quad ${tangents[1].tex.canonical} \\)
+            }{}
+            \\vfill
+            ${i % 2 === 1 ? '\\newpage' : ''}
+            `)
+
+        }
+        /**
+         const C = new PiMath.Geometry.Circle(circle.value),
+         pts = C.getPointsOnCircle()
+
+         code.value = `C(${C.center.x.value},${C.center.y.value})
+         c=circ C,${C.radius.value}`
+
+         let tangents = []
+         pts.forEach((pt, index) => {
+         let tg = C.tangents(pt)[0]
+         tangents.push(tg)
+         code.value += `\nT${index + 1}(${pt.x.value},${pt.y.value})->tex:T_${index + 1}=@`
+         code.value += `\nt${index + 1}=line ${tg.tex.canonical}`
+
+         tangentPerPoints.value.push(`T_${index+1}(${pt.x.tex};${pt.y.tex})\\implies ${tg.tex.canonical}`)
+         })
+
+         for (let i = 0; i < tangents.length; i++) {
+         for (let j = i + 1; j < tangents.length; j++) {
+         let intersection = tangents[i].intersection(tangents[j])
+
+         if (intersection.hasIntersection) {
+         if (!intersection.point.isInListOfPoints(pts)) {
+         intersection.point.name=`I_{${i + 1}-${j + 1}}`
+         intersectionPoints.value.push({
+         point: `I_{${i+1}-${j+1}}${intersection.point.tex}`,
+         tangent1: tangents[i].tex.canonical,
+         tangent2: tangents[j].tex.canonical
+         })
+         code.value += `\nI_${i + 1}_${j + 1}(${intersection.point.x.value},${intersection.point.y.value})->tex:I_{${i+1}-${i+2}}=@`
+         }
+         }
+         }
+         }
+         */
+    })
+    it('tangentes temp tests', () => {
+        function makeCircle(): { circle: Circle, point: Point, tangent: Line, symetric: Line } {
+            let A = Random.Geometry.point({axis: false}),
+                rv = Random.number(1, 3),
+                r = rv ** 2 + (rv + 1) ** 2
+            let c = new Circle(A, r, true)
+            let pts = c.getPointsOnCircle(true)
+
+            pts = Random.shuffle(pts)
+            let pt: Point, n: Vector
+            for (let p of pts) {
+                n = new Vector(A, p)
+                if (!n.x.isZero() && !n.y.isZero()) {
+                    pt = p
+                    break
+                }
+            }
+
+            const p2 = new Point(A.x.clone(), A.y.clone()).translate({x: n.x.opposed(), y: n.y.opposed()})
+            const t = new Line(n, pt)
+            const s = new Line(n, p2)
+            return {
+                circle: c,
+                point: pt,
+                tangent: t,
+                symetric: s
+            }
+        }
+
+        for (let i = 0; i < 30; i++) {
+
+            const data1 = makeCircle()
+            const item1 = `Calculer l'équation de la tangente au cercle d'équation \\( (\\Gamma_1): ${data1.circle.tex} \\) un cercle passant par le point \\( T=${data1.point.tex} \\).`
+
+            const data2 = makeCircle()
+            const item2 = `Calculer l'équation des tangentes au cercle d'équation \\( (\\Gamma_2): ${data2.circle.cartesian.tex} \\) de pente \\( \\displaystyle ${data2.tangent.slope.tex} \\).`
+
+            console.log(`\\textbf{(exercice ${i + 1})}
+        
+        \\begin{enumerate}[(I),itemsep=10em] 
+        \\item ${item1}
+        \\item ${item2}
+            \\end{enumerate}
+            \\iftoggle{master}{
+            (I) \\( ${data1.tangent.tex.canonical} \\)
+            
+            (II) \\( (\\Gamma_2): ${data2.circle.tex} \\) \\\\ \\( (t_1): ${data2.tangent.tex.canonical} \\) et \\( (t_2): ${data2.symetric.tex.canonical} \\)
+            
+            }{}
+            \\vfill
+            ${i % 2 === 1 ? '\\newpage' : ''}
+            `)
+
+        }
+    })
+//     it('intersection temp tests', () => {
+//         for (let i = 0; i < 30; i++) {
+//             let A = Random.Geometry.point({axis: false}),
+//                 rv = Random.number(1, 3),
+//                 r = rv ** 2 + (rv + 1) ** 2
+//
+//             let c = new Circle(A, r, true)
+//             let pts = c.getPointsOnCircle(true)
+//             // console.log(r, pts.length)
+//
+//             // console.log(c.tex)
+//             // console.log(pts.map(pt => pt.display))
+//             pts = Random.shuffle(pts)
+//             let ptt = pts.shift(),
+//                 pt1 = pts.shift(),
+//                 pt2
+//
+//             for (let pt of pts) {
+//                 if (!pt1.x.isEqual(pt.x) && !pt1.y.isEqual(pt.y) && !A.isEqual(new Point().middleOf(pt1, pt))) {
+//                     pt2 = pt.clone()
+//                     break
+//                 }
+//             }
+//
+//             // console.log('Pt de tangence')
+//             // console.log(ptt.display)
+//             let t = c.tangents(ptt)[0]
+//             // console.log(t.tex.canonical)
+//
+//             // console.log('intersection en deux points')
+//             // console.log(pt1.display, pt2.display)
+//             let d = new Line(pt1, pt2)
+//             // console.log(d.tex.canonical)
+//
+//             let P = Random.Geometry.point()
+//             while (P.x.isEqual(c.center.x) || P.y.isEqual(c.center.y)) {
+//                 P = Random.Geometry.point()
+//             }
+//             // Le point P n'est pas sur le centre.
+//             let v = new Vector(c.center, P)
+//             while (P.distanceTo(A).value <= Math.sqrt(r)) {
+//                 P.x.add(v.x)
+//                 P.y.add(v.y)
+//             }
+//             let p = new Line(P, v, LinePropriety.Perpendicular)
+//             // console.log(P.display)
+//             // console.log(p.display.canonical)
+//
+//             let lignes = Random.shuffle([t, d, p])
+//
+// //             console.log(`A${A.display}
+// // c=circ A,${Math.sqrt(r)}
+// // T${ptt.display}
+// // P${pt1.display}
+// // Q${pt2.display}
+// // t=line ${t.display.canonical}
+// // d=line ${d.display.canonical}
+// // p=line ${p.display.canonical}`)
+//             console.log(`(exercice ${i + 1}): Soit \\(\\Gamma\\) un cercle et \\(d_1\\), \\(d_2\\) et \\(d_3\\) trois droites.
+//             \\mathleft
+//             \\[(\\Gamma): ${c.tex}\\]
+//             \\[(d_1): ${lignes[0].tex.canonical} \\qquad (d_2): ${lignes[1].tex.canonical}  \\qquad (d_3): ${lignes[2].tex.canonical}\\]
+//
+//             \\begin{enumerate}[label=\\Alph*]
+//             \\item déterminer les positions relatives de \\(d_1\\), \\(d_2\\) et \\(d_3\\) par rapport à \\(\\Gamma\\)
+//             \\item calculer les coordonnées du ou des points d'intersection entre le cercle et une des droites qui le coupe (au choix).
+//             \\end{enumerate}
+//             \\iftoggle{master}{\\(${t.tex.canonical}\\implies ${ptt.tex}\\) \\\\ \\(${d.tex.canonical}\\implies ${pt1.tex},\\ ${pt2.tex}\\) \\\\}{}
+//             \\vfill
+//             ${i % 2 === 1 ? '\\newpage' : ''}
+//             `)
+//
+//         }
+//
+//     })
 //     it('temp tests', () => {
 //         for (let i = 0; i < 30; i++) {
 //             let A = Random.Geometry.point({axis: false}),

package/tests/numeric.test.ts

@@ -8,7 +8,7 @@ describe('Numeric', () => { // the tests container
         expect(Numeric.numberCorrection(a)).to.be.equal(0.3)
         const b = Math.pow(10, -5)
 
-        expect(Numeric.numberCorrection(b, 1,12)).to.be.equal(0.00001)
+        expect(Numeric.numberCorrection(b, 1, 12)).to.be.equal(0.00001)
     })
 
 
@@ -21,7 +21,23 @@ describe('Numeric', () => { // the tests container
     })
 
     it('should decompose a number in two factors', function () {
-        expect(Numeric.decompose(25).map(x=>x.join(','))).to.have.all.members(['1,25', '5,5'])
-        expect(Numeric.decompose(6).map(x=>x.join(','))).to.have.all.members(['1,6', '2,3'])
+        expect(Numeric.decompose(25).map(x => x.join(','))).to.have.all.members(['1,25', '5,5'])
+        expect(Numeric.decompose(6).map(x => x.join(','))).to.have.all.members(['1,6', '2,3'])
     });
+
+    it('algo perso', () => {
+        for (let n = 1000; n < 10000; n++) {
+            const a = Math.trunc(n / 1000)
+            const b = Math.trunc((n - 1000 * a) / 100)
+            const c = Math.trunc((n - 1000 * a - 100 * b) / 10)
+            const d = Math.trunc(n - 1000 * a - 100 * b - 10 * c)
+
+            const p = a + b + c + d
+            const p2 = a ** 2 + b ** 2 + c ** 2 + d ** 2
+
+            if (n === p * p2 ** 2) {
+                console.log(n)
+            }
+        }
+    })
 });

package/tsconfig.json

@@ -17,7 +17,7 @@
       "src/maths/geometry/triangle.ts",
       "src/maths/geometry/vector.ts",
       "src/maths/numeric.ts",
-      "src/maths/shutingyard.ts",
+      "src/maths/shutingyard.ts"
     ],
     "plugin": [
       "./typedoc.katex.js"
@@ -25,13 +25,24 @@
     "out": "docs"
   },
   "compilerOptions": {
+    "target": "es2021",
+    "useDefineForClassFields": true,
+    "module": "ESNext",
+    "lib": [
+      "ES2021",
+      "DOM",
+      "DOM.Iterable"
+    ],
+    "skipLibCheck": true,
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noEmit": true,
     "outDir": "./esm/",
     "noImplicitAny": true,
-    "module": "commonjs",
-    "target": "es2021",
     "allowJs": true,
     "sourceMap": true,
-    "moduleResolution": "node",
     "declaration": true,
     "removeComments": false
   },

package/vite.config.js

@@ -0,0 +1,23 @@
+import {defineConfig} from "vite";
+
+export default defineConfig({
+	build: {
+		lib: {
+			entry: "src/main.ts",
+			name: "PiMath",
+			fileName: "pimath"
+		}
+	},
+	rollupOptions: {
+		external: ["vue"],
+		output: {
+			globals: {
+				vue: "Vue"
+			}
+		}
+		// input: {
+		// 	main: resolve(__dirname, "src/index.html"),
+		// 	playground: "src/demo/playground.html"
+		// }
+	}
+})

package/webpack-production.config.js

@@ -1,26 +1,26 @@
 const path = require('path');
 
 module.exports = {
-    mode: 'production',
-    entry: './src/index.ts',
-    devtool: 'source-map',
-    module: {
-        rules: [
-            {
-                test: /\.tsx?$/,
-                use: 'ts-loader',
-                exclude: /node_module/,
-            },
-        ],
-    },
-    resolve: {
-        extensions: ['.tsx','.ts', '.js'],
-    },
-    output: {
-        filename: 'pimath.js',
-        path: path.resolve(__dirname, 'dist'),
-    },
-    optimization: {
-        minimize: false
-    }
+	mode: 'production',
+	entry: './src/main.ts',
+	devtool: 'source-map',
+	module: {
+		rules: [
+			{
+				test: /\.tsx?$/,
+				use: 'ts-loader',
+				exclude: /node_module/,
+			},
+		],
+	},
+	resolve: {
+		extensions: ['.tsx', '.ts', '.js'],
+	},
+	output: {
+		filename: 'pimath.js',
+		path: path.resolve(__dirname, 'dist'),
+	},
+	optimization: {
+		minimize: false
+	}
 };

package/webpack.config.js

@@ -1,26 +1,26 @@
 const path = require('path');
 
 module.exports = {
-    mode: 'development',
-    entry: './src/index.ts',
-    devtool: 'source-map',
-    module: {
-        rules: [
-            {
-                test: /\.tsx?$/,
-                use: 'ts-loader',
-                exclude: /node_module/,
-            },
-        ],
-    },
-    resolve: {
-        extensions: ['.tsx','.ts', '.js'],
-    },
-    output: {
-        filename: 'pimath.js',
-        path: path.resolve(__dirname, 'dev'),
-    },
-    optimization: {
-        minimize: false
-    }
+	mode: 'development',
+	entry: './src/main.ts',
+	devtool: 'source-map',
+	module: {
+		rules: [
+			{
+				test: /\.tsx?$/,
+				use: 'ts-loader',
+				exclude: /node_module/,
+			},
+		],
+	},
+	resolve: {
+		extensions: ['.tsx', '.ts', '.js'],
+	},
+	output: {
+		filename: 'pimath.js',
+		path: path.resolve(__dirname, 'dev'),
+	},
+	optimization: {
+		minimize: false
+	}
 };