geometrix 0.5.10 → 0.5.12

package/src/line.ts

@@ -1,359 +0,0 @@
-// line.ts
-// line.ts deals with lines
-// line.ts depends on angle_utils.ts, triangle_utils.ts and point.ts
-
-import type { tCanvasAdjust } from './canvas_utils';
-//import type { tPolar } from './point';
-//import { colorCanvasPoint } from '$lib/style/colors.scss';
-import { colors, point2canvas } from './canvas_utils';
-import {
-	//degToRad,
-	//radToDeg,
-	roundZero,
-	//withinZero2Pi,
-	withinPiPi,
-	withinZeroPi,
-	withinHPiHPi
-} from './angle_utils';
-import {
-	//rightTriLaFromLbLc,
-	//rightTriLbFromLaLc,
-	//lcFromLaLbAc,
-	//aCFromLaLbLc,
-	//aCFromAaAb
-	lbFromLaAaAb
-	//aBFromLaLbAa
-} from './triangle_utils';
-import { point, Point } from './point';
-
-interface tAffine {
-	quasiVertical: boolean;
-	ha: number;
-	hb: number;
-	va: number;
-	vb: number;
-}
-
-/* Base classes */
-
-class Line {
-	cx: number;
-	cy: number;
-	ca: number;
-	constructor(ix: number, iy: number, ia: number) {
-		this.cx = ix;
-		this.cy = iy;
-		this.ca = ia;
-	}
-	draw(ctx: CanvasRenderingContext2D, cAdjust: tCanvasAdjust, color: string = colors.line) {
-		const display_length = ctx.canvas.width * 2;
-		const [cx1, cy1] = point2canvas(
-			this.cx - display_length * Math.cos(this.ca),
-			this.cy - display_length * Math.sin(this.ca),
-			cAdjust
-		);
-		const [cx2, cy2] = point2canvas(
-			this.cx + 2 * display_length * Math.cos(this.ca),
-			this.cy + 2 * display_length * Math.sin(this.ca),
-			cAdjust
-		);
-		ctx.beginPath();
-		ctx.moveTo(cx1, cy1);
-		ctx.lineTo(cx2, cy2);
-		ctx.strokeStyle = color;
-		ctx.stroke();
-	}
-	setFromPoints(p1: Point, p2: Point) {
-		this.cx = p1.cx;
-		this.cy = p1.cy;
-		this.ca = p1.angleToPoint(p2);
-		return this;
-	}
-	getAffine(): tAffine {
-		const rAffine: tAffine = { quasiVertical: false, ha: 0, hb: 0, va: 0, vb: 0 };
-		const angleZeroHPi = Math.abs(withinHPiHPi(this.ca));
-		if (angleZeroHPi > Math.PI / 4) {
-			// x = va * y + vb
-			rAffine.quasiVertical = true;
-			rAffine.va = -1 * Math.tan(withinHPiHPi(this.ca - Math.PI / 2));
-			rAffine.vb = this.cx - rAffine.va * this.cy;
-		} else {
-			// y = ha * x + hb
-			rAffine.ha = Math.tan(withinHPiHPi(this.ca));
-			rAffine.hb = this.cy - rAffine.ha * this.cx;
-		}
-		return rAffine;
-	}
-	setAffine(iAffine: tAffine): Line {
-		const rLine = new Line(0, 0, 0);
-		if (iAffine.quasiVertical) {
-			rLine.ca = Math.PI / 2 - Math.atan(iAffine.va);
-			rLine.cx = iAffine.vb;
-			rLine.cy = 0;
-		} else {
-			rLine.ca = Math.atan(iAffine.ha);
-			rLine.cx = 0;
-			rLine.cy = iAffine.hb;
-		}
-		return rLine;
-	}
-	// intersection
-	intersection(il: Line): Point {
-		if (this.isParallel(il)) {
-			throw `err902: no intersection, lines are parallel ca1: ${this.ca} ca2: ${il.ca}`;
-		}
-		let rx = 0;
-		let ry = 0;
-		const affin1 = this.getAffine();
-		const affin2 = il.getAffine();
-		if (affin1.quasiVertical) {
-			if (affin2.quasiVertical) {
-				// x = va1 * y + vb1; x = va2 * y + vb2
-				// y = (vb1 - vb2) / (va2 - va1)
-				ry = (affin1.vb - affin2.vb) / (affin2.va - affin1.va);
-				rx = affin1.va * ry + affin1.vb;
-			} else {
-				// x = va1 * y + vb1; y = ha2 * x + hb2
-				// x = va1 * (ha2 * x + hb2) + vb1; x = ((va1 * hb2) + vb1) / (1 - va1 * ha2)
-				rx = (affin1.va * affin2.hb + affin1.vb) / (1 - affin1.va * affin2.ha);
-				ry = affin2.ha * rx + affin2.hb;
-			}
-		} else {
-			if (affin2.quasiVertical) {
-				// y = ha1 * x + hb1; x = va2 * y + vb2
-				// y = ha1 * (va2 * y + vb2) + hb1; y = ((ha1 * vb2) + hb1) / (1 - ha1 * va2)
-				ry = (affin1.ha * affin2.vb + affin1.hb) / (1 - affin1.ha * affin2.va);
-				rx = affin2.va * ry + affin2.vb;
-			} else {
-				// y = ha1 * x + hb1; y = ha2 * x + hb2
-				// y = (hb1 - hb2) / (ha2 - ha1)
-				rx = (affin1.hb - affin2.hb) / (affin2.ha - affin1.ha);
-				ry = affin1.ha * rx + affin1.hb;
-			}
-		}
-		const rp = point(rx, ry);
-		return rp;
-	}
-	getAxisXIntersection(): number {
-		const c_axisX = new Line(0, 0, 0);
-		const rp = this.intersection(c_axisX);
-		return rp.cx;
-	}
-	getAxisYIntersection(): number {
-		const c_axisY = new Line(0, 0, Math.PI / 2);
-		const rp = this.intersection(c_axisY);
-		return rp.cy;
-	}
-	getAxisXIntersecTri(): number {
-		let rX = Infinity;
-		if (roundZero(withinHPiHPi(this.ca)) !== 0) {
-			const p1 = new Point(this.cx, this.cy);
-			const l1ca = withinZeroPi(this.ca);
-			const aC = p1.angleOrig();
-			const la = p1.distanceOrig();
-			if (roundZero(la) === 0) {
-				rX = 0;
-			} else if (roundZero(withinHPiHPi(l1ca - aC)) === 0) {
-				rX = 0;
-			} else {
-				const aA = Math.min(l1ca, Math.PI - l1ca);
-				const aB = withinPiPi(l1ca - aC);
-				const aB2 = Math.min(Math.abs(aB), Math.PI - Math.abs(aB));
-				rX = Math.sign(aB) * lbFromLaAaAb(la, aA, aB2);
-			}
-		}
-		return rX;
-	}
-	getAxisYIntersecTri(): number {
-		let rY = Infinity;
-		if (roundZero(withinHPiHPi(this.ca - Math.PI / 2)) !== 0) {
-			const p1 = new Point(this.cx, this.cy);
-			const l1ca = withinHPiHPi(this.ca);
-			const aC = p1.angleOrig();
-			const la = p1.distanceOrig();
-			const angleDiff = withinHPiHPi(l1ca - aC);
-			if (roundZero(la) === 0) {
-				rY = 0;
-			} else if (roundZero(angleDiff) === 0) {
-				rY = 0;
-			} else {
-				const aA = withinZeroPi(l1ca - Math.PI / 2);
-				const aB = -1 * withinPiPi(l1ca - aC);
-				const aA2 = Math.min(aA, Math.PI - aA);
-				const aB2 = Math.min(Math.abs(aB), Math.PI - Math.abs(aB));
-				rY = Math.sign(aB) * lbFromLaAaAb(la, aA2, aB2);
-			}
-		}
-		return rY;
-	}
-	angleOrig(): number {
-		// compute direction, i.e. top-side or bottom-side
-		const p1 = new Point(this.cx, this.cy);
-		const aC = p1.angleOrig();
-		const l1ca = withinHPiHPi(this.ca);
-		const aB = -1 * withinPiPi(l1ca - aC);
-		let direction = 0;
-		if (aB < 0) {
-			direction = -Math.PI;
-		}
-		// end of direction calculation
-		const ra = withinZeroPi(Math.PI / 2 + this.ca) + direction;
-		return ra;
-	}
-	distanceOrig(): number {
-		const a1 = this.angleOrig();
-		const p1 = new Point(this.cx, this.cy);
-		const a2 = p1.angleOrig();
-		const la = p1.distanceOrig();
-		const a12 = withinHPiHPi(a2 - a1);
-		const rd = la * Math.cos(a12);
-		return rd;
-	}
-	projectOrig(): Point {
-		const pa = this.angleOrig();
-		const pl = this.distanceOrig();
-		return point(0, 0).setPolar(pa, pl);
-	}
-	// methods inherited from point
-	translate(ix: number, iy: number): Line {
-		return new Line(this.cx + ix, this.cy + iy, this.ca);
-	}
-	rotateOrig(ia: number): Line {
-		// rotation with the origin as center
-		const lPoint2 = new Point(this.cx, this.cy).rotateOrig(ia);
-		return new Line(lPoint2.cx, lPoint2.cy, withinPiPi(this.ca + ia));
-	}
-	scaleOrig(ir: number): Line {
-		const lPoint2 = new Point(this.cx, this.cy).scaleOrig(ir);
-		return new Line(lPoint2.cx, lPoint2.cy, this.ca);
-	}
-	rotate(ic: Point, ia: number): Line {
-		const lPoint2 = new Point(this.cx, this.cy).rotate(ic, ia);
-		return new Line(lPoint2.cx, lPoint2.cy, withinPiPi(this.ca + ia));
-	}
-	scale(ic: Point, ir: number): Line {
-		const lPoint2 = new Point(this.cx, this.cy).scale(ic, ir);
-		return new Line(lPoint2.cx, lPoint2.cy, this.ca);
-	}
-	clone(): Line {
-		const lPoint2 = new Point(this.cx, this.cy);
-		return new Line(lPoint2.cx, lPoint2.cy, this.ca);
-	}
-	// end of methods from point
-	// line creation
-	lineOrthogonal(ic: Point): Line {
-		return new Line(ic.cx, ic.cy, this.ca + Math.PI / 2);
-	}
-	lineParallel(ic: Point): Line {
-		return new Line(ic.cx, ic.cy, this.ca);
-	}
-	// orthogonal projection
-	distanceToPoint(ic: Point): number {
-		let rd = 0;
-		const p1 = new Point(this.cx, this.cy);
-		const lp1ic = p1.distanceToPoint(ic);
-		if (roundZero(lp1ic) !== 0) {
-			const aC = p1.angleToPoint(ic);
-			const aB = withinHPiHPi(aC - this.ca);
-			rd = lp1ic * Math.abs(Math.sin(aB));
-		}
-		return rd;
-	}
-	projectPoint(ic: Point): Point {
-		let rd = 0;
-		const p1 = new Point(this.cx, this.cy);
-		const lp1ic = p1.distanceToPoint(ic);
-		if (roundZero(lp1ic) !== 0) {
-			const aC = p1.angleToPoint(ic);
-			const aB = withinPiPi(aC - this.ca);
-			rd = lp1ic * Math.cos(aB);
-		}
-		const rp = p1.translatePolar(this.ca, rd);
-		return rp;
-	}
-	// line comparison
-	isParallel(il: Line): boolean {
-		const rb = roundZero(withinHPiHPi(this.ca - il.ca)) === 0;
-		return rb;
-	}
-	isOrthogonal(il: Line): boolean {
-		const rb = roundZero(withinHPiHPi(Math.PI / 2 + this.ca - il.ca)) === 0;
-		return rb;
-	}
-	isEqual(il: Line): boolean {
-		const p2 = point(il.cx, il.cy);
-		const dist = this.distanceToPoint(p2);
-		const rb = roundZero(dist) === 0 && this.isParallel(il);
-		return rb;
-	}
-	// bisector
-	bisector(il: Line, ip: Point): Line {
-		const pInter = this.intersection(il);
-		const a1t = withinZeroPi(this.ca);
-		const a2t = withinZeroPi(il.ca);
-		const a1 = Math.min(a1t, a2t);
-		const a2 = Math.max(a1t, a2t);
-		const aList = [a1, a2, a1 + Math.PI, a2 + Math.PI, a1];
-		const aRef = pInter.angleToPoint(ip);
-		let idx = 0;
-		for (let i = 0; i < 4; i++) {
-			const aDiff1 = withinPiPi(aList[i] - aRef);
-			const aDiff2 = withinPiPi(aList[i + 1] - aRef);
-			if (aDiff1 === 0 || aDiff2 === 0) {
-				throw `err419: bad reference point for bisecor ${ip.cx} ${ip.cy}`;
-			}
-			if (aDiff1 < 0 && aDiff2 > 0) {
-				idx = i;
-			}
-		}
-		const a0 = withinZeroPi((a1 + a2) / 2);
-		const ca = a0 + (idx * Math.PI) / 2;
-		return new Line(pInter.cx, pInter.cy, ca);
-	}
-	// parallel distance
-	lineParallelDistance(iDist: number, ipMagnet: Point, ipMagnet2: Point): Line {
-		const p1 = point(this.cx, this.cy);
-		const p2a = p1.translatePolar(this.ca + Math.PI / 2, iDist);
-		const p2b = p1.translatePolar(this.ca - Math.PI / 2, iDist);
-		let p2 = p2b;
-		let pMagnet = ipMagnet;
-		if (roundZero(this.distanceToPoint(pMagnet)) === 0) {
-			pMagnet = ipMagnet2;
-		}
-		if (pMagnet.distanceToPoint(p2a) < pMagnet.distanceToPoint(p2b)) {
-			p2 = p2a;
-		}
-		return new Line(p2.cx, p2.cy, this.ca);
-	}
-}
-
-function line(ix: number, iy: number, ia: number): Line {
-	return new Line(ix, iy, ia);
-}
-
-function linePP(ip1: Point, ip2: Point): Line {
-	const rline = line(0, 0, 0).setFromPoints(ip1, ip2);
-	return rline;
-}
-
-function bisector(ip1: Point, ip2: Point): Line {
-	if (ip1.isEqual(ip2)) {
-		throw `err546: no bisector with two same points cx: ${ip1.cx} cy: ${ip1.cy}`;
-	}
-	const pbi = ip1.middlePoint(ip2);
-	const abi = withinZeroPi(ip1.angleToPoint(ip2) + Math.PI / 2);
-	return line(pbi.cx, pbi.cy, abi);
-}
-function circleCenter(ip1: Point, ip2: Point, ip3: Point): Point {
-	if (ip1.isEqual(ip2) || ip2.isEqual(ip3) || ip1.isEqual(ip3)) {
-		throw `err833: no bisector with two same points cx: ${ip1.cx} cy: ${ip1.cy}`;
-	}
-	const bisec1 = bisector(ip1, ip2);
-	const bisec2 = bisector(ip2, ip3);
-	const rp = bisec1.intersection(bisec2);
-	return rp;
-}
-
-/* export */
-
-export { Line, line, linePP, bisector, circleCenter };

package/src/paramFile.ts

@@ -1,52 +0,0 @@
-// paramFile.ts
-
-import type { tParamVal } from './designParams';
-
-interface tParamValInFile {
-	lastModif: string;
-	pVal: tParamVal;
-	comment: string;
-}
-
-function createParamFile(lastModif: string, idparams: tParamVal, comment: string): string {
-	const allVal: tParamValInFile = {
-		lastModif: lastModif,
-		pVal: idparams,
-		comment: comment
-	};
-	const fContentStr = JSON.stringify(allVal, null, '  ');
-	return fContentStr;
-}
-
-function parseParamFile(fContentStr: string): [tParamValInFile, string] {
-	const wholeJson = JSON.parse(fContentStr) as tParamValInFile;
-	const lastModifKey = 'lastModif';
-	const pValKey = 'pVal';
-	const commentKey = 'comment';
-	let rlog = '';
-	const rObj: tParamValInFile = { lastModif: '', pVal: {}, comment: '' };
-	if (Object.hasOwn(wholeJson, lastModifKey)) {
-		rObj[lastModifKey] = wholeJson[lastModifKey];
-	}
-	if (Object.hasOwn(wholeJson, pValKey)) {
-		const paNaVa = wholeJson[pValKey];
-		for (const paNa of Object.keys(paNaVa)) {
-			const paVa = paNaVa[paNa];
-			//const paVa = parseFloat(paVaStr);
-			if (isNaN(paVa)) {
-				throw `err905: ${paVa} is not a number!`;
-			}
-			rObj[pValKey][paNa] = paVa;
-		}
-		rlog += `info398: parsing file has found ${Object.keys(rObj[pValKey]).length} parameters\n`;
-	} else {
-		throw `err489: parameter-json-file has no key ${pValKey}\n`;
-	}
-	if (Object.hasOwn(wholeJson, commentKey)) {
-		rObj[commentKey] = wholeJson[commentKey];
-	}
-	return [rObj, rlog];
-}
-
-export type { tParamValInFile };
-export { createParamFile, parseParamFile };

package/src/point.test.ts

@@ -1,36 +0,0 @@
-import { describe, it, expect } from 'vitest';
-//import type { tPolar } from './point';
-import { Point, point } from './point';
-
-describe('point module', () => {
-	const p1 = new Point(5, 5);
-	const p2 = point(8, 9);
-	const p3 = point(25, 25);
-	it('Point class basic', () => {
-		expect(p1.distanceOrig()).toBeCloseTo(5 * Math.sqrt(2), 5);
-		expect(p1.isEqual(p1)).toBe(true);
-		expect(p1.isEqual(p3)).toBeFalsy();
-	});
-	it('Point translate', () => {
-		expect(p1.translate(1, 2).isEqual(point(6, 7))).toBeTruthy();
-		expect(p1.translatePolar(Math.PI / 2, 10).isEqual(point(5, 15))).toBeTruthy();
-	});
-	it('distanceToPoint function', () => {
-		expect(p1.distanceToPoint(p2)).toBeCloseTo(5);
-	});
-	it('angleToPoint function', () => {
-		expect(p1.angleToPoint(p3)).toBeCloseTo(Math.PI / 4, 5);
-	});
-	const p4 = point(5, -1);
-	const p5 = point(15, 5);
-	it('point creation middle', () => {
-		expect(p1.middlePoint(p4).isEqual(point(5, 2))).toBeTruthy();
-	});
-	it('point creation equidistance', () => {
-		expect(() => p1.equidistantPoint(p4, 2, p2)).toThrowError(/err392/);
-		expect(p1.equidistantPoint(p4, 5, p2).isEqual(point(9, 2))).toBeTruthy();
-		expect(p1.equidistantPoint(p4, 10, p2).isEqual(point(9, 3))).toBeFalsy();
-		expect(() => p1.equidistantPoint(p1, 10, p2)).toThrowError(/err633/);
-		expect(p1.equidistantPoint(p5, 5, p2).isEqual(point(10, 5))).toBeTruthy();
-	});
-});

package/src/point.ts

@@ -1,246 +0,0 @@
-// point.ts
-// point.ts deals with points
-// point.ts depends on canvas_utils.ts
-
-import type { tCanvasAdjust } from './canvas_utils';
-//import { colorCanvasPoint } from '$lib/style/colors.scss';
-import { colors, point2canvas } from './canvas_utils';
-import { roundZero, withinPiPi } from './angle_utils';
-
-type tPolar = [number, number]; // angle, distance
-enum ShapePoint {
-	eDefault,
-	eCircle,
-	eCross,
-	eSquare,
-	eBigSquare,
-	eTwoTri,
-	eTri1,
-	eTri2,
-	eTri3,
-	eTri4
-}
-
-/* Base classes */
-class Point {
-	cx: number;
-	cy: number;
-	shape: ShapePoint;
-	constructor(ix: number, iy: number, ishape = ShapePoint.eDefault) {
-		this.cx = ix;
-		this.cy = iy;
-		this.shape = ishape;
-	}
-	draw(
-		ctx: CanvasRenderingContext2D,
-		cAdjust: tCanvasAdjust,
-		color: string = colors.point,
-		ishape = ShapePoint.eDefault
-	) {
-		if (isFinite(this.cx) && isFinite(this.cy)) {
-			const radius = ctx.canvas.width * (0.7 / 100);
-			const radius2 = 2 * radius;
-			const [cx2, cy2] = point2canvas(this.cx, this.cy, cAdjust);
-			//console.log(`dbg493: ${cx2} ${cy2}`);
-			let shape = ishape;
-			if (shape === ShapePoint.eDefault) {
-				shape = this.shape;
-			}
-			ctx.beginPath();
-			switch (shape) {
-				case ShapePoint.eCross:
-					ctx.moveTo(cx2 - radius2, cy2);
-					ctx.lineTo(cx2 + radius2, cy2);
-					ctx.moveTo(cx2, cy2 - radius2);
-					ctx.lineTo(cx2, cy2 + radius2);
-					break;
-				case ShapePoint.eSquare:
-					ctx.rect(cx2 - radius, cy2 - radius, 2 * radius, 2 * radius);
-					break;
-				case ShapePoint.eBigSquare:
-					ctx.rect(cx2 - 2 * radius, cy2 - 2 * radius, 4 * radius, 4 * radius);
-					break;
-				case ShapePoint.eTwoTri:
-					ctx.moveTo(cx2 - radius2, cy2);
-					ctx.lineTo(cx2 + radius2, cy2);
-					ctx.lineTo(cx2, cy2 + radius2);
-					ctx.lineTo(cx2, cy2 - radius2);
-					ctx.lineTo(cx2 - radius2, cy2);
-					break;
-				case ShapePoint.eTri1:
-					ctx.moveTo(cx2 - radius2, cy2);
-					ctx.lineTo(cx2 + radius2, cy2);
-					ctx.lineTo(cx2, cy2 - radius2);
-					ctx.lineTo(cx2, cy2 + radius2);
-					break;
-				case ShapePoint.eTri2:
-					ctx.moveTo(cx2 + radius2, cy2);
-					ctx.lineTo(cx2 - radius2, cy2);
-					ctx.lineTo(cx2, cy2 - radius2);
-					ctx.lineTo(cx2, cy2 + radius2);
-					break;
-				case ShapePoint.eTri3:
-					ctx.moveTo(cx2 + radius2, cy2);
-					ctx.lineTo(cx2 - radius2, cy2);
-					ctx.lineTo(cx2, cy2 + radius2);
-					ctx.lineTo(cx2, cy2 - radius2);
-					break;
-				case ShapePoint.eTri4:
-					ctx.moveTo(cx2 - radius2, cy2);
-					ctx.lineTo(cx2 + radius2, cy2);
-					ctx.lineTo(cx2, cy2 + radius2);
-					ctx.lineTo(cx2, cy2 - radius2);
-					break;
-				case ShapePoint.eCircle:
-				default:
-					ctx.arc(cx2, cy2, radius, 0, 2 * Math.PI);
-			}
-			ctx.strokeStyle = color;
-			ctx.stroke();
-		} else {
-			console.log(`INFO489: point not draw because of infinity ${this.cx} ${this.cy}`);
-		}
-	}
-	distanceOrig(): number {
-		return Math.sqrt(this.cx ** 2 + this.cy ** 2);
-	}
-	angleOrig(): number {
-		return Math.atan2(this.cy, this.cx);
-	}
-	getPolar(): tPolar {
-		return [this.angleOrig(), this.distanceOrig()];
-	}
-	setPolar(ia: number, il: number): Point {
-		return new Point(il * Math.cos(ia), il * Math.sin(ia));
-	}
-	translate(ix: number, iy: number): Point {
-		return new Point(this.cx + ix, this.cy + iy);
-	}
-	translatePolar(ia: number, il: number): Point {
-		return new Point(this.cx + il * Math.cos(ia), this.cy + il * Math.sin(ia));
-	}
-	clone(ishape = ShapePoint.eDefault): Point {
-		return new Point(this.cx, this.cy, ishape);
-	}
-	rotateOrig(ia: number): Point {
-		// rotation with the origin as center
-		const polar = this.getPolar();
-		return this.setPolar(polar[0] + ia, polar[1]);
-	}
-	scaleOrig(ir: number): Point {
-		const polar = this.getPolar();
-		return this.setPolar(polar[0], polar[1] * ir);
-	}
-	rotate(ic: Point, ia: number): Point {
-		const p1 = this.translate(-1 * ic.cx, -1 * ic.cy);
-		const polar = p1.getPolar();
-		const p2 = this.setPolar(polar[0] + ia, polar[1]);
-		return p2.translate(ic.cx, ic.cy);
-	}
-	scale(ic: Point, ir: number): Point {
-		const p1 = this.translate(-1 * ic.cx, -1 * ic.cy);
-		const polar = p1.getPolar();
-		const p2 = this.setPolar(polar[0], polar[1] * ir);
-		return p2.translate(ic.cx, ic.cy);
-	}
-	// point comparison
-	isEqual(ic: Point): boolean {
-		const rb = roundZero(this.cx - ic.cx) === 0 && roundZero(this.cy - ic.cy) === 0;
-		return rb;
-	}
-	// measurement
-	distanceToPoint(p2: Point): number {
-		const rd = Math.sqrt((p2.cx - this.cx) ** 2 + (p2.cy - this.cy) ** 2);
-		return rd;
-	}
-	angleToPoint(p2: Point): number {
-		if (roundZero(this.distanceToPoint(p2)) === 0) {
-			throw `err434: no angle because points identical ${this.cx} ${p2.cx} ${this.cy} ${p2.cy}`;
-		}
-		const ra = Math.atan2(p2.cy - this.cy, p2.cx - this.cx);
-		return ra;
-	}
-	angleFromToPoints(p2: Point, p3: Point): number {
-		const ap2 = this.angleToPoint(p2);
-		const ap3 = this.angleToPoint(p3);
-		const ra = withinPiPi(ap3 - ap2);
-		return ra;
-	}
-	// from 2 points create a new point
-	middlePoint(p2: Point): Point {
-		const rx = (this.cx + p2.cx) / 2;
-		const ry = (this.cy + p2.cy) / 2;
-		return new Point(rx, ry);
-	}
-	equidistantPoint(p2: Point, dist: number, p3: Point): Point {
-		const lp1p2h = this.distanceToPoint(p2) / 2;
-		if (this.isEqual(p2)) {
-			throw `err633: no equidistance because identical point ${this.cx} ${this.cy}`;
-		}
-		if (dist < lp1p2h) {
-			throw `err392: equidistance ${dist} smaller than lp1p2h ${lp1p2h}`;
-		}
-		const pbi = this.middlePoint(p2);
-		const abi = this.angleToPoint(p2) + Math.PI / 2;
-		const oppos = Math.sqrt(dist ** 2 - lp1p2h ** 2);
-		const rp1 = pbi.translatePolar(abi, oppos);
-		const rp2 = pbi.translatePolar(abi + Math.PI, oppos);
-		const dp1 = p3.distanceToPoint(rp1);
-		const dp2 = p3.distanceToPoint(rp2);
-		if (oppos !== 0 && dp1 === dp2) {
-			throw `err284: magnet point p3 is on line p1p2. cx ${p3.cx} cy: ${p3.cy}`;
-		}
-		let rp = rp1;
-		if (dp2 < dp1) {
-			rp = rp2;
-		}
-		return rp;
-	}
-}
-
-function point(ix: number, iy: number, ishape = ShapePoint.eDefault) {
-	return new Point(ix, iy, ishape);
-}
-
-function pointMinMax(aPoint: Point[]): [number, number, number, number] {
-	let xMin = 0;
-	let xMax = 0;
-	let yMin = 0;
-	let yMax = 0;
-	if (aPoint.length > 0) {
-		// the first point of the list should not contain infinity
-		const p0 = aPoint[0];
-		if (
-			p0.cx === Number.NEGATIVE_INFINITY ||
-			p0.cx === Number.POSITIVE_INFINITY ||
-			p0.cy === Number.NEGATIVE_INFINITY ||
-			p0.cy === Number.POSITIVE_INFINITY
-		) {
-			throw `err292: pointMinMax first point with infinity: ${p0.cx} ${p0.cy}`;
-		}
-		xMin = aPoint[0].cx;
-		xMax = aPoint[0].cx;
-		yMin = aPoint[0].cy;
-		yMax = aPoint[0].cy;
-		for (const p of aPoint) {
-			if (p.cx !== Number.NEGATIVE_INFINITY) {
-				xMin = Math.min(xMin, p.cx);
-			}
-			if (p.cx !== Number.POSITIVE_INFINITY) {
-				xMax = Math.max(xMax, p.cx);
-			}
-			if (p.cy !== Number.NEGATIVE_INFINITY) {
-				yMin = Math.min(yMin, p.cy);
-			}
-			if (p.cy !== Number.POSITIVE_INFINITY) {
-				yMax = Math.max(yMax, p.cy);
-			}
-		}
-	}
-	return [xMin, xMax, yMin, yMax];
-}
-
-/* export */
-
-export type { tPolar };
-export { ShapePoint, Point, point, pointMinMax };