master
1const std = @import("std");
2
3pub const LE = enum(i32) {
4 Less = -1,
5 Equal = 0,
6 Greater = 1,
7
8 const Unordered: LE = .Greater;
9};
10
11pub const GE = enum(i32) {
12 Less = -1,
13 Equal = 0,
14 Greater = 1,
15
16 const Unordered: GE = .Less;
17};
18
19pub inline fn cmpf2(comptime T: type, comptime RT: type, a: T, b: T) RT {
20 const bits = @typeInfo(T).float.bits;
21 const srep_t = std.meta.Int(.signed, bits);
22 const rep_t = std.meta.Int(.unsigned, bits);
23
24 const significandBits = std.math.floatMantissaBits(T);
25 const exponentBits = std.math.floatExponentBits(T);
26 const signBit = (@as(rep_t, 1) << (significandBits + exponentBits));
27 const absMask = signBit - 1;
28 const infT = comptime std.math.inf(T);
29 const infRep = @as(rep_t, @bitCast(infT));
30
31 const aInt = @as(srep_t, @bitCast(a));
32 const bInt = @as(srep_t, @bitCast(b));
33 const aAbs = @as(rep_t, @bitCast(aInt)) & absMask;
34 const bAbs = @as(rep_t, @bitCast(bInt)) & absMask;
35
36 // If either a or b is NaN, they are unordered.
37 if (aAbs > infRep or bAbs > infRep) return RT.Unordered;
38
39 // If a and b are both zeros, they are equal.
40 if ((aAbs | bAbs) == 0) return .Equal;
41
42 // If at least one of a and b is positive, we get the same result comparing
43 // a and b as signed integers as we would with a floating-point compare.
44 if ((aInt & bInt) >= 0) {
45 if (aInt < bInt) {
46 return .Less;
47 } else if (aInt == bInt) {
48 return .Equal;
49 } else return .Greater;
50 } else {
51 // Otherwise, both are negative, so we need to flip the sense of the
52 // comparison to get the correct result. (This assumes a twos- or ones-
53 // complement integer representation; if integers are represented in a
54 // sign-magnitude representation, then this flip is incorrect).
55 if (aInt > bInt) {
56 return .Less;
57 } else if (aInt == bInt) {
58 return .Equal;
59 } else return .Greater;
60 }
61}
62
63pub inline fn cmp_f80(comptime RT: type, a: f80, b: f80) RT {
64 const a_rep = std.math.F80.fromFloat(a);
65 const b_rep = std.math.F80.fromFloat(b);
66 const sig_bits = std.math.floatMantissaBits(f80);
67 const int_bit = 0x8000000000000000;
68 const sign_bit = 0x8000;
69 const special_exp = 0x7FFF;
70
71 // If either a or b is NaN, they are unordered.
72 if ((a_rep.exp & special_exp == special_exp and a_rep.fraction ^ int_bit != 0) or
73 (b_rep.exp & special_exp == special_exp and b_rep.fraction ^ int_bit != 0))
74 return RT.Unordered;
75
76 // If a and b are both zeros, they are equal.
77 if ((a_rep.fraction | b_rep.fraction) | ((a_rep.exp | b_rep.exp) & special_exp) == 0)
78 return .Equal;
79
80 if (@intFromBool(a_rep.exp == b_rep.exp) & @intFromBool(a_rep.fraction == b_rep.fraction) != 0) {
81 return .Equal;
82 } else if (a_rep.exp & sign_bit != b_rep.exp & sign_bit) {
83 // signs are different
84 if (@as(i16, @bitCast(a_rep.exp)) < @as(i16, @bitCast(b_rep.exp))) {
85 return .Less;
86 } else {
87 return .Greater;
88 }
89 } else {
90 const a_fraction = a_rep.fraction | (@as(u80, a_rep.exp) << sig_bits);
91 const b_fraction = b_rep.fraction | (@as(u80, b_rep.exp) << sig_bits);
92 if ((a_fraction < b_fraction) == (a_rep.exp & sign_bit == 0)) {
93 return .Less;
94 } else {
95 return .Greater;
96 }
97 }
98}
99
100test "cmp_f80" {
101 inline for (.{ LE, GE }) |RT| {
102 try std.testing.expect(cmp_f80(RT, 1.0, 1.0) == RT.Equal);
103 try std.testing.expect(cmp_f80(RT, 0.0, -0.0) == RT.Equal);
104 try std.testing.expect(cmp_f80(RT, 2.0, 4.0) == RT.Less);
105 try std.testing.expect(cmp_f80(RT, 2.0, -4.0) == RT.Greater);
106 try std.testing.expect(cmp_f80(RT, -2.0, -4.0) == RT.Greater);
107 try std.testing.expect(cmp_f80(RT, -2.0, 4.0) == RT.Less);
108 }
109}
110
111pub inline fn unordcmp(comptime T: type, a: T, b: T) i32 {
112 const rep_t = std.meta.Int(.unsigned, @typeInfo(T).float.bits);
113
114 const significandBits = std.math.floatMantissaBits(T);
115 const exponentBits = std.math.floatExponentBits(T);
116 const signBit = (@as(rep_t, 1) << (significandBits + exponentBits));
117 const absMask = signBit - 1;
118 const infRep = @as(rep_t, @bitCast(std.math.inf(T)));
119
120 const aAbs: rep_t = @as(rep_t, @bitCast(a)) & absMask;
121 const bAbs: rep_t = @as(rep_t, @bitCast(b)) & absMask;
122
123 return @intFromBool(aAbs > infRep or bAbs > infRep);
124}
125
126test {
127 _ = @import("comparesf2_test.zig");
128 _ = @import("comparedf2_test.zig");
129}