Commit f950ec0c16de6dba8a541b1a6453ebe431430782 | zig

std/math/acos.zig+8-2

 @@ -1,11 +1,17 @@
-// Special Cases:
+// Ported from musl, which is licensed under the MIT license:
+// https://git.musl-libc.org/cgit/musl/tree/COPYRIGHT
 //
-// - acos(x)   = nan if x < -1 or x > 1
+// https://git.musl-libc.org/cgit/musl/tree/src/math/acosf.c
+// https://git.musl-libc.org/cgit/musl/tree/src/math/acos.c
 const std = @import("../std.zig");
 const math = std.math;
 const expect = std.testing.expect;
+/// Returns the arc-cosine of x.
+///
+/// Special cases:
+///  - acos(x)   = nan if x < -1 or x > 1
 pub fn acos(x: var) @typeOf(x) {
     const T = @typeOf(x);
     return switch (T) {

std/math/acosh.zig+9-3

 @@ -1,13 +1,19 @@
-// Special Cases:
+// Ported from musl, which is licensed under the MIT license:
+// https://git.musl-libc.org/cgit/musl/tree/COPYRIGHT
 //
-// - acosh(x)   = snan if x < 1
+// https://git.musl-libc.org/cgit/musl/tree/src/math/acoshf.c
-// - acosh(nan) = nan
+// https://git.musl-libc.org/cgit/musl/tree/src/math/acosh.c
 const builtin = @import("builtin");
 const std = @import("../std.zig");
 const math = std.math;
 const expect = std.testing.expect;
+/// Returns the hyperbolic arc-cosine of x.
+///
+/// Special cases:
+///  - acosh(x)   = snan if x < 1
+///  - acosh(nan) = nan
 pub fn acosh(x: var) @typeOf(x) {
     const T = @typeOf(x);
     return switch (T) {

std/math/asin.zig+9-3

 @@ -1,12 +1,18 @@
-// Special Cases:
+// Ported from musl, which is licensed under the MIT license:
+// https://git.musl-libc.org/cgit/musl/tree/COPYRIGHT
 //
-// - asin(+-0) = +-0
+// https://git.musl-libc.org/cgit/musl/tree/src/math/asinf.c
-// - asin(x)   = nan if x < -1 or x > 1
+// https://git.musl-libc.org/cgit/musl/tree/src/math/asin.c
 const std = @import("../std.zig");
 const math = std.math;
 const expect = std.testing.expect;
+/// Returns the arc-sin of x.
+///
+/// Special Cases:
+///  - asin(+-0) = +-0
+///  - asin(x)   = nan if x < -1 or x > 1
 pub fn asin(x: var) @typeOf(x) {
     const T = @typeOf(x);
     return switch (T) {

std/math/asinh.zig+10-4

 @@ -1,14 +1,20 @@
-// Special Cases:
+// Ported from musl, which is licensed under the MIT license:
+// https://git.musl-libc.org/cgit/musl/tree/COPYRIGHT
 //
-// - asinh(+-0)   = +-0
+// https://git.musl-libc.org/cgit/musl/tree/src/math/asinhf.c
-// - asinh(+-inf) = +-inf
+// https://git.musl-libc.org/cgit/musl/tree/src/math/asinh.c
-// - asinh(nan)   = nan
 const std = @import("../std.zig");
 const math = std.math;
 const expect = std.testing.expect;
 const maxInt = std.math.maxInt;
+/// Returns the hyperbolic arc-sin of x.
+///
+/// Special Cases:
+///  - asinh(+-0)   = +-0
+///  - asinh(+-inf) = +-inf
+///  - asinh(nan)   = nan
 pub fn asinh(x: var) @typeOf(x) {
     const T = @typeOf(x);
     return switch (T) {

std/math/atan.zig+9-3

 @@ -1,12 +1,18 @@
-// Special Cases:
+// Ported from musl, which is licensed under the MIT license:
+// https://git.musl-libc.org/cgit/musl/tree/COPYRIGHT
 //
-// - atan(+-0)   = +-0
+// https://git.musl-libc.org/cgit/musl/tree/src/math/atanf.c
-// - atan(+-inf) = +-pi/2
+// https://git.musl-libc.org/cgit/musl/tree/src/math/atan.c
 const std = @import("../std.zig");
 const math = std.math;
 const expect = std.testing.expect;
+/// Returns the arc-tangent of x.
+///
+/// Special Cases:
+///  - atan(+-0)   = +-0
+///  - atan(+-inf) = +-pi/2
 pub fn atan(x: var) @typeOf(x) {
     const T = @typeOf(x);
     return switch (T) {

std/math/atan2.zig+24-18

 @@ -1,27 +1,33 @@
-// Special Cases:
+// Ported from musl, which is licensed under the MIT license:
+// https://git.musl-libc.org/cgit/musl/tree/COPYRIGHT
 //
-//  atan2(y, nan)     = nan
+// https://git.musl-libc.org/cgit/musl/tree/src/math/atan2f.c
-//  atan2(nan, x)     = nan
+// https://git.musl-libc.org/cgit/musl/tree/src/math/atan2.c
-//  atan2(+0, x>=0)   = +0
-//  atan2(-0, x>=0)   = -0
-//  atan2(+0, x<=-0)  = +pi
-//  atan2(-0, x<=-0)  = -pi
-//  atan2(y>0, 0)     = +pi/2
-//  atan2(y<0, 0)     = -pi/2
-//  atan2(+inf, +inf) = +pi/4
-//  atan2(-inf, +inf) = -pi/4
-//  atan2(+inf, -inf) = 3pi/4
-//  atan2(-inf, -inf) = -3pi/4
-//  atan2(y, +inf)    = 0
-//  atan2(y>0, -inf)  = +pi
-//  atan2(y<0, -inf)  = -pi
-//  atan2(+inf, x)    = +pi/2
-//  atan2(-inf, x)    = -pi/2
 const std = @import("../std.zig");
 const math = std.math;
 const expect = std.testing.expect;
+/// Returns the arc-tangent of y/x.
+///
+/// Special Cases:
+///  - atan2(y, nan)     = nan
+///  - atan2(nan, x)     = nan
+///  - atan2(+0, x>=0)   = +0
+///  - atan2(-0, x>=0)   = -0
+///  - atan2(+0, x<=-0)  = +pi
+///  - atan2(-0, x<=-0)  = -pi
+///  - atan2(y>0, 0)     = +pi/2
+///  - atan2(y<0, 0)     = -pi/2
+///  - atan2(+inf, +inf) = +pi/4
+///  - atan2(-inf, +inf) = -pi/4
+///  - atan2(+inf, -inf) = 3pi/4
+///  - atan2(-inf, -inf) = -3pi/4
+///  - atan2(y, +inf)    = 0
+///  - atan2(y>0, -inf)  = +pi
+///  - atan2(y<0, -inf)  = -pi
+///  - atan2(+inf, x)    = +pi/2
+///  - atan2(-inf, x)    = -pi/2
 pub fn atan2(comptime T: type, y: T, x: T) T {
     return switch (T) {
         f32 => atan2_32(y, x),

std/math/atanh.zig+10-4

 @@ -1,14 +1,20 @@
-// Special Cases:
+// Ported from musl, which is licensed under the MIT license:
+// https://git.musl-libc.org/cgit/musl/tree/COPYRIGHT
 //
-// - atanh(+-1) = +-inf with signal
+// https://git.musl-libc.org/cgit/musl/tree/src/math/atanhf.c
-// - atanh(x)   = nan if |x| > 1 with signal
+// https://git.musl-libc.org/cgit/musl/tree/src/math/atanh.c
-// - atanh(nan) = nan
 const std = @import("../std.zig");
 const math = std.math;
 const expect = std.testing.expect;
 const maxInt = std.math.maxInt;
+/// Returns the hyperbolic arc-tangent of x.
+///
+/// Special Cases:
+///  - atanh(+-1) = +-inf with signal
+///  - atanh(x)   = nan if |x| > 1 with signal
+///  - atanh(nan) = nan
 pub fn atanh(x: var) @typeOf(x) {
     const T = @typeOf(x);
     return switch (T) {

std/math/big/int.zig+112-45

...	@@ -21,32 +21,49 @@ comptime {	...	@@ -21,32 +21,49 @@ comptime {
21	debug.assert(Limb.is_signed == false);	21	debug.assert(Limb.is_signed == false);
22	}	22	}
23		23
		24	/// An arbitrary-precision big integer.
		25	///
		26	/// Memory is allocated by an Int as needed to ensure operations never overflow. The range of an
		27	/// Int is bounded only by available memory.
24	pub const Int = struct {	28	pub const Int = struct {
25	const sign_bit: usize = 1 << (usize.bit_count - 1);	29	const sign_bit: usize = 1 << (usize.bit_count - 1);
26		30
		31	/// Default number of limbs to allocate on creation of an Int.
		32	pub const default_capacity = 4;
		33
		34	/// Allocator used by the Int when requesting memory.
27	allocator: ?*Allocator,	35	allocator: ?*Allocator,
28	// - little-endian ordered	36
29	// - len >= 1 always	37	/// Raw digits. These are:
30	// - zero value -> len == 1 with limbs[0] == 0	38	///
		39	/// * Little-endian ordered
		40	/// * limbs.len >= 1
		41	/// * Zero is represent as Int.len() == 1 with limbs[0] == 0.
		42	///
		43	/// Accessing limbs directly should be avoided.
31	limbs: []Limb,	44	limbs: []Limb,
32	// High bit is the sign bit. 1 is negative, 0 positive.
33	// Remaining bits indicate the number of used limbs.
34	//
35	// If Zig gets smarter about packing data, this can be rewritten as a u1 and usize - 1 field.
36	metadata: usize,
37		45
38	const default_capacity = 4;	46	/// High bit is the sign bit. If set, Int is negative, else Int is positive.
		47	/// The remaining bits represent the number of limbs used by Int.
		48	metadata: usize,
39		49
		50	/// Creates a new Int. default_capacity limbs will be allocated immediately.
		51	/// Int will be zeroed.
40	pub fn init(allocator: *Allocator) !Int {	52	pub fn init(allocator: *Allocator) !Int {
41	return try Int.initCapacity(allocator, default_capacity);	53	return try Int.initCapacity(allocator, default_capacity);
42	}	54	}
43		55
		56	/// Creates a new Int. Int will be set to `value`.
		57	///
		58	/// This is identical to an `init`, followed by a `set`.
44	pub fn initSet(allocator: *Allocator, value: var) !Int {	59	pub fn initSet(allocator: *Allocator, value: var) !Int {
45	var s = try Int.init(allocator);	60	var s = try Int.init(allocator);
46	try s.set(value);	61	try s.set(value);
47	return s;	62	return s;
48	}	63	}
49		64
		65	/// Creates a new Int with a specific capacity. If capacity < default_capacity then the
		66	/// default capacity will be used instead.
50	pub fn initCapacity(allocator: *Allocator, capacity: usize) !Int {	67	pub fn initCapacity(allocator: *Allocator, capacity: usize) !Int {
51	return Int{	68	return Int{
52	.allocator = allocator,	69	.allocator = allocator,
...	@@ -59,14 +76,17 @@ pub const Int = struct {	...	@@ -59,14 +76,17 @@ pub const Int = struct {
59	};	76	};
60	}	77	}
61		78
		79	/// Returns the number of limbs currently in use.
62	pub fn len(self: Int) usize {	80	pub fn len(self: Int) usize {
63	return self.metadata & ~sign_bit;	81	return self.metadata & ~sign_bit;
64	}	82	}
65		83
		84	/// Returns whether an Int is positive.
66	pub fn isPositive(self: Int) bool {	85	pub fn isPositive(self: Int) bool {
67	return self.metadata & sign_bit == 0;	86	return self.metadata & sign_bit == 0;
68	}	87	}
69		88
		89	/// Sets the sign of an Int.
70	pub fn setSign(self: *Int, positive: bool) void {	90	pub fn setSign(self: *Int, positive: bool) void {
71	if (positive) {	91	if (positive) {
72	self.metadata &= ~sign_bit;	92	self.metadata &= ~sign_bit;
...	@@ -75,14 +95,17 @@ pub const Int = struct {	...	@@ -75,14 +95,17 @@ pub const Int = struct {
75	}	95	}
76	}	96	}
77		97
		98	/// Sets the length of an Int.
		99	///
		100	/// If setLen is used, then the Int must be normalized to suit.
78	pub fn setLen(self: *Int, new_len: usize) void {	101	pub fn setLen(self: *Int, new_len: usize) void {
79	self.metadata &= sign_bit;	102	self.metadata &= sign_bit;
80	self.metadata \|= new_len;	103	self.metadata \|= new_len;
81	}	104	}
82		105
83	// Initialize an Int directly from a fixed set of limb values. This is considered read-only	106	/// Returns an Int backed by a fixed set of limb values.
84	// and cannot be used as a receiver argument to any functions. If this tries to allocate	107	/// This is read-only and cannot be used as a result argument. If the Int tries to allocate
85	// at any point a panic will occur due to the null allocator.	108	/// memory a runtime panic will occur.
86	pub fn initFixed(limbs: []const Limb) Int {	109	pub fn initFixed(limbs: []const Limb) Int {
87	var self = Int{	110	var self = Int{
88	.allocator = null,	111	.allocator = null,
...	@@ -95,6 +118,9 @@ pub const Int = struct {	...	@@ -95,6 +118,9 @@ pub const Int = struct {
95	return self;	118	return self;
96	}	119	}
97		120
		121	/// Ensures an Int has enough space allocated for capacity limbs. If the Int does not have
		122	/// sufficient capacity, the exact amount will be allocated. This occurs even if the requested
		123	/// capacity is only greater than the current capacity by one limb.
98	pub fn ensureCapacity(self: *Int, capacity: usize) !void {	124	pub fn ensureCapacity(self: *Int, capacity: usize) !void {
99	self.assertWritable();	125	self.assertWritable();
100	if (capacity <= self.limbs.len) {	126	if (capacity <= self.limbs.len) {
...	@@ -110,12 +136,15 @@ pub const Int = struct {	...	@@ -110,12 +136,15 @@ pub const Int = struct {
110	}	136	}
111	}	137	}
112		138
		139	/// Frees all memory associated with an Int.
113	pub fn deinit(self: *Int) void {	140	pub fn deinit(self: *Int) void {
114	self.assertWritable();	141	self.assertWritable();
115	self.allocator.?.free(self.limbs);	142	self.allocator.?.free(self.limbs);
116	self.* = undefined;	143	self.* = undefined;
117	}	144	}
118		145
		146	/// Clones an Int and returns a new Int with the same value. The new Int is a deep copy and
		147	/// can be modified separately from the original.
119	pub fn clone(other: Int) !Int {	148	pub fn clone(other: Int) !Int {
120	other.assertWritable();	149	other.assertWritable();
121	return Int{	150	return Int{
...	@@ -129,6 +158,8 @@ pub const Int = struct {	...	@@ -129,6 +158,8 @@ pub const Int = struct {
129	};	158	};
130	}	159	}
131		160
		161	/// Copies the value of an Int to an existing Int so that they both have the same value.
		162	/// Extra memory will be allocated if the receiver does not have enough capacity.
132	pub fn copy(self: *Int, other: Int) !void {	163	pub fn copy(self: *Int, other: Int) !void {
133	self.assertWritable();	164	self.assertWritable();
134	if (self.limbs.ptr == other.limbs.ptr) {	165	if (self.limbs.ptr == other.limbs.ptr) {
...	@@ -140,6 +171,8 @@ pub const Int = struct {	...	@@ -140,6 +171,8 @@ pub const Int = struct {
140	self.metadata = other.metadata;	171	self.metadata = other.metadata;
141	}	172	}
142		173
		174	/// Efficiently swap an Int with another. This swaps the limb pointers and a full copy is not
		175	/// performed. The address of the limbs field will not be the same after this function.
143	pub fn swap(self: Int, other: Int) void {	176	pub fn swap(self: Int, other: Int) void {
144	self.assertWritable();	177	self.assertWritable();
145	mem.swap(Int, self, other);	178	mem.swap(Int, self, other);
...	@@ -152,35 +185,39 @@ pub const Int = struct {	...	@@ -152,35 +185,39 @@ pub const Int = struct {
152	debug.warn("\n");	185	debug.warn("\n");
153	}	186	}
154		187
		188	/// Negate the sign of an Int.
155	pub fn negate(self: *Int) void {	189	pub fn negate(self: *Int) void {
156	self.metadata ^= sign_bit;	190	self.metadata ^= sign_bit;
157	}	191	}
158		192
		193	/// Make an Int positive.
159	pub fn abs(self: *Int) void {	194	pub fn abs(self: *Int) void {
160	self.metadata &= ~sign_bit;	195	self.metadata &= ~sign_bit;
161	}	196	}
162		197
		198	/// Returns true if an Int is odd.
163	pub fn isOdd(self: Int) bool {	199	pub fn isOdd(self: Int) bool {
164	return self.limbs[0] & 1 != 0;	200	return self.limbs[0] & 1 != 0;
165	}	201	}
166		202
		203	/// Returns true if an Int is even.
167	pub fn isEven(self: Int) bool {	204	pub fn isEven(self: Int) bool {
168	return !self.isOdd();	205	return !self.isOdd();
169	}	206	}
170		207
171	// Returns the number of bits required to represent the absolute value of self.	208	/// Returns the number of bits required to represent the absolute value an Int.
172	fn bitCountAbs(self: Int) usize {	209	fn bitCountAbs(self: Int) usize {
173	return (self.len() - 1) * Limb.bit_count + (Limb.bit_count - @clz(self.limbs[self.len() - 1]));	210	return (self.len() - 1) * Limb.bit_count + (Limb.bit_count - @clz(self.limbs[self.len() - 1]));
174	}	211	}
175		212
176	// Returns the number of bits required to represent the integer in twos-complement form.	213	/// Returns the number of bits required to represent the integer in twos-complement form.
177	//	214	///
178	// If the integer is negative the value returned is the number of bits needed by a signed	215	/// If the integer is negative the value returned is the number of bits needed by a signed
179	// integer to represent the value. If positive the value is the number of bits for an	216	/// integer to represent the value. If positive the value is the number of bits for an
180	// unsigned integer. Any unsigned integer will fit in the signed integer with bitcount	217	/// unsigned integer. Any unsigned integer will fit in the signed integer with bitcount
181	// one greater than the returned value.	218	/// one greater than the returned value.
182	//	219	///
183	// e.g. -127 returns 8 as it will fit in an i8. 127 returns 7 since it fits in a u7.	220	/// e.g. -127 returns 8 as it will fit in an i8. 127 returns 7 since it fits in a u7.
184	fn bitCountTwosComp(self: Int) usize {	221	fn bitCountTwosComp(self: Int) usize {
185	var bits = self.bitCountAbs();	222	var bits = self.bitCountAbs();
186		223
...	@@ -203,7 +240,7 @@ pub const Int = struct {	...	@@ -203,7 +240,7 @@ pub const Int = struct {
203	return bits;	240	return bits;
204	}	241	}
205		242
206	pub fn fitsInTwosComp(self: Int, is_signed: bool, bit_count: usize) bool {	243	fn fitsInTwosComp(self: Int, is_signed: bool, bit_count: usize) bool {
207	if (self.eqZero()) {	244	if (self.eqZero()) {
208	return true;	245	return true;
209	}	246	}
...	@@ -215,18 +252,20 @@ pub const Int = struct {	...	@@ -215,18 +252,20 @@ pub const Int = struct {
215	return bit_count >= req_bits;	252	return bit_count >= req_bits;
216	}	253	}
217		254
		255	/// Returns whether self can fit into an integer of the requested type.
218	pub fn fits(self: Int, comptime T: type) bool {	256	pub fn fits(self: Int, comptime T: type) bool {
219	return self.fitsInTwosComp(T.is_signed, T.bit_count);	257	return self.fitsInTwosComp(T.is_signed, T.bit_count);
220	}	258	}
221		259
222	// Returns the approximate size of the integer in the given base. Negative values accommodate for	260	/// Returns the approximate size of the integer in the given base. Negative values accommodate for
223	// the minus sign. This is used for determining the number of characters needed to print the	261	/// the minus sign. This is used for determining the number of characters needed to print the
224	// value. It is inexact and will exceed the given value by 1-2 digits.	262	/// value. It is inexact and may exceed the given value by ~1-2 bytes.
225	pub fn sizeInBase(self: Int, base: usize) usize {	263	pub fn sizeInBase(self: Int, base: usize) usize {
226	const bit_count = usize(@boolToInt(!self.isPositive())) + self.bitCountAbs();	264	const bit_count = usize(@boolToInt(!self.isPositive())) + self.bitCountAbs();
227	return (bit_count / math.log2(base)) + 1;	265	return (bit_count / math.log2(base)) + 1;
228	}	266	}
229		267
		268	/// Sets an Int to value. Value must be an primitive integer type.
230	pub fn set(self: *Int, value: var) Allocator.Error!void {	269	pub fn set(self: *Int, value: var) Allocator.Error!void {
231	self.assertWritable();	270	self.assertWritable();
232	const T = @typeOf(value);	271	const T = @typeOf(value);
...	@@ -290,6 +329,9 @@ pub const Int = struct {	...	@@ -290,6 +329,9 @@ pub const Int = struct {
290	TargetTooSmall,	329	TargetTooSmall,
291	};	330	};
292		331
		332	/// Convert self to type T.
		333	///
		334	/// Returns an error if self cannot be narrowed into the requested type without truncation.
293	pub fn to(self: Int, comptime T: type) ConvertError!T {	335	pub fn to(self: Int, comptime T: type) ConvertError!T {
294	switch (@typeId(T)) {	336	switch (@typeId(T)) {
295	TypeId.Int => {	337	TypeId.Int => {
...	@@ -353,6 +395,13 @@ pub const Int = struct {	...	@@ -353,6 +395,13 @@ pub const Int = struct {
353	};	395	};
354	}	396	}
355		397
		398	/// Set self from the string representation `value`.
		399	///
		400	/// value must contain only digits <= `base`. Base prefixes are not allowed (e.g. 0x43 should
		401	/// simply be 43).
		402	///
		403	/// Returns an error if memory could not be allocated or `value` has invalid digits for the
		404	/// requested base.
356	pub fn setString(self: *Int, base: u8, value: []const u8) !void {	405	pub fn setString(self: *Int, base: u8, value: []const u8) !void {
357	self.assertWritable();	406	self.assertWritable();
358	if (base < 2 or base > 16) {	407	if (base < 2 or base > 16) {
...	@@ -380,6 +429,8 @@ pub const Int = struct {	...	@@ -380,6 +429,8 @@ pub const Int = struct {
380	self.setSign(positive);	429	self.setSign(positive);
381	}	430	}
382		431
		432	/// Converts self to a string in the requested base. Memory is allocated from the provided
		433	/// allocator and not the one present in self.
383	/// TODO make this call format instead of the other way around	434	/// TODO make this call format instead of the other way around
384	pub fn toString(self: Int, allocator: *Allocator, base: u8) ![]const u8 {	435	pub fn toString(self: Int, allocator: *Allocator, base: u8) ![]const u8 {
385	if (base < 2 or base > 16) {	436	if (base < 2 or base > 16) {
...	@@ -463,7 +514,7 @@ pub const Int = struct {	...	@@ -463,7 +514,7 @@ pub const Int = struct {
463	return s;	514	return s;
464	}	515	}
465		516
466	/// for the std lib format function	517	/// To allow `std.fmt.printf` to work with Int.
467	/// TODO make this non-allocating	518	/// TODO make this non-allocating
468	pub fn format(	519	pub fn format(
469	self: Int,	520	self: Int,
...	@@ -480,7 +531,7 @@ pub const Int = struct {	...	@@ -480,7 +531,7 @@ pub const Int = struct {
480	return output(context, str);	531	return output(context, str);
481	}	532	}
482		533
483	// returns -1, 0, 1 if \|a\| < \|b\|, \|a\| == \|b\| or \|a\| > \|b\| respectively.	534	/// Returns -1, 0, 1 if \|a\| < \|b\|, \|a\| == \|b\| or \|a\| > \|b\| respectively.
484	pub fn cmpAbs(a: Int, b: Int) i8 {	535	pub fn cmpAbs(a: Int, b: Int) i8 {
485	if (a.len() < b.len()) {	536	if (a.len() < b.len()) {
486	return -1;	537	return -1;
...	@@ -505,7 +556,7 @@ pub const Int = struct {	...	@@ -505,7 +556,7 @@ pub const Int = struct {
505	}	556	}
506	}	557	}
507		558
508	// returns -1, 0, 1 if a < b, a == b or a > b respectively.	559	/// Returns -1, 0, 1 if a < b, a == b or a > b respectively.
509	pub fn cmp(a: Int, b: Int) i8 {	560	pub fn cmp(a: Int, b: Int) i8 {
510	if (a.isPositive() != b.isPositive()) {	561	if (a.isPositive() != b.isPositive()) {
511	return if (a.isPositive()) i8(1) else -1;	562	return if (a.isPositive()) i8(1) else -1;
...	@@ -515,17 +566,17 @@ pub const Int = struct {	...	@@ -515,17 +566,17 @@ pub const Int = struct {
515	}	566	}
516	}	567	}
517		568
518	// if a == 0	569	/// Returns true if a == 0.
519	pub fn eqZero(a: Int) bool {	570	pub fn eqZero(a: Int) bool {
520	return a.len() == 1 and a.limbs[0] == 0;	571	return a.len() == 1 and a.limbs[0] == 0;
521	}	572	}
522		573
523	// if \|a\| == \|b\|	574	/// Returns true if \|a\| == \|b\|.
524	pub fn eqAbs(a: Int, b: Int) bool {	575	pub fn eqAbs(a: Int, b: Int) bool {
525	return cmpAbs(a, b) == 0;	576	return cmpAbs(a, b) == 0;
526	}	577	}
527		578
528	// if a == b	579	/// Returns true if a == b.
529	pub fn eq(a: Int, b: Int) bool {	580	pub fn eq(a: Int, b: Int) bool {
530	return cmp(a, b) == 0;	581	return cmp(a, b) == 0;
531	}	582	}
...	@@ -559,7 +610,11 @@ pub const Int = struct {	...	@@ -559,7 +610,11 @@ pub const Int = struct {
559	};	610	};
560	}	611	}
561		612
562	// r = a + b	613	/// r = a + b
		614	///
		615	/// r, a and b may be aliases.
		616	///
		617	/// Returns an error if memory could not be allocated.
563	pub fn add(r: *Int, a: Int, b: Int) Allocator.Error!void {	618	pub fn add(r: *Int, a: Int, b: Int) Allocator.Error!void {
564	r.assertWritable();	619	r.assertWritable();
565	if (a.eqZero()) {	620	if (a.eqZero()) {
...	@@ -617,7 +672,11 @@ pub const Int = struct {	...	@@ -617,7 +672,11 @@ pub const Int = struct {
617	r[i] = carry;	672	r[i] = carry;
618	}	673	}
619		674
620	// r = a - b	675	/// r = a - b
		676	///
		677	/// r, a and b may be aliases.
		678	///
		679	/// Returns an error if memory could not be allocated.
621	pub fn sub(r: *Int, a: Int, b: Int) !void {	680	pub fn sub(r: *Int, a: Int, b: Int) !void {
622	r.assertWritable();	681	r.assertWritable();
623	if (a.isPositive() != b.isPositive()) {	682	if (a.isPositive() != b.isPositive()) {
...	@@ -684,9 +743,11 @@ pub const Int = struct {	...	@@ -684,9 +743,11 @@ pub const Int = struct {
684	debug.assert(borrow == 0);	743	debug.assert(borrow == 0);
685	}	744	}
686		745
687	// rma = a * b	746	/// rma = a * b
688	//	747	///
689	// For greatest efficiency, ensure rma does not alias a or b.	748	/// rma, a and b may be aliases. However, it is more efficient if rma does not alias a or b.
		749	///
		750	/// Returns an error if memory could not be allocated.
690	pub fn mul(rma: *Int, a: Int, b: Int) !void {	751	pub fn mul(rma: *Int, a: Int, b: Int) !void {
691	rma.assertWritable();	752	rma.assertWritable();
692		753
...	@@ -759,6 +820,9 @@ pub const Int = struct {	...	@@ -759,6 +820,9 @@ pub const Int = struct {
759	}	820	}
760	}	821	}
761		822
		823	/// q = a / b (rem r)
		824	///
		825	/// a / b are floored (rounded towards 0).
762	pub fn divFloor(q: Int, r: Int, a: Int, b: Int) !void {	826	pub fn divFloor(q: Int, r: Int, a: Int, b: Int) !void {
763	try div(q, r, a, b);	827	try div(q, r, a, b);
764		828
...	@@ -771,6 +835,9 @@ pub const Int = struct {	...	@@ -771,6 +835,9 @@ pub const Int = struct {
771	r.setSign(b.isPositive());	835	r.setSign(b.isPositive());
772	}	836	}
773		837
		838	/// q = a / b (rem r)
		839	///
		840	/// a / b are truncated (rounded towards -inf).
774	pub fn divTrunc(q: Int, r: Int, a: Int, b: Int) !void {	841	pub fn divTrunc(q: Int, r: Int, a: Int, b: Int) !void {
775	try div(q, r, a, b);	842	try div(q, r, a, b);
776	r.setSign(a.isPositive());	843	r.setSign(a.isPositive());
...	@@ -969,7 +1036,7 @@ pub const Int = struct {	...	@@ -969,7 +1036,7 @@ pub const Int = struct {
969	r.normalize(r.len());	1036	r.normalize(r.len());
970	}	1037	}
971		1038
972	// r = a << shift, in other words, r = a * 2^shift	1039	/// r = a << shift, in other words, r = a * 2^shift
973	pub fn shiftLeft(r: *Int, a: Int, shift: usize) !void {	1040	pub fn shiftLeft(r: *Int, a: Int, shift: usize) !void {
974	r.assertWritable();	1041	r.assertWritable();
975		1042
...	@@ -1002,7 +1069,7 @@ pub const Int = struct {	...	@@ -1002,7 +1069,7 @@ pub const Int = struct {
1002	mem.set(Limb, r[0 .. limb_shift - 1], 0);	1069	mem.set(Limb, r[0 .. limb_shift - 1], 0);
1003	}	1070	}
1004		1071
1005	// r = a >> shift	1072	/// r = a >> shift
1006	pub fn shiftRight(r: *Int, a: Int, shift: usize) !void {	1073	pub fn shiftRight(r: *Int, a: Int, shift: usize) !void {
1007	r.assertWritable();	1074	r.assertWritable();
1008		1075
...	@@ -1038,7 +1105,9 @@ pub const Int = struct {	...	@@ -1038,7 +1105,9 @@ pub const Int = struct {
1038	}	1105	}
1039	}	1106	}
1040		1107
1041	// r = a \| b	1108	/// r = a \| b
		1109	///
		1110	/// a and b are zero-extended to the longer of a or b.
1042	pub fn bitOr(r: *Int, a: Int, b: Int) !void {	1111	pub fn bitOr(r: *Int, a: Int, b: Int) !void {
1043	r.assertWritable();	1112	r.assertWritable();
1044		1113
...	@@ -1067,7 +1136,7 @@ pub const Int = struct {	...	@@ -1067,7 +1136,7 @@ pub const Int = struct {
1067	}	1136	}
1068	}	1137	}
1069		1138
1070	// r = a & b	1139	/// r = a & b
1071	pub fn bitAnd(r: *Int, a: Int, b: Int) !void {	1140	pub fn bitAnd(r: *Int, a: Int, b: Int) !void {
1072	r.assertWritable();	1141	r.assertWritable();
1073		1142
...	@@ -1093,7 +1162,7 @@ pub const Int = struct {	...	@@ -1093,7 +1162,7 @@ pub const Int = struct {
1093	}	1162	}
1094	}	1163	}
1095		1164
1096	// r = a ^ b	1165	/// r = a ^ b
1097	pub fn bitXor(r: *Int, a: Int, b: Int) !void {	1166	pub fn bitXor(r: *Int, a: Int, b: Int) !void {
1098	r.assertWritable();	1167	r.assertWritable();
1099		1168
...	@@ -1279,10 +1348,8 @@ test "big.int bitcount/to" {	...	@@ -1279,10 +1348,8 @@ test "big.int bitcount/to" {
1279	try a.set(0);	1348	try a.set(0);
1280	testing.expect(a.bitCountTwosComp() == 0);	1349	testing.expect(a.bitCountTwosComp() == 0);
1281		1350
1282	// TODO: stack smashing	1351	testing.expect((try a.to(u0)) == 0);
1283	// testing.expect((try a.to(u0)) == 0);	1352	testing.expect((try a.to(i0)) == 0);
1284	// TODO: sigsegv
1285	// testing.expect((try a.to(i0)) == 0);
1286		1353
1287	try a.set(-1);	1354	try a.set(-1);
1288	testing.expect(a.bitCountTwosComp() == 1);	1355	testing.expect(a.bitCountTwosComp() == 1);

std/math/big/rational.zig+55-13

 @@ -14,11 +14,22 @@ const Limb = bn.Limb;
 const DoubleLimb = bn.DoubleLimb;
 const Int = bn.Int;
+/// An arbitrary-precision rational number.
+///
+/// Memory is allocated as needed for operations to ensure full precision is kept. The precision
+/// of a Rational is only bounded by memory.
+///
+/// Rational's are always normalized. That is, for a Rational r = p/q where p and q are integers,
+/// gcd(p, q) = 1 always.
 pub const Rational = struct {
-    // Sign of Rational is sign of p. Sign of q is ignored
+    /// Numerator. Determines the sign of the Rational.
     p: Int,
+    /// Denominator. Sign is ignored.
     q: Int,
+    /// Create a new Rational. A small amount of memory will be allocated on initialization.
+    /// This will be 2 * Int.default_capacity.
     pub fn init(a: *Allocator) !Rational {
         return Rational{
             .p = try Int.init(a),
 @@ -26,18 +37,21 @@ pub const Rational = struct {
         };
     }
+    /// Frees all memory associated with a Rational.
     pub fn deinit(self: *Rational) void {
         self.p.deinit();
         self.q.deinit();
     }
+    /// Set a Rational from a primitive integer type.
     pub fn setInt(self: *Rational, a: var) !void {
         try self.p.set(a);
         try self.q.set(1);
     }
-    // TODO: Accept a/b fractions and exponent form
+    /// Set a Rational from a string of the form `A/B` where A and B are base-10 integers.
     pub fn setFloatString(self: *Rational, str: []const u8) !void {
+        // TODO: Accept a/b fractions and exponent form
         if (str.len == 0) {
             return error.InvalidFloatString;
         }
 @@ -111,8 +125,10 @@ pub const Rational = struct {
         }
     }
-    // Translated from golang.go/src/math/big/rat.go.
+    /// Set a Rational from a floating-point value. The rational will have enough precision to
+    /// completely represent the provided float.
     pub fn setFloat(self: *Rational, comptime T: type, f: T) !void {
+        // Translated from golang.go/src/math/big/rat.go.
         debug.assert(@typeId(T) == builtin.TypeId.Float);
         const UnsignedIntType = @IntType(false, T.bit_count);
 @@ -164,8 +180,13 @@ pub const Rational = struct {
         try self.reduce();
     }
-    // Translated from golang.go/src/math/big/rat.go.
+    /// Return a floating-point value that is the closest value to a Rational.
+    ///
+    /// The result may not be exact if the Rational is too precise or too large for the
+    /// target type.
     pub fn toFloat(self: Rational, comptime T: type) !T {
+        // Translated from golang.go/src/math/big/rat.go.
+        // TODO: Indicate whether the result is not exact.
         debug.assert(@typeId(T) == builtin.TypeId.Float);
         const fsize = T.bit_count;
 @@ -259,6 +280,7 @@ pub const Rational = struct {
         return if (self.p.isPositive()) f else -f;
     }
+    /// Set a rational from an integer ratio.
     pub fn setRatio(self: *Rational, p: var, q: var) !void {
         try self.p.set(p);
         try self.q.set(q);
 @@ -273,11 +295,13 @@ pub const Rational = struct {
         }
     }
+    /// Set a Rational directly from an Int.
     pub fn copyInt(self: *Rational, a: Int) !void {
         try self.p.copy(a);
         try self.q.set(1);
     }
+    /// Set a Rational directly from a ratio of two Int's.
     pub fn copyRatio(self: *Rational, a: Int, b: Int) !void {
         try self.p.copy(a);
         try self.q.copy(b);
 @@ -288,23 +312,29 @@ pub const Rational = struct {
         try self.reduce();
     }
+    /// Make a Rational positive.
     pub fn abs(r: *Rational) void {
         r.p.abs();
     }
+    /// Negate the sign of a Rational.
     pub fn negate(r: *Rational) void {
         r.p.negate();
     }
+    /// Efficiently swap a Rational with another. This swaps the limb pointers and a full copy is not
+    /// performed. The address of the limbs field will not be the same after this function.
     pub fn swap(r: *Rational, other: *Rational) void {
         r.p.swap(&other.p);
         r.q.swap(&other.q);
     }
+    /// Returns -1, 0, 1 if a < b, a == b or a > b respectively.
     pub fn cmp(a: Rational, b: Rational) !i8 {
         return cmpInternal(a, b, true);
     }
+    /// Returns -1, 0, 1 if |a| < |b|, |a| == |b| or |a| > |b| respectively.
     pub fn cmpAbs(a: Rational, b: Rational) !i8 {
         return cmpInternal(a, b, false);
     }
 @@ -325,9 +355,11 @@ pub const Rational = struct {
         return if (is_abs) q.cmpAbs(p) else q.cmp(p);
     }
-    // r/q = ap/aq + bp/bq = (ap*bq + bp*aq) / (aq*bq)
+    /// rma = a + b.
-    //
+    ///
-    // For best performance, rma should not alias a or b.
+    /// rma, a and b may be aliases. However, it is more efficient if rma does not alias a or b.
+    ///
+    /// Returns an error if memory could not be allocated.
     pub fn add(rma: *Rational, a: Rational, b: Rational) !void {
         var r = rma;
         var aliased = rma.p.limbs.ptr == a.p.limbs.ptr or rma.p.limbs.ptr == b.p.limbs.ptr;
 @@ -351,9 +383,11 @@ pub const Rational = struct {
         try r.reduce();
     }
-    // r/q = ap/aq - bp/bq = (ap*bq - bp*aq) / (aq*bq)
+    /// rma = a - b.
-    //
+    ///
-    // For best performance, rma should not alias a or b.
+    /// rma, a and b may be aliases. However, it is more efficient if rma does not alias a or b.
+    ///
+    /// Returns an error if memory could not be allocated.
     pub fn sub(rma: *Rational, a: Rational, b: Rational) !void {
         var r = rma;
         var aliased = rma.p.limbs.ptr == a.p.limbs.ptr or rma.p.limbs.ptr == b.p.limbs.ptr;
 @@ -377,14 +411,22 @@ pub const Rational = struct {
         try r.reduce();
     }
-    // r/q = ap/aq * bp/bq = ap*bp / aq*bq
+    /// rma = a * b.
+    ///
+    /// rma, a and b may be aliases. However, it is more efficient if rma does not alias a or b.
+    ///
+    /// Returns an error if memory could not be allocated.
     pub fn mul(r: *Rational, a: Rational, b: Rational) !void {
         try r.p.mul(a.p, b.p);
         try r.q.mul(a.q, b.q);
         try r.reduce();
     }
-    // r/q = (ap/aq) / (bp/bq) = ap*bq / bp*aq
+    /// rma = a / b.
+    ///
+    /// rma, a and b may be aliases. However, it is more efficient if rma does not alias a or b.
+    ///
+    /// Returns an error if memory could not be allocated.
     pub fn div(r: *Rational, a: Rational, b: Rational) !void {
         if (b.p.eqZero()) {
             @panic("division by zero");
 @@ -395,7 +437,7 @@ pub const Rational = struct {
         try r.reduce();
     }
-    // r/q = q/r
+    /// Invert the numerator and denominator fields of a Rational. p/q => q/p.
     pub fn invert(r: *Rational) void {
         Int.swap(&r.p, &r.q);
     }

std/math/cbrt.zig+10-4

 @@ -1,13 +1,19 @@
-// Special Cases:
+// Ported from musl, which is licensed under the MIT license:
+// https://git.musl-libc.org/cgit/musl/tree/COPYRIGHT
 //
-// - cbrt(+-0)   = +-0
+// https://git.musl-libc.org/cgit/musl/tree/src/math/cbrtf.c
-// - cbrt(+-inf) = +-inf
+// https://git.musl-libc.org/cgit/musl/tree/src/math/cbrt.c
-// - cbrt(nan)   = nan
 const std = @import("../std.zig");
 const math = std.math;
 const expect = std.testing.expect;
+/// Returns the cube root of x.
+///
+/// Special Cases:
+///  - cbrt(+-0)   = +-0
+///  - cbrt(+-inf) = +-inf
+///  - cbrt(nan)   = nan
 pub fn cbrt(x: var) @typeOf(x) {
     const T = @typeOf(x);
     return switch (T) {

std/math/ceil.zig+10-4

 @@ -1,14 +1,20 @@
-// Special Cases:
+// Ported from musl, which is licensed under the MIT license:
+// https://git.musl-libc.org/cgit/musl/tree/COPYRIGHT
 //
-// - ceil(+-0)   = +-0
+// https://git.musl-libc.org/cgit/musl/tree/src/math/ceilf.c
-// - ceil(+-inf) = +-inf
+// https://git.musl-libc.org/cgit/musl/tree/src/math/ceil.c
-// - ceil(nan)   = nan
 const builtin = @import("builtin");
 const std = @import("../std.zig");
 const math = std.math;
 const expect = std.testing.expect;
+/// Returns the least integer value greater than of equal to x.
+///
+/// Special Cases:
+///  - ceil(+-0)   = +-0
+///  - ceil(+-inf) = +-inf
+///  - ceil(nan)   = nan
 pub fn ceil(x: var) @typeOf(x) {
     const T = @typeOf(x);
     return switch (T) {

std/math/complex.zig+12

...	@@ -23,13 +23,18 @@ pub const sqrt = @import("complex/sqrt.zig").sqrt;	...	@@ -23,13 +23,18 @@ pub const sqrt = @import("complex/sqrt.zig").sqrt;
23	pub const tanh = @import("complex/tanh.zig").tanh;	23	pub const tanh = @import("complex/tanh.zig").tanh;
24	pub const tan = @import("complex/tan.zig").tan;	24	pub const tan = @import("complex/tan.zig").tan;
25		25
		26	/// A complex number consisting of a real an imaginary part. T must be a floating-point value.
26	pub fn Complex(comptime T: type) type {	27	pub fn Complex(comptime T: type) type {
27	return struct {	28	return struct {
28	const Self = @This();	29	const Self = @This();
29		30
		31	/// Real part.
30	re: T,	32	re: T,
		33
		34	/// Imaginary part.
31	im: T,	35	im: T,
32		36
		37	/// Create a new Complex number from the given real and imaginary parts.
33	pub fn new(re: T, im: T) Self {	38	pub fn new(re: T, im: T) Self {
34	return Self{	39	return Self{
35	.re = re,	40	.re = re,
...	@@ -37,6 +42,7 @@ pub fn Complex(comptime T: type) type {	...	@@ -37,6 +42,7 @@ pub fn Complex(comptime T: type) type {
37	};	42	};
38	}	43	}
39		44
		45	/// Returns the sum of two complex numbers.
40	pub fn add(self: Self, other: Self) Self {	46	pub fn add(self: Self, other: Self) Self {
41	return Self{	47	return Self{
42	.re = self.re + other.re,	48	.re = self.re + other.re,
...	@@ -44,6 +50,7 @@ pub fn Complex(comptime T: type) type {	...	@@ -44,6 +50,7 @@ pub fn Complex(comptime T: type) type {
44	};	50	};
45	}	51	}
46		52
		53	/// Returns the subtraction of two complex numbers.
47	pub fn sub(self: Self, other: Self) Self {	54	pub fn sub(self: Self, other: Self) Self {
48	return Self{	55	return Self{
49	.re = self.re - other.re,	56	.re = self.re - other.re,
...	@@ -51,6 +58,7 @@ pub fn Complex(comptime T: type) type {	...	@@ -51,6 +58,7 @@ pub fn Complex(comptime T: type) type {
51	};	58	};
52	}	59	}
53		60
		61	/// Returns the product of two complex numbers.
54	pub fn mul(self: Self, other: Self) Self {	62	pub fn mul(self: Self, other: Self) Self {
55	return Self{	63	return Self{
56	.re = self.re * other.re - self.im * other.im,	64	.re = self.re * other.re - self.im * other.im,
...	@@ -58,6 +66,7 @@ pub fn Complex(comptime T: type) type {	...	@@ -58,6 +66,7 @@ pub fn Complex(comptime T: type) type {
58	};	66	};
59	}	67	}
60		68
		69	/// Returns the quotient of two complex numbers.
61	pub fn div(self: Self, other: Self) Self {	70	pub fn div(self: Self, other: Self) Self {
62	const re_num = self.re * other.re + self.im * other.im;	71	const re_num = self.re * other.re + self.im * other.im;
63	const im_num = self.im * other.re - self.re * other.im;	72	const im_num = self.im * other.re - self.re * other.im;
...	@@ -69,6 +78,7 @@ pub fn Complex(comptime T: type) type {	...	@@ -69,6 +78,7 @@ pub fn Complex(comptime T: type) type {
69	};	78	};
70	}	79	}
71		80
		81	/// Returns the complex conjugate of a number.
72	pub fn conjugate(self: Self) Self {	82	pub fn conjugate(self: Self) Self {
73	return Self{	83	return Self{
74	.re = self.re,	84	.re = self.re,
...	@@ -76,6 +86,7 @@ pub fn Complex(comptime T: type) type {	...	@@ -76,6 +86,7 @@ pub fn Complex(comptime T: type) type {
76	};	86	};
77	}	87	}
78		88
		89	/// Returns the reciprocal of a complex number.
79	pub fn reciprocal(self: Self) Self {	90	pub fn reciprocal(self: Self) Self {
80	const m = self.re * self.re + self.im * self.im;	91	const m = self.re * self.re + self.im * self.im;
81	return Self{	92	return Self{
...	@@ -84,6 +95,7 @@ pub fn Complex(comptime T: type) type {	...	@@ -84,6 +95,7 @@ pub fn Complex(comptime T: type) type {
84	};	95	};
85	}	96	}
86		97
		98	/// Returns the magnitude of a complex number.
87	pub fn magnitude(self: Self) T {	99	pub fn magnitude(self: Self) T {
88	return math.sqrt(self.re * self.re + self.im * self.im);	100	return math.sqrt(self.re * self.re + self.im * self.im);
89	}	101	}

std/math/complex/abs.zig+1

...	@@ -4,6 +4,7 @@ const math = std.math;	...	@@ -4,6 +4,7 @@ const math = std.math;
4	const cmath = math.complex;	4	const cmath = math.complex;
5	const Complex = cmath.Complex;	5	const Complex = cmath.Complex;
6		6
		7	/// Returns the absolute value (modulus) of z.
7	pub fn abs(z: var) @typeOf(z.re) {	8	pub fn abs(z: var) @typeOf(z.re) {
8	const T = @typeOf(z.re);	9	const T = @typeOf(z.re);
9	return math.hypot(T, z.re, z.im);	10	return math.hypot(T, z.re, z.im);

std/math/complex/acos.zig+1

...	@@ -4,6 +4,7 @@ const math = std.math;	...	@@ -4,6 +4,7 @@ const math = std.math;
4	const cmath = math.complex;	4	const cmath = math.complex;
5	const Complex = cmath.Complex;	5	const Complex = cmath.Complex;
6		6
		7	/// Returns the arc-cosine of z.
7	pub fn acos(z: var) Complex(@typeOf(z.re)) {	8	pub fn acos(z: var) Complex(@typeOf(z.re)) {
8	const T = @typeOf(z.re);	9	const T = @typeOf(z.re);
9	const q = cmath.asin(z);	10	const q = cmath.asin(z);

std/math/complex/acosh.zig+1

...	@@ -4,6 +4,7 @@ const math = std.math;	...	@@ -4,6 +4,7 @@ const math = std.math;
4	const cmath = math.complex;	4	const cmath = math.complex;
5	const Complex = cmath.Complex;	5	const Complex = cmath.Complex;
6		6
		7	/// Returns the hyperbolic arc-cosine of z.
7	pub fn acosh(z: var) Complex(@typeOf(z.re)) {	8	pub fn acosh(z: var) Complex(@typeOf(z.re)) {
8	const T = @typeOf(z.re);	9	const T = @typeOf(z.re);
9	const q = cmath.acos(z);	10	const q = cmath.acos(z);

std/math/complex/arg.zig+1

...	@@ -4,6 +4,7 @@ const math = std.math;	...	@@ -4,6 +4,7 @@ const math = std.math;
4	const cmath = math.complex;	4	const cmath = math.complex;
5	const Complex = cmath.Complex;	5	const Complex = cmath.Complex;
6		6
		7	/// Returns the angular component (in radians) of z.
7	pub fn arg(z: var) @typeOf(z.re) {	8	pub fn arg(z: var) @typeOf(z.re) {
8	const T = @typeOf(z.re);	9	const T = @typeOf(z.re);
9	return math.atan2(T, z.im, z.re);	10	return math.atan2(T, z.im, z.re);

std/math/complex/asin.zig+1

...	@@ -4,6 +4,7 @@ const math = std.math;	...	@@ -4,6 +4,7 @@ const math = std.math;
4	const cmath = math.complex;	4	const cmath = math.complex;
5	const Complex = cmath.Complex;	5	const Complex = cmath.Complex;
6		6
		7	// Returns the arc-sine of z.
7	pub fn asin(z: var) Complex(@typeOf(z.re)) {	8	pub fn asin(z: var) Complex(@typeOf(z.re)) {
8	const T = @typeOf(z.re);	9	const T = @typeOf(z.re);
9	const x = z.re;	10	const x = z.re;

std/math/complex/asinh.zig+1

...	@@ -4,6 +4,7 @@ const math = std.math;	...	@@ -4,6 +4,7 @@ const math = std.math;
4	const cmath = math.complex;	4	const cmath = math.complex;
5	const Complex = cmath.Complex;	5	const Complex = cmath.Complex;
6		6
		7	/// Returns the hyperbolic arc-sine of z.
7	pub fn asinh(z: var) Complex(@typeOf(z.re)) {	8	pub fn asinh(z: var) Complex(@typeOf(z.re)) {
8	const T = @typeOf(z.re);	9	const T = @typeOf(z.re);
9	const q = Complex(T).new(-z.im, z.re);	10	const q = Complex(T).new(-z.im, z.re);

std/math/complex/atan.zig+7

 @@ -1,9 +1,16 @@
+// Ported from musl, which is licensed under the MIT license:
+// https://git.musl-libc.org/cgit/musl/tree/COPYRIGHT
+//
+// https://git.musl-libc.org/cgit/musl/tree/src/complex/catanf.c
+// https://git.musl-libc.org/cgit/musl/tree/src/complex/catan.c
 const std = @import("../../std.zig");
 const testing = std.testing;
 const math = std.math;
 const cmath = math.complex;
 const Complex = cmath.Complex;
+/// Returns the arc-tangent of z.
 pub fn atan(z: var) @typeOf(z) {
     const T = @typeOf(z.re);
     return switch (T) {

std/math/complex/atanh.zig+1

...	@@ -4,6 +4,7 @@ const math = std.math;	...	@@ -4,6 +4,7 @@ const math = std.math;
4	const cmath = math.complex;	4	const cmath = math.complex;
5	const Complex = cmath.Complex;	5	const Complex = cmath.Complex;
6		6
		7	/// Returns the hyperbolic arc-tangent of z.
7	pub fn atanh(z: var) Complex(@typeOf(z.re)) {	8	pub fn atanh(z: var) Complex(@typeOf(z.re)) {
8	const T = @typeOf(z.re);	9	const T = @typeOf(z.re);
9	const q = Complex(T).new(-z.im, z.re);	10	const q = Complex(T).new(-z.im, z.re);

std/math/complex/conj.zig+1

...	@@ -4,6 +4,7 @@ const math = std.math;	...	@@ -4,6 +4,7 @@ const math = std.math;
4	const cmath = math.complex;	4	const cmath = math.complex;
5	const Complex = cmath.Complex;	5	const Complex = cmath.Complex;
6		6
		7	/// Returns the complex conjugate of z.
7	pub fn conj(z: var) Complex(@typeOf(z.re)) {	8	pub fn conj(z: var) Complex(@typeOf(z.re)) {
8	const T = @typeOf(z.re);	9	const T = @typeOf(z.re);
9	return Complex(T).new(z.re, -z.im);	10	return Complex(T).new(z.re, -z.im);

std/math/complex/cos.zig+1

...	@@ -4,6 +4,7 @@ const math = std.math;	...	@@ -4,6 +4,7 @@ const math = std.math;
4	const cmath = math.complex;	4	const cmath = math.complex;
5	const Complex = cmath.Complex;	5	const Complex = cmath.Complex;
6		6
		7	/// Returns the cosine of z.
7	pub fn cos(z: var) Complex(@typeOf(z.re)) {	8	pub fn cos(z: var) Complex(@typeOf(z.re)) {
8	const T = @typeOf(z.re);	9	const T = @typeOf(z.re);
9	const p = Complex(T).new(-z.im, z.re);	10	const p = Complex(T).new(-z.im, z.re);

std/math/complex/cosh.zig+7

...	@@ -1,3 +1,9 @@	...	@@ -1,3 +1,9 @@
		1	// Ported from musl, which is licensed under the MIT license:
		2	// https://git.musl-libc.org/cgit/musl/tree/COPYRIGHT
		3	//
		4	// https://git.musl-libc.org/cgit/musl/tree/src/complex/ccoshf.c
		5	// https://git.musl-libc.org/cgit/musl/tree/src/complex/ccosh.c
		6
1	const std = @import("../../std.zig");	7	const std = @import("../../std.zig");
2	const testing = std.testing;	8	const testing = std.testing;
3	const math = std.math;	9	const math = std.math;
...	@@ -6,6 +12,7 @@ const Complex = cmath.Complex;	...	@@ -6,6 +12,7 @@ const Complex = cmath.Complex;
6		12
7	const ldexp_cexp = @import("ldexp.zig").ldexp_cexp;	13	const ldexp_cexp = @import("ldexp.zig").ldexp_cexp;
8		14
		15	/// Returns the hyperbolic arc-cosine of z.
9	pub fn cosh(z: var) Complex(@typeOf(z.re)) {	16	pub fn cosh(z: var) Complex(@typeOf(z.re)) {
10	const T = @typeOf(z.re);	17	const T = @typeOf(z.re);
11	return switch (T) {	18	return switch (T) {

std/math/complex/exp.zig+7

...	@@ -1,3 +1,9 @@	...	@@ -1,3 +1,9 @@
		1	// Ported from musl, which is licensed under the MIT license:
		2	// https://git.musl-libc.org/cgit/musl/tree/COPYRIGHT
		3	//
		4	// https://git.musl-libc.org/cgit/musl/tree/src/complex/cexpf.c
		5	// https://git.musl-libc.org/cgit/musl/tree/src/complex/cexp.c
		6
1	const std = @import("../../std.zig");	7	const std = @import("../../std.zig");
2	const testing = std.testing;	8	const testing = std.testing;
3	const math = std.math;	9	const math = std.math;
...	@@ -6,6 +12,7 @@ const Complex = cmath.Complex;	...	@@ -6,6 +12,7 @@ const Complex = cmath.Complex;
6		12
7	const ldexp_cexp = @import("ldexp.zig").ldexp_cexp;	13	const ldexp_cexp = @import("ldexp.zig").ldexp_cexp;
8		14
		15	/// Returns e raised to the power of z (e^z).
9	pub fn exp(z: var) @typeOf(z) {	16	pub fn exp(z: var) @typeOf(z) {
10	const T = @typeOf(z.re);	17	const T = @typeOf(z.re);
11		18

std/math/complex/ldexp.zig+7

 @@ -1,9 +1,16 @@
+// Ported from musl, which is licensed under the MIT license:
+// https://git.musl-libc.org/cgit/musl/tree/COPYRIGHT
+//
+// https://git.musl-libc.org/cgit/musl/tree/src/complex/__cexpf.c
+// https://git.musl-libc.org/cgit/musl/tree/src/complex/__cexp.c
 const std = @import("../../std.zig");
 const debug = std.debug;
 const math = std.math;
 const cmath = math.complex;
 const Complex = cmath.Complex;
+/// Returns exp(z) scaled to avoid overflow.
 pub fn ldexp_cexp(z: var, expt: i32) @typeOf(z) {
     const T = @typeOf(z.re);

std/math/complex/log.zig+1

...	@@ -4,6 +4,7 @@ const math = std.math;	...	@@ -4,6 +4,7 @@ const math = std.math;
4	const cmath = math.complex;	4	const cmath = math.complex;
5	const Complex = cmath.Complex;	5	const Complex = cmath.Complex;
6		6
		7	/// Returns the natural logarithm of z.
7	pub fn log(z: var) Complex(@typeOf(z.re)) {	8	pub fn log(z: var) Complex(@typeOf(z.re)) {
8	const T = @typeOf(z.re);	9	const T = @typeOf(z.re);
9	const r = cmath.abs(z);	10	const r = cmath.abs(z);

std/math/complex/pow.zig+1

...	@@ -4,6 +4,7 @@ const math = std.math;	...	@@ -4,6 +4,7 @@ const math = std.math;
4	const cmath = math.complex;	4	const cmath = math.complex;
5	const Complex = cmath.Complex;	5	const Complex = cmath.Complex;
6		6
		7	/// Returns z raised to the complex power of c.
7	pub fn pow(comptime T: type, z: T, c: T) T {	8	pub fn pow(comptime T: type, z: T, c: T) T {
8	const p = cmath.log(z);	9	const p = cmath.log(z);
9	const q = c.mul(p);	10	const q = c.mul(p);

std/math/complex/proj.zig+1

...	@@ -4,6 +4,7 @@ const math = std.math;	...	@@ -4,6 +4,7 @@ const math = std.math;
4	const cmath = math.complex;	4	const cmath = math.complex;
5	const Complex = cmath.Complex;	5	const Complex = cmath.Complex;
6		6
		7	/// Returns the projection of z onto the riemann sphere.
7	pub fn proj(z: var) Complex(@typeOf(z.re)) {	8	pub fn proj(z: var) Complex(@typeOf(z.re)) {
8	const T = @typeOf(z.re);	9	const T = @typeOf(z.re);
9		10

std/math/complex/sin.zig+1

...	@@ -4,6 +4,7 @@ const math = std.math;	...	@@ -4,6 +4,7 @@ const math = std.math;
4	const cmath = math.complex;	4	const cmath = math.complex;
5	const Complex = cmath.Complex;	5	const Complex = cmath.Complex;
6		6
		7	/// Returns the sine of z.
7	pub fn sin(z: var) Complex(@typeOf(z.re)) {	8	pub fn sin(z: var) Complex(@typeOf(z.re)) {
8	const T = @typeOf(z.re);	9	const T = @typeOf(z.re);
9	const p = Complex(T).new(-z.im, z.re);	10	const p = Complex(T).new(-z.im, z.re);

std/math/complex/sinh.zig+7

...	@@ -1,3 +1,9 @@	...	@@ -1,3 +1,9 @@
		1	// Ported from musl, which is licensed under the MIT license:
		2	// https://git.musl-libc.org/cgit/musl/tree/COPYRIGHT
		3	//
		4	// https://git.musl-libc.org/cgit/musl/tree/src/complex/csinhf.c
		5	// https://git.musl-libc.org/cgit/musl/tree/src/complex/csinh.c
		6
1	const std = @import("../../std.zig");	7	const std = @import("../../std.zig");
2	const testing = std.testing;	8	const testing = std.testing;
3	const math = std.math;	9	const math = std.math;
...	@@ -6,6 +12,7 @@ const Complex = cmath.Complex;	...	@@ -6,6 +12,7 @@ const Complex = cmath.Complex;
6		12
7	const ldexp_cexp = @import("ldexp.zig").ldexp_cexp;	13	const ldexp_cexp = @import("ldexp.zig").ldexp_cexp;
8		14
		15	/// Returns the hyperbolic sine of z.
9	pub fn sinh(z: var) @typeOf(z) {	16	pub fn sinh(z: var) @typeOf(z) {
10	const T = @typeOf(z.re);	17	const T = @typeOf(z.re);
11	return switch (T) {	18	return switch (T) {

std/math/complex/sqrt.zig+8

 @@ -1,9 +1,17 @@
+// Ported from musl, which is licensed under the MIT license:
+// https://git.musl-libc.org/cgit/musl/tree/COPYRIGHT
+//
+// https://git.musl-libc.org/cgit/musl/tree/src/complex/csqrtf.c
+// https://git.musl-libc.org/cgit/musl/tree/src/complex/csqrt.c
 const std = @import("../../std.zig");
 const testing = std.testing;
 const math = std.math;
 const cmath = math.complex;
 const Complex = cmath.Complex;
+/// Returns the square root of z. The real and imaginary parts of the result have the same sign
+/// as the imaginary part of z.
 pub fn sqrt(z: var) @typeOf(z) {
     const T = @typeOf(z.re);

std/math/complex/tan.zig+1

...	@@ -4,6 +4,7 @@ const math = std.math;	...	@@ -4,6 +4,7 @@ const math = std.math;
4	const cmath = math.complex;	4	const cmath = math.complex;
5	const Complex = cmath.Complex;	5	const Complex = cmath.Complex;
6		6
		7	/// Returns the tanget of z.
7	pub fn tan(z: var) Complex(@typeOf(z.re)) {	8	pub fn tan(z: var) Complex(@typeOf(z.re)) {
8	const T = @typeOf(z.re);	9	const T = @typeOf(z.re);
9	const q = Complex(T).new(-z.im, z.re);	10	const q = Complex(T).new(-z.im, z.re);

std/math/complex/tanh.zig+7

 @@ -1,9 +1,16 @@
+// Ported from musl, which is licensed under the MIT license:
+// https://git.musl-libc.org/cgit/musl/tree/COPYRIGHT
+//
+// https://git.musl-libc.org/cgit/musl/tree/src/complex/ctanhf.c
+// https://git.musl-libc.org/cgit/musl/tree/src/complex/ctanh.c
 const std = @import("../../std.zig");
 const testing = std.testing;
 const math = std.math;
 const cmath = math.complex;
 const Complex = cmath.Complex;
+/// Returns the hyperbolic tangent of z.
 pub fn tanh(z: var) @typeOf(z) {
     const T = @typeOf(z.re);
     return switch (T) {

std/math/copysign.zig+7

 @@ -1,8 +1,15 @@
+// Ported from musl, which is licensed under the MIT license:
+// https://git.musl-libc.org/cgit/musl/tree/COPYRIGHT
+//
+// https://git.musl-libc.org/cgit/musl/tree/src/math/copysignf.c
+// https://git.musl-libc.org/cgit/musl/tree/src/math/copysign.c
 const std = @import("../std.zig");
 const math = std.math;
 const expect = std.testing.expect;
 const maxInt = std.math.maxInt;
+/// Returns a value with the magnitude of x and the sign of y.
 pub fn copysign(comptime T: type, x: T, y: T) T {
     return switch (T) {
         f16 => copysign16(x, y),

std/math/cos.zig+46-100

 @@ -1,18 +1,23 @@
-// Special Cases:
+// Ported from go, which is licensed under a BSD-3 license.
+// https://golang.org/LICENSE
 //
-// - cos(+-inf) = nan
+// https://golang.org/src/math/sin.go
-// - cos(nan)   = nan
 const builtin = @import("builtin");
 const std = @import("../std.zig");
 const math = std.math;
 const expect = std.testing.expect;
+/// Returns the cosine of the radian value x.
+///
+/// Special Cases:
+///  - cos(+-inf) = nan
+///  - cos(nan)   = nan
 pub fn cos(x: var) @typeOf(x) {
     const T = @typeOf(x);
     return switch (T) {
-        f32 => cos32(x),
+        f32 => cos_(f32, x),
-        f64 => cos64(x),
+        f64 => cos_(f64, x),
         else => @compileError("cos not implemented for " ++ @typeName(T)),
     };
 }
 @@ -33,78 +38,24 @@ const C3 = 2.48015872888517045348E-5;
 const C4 = -1.38888888888730564116E-3;
 const C5 = 4.16666666666665929218E-2;
-// NOTE: This is taken from the go stdlib. The musl implementation is much more complex.
+const pi4a = 7.85398125648498535156e-1;
-//
+const pi4b = 3.77489470793079817668E-8;
-// This may have slight differences on some edge cases and may need to replaced if so.
+const pi4c = 2.69515142907905952645E-15;
-fn cos32(x_: f32) f32 {
+const m4pi = 1.273239544735162542821171882678754627704620361328125;
-    const pi4a = 7.85398125648498535156e-1;
-    const pi4b = 3.77489470793079817668E-8;
-    const pi4c = 2.69515142907905952645E-15;
-    const m4pi = 1.273239544735162542821171882678754627704620361328125;
-    var x = x_;
-    if (math.isNan(x) or math.isInf(x)) {
-        return math.nan(f32);
-    }
-    var sign = false;
-    if (x < 0) {
-        x = -x;
-    }
-    var y = math.floor(x * m4pi);
-    var j = @floatToInt(i64, y);
-    if (j & 1 == 1) {
+fn cos_(comptime T: type, x_: T) T {
-        j += 1;
+    const I = @IntType(true, T.bit_count);
-        y += 1;
-    }
-    j &= 7;
-    if (j > 3) {
-        j -= 4;
-        sign = !sign;
-    }
-    if (j > 1) {
-        sign = !sign;
-    }
-    const z = ((x - y * pi4a) - y * pi4b) - y * pi4c;
-    const w = z * z;
-    const r = r: {
-        if (j == 1 or j == 2) {
-            break :r z + z * w * (S5 + w * (S4 + w * (S3 + w * (S2 + w * (S1 + w * S0)))));
-        } else {
-            break :r 1.0 - 0.5 * w + w * w * (C5 + w * (C4 + w * (C3 + w * (C2 + w * (C1 + w * C0)))));
-        }
-    };
-    if (sign) {
-        return -r;
-    } else {
-        return r;
-    }
-}
-fn cos64(x_: f64) f64 {
-    const pi4a = 7.85398125648498535156e-1;
-    const pi4b = 3.77489470793079817668E-8;
-    const pi4c = 2.69515142907905952645E-15;
-    const m4pi = 1.273239544735162542821171882678754627704620361328125;
     var x = x_;
     if (math.isNan(x) or math.isInf(x)) {
-        return math.nan(f64);
+        return math.nan(T);
     }
     var sign = false;
-    if (x < 0) {
+    x = math.fabs(x);
-        x = -x;
-    }
     var y = math.floor(x * m4pi);
-    var j = @floatToInt(i64, y);
+    var j = @floatToInt(I, y);
     if (j & 1 == 1) {
         j += 1;
 @@ -123,56 +74,51 @@ fn cos64(x_: f64) f64 {
     const z = ((x - y * pi4a) - y * pi4b) - y * pi4c;
     const w = z * z;
-    const r = r: {
+    const r = if (j == 1 or j == 2)
-        if (j == 1 or j == 2) {
+        z + z * w * (S5 + w * (S4 + w * (S3 + w * (S2 + w * (S1 + w * S0)))))
-            break :r z + z * w * (S5 + w * (S4 + w * (S3 + w * (S2 + w * (S1 + w * S0)))));
+    else
-        } else {
+        1.0 - 0.5 * w + w * w * (C5 + w * (C4 + w * (C3 + w * (C2 + w * (C1 + w * C0)))));
-            break :r 1.0 - 0.5 * w + w * w * (C5 + w * (C4 + w * (C3 + w * (C2 + w * (C1 + w * C0)))));
-        }
-    };
-    if (sign) {
+    return if (sign) -r else r;
-        return -r;
-    } else {
-        return r;
-    }
 }
 test "math.cos" {
-    expect(cos(f32(0.0)) == cos32(0.0));
+    expect(cos(f32(0.0)) == cos_(f32, 0.0));
-    expect(cos(f64(0.0)) == cos64(0.0));
+    expect(cos(f64(0.0)) == cos_(f64, 0.0));
 }
 test "math.cos32" {
     const epsilon = 0.000001;
-    expect(math.approxEq(f32, cos32(0.0), 1.0, epsilon));
+    expect(math.approxEq(f32, cos_(f32, 0.0), 1.0, epsilon));
-    expect(math.approxEq(f32, cos32(0.2), 0.980067, epsilon));
+    expect(math.approxEq(f32, cos_(f32, 0.2), 0.980067, epsilon));
-    expect(math.approxEq(f32, cos32(0.8923), 0.627623, epsilon));
+    expect(math.approxEq(f32, cos_(f32, 0.8923), 0.627623, epsilon));
-    expect(math.approxEq(f32, cos32(1.5), 0.070737, epsilon));
+    expect(math.approxEq(f32, cos_(f32, 1.5), 0.070737, epsilon));
-    expect(math.approxEq(f32, cos32(37.45), 0.969132, epsilon));
+    expect(math.approxEq(f32, cos_(f32, -1.5), 0.070737, epsilon));
-    expect(math.approxEq(f32, cos32(89.123), 0.400798, epsilon));
+    expect(math.approxEq(f32, cos_(f32, 37.45), 0.969132, epsilon));
+    expect(math.approxEq(f32, cos_(f32, 89.123), 0.400798, epsilon));
 }
 test "math.cos64" {
     const epsilon = 0.000001;
-    expect(math.approxEq(f64, cos64(0.0), 1.0, epsilon));
+    expect(math.approxEq(f64, cos_(f64, 0.0), 1.0, epsilon));
-    expect(math.approxEq(f64, cos64(0.2), 0.980067, epsilon));
+    expect(math.approxEq(f64, cos_(f64, 0.2), 0.980067, epsilon));
-    expect(math.approxEq(f64, cos64(0.8923), 0.627623, epsilon));
+    expect(math.approxEq(f64, cos_(f64, 0.8923), 0.627623, epsilon));
-    expect(math.approxEq(f64, cos64(1.5), 0.070737, epsilon));
+    expect(math.approxEq(f64, cos_(f64, 1.5), 0.070737, epsilon));
-    expect(math.approxEq(f64, cos64(37.45), 0.969132, epsilon));
+    expect(math.approxEq(f64, cos_(f64, -1.5), 0.070737, epsilon));
-    expect(math.approxEq(f64, cos64(89.123), 0.40080, epsilon));
+    expect(math.approxEq(f64, cos_(f64, 37.45), 0.969132, epsilon));
+    expect(math.approxEq(f64, cos_(f64, 89.123), 0.40080, epsilon));
 }
 test "math.cos32.special" {
-    expect(math.isNan(cos32(math.inf(f32))));
+    expect(math.isNan(cos_(f32, math.inf(f32))));
-    expect(math.isNan(cos32(-math.inf(f32))));
+    expect(math.isNan(cos_(f32, -math.inf(f32))));
-    expect(math.isNan(cos32(math.nan(f32))));
+    expect(math.isNan(cos_(f32, math.nan(f32))));
 }
 test "math.cos64.special" {
-    expect(math.isNan(cos64(math.inf(f64))));
+    expect(math.isNan(cos_(f64, math.inf(f64))));
-    expect(math.isNan(cos64(-math.inf(f64))));
+    expect(math.isNan(cos_(f64, -math.inf(f64))));
-    expect(math.isNan(cos64(math.nan(f64))));
+    expect(math.isNan(cos_(f64, math.nan(f64))));
 }

std/math/cosh.zig+10-4

 @@ -1,8 +1,8 @@
-// Special Cases:
+// Ported from musl, which is licensed under the MIT license:
+// https://git.musl-libc.org/cgit/musl/tree/COPYRIGHT
 //
-// - cosh(+-0)   = 1
+// https://git.musl-libc.org/cgit/musl/tree/src/math/coshf.c
-// - cosh(+-inf) = +inf
+// https://git.musl-libc.org/cgit/musl/tree/src/math/cosh.c
-// - cosh(nan)   = nan
 const builtin = @import("builtin");
 const std = @import("../std.zig");
 @@ -11,6 +11,12 @@ const expo2 = @import("expo2.zig").expo2;
 const expect = std.testing.expect;
 const maxInt = std.math.maxInt;
+/// Returns the hyperbolic cosine of x.
+///
+/// Special Cases:
+///  - cosh(+-0)   = 1
+///  - cosh(+-inf) = +inf
+///  - cosh(nan)   = nan
 pub fn cosh(x: var) @typeOf(x) {
     const T = @typeOf(x);
     return switch (T) {

std/math/exp.zig+9-3

 @@ -1,13 +1,19 @@
-// Special Cases:
+// Ported from musl, which is licensed under the MIT license:
+// https://git.musl-libc.org/cgit/musl/tree/COPYRIGHT
 //
-// - exp(+inf) = +inf
+// https://git.musl-libc.org/cgit/musl/tree/src/math/expf.c
-// - exp(nan)  = nan
+// https://git.musl-libc.org/cgit/musl/tree/src/math/exp.c
 const std = @import("../std.zig");
 const math = std.math;
 const assert = std.debug.assert;
 const builtin = @import("builtin");
+/// Returns e raised to the power of x (e^x).
+///
+/// Special Cases:
+///  - exp(+inf) = +inf
+///  - exp(nan)  = nan
 pub fn exp(x: var) @typeOf(x) {
     const T = @typeOf(x);
     return switch (T) {

std/math/exp2.zig+9-3

 @@ -1,12 +1,18 @@
-// Special Cases:
+// Ported from musl, which is licensed under the MIT license:
+// https://git.musl-libc.org/cgit/musl/tree/COPYRIGHT
 //
-// - exp2(+inf) = +inf
+// https://git.musl-libc.org/cgit/musl/tree/src/math/exp2f.c
-// - exp2(nan)  = nan
+// https://git.musl-libc.org/cgit/musl/tree/src/math/exp2.c
 const std = @import("../std.zig");
 const math = std.math;
 const expect = std.testing.expect;
+/// Returns 2 raised to the power of x (2^x).
+///
+/// Special Cases:
+///  - exp2(+inf) = +inf
+///  - exp2(nan)  = nan
 pub fn exp2(x: var) @typeOf(x) {
     const T = @typeOf(x);
     return switch (T) {

std/math/expm1.zig+13-4

...	@@ -1,14 +1,23 @@	...	@@ -1,14 +1,23 @@
1	// Special Cases:	1	// Ported from musl, which is licensed under the MIT license:
		2	// https://git.musl-libc.org/cgit/musl/tree/COPYRIGHT
2	//	3	//
3	// - expm1(+inf) = +inf	4	// https://git.musl-libc.org/cgit/musl/tree/src/math/expmf.c
4	// - expm1(-inf) = -1	5	// https://git.musl-libc.org/cgit/musl/tree/src/math/expm.c
5	// - expm1(nan) = nan	6
		7	// TODO: Updated recently.
6		8
7	const builtin = @import("builtin");	9	const builtin = @import("builtin");
8	const std = @import("../std.zig");	10	const std = @import("../std.zig");
9	const math = std.math;	11	const math = std.math;
10	const expect = std.testing.expect;	12	const expect = std.testing.expect;
11		13
		14	/// Returns e raised to the power of x, minus 1 (e^x - 1). This is more accurate than exp(e, x) - 1
		15	/// when x is near 0.
		16	///
		17	/// Special Cases:
		18	/// - expm1(+inf) = +inf
		19	/// - expm1(-inf) = -1
		20	/// - expm1(nan) = nan
12	pub fn expm1(x: var) @typeOf(x) {	21	pub fn expm1(x: var) @typeOf(x) {
13	const T = @typeOf(x);	22	const T = @typeOf(x);
14	return switch (T) {	23	return switch (T) {

std/math/expo2.zig+7

...	@@ -1,5 +1,12 @@	...	@@ -1,5 +1,12 @@
		1	// Ported from musl, which is licensed under the MIT license:
		2	// https://git.musl-libc.org/cgit/musl/tree/COPYRIGHT
		3	//
		4	// https://git.musl-libc.org/cgit/musl/tree/src/math/__expo2f.c
		5	// https://git.musl-libc.org/cgit/musl/tree/src/math/__expo2.c
		6
1	const math = @import("../math.zig");	7	const math = @import("../math.zig");
2		8
		9	/// Returns exp(x) / 2 for x >= log(maxFloat(T)).
3	pub fn expo2(x: var) @typeOf(x) {	10	pub fn expo2(x: var) @typeOf(x) {
4	const T = @typeOf(x);	11	const T = @typeOf(x);
5	return switch (T) {	12	return switch (T) {

std/math/fabs.zig+9-3

 @@ -1,13 +1,19 @@
-// Special Cases:
+// Ported from musl, which is licensed under the MIT license:
+// https://git.musl-libc.org/cgit/musl/tree/COPYRIGHT
 //
-// - fabs(+-inf) = +inf
+// https://git.musl-libc.org/cgit/musl/tree/src/math/fabsf.c
-// - fabs(nan)   = nan
+// https://git.musl-libc.org/cgit/musl/tree/src/math/fabs.c
 const std = @import("../std.zig");
 const math = std.math;
 const expect = std.testing.expect;
 const maxInt = std.math.maxInt;
+/// Returns the absolute value of x.
+///
+/// Special Cases:
+///  - fabs(+-inf) = +inf
+///  - fabs(nan)   = nan
 pub fn fabs(x: var) @typeOf(x) {
     const T = @typeOf(x);
     return switch (T) {

std/math/floor.zig+10-4

 @@ -1,14 +1,20 @@
-// Special Cases:
+// Ported from musl, which is licensed under the MIT license:
+// https://git.musl-libc.org/cgit/musl/tree/COPYRIGHT
 //
-// - floor(+-0)   = +-0
+// https://git.musl-libc.org/cgit/musl/tree/src/math/floorf.c
-// - floor(+-inf) = +-inf
+// https://git.musl-libc.org/cgit/musl/tree/src/math/floor.c
-// - floor(nan)   = nan
 const builtin = @import("builtin");
 const expect = std.testing.expect;
 const std = @import("../std.zig");
 const math = std.math;
+/// Returns the greatest integer value less than or equal to x.
+///
+/// Special Cases:
+///  - floor(+-0)   = +-0
+///  - floor(+-inf) = +-inf
+///  - floor(nan)   = nan
 pub fn floor(x: var) @typeOf(x) {
     const T = @typeOf(x);
     return switch (T) {

std/math/fma.zig+9-1

 @@ -1,7 +1,14 @@
+// Ported from musl, which is licensed under the MIT license:
+// https://git.musl-libc.org/cgit/musl/tree/COPYRIGHT
+//
+// https://git.musl-libc.org/cgit/musl/tree/src/math/fmaf.c
+// https://git.musl-libc.org/cgit/musl/tree/src/math/fma.c
 const std = @import("../std.zig");
 const math = std.math;
 const expect = std.testing.expect;
+/// Returns x * y + z with a single rounding error.
 pub fn fma(comptime T: type, x: T, y: T, z: T) T {
     return switch (T) {
         f32 => fma32(x, y, z),
 @@ -16,7 +23,7 @@ fn fma32(x: f32, y: f32, z: f32) f32 {
     const u = @bitCast(u64, xy_z);
     const e = (u >> 52) & 0x7FF;
-    if ((u & 0x1FFFFFFF) != 0x10000000 or e == 0x7FF or xy_z - xy == z) {
+    if ((u & 0x1FFFFFFF) != 0x10000000 or e == 0x7FF or (xy_z - xy == z and xy_z - z == xy)) {
         return @floatCast(f32, xy_z);
     } else {
         // TODO: Handle inexact case with double-rounding
 @@ -24,6 +31,7 @@ fn fma32(x: f32, y: f32, z: f32) f32 {
     }
 }
+// NOTE: Upstream fma.c has been rewritten completely to raise fp exceptions more accurately.
 fn fma64(x: f64, y: f64, z: f64) f64 {
     if (!math.isFinite(x) or !math.isFinite(y)) {
         return x * y + z;

std/math/frexp.zig+11-4

 @@ -1,8 +1,8 @@
-// Special Cases:
+// Ported from musl, which is licensed under the MIT license:
+// https://git.musl-libc.org/cgit/musl/tree/COPYRIGHT
 //
-// - frexp(+-0)   = +-0, 0
+// https://git.musl-libc.org/cgit/musl/tree/src/math/frexpf.c
-// - frexp(+-inf) = +-inf, 0
+// https://git.musl-libc.org/cgit/musl/tree/src/math/frexp.c
-// - frexp(nan)   = nan, undefined
 const std = @import("../std.zig");
 const math = std.math;
 @@ -17,6 +17,13 @@ fn frexp_result(comptime T: type) type {
 pub const frexp32_result = frexp_result(f32);
 pub const frexp64_result = frexp_result(f64);
+/// Breaks x into a normalized fraction and an integral power of two.
+/// f == frac * 2^exp, with |frac| in the interval [0.5, 1).
+///
+/// Special Cases:
+///  - frexp(+-0)   = +-0, 0
+///  - frexp(+-inf) = +-inf, 0
+///  - frexp(nan)   = nan, undefined
 pub fn frexp(x: var) frexp_result(@typeOf(x)) {
     const T = @typeOf(x);
     return switch (T) {

std/math/hypot.zig+11-5

 @@ -1,15 +1,21 @@
-// Special Cases:
+// Ported from musl, which is licensed under the MIT license:
+// https://git.musl-libc.org/cgit/musl/tree/COPYRIGHT
 //
-// - hypot(+-inf, y)  = +inf
+// https://git.musl-libc.org/cgit/musl/tree/src/math/hypotf.c
-// - hypot(x, +-inf)  = +inf
+// https://git.musl-libc.org/cgit/musl/tree/src/math/hypot.c
-// - hypot(nan, y)    = nan
-// - hypot(x, nan)    = nan
 const std = @import("../std.zig");
 const math = std.math;
 const expect = std.testing.expect;
 const maxInt = std.math.maxInt;
+/// Returns sqrt(x * x + y * y), avoiding unncessary overflow and underflow.
+///
+/// Special Cases:
+///  - hypot(+-inf, y)  = +inf
+///  - hypot(x, +-inf)  = +inf
+///  - hypot(nan, y)    = nan
+///  - hypot(x, nan)    = nan
 pub fn hypot(comptime T: type, x: T, y: T) T {
     return switch (T) {
         f32 => hypot32(x, y),

std/math/ilogb.zig+10-4

 @@ -1,8 +1,8 @@
-// Special Cases:
+// Ported from musl, which is licensed under the MIT license:
+// https://git.musl-libc.org/cgit/musl/tree/COPYRIGHT
 //
-// - ilogb(+-inf) = maxInt(i32)
+// https://git.musl-libc.org/cgit/musl/tree/src/math/ilogbf.c
-// - ilogb(0)     = maxInt(i32)
+// https://git.musl-libc.org/cgit/musl/tree/src/math/ilogb.c
-// - ilogb(nan)   = maxInt(i32)
 const std = @import("../std.zig");
 const math = std.math;
 @@ -10,6 +10,12 @@ const expect = std.testing.expect;
 const maxInt = std.math.maxInt;
 const minInt = std.math.minInt;
+/// Returns the binary exponent of x as an integer.
+///
+/// Special Cases:
+///  - ilogb(+-inf) = maxInt(i32)
+///  - ilogb(0)     = maxInt(i32)
+///  - ilogb(nan)   = maxInt(i32)
 pub fn ilogb(x: var) i32 {
     const T = @typeOf(x);
     return switch (T) {

std/math/inf.zig+1

...	@@ -1,6 +1,7 @@	...	@@ -1,6 +1,7 @@
1	const std = @import("../std.zig");	1	const std = @import("../std.zig");
2	const math = std.math;	2	const math = std.math;
3		3
		4	/// Returns value inf for the type T.
4	pub fn inf(comptime T: type) T {	5	pub fn inf(comptime T: type) T {
5	return switch (T) {	6	return switch (T) {
6	f16 => math.inf_f16,	7	f16 => math.inf_f16,

std/math/isfinite.zig+1

...	@@ -3,6 +3,7 @@ const math = std.math;	...	@@ -3,6 +3,7 @@ const math = std.math;
3	const expect = std.testing.expect;	3	const expect = std.testing.expect;
4	const maxInt = std.math.maxInt;	4	const maxInt = std.math.maxInt;
5		5
		6	/// Returns whether x is a finite value.
6	pub fn isFinite(x: var) bool {	7	pub fn isFinite(x: var) bool {
7	const T = @typeOf(x);	8	const T = @typeOf(x);
8	switch (T) {	9	switch (T) {

std/math/isinf.zig+3

...	@@ -3,6 +3,7 @@ const math = std.math;	...	@@ -3,6 +3,7 @@ const math = std.math;
3	const expect = std.testing.expect;	3	const expect = std.testing.expect;
4	const maxInt = std.math.maxInt;	4	const maxInt = std.math.maxInt;
5		5
		6	/// Returns whether x is an infinity, ignoring sign.
6	pub fn isInf(x: var) bool {	7	pub fn isInf(x: var) bool {
7	const T = @typeOf(x);	8	const T = @typeOf(x);
8	switch (T) {	9	switch (T) {
...	@@ -28,6 +29,7 @@ pub fn isInf(x: var) bool {	...	@@ -28,6 +29,7 @@ pub fn isInf(x: var) bool {
28	}	29	}
29	}	30	}
30		31
		32	/// Returns whether x is an infinity with a positive sign.
31	pub fn isPositiveInf(x: var) bool {	33	pub fn isPositiveInf(x: var) bool {
32	const T = @typeOf(x);	34	const T = @typeOf(x);
33	switch (T) {	35	switch (T) {
...	@@ -49,6 +51,7 @@ pub fn isPositiveInf(x: var) bool {	...	@@ -49,6 +51,7 @@ pub fn isPositiveInf(x: var) bool {
49	}	51	}
50	}	52	}
51		53
		54	/// Returns whether x is an infinity with a negative sign.
52	pub fn isNegativeInf(x: var) bool {	55	pub fn isNegativeInf(x: var) bool {
53	const T = @typeOf(x);	56	const T = @typeOf(x);
54	switch (T) {	57	switch (T) {

std/math/isnan.zig+4-2

 @@ -3,13 +3,15 @@ const math = std.math;
 const expect = std.testing.expect;
 const maxInt = std.math.maxInt;
+/// Returns whether x is a nan.
 pub fn isNan(x: var) bool {
     return x != x;
 }
-/// Note: A signalling nan is identical to a standard nan right now but may have a different bit
+/// Returns whether x is a signalling nan.
-/// representation in the future when required.
 pub fn isSignalNan(x: var) bool {
+    // Note: A signalling nan is identical to a standard nan right now but may have a different bit
+    // representation in the future when required.
     return isNan(x);
 }

std/math/isnormal.zig+1

...	@@ -3,6 +3,7 @@ const math = std.math;	...	@@ -3,6 +3,7 @@ const math = std.math;
3	const expect = std.testing.expect;	3	const expect = std.testing.expect;
4	const maxInt = std.math.maxInt;	4	const maxInt = std.math.maxInt;
5		5
		6	// Returns whether x has a normalized representation (i.e. integer part of mantissa is 1).
6	pub fn isNormal(x: var) bool {	7	pub fn isNormal(x: var) bool {
7	const T = @typeOf(x);	8	const T = @typeOf(x);
8	switch (T) {	9	switch (T) {

std/math/ln.zig+11-5

 @@ -1,9 +1,8 @@
-// Special Cases:
+// Ported from musl, which is licensed under the MIT license:
+// https://git.musl-libc.org/cgit/musl/tree/COPYRIGHT
 //
-// - ln(+inf)  = +inf
+// https://git.musl-libc.org/cgit/musl/tree/src/math/lnf.c
-// - ln(0)     = -inf
+// https://git.musl-libc.org/cgit/musl/tree/src/math/ln.c
-// - ln(x)     = nan if x < 0
-// - ln(nan)   = nan
 const std = @import("../std.zig");
 const math = std.math;
 @@ -11,6 +10,13 @@ const expect = std.testing.expect;
 const builtin = @import("builtin");
 const TypeId = builtin.TypeId;
+/// Returns the natural logarithm of x.
+///
+/// Special Cases:
+///  - ln(+inf)  = +inf
+///  - ln(0)     = -inf
+///  - ln(x)     = nan if x < 0
+///  - ln(nan)   = nan
 pub fn ln(x: var) @typeOf(x) {
     const T = @typeOf(x);
     switch (@typeId(T)) {

std/math/log.zig+7

 @@ -1,9 +1,16 @@
+// Ported from musl, which is licensed under the MIT license:
+// https://git.musl-libc.org/cgit/musl/tree/COPYRIGHT
+//
+// https://git.musl-libc.org/cgit/musl/tree/src/math/logf.c
+// https://git.musl-libc.org/cgit/musl/tree/src/math/log.c
 const std = @import("../std.zig");
 const math = std.math;
 const builtin = @import("builtin");
 const TypeId = builtin.TypeId;
 const expect = std.testing.expect;
+/// Returns the logarithm of x for the provided base.
 pub fn log(comptime T: type, base: T, x: T) T {
     if (base == 2) {
         return math.log2(x);

std/math/log10.zig+11-5

 @@ -1,9 +1,8 @@
-// Special Cases:
+// Ported from musl, which is licensed under the MIT license:
+// https://git.musl-libc.org/cgit/musl/tree/COPYRIGHT
 //
-// - log10(+inf)  = +inf
+// https://git.musl-libc.org/cgit/musl/tree/src/math/log10f.c
-// - log10(0)     = -inf
+// https://git.musl-libc.org/cgit/musl/tree/src/math/log10.c
-// - log10(x)     = nan if x < 0
-// - log10(nan)   = nan
 const std = @import("../std.zig");
 const math = std.math;
 @@ -12,6 +11,13 @@ const builtin = @import("builtin");
 const TypeId = builtin.TypeId;
 const maxInt = std.math.maxInt;
+/// Returns the base-10 logarithm of x.
+///
+/// Special Cases:
+///  - log10(+inf)  = +inf
+///  - log10(0)     = -inf
+///  - log10(x)     = nan if x < 0
+///  - log10(nan)   = nan
 pub fn log10(x: var) @typeOf(x) {
     const T = @typeOf(x);
     switch (@typeId(T)) {

std/math/log1p.zig+12-6

 @@ -1,16 +1,22 @@
-// Special Cases:
+// Ported from musl, which is licensed under the MIT license:
+// https://git.musl-libc.org/cgit/musl/tree/COPYRIGHT
 //
-// - log1p(+inf)  = +inf
+// https://git.musl-libc.org/cgit/musl/tree/src/math/log1pf.c
-// - log1p(+-0)   = +-0
+// https://git.musl-libc.org/cgit/musl/tree/src/math/log1p.c
-// - log1p(-1)    = -inf
-// - log1p(x)     = nan if x < -1
-// - log1p(nan)   = nan
 const builtin = @import("builtin");
 const std = @import("../std.zig");
 const math = std.math;
 const expect = std.testing.expect;
+/// Returns the natural logarithm of 1 + x with greater accuracy when x is near zero.
+///
+/// Special Cases:
+///  - log1p(+inf)  = +inf
+///  - log1p(+-0)   = +-0
+///  - log1p(-1)    = -inf
+///  - log1p(x)     = nan if x < -1
+///  - log1p(nan)   = nan
 pub fn log1p(x: var) @typeOf(x) {
     const T = @typeOf(x);
     return switch (T) {

std/math/log2.zig+11-5

 @@ -1,9 +1,8 @@
-// Special Cases:
+// Ported from musl, which is licensed under the MIT license:
+// https://git.musl-libc.org/cgit/musl/tree/COPYRIGHT
 //
-// - log2(+inf)  = +inf
+// https://git.musl-libc.org/cgit/musl/tree/src/math/log2f.c
-// - log2(0)     = -inf
+// https://git.musl-libc.org/cgit/musl/tree/src/math/log2.c
-// - log2(x)     = nan if x < 0
-// - log2(nan)   = nan
 const std = @import("../std.zig");
 const math = std.math;
 @@ -12,6 +11,13 @@ const builtin = @import("builtin");
 const TypeId = builtin.TypeId;
 const maxInt = std.math.maxInt;
+/// Returns the base-2 logarithm of x.
+///
+/// Special Cases:
+///  - log2(+inf)  = +inf
+///  - log2(0)     = -inf
+///  - log2(x)     = nan if x < 0
+///  - log2(nan)   = nan
 pub fn log2(x: var) @typeOf(x) {
     const T = @typeOf(x);
     switch (@typeId(T)) {

std/math/modf.zig+10-3

 @@ -1,7 +1,8 @@
-// Special Cases:
+// Ported from musl, which is licensed under the MIT license:
+// https://git.musl-libc.org/cgit/musl/tree/COPYRIGHT
 //
-// - modf(+-inf) = +-inf, nan
+// https://git.musl-libc.org/cgit/musl/tree/src/math/modff.c
-// - modf(nan)   = nan, nan
+// https://git.musl-libc.org/cgit/musl/tree/src/math/modf.c
 const std = @import("../std.zig");
 const math = std.math;
 @@ -17,6 +18,12 @@ fn modf_result(comptime T: type) type {
 pub const modf32_result = modf_result(f32);
 pub const modf64_result = modf_result(f64);
+/// Returns the integer and fractional floating-point numbers that sum to x. The sign of each
+/// result is the same as the sign of x.
+///
+/// Special Cases:
+///  - modf(+-inf) = +-inf, nan
+///  - modf(nan)   = nan, nan
 pub fn modf(x: var) modf_result(@typeOf(x)) {
     const T = @typeOf(x);
     return switch (T) {

std/math/nan.zig+4-2

...	@@ -1,5 +1,6 @@	...	@@ -1,5 +1,6 @@
1	const math = @import("../math.zig");	1	const math = @import("../math.zig");
2		2
		3	/// Returns the nan representation for type T.
3	pub fn nan(comptime T: type) T {	4	pub fn nan(comptime T: type) T {
4	return switch (T) {	5	return switch (T) {
5	f16 => math.nan_f16,	6	f16 => math.nan_f16,
...	@@ -10,9 +11,10 @@ pub fn nan(comptime T: type) T {	...	@@ -10,9 +11,10 @@ pub fn nan(comptime T: type) T {
10	};	11	};
11	}	12	}
12		13
13	// Note: A signalling nan is identical to a standard right now by may have a different bit	14	/// Returns the signalling nan representation for type T.
14	// representation in the future when required.
15	pub fn snan(comptime T: type) T {	15	pub fn snan(comptime T: type) T {
		16	// Note: A signalling nan is identical to a standard right now by may have a different bit
		17	// representation in the future when required.
16	return switch (T) {	18	return switch (T) {
17	f16 => @bitCast(f16, math.nan_u16),	19	f16 => @bitCast(f16, math.nan_u16),
18	f32 => @bitCast(f32, math.nan_u32),	20	f32 => @bitCast(f32, math.nan_u32),

std/math/pow.zig+57-39

...	@@ -1,32 +1,36 @@	...	@@ -1,32 +1,36 @@
1	// Special Cases:	1	// Ported from go, which is licensed under a BSD-3 license.
		2	// https://golang.org/LICENSE
2	//	3	//
3	// pow(x, +-0) = 1 for any x	4	// https://golang.org/src/math/pow.go
4	// pow(1, y) = 1 for any y
5	// pow(x, 1) = x for any x
6	// pow(nan, y) = nan
7	// pow(x, nan) = nan
8	// pow(+-0, y) = +-inf for y an odd integer < 0
9	// pow(+-0, -inf) = +inf
10	// pow(+-0, +inf) = +0
11	// pow(+-0, y) = +inf for finite y < 0 and not an odd integer
12	// pow(+-0, y) = +-0 for y an odd integer > 0
13	// pow(+-0, y) = +0 for finite y > 0 and not an odd integer
14	// pow(-1, +-inf) = 1
15	// pow(x, +inf) = +inf for \|x\| > 1
16	// pow(x, -inf) = +0 for \|x\| > 1
17	// pow(x, +inf) = +0 for \|x\| < 1
18	// pow(x, -inf) = +inf for \|x\| < 1
19	// pow(+inf, y) = +inf for y > 0
20	// pow(+inf, y) = +0 for y < 0
21	// pow(-inf, y) = pow(-0, -y)
22	// pow(x, y) = nan for finite x < 0 and finite non-integer y
23		5
24	const builtin = @import("builtin");	6	const builtin = @import("builtin");
25	const std = @import("../std.zig");	7	const std = @import("../std.zig");
26	const math = std.math;	8	const math = std.math;
27	const expect = std.testing.expect;	9	const expect = std.testing.expect;
28		10
29	// This implementation is taken from the go stlib, musl is a bit more complex.	11	/// Returns x raised to the power of y (x^y).
		12	///
		13	/// Special Cases:
		14	/// - pow(x, +-0) = 1 for any x
		15	/// - pow(1, y) = 1 for any y
		16	/// - pow(x, 1) = x for any x
		17	/// - pow(nan, y) = nan
		18	/// - pow(x, nan) = nan
		19	/// - pow(+-0, y) = +-inf for y an odd integer < 0
		20	/// - pow(+-0, -inf) = +inf
		21	/// - pow(+-0, +inf) = +0
		22	/// - pow(+-0, y) = +inf for finite y < 0 and not an odd integer
		23	/// - pow(+-0, y) = +-0 for y an odd integer > 0
		24	/// - pow(+-0, y) = +0 for finite y > 0 and not an odd integer
		25	/// - pow(-1, +-inf) = 1
		26	/// - pow(x, +inf) = +inf for \|x\| > 1
		27	/// - pow(x, -inf) = +0 for \|x\| > 1
		28	/// - pow(x, +inf) = +0 for \|x\| < 1
		29	/// - pow(x, -inf) = +inf for \|x\| < 1
		30	/// - pow(+inf, y) = +inf for y > 0
		31	/// - pow(+inf, y) = +0 for y < 0
		32	/// - pow(-inf, y) = pow(-0, -y)
		33	/// - pow(x, y) = nan for finite x < 0 and finite non-integer y
30	pub fn pow(comptime T: type, x: T, y: T) T {	34	pub fn pow(comptime T: type, x: T, y: T) T {
31	if (@typeInfo(T) == builtin.TypeId.Int) {	35	if (@typeInfo(T) == builtin.TypeId.Int) {
32	return math.powi(T, x, y) catch unreachable;	36	return math.powi(T, x, y) catch unreachable;
...	@@ -53,15 +57,6 @@ pub fn pow(comptime T: type, x: T, y: T) T {	...	@@ -53,15 +57,6 @@ pub fn pow(comptime T: type, x: T, y: T) T {
53	return x;	57	return x;
54	}	58	}
55		59
56	// special case sqrt
57	if (y == 0.5) {
58	return math.sqrt(x);
59	}
60
61	if (y == -0.5) {
62	return 1 / math.sqrt(x);
63	}
64
65	if (x == 0) {	60	if (x == 0) {
66	if (y < 0) {	61	if (y < 0) {
67	// pow(+-0, y) = +- 0 for y an odd integer	62	// pow(+-0, y) = +- 0 for y an odd integer
...	@@ -112,14 +107,16 @@ pub fn pow(comptime T: type, x: T, y: T) T {	...	@@ -112,14 +107,16 @@ pub fn pow(comptime T: type, x: T, y: T) T {
112	}	107	}
113	}	108	}
114		109
115	var ay = y;	110	// special case sqrt
116	var flip = false;	111	if (y == 0.5) {
117	if (ay < 0) {	112	return math.sqrt(x);
118	ay = -ay;	113	}
119	flip = true;	114
		115	if (y == -0.5) {
		116	return 1 / math.sqrt(x);
120	}	117	}
121		118
122	const r1 = math.modf(ay);	119	const r1 = math.modf(math.fabs(y));
123	var yi = r1.ipart;	120	var yi = r1.ipart;
124	var yf = r1.fpart;	121	var yf = r1.fpart;
125		122
...	@@ -148,8 +145,18 @@ pub fn pow(comptime T: type, x: T, y: T) T {	...	@@ -148,8 +145,18 @@ pub fn pow(comptime T: type, x: T, y: T) T {
148	var xe = r2.exponent;	145	var xe = r2.exponent;
149	var x1 = r2.significand;	146	var x1 = r2.significand;
150		147
151	var i = @floatToInt(i32, yi);	148	var i = @floatToInt(@IntType(true, T.bit_count), yi);
152	while (i != 0) : (i >>= 1) {	149	while (i != 0) : (i >>= 1) {
		150	const overflow_shift = math.floatExponentBits(T) + 1;
		151	if (xe < -(1 << overflow_shift) or (1 << overflow_shift) < xe) {
		152	// catch xe before it overflows the left shift below
		153	// Since i != 0 it has at least one bit still set, so ae will accumulate xe
		154	// on at least one more iteration, ae += xe is a lower bound on ae
		155	// the lower bound on ae exceeds the size of a float exp
		156	// so the final call to Ldexp will produce under/overflow (0/Inf)
		157	ae += xe;
		158	break;
		159	}
153	if (i & 1 == 1) {	160	if (i & 1 == 1) {
154	a1 *= x1;	161	a1 *= x1;
155	ae += xe;	162	ae += xe;
...	@@ -163,7 +170,7 @@ pub fn pow(comptime T: type, x: T, y: T) T {	...	@@ -163,7 +170,7 @@ pub fn pow(comptime T: type, x: T, y: T) T {
163	}	170	}
164		171
165	// a = a1 2^ae	172	// a = a1 2^ae
166	if (flip) {	173	if (y < 0) {
167	a1 = 1 / a1;	174	a1 = 1 / a1;
168	ae = -ae;	175	ae = -ae;
169	}	176	}
...	@@ -202,6 +209,9 @@ test "math.pow.special" {	...	@@ -202,6 +209,9 @@ test "math.pow.special" {
202	expect(pow(f32, 45, 1.0) == 45);	209	expect(pow(f32, 45, 1.0) == 45);
203	expect(pow(f32, -45, 1.0) == -45);	210	expect(pow(f32, -45, 1.0) == -45);
204	expect(math.isNan(pow(f32, math.nan(f32), 5.0)));	211	expect(math.isNan(pow(f32, math.nan(f32), 5.0)));
		212	expect(math.isPositiveInf(pow(f32, -math.inf(f32), 0.5)));
		213	expect(math.isPositiveInf(pow(f32, -0, -0.5)));
		214	expect(pow(f32, -0, 0.5) == 0);
205	expect(math.isNan(pow(f32, 5.0, math.nan(f32))));	215	expect(math.isNan(pow(f32, 5.0, math.nan(f32))));
206	expect(math.isPositiveInf(pow(f32, 0.0, -1.0)));	216	expect(math.isPositiveInf(pow(f32, 0.0, -1.0)));
207	//expect(math.isNegativeInf(pow(f32, -0.0, -3.0))); TODO is this required?	217	//expect(math.isNegativeInf(pow(f32, -0.0, -3.0))); TODO is this required?
...	@@ -232,3 +242,11 @@ test "math.pow.special" {	...	@@ -232,3 +242,11 @@ test "math.pow.special" {
232	expect(math.isNan(pow(f32, -1.0, 1.2)));	242	expect(math.isNan(pow(f32, -1.0, 1.2)));
233	expect(math.isNan(pow(f32, -12.4, 78.5)));	243	expect(math.isNan(pow(f32, -12.4, 78.5)));
234	}	244	}
		245
		246	test "math.pow.overflow" {
		247	expect(math.isPositiveInf(pow(f64, 2, 1 << 32)));
		248	expect(pow(f64, 2, -(1 << 32)) == 0);
		249	expect(math.isNegativeInf(pow(f64, -2, (1 << 32) + 1)));
		250	expect(pow(f64, 0.5, 1 << 45) == 0);
		251	expect(math.isPositiveInf(pow(f64, 0.5, -(1 << 45))));
		252	}

std/math/powi.zig+13-9

 @@ -1,12 +1,7 @@
-// Special Cases:
+// Based on Rust, which is licensed under the MIT license.
+// https://github.com/rust-lang/rust/blob/360432f1e8794de58cd94f34c9c17ad65871e5b5/LICENSE-MIT
 //
-//  powi(x, +-0)   = 1 for any x
+// https://github.com/rust-lang/rust/blob/360432f1e8794de58cd94f34c9c17ad65871e5b5/src/libcore/num/mod.rs#L3423
-//  powi(0, y)     = 0 for any y
-//  powi(1, y)     = 1 for any y
-//  powi(-1, y)    = -1 for for y an odd integer
-//  powi(-1, y)    = 1 for for y an even integer
-//  powi(x, y)     = Overflow for for y >= @sizeOf(x) - 1 y > 0
-//  powi(x, y)     = Underflow for for y > @sizeOf(x) - 1 y < 0
 const builtin = @import("builtin");
 const std = @import("../std.zig");
 @@ -14,7 +9,16 @@ const math = std.math;
 const assert = std.debug.assert;
 const testing = std.testing;
-// This implementation is based on that from the rust stlib
+/// Returns the power of x raised by the integer y (x^y).
+///
+/// Special Cases:
+///  - powi(x, +-0)   = 1 for any x
+///  - powi(0, y)     = 0 for any y
+///  - powi(1, y)     = 1 for any y
+///  - powi(-1, y)    = -1 for y an odd integer
+///  - powi(-1, y)    = 1 for y an even integer
+///  - powi(x, y)     = Overflow for y >= @sizeOf(x) - 1 or y > 0
+///  - powi(x, y)     = Underflow for y > @sizeOf(x) - 1 or y < 0
 pub fn powi(comptime T: type, x: T, y: T) (error{
     Overflow,
     Underflow,

std/math/round.zig+10-4

 @@ -1,14 +1,20 @@
-// Special Cases:
+// Ported from musl, which is licensed under the MIT license:
+// https://git.musl-libc.org/cgit/musl/tree/COPYRIGHT
 //
-// - round(+-0)   = +-0
+// https://git.musl-libc.org/cgit/musl/tree/src/math/roundf.c
-// - round(+-inf) = +-inf
+// https://git.musl-libc.org/cgit/musl/tree/src/math/round.c
-// - round(nan)   = nan
 const builtin = @import("builtin");
 const expect = std.testing.expect;
 const std = @import("../std.zig");
 const math = std.math;
+/// Returns x rounded to the nearest integer, rounding half away from zero.
+///
+/// Special Cases:
+///  - round(+-0)   = +-0
+///  - round(+-inf) = +-inf
+///  - round(nan)   = nan
 pub fn round(x: var) @typeOf(x) {
     const T = @typeOf(x);
     return switch (T) {

std/math/scalbn.zig+7

...	@@ -1,7 +1,14 @@	...	@@ -1,7 +1,14 @@
		1	// Ported from musl, which is licensed under the MIT license:
		2	// https://git.musl-libc.org/cgit/musl/tree/COPYRIGHT
		3	//
		4	// https://git.musl-libc.org/cgit/musl/tree/src/math/scalbnf.c
		5	// https://git.musl-libc.org/cgit/musl/tree/src/math/scalbn.c
		6
1	const std = @import("../std.zig");	7	const std = @import("../std.zig");
2	const math = std.math;	8	const math = std.math;
3	const expect = std.testing.expect;	9	const expect = std.testing.expect;
4		10
		11	/// Returns x * 2^n.
5	pub fn scalbn(x: var, n: i32) @typeOf(x) {	12	pub fn scalbn(x: var, n: i32) @typeOf(x) {
6	const T = @typeOf(x);	13	const T = @typeOf(x);
7	return switch (T) {	14	return switch (T) {

std/math/signbit.zig+1

...	@@ -2,6 +2,7 @@ const std = @import("../std.zig");	...	@@ -2,6 +2,7 @@ const std = @import("../std.zig");
2	const math = std.math;	2	const math = std.math;
3	const expect = std.testing.expect;	3	const expect = std.testing.expect;
4		4
		5	/// Returns whether x is negative or negative 0.
5	pub fn signbit(x: var) bool {	6	pub fn signbit(x: var) bool {
6	const T = @typeOf(x);	7	const T = @typeOf(x);
7	return switch (T) {	8	return switch (T) {

std/math/sin.zig+52-108

 @@ -1,19 +1,24 @@
-// Special Cases:
+// Ported from go, which is licensed under a BSD-3 license.
+// https://golang.org/LICENSE
 //
-// - sin(+-0)   = +-0
+// https://golang.org/src/math/sin.go
-// - sin(+-inf) = nan
-// - sin(nan)   = nan
 const builtin = @import("builtin");
 const std = @import("../std.zig");
 const math = std.math;
 const expect = std.testing.expect;
+/// Returns the sine of the radian value x.
+///
+/// Special Cases:
+///  - sin(+-0)   = +-0
+///  - sin(+-inf) = nan
+///  - sin(nan)   = nan
 pub fn sin(x: var) @typeOf(x) {
     const T = @typeOf(x);
     return switch (T) {
-        f32 => sin32(x),
+        f32 => sin_(T, x),
-        f64 => sin64(x),
+        f64 => sin_(T, x),
         else => @compileError("sin not implemented for " ++ @typeName(T)),
     };
 }
 @@ -34,83 +39,27 @@ const C3 = 2.48015872888517045348E-5;
 const C4 = -1.38888888888730564116E-3;
 const C5 = 4.16666666666665929218E-2;
-// NOTE: This is taken from the go stdlib. The musl implementation is much more complex.
+const pi4a = 7.85398125648498535156e-1;
-//
+const pi4b = 3.77489470793079817668E-8;
-// This may have slight differences on some edge cases and may need to replaced if so.
+const pi4c = 2.69515142907905952645E-15;
-fn sin32(x_: f32) f32 {
+const m4pi = 1.273239544735162542821171882678754627704620361328125;
-    const pi4a = 7.85398125648498535156e-1;
-    const pi4b = 3.77489470793079817668E-8;
-    const pi4c = 2.69515142907905952645E-15;
-    const m4pi = 1.273239544735162542821171882678754627704620361328125;
-    var x = x_;
-    if (x == 0 or math.isNan(x)) {
-        return x;
-    }
-    if (math.isInf(x)) {
-        return math.nan(f32);
-    }
-    var sign = false;
-    if (x < 0) {
-        x = -x;
-        sign = true;
-    }
-    var y = math.floor(x * m4pi);
-    var j = @floatToInt(i64, y);
-    if (j & 1 == 1) {
-        j += 1;
-        y += 1;
-    }
-    j &= 7;
+fn sin_(comptime T: type, x_: T) T {
-    if (j > 3) {
+    const I = @IntType(true, T.bit_count);
-        j -= 4;
-        sign = !sign;
-    }
-    const z = ((x - y * pi4a) - y * pi4b) - y * pi4c;
-    const w = z * z;
-    const r = r: {
-        if (j == 1 or j == 2) {
-            break :r 1.0 - 0.5 * w + w * w * (C5 + w * (C4 + w * (C3 + w * (C2 + w * (C1 + w * C0)))));
-        } else {
-            break :r z + z * w * (S5 + w * (S4 + w * (S3 + w * (S2 + w * (S1 + w * S0)))));
-        }
-    };
-    if (sign) {
-        return -r;
-    } else {
-        return r;
-    }
-}
-fn sin64(x_: f64) f64 {
-    const pi4a = 7.85398125648498535156e-1;
-    const pi4b = 3.77489470793079817668E-8;
-    const pi4c = 2.69515142907905952645E-15;
-    const m4pi = 1.273239544735162542821171882678754627704620361328125;
     var x = x_;
     if (x == 0 or math.isNan(x)) {
         return x;
     }
     if (math.isInf(x)) {
-        return math.nan(f64);
+        return math.nan(T);
     }
-    var sign = false;
+    var sign = x < 0;
-    if (x < 0) {
+    x = math.fabs(x);
-        x = -x;
-        sign = true;
-    }
     var y = math.floor(x * m4pi);
-    var j = @floatToInt(i64, y);
+    var j = @floatToInt(I, y);
     if (j & 1 == 1) {
         j += 1;
 @@ -126,61 +75,56 @@ fn sin64(x_: f64) f64 {
     const z = ((x - y * pi4a) - y * pi4b) - y * pi4c;
     const w = z * z;
-    const r = r: {
+    const r = if (j == 1 or j == 2)
-        if (j == 1 or j == 2) {
+        1.0 - 0.5 * w + w * w * (C5 + w * (C4 + w * (C3 + w * (C2 + w * (C1 + w * C0)))))
-            break :r 1.0 - 0.5 * w + w * w * (C5 + w * (C4 + w * (C3 + w * (C2 + w * (C1 + w * C0)))));
+    else
-        } else {
+        z + z * w * (S5 + w * (S4 + w * (S3 + w * (S2 + w * (S1 + w * S0)))));
-            break :r z + z * w * (S5 + w * (S4 + w * (S3 + w * (S2 + w * (S1 + w * S0)))));
-        }
-    };
-    if (sign) {
+    return if (sign) -r else r;
-        return -r;
-    } else {
-        return r;
-    }
 }
 test "math.sin" {
-    expect(sin(f32(0.0)) == sin32(0.0));
+    expect(sin(f32(0.0)) == sin_(f32, 0.0));
-    expect(sin(f64(0.0)) == sin64(0.0));
+    expect(sin(f64(0.0)) == sin_(f64, 0.0));
     expect(comptime (math.sin(f64(2))) == math.sin(f64(2)));
 }
 test "math.sin32" {
     const epsilon = 0.000001;
-    expect(math.approxEq(f32, sin32(0.0), 0.0, epsilon));
+    expect(math.approxEq(f32, sin_(f32, 0.0), 0.0, epsilon));
-    expect(math.approxEq(f32, sin32(0.2), 0.198669, epsilon));
+    expect(math.approxEq(f32, sin_(f32, 0.2), 0.198669, epsilon));
-    expect(math.approxEq(f32, sin32(0.8923), 0.778517, epsilon));
+    expect(math.approxEq(f32, sin_(f32, 0.8923), 0.778517, epsilon));
-    expect(math.approxEq(f32, sin32(1.5), 0.997495, epsilon));
+    expect(math.approxEq(f32, sin_(f32, 1.5), 0.997495, epsilon));
-    expect(math.approxEq(f32, sin32(37.45), -0.246544, epsilon));
+    expect(math.approxEq(f32, sin_(f32, -1.5), -0.997495, epsilon));
-    expect(math.approxEq(f32, sin32(89.123), 0.916166, epsilon));
+    expect(math.approxEq(f32, sin_(f32, 37.45), -0.246544, epsilon));
+    expect(math.approxEq(f32, sin_(f32, 89.123), 0.916166, epsilon));
 }
 test "math.sin64" {
     const epsilon = 0.000001;
-    expect(math.approxEq(f64, sin64(0.0), 0.0, epsilon));
+    expect(math.approxEq(f64, sin_(f64, 0.0), 0.0, epsilon));
-    expect(math.approxEq(f64, sin64(0.2), 0.198669, epsilon));
+    expect(math.approxEq(f64, sin_(f64, 0.2), 0.198669, epsilon));
-    expect(math.approxEq(f64, sin64(0.8923), 0.778517, epsilon));
+    expect(math.approxEq(f64, sin_(f64, 0.8923), 0.778517, epsilon));
-    expect(math.approxEq(f64, sin64(1.5), 0.997495, epsilon));
+    expect(math.approxEq(f64, sin_(f64, 1.5), 0.997495, epsilon));
-    expect(math.approxEq(f64, sin64(37.45), -0.246543, epsilon));
+    expect(math.approxEq(f64, sin_(f64, -1.5), -0.997495, epsilon));
-    expect(math.approxEq(f64, sin64(89.123), 0.916166, epsilon));
+    expect(math.approxEq(f64, sin_(f64, 37.45), -0.246543, epsilon));
+    expect(math.approxEq(f64, sin_(f64, 89.123), 0.916166, epsilon));
 }
 test "math.sin32.special" {
-    expect(sin32(0.0) == 0.0);
+    expect(sin_(f32, 0.0) == 0.0);
-    expect(sin32(-0.0) == -0.0);
+    expect(sin_(f32, -0.0) == -0.0);
-    expect(math.isNan(sin32(math.inf(f32))));
+    expect(math.isNan(sin_(f32, math.inf(f32))));
-    expect(math.isNan(sin32(-math.inf(f32))));
+    expect(math.isNan(sin_(f32, -math.inf(f32))));
-    expect(math.isNan(sin32(math.nan(f32))));
+    expect(math.isNan(sin_(f32, math.nan(f32))));
 }
 test "math.sin64.special" {
-    expect(sin64(0.0) == 0.0);
+    expect(sin_(f64, 0.0) == 0.0);
-    expect(sin64(-0.0) == -0.0);
+    expect(sin_(f64, -0.0) == -0.0);
-    expect(math.isNan(sin64(math.inf(f64))));
+    expect(math.isNan(sin_(f64, math.inf(f64))));
-    expect(math.isNan(sin64(-math.inf(f64))));
+    expect(math.isNan(sin_(f64, -math.inf(f64))));
-    expect(math.isNan(sin64(math.nan(f64))));
+    expect(math.isNan(sin_(f64, math.nan(f64))));
 }

std/math/sinh.zig+10-4

 @@ -1,8 +1,8 @@
-// Special Cases:
+// Ported from musl, which is licensed under the MIT license:
+// https://git.musl-libc.org/cgit/musl/tree/COPYRIGHT
 //
-// - sinh(+-0)   = +-0
+// https://git.musl-libc.org/cgit/musl/tree/src/math/sinhf.c
-// - sinh(+-inf) = +-inf
+// https://git.musl-libc.org/cgit/musl/tree/src/math/sinh.c
-// - sinh(nan)   = nan
 const builtin = @import("builtin");
 const std = @import("../std.zig");
 @@ -11,6 +11,12 @@ const expect = std.testing.expect;
 const expo2 = @import("expo2.zig").expo2;
 const maxInt = std.math.maxInt;
+/// Returns the hyperbolic sine of x.
+///
+/// Special Cases:
+///  - sinh(+-0)   = +-0
+///  - sinh(+-inf) = +-inf
+///  - sinh(nan)   = nan
 pub fn sinh(x: var) @typeOf(x) {
     const T = @typeOf(x);
     return switch (T) {

std/math/sqrt.zig+7-7

 @@ -1,10 +1,3 @@
-// Special Cases:
-//
-// - sqrt(+inf)  = +inf
-// - sqrt(+-0)   = +-0
-// - sqrt(x)     = nan if x < 0
-// - sqrt(nan)   = nan
 const std = @import("../std.zig");
 const math = std.math;
 const expect = std.testing.expect;
 @@ -12,6 +5,13 @@ const builtin = @import("builtin");
 const TypeId = builtin.TypeId;
 const maxInt = std.math.maxInt;
+/// Returns the square root of x.
+///
+/// Special Cases:
+///  - sqrt(+inf)  = +inf
+///  - sqrt(+-0)   = +-0
+///  - sqrt(x)     = nan if x < 0
+///  - sqrt(nan)   = nan
 pub fn sqrt(x: var) (if (@typeId(@typeOf(x)) == TypeId.Int) @IntType(false, @typeOf(x).bit_count / 2) else @typeOf(x)) {
     const T = @typeOf(x);
     switch (@typeId(T)) {

std/math/tan.zig+50-104

 @@ -1,19 +1,24 @@
-// Special Cases:
+// Ported from go, which is licensed under a BSD-3 license.
+// https://golang.org/LICENSE
 //
-// - tan(+-0)   = +-0
+// https://golang.org/src/math/tan.go
-// - tan(+-inf) = nan
-// - tan(nan)   = nan
 const builtin = @import("builtin");
 const std = @import("../std.zig");
 const math = std.math;
 const expect = std.testing.expect;
+/// Returns the tangent of the radian value x.
+///
+/// Special Cases:
+///  - tan(+-0)   = +-0
+///  - tan(+-inf) = nan
+///  - tan(nan)   = nan
 pub fn tan(x: var) @typeOf(x) {
     const T = @typeOf(x);
     return switch (T) {
-        f32 => tan32(x),
+        f32 => tan_(f32, x),
-        f64 => tan64(x),
+        f64 => tan_(f64, x),
         else => @compileError("tan not implemented for " ++ @typeName(T)),
     };
 }
 @@ -27,80 +32,27 @@ const Tq2 = -1.32089234440210967447E6;
 const Tq3 = 2.50083801823357915839E7;
 const Tq4 = -5.38695755929454629881E7;
-// NOTE: This is taken from the go stdlib. The musl implementation is much more complex.
+const pi4a = 7.85398125648498535156e-1;
-//
+const pi4b = 3.77489470793079817668E-8;
-// This may have slight differences on some edge cases and may need to replaced if so.
+const pi4c = 2.69515142907905952645E-15;
-fn tan32(x_: f32) f32 {
+const m4pi = 1.273239544735162542821171882678754627704620361328125;
-    const pi4a = 7.85398125648498535156e-1;
-    const pi4b = 3.77489470793079817668E-8;
-    const pi4c = 2.69515142907905952645E-15;
-    const m4pi = 1.273239544735162542821171882678754627704620361328125;
-    var x = x_;
-    if (x == 0 or math.isNan(x)) {
-        return x;
-    }
-    if (math.isInf(x)) {
-        return math.nan(f32);
-    }
-    var sign = false;
-    if (x < 0) {
-        x = -x;
-        sign = true;
-    }
-    var y = math.floor(x * m4pi);
-    var j = @floatToInt(i64, y);
-    if (j & 1 == 1) {
-        j += 1;
-        y += 1;
-    }
-    const z = ((x - y * pi4a) - y * pi4b) - y * pi4c;
-    const w = z * z;
-    var r = r: {
-        if (w > 1e-14) {
-            break :r z + z * (w * ((Tp0 * w + Tp1) * w + Tp2) / ((((w + Tq1) * w + Tq2) * w + Tq3) * w + Tq4));
-        } else {
-            break :r z;
-        }
-    };
-    if (j & 2 == 2) {
-        r = -1 / r;
-    }
-    if (sign) {
-        r = -r;
-    }
-    return r;
-}
-fn tan64(x_: f64) f64 {
+fn tan_(comptime T: type, x_: T) T {
-    const pi4a = 7.85398125648498535156e-1;
+    const I = @IntType(true, T.bit_count);
-    const pi4b = 3.77489470793079817668E-8;
-    const pi4c = 2.69515142907905952645E-15;
-    const m4pi = 1.273239544735162542821171882678754627704620361328125;
     var x = x_;
     if (x == 0 or math.isNan(x)) {
         return x;
     }
     if (math.isInf(x)) {
-        return math.nan(f64);
+        return math.nan(T);
     }
-    var sign = false;
+    var sign = x < 0;
-    if (x < 0) {
+    x = math.fabs(x);
-        x = -x;
-        sign = true;
-    }
     var y = math.floor(x * m4pi);
-    var j = @floatToInt(i64, y);
+    var j = @floatToInt(I, y);
     if (j & 1 == 1) {
         j += 1;
 @@ -110,63 +62,57 @@ fn tan64(x_: f64) f64 {
     const z = ((x - y * pi4a) - y * pi4b) - y * pi4c;
     const w = z * z;
-    var r = r: {
+    var r = if (w > 1e-14)
-        if (w > 1e-14) {
+        z + z * (w * ((Tp0 * w + Tp1) * w + Tp2) / ((((w + Tq1) * w + Tq2) * w + Tq3) * w + Tq4))
-            break :r z + z * (w * ((Tp0 * w + Tp1) * w + Tp2) / ((((w + Tq1) * w + Tq2) * w + Tq3) * w + Tq4));
+    else
-        } else {
+        z;
-            break :r z;
-        }
-    };
     if (j & 2 == 2) {
         r = -1 / r;
     }
-    if (sign) {
-        r = -r;
-    }
-    return r;
+    return if (sign) -r else r;
 }
 test "math.tan" {
-    expect(tan(f32(0.0)) == tan32(0.0));
+    expect(tan(f32(0.0)) == tan_(f32, 0.0));
-    expect(tan(f64(0.0)) == tan64(0.0));
+    expect(tan(f64(0.0)) == tan_(f64, 0.0));
 }
 test "math.tan32" {
     const epsilon = 0.000001;
-    expect(math.approxEq(f32, tan32(0.0), 0.0, epsilon));
+    expect(math.approxEq(f32, tan_(f32, 0.0), 0.0, epsilon));
-    expect(math.approxEq(f32, tan32(0.2), 0.202710, epsilon));
+    expect(math.approxEq(f32, tan_(f32, 0.2), 0.202710, epsilon));
-    expect(math.approxEq(f32, tan32(0.8923), 1.240422, epsilon));
+    expect(math.approxEq(f32, tan_(f32, 0.8923), 1.240422, epsilon));
-    expect(math.approxEq(f32, tan32(1.5), 14.101420, epsilon));
+    expect(math.approxEq(f32, tan_(f32, 1.5), 14.101420, epsilon));
-    expect(math.approxEq(f32, tan32(37.45), -0.254397, epsilon));
+    expect(math.approxEq(f32, tan_(f32, 37.45), -0.254397, epsilon));
-    expect(math.approxEq(f32, tan32(89.123), 2.285852, epsilon));
+    expect(math.approxEq(f32, tan_(f32, 89.123), 2.285852, epsilon));
 }
 test "math.tan64" {
     const epsilon = 0.000001;
-    expect(math.approxEq(f64, tan64(0.0), 0.0, epsilon));
+    expect(math.approxEq(f64, tan_(f64, 0.0), 0.0, epsilon));
-    expect(math.approxEq(f64, tan64(0.2), 0.202710, epsilon));
+    expect(math.approxEq(f64, tan_(f64, 0.2), 0.202710, epsilon));
-    expect(math.approxEq(f64, tan64(0.8923), 1.240422, epsilon));
+    expect(math.approxEq(f64, tan_(f64, 0.8923), 1.240422, epsilon));
-    expect(math.approxEq(f64, tan64(1.5), 14.101420, epsilon));
+    expect(math.approxEq(f64, tan_(f64, 1.5), 14.101420, epsilon));
-    expect(math.approxEq(f64, tan64(37.45), -0.254397, epsilon));
+    expect(math.approxEq(f64, tan_(f64, 37.45), -0.254397, epsilon));
-    expect(math.approxEq(f64, tan64(89.123), 2.2858376, epsilon));
+    expect(math.approxEq(f64, tan_(f64, 89.123), 2.2858376, epsilon));
 }
 test "math.tan32.special" {
-    expect(tan32(0.0) == 0.0);
+    expect(tan_(f32, 0.0) == 0.0);
-    expect(tan32(-0.0) == -0.0);
+    expect(tan_(f32, -0.0) == -0.0);
-    expect(math.isNan(tan32(math.inf(f32))));
+    expect(math.isNan(tan_(f32, math.inf(f32))));
-    expect(math.isNan(tan32(-math.inf(f32))));
+    expect(math.isNan(tan_(f32, -math.inf(f32))));
-    expect(math.isNan(tan32(math.nan(f32))));
+    expect(math.isNan(tan_(f32, math.nan(f32))));
 }
 test "math.tan64.special" {
-    expect(tan64(0.0) == 0.0);
+    expect(tan_(f64, 0.0) == 0.0);
-    expect(tan64(-0.0) == -0.0);
+    expect(tan_(f64, -0.0) == -0.0);
-    expect(math.isNan(tan64(math.inf(f64))));
+    expect(math.isNan(tan_(f64, math.inf(f64))));
-    expect(math.isNan(tan64(-math.inf(f64))));
+    expect(math.isNan(tan_(f64, -math.inf(f64))));
-    expect(math.isNan(tan64(math.nan(f64))));
+    expect(math.isNan(tan_(f64, math.nan(f64))));
 }

std/math/tanh.zig+10-4

 @@ -1,8 +1,8 @@
-// Special Cases:
+// Ported from musl, which is licensed under the MIT license:
+// https://git.musl-libc.org/cgit/musl/tree/COPYRIGHT
 //
-// - sinh(+-0)   = +-0
+// https://git.musl-libc.org/cgit/musl/tree/src/math/tanhf.c
-// - sinh(+-inf) = +-1
+// https://git.musl-libc.org/cgit/musl/tree/src/math/tanh.c
-// - sinh(nan)   = nan
 const builtin = @import("builtin");
 const std = @import("../std.zig");
 @@ -11,6 +11,12 @@ const expect = std.testing.expect;
 const expo2 = @import("expo2.zig").expo2;
 const maxInt = std.math.maxInt;
+/// Returns the hyperbolic tangent of x.
+///
+/// Special Cases:
+///  - sinh(+-0)   = +-0
+///  - sinh(+-inf) = +-1
+///  - sinh(nan)   = nan
 pub fn tanh(x: var) @typeOf(x) {
     const T = @typeOf(x);
     return switch (T) {

std/math/trunc.zig+10-4

 @@ -1,14 +1,20 @@
-// Special Cases:
+// Ported from musl, which is licensed under the MIT license:
+// https://git.musl-libc.org/cgit/musl/tree/COPYRIGHT
 //
-// - trunc(+-0)   = +-0
+// https://git.musl-libc.org/cgit/musl/tree/src/math/truncf.c
-// - trunc(+-inf) = +-inf
+// https://git.musl-libc.org/cgit/musl/tree/src/math/trunc.c
-// - trunc(nan)   = nan
 const std = @import("../std.zig");
 const math = std.math;
 const expect = std.testing.expect;
 const maxInt = std.math.maxInt;
+/// Returns the integer value of x.
+///
+/// Special Cases:
+///  - trunc(+-0)   = +-0
+///  - trunc(+-inf) = +-inf
+///  - trunc(nan)   = nan
 pub fn trunc(x: var) @typeOf(x) {
     const T = @typeOf(x);
     return switch (T) {

author	Marc Tiehuis <marc@tiehu.is> 2019-05-02 19:05:26+12:00
committer	GitHub <noreply@github.com> 2019-05-02 19:05:26+12:00
log	f950ec0c16de6dba8a541b1a6453ebe431430782
tree	47df2ed19eece69d35a60eeff8c26511cfe996e3
parent	c00c18de6a5e436b1c362c06d6e5259c8f731a90
parent	3370e60dd96828db6f9d1da36e71064303e97de6
signature	Signed by PGP key 4AEE18F83AFDEB23

Merge pull request #2397 from ziglang/std.math