geometrix 0.5.10 → 0.5.12

package/src/designParams.ts

@@ -1,178 +0,0 @@
-// designParams
-
-enum PType {
-	eNumber,
-	eCheckbox,
-	eDropdown
-}
-
-interface tParam {
-	name: string;
-	unit: string;
-	init: number;
-	min: number;
-	max: number;
-	step: number;
-	dropdown: string[];
-	pType: PType;
-}
-interface tSimTime {
-	tMax: number;
-	tStep: number;
-	tUpdate: number; // in ms
-}
-interface tParamDef {
-	partName: string;
-	params: tParam[];
-	paramSvg: Record<string, string>;
-	sim: tSimTime;
-}
-
-type tParamVal = Record<string, number>;
-type tParamChanged = Record<string, boolean>;
-
-interface tDesignParamOne {
-	val: number;
-	init: number;
-	chg: boolean;
-}
-
-function oneDesignParam(iVal: number, iInit: number, iChg: boolean): tDesignParamOne {
-	const oneDP: tDesignParamOne = { val: iVal, init: iInit, chg: iChg };
-	return oneDP;
-}
-
-type tDesignParamList = Record<string, tDesignParamOne>;
-
-function paramListToVal(dpList: tDesignParamList): tParamVal {
-	const rParamVal: tParamVal = {};
-	for (const pa of Object.keys(dpList)) {
-		rParamVal[pa] = dpList[pa].val;
-	}
-	return rParamVal;
-}
-
-class DesignParam {
-	paramVal: tParamVal = {};
-	paramInit: tParamVal = {};
-	paramChanged: tParamChanged = {};
-	partName: string;
-	paramNames: string[];
-	getParamName(): string[] {
-		const rNames: string[] = [];
-		for (const pName of Object.keys(this.paramVal)) {
-			rNames.push(pName);
-		}
-		return rNames;
-	}
-	constructor(iparamDef: tParamDef) {
-		for (const pi of iparamDef.params) {
-			this.paramVal[pi.name] = pi.init;
-			this.paramInit[pi.name] = pi.init;
-			this.paramChanged[pi.name] = false;
-		}
-		this.partName = iparamDef.partName;
-		this.paramNames = this.getParamName();
-	}
-	getPartName(): string {
-		return this.partName;
-	}
-	getParamVal(): tParamVal {
-		return this.paramVal;
-	}
-	getVal(iname: string): number {
-		if (this.paramNames.includes(iname)) {
-			return this.paramVal[iname];
-		} else {
-			throw `err140: parameter ${iname} does not exist in design ${this.partName}`;
-		}
-	}
-	getInit(iname: string): number {
-		if (this.paramNames.includes(iname)) {
-			return this.paramInit[iname];
-		} else {
-			throw `err149: parameter ${iname} does not exist in design ${this.partName}`;
-		}
-	}
-	getChanged(iname: string): boolean {
-		if (this.paramNames.includes(iname)) {
-			return this.paramChanged[iname];
-		} else {
-			throw `err156: parameter ${iname} does not exist in design ${this.partName}`;
-		}
-	}
-	setVal(iname: string, ival: number) {
-		if (this.paramNames.includes(iname)) {
-			this.paramVal[iname] = ival;
-			this.paramChanged[iname] = true;
-		} else {
-			throw `err163: parameter ${iname} does not exist in design ${this.partName}`;
-		}
-	}
-	applyParamVal(iValues: tParamVal): string {
-		let rlog = '';
-		for (const pa of Object.keys(iValues)) {
-			this.setVal(pa, iValues[pa]);
-		}
-		rlog += `info104: apply ${Object.keys(iValues).length} parameters on ${this.partName}\n`;
-		return rlog;
-	}
-	applyParamList(iValues: tDesignParamList): string {
-		const rlog = this.applyParamVal(paramListToVal(iValues));
-		return rlog;
-	}
-	getDesignParamList(): tDesignParamList {
-		const rDPList: tDesignParamList = {};
-		for (const pi of this.paramNames) {
-			rDPList[pi] = oneDesignParam(this.getVal(pi), this.getInit(pi), this.getChanged(pi));
-		}
-		return rDPList;
-	}
-}
-
-function designParam(iparamDef: tParamDef): DesignParam {
-	return new DesignParam(iparamDef);
-}
-
-function pNumber(name: string, unit: string, init: number, min = 0, max = 100, step = 1): tParam {
-	const rParam: tParam = {
-		name: name,
-		unit: unit,
-		init: init,
-		min: min,
-		max: max,
-		step: step,
-		dropdown: [],
-		pType: PType.eNumber
-	};
-	return rParam;
-}
-function pCheckbox(name: string, init: boolean): tParam {
-	const rParam: tParam = {
-		name: name,
-		unit: 'checkbox',
-		init: init ? 1 : 0,
-		min: 0,
-		max: 1,
-		step: 1,
-		dropdown: [],
-		pType: PType.eCheckbox
-	};
-	return rParam;
-}
-function pDropdown(name: string, values: string[]): tParam {
-	const rParam: tParam = {
-		name: name,
-		unit: 'dropdown',
-		init: 0,
-		min: 0,
-		max: values.length - 1,
-		step: 1,
-		dropdown: values,
-		pType: PType.eDropdown
-	};
-	return rParam;
-}
-
-export type { tParamDef, tParamVal, tDesignParamList, DesignParam };
-export { PType, pNumber, pCheckbox, pDropdown, designParam, paramListToVal, oneDesignParam };

package/src/figure.test.ts

@@ -1,21 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { degToRad, radToDeg, roundZero, point } from './figure';
-
-describe('angle suit', () => {
-	it('radian to degree', () => {
-		expect(roundZero(radToDeg(Math.PI / 3) - 60)).toBe(0);
-	});
-	it('degree to radian', () => {
-		expect(roundZero(degToRad(45) - Math.PI / 4)).toBe(0);
-	});
-});
-
-describe('point suit', () => {
-	it('coordinate cartesian to polar', () => {
-		const cpolar = point(2, 2).getPolar();
-		expect([
-			roundZero(cpolar[0] - Math.PI / 4),
-			roundZero(cpolar[1] - Math.sqrt(8))
-		]).toStrictEqual([0, 0]);
-	});
-});

package/src/figure.ts

@@ -1,400 +0,0 @@
-// figure.ts
-// a minimalistic 2D euclid geometry calculation library
-// figure.ts deals with points, lines, vectors, contours
-// figure.ts gather all other modules of geom
-
-import type { tCanvasAdjust } from './canvas_utils';
-//import { colorCanvasPoint } from '$lib/style/colors.scss';
-import { colors, adjustZero, adjustInit } from './canvas_utils';
-import { withinZero2Pi, withinPiPi, degToRad, radToDeg, roundZero, ffix } from './angle_utils';
-import { lcFromLaLbAc, aCFromLaLbLc, lbFromLaAaAb, aBFromLaLbAa } from './triangle_utils';
-import { ShapePoint, Point, point, pointMinMax } from './point';
-import { Line, line, linePP, bisector, circleCenter } from './line';
-import { Vector, vector } from './vector';
-import type { tContour } from './contour';
-import { contour, contourCircle } from './contour';
-
-interface tLayers {
-	points: boolean;
-	lines: boolean;
-	vectors: boolean;
-	main: boolean;
-	mainB: boolean;
-	second: boolean;
-	secondB: boolean;
-	dynamics: boolean;
-	ruler: boolean;
-	refframe: boolean;
-}
-
-class Figure {
-	pointList: Point[];
-	lineList: Line[];
-	vectorList: Vector[];
-	mainList: tContour[];
-	mainBList: tContour[];
-	secondList: tContour[];
-	secondBList: tContour[];
-	dynamicsList: tContour[];
-	xMin: number;
-	xMax: number;
-	yMin: number;
-	yMax: number;
-	constructor() {
-		this.pointList = [];
-		this.lineList = [];
-		this.vectorList = [];
-		this.mainList = [];
-		this.mainBList = [];
-		this.secondList = [];
-		this.secondBList = [];
-		this.dynamicsList = [];
-		this.xMin = 0;
-		this.xMax = 0;
-		this.yMin = 0;
-		this.yMax = 0;
-	}
-	addPoint(ipoint: Point) {
-		this.pointList.push(ipoint);
-	}
-	addPoints(ipoints: Point[]) {
-		//for (const ipt of ipoints) {
-		//	this.pointList.push(ipt);
-		//}
-		this.pointList.push(...ipoints);
-	}
-	addLine(iline: Line) {
-		this.lineList.push(iline);
-	}
-	addLines(ilines: Line[]) {
-		for (const iline of ilines) {
-			this.lineList.push(iline);
-		}
-	}
-	addVector(ivector: Vector) {
-		this.vectorList.push(ivector);
-	}
-	addMain(icontour: tContour) {
-		const roundedContour = icontour.generateContour();
-		this.addPoints(roundedContour.generatePoints());
-		//this.addPoints(icontour.generatePoints()); // points of the skeleton
-		this.addLines(roundedContour.generateLines());
-		this.mainList.push(roundedContour);
-		this.mainBList.push(icontour.extractSkeleton());
-	}
-	addSecond(icontour: tContour) {
-		const roundedContour = icontour.generateContour();
-		this.addPoints(roundedContour.generatePoints());
-		//this.addPoints(icontour.generatePoints()); // points of the skeleton
-		this.addLines(roundedContour.generateLines());
-		this.secondList.push(roundedContour);
-		this.secondBList.push(icontour.extractSkeleton());
-	}
-	addDynamics(icontour: tContour) {
-		this.addPoints(icontour.generatePoints());
-		this.addLines(icontour.generateLines());
-		this.dynamicsList.push(icontour);
-	}
-	translate(ix: number, iy: number): Figure {
-		const rfig = new Figure();
-		for (const pt of this.pointList) {
-			rfig.addPoint(pt.translate(ix, iy));
-		}
-		for (const li of this.lineList) {
-			rfig.addLine(li.translate(ix, iy));
-		}
-		for (const vec of this.vectorList) {
-			rfig.addVector(vec.translate(ix, iy));
-		}
-		for (const ctr of this.mainList) {
-			rfig.addMain(ctr.translate(ix, iy));
-		}
-		for (const ctr of this.secondList) {
-			rfig.addSecond(ctr.translate(ix, iy));
-		}
-		for (const ctr of this.dynamicsList) {
-			rfig.addDynamics(ctr.translate(ix, iy));
-		}
-		return rfig;
-	}
-	translatePolar(ia: number, il: number): Figure {
-		return this.translate(il * Math.cos(ia), il * Math.sin(ia));
-	}
-	rotate(ix: number, iy: number, ia: number): Figure {
-		const rfig = new Figure();
-		const pt0 = point(ix, iy);
-		for (const pt of this.pointList) {
-			rfig.addPoint(pt.rotate(pt0, ia));
-		}
-		for (const li of this.lineList) {
-			rfig.addLine(li.rotate(pt0, ia));
-		}
-		for (const vec of this.vectorList) {
-			rfig.addVector(vec.rotate(pt0, ia));
-		}
-		for (const ctr of this.mainList) {
-			rfig.addMain(ctr.rotate(ix, iy, ia));
-		}
-		for (const ctr of this.secondList) {
-			rfig.addSecond(ctr.rotate(ix, iy, ia));
-		}
-		for (const ctr of this.dynamicsList) {
-			rfig.addDynamics(ctr.rotate(ix, iy, ia));
-		}
-		return rfig;
-	}
-	mergeFigure(ifig: Figure, mainToSecond = false) {
-		for (const pt of ifig.pointList) {
-			this.addPoint(pt.clone());
-		}
-		for (const li of ifig.lineList) {
-			this.addLine(li.clone());
-		}
-		for (const vec of ifig.vectorList) {
-			this.addVector(vec.clone());
-		}
-		for (const ctr of ifig.mainList) {
-			if (mainToSecond) {
-				this.addSecond(ctr.clone());
-			} else {
-				this.addMain(ctr.clone());
-			}
-		}
-		for (const ctr of ifig.secondList) {
-			this.addSecond(ctr.clone());
-		}
-		for (const ctr of ifig.dynamicsList) {
-			this.addDynamics(ctr.clone());
-		}
-	}
-	clear() {
-		this.pointList = [];
-		this.lineList = [];
-		this.vectorList = [];
-		this.mainList = [];
-		this.mainBList = [];
-		this.secondList = [];
-		this.secondBList = [];
-		this.dynamicsList = [];
-	}
-	getMinMax() {
-		[this.xMin, this.xMax, this.yMin, this.yMax] = pointMinMax(this.pointList);
-		//console.log(`dbg137: ${this.xMin}, ${this.xMax}, ${this.yMin}, ${this.yMax}`);
-	}
-	getAdjustFull(iCanvasWidth: number, iCanvasHeight: number): tCanvasAdjust {
-		//console.log(`dbg140: ${iCanvasWidth}, ${iCanvasHeight}`);
-		let rCanvasAdjust: tCanvasAdjust = adjustZero();
-		if (this.pointList.length > 0) {
-			this.getMinMax();
-			rCanvasAdjust = adjustInit(
-				this.xMin,
-				this.xMax,
-				this.yMin,
-				this.yMax,
-				iCanvasWidth,
-				iCanvasHeight
-			);
-		}
-		//console.log(`dbg150: ${rCanvasAdjust.shiftX}, ${rCanvasAdjust.scaleX}`);
-		return rCanvasAdjust;
-	}
-	getAdjustZoom(iCanvasWidth: number, iCanvasHeight: number): tCanvasAdjust {
-		//console.log(`dbg140: ${iCanvasWidth}, ${iCanvasHeight}`);
-		let rCanvasAdjust: tCanvasAdjust = adjustZero();
-		if (this.pointList.length > 0) {
-			this.getMinMax();
-			const xMin = (this.xMin + this.xMax) / 2;
-			const yMin = (this.yMin + this.yMax) / 2;
-			rCanvasAdjust = adjustInit(
-				xMin,
-				this.xMax,
-				yMin,
-				this.yMax,
-				iCanvasWidth,
-				iCanvasHeight
-			);
-		}
-		//console.log(`dbg150: ${rCanvasAdjust.shiftX}, ${rCanvasAdjust.scaleX}`);
-		return rCanvasAdjust;
-	}
-	quantifyRuler(canvasWidth: number, adjust: tCanvasAdjust) {
-		const minWidth = canvasWidth / 10;
-		const lsizep = minWidth / adjust.scaleX;
-		let lref = 0.0001;
-		while (lref < lsizep) {
-			lref *= 10;
-		}
-		if (lref / 5 > lsizep) {
-			lref /= 5;
-		} else if (lref / 2 > lsizep) {
-			lref /= 2;
-		}
-		const lsize = lref * adjust.scaleX; // radius2canvas
-		return [lref, lsize];
-	}
-	drawRuler(ctx: CanvasRenderingContext2D, adjust: tCanvasAdjust, color: string) {
-		const [lref, lsize] = this.quantifyRuler(ctx.canvas.width, adjust);
-		const xpos = ctx.canvas.width - 10 - lsize;
-		//ctx.clearRect(xpos, 5, 100, 25);
-		ctx.font = '15px Arial';
-		ctx.fillStyle = color;
-		ctx.fillText(`${lref.toFixed(4)}`, xpos, 20);
-		ctx.beginPath();
-		ctx.moveTo(xpos, 25);
-		ctx.lineTo(xpos + lsize, 25);
-		ctx.lineTo(xpos + lsize, 25 + lsize);
-		ctx.strokeStyle = color;
-		ctx.stroke();
-	}
-	draw(ctx: CanvasRenderingContext2D, adjust: tCanvasAdjust, layers: tLayers) {
-		if (layers.points) {
-			for (const p of this.pointList) {
-				p.draw(ctx, adjust);
-			}
-		}
-		if (layers.lines) {
-			for (const li of this.lineList) {
-				li.draw(ctx, adjust);
-			}
-		}
-		if (layers.vectors) {
-			for (const li of this.vectorList) {
-				li.draw(ctx, adjust);
-			}
-		}
-		if (layers.main) {
-			for (const li of this.mainList) {
-				li.draw(ctx, adjust, colors.main);
-			}
-		}
-		if (layers.mainB) {
-			for (const li of this.mainBList) {
-				li.draw(ctx, adjust, colors.mainB);
-			}
-		}
-		if (layers.second) {
-			for (const li of this.secondList) {
-				li.draw(ctx, adjust, colors.second);
-			}
-		}
-		if (layers.secondB) {
-			for (const li of this.secondBList) {
-				li.draw(ctx, adjust, colors.secondB);
-			}
-		}
-		if (layers.dynamics) {
-			for (const li of this.dynamicsList) {
-				li.draw(ctx, adjust, colors.dynamics);
-			}
-		}
-		if (layers.ruler) {
-			this.drawRuler(ctx, adjust, colors.ruler);
-		}
-		if (layers.refframe) {
-			for (const i of [10, 100, 200]) {
-				point(i, 0).draw(ctx, adjust, colors.reference, ShapePoint.eCross);
-				point(-i, 0).draw(ctx, adjust, colors.reference, ShapePoint.eCross);
-				point(0, i).draw(ctx, adjust, colors.reference, ShapePoint.eCross);
-				point(0, -i).draw(ctx, adjust, colors.reference, ShapePoint.eCross);
-			}
-			point(0, 0).draw(ctx, adjust, colors.origin, ShapePoint.eCross);
-		}
-	}
-}
-
-function figure() {
-	return new Figure();
-}
-
-type tFaces = Record<string, Figure>;
-function mergeFaces(iFaces: tFaces): Figure {
-	const rfig = figure();
-	for (const face in iFaces) {
-		const fig = iFaces[face];
-		for (const ipoint of fig.pointList) {
-			rfig.pointList.push(ipoint);
-		}
-		for (const iline of fig.lineList) {
-			rfig.lineList.push(iline);
-		}
-		for (const ivector of fig.vectorList) {
-			rfig.vectorList.push(ivector);
-		}
-		for (const ctr of fig.mainList) {
-			rfig.mainList.push(ctr);
-		}
-		for (const ctr of fig.mainBList) {
-			rfig.mainBList.push(ctr);
-		}
-		for (const ctr of fig.secondList) {
-			rfig.secondList.push(ctr);
-		}
-		for (const ctr of fig.secondBList) {
-			rfig.secondBList.push(ctr);
-		}
-		for (const ctr of fig.dynamicsList) {
-			rfig.dynamicsList.push(ctr);
-		}
-	}
-	return rfig;
-}
-
-function initLayers(): tLayers {
-	const layers: tLayers = {
-		points: false,
-		lines: false,
-		vectors: false,
-		main: true,
-		mainB: false,
-		second: true,
-		secondB: false,
-		dynamics: false,
-		ruler: true,
-		refframe: false
-	};
-	return layers;
-}
-function copyLayers(iLayers: tLayers): tLayers {
-	const layers: tLayers = {
-		points: iLayers.points,
-		lines: iLayers.lines,
-		vectors: iLayers.vectors,
-		main: iLayers.main,
-		mainB: iLayers.mainB,
-		second: iLayers.second,
-		secondB: iLayers.secondB,
-		dynamics: iLayers.dynamics,
-		ruler: iLayers.ruler,
-		refframe: iLayers.refframe
-	};
-	return layers;
-}
-
-/* export */
-
-export type { Point, tContour, tLayers, Figure, tFaces };
-export {
-	ShapePoint,
-	withinZero2Pi,
-	withinPiPi,
-	degToRad,
-	radToDeg,
-	roundZero,
-	ffix,
-	lcFromLaLbAc,
-	aCFromLaLbLc,
-	lbFromLaAaAb,
-	aBFromLaLbAa,
-	point,
-	line,
-	linePP,
-	bisector,
-	circleCenter,
-	vector,
-	contour,
-	contourCircle,
-	figure,
-	mergeFaces,
-	initLayers,
-	copyLayers
-};

package/src/index.ts

@@ -1,16 +0,0 @@
-// index.ts (previously geom.ts)
-
-export * from './canvas_utils';
-
-//import type { Point, tContour, tLayers, Figure } from './figure';
-//export type { Point, tContour, tLayers, Figure };
-//export type * from './figure';
-export * from './figure';
-
-export * from './designParams';
-export * from './volume';
-export * from './sub_design';
-export * from './aaParamGeom';
-
-export * from './aaExportFile';
-export * from './paramFile';

package/src/line.test.ts

@@ -1,78 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { Line, line, bisector, circleCenter } from './line';
-import { point } from './point';
-import { degToRad } from './angle_utils';
-
-describe('line module', () => {
-	const l1 = new Line(10, 10, Math.PI / 4);
-	const l2 = line(20, 20, (3 / 4) * Math.PI);
-	const p1 = point(30, 30);
-	const p2 = point(30, -30);
-	const lr1 = line(9, -3, degToRad(288));
-	const lr2 = line(-15, -33, degToRad(-37));
-	it('Line construction', () => {
-		expect(() => new Line(0, 0, 0).setFromPoints(p1, p1)).toThrowError(/err434/);
-		expect(new Line(0, 0, 0).setFromPoints(p2, p1).ca).toBeCloseTo(Math.PI / 2, 5);
-	});
-	it('Line Affine', () => {
-		const l1Affine = l1.getAffine();
-		const l1b = line(0, 0, 0).setAffine(l1Affine);
-		expect(l1.isEqual(l1b)).toBeTruthy();
-		const lr1Affine = lr1.getAffine();
-		const lr1b = line(0, 0, 0).setAffine(lr1Affine);
-		expect(lr1.isEqual(lr1b)).toBeTruthy();
-	});
-	it('Line Axis X and Y intersection', () => {
-		expect(l1.getAxisXIntersection()).toBeCloseTo(0, 5);
-		expect(l2.getAxisXIntersection()).toBeCloseTo(40, 5);
-		expect(l1.getAxisYIntersection()).toBeCloseTo(0, 5);
-		expect(l2.getAxisYIntersection()).toBeCloseTo(40, 5);
-	});
-	it('Line Axis X and Y intersection with triangulation', () => {
-		expect(lr1.getAxisXIntersecTri()).toBeCloseTo(lr1.getAxisXIntersection(), 5);
-		expect(lr2.getAxisXIntersecTri()).toBeCloseTo(lr2.getAxisXIntersection(), 5);
-		expect(lr1.getAxisYIntersecTri()).toBeCloseTo(lr1.getAxisYIntersection(), 5);
-		expect(lr2.getAxisYIntersecTri()).toBeCloseTo(lr2.getAxisYIntersection(), 5);
-	});
-	it('Line distance to Origine', () => {
-		expect(l1.distanceOrig()).toBeCloseTo(0, 5);
-		expect(l2.distanceOrig()).toBeCloseTo(20 * Math.sqrt(2), 5);
-	});
-	const l3 = line(50, 0, Math.PI / 2);
-	const l4 = line(0, 60, 0);
-	it('Line orthogonal projection', () => {
-		expect(l1.distanceToPoint(point(10, 10))).toBeCloseTo(0, 5);
-		expect(l1.distanceToPoint(point(0, 0))).toBeCloseTo(0, 5);
-		expect(l1.distanceToPoint(point(10, -10))).toBeCloseTo(10 * Math.sqrt(2), 5);
-		expect(l3.distanceToPoint(point(50, 10))).toBeCloseTo(0, 5);
-		expect(l3.distanceToPoint(point(30, 10))).toBeCloseTo(20, 5);
-		expect(l4.distanceToPoint(point(-10, 60))).toBeCloseTo(0, 5);
-		expect(l4.distanceToPoint(point(20, 90))).toBeCloseTo(30, 5);
-	});
-	const l5 = line(-30, -30, -Math.PI / 2);
-	const l6 = line(-30, 40, -Math.PI / 2);
-	it('Line comparison', () => {
-		expect(l1.isOrthogonal(l2)).toBeTruthy();
-		expect(l1.isOrthogonal(l1)).toBeFalsy();
-		expect(l1.isOrthogonal(l3)).toBeFalsy();
-		expect(l1.isParallel(l2)).toBeFalsy();
-		expect(l3.isParallel(l5)).toBeTruthy();
-		expect(l3.isParallel(l3)).toBeTruthy();
-		expect(l4.isParallel(l1)).toBeFalsy();
-		expect(l1.isEqual(l1)).toBeTruthy();
-		expect(l1.isEqual(l2)).toBeFalsy();
-		expect(l5.isEqual(l6)).toBeTruthy();
-	});
-	it('Bisector of 2 points', () => {
-		const lAxisX = line(0, 0, 0);
-		expect(bisector(p1, p2).isEqual(lAxisX)).toBeTruthy();
-	});
-	it('Circle-center of 3 points', () => {
-		const pA = point(38, 54);
-		const pB = point(-5, 28);
-		const pC = point(5, 79);
-		expect(circleCenter(pA, pB, pC).isEqual(circleCenter(pA, pC, pB))).toBeTruthy();
-		expect(circleCenter(pA, pB, pC).isEqual(circleCenter(pC, pA, pB))).toBeTruthy();
-		expect(circleCenter(pA, pB, pC).isEqual(circleCenter(pB, pA, pC))).toBeTruthy();
-	});
-});