home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Professional / OS2PRO194.ISO / os2 / prgramer / adaptor / dalib / pvm3 / cshift0.c < prev    next >
Text File  |  1993-11-30  |  12KB  |  377 lines
  1. /**************************************************************************
  2. *                                                                         *
  3. *  Author      : Dr. Thomas Brandes, GMD, I1.HR                           *
  4. *  Copyright   : GMD St. Augustin, Germany                                *
  5. *  Date        : Apr 93                                                   *
  6. *  Last Update : Apr 93                                                   *
  7. *                                                                         *
  8. *  This Module is part of the DALIB, UNILIB, HOSTLIB                      *
  9. *                                                                         *
  10. *  Module      : cshift0.c                                                *
  11. *                                                                         *
  12. *  Function    : local circular shifting of full arrays                   *
  13. *                (no communication required for local arrays)             *
  14. *                                                                         *
  15. *  Export : FORTRAN Interface                                             *
  16. *                                                                         *
  17. **************************************************************************/
  18.  
  19. /*******************************************************************
  20. *                                                                  *
  21. *  update position that  -n/2 <= pos <= n/2                        *
  22. *                                                                  *
  23. *******************************************************************/
  24.  
  25. void update_pos (pos, n)
  26. int *pos, n;
  27.  
  28. { int n2;
  29.   n2 = (n+1) / 2;
  30.   while (*pos >  n2) *pos -= n;
  31.   while (*pos < -n2) *pos += n;
  32. }
  33.  
  34. /*******************************************************************
  35. *                                                                  *
  36. *  SHIFT UP   (local operation, no communication)                  *
  37. *                                                                  *
  38. *  NAME (j,i) = NAME (j+pos,i)                                     *
  39. *                                                                  *
  40. *       -----------------------------------------------------      *
  41. * low1  |                 |                |                |      *
  42. *       |     /\          |                |                |      *
  43. *       |     ||          |                |                |      *
  44. *       |     ||          |                |                |      *
  45. *       |     ||          |                |                |      *
  46. * up1   |                 |                |                |      *
  47. *       -----------------------------------------------------      *
  48. *                                                                  *
  49. *        low2          up2                                         *
  50. *                                                                  *
  51. *   esize: bytes of one element                                    *
  52. *   nrow : (up1 - low1 + 1)                                        *
  53. *   ncol : (up2 - low2 + 1)                                        *
  54. *                                                                  *
  55. *******************************************************************/
  56.  
  57. void dalib_make_shift_up (dest, source, esize, nrow, pos, ncol)
  58. unsigned char *dest, *source;
  59. int esize, nrow, pos, ncol;
  60.  
  61. {  unsigned char *save, *source_ptr, *dest_ptr;
  62.    int pos_size, col_size, local_size, j;
  63.  
  64. #ifdef DEBUG
  65.    printf ("Proc %d calls make_shift_up, esize = %d, pos/rows = %d/%d\n",
  66.             pcb.i, esize, pos, nrow);
  67. #endif
  68.  
  69.    pos_size   = pos * esize;
  70.    col_size   = nrow * esize;
  71.    local_size = col_size - pos_size;
  72.  
  73.    /* save (1:pos) = source (low1:low1+pos-1) */
  74.  
  75.    source_ptr = source;
  76.    dest_ptr   = dest;
  77.    save       = (unsigned char*) (malloc (pos_size));
  78.  
  79.    for (j=1; j<=ncol; j++)
  80.  
  81.      { /* do it for every column */
  82.  
  83.        dalib_memcpy (save, source_ptr, pos_size);
  84.        /* save the first pos elements of the column to prevent overwrite */
  85.        dalib_memcpy (dest_ptr, source_ptr + pos_size, local_size);
  86.        dalib_memcpy (dest_ptr + local_size, save, pos_size);
  87.  
  88.        source_ptr += col_size;
  89.        dest_ptr   += col_size;
  90.      }
  91.  
  92.    free (save);
  93. }
  94.  
  95. /*******************************************************************
  96. *                                                                  *
  97. *  SHIFT DOWN (local operation, no communication)                  *
  98. *                                                                  *
  99. *  NAME (j,i) = NAME (j-pos,i)                                     *
  100. *                                                                  *
  101. *       -----------------------------------------------------      *
  102. * low1  |                 |                |                |      *
  103. *       |     ||          |                |                |      *
  104. *       |     ||          |                |                |      *
  105. *       |     ||          |                |                |      *
  106. *       |     \/          |                |                |      *
  107. * up1   |                 |                |                |      *
  108. *       -----------------------------------------------------      *
  109. *                                                                  *
  110. *        low2          up2                                         *
  111. *                                                                  *
  112. *   esize: bytes of one element                                    *
  113. *   nrow : (up1 - low1 + 1)                                        *
  114. *   ncol : (up2 - low2 + 1)                                        *
  115. *                                                                  *
  116. *******************************************************************/
  117.  
  118. void dalib_make_shift_down (dest, source, esize, nrow, pos, ncol)
  119. unsigned char *dest, *source;
  120. int esize, nrow, pos, ncol;
  121.  
  122. {  unsigned char *save, *source_ptr, *dest_ptr;
  123.    int pos_size, col_size, local_size, j;
  124.  
  125. #ifdef DEBUG
  126.    printf ("Proc %d calls make_shift_down, esize = %d, pos/rows = %d/%d\n",
  127.             pcb.i, esize, pos, nrow);
  128. #endif
  129.  
  130.    pos_size   = pos * esize;
  131.    col_size   = nrow * esize;
  132.    local_size = col_size - pos_size;
  133.  
  134.    /* save (1:pos) = source (low1:low1+pos-1) */
  135.  
  136.    source_ptr = source;
  137.    dest_ptr   = dest;
  138.    save       = (unsigned char*) (malloc (pos_size));
  139.  
  140.    for (j=1; j<=ncol; j++)
  141.  
  142.      { /* do it for every column */
  143.  
  144.        dalib_memcpy  (save, source_ptr + local_size, pos_size);
  145.        dalib_rmemcpy (dest_ptr + pos_size, source_ptr, local_size);
  146.        dalib_memcpy  (dest_ptr, save, pos_size);
  147.  
  148.        source_ptr += col_size;
  149.        dest_ptr   += col_size;
  150.      }
  151.  
  152.    free (save);
  153. }
  154.  
  155. /*******************************************************************
  156. *                                                                  *
  157. *  ONE DIMENSIONAL ARRAYS                                          *
  158. *                                                                  *
  159. *******************************************************************/
  160.  
  161. void dalib_lcshift1__ (dest, source, size, N1, dim, pos)
  162. unsigned char *dest, *source;
  163. int *size, *N1, *dim, *pos;
  164.  
  165. {  int hpos, nrow, ncol;
  166.    int msize;
  167.  
  168.    hpos = *pos;
  169.  
  170.    switch (*dim) {
  171.  
  172.    case 1 :
  173.  
  174.     update_pos (&hpos, *N1);
  175.     msize = *size;
  176.     nrow  = *N1;
  177.     ncol  = 1;
  178.  
  179.     break;
  180.  
  181.    default :
  182.  
  183.      printf ("DALIB: illegal dim (%d) in local cshift1\n", *dim);
  184.      exit (-1);
  185.  
  186.   } /* end switch */
  187.  
  188.   if (hpos > 0)
  189.      dalib_make_shift_up (dest, source, msize, nrow, hpos, ncol);
  190.    else if (hpos < 0)
  191.      dalib_make_shift_down (dest, source, msize, nrow, -hpos, ncol);
  192.    else if (dest != source)
  193.      dalib_memcpy (dest, source, msize*nrow*ncol);
  194.  
  195. } /* dalib_lcshift1 */
  196.  
  197. /*******************************************************************
  198. *                                                                  *
  199. *  TWO  DIMENSIONAL ARRAYS                                         *
  200. *                                                                  *
  201. *******************************************************************/
  202.  
  203. void dalib_lcshift2__ (dest, source, size, N1, N2, dim, pos)
  204. unsigned char *dest, *source;
  205. int *size, *N1, *N2, *dim, *pos;
  206.  
  207. {  int hpos, nrow, ncol;
  208.    int msize;
  209.  
  210.    hpos = *pos;
  211.  
  212.    switch (*dim) {
  213.  
  214.    case 1 :
  215.  
  216.     update_pos (&hpos, *N1);
  217.     msize = *size;
  218.     nrow  = *N1;
  219.     ncol  = *N2;
  220.  
  221.     break;
  222.  
  223.    case 2 :
  224.  
  225.     update_pos (&hpos, *N2);
  226.     msize = *size * *N1;
  227.     nrow  = *N2;
  228.     ncol  = 1;
  229.  
  230.     break;
  231.  
  232.    default :
  233.  
  234.      printf ("DALIB: illegal dim (%d) in local cshift3\n", *dim);
  235.      exit (-1);
  236.  
  237.   } /* end switch */
  238.  
  239.   if (hpos > 0)
  240.      dalib_make_shift_up (dest, source, msize, nrow, hpos, ncol);
  241.    else if (hpos < 0)
  242.      dalib_make_shift_down (dest, source, msize, nrow, -hpos, ncol);
  243.    else if (dest != source)
  244.      dalib_memcpy (dest, source, msize*nrow*ncol);
  245.  
  246. } /* dalib_lcshift2 */
  247.  
  248. /*******************************************************************
  249. *                                                                  *
  250. *  THREE DIMENSIONAL ARRAYS                                        *
  251. *                                                                  *
  252. *******************************************************************/
  253.  
  254. void dalib_lcshift3__ (dest, source, size, N1, N2, N3, dim, pos)
  255. unsigned char *dest, *source;
  256. int *size, *N1, *N2, *N3, *dim, *pos;
  257.  
  258. {  int hpos, nrow, ncol;
  259.    int msize;
  260.  
  261.    hpos = *pos;
  262.  
  263.    switch (*dim) {
  264.  
  265.    case 1 :
  266.  
  267.     update_pos (&hpos, *N1);
  268.     msize = *size;
  269.     nrow  = *N1;
  270.     ncol  = *N2 * *N3;
  271.  
  272.     break;
  273.  
  274.    case 2 :
  275.  
  276.     update_pos (&hpos, *N2);
  277.     msize = *size * *N1;
  278.     nrow  = *N2;
  279.     ncol  = *N3;
  280.  
  281.     break;
  282.  
  283.    case 3 :
  284.  
  285.     update_pos (&hpos, *N3);
  286.     msize = *size * *N1 * *N2;
  287.     nrow  = *N3;
  288.     ncol  = 1;
  289.  
  290.     break;
  291.  
  292.    default :
  293.  
  294.      printf ("DALIB: illegal dim (%d) in local cshift3\n", *dim);
  295.      exit (-1);
  296.  
  297.   } /* end switch */
  298.  
  299.   if (hpos > 0)
  300.      dalib_make_shift_up (dest, source, msize, nrow, hpos, ncol);
  301.    else if (hpos < 0)
  302.      dalib_make_shift_down (dest, source, msize, nrow, -hpos, ncol);
  303.    else if (dest != source)
  304.      dalib_memcpy (dest, source, msize*nrow*ncol);
  305.  
  306. } /* dalib_lcshift3 */
  307.  
  308. /*******************************************************************
  309. *                                                                  *
  310. *  FOUR  DIMENSIONAL ARRAYS                                        *
  311. *                                                                  *
  312. *******************************************************************/
  313.  
  314. void dalib_lcshift4__ (dest, source, size, N1, N2, N3, N4, dim, pos)
  315. unsigned char *dest, *source;
  316. int *size, *N1, *N2, *N3, *N4, *dim, *pos;
  317.  
  318. {  int hpos, nrow, ncol;
  319.    int msize;
  320.  
  321.    hpos = *pos;
  322.  
  323.    switch (*dim) {
  324.  
  325.    case 1 :
  326.  
  327.     update_pos (&hpos, *N1);
  328.     msize = *size;
  329.     nrow  = *N1;
  330.     ncol  = *N2 * *N3 * *N4;
  331.  
  332.     break;
  333.  
  334.    case 2 :
  335.  
  336.     update_pos (&hpos, *N2);
  337.     msize = *size * *N1;
  338.     nrow  = *N2;
  339.     ncol  = *N3 * *N4;
  340.  
  341.     break;
  342.  
  343.    case 3 :
  344.  
  345.     update_pos (&hpos, *N3);
  346.     msize = *size * *N1 * *N2;
  347.     nrow  = *N3;
  348.     ncol  = *N4;
  349.  
  350.     break;
  351.  
  352.    case 4 :
  353.  
  354.     update_pos (&hpos, *N4);
  355.     msize = *size * *N1 * *N2 * *N3;
  356.     nrow  = *N4;
  357.     ncol  = 1;
  358.  
  359.     break;
  360.  
  361.    default :
  362.  
  363.      printf ("DALIB: illegal dim (%d) in local cshift4\n", *dim);
  364.      exit (-1);
  365.  
  366.   } /* end switch */
  367.  
  368.   if (hpos > 0)
  369.      dalib_make_shift_up (dest, source, msize, nrow, hpos, ncol);
  370.    else if (hpos < 0)
  371.      dalib_make_shift_down (dest, source, msize, nrow, -hpos, ncol);
  372.    else if (dest != source)
  373.      dalib_memcpy (dest, source, msize*nrow*ncol);
  374.  
  375. } /* dalib_lcshift4 */
  376.  
  377.