1 /*
2 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
3 *
4 * Copyright 2021 Mike Becker, Olaf Wintermann All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions are met:
8 *
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 *
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
17 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
20 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
21 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
22 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
23 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
24 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
25 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
26 * POSSIBILITY OF SUCH DAMAGE.
27 */
28
29 #include "cx/compare.h"
30
31 #include <math.h>
32
33 int cx_vcmp_int(int a, int b) {
34 if (a == b) {
35 return 0;
36 } else {
37 return a < b ? -1 : 1;
38 }
39 }
40
41 int cx_cmp_int(const void *i1, const void *i2) {
42 int a = *((const int *) i1);
43 int b = *((const int *) i2);
44 return cx_vcmp_int(a, b);
45 }
46
47 int cx_vcmp_longint(long int a, long int b) {
48 if (a == b) {
49 return 0;
50 } else {
51 return a < b ? -1 : 1;
52 }
53 }
54
55 int cx_cmp_longint(const void *i1, const void *i2) {
56 long int a = *((const long int *) i1);
57 long int b = *((const long int *) i2);
58 return cx_vcmp_longint(a, b);
59 }
60
61 int cx_vcmp_longlong(long long a, long long b) {
62 if (a == b) {
63 return 0;
64 } else {
65 return a < b ? -1 : 1;
66 }
67 }
68
69 int cx_cmp_longlong(const void *i1, const void *i2) {
70 long long a = *((const long long *) i1);
71 long long b = *((const long long *) i2);
72 return cx_vcmp_longlong(a, b);
73 }
74
75 int cx_vcmp_int16(int16_t a, int16_t b) {
76 if (a == b) {
77 return 0;
78 } else {
79 return a < b ? -1 : 1;
80 }
81 }
82
83 int cx_cmp_int16(const void *i1, const void *i2) {
84 int16_t a = *((const int16_t *) i1);
85 int16_t b = *((const int16_t *) i2);
86 return cx_vcmp_int16(a, b);
87 }
88
89 int cx_vcmp_int32(int32_t a, int32_t b) {
90 if (a == b) {
91 return 0;
92 } else {
93 return a < b ? -1 : 1;
94 }
95 }
96
97 int cx_cmp_int32(const void *i1, const void *i2) {
98 int32_t a = *((const int32_t *) i1);
99 int32_t b = *((const int32_t *) i2);
100 return cx_vcmp_int32(a, b);
101 }
102
103 int cx_vcmp_int64(int64_t a, int64_t b) {
104 if (a == b) {
105 return 0;
106 } else {
107 return a < b ? -1 : 1;
108 }
109 }
110
111 int cx_cmp_int64(const void *i1, const void *i2) {
112 int64_t a = *((const int64_t *) i1);
113 int64_t b = *((const int64_t *) i2);
114 return cx_vcmp_int64(a, b);
115 }
116
117 int cx_vcmp_uint(unsigned int a, unsigned int b) {
118 if (a == b) {
119 return 0;
120 } else {
121 return a < b ? -1 : 1;
122 }
123 }
124
125 int cx_cmp_uint(const void *i1, const void *i2) {
126 unsigned int a = *((const unsigned int *) i1);
127 unsigned int b = *((const unsigned int *) i2);
128 return cx_vcmp_uint(a, b);
129 }
130
131 int cx_vcmp_ulongint(unsigned long int a, unsigned long int b) {
132 if (a == b) {
133 return 0;
134 } else {
135 return a < b ? -1 : 1;
136 }
137 }
138
139 int cx_cmp_ulongint(const void *i1, const void *i2) {
140 unsigned long int a = *((const unsigned long int *) i1);
141 unsigned long int b = *((const unsigned long int *) i2);
142 return cx_vcmp_ulongint(a, b);
143 }
144
145 int cx_vcmp_ulonglong(unsigned long long a, unsigned long long b) {
146 if (a == b) {
147 return 0;
148 } else {
149 return a < b ? -1 : 1;
150 }
151 }
152
153 int cx_cmp_ulonglong(const void *i1, const void *i2) {
154 unsigned long long a = *((const unsigned long long *) i1);
155 unsigned long long b = *((const unsigned long long *) i2);
156 return cx_vcmp_ulonglong(a, b);
157 }
158
159 int cx_vcmp_uint16(uint16_t a, uint16_t b) {
160 if (a == b) {
161 return 0;
162 } else {
163 return a < b ? -1 : 1;
164 }
165 }
166
167 int cx_cmp_uint16(const void *i1, const void *i2) {
168 uint16_t a = *((const uint16_t *) i1);
169 uint16_t b = *((const uint16_t *) i2);
170 return cx_vcmp_uint16(a, b);
171 }
172
173 int cx_vcmp_uint32(uint32_t a, uint32_t b) {
174 if (a == b) {
175 return 0;
176 } else {
177 return a < b ? -1 : 1;
178 }
179 }
180
181 int cx_cmp_uint32(const void *i1, const void *i2) {
182 uint32_t a = *((const uint32_t *) i1);
183 uint32_t b = *((const uint32_t *) i2);
184 return cx_vcmp_uint32(a, b);
185 }
186
187 int cx_vcmp_uint64(uint64_t a, uint64_t b) {
188 if (a == b) {
189 return 0;
190 } else {
191 return a < b ? -1 : 1;
192 }
193 }
194
195 int cx_cmp_uint64(const void *i1, const void *i2) {
196 uint64_t a = *((const uint64_t *) i1);
197 uint64_t b = *((const uint64_t *) i2);
198 return cx_vcmp_uint64(a, b);
199 }
200
201 int cx_vcmp_size(size_t a, size_t b) {
202 if (a == b) {
203 return 0;
204 } else {
205 return a < b ? -1 : 1;
206 }
207 }
208
209 int cx_cmp_size(const void *i1, const void *i2) {
210 size_t a = *((const size_t *) i1);
211 size_t b = *((const size_t *) i2);
212 return cx_vcmp_size(a, b);
213 }
214
215 int cx_vcmp_float(float a, float b) {
216 if (fabsf(a - b) < 1e-6f) {
217 return 0;
218 } else {
219 return a < b ? -1 : 1;
220 }
221 }
222
223 int cx_cmp_float(const void *f1, const void *f2) {
224 float a = *((const float *) f1);
225 float b = *((const float *) f2);
226 return cx_vcmp_float(a, b);
227 }
228
229 int cx_vcmp_double(double a, double b) {
230 if (fabs(a - b) < 1e-14) {
231 return 0;
232 } else {
233 return a < b ? -1 : 1;
234 }
235 }
236
237 int cx_cmp_double(
238 const void *d1,
239 const void *d2
240 ) {
241 double a = *((const double *) d1);
242 double b = *((const double *) d2);
243 return cx_vcmp_double(a, b);
244 }
245
246 int cx_vcmp_intptr(intptr_t p1, intptr_t p2) {
247 if (p1 == p2) {
248 return 0;
249 } else {
250 return p1 < p2 ? -1 : 1;
251 }
252 }
253
254 int cx_cmp_intptr(
255 const void *ptr1,
256 const void *ptr2
257 ) {
258 intptr_t p1 = *(const intptr_t *) ptr1;
259 intptr_t p2 = *(const intptr_t *) ptr2;
260 return cx_vcmp_intptr(p1, p2);
261 }
262
263 int cx_vcmp_uintptr(uintptr_t p1, uintptr_t p2) {
264 if (p1 == p2) {
265 return 0;
266 } else {
267 return p1 < p2 ? -1 : 1;
268 }
269 }
270
271 int cx_cmp_uintptr(
272 const void *ptr1,
273 const void *ptr2
274 ) {
275 uintptr_t p1 = *(const uintptr_t *) ptr1;
276 uintptr_t p2 = *(const uintptr_t *) ptr2;
277 return cx_vcmp_uintptr(p1, p2);
278 }
279
280 int cx_cmp_ptr(
281 const void *ptr1,
282 const void *ptr2
283 ) {
284 uintptr_t p1 = (uintptr_t) ptr1;
285 uintptr_t p2 = (uintptr_t) ptr2;
286 if (p1 == p2) {
287 return 0;
288 } else {
289 return p1 < p2 ? -1 : 1;
290 }
291 }
292