?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fix oversight in previous error-reporting patch; mustn't pfree path string
[PostgreSQL.git] / src / backend / utils / adt / float.c
blob4d9dc20a281a495bbed01d39393ac726c1a16b6a
1 /*-------------------------------------------------------------------------
2 *
3 * float.c
4 * Functions for the built-in floating-point types.
5 *
6 * Portions Copyright (c) 1996-2008, PostgreSQL Global Development Group
7 * Portions Copyright (c) 1994, Regents of the University of California
8 *
9 *
10 * IDENTIFICATION
11 * $PostgreSQL$
12 *
13 *-------------------------------------------------------------------------
14 */
15 #include "postgres.h"
16
17 #include <ctype.h>
18 #include <float.h>
19 #include <math.h>
20 #include <limits.h>
21
22 #include "catalog/pg_type.h"
23 #include "libpq/pqformat.h"
24 #include "utils/array.h"
25 #include "utils/builtins.h"
26
27
28 #ifndef M_PI
29 /* from my RH5.2 gcc math.h file - thomas 2000-04-03 */
30 #define M_PI 3.14159265358979323846
31 #endif
32
33 /* Visual C++ etc lacks NAN, and won't accept 0.0/0.0. NAN definition from
34 * http://msdn.microsoft.com/library/default.asp?url=/library/en-us/vclang/html/vclrfNotNumberNANItems.asp
35 */
36 #if defined(WIN32) && !defined(NAN)
37 static const uint32 nan[2] = {0xffffffff, 0x7fffffff};
38
39 #define NAN (*(const double *) nan)
40 #endif
41
42 /* not sure what the following should be, but better to make it over-sufficient */
43 #define MAXFLOATWIDTH 64
44 #define MAXDOUBLEWIDTH 128
45
46 /*
47 * check to see if a float4/8 val has underflowed or overflowed
48 */
49 #define CHECKFLOATVAL(val, inf_is_valid, zero_is_valid) \
50 do { \
51 if (isinf(val) && !(inf_is_valid)) \
52 ereport(ERROR, \
53 (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), \
54 errmsg("value out of range: overflow"))); \
55 \
56 if ((val) == 0.0 && !(zero_is_valid)) \
57 ereport(ERROR, \
58 (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), \
59 errmsg("value out of range: underflow"))); \
60 } while(0)
61
62
63 /* ========== USER I/O ROUTINES ========== */
64
65
66 /* Configurable GUC parameter */
67 int extra_float_digits = 0; /* Added to DBL_DIG or FLT_DIG */
68
69
70 static int float4_cmp_internal(float4 a, float4 b);
71 static int float8_cmp_internal(float8 a, float8 b);
72
73 #ifndef HAVE_CBRT
74 static double cbrt(double x);
75 #endif /* HAVE_CBRT */
76
77
78 /*
79 * Routines to provide reasonably platform-independent handling of
80 * infinity and NaN. We assume that isinf() and isnan() are available
81 * and work per spec. (On some platforms, we have to supply our own;
82 * see src/port.) However, generating an Infinity or NaN in the first
83 * place is less well standardized; pre-C99 systems tend not to have C99's
84 * INFINITY and NAN macros. We centralize our workarounds for this here.
85 */
86
87 double
88 get_float8_infinity(void)
89 {
90 #ifdef INFINITY
91 /* C99 standard way */
92 return (double) INFINITY;
93 #else
94
95 /*
96 * On some platforms, HUGE_VAL is an infinity, elsewhere it's just the
97 * largest normal double. We assume forcing an overflow will get us a
98 * true infinity.
99 */
100 return (double) (HUGE_VAL * HUGE_VAL);
101 #endif
102 }
103
104 float
105 get_float4_infinity(void)
106 {
107 #ifdef INFINITY
108 /* C99 standard way */
109 return (float) INFINITY;
110 #else
111
112 /*
113 * On some platforms, HUGE_VAL is an infinity, elsewhere it's just the
114 * largest normal double. We assume forcing an overflow will get us a
115 * true infinity.
116 */
117 return (float) (HUGE_VAL * HUGE_VAL);
118 #endif
119 }
120
121 double
122 get_float8_nan(void)
123 {
124 #ifdef NAN
125 /* C99 standard way */
126 return (double) NAN;
127 #else
128 /* Assume we can get a NAN via zero divide */
129 return (double) (0.0 / 0.0);
130 #endif
131 }
132
133 float
134 get_float4_nan(void)
135 {
136 #ifdef NAN
137 /* C99 standard way */
138 return (float) NAN;
139 #else
140 /* Assume we can get a NAN via zero divide */
141 return (float) (0.0 / 0.0);
142 #endif
143 }
144
145
146 /*
147 * Returns -1 if 'val' represents negative infinity, 1 if 'val'
148 * represents (positive) infinity, and 0 otherwise. On some platforms,
149 * this is equivalent to the isinf() macro, but not everywhere: C99
150 * does not specify that isinf() needs to distinguish between positive
151 * and negative infinity.
152 */
153 int
154 is_infinite(double val)
155 {
156 int inf = isinf(val);
157
158 if (inf == 0)
159 return 0;
160 else if (val > 0)
161 return 1;
162 else
163 return -1;
164 }
165
166
167 /*
168 * float4in - converts "num" to float
169 * restricted syntax:
170 * {<sp>} [+|-] {digit} [.{digit}] [<exp>]
171 * where <sp> is a space, digit is 0-9,
172 * <exp> is "e" or "E" followed by an integer.
173 */
174 Datum
175 float4in(PG_FUNCTION_ARGS)
176 {
177 char *num = PG_GETARG_CSTRING(0);
178 char *orig_num;
179 double val;
180 char *endptr;
181
182 /*
183 * endptr points to the first character _after_ the sequence we recognized
184 * as a valid floating point number. orig_num points to the original input
185 * string.
186 */
187 orig_num = num;
188
189 /*
190 * Check for an empty-string input to begin with, to avoid the vagaries of
191 * strtod() on different platforms.
192 */
193 if (*num == '\0')
194 ereport(ERROR,
195 (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
196 errmsg("invalid input syntax for type real: \"%s\"",
197 orig_num)));
198
199 /* skip leading whitespace */
200 while (*num != '\0' && isspace((unsigned char) *num))
201 num++;
202
203 errno = 0;
204 val = strtod(num, &endptr);
205
206 /* did we not see anything that looks like a double? */
207 if (endptr == num || errno != 0)
208 {
209 /*
210 * C99 requires that strtod() accept NaN and [-]Infinity, but not all
211 * platforms support that yet (and some accept them but set ERANGE
212 * anyway...) Therefore, we check for these inputs ourselves.
213 */
214 if (pg_strncasecmp(num, "NaN", 3) == 0)
215 {
216 val = get_float4_nan();
217 endptr = num + 3;
218 }
219 else if (pg_strncasecmp(num, "Infinity", 8) == 0)
220 {
221 val = get_float4_infinity();
222 endptr = num + 8;
223 }
224 else if (pg_strncasecmp(num, "-Infinity", 9) == 0)
225 {
226 val = -get_float4_infinity();
227 endptr = num + 9;
228 }
229 else if (errno == ERANGE)
230 ereport(ERROR,
231 (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
232 errmsg("\"%s\" is out of range for type real",
233 orig_num)));
234 else
235 ereport(ERROR,
236 (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
237 errmsg("invalid input syntax for type real: \"%s\"",
238 orig_num)));
239 }
240 #ifdef HAVE_BUGGY_SOLARIS_STRTOD
241 else
242 {
243 /*
244 * Many versions of Solaris have a bug wherein strtod sets endptr to
245 * point one byte beyond the end of the string when given "inf" or
246 * "infinity".
247 */
248 if (endptr != num && endptr[-1] == '\0')
249 endptr--;
250 }
251 #endif /* HAVE_BUGGY_SOLARIS_STRTOD */
252
253 #ifdef HAVE_BUGGY_IRIX_STRTOD
254
255 /*
256 * In some IRIX versions, strtod() recognizes only "inf", so if the input
257 * is "infinity" we have to skip over "inity". Also, it may return
258 * positive infinity for "-inf".
259 */
260 if (isinf(val))
261 {
262 if (pg_strncasecmp(num, "Infinity", 8) == 0)
263 {
264 val = get_float4_infinity();
265 endptr = num + 8;
266 }
267 else if (pg_strncasecmp(num, "-Infinity", 9) == 0)
268 {
269 val = -get_float4_infinity();
270 endptr = num + 9;
271 }
272 else if (pg_strncasecmp(num, "-inf", 4) == 0)
273 {
274 val = -get_float4_infinity();
275 endptr = num + 4;
276 }
277 }
278 #endif /* HAVE_BUGGY_IRIX_STRTOD */
279
280 /* skip trailing whitespace */
281 while (*endptr != '\0' && isspace((unsigned char) *endptr))
282 endptr++;
283
284 /* if there is any junk left at the end of the string, bail out */
285 if (*endptr != '\0')
286 ereport(ERROR,
287 (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
288 errmsg("invalid input syntax for type real: \"%s\"",
289 orig_num)));
290
291 /*
292 * if we get here, we have a legal double, still need to check to see if
293 * it's a legal float4
294 */
295 CHECKFLOATVAL((float4) val, isinf(val), val == 0);
296
297 PG_RETURN_FLOAT4((float4) val);
298 }
299
300 /*
301 * float4out - converts a float4 number to a string
302 * using a standard output format
303 */
304 Datum
305 float4out(PG_FUNCTION_ARGS)
306 {
307 float4 num = PG_GETARG_FLOAT4(0);
308 char *ascii = (char *) palloc(MAXFLOATWIDTH + 1);
309
310 if (isnan(num))
311 PG_RETURN_CSTRING(strcpy(ascii, "NaN"));
312
313 switch (is_infinite(num))
314 {
315 case 1:
316 strcpy(ascii, "Infinity");
317 break;
318 case -1:
319 strcpy(ascii, "-Infinity");
320 break;
321 default:
322 {
323 int ndig = FLT_DIG + extra_float_digits;
324
325 if (ndig < 1)
326 ndig = 1;
327
328 sprintf(ascii, "%.*g", ndig, num);
329 }
330 }
331
332 PG_RETURN_CSTRING(ascii);
333 }
334
335 /*
336 * float4recv - converts external binary format to float4
337 */
338 Datum
339 float4recv(PG_FUNCTION_ARGS)
340 {
341 StringInfo buf = (StringInfo) PG_GETARG_POINTER(0);
342
343 PG_RETURN_FLOAT4(pq_getmsgfloat4(buf));
344 }
345
346 /*
347 * float4send - converts float4 to binary format
348 */
349 Datum
350 float4send(PG_FUNCTION_ARGS)
351 {
352 float4 num = PG_GETARG_FLOAT4(0);
353 StringInfoData buf;
354
355 pq_begintypsend(&buf);
356 pq_sendfloat4(&buf, num);
357 PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
358 }
359
360 /*
361 * float8in - converts "num" to float8
362 * restricted syntax:
363 * {<sp>} [+|-] {digit} [.{digit}] [<exp>]
364 * where <sp> is a space, digit is 0-9,
365 * <exp> is "e" or "E" followed by an integer.
366 */
367 Datum
368 float8in(PG_FUNCTION_ARGS)
369 {
370 char *num = PG_GETARG_CSTRING(0);
371 char *orig_num;
372 double val;
373 char *endptr;
374
375 /*
376 * endptr points to the first character _after_ the sequence we recognized
377 * as a valid floating point number. orig_num points to the original input
378 * string.
379 */
380 orig_num = num;
381
382 /*
383 * Check for an empty-string input to begin with, to avoid the vagaries of
384 * strtod() on different platforms.
385 */
386 if (*num == '\0')
387 ereport(ERROR,
388 (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
389 errmsg("invalid input syntax for type double precision: \"%s\"",
390 orig_num)));
391
392 /* skip leading whitespace */
393 while (*num != '\0' && isspace((unsigned char) *num))
394 num++;
395
396 errno = 0;
397 val = strtod(num, &endptr);
398
399 /* did we not see anything that looks like a double? */
400 if (endptr == num || errno != 0)
401 {
402 /*
403 * C99 requires that strtod() accept NaN and [-]Infinity, but not all
404 * platforms support that yet (and some accept them but set ERANGE
405 * anyway...) Therefore, we check for these inputs ourselves.
406 */
407 if (pg_strncasecmp(num, "NaN", 3) == 0)
408 {
409 val = get_float8_nan();
410 endptr = num + 3;
411 }
412 else if (pg_strncasecmp(num, "Infinity", 8) == 0)
413 {
414 val = get_float8_infinity();
415 endptr = num + 8;
416 }
417 else if (pg_strncasecmp(num, "-Infinity", 9) == 0)
418 {
419 val = -get_float8_infinity();
420 endptr = num + 9;
421 }
422 else if (errno == ERANGE)
423 ereport(ERROR,
424 (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
425 errmsg("\"%s\" is out of range for type double precision",
426 orig_num)));
427 else
428 ereport(ERROR,
429 (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
430 errmsg("invalid input syntax for type double precision: \"%s\"",
431 orig_num)));
432 }
433 #ifdef HAVE_BUGGY_SOLARIS_STRTOD
434 else
435 {
436 /*
437 * Many versions of Solaris have a bug wherein strtod sets endptr to
438 * point one byte beyond the end of the string when given "inf" or
439 * "infinity".
440 */
441 if (endptr != num && endptr[-1] == '\0')
442 endptr--;
443 }
444 #endif /* HAVE_BUGGY_SOLARIS_STRTOD */
445
446 #ifdef HAVE_BUGGY_IRIX_STRTOD
447
448 /*
449 * In some IRIX versions, strtod() recognizes only "inf", so if the input
450 * is "infinity" we have to skip over "inity". Also, it may return
451 * positive infinity for "-inf".
452 */
453 if (isinf(val))
454 {
455 if (pg_strncasecmp(num, "Infinity", 8) == 0)
456 {
457 val = get_float8_infinity();
458 endptr = num + 8;
459 }
460 else if (pg_strncasecmp(num, "-Infinity", 9) == 0)
461 {
462 val = -get_float8_infinity();
463 endptr = num + 9;
464 }
465 else if (pg_strncasecmp(num, "-inf", 4) == 0)
466 {
467 val = -get_float8_infinity();
468 endptr = num + 4;
469 }
470 }
471 #endif /* HAVE_BUGGY_IRIX_STRTOD */
472
473 /* skip trailing whitespace */
474 while (*endptr != '\0' && isspace((unsigned char) *endptr))
475 endptr++;
476
477 /* if there is any junk left at the end of the string, bail out */
478 if (*endptr != '\0')
479 ereport(ERROR,
480 (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
481 errmsg("invalid input syntax for type double precision: \"%s\"",
482 orig_num)));
483
484 CHECKFLOATVAL(val, true, true);
485
486 PG_RETURN_FLOAT8(val);
487 }
488
489 /*
490 * float8out - converts float8 number to a string
491 * using a standard output format
492 */
493 Datum
494 float8out(PG_FUNCTION_ARGS)
495 {
496 float8 num = PG_GETARG_FLOAT8(0);
497 char *ascii = (char *) palloc(MAXDOUBLEWIDTH + 1);
498
499 if (isnan(num))
500 PG_RETURN_CSTRING(strcpy(ascii, "NaN"));
501
502 switch (is_infinite(num))
503 {
504 case 1:
505 strcpy(ascii, "Infinity");
506 break;
507 case -1:
508 strcpy(ascii, "-Infinity");
509 break;
510 default:
511 {
512 int ndig = DBL_DIG + extra_float_digits;
513
514 if (ndig < 1)
515 ndig = 1;
516
517 sprintf(ascii, "%.*g", ndig, num);
518 }
519 }
520
521 PG_RETURN_CSTRING(ascii);
522 }
523
524 /*
525 * float8recv - converts external binary format to float8
526 */
527 Datum
528 float8recv(PG_FUNCTION_ARGS)
529 {
530 StringInfo buf = (StringInfo) PG_GETARG_POINTER(0);
531
532 PG_RETURN_FLOAT8(pq_getmsgfloat8(buf));
533 }
534
535 /*
536 * float8send - converts float8 to binary format
537 */
538 Datum
539 float8send(PG_FUNCTION_ARGS)
540 {
541 float8 num = PG_GETARG_FLOAT8(0);
542 StringInfoData buf;
543
544 pq_begintypsend(&buf);
545 pq_sendfloat8(&buf, num);
546 PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
547 }
548
549
550 /* ========== PUBLIC ROUTINES ========== */
551
552
553 /*
554 * ======================
555 * FLOAT4 BASE OPERATIONS
556 * ======================
557 */
558
559 /*
560 * float4abs - returns |arg1| (absolute value)
561 */
562 Datum
563 float4abs(PG_FUNCTION_ARGS)
564 {
565 float4 arg1 = PG_GETARG_FLOAT4(0);
566
567 PG_RETURN_FLOAT4((float4) fabs(arg1));
568 }
569
570 /*
571 * float4um - returns -arg1 (unary minus)
572 */
573 Datum
574 float4um(PG_FUNCTION_ARGS)
575 {
576 float4 arg1 = PG_GETARG_FLOAT4(0);
577 float4 result;
578
579 result = ((arg1 != 0) ? -(arg1) : arg1);
580
581 CHECKFLOATVAL(result, isinf(arg1), true);
582 PG_RETURN_FLOAT4(result);
583 }
584
585 Datum
586 float4up(PG_FUNCTION_ARGS)
587 {
588 float4 arg = PG_GETARG_FLOAT4(0);
589
590 PG_RETURN_FLOAT4(arg);
591 }
592
593 Datum
594 float4larger(PG_FUNCTION_ARGS)
595 {
596 float4 arg1 = PG_GETARG_FLOAT4(0);
597 float4 arg2 = PG_GETARG_FLOAT4(1);
598 float4 result;
599
600 if (float4_cmp_internal(arg1, arg2) > 0)
601 result = arg1;
602 else
603 result = arg2;
604 PG_RETURN_FLOAT4(result);
605 }
606
607 Datum
608 float4smaller(PG_FUNCTION_ARGS)
609 {
610 float4 arg1 = PG_GETARG_FLOAT4(0);
611 float4 arg2 = PG_GETARG_FLOAT4(1);
612 float4 result;
613
614 if (float4_cmp_internal(arg1, arg2) < 0)
615 result = arg1;
616 else
617 result = arg2;
618 PG_RETURN_FLOAT4(result);
619 }
620
621 /*
622 * ======================
623 * FLOAT8 BASE OPERATIONS
624 * ======================
625 */
626
627 /*
628 * float8abs - returns |arg1| (absolute value)
629 */
630 Datum
631 float8abs(PG_FUNCTION_ARGS)
632 {
633 float8 arg1 = PG_GETARG_FLOAT8(0);
634
635 PG_RETURN_FLOAT8(fabs(arg1));
636 }
637
638
639 /*
640 * float8um - returns -arg1 (unary minus)
641 */
642 Datum
643 float8um(PG_FUNCTION_ARGS)
644 {
645 float8 arg1 = PG_GETARG_FLOAT8(0);
646 float8 result;
647
648 result = ((arg1 != 0) ? -(arg1) : arg1);
649
650 CHECKFLOATVAL(result, isinf(arg1), true);
651 PG_RETURN_FLOAT8(result);
652 }
653
654 Datum
655 float8up(PG_FUNCTION_ARGS)
656 {
657 float8 arg = PG_GETARG_FLOAT8(0);
658
659 PG_RETURN_FLOAT8(arg);
660 }
661
662 Datum
663 float8larger(PG_FUNCTION_ARGS)
664 {
665 float8 arg1 = PG_GETARG_FLOAT8(0);
666 float8 arg2 = PG_GETARG_FLOAT8(1);
667 float8 result;
668
669 if (float8_cmp_internal(arg1, arg2) > 0)
670 result = arg1;
671 else
672 result = arg2;
673 PG_RETURN_FLOAT8(result);
674 }
675
676 Datum
677 float8smaller(PG_FUNCTION_ARGS)
678 {
679 float8 arg1 = PG_GETARG_FLOAT8(0);
680 float8 arg2 = PG_GETARG_FLOAT8(1);
681 float8 result;
682
683 if (float8_cmp_internal(arg1, arg2) < 0)
684 result = arg1;
685 else
686 result = arg2;
687 PG_RETURN_FLOAT8(result);
688 }
689
690
691 /*
692 * ====================
693 * ARITHMETIC OPERATORS
694 * ====================
695 */
696
697 /*
698 * float4pl - returns arg1 + arg2
699 * float4mi - returns arg1 - arg2
700 * float4mul - returns arg1 * arg2
701 * float4div - returns arg1 / arg2
702 */
703 Datum
704 float4pl(PG_FUNCTION_ARGS)
705 {
706 float8 arg1 = PG_GETARG_FLOAT4(0);
707 float8 arg2 = PG_GETARG_FLOAT4(1);
708 float4 result;
709
710 result = arg1 + arg2;
711
712 /*
713 * There isn't any way to check for underflow of addition/subtraction
714 * because numbers near the underflow value have been already been to the
715 * point where we can't detect the that the two values were originally
716 * different, e.g. on x86, '1e-45'::float4 == '2e-45'::float4 ==
717 * 1.4013e-45.
718 */
719 CHECKFLOATVAL(result, isinf(arg1) || isinf(arg2), true);
720 PG_RETURN_FLOAT4(result);
721 }
722
723 Datum
724 float4mi(PG_FUNCTION_ARGS)
725 {
726 float4 arg1 = PG_GETARG_FLOAT4(0);
727 float4 arg2 = PG_GETARG_FLOAT4(1);
728 float4 result;
729
730 result = arg1 - arg2;
731 CHECKFLOATVAL(result, isinf(arg1) || isinf(arg2), true);
732 PG_RETURN_FLOAT4(result);
733 }
734
735 Datum
736 float4mul(PG_FUNCTION_ARGS)
737 {
738 float4 arg1 = PG_GETARG_FLOAT4(0);
739 float4 arg2 = PG_GETARG_FLOAT4(1);
740 float4 result;
741
742 result = arg1 * arg2;
743 CHECKFLOATVAL(result, isinf(arg1) || isinf(arg2),
744 arg1 == 0 || arg2 == 0);
745 PG_RETURN_FLOAT4(result);
746 }
747
748 Datum
749 float4div(PG_FUNCTION_ARGS)
750 {
751 float4 arg1 = PG_GETARG_FLOAT4(0);
752 float4 arg2 = PG_GETARG_FLOAT4(1);
753 float4 result;
754
755 if (arg2 == 0.0)
756 ereport(ERROR,
757 (errcode(ERRCODE_DIVISION_BY_ZERO),
758 errmsg("division by zero")));
759
760 /* Do division in float8, then check for overflow */
761 result = arg1 / arg2;
762
763 CHECKFLOATVAL(result, isinf(arg1) || isinf(arg2), arg1 == 0);
764 PG_RETURN_FLOAT4(result);
765 }
766
767 /*
768 * float8pl - returns arg1 + arg2
769 * float8mi - returns arg1 - arg2
770 * float8mul - returns arg1 * arg2
771 * float8div - returns arg1 / arg2
772 */
773 Datum
774 float8pl(PG_FUNCTION_ARGS)
775 {
776 float8 arg1 = PG_GETARG_FLOAT8(0);
777 float8 arg2 = PG_GETARG_FLOAT8(1);
778 float8 result;
779
780 result = arg1 + arg2;
781
782 CHECKFLOATVAL(result, isinf(arg1) || isinf(arg2), true);
783 PG_RETURN_FLOAT8(result);
784 }
785
786 Datum
787 float8mi(PG_FUNCTION_ARGS)
788 {
789 float8 arg1 = PG_GETARG_FLOAT8(0);
790 float8 arg2 = PG_GETARG_FLOAT8(1);
791 float8 result;
792
793 result = arg1 - arg2;
794
795 CHECKFLOATVAL(result, isinf(arg1) || isinf(arg2), true);
796 PG_RETURN_FLOAT8(result);
797 }
798
799 Datum
800 float8mul(PG_FUNCTION_ARGS)
801 {
802 float8 arg1 = PG_GETARG_FLOAT8(0);
803 float8 arg2 = PG_GETARG_FLOAT8(1);
804 float8 result;
805
806 result = arg1 * arg2;
807
808 CHECKFLOATVAL(result, isinf(arg1) || isinf(arg2),
809 arg1 == 0 || arg2 == 0);
810 PG_RETURN_FLOAT8(result);
811 }
812
813 Datum
814 float8div(PG_FUNCTION_ARGS)
815 {
816 float8 arg1 = PG_GETARG_FLOAT8(0);
817 float8 arg2 = PG_GETARG_FLOAT8(1);
818 float8 result;
819
820 if (arg2 == 0.0)
821 ereport(ERROR,
822 (errcode(ERRCODE_DIVISION_BY_ZERO),
823 errmsg("division by zero")));
824
825 result = arg1 / arg2;
826
827 CHECKFLOATVAL(result, isinf(arg1) || isinf(arg2), arg1 == 0);
828 PG_RETURN_FLOAT8(result);
829 }
830
831
832 /*
833 * ====================
834 * COMPARISON OPERATORS
835 * ====================
836 */
837
838 /*
839 * float4{eq,ne,lt,le,gt,ge} - float4/float4 comparison operations
840 */
841 static int
842 float4_cmp_internal(float4 a, float4 b)
843 {
844 /*
845 * We consider all NANs to be equal and larger than any non-NAN. This is
846 * somewhat arbitrary; the important thing is to have a consistent sort
847 * order.
848 */
849 if (isnan(a))
850 {
851 if (isnan(b))
852 return 0; /* NAN = NAN */
853 else
854 return 1; /* NAN > non-NAN */
855 }
856 else if (isnan(b))
857 {
858 return -1; /* non-NAN < NAN */
859 }
860 else
861 {
862 if (a > b)
863 return 1;
864 else if (a < b)
865 return -1;
866 else
867 return 0;
868 }
869 }
870
871 Datum
872 float4eq(PG_FUNCTION_ARGS)
873 {
874 float4 arg1 = PG_GETARG_FLOAT4(0);
875 float4 arg2 = PG_GETARG_FLOAT4(1);
876
877 PG_RETURN_BOOL(float4_cmp_internal(arg1, arg2) == 0);
878 }
879
880 Datum
881 float4ne(PG_FUNCTION_ARGS)
882 {
883 float4 arg1 = PG_GETARG_FLOAT4(0);
884 float4 arg2 = PG_GETARG_FLOAT4(1);
885
886 PG_RETURN_BOOL(float4_cmp_internal(arg1, arg2) != 0);
887 }
888
889 Datum
890 float4lt(PG_FUNCTION_ARGS)
891 {
892 float4 arg1 = PG_GETARG_FLOAT4(0);
893 float4 arg2 = PG_GETARG_FLOAT4(1);
894
895 PG_RETURN_BOOL(float4_cmp_internal(arg1, arg2) < 0);
896 }
897
898 Datum
899 float4le(PG_FUNCTION_ARGS)
900 {
901 float4 arg1 = PG_GETARG_FLOAT4(0);
902 float4 arg2 = PG_GETARG_FLOAT4(1);
903
904 PG_RETURN_BOOL(float4_cmp_internal(arg1, arg2) <= 0);
905 }
906
907 Datum
908 float4gt(PG_FUNCTION_ARGS)
909 {
910 float4 arg1 = PG_GETARG_FLOAT4(0);
911 float4 arg2 = PG_GETARG_FLOAT4(1);
912
913 PG_RETURN_BOOL(float4_cmp_internal(arg1, arg2) > 0);
914 }
915
916 Datum
917 float4ge(PG_FUNCTION_ARGS)
918 {
919 float4 arg1 = PG_GETARG_FLOAT4(0);
920 float4 arg2 = PG_GETARG_FLOAT4(1);
921
922 PG_RETURN_BOOL(float4_cmp_internal(arg1, arg2) >= 0);
923 }
924
925 Datum
926 btfloat4cmp(PG_FUNCTION_ARGS)
927 {
928 float4 arg1 = PG_GETARG_FLOAT4(0);
929 float4 arg2 = PG_GETARG_FLOAT4(1);
930
931 PG_RETURN_INT32(float4_cmp_internal(arg1, arg2));
932 }
933
934 /*
935 * float8{eq,ne,lt,le,gt,ge} - float8/float8 comparison operations
936 */
937 static int
938 float8_cmp_internal(float8 a, float8 b)
939 {
940 /*
941 * We consider all NANs to be equal and larger than any non-NAN. This is
942 * somewhat arbitrary; the important thing is to have a consistent sort
943 * order.
944 */
945 if (isnan(a))
946 {
947 if (isnan(b))
948 return 0; /* NAN = NAN */
949 else
950 return 1; /* NAN > non-NAN */
951 }
952 else if (isnan(b))
953 {
954 return -1; /* non-NAN < NAN */
955 }
956 else
957 {
958 if (a > b)
959 return 1;
960 else if (a < b)
961 return -1;
962 else
963 return 0;
964 }
965 }
966
967 Datum
968 float8eq(PG_FUNCTION_ARGS)
969 {
970 float8 arg1 = PG_GETARG_FLOAT8(0);
971 float8 arg2 = PG_GETARG_FLOAT8(1);
972
973 PG_RETURN_BOOL(float8_cmp_internal(arg1, arg2) == 0);
974 }
975
976 Datum
977 float8ne(PG_FUNCTION_ARGS)
978 {
979 float8 arg1 = PG_GETARG_FLOAT8(0);
980 float8 arg2 = PG_GETARG_FLOAT8(1);
981
982 PG_RETURN_BOOL(float8_cmp_internal(arg1, arg2) != 0);
983 }
984
985 Datum
986 float8lt(PG_FUNCTION_ARGS)
987 {
988 float8 arg1 = PG_GETARG_FLOAT8(0);
989 float8 arg2 = PG_GETARG_FLOAT8(1);
990
991 PG_RETURN_BOOL(float8_cmp_internal(arg1, arg2) < 0);
992 }
993
994 Datum
995 float8le(PG_FUNCTION_ARGS)
996 {
997 float8 arg1 = PG_GETARG_FLOAT8(0);
998 float8 arg2 = PG_GETARG_FLOAT8(1);
999
1000 PG_RETURN_BOOL(float8_cmp_internal(arg1, arg2) <= 0);
1001 }
1002
1003 Datum
1004 float8gt(PG_FUNCTION_ARGS)
1005 {
1006 float8 arg1 = PG_GETARG_FLOAT8(0);
1007 float8 arg2 = PG_GETARG_FLOAT8(1);
1008
1009 PG_RETURN_BOOL(float8_cmp_internal(arg1, arg2) > 0);
1010 }
1011
1012 Datum
1013 float8ge(PG_FUNCTION_ARGS)
1014 {
1015 float8 arg1 = PG_GETARG_FLOAT8(0);
1016 float8 arg2 = PG_GETARG_FLOAT8(1);
1017
1018 PG_RETURN_BOOL(float8_cmp_internal(arg1, arg2) >= 0);
1019 }
1020
1021 Datum
1022 btfloat8cmp(PG_FUNCTION_ARGS)
1023 {
1024 float8 arg1 = PG_GETARG_FLOAT8(0);
1025 float8 arg2 = PG_GETARG_FLOAT8(1);
1026
1027 PG_RETURN_INT32(float8_cmp_internal(arg1, arg2));
1028 }
1029
1030 Datum
1031 btfloat48cmp(PG_FUNCTION_ARGS)
1032 {
1033 float4 arg1 = PG_GETARG_FLOAT4(0);
1034 float8 arg2 = PG_GETARG_FLOAT8(1);
1035
1036 /* widen float4 to float8 and then compare */
1037 PG_RETURN_INT32(float8_cmp_internal(arg1, arg2));
1038 }
1039
1040 Datum
1041 btfloat84cmp(PG_FUNCTION_ARGS)
1042 {
1043 float8 arg1 = PG_GETARG_FLOAT8(0);
1044 float4 arg2 = PG_GETARG_FLOAT4(1);
1045
1046 /* widen float4 to float8 and then compare */
1047 PG_RETURN_INT32(float8_cmp_internal(arg1, arg2));
1048 }
1049
1050
1051 /*
1052 * ===================
1053 * CONVERSION ROUTINES
1054 * ===================
1055 */
1056
1057 /*
1058 * ftod - converts a float4 number to a float8 number
1059 */
1060 Datum
1061 ftod(PG_FUNCTION_ARGS)
1062 {
1063 float4 num = PG_GETARG_FLOAT4(0);
1064
1065 PG_RETURN_FLOAT8((float8) num);
1066 }
1067
1068
1069 /*
1070 * dtof - converts a float8 number to a float4 number
1071 */
1072 Datum
1073 dtof(PG_FUNCTION_ARGS)
1074 {
1075 float8 num = PG_GETARG_FLOAT8(0);
1076
1077 CHECKFLOATVAL((float4) num, isinf(num), num == 0);
1078
1079 PG_RETURN_FLOAT4((float4) num);
1080 }
1081
1082
1083 /*
1084 * dtoi4 - converts a float8 number to an int4 number
1085 */
1086 Datum
1087 dtoi4(PG_FUNCTION_ARGS)
1088 {
1089 float8 num = PG_GETARG_FLOAT8(0);
1090 int32 result;
1091
1092 /* 'Inf' is handled by INT_MAX */
1093 if (num < INT_MIN || num > INT_MAX || isnan(num))
1094 ereport(ERROR,
1095 (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
1096 errmsg("integer out of range")));
1097
1098 result = (int32) rint(num);
1099 PG_RETURN_INT32(result);
1100 }
1101
1102
1103 /*
1104 * dtoi2 - converts a float8 number to an int2 number
1105 */
1106 Datum
1107 dtoi2(PG_FUNCTION_ARGS)
1108 {
1109 float8 num = PG_GETARG_FLOAT8(0);
1110
1111 if (num < SHRT_MIN || num > SHRT_MAX || isnan(num))
1112 ereport(ERROR,
1113 (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
1114 errmsg("smallint out of range")));
1115
1116 PG_RETURN_INT16((int16) rint(num));
1117 }
1118
1119
1120 /*
1121 * i4tod - converts an int4 number to a float8 number
1122 */
1123 Datum
1124 i4tod(PG_FUNCTION_ARGS)
1125 {
1126 int32 num = PG_GETARG_INT32(0);
1127
1128 PG_RETURN_FLOAT8((float8) num);
1129 }
1130
1131
1132 /*
1133 * i2tod - converts an int2 number to a float8 number
1134 */
1135 Datum
1136 i2tod(PG_FUNCTION_ARGS)
1137 {
1138 int16 num = PG_GETARG_INT16(0);
1139
1140 PG_RETURN_FLOAT8((float8) num);
1141 }
1142
1143
1144 /*
1145 * ftoi4 - converts a float4 number to an int4 number
1146 */
1147 Datum
1148 ftoi4(PG_FUNCTION_ARGS)
1149 {
1150 float4 num = PG_GETARG_FLOAT4(0);
1151
1152 if (num < INT_MIN || num > INT_MAX || isnan(num))
1153 ereport(ERROR,
1154 (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
1155 errmsg("integer out of range")));
1156
1157 PG_RETURN_INT32((int32) rint(num));
1158 }
1159
1160
1161 /*
1162 * ftoi2 - converts a float4 number to an int2 number
1163 */
1164 Datum
1165 ftoi2(PG_FUNCTION_ARGS)
1166 {
1167 float4 num = PG_GETARG_FLOAT4(0);
1168
1169 if (num < SHRT_MIN || num > SHRT_MAX || isnan(num))
1170 ereport(ERROR,
1171 (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
1172 errmsg("smallint out of range")));
1173
1174 PG_RETURN_INT16((int16) rint(num));
1175 }
1176
1177
1178 /*
1179 * i4tof - converts an int4 number to a float4 number
1180 */
1181 Datum
1182 i4tof(PG_FUNCTION_ARGS)
1183 {
1184 int32 num = PG_GETARG_INT32(0);
1185
1186 PG_RETURN_FLOAT4((float4) num);
1187 }
1188
1189
1190 /*
1191 * i2tof - converts an int2 number to a float4 number
1192 */
1193 Datum
1194 i2tof(PG_FUNCTION_ARGS)
1195 {
1196 int16 num = PG_GETARG_INT16(0);
1197
1198 PG_RETURN_FLOAT4((float4) num);
1199 }
1200
1201
1202 /*
1203 * =======================
1204 * RANDOM FLOAT8 OPERATORS
1205 * =======================
1206 */
1207
1208 /*
1209 * dround - returns ROUND(arg1)
1210 */
1211 Datum
1212 dround(PG_FUNCTION_ARGS)
1213 {
1214 float8 arg1 = PG_GETARG_FLOAT8(0);
1215
1216 PG_RETURN_FLOAT8(rint(arg1));
1217 }
1218
1219 /*
1220 * dceil - returns the smallest integer greater than or
1221 * equal to the specified float
1222 */
1223 Datum
1224 dceil(PG_FUNCTION_ARGS)
1225 {
1226 float8 arg1 = PG_GETARG_FLOAT8(0);
1227
1228 PG_RETURN_FLOAT8(ceil(arg1));
1229 }
1230
1231 /*
1232 * dfloor - returns the largest integer lesser than or
1233 * equal to the specified float
1234 */
1235 Datum
1236 dfloor(PG_FUNCTION_ARGS)
1237 {
1238 float8 arg1 = PG_GETARG_FLOAT8(0);
1239
1240 PG_RETURN_FLOAT8(floor(arg1));
1241 }
1242
1243 /*
1244 * dsign - returns -1 if the argument is less than 0, 0
1245 * if the argument is equal to 0, and 1 if the
1246 * argument is greater than zero.
1247 */
1248 Datum
1249 dsign(PG_FUNCTION_ARGS)
1250 {
1251 float8 arg1 = PG_GETARG_FLOAT8(0);
1252 float8 result;
1253
1254 if (arg1 > 0)
1255 result = 1.0;
1256 else if (arg1 < 0)
1257 result = -1.0;
1258 else
1259 result = 0.0;
1260
1261 PG_RETURN_FLOAT8(result);
1262 }
1263
1264 /*
1265 * dtrunc - returns truncation-towards-zero of arg1,
1266 * arg1 >= 0 ... the greatest integer less
1267 * than or equal to arg1
1268 * arg1 < 0 ... the least integer greater
1269 * than or equal to arg1
1270 */
1271 Datum
1272 dtrunc(PG_FUNCTION_ARGS)
1273 {
1274 float8 arg1 = PG_GETARG_FLOAT8(0);
1275 float8 result;
1276
1277 if (arg1 >= 0)
1278 result = floor(arg1);
1279 else
1280 result = -floor(-arg1);
1281
1282 PG_RETURN_FLOAT8(result);
1283 }
1284
1285
1286 /*
1287 * dsqrt - returns square root of arg1
1288 */
1289 Datum
1290 dsqrt(PG_FUNCTION_ARGS)
1291 {
1292 float8 arg1 = PG_GETARG_FLOAT8(0);
1293 float8 result;
1294
1295 if (arg1 < 0)
1296 ereport(ERROR,
1297 (errcode(ERRCODE_INVALID_ARGUMENT_FOR_POWER_FUNCTION),
1298 errmsg("cannot take square root of a negative number")));
1299
1300 result = sqrt(arg1);
1301
1302 CHECKFLOATVAL(result, isinf(arg1), arg1 == 0);
1303 PG_RETURN_FLOAT8(result);
1304 }
1305
1306
1307 /*
1308 * dcbrt - returns cube root of arg1
1309 */
1310 Datum
1311 dcbrt(PG_FUNCTION_ARGS)
1312 {
1313 float8 arg1 = PG_GETARG_FLOAT8(0);
1314 float8 result;
1315
1316 result = cbrt(arg1);
1317 CHECKFLOATVAL(result, isinf(arg1), arg1 == 0);
1318 PG_RETURN_FLOAT8(result);
1319 }
1320
1321
1322 /*
1323 * dpow - returns pow(arg1,arg2)
1324 */
1325 Datum
1326 dpow(PG_FUNCTION_ARGS)
1327 {
1328 float8 arg1 = PG_GETARG_FLOAT8(0);
1329 float8 arg2 = PG_GETARG_FLOAT8(1);
1330 float8 result;
1331
1332 /*
1333 * The SQL spec requires that we emit a particular SQLSTATE error code for
1334 * certain error conditions. Specifically, we don't return a divide-by-zero
1335 * error code for 0 ^ -1.
1336 */
1337 if (arg1 == 0 && arg2 < 0)
1338 ereport(ERROR,
1339 (errcode(ERRCODE_INVALID_ARGUMENT_FOR_POWER_FUNCTION),
1340 errmsg("zero raised to a negative power is undefined")));
1341 if (arg1 < 0 && floor(arg2) != arg2)
1342 ereport(ERROR,
1343 (errcode(ERRCODE_INVALID_ARGUMENT_FOR_POWER_FUNCTION),
1344 errmsg("a negative number raised to a non-integer power yields a complex result")));
1345
1346 /*
1347 * pow() sets errno only on some platforms, depending on whether it
1348 * follows _IEEE_, _POSIX_, _XOPEN_, or _SVID_, so we try to avoid using
1349 * errno. However, some platform/CPU combinations return errno == EDOM
1350 * and result == Nan for negative arg1 and very large arg2 (they must be
1351 * using something different from our floor() test to decide it's
1352 * invalid). Other platforms (HPPA) return errno == ERANGE and a large
1353 * (HUGE_VAL) but finite result to signal overflow.
1354 */
1355 errno = 0;
1356 result = pow(arg1, arg2);
1357 if (errno == EDOM && isnan(result))
1358 {
1359 if ((fabs(arg1) > 1 && arg2 >= 0) || (fabs(arg1) < 1 && arg2 < 0))
1360 /* The sign of Inf is not significant in this case. */
1361 result = get_float8_infinity();
1362 else if (fabs(arg1) != 1)
1363 result = 0;
1364 else
1365 result = 1;
1366 }
1367 else if (errno == ERANGE && result != 0 && !isinf(result))
1368 result = get_float8_infinity();
1369
1370 CHECKFLOATVAL(result, isinf(arg1) || isinf(arg2), arg1 == 0);
1371 PG_RETURN_FLOAT8(result);
1372 }
1373
1374
1375 /*
1376 * dexp - returns the exponential function of arg1
1377 */
1378 Datum
1379 dexp(PG_FUNCTION_ARGS)
1380 {
1381 float8 arg1 = PG_GETARG_FLOAT8(0);
1382 float8 result;
1383
1384 errno = 0;
1385 result = exp(arg1);
1386 if (errno == ERANGE && result != 0 && !isinf(result))
1387 result = get_float8_infinity();
1388
1389 CHECKFLOATVAL(result, isinf(arg1), false);
1390 PG_RETURN_FLOAT8(result);
1391 }
1392
1393
1394 /*
1395 * dlog1 - returns the natural logarithm of arg1
1396 */
1397 Datum
1398 dlog1(PG_FUNCTION_ARGS)
1399 {
1400 float8 arg1 = PG_GETARG_FLOAT8(0);
1401 float8 result;
1402
1403 /*
1404 * Emit particular SQLSTATE error codes for ln(). This is required by the
1405 * SQL standard.
1406 */
1407 if (arg1 == 0.0)
1408 ereport(ERROR,
1409 (errcode(ERRCODE_INVALID_ARGUMENT_FOR_LOG),
1410 errmsg("cannot take logarithm of zero")));
1411 if (arg1 < 0)
1412 ereport(ERROR,
1413 (errcode(ERRCODE_INVALID_ARGUMENT_FOR_LOG),
1414 errmsg("cannot take logarithm of a negative number")));
1415
1416 result = log(arg1);
1417
1418 CHECKFLOATVAL(result, isinf(arg1), arg1 == 1);
1419 PG_RETURN_FLOAT8(result);
1420 }
1421
1422
1423 /*
1424 * dlog10 - returns the base 10 logarithm of arg1
1425 */
1426 Datum
1427 dlog10(PG_FUNCTION_ARGS)
1428 {
1429 float8 arg1 = PG_GETARG_FLOAT8(0);
1430 float8 result;
1431
1432 /*
1433 * Emit particular SQLSTATE error codes for log(). The SQL spec doesn't
1434 * define log(), but it does define ln(), so it makes sense to emit the
1435 * same error code for an analogous error condition.
1436 */
1437 if (arg1 == 0.0)
1438 ereport(ERROR,
1439 (errcode(ERRCODE_INVALID_ARGUMENT_FOR_LOG),
1440 errmsg("cannot take logarithm of zero")));
1441 if (arg1 < 0)
1442 ereport(ERROR,
1443 (errcode(ERRCODE_INVALID_ARGUMENT_FOR_LOG),
1444 errmsg("cannot take logarithm of a negative number")));
1445
1446 result = log10(arg1);
1447
1448 CHECKFLOATVAL(result, isinf(arg1), arg1 == 1);
1449 PG_RETURN_FLOAT8(result);
1450 }
1451
1452
1453 /*
1454 * dacos - returns the arccos of arg1 (radians)
1455 */
1456 Datum
1457 dacos(PG_FUNCTION_ARGS)
1458 {
1459 float8 arg1 = PG_GETARG_FLOAT8(0);
1460 float8 result;
1461
1462 /*
1463 * We use errno here because the trigonometric functions are cyclic and
1464 * hard to check for underflow.
1465 */
1466 errno = 0;
1467 result = acos(arg1);
1468 if (errno != 0)
1469 ereport(ERROR,
1470 (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
1471 errmsg("input is out of range")));
1472
1473 CHECKFLOATVAL(result, isinf(arg1), true);
1474 PG_RETURN_FLOAT8(result);
1475 }
1476
1477
1478 /*
1479 * dasin - returns the arcsin of arg1 (radians)
1480 */
1481 Datum
1482 dasin(PG_FUNCTION_ARGS)
1483 {
1484 float8 arg1 = PG_GETARG_FLOAT8(0);
1485 float8 result;
1486
1487 errno = 0;
1488 result = asin(arg1);
1489 if (errno != 0)
1490 ereport(ERROR,
1491 (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
1492 errmsg("input is out of range")));
1493
1494 CHECKFLOATVAL(result, isinf(arg1), true);
1495 PG_RETURN_FLOAT8(result);
1496 }
1497
1498
1499 /*
1500 * datan - returns the arctan of arg1 (radians)
1501 */
1502 Datum
1503 datan(PG_FUNCTION_ARGS)
1504 {
1505 float8 arg1 = PG_GETARG_FLOAT8(0);
1506 float8 result;
1507
1508 errno = 0;
1509 result = atan(arg1);
1510 if (errno != 0)
1511 ereport(ERROR,
1512 (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
1513 errmsg("input is out of range")));
1514
1515 CHECKFLOATVAL(result, isinf(arg1), true);
1516 PG_RETURN_FLOAT8(result);
1517 }
1518
1519
1520 /*
1521 * atan2 - returns the arctan2 of arg1 (radians)
1522 */
1523 Datum
1524 datan2(PG_FUNCTION_ARGS)
1525 {
1526 float8 arg1 = PG_GETARG_FLOAT8(0);
1527 float8 arg2 = PG_GETARG_FLOAT8(1);
1528 float8 result;
1529
1530 errno = 0;
1531 result = atan2(arg1, arg2);
1532 if (errno != 0)
1533 ereport(ERROR,
1534 (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
1535 errmsg("input is out of range")));
1536
1537 CHECKFLOATVAL(result, isinf(arg1) || isinf(arg2), true);
1538 PG_RETURN_FLOAT8(result);
1539 }
1540
1541
1542 /*
1543 * dcos - returns the cosine of arg1 (radians)
1544 */
1545 Datum
1546 dcos(PG_FUNCTION_ARGS)
1547 {
1548 float8 arg1 = PG_GETARG_FLOAT8(0);
1549 float8 result;
1550
1551 errno = 0;
1552 result = cos(arg1);
1553 if (errno != 0)
1554 ereport(ERROR,
1555 (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
1556 errmsg("input is out of range")));
1557
1558 CHECKFLOATVAL(result, isinf(arg1), true);
1559 PG_RETURN_FLOAT8(result);
1560 }
1561
1562
1563 /*
1564 * dcot - returns the cotangent of arg1 (radians)
1565 */
1566 Datum
1567 dcot(PG_FUNCTION_ARGS)
1568 {
1569 float8 arg1 = PG_GETARG_FLOAT8(0);
1570 float8 result;
1571
1572 errno = 0;
1573 result = tan(arg1);
1574 if (errno != 0)
1575 ereport(ERROR,
1576 (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
1577 errmsg("input is out of range")));
1578
1579 result = 1.0 / result;
1580 CHECKFLOATVAL(result, true /* cotan(pi/2) == inf */ , true);
1581 PG_RETURN_FLOAT8(result);
1582 }
1583
1584
1585 /*
1586 * dsin - returns the sine of arg1 (radians)
1587 */
1588 Datum
1589 dsin(PG_FUNCTION_ARGS)
1590 {
1591 float8 arg1 = PG_GETARG_FLOAT8(0);
1592 float8 result;
1593
1594 errno = 0;
1595 result = sin(arg1);
1596 if (errno != 0)
1597 ereport(ERROR,
1598 (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
1599 errmsg("input is out of range")));
1600
1601 CHECKFLOATVAL(result, isinf(arg1), true);
1602 PG_RETURN_FLOAT8(result);
1603 }
1604
1605
1606 /*
1607 * dtan - returns the tangent of arg1 (radians)
1608 */
1609 Datum
1610 dtan(PG_FUNCTION_ARGS)
1611 {
1612 float8 arg1 = PG_GETARG_FLOAT8(0);
1613 float8 result;
1614
1615 errno = 0;
1616 result = tan(arg1);
1617 if (errno != 0)
1618 ereport(ERROR,
1619 (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
1620 errmsg("input is out of range")));
1621
1622 CHECKFLOATVAL(result, true /* tan(pi/2) == Inf */ , true);
1623 PG_RETURN_FLOAT8(result);
1624 }
1625
1626
1627 /*
1628 * degrees - returns degrees converted from radians
1629 */
1630 Datum
1631 degrees(PG_FUNCTION_ARGS)
1632 {
1633 float8 arg1 = PG_GETARG_FLOAT8(0);
1634 float8 result;
1635
1636 result = arg1 * (180.0 / M_PI);
1637
1638 CHECKFLOATVAL(result, isinf(arg1), arg1 == 0);
1639 PG_RETURN_FLOAT8(result);
1640 }
1641
1642
1643 /*
1644 * dpi - returns the constant PI
1645 */
1646 Datum
1647 dpi(PG_FUNCTION_ARGS)
1648 {
1649 PG_RETURN_FLOAT8(M_PI);
1650 }
1651
1652
1653 /*
1654 * radians - returns radians converted from degrees
1655 */
1656 Datum
1657 radians(PG_FUNCTION_ARGS)
1658 {
1659 float8 arg1 = PG_GETARG_FLOAT8(0);
1660 float8 result;
1661
1662 result = arg1 * (M_PI / 180.0);
1663
1664 CHECKFLOATVAL(result, isinf(arg1), arg1 == 0);
1665 PG_RETURN_FLOAT8(result);
1666 }
1667
1668
1669 /*
1670 * drandom - returns a random number
1671 */
1672 Datum
1673 drandom(PG_FUNCTION_ARGS)
1674 {
1675 float8 result;
1676
1677 /* result [0.0 - 1.0) */
1678 result = (double) random() / ((double) MAX_RANDOM_VALUE + 1);
1679
1680 PG_RETURN_FLOAT8(result);
1681 }
1682
1683
1684 /*
1685 * setseed - set seed for the random number generator
1686 */
1687 Datum
1688 setseed(PG_FUNCTION_ARGS)
1689 {
1690 float8 seed = PG_GETARG_FLOAT8(0);
1691 int iseed;
1692
1693 if (seed < -1 || seed > 1)
1694 elog(ERROR, "setseed parameter %f out of range [-1,1]", seed);
1695
1696 iseed = (int) (seed * MAX_RANDOM_VALUE);
1697 srandom((unsigned int) iseed);
1698
1699 PG_RETURN_VOID();
1700 }
1701
1702
1703
1704 /*
1705 * =========================
1706 * FLOAT AGGREGATE OPERATORS
1707 * =========================
1708 *
1709 * float8_accum - accumulate for AVG(), variance aggregates, etc.
1710 * float4_accum - same, but input data is float4
1711 * float8_avg - produce final result for float AVG()
1712 * float8_var_samp - produce final result for float VAR_SAMP()
1713 * float8_var_pop - produce final result for float VAR_POP()
1714 * float8_stddev_samp - produce final result for float STDDEV_SAMP()
1715 * float8_stddev_pop - produce final result for float STDDEV_POP()
1716 *
1717 * The transition datatype for all these aggregates is a 3-element array
1718 * of float8, holding the values N, sum(X), sum(X*X) in that order.
1719 *
1720 * Note that we represent N as a float to avoid having to build a special
1721 * datatype. Given a reasonable floating-point implementation, there should
1722 * be no accuracy loss unless N exceeds 2 ^ 52 or so (by which time the
1723 * user will have doubtless lost interest anyway...)
1724 */
1725
1726 static float8 *
1727 check_float8_array(ArrayType *transarray, const char *caller, int n)
1728 {
1729 /*
1730 * We expect the input to be an N-element float array; verify that. We
1731 * don't need to use deconstruct_array() since the array data is just
1732 * going to look like a C array of N float8 values.
1733 */
1734 if (ARR_NDIM(transarray) != 1 ||
1735 ARR_DIMS(transarray)[0] != n ||
1736 ARR_HASNULL(transarray) ||
1737 ARR_ELEMTYPE(transarray) != FLOAT8OID)
1738 elog(ERROR, "%s: expected %d-element float8 array", caller, n);
1739 return (float8 *) ARR_DATA_PTR(transarray);
1740 }
1741
1742 Datum
1743 float8_accum(PG_FUNCTION_ARGS)
1744 {
1745 ArrayType *transarray = PG_GETARG_ARRAYTYPE_P(0);
1746 float8 newval = PG_GETARG_FLOAT8(1);
1747 float8 *transvalues;
1748 float8 N,
1749 sumX,
1750 sumX2;
1751
1752 transvalues = check_float8_array(transarray, "float8_accum", 3);
1753 N = transvalues[0];
1754 sumX = transvalues[1];
1755 sumX2 = transvalues[2];
1756
1757 N += 1.0;
1758 sumX += newval;
1759 CHECKFLOATVAL(sumX, isinf(transvalues[1]) || isinf(newval), true);
1760 sumX2 += newval * newval;
1761 CHECKFLOATVAL(sumX2, isinf(transvalues[2]) || isinf(newval), true);
1762
1763 /*
1764 * If we're invoked by nodeAgg, we can cheat and modify our first
1765 * parameter in-place to reduce palloc overhead. Otherwise we construct a
1766 * new array with the updated transition data and return it.
1767 */
1768 if (fcinfo->context && IsA(fcinfo->context, AggState))
1769 {
1770 transvalues[0] = N;
1771 transvalues[1] = sumX;
1772 transvalues[2] = sumX2;
1773
1774 PG_RETURN_ARRAYTYPE_P(transarray);
1775 }
1776 else
1777 {
1778 Datum transdatums[3];
1779 ArrayType *result;
1780
1781 transdatums[0] = Float8GetDatumFast(N);
1782 transdatums[1] = Float8GetDatumFast(sumX);
1783 transdatums[2] = Float8GetDatumFast(sumX2);
1784
1785 result = construct_array(transdatums, 3,
1786 FLOAT8OID,
1787 sizeof(float8), FLOAT8PASSBYVAL, 'd');
1788
1789 PG_RETURN_ARRAYTYPE_P(result);
1790 }
1791 }
1792
1793 Datum
1794 float4_accum(PG_FUNCTION_ARGS)
1795 {
1796 ArrayType *transarray = PG_GETARG_ARRAYTYPE_P(0);
1797
1798 /* do computations as float8 */
1799 float8 newval = PG_GETARG_FLOAT4(1);
1800 float8 *transvalues;
1801 float8 N,
1802 sumX,
1803 sumX2;
1804
1805 transvalues = check_float8_array(transarray, "float4_accum", 3);
1806 N = transvalues[0];
1807 sumX = transvalues[1];
1808 sumX2 = transvalues[2];
1809
1810 N += 1.0;
1811 sumX += newval;
1812 CHECKFLOATVAL(sumX, isinf(transvalues[1]) || isinf(newval), true);
1813 sumX2 += newval * newval;
1814 CHECKFLOATVAL(sumX2, isinf(transvalues[2]) || isinf(newval), true);
1815
1816 /*
1817 * If we're invoked by nodeAgg, we can cheat and modify our first
1818 * parameter in-place to reduce palloc overhead. Otherwise we construct a
1819 * new array with the updated transition data and return it.
1820 */
1821 if (fcinfo->context && IsA(fcinfo->context, AggState))
1822 {
1823 transvalues[0] = N;
1824 transvalues[1] = sumX;
1825 transvalues[2] = sumX2;
1826
1827 PG_RETURN_ARRAYTYPE_P(transarray);
1828 }
1829 else
1830 {
1831 Datum transdatums[3];
1832 ArrayType *result;
1833
1834 transdatums[0] = Float8GetDatumFast(N);
1835 transdatums[1] = Float8GetDatumFast(sumX);
1836 transdatums[2] = Float8GetDatumFast(sumX2);
1837
1838 result = construct_array(transdatums, 3,
1839 FLOAT8OID,
1840 sizeof(float8), FLOAT8PASSBYVAL, 'd');
1841
1842 PG_RETURN_ARRAYTYPE_P(result);
1843 }
1844 }
1845
1846 Datum
1847 float8_avg(PG_FUNCTION_ARGS)
1848 {
1849 ArrayType *transarray = PG_GETARG_ARRAYTYPE_P(0);
1850 float8 *transvalues;
1851 float8 N,
1852 sumX;
1853
1854 transvalues = check_float8_array(transarray, "float8_avg", 3);
1855 N = transvalues[0];
1856 sumX = transvalues[1];
1857 /* ignore sumX2 */
1858
1859 /* SQL92 defines AVG of no values to be NULL */
1860 if (N == 0.0)
1861 PG_RETURN_NULL();
1862
1863 PG_RETURN_FLOAT8(sumX / N);
1864 }
1865
1866 Datum
1867 float8_var_pop(PG_FUNCTION_ARGS)
1868 {
1869 ArrayType *transarray = PG_GETARG_ARRAYTYPE_P(0);
1870 float8 *transvalues;
1871 float8 N,
1872 sumX,
1873 sumX2,
1874 numerator;
1875
1876 transvalues = check_float8_array(transarray, "float8_var_pop", 3);
1877 N = transvalues[0];
1878 sumX = transvalues[1];
1879 sumX2 = transvalues[2];
1880
1881 /* Population variance is undefined when N is 0, so return NULL */
1882 if (N == 0.0)
1883 PG_RETURN_NULL();
1884
1885 numerator = N * sumX2 - sumX * sumX;
1886 CHECKFLOATVAL(numerator, isinf(sumX2) || isinf(sumX), true);
1887
1888 /* Watch out for roundoff error producing a negative numerator */
1889 if (numerator <= 0.0)
1890 PG_RETURN_FLOAT8(0.0);
1891
1892 PG_RETURN_FLOAT8(numerator / (N * N));
1893 }
1894
1895 Datum
1896 float8_var_samp(PG_FUNCTION_ARGS)
1897 {
1898 ArrayType *transarray = PG_GETARG_ARRAYTYPE_P(0);
1899 float8 *transvalues;
1900 float8 N,
1901 sumX,
1902 sumX2,
1903 numerator;
1904
1905 transvalues = check_float8_array(transarray, "float8_var_samp", 3);
1906 N = transvalues[0];
1907 sumX = transvalues[1];
1908 sumX2 = transvalues[2];
1909
1910 /* Sample variance is undefined when N is 0 or 1, so return NULL */
1911 if (N <= 1.0)
1912 PG_RETURN_NULL();
1913
1914 numerator = N * sumX2 - sumX * sumX;
1915 CHECKFLOATVAL(numerator, isinf(sumX2) || isinf(sumX), true);
1916
1917 /* Watch out for roundoff error producing a negative numerator */
1918 if (numerator <= 0.0)
1919 PG_RETURN_FLOAT8(0.0);
1920
1921 PG_RETURN_FLOAT8(numerator / (N * (N - 1.0)));
1922 }
1923
1924 Datum
1925 float8_stddev_pop(PG_FUNCTION_ARGS)
1926 {
1927 ArrayType *transarray = PG_GETARG_ARRAYTYPE_P(0);
1928 float8 *transvalues;
1929 float8 N,
1930 sumX,
1931 sumX2,
1932 numerator;
1933
1934 transvalues = check_float8_array(transarray, "float8_stddev_pop", 3);
1935 N = transvalues[0];
1936 sumX = transvalues[1];
1937 sumX2 = transvalues[2];
1938
1939 /* Population stddev is undefined when N is 0, so return NULL */
1940 if (N == 0.0)
1941 PG_RETURN_NULL();
1942
1943 numerator = N * sumX2 - sumX * sumX;
1944 CHECKFLOATVAL(numerator, isinf(sumX2) || isinf(sumX), true);
1945
1946 /* Watch out for roundoff error producing a negative numerator */
1947 if (numerator <= 0.0)
1948 PG_RETURN_FLOAT8(0.0);
1949
1950 PG_RETURN_FLOAT8(sqrt(numerator / (N * N)));
1951 }
1952
1953 Datum
1954 float8_stddev_samp(PG_FUNCTION_ARGS)
1955 {
1956 ArrayType *transarray = PG_GETARG_ARRAYTYPE_P(0);
1957 float8 *transvalues;
1958 float8 N,
1959 sumX,
1960 sumX2,
1961 numerator;
1962
1963 transvalues = check_float8_array(transarray, "float8_stddev_samp", 3);
1964 N = transvalues[0];
1965 sumX = transvalues[1];
1966 sumX2 = transvalues[2];
1967
1968 /* Sample stddev is undefined when N is 0 or 1, so return NULL */
1969 if (N <= 1.0)
1970 PG_RETURN_NULL();
1971
1972 numerator = N * sumX2 - sumX * sumX;
1973 CHECKFLOATVAL(numerator, isinf(sumX2) || isinf(sumX), true);
1974
1975 /* Watch out for roundoff error producing a negative numerator */
1976 if (numerator <= 0.0)
1977 PG_RETURN_FLOAT8(0.0);
1978
1979 PG_RETURN_FLOAT8(sqrt(numerator / (N * (N - 1.0))));
1980 }
1981
1982 /*
1983 * =========================
1984 * SQL2003 BINARY AGGREGATES
1985 * =========================
1986 *
1987 * The transition datatype for all these aggregates is a 6-element array of
1988 * float8, holding the values N, sum(X), sum(X*X), sum(Y), sum(Y*Y), sum(X*Y)
1989 * in that order. Note that Y is the first argument to the aggregates!
1990 *
1991 * It might seem attractive to optimize this by having multiple accumulator
1992 * functions that only calculate the sums actually needed. But on most
1993 * modern machines, a couple of extra floating-point multiplies will be
1994 * insignificant compared to the other per-tuple overhead, so I've chosen
1995 * to minimize code space instead.
1996 */
1997
1998 Datum
1999 float8_regr_accum(PG_FUNCTION_ARGS)
2000 {
2001 ArrayType *transarray = PG_GETARG_ARRAYTYPE_P(0);
2002 float8 newvalY = PG_GETARG_FLOAT8(1);
2003 float8 newvalX = PG_GETARG_FLOAT8(2);
2004 float8 *transvalues;
2005 float8 N,
2006 sumX,
2007 sumX2,
2008 sumY,
2009 sumY2,
2010 sumXY;
2011
2012 transvalues = check_float8_array(transarray, "float8_regr_accum", 6);
2013 N = transvalues[0];
2014 sumX = transvalues[1];
2015 sumX2 = transvalues[2];
2016 sumY = transvalues[3];
2017 sumY2 = transvalues[4];
2018 sumXY = transvalues[5];
2019
2020 N += 1.0;
2021 sumX += newvalX;
2022 CHECKFLOATVAL(sumX, isinf(transvalues[1]) || isinf(newvalX), true);
2023 sumX2 += newvalX * newvalX;
2024 CHECKFLOATVAL(sumX2, isinf(transvalues[2]) || isinf(newvalX), true);
2025 sumY += newvalY;
2026 CHECKFLOATVAL(sumY, isinf(transvalues[3]) || isinf(newvalY), true);
2027 sumY2 += newvalY * newvalY;
2028 CHECKFLOATVAL(sumY2, isinf(transvalues[4]) || isinf(newvalY), true);
2029 sumXY += newvalX * newvalY;
2030 CHECKFLOATVAL(sumXY, isinf(transvalues[5]) || isinf(newvalX) ||
2031 isinf(newvalY), true);
2032
2033 /*
2034 * If we're invoked by nodeAgg, we can cheat and modify our first
2035 * parameter in-place to reduce palloc overhead. Otherwise we construct a
2036 * new array with the updated transition data and return it.
2037 */
2038 if (fcinfo->context && IsA(fcinfo->context, AggState))
2039 {
2040 transvalues[0] = N;
2041 transvalues[1] = sumX;
2042 transvalues[2] = sumX2;
2043 transvalues[3] = sumY;
2044 transvalues[4] = sumY2;
2045 transvalues[5] = sumXY;
2046
2047 PG_RETURN_ARRAYTYPE_P(transarray);
2048 }
2049 else
2050 {
2051 Datum transdatums[6];
2052 ArrayType *result;
2053
2054 transdatums[0] = Float8GetDatumFast(N);
2055 transdatums[1] = Float8GetDatumFast(sumX);
2056 transdatums[2] = Float8GetDatumFast(sumX2);
2057 transdatums[3] = Float8GetDatumFast(sumY);
2058 transdatums[4] = Float8GetDatumFast(sumY2);
2059 transdatums[5] = Float8GetDatumFast(sumXY);
2060
2061 result = construct_array(transdatums, 6,
2062 FLOAT8OID,
2063 sizeof(float8), FLOAT8PASSBYVAL, 'd');
2064
2065 PG_RETURN_ARRAYTYPE_P(result);
2066 }
2067 }
2068
2069 Datum
2070 float8_regr_sxx(PG_FUNCTION_ARGS)
2071 {
2072 ArrayType *transarray = PG_GETARG_ARRAYTYPE_P(0);
2073 float8 *transvalues;
2074 float8 N,
2075 sumX,
2076 sumX2,
2077 numerator;
2078
2079 transvalues = check_float8_array(transarray, "float8_regr_sxx", 6);
2080 N = transvalues[0];
2081 sumX = transvalues[1];
2082 sumX2 = transvalues[2];
2083
2084 /* if N is 0 we should return NULL */
2085 if (N < 1.0)
2086 PG_RETURN_NULL();
2087
2088 numerator = N * sumX2 - sumX * sumX;
2089 CHECKFLOATVAL(numerator, isinf(sumX2) || isinf(sumX), true);
2090
2091 /* Watch out for roundoff error producing a negative numerator */
2092 if (numerator <= 0.0)
2093 PG_RETURN_FLOAT8(0.0);
2094
2095 PG_RETURN_FLOAT8(numerator / N);
2096 }
2097
2098 Datum
2099 float8_regr_syy(PG_FUNCTION_ARGS)
2100 {
2101 ArrayType *transarray = PG_GETARG_ARRAYTYPE_P(0);
2102 float8 *transvalues;
2103 float8 N,
2104 sumY,
2105 sumY2,
2106 numerator;
2107
2108 transvalues = check_float8_array(transarray, "float8_regr_syy", 6);
2109 N = transvalues[0];
2110 sumY = transvalues[3];
2111 sumY2 = transvalues[4];
2112
2113 /* if N is 0 we should return NULL */
2114 if (N < 1.0)
2115 PG_RETURN_NULL();
2116
2117 numerator = N * sumY2 - sumY * sumY;
2118 CHECKFLOATVAL(numerator, isinf(sumY2) || isinf(sumY), true);
2119
2120 /* Watch out for roundoff error producing a negative numerator */
2121 if (numerator <= 0.0)
2122 PG_RETURN_FLOAT8(0.0);
2123
2124 PG_RETURN_FLOAT8(numerator / N);
2125 }
2126
2127 Datum
2128 float8_regr_sxy(PG_FUNCTION_ARGS)
2129 {
2130 ArrayType *transarray = PG_GETARG_ARRAYTYPE_P(0);
2131 float8 *transvalues;
2132 float8 N,
2133 sumX,
2134 sumY,
2135 sumXY,
2136 numerator;
2137
2138 transvalues = check_float8_array(transarray, "float8_regr_sxy", 6);
2139 N = transvalues[0];
2140 sumX = transvalues[1];
2141 sumY = transvalues[3];
2142 sumXY = transvalues[5];
2143
2144 /* if N is 0 we should return NULL */
2145 if (N < 1.0)
2146 PG_RETURN_NULL();
2147
2148 numerator = N * sumXY - sumX * sumY;
2149 CHECKFLOATVAL(numerator, isinf(sumXY) || isinf(sumX) ||
2150 isinf(sumY), true);
2151
2152 /* A negative result is valid here */
2153
2154 PG_RETURN_FLOAT8(numerator / N);
2155 }
2156
2157 Datum
2158 float8_regr_avgx(PG_FUNCTION_ARGS)
2159 {
2160 ArrayType *transarray = PG_GETARG_ARRAYTYPE_P(0);
2161 float8 *transvalues;
2162 float8 N,
2163 sumX;
2164
2165 transvalues = check_float8_array(transarray, "float8_regr_avgx", 6);
2166 N = transvalues[0];
2167 sumX = transvalues[1];
2168
2169 /* if N is 0 we should return NULL */
2170 if (N < 1.0)
2171 PG_RETURN_NULL();
2172
2173 PG_RETURN_FLOAT8(sumX / N);
2174 }
2175
2176 Datum
2177 float8_regr_avgy(PG_FUNCTION_ARGS)
2178 {
2179 ArrayType *transarray = PG_GETARG_ARRAYTYPE_P(0);
2180 float8 *transvalues;
2181 float8 N,
2182 sumY;
2183
2184 transvalues = check_float8_array(transarray, "float8_regr_avgy", 6);
2185 N = transvalues[0];
2186 sumY = transvalues[3];
2187
2188 /* if N is 0 we should return NULL */
2189 if (N < 1.0)
2190 PG_RETURN_NULL();
2191
2192 PG_RETURN_FLOAT8(sumY / N);
2193 }
2194
2195 Datum
2196 float8_covar_pop(PG_FUNCTION_ARGS)
2197 {
2198 ArrayType *transarray = PG_GETARG_ARRAYTYPE_P(0);
2199 float8 *transvalues;
2200 float8 N,
2201 sumX,
2202 sumY,
2203 sumXY,
2204 numerator;
2205
2206 transvalues = check_float8_array(transarray, "float8_covar_pop", 6);
2207 N = transvalues[0];
2208 sumX = transvalues[1];
2209 sumY = transvalues[3];
2210 sumXY = transvalues[5];
2211
2212 /* if N is 0 we should return NULL */
2213 if (N < 1.0)
2214 PG_RETURN_NULL();
2215
2216 numerator = N * sumXY - sumX * sumY;
2217 CHECKFLOATVAL(numerator, isinf(sumXY) || isinf(sumX) ||
2218 isinf(sumY), true);
2219
2220 PG_RETURN_FLOAT8(numerator / (N * N));
2221 }
2222
2223 Datum
2224 float8_covar_samp(PG_FUNCTION_ARGS)
2225 {
2226 ArrayType *transarray = PG_GETARG_ARRAYTYPE_P(0);
2227 float8 *transvalues;
2228 float8 N,
2229 sumX,
2230 sumY,
2231 sumXY,
2232 numerator;
2233
2234 transvalues = check_float8_array(transarray, "float8_covar_samp", 6);
2235 N = transvalues[0];
2236 sumX = transvalues[1];
2237 sumY = transvalues[3];
2238 sumXY = transvalues[5];
2239
2240 /* if N is <= 1 we should return NULL */
2241 if (N < 2.0)
2242 PG_RETURN_NULL();
2243
2244 numerator = N * sumXY - sumX * sumY;
2245 CHECKFLOATVAL(numerator, isinf(sumXY) || isinf(sumX) ||
2246 isinf(sumY), true);
2247
2248 PG_RETURN_FLOAT8(numerator / (N * (N - 1.0)));
2249 }
2250
2251 Datum
2252 float8_corr(PG_FUNCTION_ARGS)
2253 {
2254 ArrayType *transarray = PG_GETARG_ARRAYTYPE_P(0);
2255 float8 *transvalues;
2256 float8 N,
2257 sumX,
2258 sumX2,
2259 sumY,
2260 sumY2,
2261 sumXY,
2262 numeratorX,
2263 numeratorY,
2264 numeratorXY;
2265
2266 transvalues = check_float8_array(transarray, "float8_corr", 6);
2267 N = transvalues[0];
2268 sumX = transvalues[1];
2269 sumX2 = transvalues[2];
2270 sumY = transvalues[3];
2271 sumY2 = transvalues[4];
2272 sumXY = transvalues[5];
2273
2274 /* if N is 0 we should return NULL */
2275 if (N < 1.0)
2276 PG_RETURN_NULL();
2277
2278 numeratorX = N * sumX2 - sumX * sumX;
2279 CHECKFLOATVAL(numeratorX, isinf(sumX2) || isinf(sumX), true);
2280 numeratorY = N * sumY2 - sumY * sumY;
2281 CHECKFLOATVAL(numeratorY, isinf(sumY2) || isinf(sumY), true);
2282 numeratorXY = N * sumXY - sumX * sumY;
2283 CHECKFLOATVAL(numeratorXY, isinf(sumXY) || isinf(sumX) ||
2284 isinf(sumY), true);
2285 if (numeratorX <= 0 || numeratorY <= 0)
2286 PG_RETURN_NULL();
2287
2288 PG_RETURN_FLOAT8(numeratorXY / sqrt(numeratorX * numeratorY));
2289 }
2290
2291 Datum
2292 float8_regr_r2(PG_FUNCTION_ARGS)
2293 {
2294 ArrayType *transarray = PG_GETARG_ARRAYTYPE_P(0);
2295 float8 *transvalues;
2296 float8 N,
2297 sumX,
2298 sumX2,
2299 sumY,
2300 sumY2,
2301 sumXY,
2302 numeratorX,
2303 numeratorY,
2304 numeratorXY;
2305
2306 transvalues = check_float8_array(transarray, "float8_regr_r2", 6);
2307 N = transvalues[0];
2308 sumX = transvalues[1];
2309 sumX2 = transvalues[2];
2310 sumY = transvalues[3];
2311 sumY2 = transvalues[4];
2312 sumXY = transvalues[5];
2313
2314 /* if N is 0 we should return NULL */
2315 if (N < 1.0)
2316 PG_RETURN_NULL();
2317
2318 numeratorX = N * sumX2 - sumX * sumX;
2319 CHECKFLOATVAL(numeratorX, isinf(sumX2) || isinf(sumX), true);
2320 numeratorY = N * sumY2 - sumY * sumY;
2321 CHECKFLOATVAL(numeratorY, isinf(sumY2) || isinf(sumY), true);
2322 numeratorXY = N * sumXY - sumX * sumY;
2323 CHECKFLOATVAL(numeratorXY, isinf(sumXY) || isinf(sumX) ||
2324 isinf(sumY), true);
2325 if (numeratorX <= 0)
2326 PG_RETURN_NULL();
2327 /* per spec, horizontal line produces 1.0 */
2328 if (numeratorY <= 0)
2329 PG_RETURN_FLOAT8(1.0);
2330
2331 PG_RETURN_FLOAT8((numeratorXY * numeratorXY) /
2332 (numeratorX * numeratorY));
2333 }
2334
2335 Datum
2336 float8_regr_slope(PG_FUNCTION_ARGS)
2337 {
2338 ArrayType *transarray = PG_GETARG_ARRAYTYPE_P(0);
2339 float8 *transvalues;
2340 float8 N,
2341 sumX,
2342 sumX2,
2343 sumY,
2344 sumXY,
2345 numeratorX,
2346 numeratorXY;
2347
2348 transvalues = check_float8_array(transarray, "float8_regr_slope", 6);
2349 N = transvalues[0];
2350 sumX = transvalues[1];
2351 sumX2 = transvalues[2];
2352 sumY = transvalues[3];
2353 sumXY = transvalues[5];
2354
2355 /* if N is 0 we should return NULL */
2356 if (N < 1.0)
2357 PG_RETURN_NULL();
2358
2359 numeratorX = N * sumX2 - sumX * sumX;
2360 CHECKFLOATVAL(numeratorX, isinf(sumX2) || isinf(sumX), true);
2361 numeratorXY = N * sumXY - sumX * sumY;
2362 CHECKFLOATVAL(numeratorXY, isinf(sumXY) || isinf(sumX) ||
2363 isinf(sumY), true);
2364 if (numeratorX <= 0)
2365 PG_RETURN_NULL();
2366
2367 PG_RETURN_FLOAT8(numeratorXY / numeratorX);
2368 }
2369
2370 Datum
2371 float8_regr_intercept(PG_FUNCTION_ARGS)
2372 {
2373 ArrayType *transarray = PG_GETARG_ARRAYTYPE_P(0);
2374 float8 *transvalues;
2375 float8 N,
2376 sumX,
2377 sumX2,
2378 sumY,
2379 sumXY,
2380 numeratorX,
2381 numeratorXXY;
2382
2383 transvalues = check_float8_array(transarray, "float8_regr_intercept", 6);
2384 N = transvalues[0];
2385 sumX = transvalues[1];
2386 sumX2 = transvalues[2];
2387 sumY = transvalues[3];
2388 sumXY = transvalues[5];
2389
2390 /* if N is 0 we should return NULL */
2391 if (N < 1.0)
2392 PG_RETURN_NULL();
2393
2394 numeratorX = N * sumX2 - sumX * sumX;
2395 CHECKFLOATVAL(numeratorX, isinf(sumX2) || isinf(sumX), true);
2396 numeratorXXY = sumY * sumX2 - sumX * sumXY;
2397 CHECKFLOATVAL(numeratorXXY, isinf(sumY) || isinf(sumX2) ||
2398 isinf(sumX) || isinf(sumXY), true);
2399 if (numeratorX <= 0)
2400 PG_RETURN_NULL();
2401
2402 PG_RETURN_FLOAT8(numeratorXXY / numeratorX);
2403 }
2404
2405
2406 /*
2407 * ====================================
2408 * MIXED-PRECISION ARITHMETIC OPERATORS
2409 * ====================================
2410 */
2411
2412 /*
2413 * float48pl - returns arg1 + arg2
2414 * float48mi - returns arg1 - arg2
2415 * float48mul - returns arg1 * arg2
2416 * float48div - returns arg1 / arg2
2417 */
2418 Datum
2419 float48pl(PG_FUNCTION_ARGS)
2420 {
2421 float4 arg1 = PG_GETARG_FLOAT4(0);
2422 float8 arg2 = PG_GETARG_FLOAT8(1);
2423 float8 result;
2424
2425 result = arg1 + arg2;
2426 CHECKFLOATVAL(result, isinf(arg1) || isinf(arg2), true);
2427 PG_RETURN_FLOAT8(result);
2428 }
2429
2430 Datum
2431 float48mi(PG_FUNCTION_ARGS)
2432 {
2433 float4 arg1 = PG_GETARG_FLOAT4(0);
2434 float8 arg2 = PG_GETARG_FLOAT8(1);
2435 float8 result;
2436
2437 result = arg1 - arg2;
2438 CHECKFLOATVAL(result, isinf(arg1) || isinf(arg2), true);
2439 PG_RETURN_FLOAT8(result);
2440 }
2441
2442 Datum
2443 float48mul(PG_FUNCTION_ARGS)
2444 {
2445 float4 arg1 = PG_GETARG_FLOAT4(0);
2446 float8 arg2 = PG_GETARG_FLOAT8(1);
2447 float8 result;
2448
2449 result = arg1 * arg2;
2450 CHECKFLOATVAL(result, isinf(arg1) || isinf(arg2),
2451 arg1 == 0 || arg2 == 0);
2452 PG_RETURN_FLOAT8(result);
2453 }
2454
2455 Datum
2456 float48div(PG_FUNCTION_ARGS)
2457 {
2458 float4 arg1 = PG_GETARG_FLOAT4(0);
2459 float8 arg2 = PG_GETARG_FLOAT8(1);
2460 float8 result;
2461
2462 if (arg2 == 0.0)
2463 ereport(ERROR,
2464 (errcode(ERRCODE_DIVISION_BY_ZERO),
2465 errmsg("division by zero")));
2466
2467 result = arg1 / arg2;
2468 CHECKFLOATVAL(result, isinf(arg1) || isinf(arg2), arg1 == 0);
2469 PG_RETURN_FLOAT8(result);
2470 }
2471
2472 /*
2473 * float84pl - returns arg1 + arg2
2474 * float84mi - returns arg1 - arg2
2475 * float84mul - returns arg1 * arg2
2476 * float84div - returns arg1 / arg2
2477 */
2478 Datum
2479 float84pl(PG_FUNCTION_ARGS)
2480 {
2481 float8 arg1 = PG_GETARG_FLOAT8(0);
2482 float4 arg2 = PG_GETARG_FLOAT4(1);
2483 float8 result;
2484
2485 result = arg1 + arg2;
2486
2487 CHECKFLOATVAL(result, isinf(arg1) || isinf(arg2), true);
2488 PG_RETURN_FLOAT8(result);
2489 }
2490
2491 Datum
2492 float84mi(PG_FUNCTION_ARGS)
2493 {
2494 float8 arg1 = PG_GETARG_FLOAT8(0);
2495 float4 arg2 = PG_GETARG_FLOAT4(1);
2496 float8 result;
2497
2498 result = arg1 - arg2;
2499
2500 CHECKFLOATVAL(result, isinf(arg1) || isinf(arg2), true);
2501 PG_RETURN_FLOAT8(result);
2502 }
2503
2504 Datum
2505 float84mul(PG_FUNCTION_ARGS)
2506 {
2507 float8 arg1 = PG_GETARG_FLOAT8(0);
2508 float4 arg2 = PG_GETARG_FLOAT4(1);
2509 float8 result;
2510
2511 result = arg1 * arg2;
2512
2513 CHECKFLOATVAL(result, isinf(arg1) || isinf(arg2),
2514 arg1 == 0 || arg2 == 0);
2515 PG_RETURN_FLOAT8(result);
2516 }
2517
2518 Datum
2519 float84div(PG_FUNCTION_ARGS)
2520 {
2521 float8 arg1 = PG_GETARG_FLOAT8(0);
2522 float4 arg2 = PG_GETARG_FLOAT4(1);
2523 float8 result;
2524
2525 if (arg2 == 0.0)
2526 ereport(ERROR,
2527 (errcode(ERRCODE_DIVISION_BY_ZERO),
2528 errmsg("division by zero")));
2529
2530 result = arg1 / arg2;
2531
2532 CHECKFLOATVAL(result, isinf(arg1) || isinf(arg2), arg1 == 0);
2533 PG_RETURN_FLOAT8(result);
2534 }
2535
2536 /*
2537 * ====================
2538 * COMPARISON OPERATORS
2539 * ====================
2540 */
2541
2542 /*
2543 * float48{eq,ne,lt,le,gt,ge} - float4/float8 comparison operations
2544 */
2545 Datum
2546 float48eq(PG_FUNCTION_ARGS)
2547 {
2548 float4 arg1 = PG_GETARG_FLOAT4(0);
2549 float8 arg2 = PG_GETARG_FLOAT8(1);
2550
2551 PG_RETURN_BOOL(float8_cmp_internal(arg1, arg2) == 0);
2552 }
2553
2554 Datum
2555 float48ne(PG_FUNCTION_ARGS)
2556 {
2557 float4 arg1 = PG_GETARG_FLOAT4(0);
2558 float8 arg2 = PG_GETARG_FLOAT8(1);
2559
2560 PG_RETURN_BOOL(float8_cmp_internal(arg1, arg2) != 0);
2561 }
2562
2563 Datum
2564 float48lt(PG_FUNCTION_ARGS)
2565 {
2566 float4 arg1 = PG_GETARG_FLOAT4(0);
2567 float8 arg2 = PG_GETARG_FLOAT8(1);
2568
2569 PG_RETURN_BOOL(float8_cmp_internal(arg1, arg2) < 0);
2570 }
2571
2572 Datum
2573 float48le(PG_FUNCTION_ARGS)
2574 {
2575 float4 arg1 = PG_GETARG_FLOAT4(0);
2576 float8 arg2 = PG_GETARG_FLOAT8(1);
2577
2578 PG_RETURN_BOOL(float8_cmp_internal(arg1, arg2) <= 0);
2579 }
2580
2581 Datum
2582 float48gt(PG_FUNCTION_ARGS)
2583 {
2584 float4 arg1 = PG_GETARG_FLOAT4(0);
2585 float8 arg2 = PG_GETARG_FLOAT8(1);
2586
2587 PG_RETURN_BOOL(float8_cmp_internal(arg1, arg2) > 0);
2588 }
2589
2590 Datum
2591 float48ge(PG_FUNCTION_ARGS)
2592 {
2593 float4 arg1 = PG_GETARG_FLOAT4(0);
2594 float8 arg2 = PG_GETARG_FLOAT8(1);
2595
2596 PG_RETURN_BOOL(float8_cmp_internal(arg1, arg2) >= 0);
2597 }
2598
2599 /*
2600 * float84{eq,ne,lt,le,gt,ge} - float8/float4 comparison operations
2601 */
2602 Datum
2603 float84eq(PG_FUNCTION_ARGS)
2604 {
2605 float8 arg1 = PG_GETARG_FLOAT8(0);
2606 float4 arg2 = PG_GETARG_FLOAT4(1);
2607
2608 PG_RETURN_BOOL(float8_cmp_internal(arg1, arg2) == 0);
2609 }
2610
2611 Datum
2612 float84ne(PG_FUNCTION_ARGS)
2613 {
2614 float8 arg1 = PG_GETARG_FLOAT8(0);
2615 float4 arg2 = PG_GETARG_FLOAT4(1);
2616
2617 PG_RETURN_BOOL(float8_cmp_internal(arg1, arg2) != 0);
2618 }
2619
2620 Datum
2621 float84lt(PG_FUNCTION_ARGS)
2622 {
2623 float8 arg1 = PG_GETARG_FLOAT8(0);
2624 float4 arg2 = PG_GETARG_FLOAT4(1);
2625
2626 PG_RETURN_BOOL(float8_cmp_internal(arg1, arg2) < 0);
2627 }
2628
2629 Datum
2630 float84le(PG_FUNCTION_ARGS)
2631 {
2632 float8 arg1 = PG_GETARG_FLOAT8(0);
2633 float4 arg2 = PG_GETARG_FLOAT4(1);
2634
2635 PG_RETURN_BOOL(float8_cmp_internal(arg1, arg2) <= 0);
2636 }
2637
2638 Datum
2639 float84gt(PG_FUNCTION_ARGS)
2640 {
2641 float8 arg1 = PG_GETARG_FLOAT8(0);
2642 float4 arg2 = PG_GETARG_FLOAT4(1);
2643
2644 PG_RETURN_BOOL(float8_cmp_internal(arg1, arg2) > 0);
2645 }
2646
2647 Datum
2648 float84ge(PG_FUNCTION_ARGS)
2649 {
2650 float8 arg1 = PG_GETARG_FLOAT8(0);
2651 float4 arg2 = PG_GETARG_FLOAT4(1);
2652
2653 PG_RETURN_BOOL(float8_cmp_internal(arg1, arg2) >= 0);
2654 }
2655
2656 /*
2657 * Implements the float8 version of the width_bucket() function
2658 * defined by SQL2003. See also width_bucket_numeric().
2659 *
2660 * 'bound1' and 'bound2' are the lower and upper bounds of the
2661 * histogram's range, respectively. 'count' is the number of buckets
2662 * in the histogram. width_bucket() returns an integer indicating the
2663 * bucket number that 'operand' belongs to in an equiwidth histogram
2664 * with the specified characteristics. An operand smaller than the
2665 * lower bound is assigned to bucket 0. An operand greater than the
2666 * upper bound is assigned to an additional bucket (with number
2667 * count+1). We don't allow "NaN" for any of the float8 inputs, and we
2668 * don't allow either of the histogram bounds to be +/- infinity.
2669 */
2670 Datum
2671 width_bucket_float8(PG_FUNCTION_ARGS)
2672 {
2673 float8 operand = PG_GETARG_FLOAT8(0);
2674 float8 bound1 = PG_GETARG_FLOAT8(1);
2675 float8 bound2 = PG_GETARG_FLOAT8(2);
2676 int32 count = PG_GETARG_INT32(3);
2677 int32 result;
2678
2679 if (count <= 0.0)
2680 ereport(ERROR,
2681 (errcode(ERRCODE_INVALID_ARGUMENT_FOR_WIDTH_BUCKET_FUNCTION),
2682 errmsg("count must be greater than zero")));
2683
2684 if (isnan(operand) || isnan(bound1) || isnan(bound2))
2685 ereport(ERROR,
2686 (errcode(ERRCODE_INVALID_ARGUMENT_FOR_WIDTH_BUCKET_FUNCTION),
2687 errmsg("operand, lower bound and upper bound cannot be NaN")));
2688
2689 /* Note that we allow "operand" to be infinite */
2690 if (is_infinite(bound1) || is_infinite(bound2))
2691 ereport(ERROR,
2692 (errcode(ERRCODE_INVALID_ARGUMENT_FOR_WIDTH_BUCKET_FUNCTION),
2693 errmsg("lower and upper bounds must be finite")));
2694
2695 if (bound1 < bound2)
2696 {
2697 if (operand < bound1)
2698 result = 0;
2699 else if (operand >= bound2)
2700 {
2701 result = count + 1;
2702 /* check for overflow */
2703 if (result < count)
2704 ereport(ERROR,
2705 (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
2706 errmsg("integer out of range")));
2707 }
2708 else
2709 result = ((float8) count * (operand - bound1) / (bound2 - bound1)) + 1;
2710 }
2711 else if (bound1 > bound2)
2712 {
2713 if (operand > bound1)
2714 result = 0;
2715 else if (operand <= bound2)
2716 {
2717 result = count + 1;
2718 /* check for overflow */
2719 if (result < count)
2720 ereport(ERROR,
2721 (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
2722 errmsg("integer out of range")));
2723 }
2724 else
2725 result = ((float8) count * (bound1 - operand) / (bound1 - bound2)) + 1;
2726 }
2727 else
2728 {
2729 ereport(ERROR,
2730 (errcode(ERRCODE_INVALID_ARGUMENT_FOR_WIDTH_BUCKET_FUNCTION),
2731 errmsg("lower bound cannot equal upper bound")));
2732 result = 0; /* keep the compiler quiet */
2733 }
2734
2735 PG_RETURN_INT32(result);
2736 }
2737
2738 /* ========== PRIVATE ROUTINES ========== */
2739
2740 #ifndef HAVE_CBRT
2741
2742 static double
2743 cbrt(double x)
2744 {
2745 int isneg = (x < 0.0);
2746 double absx = fabs(x);
2747 double tmpres = pow(absx, (double) 1.0 / (double) 3.0);
2748
2749 /*
2750 * The result is somewhat inaccurate --- not really pow()'s fault, as the
2751 * exponent it's handed contains roundoff error. We can improve the
2752 * accuracy by doing one iteration of Newton's formula. Beware of zero
2753 * input however.
2754 */
2755 if (tmpres > 0.0)
2756 tmpres -= (tmpres - absx / (tmpres * tmpres)) / (double) 3.0;
2757
2758 return isneg ? -tmpres : tmpres;
2759 }
2760
2761 #endif /* !HAVE_CBRT */
PostgreSQL from CVS