granicus.if.org Git - postgresql/blob - src/backend/utils/adt/int.c

   1 /*-------------------------------------------------------------------------
   2  *
   3  * int.c
   4  *        Functions for the built-in integer types (except int8).
   5  *
   6  * Portions Copyright (c) 1996-2000, PostgreSQL, Inc
   7  * Portions Copyright (c) 1994, Regents of the University of California
   8  *
   9  *
  10  * IDENTIFICATION
  11  *        $Header: /cvsroot/pgsql/src/backend/utils/adt/int.c,v 1.38 2000/06/14 18:17:44 petere Exp $
  12  *
  13  *-------------------------------------------------------------------------
  14  */
  15 /*
  16  * OLD COMMENTS
  17  *              I/O routines:
  18  *               int2in, int2out, int2vectorin, int2vectorout, int4in, int4out
  19  *              Conversion routines:
  20  *               itoi, int2_text, int4_text
  21  *              Boolean operators:
  22  *               inteq, intne, intlt, intle, intgt, intge
  23  *              Arithmetic operators:
  24  *               intpl, intmi, int4mul, intdiv
  25  *
  26  *              Arithmetic operators:
  27  *               intmod, int4fac
  28  */
  29
  30 #include <ctype.h>
  31
  32 #include "postgres.h"
  33
  34 #ifdef HAVE_LIMITS_H
  35 #include <limits.h>
  36 #endif
  37
  38 #include "utils/builtins.h"
  39
  40 #ifndef SHRT_MAX
  41 #define SHRT_MAX (0x7FFF)
  42 #endif
  43 #ifndef SHRT_MIN
  44 #define SHRT_MIN (-0x8000)
  45 #endif
  46
  47 /*****************************************************************************
  48  *       USER I/O ROUTINES                                                                                                               *
  49  *****************************************************************************/
  50
  51 /*
  52  *              int2in                  - converts "num" to short
  53  */
  54 Datum
  55 int2in(PG_FUNCTION_ARGS)
  56 {
  57         char       *num = PG_GETARG_CSTRING(0);
  58
  59         PG_RETURN_INT16(pg_atoi(num, sizeof(int16), '\0'));
  60 }
  61
  62 /*
  63  *              int2out                 - converts short to "num"
  64  */
  65 Datum
  66 int2out(PG_FUNCTION_ARGS)
  67 {
  68         int16           arg1 = PG_GETARG_INT16(0);
  69         char       *result = (char *) palloc(7); /* sign, 5 digits, '\0' */
  70
  71         itoa((int) arg1, result);
  72         PG_RETURN_CSTRING(result);
  73 }
  74
  75 /*
  76  *              int2vectorin                    - converts "num num ..." to internal form
  77  *
  78  *              Note: Fills any missing slots with zeroes.
  79  */
  80 Datum
  81 int2vectorin(PG_FUNCTION_ARGS)
  82 {
  83         char       *intString = PG_GETARG_CSTRING(0);
  84         int16      *result = (int16 *) palloc(sizeof(int16[INDEX_MAX_KEYS]));
  85         int                     slot;
  86
  87         for (slot = 0; *intString && slot < INDEX_MAX_KEYS; slot++)
  88         {
  89                 if (sscanf(intString, "%hd", &result[slot]) != 1)
  90                         break;
  91                 while (*intString && isspace((int) *intString))
  92                         intString++;
  93                 while (*intString && !isspace((int) *intString))
  94                         intString++;
  95         }
  96         while (*intString && isspace((int) *intString))
  97                 intString++;
  98         if (*intString)
  99                 elog(ERROR, "int2vector value has too many values");
 100         while (slot < INDEX_MAX_KEYS)
 101                 result[slot++] = 0;
 102
 103         PG_RETURN_POINTER(result);
 104 }
 105
 106 /*
 107  *              int2vectorout           - converts internal form to "num num ..."
 108  */
 109 Datum
 110 int2vectorout(PG_FUNCTION_ARGS)
 111 {
 112         int16      *int2Array = (int16 *) PG_GETARG_POINTER(0);
 113         int                     num,
 114                                 maxnum;
 115         char       *rp;
 116         char       *result;
 117
 118         /* find last non-zero value in vector */
 119         for (maxnum = INDEX_MAX_KEYS - 1; maxnum >= 0; maxnum--)
 120                 if (int2Array[maxnum] != 0)
 121                         break;
 122
 123         /* assumes sign, 5 digits, ' ' */
 124         rp = result = (char *) palloc((maxnum + 1) * 7 + 1);
 125         for (num = 0; num <= maxnum; num++)
 126         {
 127                 if (num != 0)
 128                         *rp++ = ' ';
 129                 ltoa(int2Array[num], rp);
 130                 while (*++rp != '\0')
 131                         ;
 132         }
 133         *rp = '\0';
 134         PG_RETURN_CSTRING(result);
 135 }
 136
 137 /*
 138  * We don't have a complete set of int2vector support routines,
 139  * but we need int2vectoreq for catcache indexing.
 140  */
 141 Datum
 142 int2vectoreq(PG_FUNCTION_ARGS)
 143 {
 144         int16      *arg1 = (int16 *) PG_GETARG_POINTER(0);
 145         int16      *arg2 = (int16 *) PG_GETARG_POINTER(1);
 146
 147         PG_RETURN_BOOL(memcmp(arg1, arg2, INDEX_MAX_KEYS * sizeof(int16)) == 0);
 148 }
 149
 150 /*
 151  * Type int44 has no real-world use, but the regression tests use it.
 152  * It's a four-element vector of int4's.
 153  */
 154
 155 /*
 156  *              int44in                 - converts "num num ..." to internal form
 157  *
 158  *              Note: Fills any missing positions with zeroes.
 159  */
 160 Datum
 161 int44in(PG_FUNCTION_ARGS)
 162 {
 163         char       *input_string = PG_GETARG_CSTRING(0);
 164         int32      *result = (int32 *) palloc(4 * sizeof(int32));
 165         int                     i;
 166
 167         i = sscanf(input_string,
 168                            "%d, %d, %d, %d",
 169                            &result[0],
 170                            &result[1],
 171                            &result[2],
 172                            &result[3]);
 173         while (i < 4)
 174                 result[i++] = 0;
 175
 176         PG_RETURN_POINTER(result);
 177 }
 178
 179 /*
 180  *              int44out                - converts internal form to "num num ..."
 181  */
 182 Datum
 183 int44out(PG_FUNCTION_ARGS)
 184 {
 185         int32      *an_array = (int32 *) PG_GETARG_POINTER(0);
 186         char       *result = (char *) palloc(16 * 4); /* Allow 14 digits + sign */
 187         int                     i;
 188         char       *walk;
 189
 190         walk = result;
 191         for (i = 0; i < 4; i++)
 192         {
 193                 itoa(an_array[i], walk);
 194                 while (*++walk != '\0')
 195                         ;
 196                 *walk++ = ' ';
 197         }
 198         *--walk = '\0';
 199         PG_RETURN_CSTRING(result);
 200 }
 201
 202
 203 /*****************************************************************************
 204  *       PUBLIC ROUTINES                                                                                                                 *
 205  *****************************************************************************/
 206
 207 /*
 208  *              int4in                  - converts "num" to int4
 209  */
 210 Datum
 211 int4in(PG_FUNCTION_ARGS)
 212 {
 213         char       *num = PG_GETARG_CSTRING(0);
 214
 215         PG_RETURN_INT32(pg_atoi(num, sizeof(int32), '\0'));
 216 }
 217
 218 /*
 219  *              int4out                 - converts int4 to "num"
 220  */
 221 Datum
 222 int4out(PG_FUNCTION_ARGS)
 223 {
 224         int32           arg1 = PG_GETARG_INT32(0);
 225         char       *result = (char *) palloc(12); /* sign, 10 digits, '\0' */
 226
 227         ltoa(arg1, result);
 228         PG_RETURN_CSTRING(result);
 229 }
 230
 231
 232 /*
 233  *              ===================
 234  *              CONVERSION ROUTINES
 235  *              ===================
 236  */
 237
 238 Datum
 239 i2toi4(PG_FUNCTION_ARGS)
 240 {
 241         int16           arg1 = PG_GETARG_INT16(0);
 242
 243         PG_RETURN_INT32((int32) arg1);
 244 }
 245
 246 Datum
 247 i4toi2(PG_FUNCTION_ARGS)
 248 {
 249         int32           arg1 = PG_GETARG_INT32(0);
 250
 251         if (arg1 < SHRT_MIN)
 252                 elog(ERROR, "i4toi2: '%d' causes int2 underflow", arg1);
 253         if (arg1 > SHRT_MAX)
 254                 elog(ERROR, "i4toi2: '%d' causes int2 overflow", arg1);
 255
 256         PG_RETURN_INT16((int16) arg1);
 257 }
 258
 259 Datum
 260 int2_text(PG_FUNCTION_ARGS)
 261 {
 262         int16           arg1 = PG_GETARG_INT16(0);
 263         text       *result = (text *) palloc(7+VARHDRSZ); /* sign,5 digits, '\0' */
 264
 265         itoa((int) arg1, VARDATA(result));
 266         VARSIZE(result) = strlen(VARDATA(result)) + VARHDRSZ;
 267         PG_RETURN_TEXT_P(result);
 268 }
 269
 270 Datum
 271 text_int2(PG_FUNCTION_ARGS)
 272 {
 273         text       *string = PG_GETARG_TEXT_P(0);
 274         Datum           result;
 275         int                     len;
 276         char       *str;
 277
 278         len = VARSIZE(string) - VARHDRSZ;
 279
 280         str = palloc(len + 1);
 281         memcpy(str, VARDATA(string), len);
 282         *(str + len) = '\0';
 283
 284         result = DirectFunctionCall1(int2in, CStringGetDatum(str));
 285         pfree(str);
 286
 287         return result;
 288 }
 289
 290 Datum
 291 int4_text(PG_FUNCTION_ARGS)
 292 {
 293         int32           arg1 = PG_GETARG_INT32(0);
 294         text       *result = (text *) palloc(12+VARHDRSZ); /* sign,10 digits,'\0' */
 295
 296         ltoa(arg1, VARDATA(result));
 297         VARSIZE(result) = strlen(VARDATA(result)) + VARHDRSZ;
 298         PG_RETURN_TEXT_P(result);
 299 }
 300
 301 Datum
 302 text_int4(PG_FUNCTION_ARGS)
 303 {
 304         text       *string = PG_GETARG_TEXT_P(0);
 305         Datum           result;
 306         int                     len;
 307         char       *str;
 308
 309         len = VARSIZE(string) - VARHDRSZ;
 310
 311         str = palloc(len + 1);
 312         memcpy(str, VARDATA(string), len);
 313         *(str + len) = '\0';
 314
 315         result = DirectFunctionCall1(int4in, CStringGetDatum(str));
 316         pfree(str);
 317
 318         return result;
 319 }
 320
 321
 322 /*
 323  *              ============================
 324  *              COMPARISON OPERATOR ROUTINES
 325  *              ============================
 326  */
 327
 328 /*
 329  *              inteq                   - returns 1 iff arg1 == arg2
 330  *              intne                   - returns 1 iff arg1 != arg2
 331  *              intlt                   - returns 1 iff arg1 < arg2
 332  *              intle                   - returns 1 iff arg1 <= arg2
 333  *              intgt                   - returns 1 iff arg1 > arg2
 334  *              intge                   - returns 1 iff arg1 >= arg2
 335  */
 336
 337 Datum
 338 int4eq(PG_FUNCTION_ARGS)
 339 {
 340         int32           arg1 = PG_GETARG_INT32(0);
 341         int32           arg2 = PG_GETARG_INT32(1);
 342
 343         PG_RETURN_BOOL(arg1 == arg2);
 344 }
 345
 346 Datum
 347 int4ne(PG_FUNCTION_ARGS)
 348 {
 349         int32           arg1 = PG_GETARG_INT32(0);
 350         int32           arg2 = PG_GETARG_INT32(1);
 351
 352         PG_RETURN_BOOL(arg1 != arg2);
 353 }
 354
 355 Datum
 356 int4lt(PG_FUNCTION_ARGS)
 357 {
 358         int32           arg1 = PG_GETARG_INT32(0);
 359         int32           arg2 = PG_GETARG_INT32(1);
 360
 361         PG_RETURN_BOOL(arg1 < arg2);
 362 }
 363
 364 Datum
 365 int4le(PG_FUNCTION_ARGS)
 366 {
 367         int32           arg1 = PG_GETARG_INT32(0);
 368         int32           arg2 = PG_GETARG_INT32(1);
 369
 370         PG_RETURN_BOOL(arg1 <= arg2);
 371 }
 372
 373 Datum
 374 int4gt(PG_FUNCTION_ARGS)
 375 {
 376         int32           arg1 = PG_GETARG_INT32(0);
 377         int32           arg2 = PG_GETARG_INT32(1);
 378
 379         PG_RETURN_BOOL(arg1 > arg2);
 380 }
 381
 382 Datum
 383 int4ge(PG_FUNCTION_ARGS)
 384 {
 385         int32           arg1 = PG_GETARG_INT32(0);
 386         int32           arg2 = PG_GETARG_INT32(1);
 387
 388         PG_RETURN_BOOL(arg1 >= arg2);
 389 }
 390
 391 Datum
 392 int2eq(PG_FUNCTION_ARGS)
 393 {
 394         int16           arg1 = PG_GETARG_INT16(0);
 395         int16           arg2 = PG_GETARG_INT16(1);
 396
 397         PG_RETURN_BOOL(arg1 == arg2);
 398 }
 399
 400 Datum
 401 int2ne(PG_FUNCTION_ARGS)
 402 {
 403         int16           arg1 = PG_GETARG_INT16(0);
 404         int16           arg2 = PG_GETARG_INT16(1);
 405
 406         PG_RETURN_BOOL(arg1 != arg2);
 407 }
 408
 409 Datum
 410 int2lt(PG_FUNCTION_ARGS)
 411 {
 412         int16           arg1 = PG_GETARG_INT16(0);
 413         int16           arg2 = PG_GETARG_INT16(1);
 414
 415         PG_RETURN_BOOL(arg1 < arg2);
 416 }
 417
 418 Datum
 419 int2le(PG_FUNCTION_ARGS)
 420 {
 421         int16           arg1 = PG_GETARG_INT16(0);
 422         int16           arg2 = PG_GETARG_INT16(1);
 423
 424         PG_RETURN_BOOL(arg1 <= arg2);
 425 }
 426
 427 Datum
 428 int2gt(PG_FUNCTION_ARGS)
 429 {
 430         int16           arg1 = PG_GETARG_INT16(0);
 431         int16           arg2 = PG_GETARG_INT16(1);
 432
 433         PG_RETURN_BOOL(arg1 > arg2);
 434 }
 435
 436 Datum
 437 int2ge(PG_FUNCTION_ARGS)
 438 {
 439         int16           arg1 = PG_GETARG_INT16(0);
 440         int16           arg2 = PG_GETARG_INT16(1);
 441
 442         PG_RETURN_BOOL(arg1 >= arg2);
 443 }
 444
 445 Datum
 446 int24eq(PG_FUNCTION_ARGS)
 447 {
 448         int16           arg1 = PG_GETARG_INT16(0);
 449         int32           arg2 = PG_GETARG_INT32(1);
 450
 451         PG_RETURN_BOOL(arg1 == arg2);
 452 }
 453
 454 Datum
 455 int24ne(PG_FUNCTION_ARGS)
 456 {
 457         int16           arg1 = PG_GETARG_INT16(0);
 458         int32           arg2 = PG_GETARG_INT32(1);
 459
 460         PG_RETURN_BOOL(arg1 != arg2);
 461 }
 462
 463 Datum
 464 int24lt(PG_FUNCTION_ARGS)
 465 {
 466         int16           arg1 = PG_GETARG_INT16(0);
 467         int32           arg2 = PG_GETARG_INT32(1);
 468
 469         PG_RETURN_BOOL(arg1 < arg2);
 470 }
 471
 472 Datum
 473 int24le(PG_FUNCTION_ARGS)
 474 {
 475         int16           arg1 = PG_GETARG_INT16(0);
 476         int32           arg2 = PG_GETARG_INT32(1);
 477
 478         PG_RETURN_BOOL(arg1 <= arg2);
 479 }
 480
 481 Datum
 482 int24gt(PG_FUNCTION_ARGS)
 483 {
 484         int16           arg1 = PG_GETARG_INT16(0);
 485         int32           arg2 = PG_GETARG_INT32(1);
 486
 487         PG_RETURN_BOOL(arg1 > arg2);
 488 }
 489
 490 Datum
 491 int24ge(PG_FUNCTION_ARGS)
 492 {
 493         int16           arg1 = PG_GETARG_INT16(0);
 494         int32           arg2 = PG_GETARG_INT32(1);
 495
 496         PG_RETURN_BOOL(arg1 >= arg2);
 497 }
 498
 499 Datum
 500 int42eq(PG_FUNCTION_ARGS)
 501 {
 502         int32           arg1 = PG_GETARG_INT32(0);
 503         int16           arg2 = PG_GETARG_INT16(1);
 504
 505         PG_RETURN_BOOL(arg1 == arg2);
 506 }
 507
 508 Datum
 509 int42ne(PG_FUNCTION_ARGS)
 510 {
 511         int32           arg1 = PG_GETARG_INT32(0);
 512         int16           arg2 = PG_GETARG_INT16(1);
 513
 514         PG_RETURN_BOOL(arg1 != arg2);
 515 }
 516
 517 Datum
 518 int42lt(PG_FUNCTION_ARGS)
 519 {
 520         int32           arg1 = PG_GETARG_INT32(0);
 521         int16           arg2 = PG_GETARG_INT16(1);
 522
 523         PG_RETURN_BOOL(arg1 < arg2);
 524 }
 525
 526 Datum
 527 int42le(PG_FUNCTION_ARGS)
 528 {
 529         int32           arg1 = PG_GETARG_INT32(0);
 530         int16           arg2 = PG_GETARG_INT16(1);
 531
 532         PG_RETURN_BOOL(arg1 <= arg2);
 533 }
 534
 535 Datum
 536 int42gt(PG_FUNCTION_ARGS)
 537 {
 538         int32           arg1 = PG_GETARG_INT32(0);
 539         int16           arg2 = PG_GETARG_INT16(1);
 540
 541         PG_RETURN_BOOL(arg1 > arg2);
 542 }
 543
 544 Datum
 545 int42ge(PG_FUNCTION_ARGS)
 546 {
 547         int32           arg1 = PG_GETARG_INT32(0);
 548         int16           arg2 = PG_GETARG_INT16(1);
 549
 550         PG_RETURN_BOOL(arg1 >= arg2);
 551 }
 552
 553 /*
 554  *              int[24]pl               - returns arg1 + arg2
 555  *              int[24]mi               - returns arg1 - arg2
 556  *              int[24]mul              - returns arg1 * arg2
 557  *              int[24]div              - returns arg1 / arg2
 558  */
 559
 560 Datum
 561 int4um(PG_FUNCTION_ARGS)
 562 {
 563         int32           arg = PG_GETARG_INT32(0);
 564
 565         PG_RETURN_INT32(-arg);
 566 }
 567
 568 Datum
 569 int4pl(PG_FUNCTION_ARGS)
 570 {
 571         int32           arg1 = PG_GETARG_INT32(0);
 572         int32           arg2 = PG_GETARG_INT32(1);
 573
 574         PG_RETURN_INT32(arg1 + arg2);
 575 }
 576
 577 Datum
 578 int4mi(PG_FUNCTION_ARGS)
 579 {
 580         int32           arg1 = PG_GETARG_INT32(0);
 581         int32           arg2 = PG_GETARG_INT32(1);
 582
 583         PG_RETURN_INT32(arg1 - arg2);
 584 }
 585
 586 Datum
 587 int4mul(PG_FUNCTION_ARGS)
 588 {
 589         int32           arg1 = PG_GETARG_INT32(0);
 590         int32           arg2 = PG_GETARG_INT32(1);
 591
 592         PG_RETURN_INT32(arg1 * arg2);
 593 }
 594
 595 Datum
 596 int4div(PG_FUNCTION_ARGS)
 597 {
 598         int32           arg1 = PG_GETARG_INT32(0);
 599         int32           arg2 = PG_GETARG_INT32(1);
 600
 601         PG_RETURN_INT32(arg1 / arg2);
 602 }
 603
 604 Datum
 605 int4inc(PG_FUNCTION_ARGS)
 606 {
 607         int32           arg = PG_GETARG_INT32(0);
 608
 609         PG_RETURN_INT32(arg + 1);
 610 }
 611
 612 Datum
 613 int2um(PG_FUNCTION_ARGS)
 614 {
 615         int16           arg = PG_GETARG_INT16(0);
 616
 617         PG_RETURN_INT16(-arg);
 618 }
 619
 620 Datum
 621 int2pl(PG_FUNCTION_ARGS)
 622 {
 623         int16           arg1 = PG_GETARG_INT16(0);
 624         int16           arg2 = PG_GETARG_INT16(1);
 625
 626         PG_RETURN_INT16(arg1 + arg2);
 627 }
 628
 629 Datum
 630 int2mi(PG_FUNCTION_ARGS)
 631 {
 632         int16           arg1 = PG_GETARG_INT16(0);
 633         int16           arg2 = PG_GETARG_INT16(1);
 634
 635         PG_RETURN_INT16(arg1 - arg2);
 636 }
 637
 638 Datum
 639 int2mul(PG_FUNCTION_ARGS)
 640 {
 641         int16           arg1 = PG_GETARG_INT16(0);
 642         int16           arg2 = PG_GETARG_INT16(1);
 643
 644         PG_RETURN_INT16(arg1 * arg2);
 645 }
 646
 647 Datum
 648 int2div(PG_FUNCTION_ARGS)
 649 {
 650         int16           arg1 = PG_GETARG_INT16(0);
 651         int16           arg2 = PG_GETARG_INT16(1);
 652
 653         PG_RETURN_INT16(arg1 / arg2);
 654 }
 655
 656 Datum
 657 int2inc(PG_FUNCTION_ARGS)
 658 {
 659         int16           arg = PG_GETARG_INT16(0);
 660
 661         PG_RETURN_INT16(arg + 1);
 662 }
 663
 664 Datum
 665 int24pl(PG_FUNCTION_ARGS)
 666 {
 667         int16           arg1 = PG_GETARG_INT16(0);
 668         int32           arg2 = PG_GETARG_INT32(1);
 669
 670         PG_RETURN_INT32(arg1 + arg2);
 671 }
 672
 673 Datum
 674 int24mi(PG_FUNCTION_ARGS)
 675 {
 676         int16           arg1 = PG_GETARG_INT16(0);
 677         int32           arg2 = PG_GETARG_INT32(1);
 678
 679         PG_RETURN_INT32(arg1 - arg2);
 680 }
 681
 682 Datum
 683 int24mul(PG_FUNCTION_ARGS)
 684 {
 685         int16           arg1 = PG_GETARG_INT16(0);
 686         int32           arg2 = PG_GETARG_INT32(1);
 687
 688         PG_RETURN_INT32(arg1 * arg2);
 689 }
 690
 691 Datum
 692 int24div(PG_FUNCTION_ARGS)
 693 {
 694         int16           arg1 = PG_GETARG_INT16(0);
 695         int32           arg2 = PG_GETARG_INT32(1);
 696
 697         PG_RETURN_INT32(arg1 / arg2);
 698 }
 699
 700 Datum
 701 int42pl(PG_FUNCTION_ARGS)
 702 {
 703         int32           arg1 = PG_GETARG_INT32(0);
 704         int16           arg2 = PG_GETARG_INT16(1);
 705
 706         PG_RETURN_INT32(arg1 + arg2);
 707 }
 708
 709 Datum
 710 int42mi(PG_FUNCTION_ARGS)
 711 {
 712         int32           arg1 = PG_GETARG_INT32(0);
 713         int16           arg2 = PG_GETARG_INT16(1);
 714
 715         PG_RETURN_INT32(arg1 - arg2);
 716 }
 717
 718 Datum
 719 int42mul(PG_FUNCTION_ARGS)
 720 {
 721         int32           arg1 = PG_GETARG_INT32(0);
 722         int16           arg2 = PG_GETARG_INT16(1);
 723
 724         PG_RETURN_INT32(arg1 * arg2);
 725 }
 726
 727 Datum
 728 int42div(PG_FUNCTION_ARGS)
 729 {
 730         int32           arg1 = PG_GETARG_INT32(0);
 731         int16           arg2 = PG_GETARG_INT16(1);
 732
 733         PG_RETURN_INT32(arg1 / arg2);
 734 }
 735
 736 Datum
 737 int4mod(PG_FUNCTION_ARGS)
 738 {
 739         int32           arg1 = PG_GETARG_INT32(0);
 740         int32           arg2 = PG_GETARG_INT32(1);
 741
 742         PG_RETURN_INT32(arg1 % arg2);
 743 }
 744
 745 Datum
 746 int2mod(PG_FUNCTION_ARGS)
 747 {
 748         int16           arg1 = PG_GETARG_INT16(0);
 749         int16           arg2 = PG_GETARG_INT16(1);
 750
 751         PG_RETURN_INT16(arg1 % arg2);
 752 }
 753
 754 Datum
 755 int24mod(PG_FUNCTION_ARGS)
 756 {
 757         int16           arg1 = PG_GETARG_INT16(0);
 758         int32           arg2 = PG_GETARG_INT32(1);
 759
 760         PG_RETURN_INT32(arg1 % arg2);
 761 }
 762
 763 Datum
 764 int42mod(PG_FUNCTION_ARGS)
 765 {
 766         int32           arg1 = PG_GETARG_INT32(0);
 767         int16           arg2 = PG_GETARG_INT16(1);
 768
 769         PG_RETURN_INT32(arg1 % arg2);
 770 }
 771
 772 /* int[24]fac()
 773  * Factorial
 774  */
 775 Datum
 776 int4fac(PG_FUNCTION_ARGS)
 777 {
 778         int32           arg1 = PG_GETARG_INT32(0);
 779         int32           result;
 780
 781         if (arg1 < 1)
 782                 result = 0;
 783         else
 784                 for (result = 1; arg1 > 0; --arg1)
 785                         result *= arg1;
 786         PG_RETURN_INT32(result);
 787 }
 788
 789 Datum
 790 int2fac(PG_FUNCTION_ARGS)
 791 {
 792         int16           arg1 = PG_GETARG_INT16(0);
 793         int32           result;
 794
 795         if (arg1 < 1)
 796                 result = 0;
 797         else
 798                 for (result = 1; arg1 > 0; --arg1)
 799                         result *= arg1;
 800         PG_RETURN_INT32(result);
 801 }
 802
 803 /* int[24]abs()
 804  * Absolute value
 805  */
 806 Datum
 807 int4abs(PG_FUNCTION_ARGS)
 808 {
 809         int32           arg1 = PG_GETARG_INT32(0);
 810
 811         PG_RETURN_INT32((arg1 < 0) ? -arg1 : arg1);
 812 }
 813
 814 Datum
 815 int2abs(PG_FUNCTION_ARGS)
 816 {
 817         int16           arg1 = PG_GETARG_INT16(0);
 818
 819         PG_RETURN_INT16((arg1 < 0) ? -arg1 : arg1);
 820 }
 821
 822 Datum
 823 int2larger(PG_FUNCTION_ARGS)
 824 {
 825         int16           arg1 = PG_GETARG_INT16(0);
 826         int16           arg2 = PG_GETARG_INT16(1);
 827
 828         PG_RETURN_INT16((arg1 > arg2) ? arg1 : arg2);
 829 }
 830
 831 Datum
 832 int2smaller(PG_FUNCTION_ARGS)
 833 {
 834         int16           arg1 = PG_GETARG_INT16(0);
 835         int16           arg2 = PG_GETARG_INT16(1);
 836
 837         PG_RETURN_INT16((arg1 < arg2) ? arg1 : arg2);
 838 }
 839
 840 Datum
 841 int4larger(PG_FUNCTION_ARGS)
 842 {
 843         int32           arg1 = PG_GETARG_INT32(0);
 844         int32           arg2 = PG_GETARG_INT32(1);
 845
 846         PG_RETURN_INT32((arg1 > arg2) ? arg1 : arg2);
 847 }
 848
 849 Datum
 850 int4smaller(PG_FUNCTION_ARGS)
 851 {
 852         int32           arg1 = PG_GETARG_INT32(0);
 853         int32           arg2 = PG_GETARG_INT32(1);
 854
 855         PG_RETURN_INT32((arg1 < arg2) ? arg1 : arg2);
 856 }