Organize and improve testing: math.zig

[matu3ba]

Background: Tests are separated in test/behavior/math.zig, lib/std/math.zig and (to mention for completeness) now for implementing stage2 also test/behaviror/int_div.zig.
This is not documented and it would be nice to be consistent with "tests to show usage" with "extensive tests for edge cases" per file.

Thus there are 3 solutions, if math.zig should remain like it is:

1. Move all "extensive tests for edge cases" to test/behavior/math.zig and document it somewhere
2. Move all "extensive tests for edge cases" to lib/std/math/ and document it somewhere
3. Allow accurate control which test to run inside a file and have a convention how to prefix/name tests (requires additional implementation)

Aside of that, the following (reoccuring) possibly incomplete list of problems exist regarding test coverage:
general edge cases for division:

• 0/1,-0/1, 1/1,-1/-1
• max/max,min/min,max/min,min/max
• 0/0, anynumber/0

div:

• 15,14,13,12 / 3

divExact, edge cases not tested:

• 55/-11

divFloor

• divFloor(i32, -0x80000000, 1) == -0x80000000); -0x is unnecessary complex and unfortunately the default output of std.fmt
• 2/-12, 0/12,0/-12,-0/12,-0/12 ?

similar problems exist for rem and mod

[matu3ba]

complete list of functions in math.zig to review/fix after clarification, where tests should go:

• pub fn approxEqAbs(comptime T: type, x: T, y: T, tolerance: T) bool {
• pub fn approxEqRel(comptime T: type, x: T, y: T, tolerance: T) bool {
• pub fn approxEq(comptime T: type, x: T, y: T, tolerance: T) bool {
• pub fn doNotOptimizeAway(value: anytype) void {
• pub fn raiseInvalid() void {
• pub fn raiseUnderflow() void {
• pub fn raiseOverflow() void {
• pub fn raiseInexact() void {
• pub fn raiseDivByZero() void {
• pub fn floatMantissaBits(comptime T: type) comptime_int {
• pub fn floatExponentBits(comptime T: type) comptime_int {
• pub fn Min(comptime A: type, comptime B: type) type {
• pub fn min(x: anytype, y: anytype) Min(@typeof(x), @typeof(y)) {
• pub fn min3(x: anytype, y: anytype, z: anytype) @typeof(x, y, z) {
• pub fn max(x: anytype, y: anytype) @typeof(x, y) {
• pub fn max3(x: anytype, y: anytype, z: anytype) @typeof(x, y, z) {
• pub fn clamp(val: anytype, lower: anytype, upper: anytype) @typeof(val, lower, upper) {
• pub fn mul(comptime T: type, a: T, b: T) (error{Overflow}!T) {
• pub fn add(comptime T: type, a: T, b: T) (error{Overflow}!T) {
• pub fn sub(comptime T: type, a: T, b: T) (error{Overflow}!T) {
• pub fn negate(x: anytype) !@typeof(x) {
• pub fn shlExact(comptime T: type, a: T, shift_amt: Log2Int(T)) !T {
• pub fn shl(comptime T: type, a: T, shift_amt: anytype) T {
• pub fn shr(comptime T: type, a: T, shift_amt: anytype) T {
• pub fn rotr(comptime T: type, x: T, r: anytype) T {
• pub fn rotl(comptime T: type, x: T, r: anytype) T {
• pub fn Log2Int(comptime T: type) type {
• pub fn Log2IntCeil(comptime T: type) type {
• pub fn IntFittingRange(comptime from: comptime_int, comptime to: comptime_int) type {
• pub fn absInt(x: anytype) !@typeof(x) {
• pub fn divTrunc(comptime T: type, numerator: T, denominator: T) !T {
• pub fn divFloor(comptime T: type, numerator: T, denominator: T) !T {
• pub fn divCeil(comptime T: type, numerator: T, denominator: T) !T {
• pub fn divExact(comptime T: type, numerator: T, denominator: T) !T {
• pub fn mod(comptime T: type, numerator: T, denominator: T) !T {
• pub fn rem(comptime T: type, numerator: T, denominator: T) !T {
• pub fn absCast(x: anytype) switch (@typeinfo(@typeof(x))) {
• pub fn negateCast(x: anytype) !std.meta.Int(.signed, std.meta.bitCount(@typeof(x))) {
• pub fn cast(comptime T: type, x: anytype) (error{Overflow}!T) {
• pub fn alignCast(comptime alignment: u29, ptr: anytype) AlignCastError!@typeof(@aligncast(alignment, ptr)) {
• pub fn isPowerOfTwo(v: anytype) bool {
• pub fn floorPowerOfTwo(comptime T: type, value: T) T {
• pub fn ceilPowerOfTwoPromote(comptime T: type, value: T) std.meta.Int(@typeinfo(T).Int.signedness, @typeinfo(T).Int.bits + 1) {
• pub fn ceilPowerOfTwo(comptime T: type, value: T) (error{Overflow}!T) {
• pub fn ceilPowerOfTwoAssert(comptime T: type, value: T) T {
• pub fn log2_int(comptime T: type, x: T) Log2Int(T) {
• pub fn log2_int_ceil(comptime T: type, x: T) Log2IntCeil(T) {
• pub fn lossyCast(comptime T: type, value: anytype) T {
• pub fn maxInt(comptime T: type) comptime_int {
• pub fn minInt(comptime T: type) comptime_int {
• pub fn mulWide(comptime T: type, a: T, b: T) std.meta.Int(
• pub fn invert(self: Order) Order {
• pub fn compare(self: Order, op: CompareOperator) bool {
• pub fn order(a: anytype, b: anytype) Order {
• pub fn compare(a: anytype, op: CompareOperator, b: anytype) bool {
• pub fn comptimeMod(num: anytype, denom: comptime_int) IntFittingRange(0, denom - 1) {
• pub fn make_f80(repr: F80) f80 {
• pub fn break_f80(x: f80) F80 {