[rustc.git] / src / libcompiler_builtins / compiler-rt / test / builtins / Unit / divsc3_test.c

// RUN: %clang_builtins %s %librt -lm -o %t && %run %t
//===-- divsc3_test.c - Test __divsc3 -------------------------------------===//
//
//                     The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file tests __divsc3 for the compiler_rt library.
//
//===----------------------------------------------------------------------===//

#include "int_lib.h"
#include <math.h>
#include <complex.h>
#include <stdio.h>

// REQUIRES: c99-complex

// Returns: the quotient of (a + ib) / (c + id)

COMPILER_RT_ABI float _Complex
__divsc3(float __a, float __b, float __c, float __d);

enum {zero, non_zero, inf, NaN, non_zero_nan};

int
classify(float _Complex x)
{
    if (x == 0)
        return zero;
    if (isinf(crealf(x)) || isinf(cimagf(x)))
        return inf;
    if (isnan(crealf(x)) && isnan(cimagf(x)))
        return NaN;
    if (isnan(crealf(x)))
    {
        if (cimagf(x) == 0)
            return NaN;
        return non_zero_nan;
    }
    if (isnan(cimagf(x)))
    {
        if (crealf(x) == 0)
            return NaN;
        return non_zero_nan;
    }
    return non_zero;
}

int test__divsc3(float a, float b, float c, float d)
{
    float _Complex r = __divsc3(a, b, c, d);
//     printf("test__divsc3(%f, %f, %f, %f) = %f + I%f\n",
//             a, b, c, d, crealf(r), cimagf(r));
	float _Complex dividend;
	float _Complex divisor;
	
	__real__ dividend = a;
	__imag__ dividend = b;
	__real__ divisor = c;
	__imag__ divisor = d;
	
    switch (classify(dividend))
    {
    case zero:
        switch (classify(divisor))
        {
        case zero:
            if (classify(r) != NaN)
                return 1;
            break;
        case non_zero:
            if (classify(r) != zero)
                return 1;
            break;
        case inf:
            if (classify(r) != zero)
                return 1;
            break;
        case NaN:
            if (classify(r) != NaN)
                return 1;
            break;
        case non_zero_nan:
            if (classify(r) != NaN)
                return 1;
            break;
        }
        break;
    case non_zero:
        switch (classify(divisor))
        {
        case zero:
            if (classify(r) != inf)
                return 1;
            break;
        case non_zero:
            if (classify(r) != non_zero)
                return 1;
            {
            float _Complex z = (a * c + b * d) / (c * c + d * d)
                             + (b * c - a * d) / (c * c + d * d) * _Complex_I;
            if (r != z)
                return 1;
            }
            break;
        case inf:
            if (classify(r) != zero)
                return 1;
            break;
        case NaN:
            if (classify(r) != NaN)
                return 1;
            break;
        case non_zero_nan:
            if (classify(r) != NaN)
                return 1;
            break;
        }
        break;
    case inf:
        switch (classify(divisor))
        {
        case zero:
            if (classify(r) != inf)
                return 1;
            break;
        case non_zero:
            if (classify(r) != inf)
                return 1;
            break;
        case inf:
            if (classify(r) != NaN)
                return 1;
            break;
        case NaN:
            if (classify(r) != NaN)
                return 1;
            break;
        case non_zero_nan:
            if (classify(r) != NaN)
                return 1;
            break;
        }
        break;
    case NaN:
        switch (classify(divisor))
        {
        case zero:
            if (classify(r) != NaN)
                return 1;
            break;
        case non_zero:
            if (classify(r) != NaN)
                return 1;
            break;
        case inf:
            if (classify(r) != NaN)
                return 1;
            break;
        case NaN:
            if (classify(r) != NaN)
                return 1;
            break;
        case non_zero_nan:
            if (classify(r) != NaN)
                return 1;
            break;
        }
        break;
    case non_zero_nan:
        switch (classify(divisor))
        {
        case zero:
            if (classify(r) != inf)
                return 1;
            break;
        case non_zero:
            if (classify(r) != NaN)
                return 1;
            break;
        case inf:
            if (classify(r) != NaN)
                return 1;
            break;
        case NaN:
            if (classify(r) != NaN)
                return 1;
            break;
        case non_zero_nan:
            if (classify(r) != NaN)
                return 1;
            break;
        }
        break;
    }
    
    return 0;
}

float x[][2] =
{
    { 1.e-6,  1.e-6},
    {-1.e-6,  1.e-6},
    {-1.e-6, -1.e-6},
    { 1.e-6, -1.e-6},

    { 1.e+6,  1.e-6},
    {-1.e+6,  1.e-6},
    {-1.e+6, -1.e-6},
    { 1.e+6, -1.e-6},

    { 1.e-6,  1.e+6},
    {-1.e-6,  1.e+6},
    {-1.e-6, -1.e+6},
    { 1.e-6, -1.e+6},

    { 1.e+6,  1.e+6},
    {-1.e+6,  1.e+6},
    {-1.e+6, -1.e+6},
    { 1.e+6, -1.e+6},

    {NAN, NAN},
    {-INFINITY, NAN},
    {-2, NAN},
    {-1, NAN},
    {-0.5, NAN},
    {-0., NAN},
    {+0., NAN},
    {0.5, NAN},
    {1, NAN},
    {2, NAN},
    {INFINITY, NAN},

    {NAN, -INFINITY},
    {-INFINITY, -INFINITY},
    {-2, -INFINITY},
    {-1, -INFINITY},
    {-0.5, -INFINITY},
    {-0., -INFINITY},
    {+0., -INFINITY},
    {0.5, -INFINITY},
    {1, -INFINITY},
    {2, -INFINITY},
    {INFINITY, -INFINITY},

    {NAN, -2},
    {-INFINITY, -2},
    {-2, -2},
    {-1, -2},
    {-0.5, -2},
    {-0., -2},
    {+0., -2},
    {0.5, -2},
    {1, -2},
    {2, -2},
    {INFINITY, -2},

    {NAN, -1},
    {-INFINITY, -1},
    {-2, -1},
    {-1, -1},
    {-0.5, -1},
    {-0., -1},
    {+0., -1},
    {0.5, -1},
    {1, -1},
    {2, -1},
    {INFINITY, -1},

    {NAN, -0.5},
    {-INFINITY, -0.5},
    {-2, -0.5},
    {-1, -0.5},
    {-0.5, -0.5},
    {-0., -0.5},
    {+0., -0.5},
    {0.5, -0.5},
    {1, -0.5},
    {2, -0.5},
    {INFINITY, -0.5},

    {NAN, -0.},
    {-INFINITY, -0.},
    {-2, -0.},
    {-1, -0.},
    {-0.5, -0.},
    {-0., -0.},
    {+0., -0.},
    {0.5, -0.},
    {1, -0.},
    {2, -0.},
    {INFINITY, -0.},

    {NAN, 0.},
    {-INFINITY, 0.},
    {-2, 0.},
    {-1, 0.},
    {-0.5, 0.},
    {-0., 0.},
    {+0., 0.},
    {0.5, 0.},
    {1, 0.},
    {2, 0.},
    {INFINITY, 0.},

    {NAN, 0.5},
    {-INFINITY, 0.5},
    {-2, 0.5},
    {-1, 0.5},
    {-0.5, 0.5},
    {-0., 0.5},
    {+0., 0.5},
    {0.5, 0.5},
    {1, 0.5},
    {2, 0.5},
    {INFINITY, 0.5},

    {NAN, 1},
    {-INFINITY, 1},
    {-2, 1},
    {-1, 1},
    {-0.5, 1},
    {-0., 1},
    {+0., 1},
    {0.5, 1},
    {1, 1},
    {2, 1},
    {INFINITY, 1},

    {NAN, 2},
    {-INFINITY, 2},
    {-2, 2},
    {-1, 2},
    {-0.5, 2},
    {-0., 2},
    {+0., 2},
    {0.5, 2},
    {1, 2},
    {2, 2},
    {INFINITY, 2},

    {NAN, INFINITY},
    {-INFINITY, INFINITY},
    {-2, INFINITY},
    {-1, INFINITY},
    {-0.5, INFINITY},
    {-0., INFINITY},
    {+0., INFINITY},
    {0.5, INFINITY},
    {1, INFINITY},
    {2, INFINITY},
    {INFINITY, INFINITY}

};

int main()
{
    const unsigned N = sizeof(x) / sizeof(x[0]);
    unsigned i, j;
    for (i = 0; i < N; ++i)
    {
        for (j = 0; j < N; ++j)
        {
            if (test__divsc3(x[i][0], x[i][1], x[j][0], x[j][1]))
                return 1;
        }
    }

    return 0;
}
Commit	Line	Data
2c00a5a8	1	// RUN: %clang_builtins %s %librt -lm -o %t && %run %t
1a4d82fc JJ	2	//===-- divsc3_test.c - Test __divsc3 -------------------------------------===//
	3	//
	4	// The LLVM Compiler Infrastructure
	5	//
	6	// This file is dual licensed under the MIT and the University of Illinois Open
	7	// Source Licenses. See LICENSE.TXT for details.
	8	//
	9	//===----------------------------------------------------------------------===//
	10	//
	11	// This file tests __divsc3 for the compiler_rt library.
	12	//
	13	//===----------------------------------------------------------------------===//
	14
	15	#include "int_lib.h"
	16	#include <math.h>
	17	#include <complex.h>
	18	#include <stdio.h>
	19
2c00a5a8 XL	20	// REQUIRES: c99-complex
2c00a5a8 XL	21
1a4d82fc JJ	22	// Returns: the quotient of (a + ib) / (c + id)
1a4d82fc JJ	23
92a42be0 SL	24	COMPILER_RT_ABI float _Complex
92a42be0 SL	25	__divsc3(float __a, float __b, float __c, float __d);
1a4d82fc JJ	26
	27	enum {zero, non_zero, inf, NaN, non_zero_nan};
	28
	29	int
	30	classify(float _Complex x)
	31	{
	32	if (x == 0)
	33	return zero;
	34	if (isinf(crealf(x)) \|\| isinf(cimagf(x)))
	35	return inf;
	36	if (isnan(crealf(x)) && isnan(cimagf(x)))
	37	return NaN;
	38	if (isnan(crealf(x)))
	39	{
	40	if (cimagf(x) == 0)
	41	return NaN;
	42	return non_zero_nan;
	43	}
	44	if (isnan(cimagf(x)))
	45	{
	46	if (crealf(x) == 0)
	47	return NaN;
	48	return non_zero_nan;
	49	}
	50	return non_zero;
	51	}
	52
	53	int test__divsc3(float a, float b, float c, float d)
	54	{
	55	float _Complex r = __divsc3(a, b, c, d);
	56	// printf("test__divsc3(%f, %f, %f, %f) = %f + I%f\n",
	57	// a, b, c, d, crealf(r), cimagf(r));
	58	float _Complex dividend;
	59	float _Complex divisor;
	60
	61	__real__ dividend = a;
	62	__imag__ dividend = b;
	63	__real__ divisor = c;
	64	__imag__ divisor = d;
	65
	66	switch (classify(dividend))
	67	{
	68	case zero:
	69	switch (classify(divisor))
	70	{
	71	case zero:
	72	if (classify(r) != NaN)
	73	return 1;
	74	break;
	75	case non_zero:
	76	if (classify(r) != zero)
	77	return 1;
	78	break;
	79	case inf:
	80	if (classify(r) != zero)
	81	return 1;
	82	break;
	83	case NaN:
	84	if (classify(r) != NaN)
	85	return 1;
	86	break;
	87	case non_zero_nan:
	88	if (classify(r) != NaN)
	89	return 1;
90	break;
91	}
92	break;
93	case non_zero:
94	switch (classify(divisor))
95	{
96	case zero:
97	if (classify(r) != inf)
98	return 1;
99	break;
100	case non_zero:
101	if (classify(r) != non_zero)
102	return 1;
103	{
104	float _Complex z = (a * c + b * d) / (c * c + d * d)
105	+ (b * c - a * d) / (c * c + d * d) * _Complex_I;
106	if (r != z)
107	return 1;
108	}
109	break;
110	case inf:
111	if (classify(r) != zero)
112	return 1;
113	break;
114	case NaN:
115	if (classify(r) != NaN)
116	return 1;
117	break;
118	case non_zero_nan:
119	if (classify(r) != NaN)
120	return 1;
121	break;
122	}
123	break;
124	case inf:
125	switch (classify(divisor))
126	{
127	case zero:
128	if (classify(r) != inf)
129	return 1;
130	break;
131	case non_zero:
132	if (classify(r) != inf)
133	return 1;
134	break;
135	case inf:
136	if (classify(r) != NaN)
137	return 1;
138	break;
139	case NaN:
140	if (classify(r) != NaN)
141	return 1;
142	break;
143	case non_zero_nan:
144	if (classify(r) != NaN)
145	return 1;
146	break;
147	}
148	break;
149	case NaN:
150	switch (classify(divisor))
151	{
152	case zero:
153	if (classify(r) != NaN)
154	return 1;
155	break;
156	case non_zero:
157	if (classify(r) != NaN)
158	return 1;
159	break;
160	case inf:
161	if (classify(r) != NaN)
162	return 1;
163	break;
164	case NaN:
165	if (classify(r) != NaN)
166	return 1;
167	break;
168	case non_zero_nan:
169	if (classify(r) != NaN)
170	return 1;
171	break;
172	}
173	break;
174	case non_zero_nan:
175	switch (classify(divisor))
176	{
177	case zero:
178	if (classify(r) != inf)
179	return 1;
180	break;
181	case non_zero:
182	if (classify(r) != NaN)
183	return 1;
184	break;
185	case inf:
186	if (classify(r) != NaN)
187	return 1;
188	break;
189	case NaN:
190	if (classify(r) != NaN)
191	return 1;
192	break;
193	case non_zero_nan:
194	if (classify(r) != NaN)
195	return 1;
196	break;
197	}
198	break;
199	}
200
201	return 0;
202	}
203
204	float x[][2] =
205	{
206	{ 1.e-6, 1.e-6},
207	{-1.e-6, 1.e-6},
208	{-1.e-6, -1.e-6},
209	{ 1.e-6, -1.e-6},
210
211	{ 1.e+6, 1.e-6},
212	{-1.e+6, 1.e-6},
213	{-1.e+6, -1.e-6},
214	{ 1.e+6, -1.e-6},
215
216	{ 1.e-6, 1.e+6},
217	{-1.e-6, 1.e+6},
218	{-1.e-6, -1.e+6},
219	{ 1.e-6, -1.e+6},
220
221	{ 1.e+6, 1.e+6},
222	{-1.e+6, 1.e+6},
223	{-1.e+6, -1.e+6},
224	{ 1.e+6, -1.e+6},
225
226	{NAN, NAN},
227	{-INFINITY, NAN},
228	{-2, NAN},
229	{-1, NAN},
230	{-0.5, NAN},
231	{-0., NAN},
232	{+0., NAN},
233	{0.5, NAN},
234	{1, NAN},
235	{2, NAN},
236	{INFINITY, NAN},
237
238	{NAN, -INFINITY},
239	{-INFINITY, -INFINITY},
240	{-2, -INFINITY},
241	{-1, -INFINITY},
242	{-0.5, -INFINITY},
243	{-0., -INFINITY},
244	{+0., -INFINITY},
245	{0.5, -INFINITY},
246	{1, -INFINITY},
247	{2, -INFINITY},
248	{INFINITY, -INFINITY},
249
250	{NAN, -2},
251	{-INFINITY, -2},
252	{-2, -2},
253	{-1, -2},
254	{-0.5, -2},
255	{-0., -2},
256	{+0., -2},
257	{0.5, -2},
258	{1, -2},
259	{2, -2},
260	{INFINITY, -2},
261
262	{NAN, -1},
263	{-INFINITY, -1},
264	{-2, -1},
265	{-1, -1},
266	{-0.5, -1},
267	{-0., -1},
268	{+0., -1},
269	{0.5, -1},
270	{1, -1},
271	{2, -1},
272	{INFINITY, -1},
273
274	{NAN, -0.5},
275	{-INFINITY, -0.5},
276	{-2, -0.5},
277	{-1, -0.5},
278	{-0.5, -0.5},
279	{-0., -0.5},
280	{+0., -0.5},
281	{0.5, -0.5},
282	{1, -0.5},
283	{2, -0.5},
284	{INFINITY, -0.5},
285
286	{NAN, -0.},
287	{-INFINITY, -0.},
288	{-2, -0.},
289	{-1, -0.},
290	{-0.5, -0.},
291	{-0., -0.},
292	{+0., -0.},
293	{0.5, -0.},
294	{1, -0.},
295	{2, -0.},
296	{INFINITY, -0.},
297
298	{NAN, 0.},
299	{-INFINITY, 0.},
300	{-2, 0.},
301	{-1, 0.},
302	{-0.5, 0.},
303	{-0., 0.},
304	{+0., 0.},
305	{0.5, 0.},
306	{1, 0.},
307	{2, 0.},
308	{INFINITY, 0.},
309
310	{NAN, 0.5},
311	{-INFINITY, 0.5},
312	{-2, 0.5},
313	{-1, 0.5},
314	{-0.5, 0.5},
315	{-0., 0.5},
316	{+0., 0.5},
317	{0.5, 0.5},
318	{1, 0.5},
319	{2, 0.5},
320	{INFINITY, 0.5},
321
322	{NAN, 1},
323	{-INFINITY, 1},
324	{-2, 1},
325	{-1, 1},
326	{-0.5, 1},
327	{-0., 1},
328	{+0., 1},
329	{0.5, 1},
330	{1, 1},
331	{2, 1},
332	{INFINITY, 1},
333
334	{NAN, 2},
335	{-INFINITY, 2},
336	{-2, 2},
337	{-1, 2},
338	{-0.5, 2},
339	{-0., 2},
340	{+0., 2},
341	{0.5, 2},
342	{1, 2},
343	{2, 2},
344	{INFINITY, 2},
345
346	{NAN, INFINITY},
347	{-INFINITY, INFINITY},
348	{-2, INFINITY},
349	{-1, INFINITY},
350	{-0.5, INFINITY},
351	{-0., INFINITY},
352	{+0., INFINITY},
353	{0.5, INFINITY},
354	{1, INFINITY},
355	{2, INFINITY},
356	{INFINITY, INFINITY}
357
358	};
359
360	int main()
361	{
362	const unsigned N = sizeof(x) / sizeof(x[0]);
363	unsigned i, j;
364	for (i = 0; i < N; ++i)
365	{
366	for (j = 0; j < N; ++j)
367	{
368	if (test__divsc3(x[i][0], x[i][1], x[j][0], x[j][1]))
369	return 1;
370	}
371	}
372
373	return 0;
374	}