Commit b729a3f008304d464b431f8ac34ad16cde08ba7b | zig

author	expikr <77922942+expikr@users.noreply.github.com> 2024-01-20 14:32:07+08:00
committer	GitHub <noreply@github.com> 2024-01-20 01:32:07-05:00
log	b729a3f008304d464b431f8ac34ad16cde08ba7b
tree	00b0c9c4d1c9c5a8f75bab77ce4b39a7748b173a
parent	1a98fcd00abb7266418532a103214467497d58c6
signature	Signed by PGP key B5690EEEBB952194

std.math: make hypot infer type from argument (#17910)

using peer type resolution

3 files changed, 21 insertions(+), 14 deletions(-)

lib
- std
  - math
    complex
    abs.zig
    sqrt.zig
    hypot.zig

lib/std/math/complex/abs.zig+2-3

 @@ -5,9 +5,8 @@ const cmath = math.complex;
 const Complex = cmath.Complex;
 /// Returns the absolute value (modulus) of z.
-pub fn abs(z: anytype) @TypeOf(z.re) {
+pub fn abs(z: anytype) @TypeOf(z.re, z.im) {
-    const T = @TypeOf(z.re);
+    return math.hypot(z.re, z.im);
-    return math.hypot(T, z.re, z.im);
 }
 const epsilon = 0.0001;

lib/std/math/complex/sqrt.zig+4-4

...	@@ -56,13 +56,13 @@ fn sqrt32(z: Complex(f32)) Complex(f32) {	...	@@ -56,13 +56,13 @@ fn sqrt32(z: Complex(f32)) Complex(f32) {
56	const dy = @as(f64, y);	56	const dy = @as(f64, y);
57		57
58	if (dx >= 0) {	58	if (dx >= 0) {
59	const t = @sqrt((dx + math.hypot(f64, dx, dy)) * 0.5);	59	const t = @sqrt((dx + math.hypot(dx, dy)) * 0.5);
60	return Complex(f32).init(	60	return Complex(f32).init(
61	@as(f32, @floatCast(t)),	61	@as(f32, @floatCast(t)),
62	@as(f32, @floatCast(dy / (2.0 * t))),	62	@as(f32, @floatCast(dy / (2.0 * t))),
63	);	63	);
64	} else {	64	} else {
65	const t = @sqrt((-dx + math.hypot(f64, dx, dy)) * 0.5);	65	const t = @sqrt((-dx + math.hypot(dx, dy)) * 0.5);
66	return Complex(f32).init(	66	return Complex(f32).init(
67	@as(f32, @floatCast(@abs(y) / (2.0 * t))),	67	@as(f32, @floatCast(@abs(y) / (2.0 * t))),
68	@as(f32, @floatCast(math.copysign(t, y))),	68	@as(f32, @floatCast(math.copysign(t, y))),
...	@@ -112,10 +112,10 @@ fn sqrt64(z: Complex(f64)) Complex(f64) {	...	@@ -112,10 +112,10 @@ fn sqrt64(z: Complex(f64)) Complex(f64) {
112		112
113	var result: Complex(f64) = undefined;	113	var result: Complex(f64) = undefined;
114	if (x >= 0) {	114	if (x >= 0) {
115	const t = @sqrt((x + math.hypot(f64, x, y)) * 0.5);	115	const t = @sqrt((x + math.hypot(x, y)) * 0.5);
116	result = Complex(f64).init(t, y / (2.0 * t));	116	result = Complex(f64).init(t, y / (2.0 * t));
117	} else {	117	} else {
118	const t = @sqrt((-x + math.hypot(f64, x, y)) * 0.5);	118	const t = @sqrt((-x + math.hypot(x, y)) * 0.5);
119	result = Complex(f64).init(@abs(y) / (2.0 * t), math.copysign(t, y));	119	result = Complex(f64).init(@abs(y) / (2.0 * t), math.copysign(t, y));
120	}	120	}
121		121

lib/std/math/hypot.zig+15-7

 @@ -12,11 +12,15 @@ const maxInt = std.math.maxInt;
 /// Returns sqrt(x * x + y * y), avoiding unnecessary overflow and underflow.
 ///
 /// Special Cases:
-///  - hypot(+-inf, y)  = +inf
+///
-///  - hypot(x, +-inf)  = +inf
+/// |   x   |   y   | hypot |
-///  - hypot(nan, y)    = nan
+/// |-------|-------|-------|
-///  - hypot(x, nan)    = nan
+/// | +inf  |  num  | +inf  |
-pub fn hypot(comptime T: type, x: T, y: T) T {
+/// |  num  | +-inf | +inf  |
+/// |  nan  |  any  |  nan  |
+/// |  any  |  nan  |  nan  |
+pub fn hypot(x: anytype, y: anytype) @TypeOf(x, y) {
+    const T = @TypeOf(x, y);
     return switch (T) {
         f32 => hypot32(x, y),
         f64 => hypot64(x, y),
 @@ -121,8 +125,12 @@ fn hypot64(x: f64, y: f64) f64 {
 }
 test "math.hypot" {
-    try expect(hypot(f32, 0.0, -1.2) == hypot32(0.0, -1.2));
+    const x32: f32 = 0.0;
-    try expect(hypot(f64, 0.0, -1.2) == hypot64(0.0, -1.2));
+    const y32: f32 = -1.2;
+    const x64: f64 = 0.0;
+    const y64: f64 = -1.2;
+    try expect(hypot(x32, y32) == hypot32(0.0, -1.2));
+    try expect(hypot(x64, y64) == hypot64(0.0, -1.2));
 }
 test "math.hypot32" {