Return to tst-addsub.c CVS log

Up to [local] / OpenXM_contrib / gmp / mpn / tests

Annotation of OpenXM_contrib/gmp/mpn/tests/tst-addsub.c, Revision 1.1

1.1     ! maekawa     1: #include <stdio.h>
        !             2: #include <stdlib.h>
        !             3: #include "gmp.h"
        !             4: #include "gmp-impl.h"
        !             5:
        !             6: #define ADD 1
        !             7: #define SUB 2
        !             8:
        !             9: #ifndef METHOD
        !            10: #define METHOD ADD
        !            11: #endif
        !            12:
        !            13: #if METHOD == ADD
        !            14: #define REFCALL refmpn_add_n
        !            15: #define TESTCALL mpn_add_n
        !            16: #endif
        !            17:
        !            18: #if METHOD == SUB
        !            19: #define REFCALL refmpn_sub_n
        !            20: #define TESTCALL mpn_sub_n
        !            21: #endif
        !            22:
        !            23: mp_limb_t refmpn_add_n ();
        !            24: mp_limb_t refmpn_sub_n ();
        !            25:
        !            26: #define SIZE 100
        !            27:
        !            28: main (argc, argv)
        !            29:      int argc;
        !            30:      char **argv;
        !            31: {
        !            32:   mp_size_t alloc_size, max_size, size, i, cumul_size;
        !            33:   mp_ptr s1, s2, dx, dy;
        !            34:   int s1_align, s2_align, d_align;
        !            35:   long pass, n_passes;
        !            36:   mp_limb_t cx, cy;
        !            37:
        !            38:   max_size = SIZE;
        !            39:   n_passes = 1000000;
        !            40:
        !            41:   argc--; argv++;
        !            42:   if (argc)
        !            43:     {
        !            44:       max_size = atol (*argv);
        !            45:       argc--; argv++;
        !            46:     }
        !            47:
        !            48:   alloc_size = max_size + 32;
        !            49:   s1 = malloc (alloc_size * BYTES_PER_MP_LIMB);
        !            50:   s2 = malloc (alloc_size * BYTES_PER_MP_LIMB);
        !            51:   dx = malloc (alloc_size * BYTES_PER_MP_LIMB);
        !            52:   dy = malloc (alloc_size * BYTES_PER_MP_LIMB);
        !            53:
        !            54:   cumul_size = 0;
        !            55:   for (pass = 0; pass < n_passes; pass++)
        !            56:     {
        !            57:       cumul_size += size;
        !            58:       if (cumul_size >= 1000000)
        !            59:        {
        !            60:          cumul_size -= 1000000;
        !            61:          printf ("%d ", pass); fflush (stdout);
        !            62:        }
        !            63:       s1_align = random () % 32;
        !            64:       s2_align = random () % 32;
        !            65:       d_align = random () % 32;
        !            66:
        !            67:       size = random () % max_size + 1;
        !            68:
        !            69:       mpn_random2 (s1 + s1_align, size);
        !            70:       mpn_random2 (s2 + s2_align, size);
        !            71:
        !            72:       for (i = 0; i < alloc_size; i++)
        !            73:        dx[i] = dy[i] = i + 0x9876500;
        !            74:
        !            75:       cx = TESTCALL (dx + d_align, s1 + s1_align, s2 + s2_align, size);
        !            76:       cy = REFCALL (dy + d_align, s1 + s1_align, s2 + s2_align, size);
        !            77:
        !            78:       if (cx != cy || mpn_cmp (dx, dy, alloc_size) != 0)
        !            79:        abort ();
        !            80:     }
        !            81:
        !            82:   printf ("%d passes OK\n", n_passes);
        !            83:   exit (0);
        !            84: }
        !            85:
        !            86: mp_limb_t
        !            87: #if __STDC__
        !            88: refmpn_add_n (mp_ptr res_ptr,
        !            89:              mp_srcptr s1_ptr, mp_srcptr s2_ptr, mp_size_t size)
        !            90: #else
        !            91: refmpn_add_n (res_ptr, s1_ptr, s2_ptr, size)
        !            92:      register mp_ptr res_ptr;
        !            93:      register mp_srcptr s1_ptr;
        !            94:      register mp_srcptr s2_ptr;
        !            95:      mp_size_t size;
        !            96: #endif
        !            97: {
        !            98:   register mp_limb_t x, y, cy;
        !            99:   register mp_size_t j;
        !           100:
        !           101:   /* The loop counter and index J goes from -SIZE to -1.  This way
        !           102:      the loop becomes faster.  */
        !           103:   j = -size;
        !           104:
        !           105:   /* Offset the base pointers to compensate for the negative indices.  */
        !           106:   s1_ptr -= j;
        !           107:   s2_ptr -= j;
        !           108:   res_ptr -= j;
        !           109:
        !           110:   cy = 0;
        !           111:   do
        !           112:     {
        !           113:       y = s2_ptr[j];
        !           114:       x = s1_ptr[j];
        !           115:       y += cy;                 /* add previous carry to one addend */
        !           116:       cy = (y < cy);           /* get out carry from that addition */
        !           117:       y = x + y;               /* add other addend */
        !           118:       cy = (y < x) + cy;       /* get out carry from that add, combine */
        !           119:       res_ptr[j] = y;
        !           120:     }
        !           121:   while (++j != 0);
        !           122:
        !           123:   return cy;
        !           124: }
        !           125:
        !           126: mp_limb_t
        !           127: #if __STDC__
        !           128: refmpn_sub_n (mp_ptr res_ptr,
        !           129:               mp_srcptr s1_ptr, mp_srcptr s2_ptr, mp_size_t size)
        !           130: #else
        !           131: refmpn_sub_n (res_ptr, s1_ptr, s2_ptr, size)
        !           132:      register mp_ptr res_ptr;
        !           133:      register mp_srcptr s1_ptr;
        !           134:      register mp_srcptr s2_ptr;
        !           135:      mp_size_t size;
        !           136: #endif
        !           137: {
        !           138:   register mp_limb_t x, y, cy;
        !           139:   register mp_size_t j;
        !           140:
        !           141:   /* The loop counter and index J goes from -SIZE to -1.  This way
        !           142:      the loop becomes faster.  */
        !           143:   j = -size;
        !           144:
        !           145:   /* Offset the base pointers to compensate for the negative indices.  */
        !           146:   s1_ptr -= j;
        !           147:   s2_ptr -= j;
        !           148:   res_ptr -= j;
        !           149:
        !           150:   cy = 0;
        !           151:   do
        !           152:     {
        !           153:       y = s2_ptr[j];
        !           154:       x = s1_ptr[j];
        !           155:       y += cy;                 /* add previous carry to subtrahend */
        !           156:       cy = (y < cy);           /* get out carry from that addition */
        !           157:       y = x - y;               /* main subtract */
        !           158:       cy = (y > x) + cy;       /* get out carry from the subtract, combine */
        !           159:       res_ptr[j] = y;
        !           160:     }
        !           161:   while (++j != 0);
        !           162:
        !           163:   return cy;
        !           164: }