goscript 0.0.34 → 0.0.36

package/gs/math/j0.gs.test.ts

@@ -0,0 +1,74 @@
+import { describe, it, expect } from 'vitest'
+import { J0, Y0 } from './j0.gs.js'
+
+describe('J0', () => {
+  it('should return correct values for zero and small inputs', () => {
+    expect(J0(0)).toBe(1)
+    expect(J0(1)).toBeCloseTo(0.7651976865579666, 14)
+    expect(J0(2)).toBeCloseTo(0.22389077914123567, 6)
+  })
+
+  it('should return correct values for various inputs', () => {
+    expect(J0(3)).toBeCloseTo(-0.2600519549019335, 5)
+    expect(J0(5)).toBeCloseTo(-0.1775967713143383, 6)
+    expect(J0(10)).toBeCloseTo(-0.24593576445134832, 5)
+  })
+
+  it('should be an even function', () => {
+    const testValues = [1, 2, 3, 5, 10]
+    for (const x of testValues) {
+      expect(J0(-x)).toBeCloseTo(J0(x), 14)
+    }
+  })
+
+  it('should handle special values', () => {
+    expect(J0(Number.POSITIVE_INFINITY)).toBe(0)
+    expect(J0(Number.NEGATIVE_INFINITY)).toBe(0)
+    expect(Number.isNaN(J0(Number.NaN))).toBe(true)
+  })
+
+  it('should oscillate for large values', () => {
+    // J0 should oscillate around 0 for large x
+    const largeValues = [20, 30, 50, 100]
+    for (const x of largeValues) {
+      expect(Math.abs(J0(x))).toBeLessThan(0.5)
+    }
+  })
+})
+
+describe('Y0', () => {
+  it('should return correct values for positive inputs', () => {
+    expect(Y0(1)).toBeCloseTo(0.08825696421567696, 14)
+    expect(Y0(2)).toBeCloseTo(0.5103756726497451, 5)
+    expect(Y0(5)).toBeCloseTo(-0.3085176252490338, 5)
+  })
+
+  it('should approach negative infinity as x approaches 0 from positive side', () => {
+    expect(Y0(0.001)).toBeLessThan(-4)
+    expect(Y0(0.0001)).toBeLessThan(-5)
+  })
+
+  it('should handle special values', () => {
+    expect(Y0(Number.POSITIVE_INFINITY)).toBe(0)
+    // Check if Y0(0) returns a very large negative number or -Infinity
+    const y0_zero = Y0(0)
+    expect(y0_zero < -1e10 || y0_zero === Number.NEGATIVE_INFINITY || Number.isNaN(y0_zero)).toBe(true)
+    expect(Number.isNaN(Y0(-1))).toBe(true)
+    expect(Number.isNaN(Y0(Number.NEGATIVE_INFINITY))).toBe(true)
+    expect(Number.isNaN(Y0(Number.NaN))).toBe(true)
+  })
+
+  it('should oscillate for large values', () => {
+    // Y0 should oscillate around 0 for large x
+    const largeValues = [20, 30, 50, 100]
+    for (const x of largeValues) {
+      expect(Math.abs(Y0(x))).toBeLessThan(0.5)
+    }
+  })
+
+  it('should be undefined for negative values', () => {
+    expect(Number.isNaN(Y0(-1))).toBe(true)
+    expect(Number.isNaN(Y0(-5))).toBe(true)
+    expect(Number.isNaN(Y0(-10))).toBe(true)
+  })
+}) 

package/gs/math/j0.gs.ts

@@ -0,0 +1,257 @@
+import * as $ from "@goscript/builtin/builtin.js";
+import { Abs } from "./abs.gs.js";
+import { Inf, IsInf, IsNaN, NaN } from "./bits.gs.js";
+import { Log } from "./log.gs.js";
+import { Cos } from "./sin.gs.js";
+import { Sincos } from "./sincos.gs.js";
+import { Sqrt } from "./sqrt.gs.js";
+
+// J0 returns the order-zero Bessel function of the first kind.
+//
+// Special cases are:
+//
+//	J0(±Inf) = 0
+//	J0(0) = 1
+//	J0(NaN) = NaN
+export function J0(x: number): number {
+	// Constants
+	const TwoM27: number = 1.0 / (1 << 27); // 2**-27
+	const TwoM13: number = 1.0 / (1 << 13); // 2**-13
+	const Two129: number = Math.pow(2, 129); // 2**129
+	
+	// R0/S0 coefficients on [0, 2]
+	const R02: number = 1.56249999999999947958e-02;
+	const R03: number = -1.89979294238854721751e-04;
+	const R04: number = 1.82954049532700665670e-06;
+	const R05: number = -4.61832688532103189199e-09;
+	const S01: number = 1.56191029464890010492e-02;
+	const S02: number = 1.16926784663337450260e-04;
+	const S03: number = 5.13546550207318111446e-07;
+	const S04: number = 1.16614003333790000205e-09;
+	
+	// special cases
+	if (IsNaN(x)) {
+		return x;
+	}
+	if (IsInf(x, 0)) {
+		return 0;
+	}
+	if (x == 0) {
+		return 1;
+	}
+
+	x = Abs(x);
+
+	// |x| >= 2.0
+	if (x >= 2) {
+		const [s, c] = Sincos(x);
+		let ss = s - c;
+		let cc = s + c;
+
+		// make sure x+x does not overflow
+		if (x < 1.79769e+308 / 2) {
+			const z = -Cos(x + x);
+			if (s * c < 0) {
+				cc = z / ss;
+			} else {
+				ss = z / cc;
+			}
+		}
+
+		let z: number;
+		// |x| > ~6.8056e+38
+		if (x > 680564733841876926926749214863536422912) {
+			z = (1 / 1.77245) * cc / Sqrt(x);
+		} else {
+			const u = pzero(x);
+			const v = qzero(x);
+			z = (1 / 1.77245) * (u * cc - v * ss) / Sqrt(x);
+		}
+		return z;
+	}
+	
+	// |x| < ~1.2207e-4
+	if (x < 0.00012207) {
+		// |x| < ~7.4506e-9
+		if (x < 7.45058e-09) {
+			return 1;
+		}
+		return 1 - 0.25 * x * x;
+	}
+	
+	const z = x * x;
+	const r = z * (R02 + z * (R03 + z * (R04 + z * R05)));
+	const s = 1 + z * (S01 + z * (S02 + z * (S03 + z * S04)));
+
+	// |x| < 1.00
+	if (x < 1) {
+		return 1 + z * (-0.25 + (r / s));
+	}
+	const u = 0.5 * x;
+	return (1 + u) * (1 - u) + z * (r / s);
+}
+
+// Y0 returns the order-zero Bessel function of the second kind.
+//
+// Special cases are:
+//
+//	Y0(+Inf) = 0
+//	Y0(0) = -Inf
+//	Y0(x < 0) = NaN
+//	Y0(NaN) = NaN
+export function Y0(x: number): number {
+	// Constants
+	const TwoM27: number = 1.0 / (1 << 27); // 2**-27
+	const Two129: number = Math.pow(2, 129); // 2**129
+	
+	// U coefficients
+	const U00: number = -7.38042951086872317523e-02;
+	const U01: number = 1.76666452509181115538e-01;
+	const U02: number = -1.38185671945596898896e-02;
+	const U03: number = 3.47453432093683650238e-04;
+	const U04: number = -3.81407053724364161125e-06;
+	const U05: number = 1.95590137035022920206e-08;
+	const U06: number = -3.98205194132103398453e-11;
+	
+	// V coefficients
+	const V01: number = 1.27304834834123699328e-02;
+	const V02: number = 7.60068627350353253702e-05;
+	const V03: number = 2.59150851840457805467e-07;
+	const V04: number = 4.41110311332675467403e-10;
+	
+	// special cases
+	if (x < 0 || IsNaN(x)) {
+		return NaN();
+	}
+	if (IsInf(x, 1)) {
+		return 0;
+	}
+	if (x == 0) {
+		return Inf(-1);
+	}
+
+	// |x| >= 2.0
+	if (x >= 2) {
+		const [s, c] = Sincos(x);
+		let ss = s - c;
+		let cc = s + c;
+
+		// make sure x+x does not overflow
+		if (x < 1.79769e+308 / 2) {
+			const z = -Cos(x + x);
+			if (s * c < 0) {
+				cc = z / ss;
+			} else {
+				ss = z / cc;
+			}
+		}
+		
+		let z: number;
+		// |x| > ~6.8056e+38
+		if (x > 680564733841876926926749214863536422912) {
+			z = (1 / 1.77245) * ss / Sqrt(x);
+		} else {
+			const u = pzero(x);
+			const v = qzero(x);
+			z = (1 / 1.77245) * (u * ss + v * cc) / Sqrt(x);
+		}
+		return z;
+	}
+
+	// |x| < ~7.4506e-9
+	if (x <= 7.45058e-09) {
+		return U00 + (2 / Math.PI) * Log(x);
+	}
+	
+	const z = x * x;
+	const u = U00 + z * (U01 + z * (U02 + z * (U03 + z * (U04 + z * (U05 + z * U06)))));
+	const v = 1 + z * (V01 + z * (V02 + z * (V03 + z * V04)));
+	return u / v + (2 / Math.PI) * J0(x) * Log(x);
+}
+
+const p0R8: $.VarRef<$.Slice<number>> = $.varRef($.arrayToSlice<number>([0.00000000000000000000e+00, -7.03124999999900357484e-02, -8.08167041275349795626e+00, -2.57063105679704847262e+02, -2.48521641009428822144e+03, -5.25304380490729545272e+03]));
+
+const p0S8: $.VarRef<$.Slice<number>> = $.varRef($.arrayToSlice<number>([1.16534364619668181717e+02, 3.83374475364121826715e+03, 4.05978572648472545552e+04, 1.16752972564375915681e+05, 4.76277284146730962675e+04]));
+
+const p0R5: $.VarRef<$.Slice<number>> = $.varRef($.arrayToSlice<number>([-1.14125464691894502584e-11, -7.03124940873599280078e-02, -4.15961064470587782438e+00, -6.76747652265167261021e+01, -3.31231299649172967747e+02, -3.46433388365604912451e+02]));
+
+const p0S5: $.VarRef<$.Slice<number>> = $.varRef($.arrayToSlice<number>([6.07539382692300335975e+01, 1.05125230595704579173e+03, 5.97897094333855784498e+03, 9.62544514357774460223e+03, 2.40605815922939109441e+03]));
+
+const p0R3: $.VarRef<$.Slice<number>> = $.varRef($.arrayToSlice<number>([-2.54704601771951915620e-09, -7.03119616381481654654e-02, -2.40903221549529611423e+00, -2.19659774734883086467e+01, -5.80791704701737572236e+01, -3.14479470594888503854e+01]));
+
+const p0S3: $.VarRef<$.Slice<number>> = $.varRef($.arrayToSlice<number>([3.58560338055209726349e+01, 3.61513983050303863820e+02, 1.19360783792111533330e+03, 1.12799679856907414432e+03, 1.73580930813335754692e+02]));
+
+const p0R2: $.VarRef<$.Slice<number>> = $.varRef($.arrayToSlice<number>([-8.87534333032526411254e-08, -7.03030995483624743247e-02, -1.45073846780952986357e+00, -7.63569613823527770791e+00, -1.11931668860356747786e+01, -3.23364579351335335033e+00]));
+
+const p0S2: $.VarRef<$.Slice<number>> = $.varRef($.arrayToSlice<number>([2.22202997532088808441e+01, 1.36206794218215208048e+02, 2.70470278658083486789e+02, 1.53875394208320329881e+02, 1.46576176948256193810e+01]));
+
+export function pzero(x: number): number {
+	let p: $.VarRef<$.Slice<number>>;
+	let q: $.VarRef<$.Slice<number>>;
+	
+	if (x >= 8) {
+		p = p0R8;
+		q = p0S8;
+	} else if (x >= 4.5454) {
+		p = p0R5;
+		q = p0S5;
+	} else if (x >= 2.8571) {
+		p = p0R3;
+		q = p0S3;
+	} else if (x >= 2) {
+		p = p0R2;
+		q = p0S2;
+	} else {
+		// This should not happen based on the calling code, but we need to handle it
+		throw new Error("pzero: x must be >= 2");
+	}
+	
+	const z = 1 / (x * x);
+	const r = p.value![0] + z * (p.value![1] + z * (p.value![2] + z * (p.value![3] + z * (p.value![4] + z * p.value![5]))));
+	const s = 1 + z * (q.value![0] + z * (q.value![1] + z * (q.value![2] + z * (q.value![3] + z * q.value![4]))));
+	return 1 + r / s;
+}
+
+const q0R8: $.VarRef<$.Slice<number>> = $.varRef($.arrayToSlice<number>([0.00000000000000000000e+00, 7.32421874999935051953e-02, 1.17682064682252693899e+01, 5.57673380256401856059e+02, 8.85919720756468632317e+03, 3.70146267776887834771e+04]));
+
+const q0S8: $.VarRef<$.Slice<number>> = $.varRef($.arrayToSlice<number>([1.63776026895689824414e+02, 8.09834494656449805916e+03, 1.42538291419120476348e+05, 8.03309257119514397345e+05, 8.40501579819060512818e+05, -3.43899293537866615225e+05]));
+
+const q0R5: $.VarRef<$.Slice<number>> = $.varRef($.arrayToSlice<number>([1.84085963594515531381e-11, 7.32421766612684765896e-02, 5.83563508962056953777e+00, 1.35111577286449829671e+02, 1.02724376596164097464e+03, 1.98997785864605384631e+03]));
+
+const q0S5: $.VarRef<$.Slice<number>> = $.varRef($.arrayToSlice<number>([8.27766102236537761883e+01, 2.07781416421392987104e+03, 1.88472887785718085070e+04, 5.67511122894947329769e+04, 3.59767538425114471465e+04, -5.35434275601944773371e+03]));
+
+const q0R3: $.VarRef<$.Slice<number>> = $.varRef($.arrayToSlice<number>([4.37741014089738620906e-09, 7.32411180042911447163e-02, 3.34423137516170720929e+00, 4.26218440745412650017e+01, 1.70808091340565596283e+02, 1.66733948696651168575e+02]));
+
+const q0S3: $.VarRef<$.Slice<number>> = $.varRef($.arrayToSlice<number>([4.87588729724587182091e+01, 7.09689221056606015736e+02, 3.70414822620111362994e+03, 6.46042516752568917582e+03, 2.51633368920368957333e+03, -1.49247451836156386662e+02]));
+
+const q0R2: $.VarRef<$.Slice<number>> = $.varRef($.arrayToSlice<number>([1.50444444886983272379e-07, 7.32234265963079278272e-02, 1.99819174093815998816e+00, 1.44956029347885735348e+01, 3.16662317504781540833e+01, 1.62527075710929267416e+01]));
+
+const q0S2: $.VarRef<$.Slice<number>> = $.varRef($.arrayToSlice<number>([3.03655848355219184498e+01, 2.69348118608049844624e+02, 8.44783757595320139444e+02, 8.82935845112488550512e+02, 2.12666388511798828631e+02, -5.31095493882666946917e+00]));
+
+export function qzero(x: number): number {
+	let p: $.VarRef<$.Slice<number>>;
+	let q: $.VarRef<$.Slice<number>>;
+	
+	if (x >= 8) {
+		p = q0R8;
+		q = q0S8;
+	} else if (x >= 4.5454) {
+		p = q0R5;
+		q = q0S5;
+	} else if (x >= 2.8571) {
+		p = q0R3;
+		q = q0S3;
+	} else if (x >= 2) {
+		p = q0R2;
+		q = q0S2;
+	} else {
+		// This should not happen based on the calling code, but we need to handle it
+		throw new Error("qzero: x must be >= 2");
+	}
+	
+	const z = 1 / (x * x);
+	const r = p.value![0] + z * (p.value![1] + z * (p.value![2] + z * (p.value![3] + z * (p.value![4] + z * p.value![5]))));
+	const s = 1 + z * (q.value![0] + z * (q.value![1] + z * (q.value![2] + z * (q.value![3] + z * (q.value![4] + z * q.value![5])))));
+	return (-0.125 + r / s) / x;
+}
+

package/gs/math/j1.gs.test.ts

@@ -0,0 +1,81 @@
+import { describe, it, expect } from 'vitest'
+import { J1, Y1 } from './j1.gs.js'
+
+describe('J1', () => {
+  it('should return correct values for zero and small inputs', () => {
+    expect(J1(0)).toBe(0)
+    expect(J1(1)).toBeCloseTo(0.4400505857449335, 7)
+    expect(J1(2)).toBeCloseTo(0.5767248077568733, 5)
+  })
+
+  it('should return correct values for various inputs', () => {
+    expect(J1(3)).toBeCloseTo(0.33905895852593637, 5)
+    expect(J1(5)).toBeCloseTo(-0.32757913759146523, 5)
+    expect(J1(10)).toBeCloseTo(0.043472746168861424, 6)
+  })
+
+  it('should be an odd function', () => {
+    const testValues = [1, 2, 3, 5, 10]
+    for (const x of testValues) {
+      expect(J1(-x)).toBeCloseTo(-J1(x), 14)
+    }
+  })
+
+  it('should handle special values', () => {
+    expect(J1(Number.POSITIVE_INFINITY)).toBe(0)
+    expect(J1(Number.NEGATIVE_INFINITY)).toBe(0)
+    expect(Number.isNaN(J1(Number.NaN))).toBe(true)
+  })
+
+  it('should oscillate for large values', () => {
+    // J1 should oscillate around 0 for large x
+    const largeValues = [20, 30, 50, 100]
+    for (const x of largeValues) {
+      expect(Math.abs(J1(x))).toBeLessThan(0.5)
+    }
+  })
+
+  it('should approach x/2 for small x', () => {
+    const smallValues = [0.01, 0.001, 0.0001]
+    for (const x of smallValues) {
+      expect(J1(x)).toBeCloseTo(x / 2, 6)
+    }
+  })
+})
+
+describe('Y1', () => {
+  it('should return correct values for positive inputs', () => {
+    expect(Y1(1)).toBeCloseTo(-0.7812128213002887, 6)
+    expect(Y1(2)).toBeCloseTo(-0.10703243154093754, 6)
+    expect(Y1(5)).toBeCloseTo(0.1478631433912268, 6)
+  })
+
+  it('should approach negative infinity as x approaches 0 from positive side', () => {
+    expect(Y1(0.001)).toBeLessThan(-300)
+    expect(Y1(0.0001)).toBeLessThan(-3000)
+  })
+
+  it('should handle special values', () => {
+    expect(Y1(Number.POSITIVE_INFINITY)).toBe(0)
+    // Check if Y1(0) returns a very large negative number or -Infinity
+    const y1_zero = Y1(0)
+    expect(y1_zero < -1e10 || y1_zero === Number.NEGATIVE_INFINITY || Number.isNaN(y1_zero)).toBe(true)
+    expect(Number.isNaN(Y1(-1))).toBe(true)
+    expect(Number.isNaN(Y1(Number.NEGATIVE_INFINITY))).toBe(true)
+    expect(Number.isNaN(Y1(Number.NaN))).toBe(true)
+  })
+
+  it('should oscillate for large values', () => {
+    // Y1 should oscillate around 0 for large x
+    const largeValues = [20, 30, 50, 100]
+    for (const x of largeValues) {
+      expect(Math.abs(Y1(x))).toBeLessThan(0.5)
+    }
+  })
+
+  it('should be undefined for negative values', () => {
+    expect(Number.isNaN(Y1(-1))).toBe(true)
+    expect(Number.isNaN(Y1(-5))).toBe(true)
+    expect(Number.isNaN(Y1(-10))).toBe(true)
+  })
+}) 

package/gs/math/j1.gs.ts

@@ -0,0 +1,231 @@
+import * as $ from "@goscript/builtin/builtin.js";
+import { Inf, IsInf, IsNaN, NaN } from "./bits.gs.js";
+import { Log } from "./log.gs.js";
+import { Cos } from "./sin.gs.js";
+import { Sincos } from "./sincos.gs.js";
+import { Sqrt } from "./sqrt.gs.js";
+
+// J1 returns the order-one Bessel function of the first kind.
+//
+// Special cases are:
+//
+//	J1(±Inf) = 0
+//	J1(NaN) = NaN
+export function J1(x: number): number {
+	// special cases
+	switch (true) {
+		case IsNaN(x):
+			return x;
+		case IsInf(x, 0) || x == 0:
+			return 0;
+	}
+
+	let sign = false;
+	if (x < 0) {
+		x = -x;
+		sign = true;
+	}
+
+	// j1(x) = 1/sqrt(pi) * (P(1,x)*cc - Q(1,x)*ss) / sqrt(x)
+	// y1(x) = 1/sqrt(pi) * (P(1,x)*ss + Q(1,x)*cc) / sqrt(x)
+	if (x >= 2) {
+		let [s, c] = Sincos(x);
+		let ss = -s - c;
+		let cc = s - c;
+
+		// make sure x+x does not overflow
+		if (x < 1.79769e+308 / 2) {
+			let z = Cos(x + x);
+			if (s * c > 0) {
+				cc = z / ss;
+			} else {
+				ss = z / cc;
+			}
+		}
+
+		// j1(x) = 1/sqrt(pi) * (P(1,x)*cc - Q(1,x)*ss) / sqrt(x)
+		// y1(x) = 1/sqrt(pi) * (P(1,x)*ss + Q(1,x)*cc) / sqrt(x)
+
+		let z: number = 0;
+		if (x > 680564733841876926926749214863536422912) {
+			z = (1 / 1.77245) * cc / Sqrt(x);
+		} else {
+			let u = pone(x);
+			let v = qone(x);
+			z = (1 / 1.77245) * (u * cc - v * ss) / Sqrt(x);
+		}
+		if (sign) {
+			return -z;
+		}
+		return z;
+	}
+	// |x|<2**-27
+	// inexact if x!=0 necessary
+	if (x < 7.45058e-09) {
+		// |x|<2**-27
+		return 0.5 * x;
+	}
+	let z = x * x;
+	let r = z * (-0.0625 + z * (0.00140706 + z * (-1.59956e-05 + z * 4.96728e-08)));
+	let s = 1.0 + z * (0.0191538 + z * (0.000185947 + z * (1.17718e-06 + z * (5.04636e-09 + z * 1.23542e-11))));
+	r *= x;
+	z = 0.5 * x + r / s;
+	if (sign) {
+		return -z;
+	}
+	return z;
+}
+
+// Y1 returns the order-one Bessel function of the second kind.
+//
+// Special cases are:
+//
+//	Y1(+Inf) = 0
+//	Y1(0) = -Inf
+//	Y1(x < 0) = NaN
+//	Y1(NaN) = NaN
+export function Y1(x: number): number {
+	// special cases
+	switch (true) {
+		case x < 0 || IsNaN(x):
+			return NaN();
+		case IsInf(x, 1):
+			return 0;
+		case x == 0:
+			return Inf(-1);
+	}
+
+	// y1(x) = sqrt(2/(pi*x))*(p1(x)*sin(x0)+q1(x)*cos(x0))
+	// where x0 = x-3pi/4
+	//     Better formula:
+	//         cos(x0) = cos(x)cos(3pi/4)+sin(x)sin(3pi/4)
+	//                 =  1/sqrt(2) * (sin(x) - cos(x))
+	//         sin(x0) = sin(x)cos(3pi/4)-cos(x)sin(3pi/4)
+	//                 = -1/sqrt(2) * (cos(x) + sin(x))
+	// To avoid cancellation, use
+	//     sin(x) +- cos(x) = -cos(2x)/(sin(x) -+ cos(x))
+	// to compute the worse one.
+	if (x >= 2) {
+		let [s, c] = Sincos(x);
+		let ss = -s - c;
+		let cc = s - c;
+
+		// make sure x+x does not overflow
+		if (x < 1.79769e+308 / 2) {
+			let z = Cos(x + x);
+			if (s * c > 0) {
+				cc = z / ss;
+			} else {
+				ss = z / cc;
+			}
+		}
+
+		let z: number = 0;
+		if (x > 680564733841876926926749214863536422912) {
+			z = (1 / 1.77245) * ss / Sqrt(x);
+		} else {
+			let u = pone(x);
+			let v = qone(x);
+			z = (1 / 1.77245) * (u * ss + v * cc) / Sqrt(x);
+		}
+		return z;
+	}
+	// x < 2**-54
+	if (x <= 5.55112e-17) {
+		// x < 2**-54
+		return -(2 / 3.14159) / x;
+	}
+	let z = x * x;
+	let u = -0.196057 + z * (0.0504439 + z * (-0.00191257 + z * (2.35253e-05 + z * -9.19099e-08)));
+	let v = 1 + z * (0.0199167 + z * (0.000202553 + z * (1.35609e-06 + z * (6.22741e-09 + z * 1.66559e-11))));
+	return x * (u / v) + (2 / 3.14159) * (J1(x) * Log(x) - 1 / x);
+}
+
+let p1R8: $.VarRef<$.Slice<number>> = $.varRef($.arrayToSlice<number>([0.00000000000000000000e+00, 1.17187499999988647970e-01, 1.32394806593073575129e+01, 4.12051854307378562225e+02, 3.87474538913960532227e+03, 7.91447954031891731574e+03]));
+
+let p1S8: $.VarRef<$.Slice<number>> = $.varRef($.arrayToSlice<number>([1.14207370375678408436e+02, 3.65093083420853463394e+03, 3.69562060269033463555e+04, 9.76027935934950801311e+04, 3.08042720627888811578e+04]));
+
+let p1R5: $.VarRef<$.Slice<number>> = $.varRef($.arrayToSlice<number>([1.31990519556243522749e-11, 1.17187493190614097638e-01, 6.80275127868432871736e+00, 1.08308182990189109773e+02, 5.17636139533199752805e+02, 5.28715201363337541807e+02]));
+
+let p1S5: $.VarRef<$.Slice<number>> = $.varRef($.arrayToSlice<number>([5.92805987221131331921e+01, 9.91401418733614377743e+02, 5.35326695291487976647e+03, 7.84469031749551231769e+03, 1.50404688810361062679e+03]));
+
+let p1R3: $.VarRef<$.Slice<number>> = $.varRef($.arrayToSlice<number>([3.02503916137373618024e-09, 1.17186865567253592491e-01, 3.93297750033315640650e+00, 3.51194035591636932736e+01, 9.10550110750781271918e+01, 4.85590685197364919645e+01]));
+
+let p1S3: $.VarRef<$.Slice<number>> = $.varRef($.arrayToSlice<number>([3.47913095001251519989e+01, 3.36762458747825746741e+02, 1.04687139975775130551e+03, 8.90811346398256432622e+02, 1.03787932439639277504e+02]));
+
+let p1R2: $.VarRef<$.Slice<number>> = $.varRef($.arrayToSlice<number>([1.07710830106873743082e-07, 1.17176219462683348094e-01, 2.36851496667608785174e+00, 1.22426109148261232917e+01, 1.76939711271687727390e+01, 5.07352312588818499250e+00]));
+
+let p1S2: $.VarRef<$.Slice<number>> = $.varRef($.arrayToSlice<number>([2.14364859363821409488e+01, 1.25290227168402751090e+02, 2.32276469057162813669e+02, 1.17679373287147100768e+02, 8.36463893371618283368e+00]));
+
+export function pone(x: number): number {
+	let p: $.VarRef<$.Slice<number>>;
+	let q: $.VarRef<$.Slice<number>>;
+	
+	if (x >= 8) {
+		p = p1R8;
+		q = p1S8;
+	} else if (x >= 4.5454) {
+		p = p1R5;
+		q = p1S5;
+	} else if (x >= 2.8571) {
+		p = p1R3;
+		q = p1S3;
+	} else if (x >= 2) {
+		p = p1R2;
+		q = p1S2;
+	} else {
+		// Default case to ensure p and q are always assigned
+		p = p1R2;
+		q = p1S2;
+	}
+	
+	let z = 1 / (x * x);
+	let r = p.value![0] + z * (p.value![1] + z * (p.value![2] + z * (p.value![3] + z * (p.value![4] + z * p.value![5]))));
+	let s = 1.0 + z * (q.value![0] + z * (q.value![1] + z * (q.value![2] + z * (q.value![3] + z * q.value![4]))));
+	return 1 + r / s;
+}
+
+let q1R8: $.VarRef<$.Slice<number>> = $.varRef($.arrayToSlice<number>([0.00000000000000000000e+00, -1.02539062499992714161e-01, -1.62717534544589987888e+01, -7.59601722513950107896e+02, -1.18498066702429587167e+04, -4.84385124285750353010e+04]));
+
+let q1S8: $.VarRef<$.Slice<number>> = $.varRef($.arrayToSlice<number>([1.61395369700722909556e+02, 7.82538599923348465381e+03, 1.33875336287249578163e+05, 7.19657723683240939863e+05, 6.66601232617776375264e+05, -2.94490264303834643215e+05]));
+
+let q1R5: $.VarRef<$.Slice<number>> = $.varRef($.arrayToSlice<number>([-2.08979931141764104297e-11, -1.02539050241375426231e-01, -8.05644828123936029840e+00, -1.83669607474888380239e+02, -1.37319376065508163265e+03, -2.61244440453215656817e+03]));
+
+let q1S5: $.VarRef<$.Slice<number>> = $.varRef($.arrayToSlice<number>([8.12765501384335777857e+01, 1.99179873460485964642e+03, 1.74684851924908907677e+04, 4.98514270910352279316e+04, 2.79480751638918118260e+04, -4.71918354795128470869e+03]));
+
+let q1R3: $.VarRef<$.Slice<number>> = $.varRef($.arrayToSlice<number>([-5.07831226461766561369e-09, -1.02537829820837089745e-01, -4.61011581139473403113e+00, -5.78472216562783643212e+01, -2.28244540737631695038e+02, -2.19210128478909325622e+02]));
+
+let q1S3: $.VarRef<$.Slice<number>> = $.varRef($.arrayToSlice<number>([4.76651550323729509273e+01, 6.73865112676699709482e+02, 3.38015286679526343505e+03, 5.54772909720722782367e+03, 1.90311919338810798763e+03, -1.35201191444307340817e+02]));
+
+let q1R2: $.VarRef<$.Slice<number>> = $.varRef($.arrayToSlice<number>([-1.78381727510958865572e-07, -1.02517042607985553460e-01, -2.75220568278187460720e+00, -1.96636162643703720221e+01, -4.23253133372830490089e+01, -2.13719211703704061733e+01]));
+
+let q1S2: $.VarRef<$.Slice<number>> = $.varRef($.arrayToSlice<number>([2.95333629060523854548e+01, 2.52981549982190529136e+02, 7.57502834868645436472e+02, 7.39393205320467245656e+02, 1.55949003336666123687e+02, -4.95949898822628210127e+00]));
+
+export function qone(x: number): number {
+	let p: $.VarRef<$.Slice<number>>;
+	let q: $.VarRef<$.Slice<number>>;
+	
+	if (x >= 8) {
+		p = q1R8;
+		q = q1S8;
+	} else if (x >= 4.5454) {
+		p = q1R5;
+		q = q1S5;
+	} else if (x >= 2.8571) {
+		p = q1R3;
+		q = q1S3;
+	} else if (x >= 2) {
+		p = q1R2;
+		q = q1S2;
+	} else {
+		// Default case to ensure p and q are always assigned
+		p = q1R2;
+		q = q1S2;
+	}
+	
+	let z = 1 / (x * x);
+	let r = p.value![0] + z * (p.value![1] + z * (p.value![2] + z * (p.value![3] + z * (p.value![4] + z * p.value![5]))));
+	let s = 1 + z * (q.value![0] + z * (q.value![1] + z * (q.value![2] + z * (q.value![3] + z * (q.value![4] + z * q.value![5])))));
+	return (0.375 + r / s) / x;
+}
+