impls/tfs/ivec.c

/**********************************ivec.c**************************************

Author: Henry M. Tufo III

e-mail: hmt@cs.brown.edu

snail-mail:
Division of Applied Mathematics
Brown University
Providence, RI 02912

Last Modification:
6.21.97
***********************************ivec.c*************************************/

#include <../src/ksp/pc/impls/tfs/tfs.h>

/* sorting args ivec.c ivec.c ... */
#define   SORT_OPT     6
#define   SORT_STACK   50000


/* allocate an address and size stack for sorter(s) */
static void *offset_stack[2*SORT_STACK];
static PetscInt   size_stack[SORT_STACK];

/***********************************ivec.c*************************************/
PetscInt *PCTFS_ivec_copy(PetscInt *arg1, PetscInt *arg2, PetscInt n)
{
  while (n--) { *arg1++ = *arg2++; }
  return(arg1);
}

/***********************************ivec.c*************************************/
PetscErrorCode PCTFS_ivec_zero(PetscInt *arg1, PetscInt n)
{
  PetscFunctionBegin;
  while (n--) { *arg1++ = 0; }
  PetscFunctionReturn(0);
}

/***********************************ivec.c*************************************/
PetscErrorCode PCTFS_ivec_set(PetscInt *arg1, PetscInt arg2, PetscInt n)
{
  PetscFunctionBegin;
  while (n--) { *arg1++ = arg2; }
  PetscFunctionReturn(0);
}

/***********************************ivec.c*************************************/
PetscErrorCode PCTFS_ivec_max(PetscInt *arg1, PetscInt *arg2, PetscInt n)
{
  PetscFunctionBegin;
  while (n--) { *arg1 = PetscMax(*arg1,*arg2); arg1++; arg2++; }
  PetscFunctionReturn(0);
}

/***********************************ivec.c*************************************/
PetscErrorCode PCTFS_ivec_min(PetscInt *arg1,  PetscInt *arg2,  PetscInt n)
{
  PetscFunctionBegin;
  while (n--) { *(arg1) = PetscMin(*arg1,*arg2); arg1++; arg2++; }
  PetscFunctionReturn(0);
}

/***********************************ivec.c*************************************/
PetscErrorCode PCTFS_ivec_mult(PetscInt *arg1,  PetscInt *arg2,  PetscInt n)
{
  PetscFunctionBegin;
  while (n--) { *arg1++ *= *arg2++; }
  PetscFunctionReturn(0);
}

/***********************************ivec.c*************************************/
PetscErrorCode PCTFS_ivec_add(PetscInt *arg1,  PetscInt *arg2,  PetscInt n)
{
  PetscFunctionBegin;
  while (n--) { *arg1++ += *arg2++; }
  PetscFunctionReturn(0);
}

/***********************************ivec.c*************************************/
PetscErrorCode PCTFS_ivec_lxor(PetscInt *arg1,  PetscInt *arg2,  PetscInt n)
{
  PetscFunctionBegin;
  while (n--) { *arg1=((*arg1 || *arg2) && !(*arg1 && *arg2)); arg1++; arg2++; }
  PetscFunctionReturn(0);
}

/***********************************ivec.c*************************************/
PetscErrorCode PCTFS_ivec_xor(PetscInt *arg1,  PetscInt *arg2,  PetscInt n)
{
  PetscFunctionBegin;
  while (n--) { *arg1++ ^= *arg2++; }
  PetscFunctionReturn(0);
}

/***********************************ivec.c*************************************/
PetscErrorCode PCTFS_ivec_or(PetscInt *arg1,  PetscInt *arg2,  PetscInt n)
{
  PetscFunctionBegin;
  while (n--) { *arg1++ |= *arg2++; }
  PetscFunctionReturn(0);
}

/***********************************ivec.c*************************************/
PetscErrorCode PCTFS_ivec_lor(PetscInt *arg1,  PetscInt *arg2,  PetscInt n)
{
  PetscFunctionBegin;
  while (n--) { *arg1 = (*arg1 || *arg2); arg1++; arg2++; }
  PetscFunctionReturn(0);
}

/***********************************ivec.c*************************************/
PetscErrorCode PCTFS_ivec_and(PetscInt *arg1,  PetscInt *arg2,  PetscInt n)
{
  PetscFunctionBegin;
  while (n--) { *arg1++ &= *arg2++; }
  PetscFunctionReturn(0);
}

/***********************************ivec.c*************************************/
PetscErrorCode PCTFS_ivec_land(PetscInt *arg1,  PetscInt *arg2,  PetscInt n)
{
  PetscFunctionBegin;
  while (n--) { *arg1 = (*arg1 && *arg2); arg1++; arg2++; }
  PetscFunctionReturn(0);
}

/***********************************ivec.c*************************************/
PetscErrorCode PCTFS_ivec_and3(PetscInt *arg1,  PetscInt *arg2,  PetscInt *arg3, PetscInt n)
{
  PetscFunctionBegin;
  while (n--) { *arg1++ = (*arg2++ & *arg3++); }
  PetscFunctionReturn(0);
}

/***********************************ivec.c*************************************/
PetscInt PCTFS_ivec_sum(PetscInt *arg1,  PetscInt n)
{
  PetscInt tmp = 0;

  while (n--) {tmp += *arg1++;}
  return(tmp);
}

/***********************************ivec.c*************************************/
PetscErrorCode PCTFS_ivec_non_uniform(PetscInt *arg1, PetscInt *arg2,  PetscInt n,  PetscInt *arg3)
{
  PetscInt i, j, type;


  PetscFunctionBegin;
  /* LATER: if we're really motivated we can sort and then unsort */
  for (i=0;i<n;) {
    /* clump 'em for now */
    j=i+1;
    type = arg3[i];
    while ((j<n)&&(arg3[j]==type)) { j++; }

    /* how many together */
    j -= i;

    /* call appropriate ivec function */
    if (type == GL_MAX)        { PCTFS_ivec_max(arg1,arg2,j); }
    else if (type == GL_MIN)   { PCTFS_ivec_min(arg1,arg2,j); }
    else if (type == GL_MULT)  { PCTFS_ivec_mult(arg1,arg2,j); }
    else if (type == GL_ADD)   { PCTFS_ivec_add(arg1,arg2,j); }
    else if (type == GL_B_XOR) { PCTFS_ivec_xor(arg1,arg2,j); }
    else if (type == GL_B_OR)  { PCTFS_ivec_or(arg1,arg2,j); }
    else if (type == GL_B_AND) { PCTFS_ivec_and(arg1,arg2,j); }
    else if (type == GL_L_XOR) { PCTFS_ivec_lxor(arg1,arg2,j); }
    else if (type == GL_L_OR)  { PCTFS_ivec_lor(arg1,arg2,j); }
    else if (type == GL_L_AND) { PCTFS_ivec_land(arg1,arg2,j); }
    else SETERRQ(PETSC_COMM_SELF,PETSC_ERR_PLIB,"unrecognized type passed to PCTFS_ivec_non_uniform()!");

    arg1+=j; arg2+=j; i+=j;
  }
  PetscFunctionReturn(0);
}

/***********************************ivec.c*************************************/
vfp PCTFS_ivec_fct_addr(PetscInt type)
{
  if (type == NON_UNIFORM)   { return((PetscErrorCode (*)(void*, void *, PetscInt, ...))&PCTFS_ivec_non_uniform); }
  else if (type == GL_MAX)   { return((PetscErrorCode (*)(void*, void *, PetscInt, ...))&PCTFS_ivec_max); }
  else if (type == GL_MIN)   { return((PetscErrorCode (*)(void*, void *, PetscInt, ...))&PCTFS_ivec_min); }
  else if (type == GL_MULT)  { return((PetscErrorCode (*)(void*, void *, PetscInt, ...))&PCTFS_ivec_mult); }
  else if (type == GL_ADD)   { return((PetscErrorCode (*)(void*, void *, PetscInt, ...))&PCTFS_ivec_add); }
  else if (type == GL_B_XOR) { return((PetscErrorCode (*)(void*, void *, PetscInt, ...))&PCTFS_ivec_xor); }
  else if (type == GL_B_OR)  { return((PetscErrorCode (*)(void*, void *, PetscInt, ...))&PCTFS_ivec_or); }
  else if (type == GL_B_AND) { return((PetscErrorCode (*)(void*, void *, PetscInt, ...))&PCTFS_ivec_and); }
  else if (type == GL_L_XOR) { return((PetscErrorCode (*)(void*, void *, PetscInt, ...))&PCTFS_ivec_lxor); }
  else if (type == GL_L_OR)  { return((PetscErrorCode (*)(void*, void *, PetscInt, ...))&PCTFS_ivec_lor); }
  else if (type == GL_L_AND) { return((PetscErrorCode (*)(void*, void *, PetscInt, ...))&PCTFS_ivec_land); }

  /* catch all ... not good if we get here */
  return(NULL);
}

/******************************************************************************/
PetscErrorCode PCTFS_ivec_sort(PetscInt *ar,  PetscInt size)
{
  PetscInt *pi, *pj, temp;
  PetscInt **top_a = (PetscInt **) offset_stack;
  PetscInt *top_s = size_stack, *bottom_s = size_stack;


  /* we're really interested in the offset of the last element */
  /* ==> length of the list is now size + 1                    */
  size--;

  /* do until we're done ... return when stack is exhausted */
  for (;;) {
    /* if list is large enough use quicksort partition exchange code */
    if (size > SORT_OPT) {
      /* start up pointer at element 1 and down at size     */
      pi = ar+1;
      pj = ar+size;

      /* find middle element in list and swap w/ element 1 */
      SWAP(*(ar+(size>>1)),*pi)

      /* order element 0,1,size-1 st {M,L,...,U} w/L<=M<=U */
      /* note ==> pivot_value in index 0                   */
      if (*pi > *pj) { SWAP(*pi,*pj) }
      if (*ar > *pj) { SWAP(*ar,*pj) }
      else if (*pi > *ar) { SWAP(*(ar),*(ar+1)) }

      /* partition about pivot_value ...                              */
      /* note lists of length 2 are not guaranteed to be sorted */
      for (;;) {
        /* walk up ... and down ... swap if equal to pivot! */
        do pi++; while (*pi<*ar);
        do pj--; while (*pj>*ar);

        /* if we've crossed we're done */
        if (pj<pi) break;

        /* else swap */
        SWAP(*pi,*pj)
      }

      /* place pivot_value in it's correct location */
      SWAP(*ar,*pj)

      /* test stack_size to see if we've exhausted our stack */
      if (top_s-bottom_s >= SORT_STACK) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_PLIB,"PCTFS_ivec_sort() :: STACK EXHAUSTED!!!");

      /* push right hand child iff length > 1 */
      if ((*top_s = size-((PetscInt) (pi-ar)))) {
        *(top_a++) = pi;
        size -= *top_s+2;
        top_s++;
      } else if (size -= *top_s+2) {;} /* set up for next loop iff there is something to do */
      else { /* might as well pop - note NR_OPT >=2 ==> we're ok! */
        ar = *(--top_a);
        size = *(--top_s);
      }
    } else { /* else sort small list directly then pop another off stack */

      /* insertion sort for bottom */
      for (pj=ar+1;pj<=ar+size;pj++) {
        temp = *pj;
        for (pi=pj-1;pi>=ar;pi--) {
          if (*pi <= temp) break;
          *(pi+1)=*pi;
        }
        *(pi+1)=temp;
      }

      /* check to see if stack is exhausted ==> DONE */
      if (top_s==bottom_s) PetscFunctionReturn(0);

      /* else pop another list from the stack */
      ar = *(--top_a);
      size = *(--top_s);
    }
  }
  PetscFunctionReturn(0);
}

/******************************************************************************/
PetscErrorCode PCTFS_ivec_sort_companion(PetscInt *ar,  PetscInt *ar2,  PetscInt size)
{
  PetscInt *pi, *pj, temp, temp2;
  PetscInt **top_a = (PetscInt **)offset_stack;
  PetscInt *top_s = size_stack, *bottom_s = size_stack;
  PetscInt *pi2, *pj2;
  PetscInt mid;

  PetscFunctionBegin;
  /* we're really interested in the offset of the last element */
  /* ==> length of the list is now size + 1                    */
  size--;

  /* do until we're done ... return when stack is exhausted */
  for (;;) {

    /* if list is large enough use quicksort partition exchange code */
    if (size > SORT_OPT) {

      /* start up pointer at element 1 and down at size     */
      mid = size>>1;
      pi = ar+1;
      pj = ar+mid;
      pi2 = ar2+1;
      pj2 = ar2+mid;

      /* find middle element in list and swap w/ element 1 */
      SWAP(*pi,*pj)
      SWAP(*pi2,*pj2)

      /* order element 0,1,size-1 st {M,L,...,U} w/L<=M<=U */
      /* note ==> pivot_value in index 0                   */
      pj = ar+size;
      pj2 = ar2+size;
      if (*pi > *pj) { SWAP(*pi,*pj) SWAP(*pi2,*pj2) }
      if (*ar > *pj) { SWAP(*ar,*pj) SWAP(*ar2,*pj2) }
      else if (*pi > *ar) { SWAP(*(ar),*(ar+1)) SWAP(*(ar2),*(ar2+1)) }

      /* partition about pivot_value ...                              */
      /* note lists of length 2 are not guaranteed to be sorted */
      for (;;) {
        /* walk up ... and down ... swap if equal to pivot! */
        do { pi++; pi2++; } while (*pi<*ar);
        do { pj--; pj2--; } while (*pj>*ar);

        /* if we've crossed we're done */
        if (pj<pi) break;

        /* else swap */
        SWAP(*pi,*pj)
        SWAP(*pi2,*pj2)
      }

      /* place pivot_value in it's correct location */
      SWAP(*ar,*pj)
      SWAP(*ar2,*pj2)

      /* test stack_size to see if we've exhausted our stack */
      if (top_s-bottom_s >= SORT_STACK) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_PLIB,"PCTFS_ivec_sort_companion() :: STACK EXHAUSTED!!!");

      /* push right hand child iff length > 1 */
      if ((*top_s = size-((PetscInt) (pi-ar)))) {
        *(top_a++) = pi;
        *(top_a++) = pi2;
        size -= *top_s+2;
        top_s++;
      } else if (size -= *top_s+2) {;} /* set up for next loop iff there is something to do */
      else  { /* might as well pop - note NR_OPT >=2 ==> we're ok! */
        ar2 = *(--top_a);
        ar  = *(--top_a);
        size = *(--top_s);
      }
    } else { /* else sort small list directly then pop another off stack */

      /* insertion sort for bottom */
      for (pj=ar+1, pj2=ar2+1;pj<=ar+size;pj++,pj2++) {
        temp = *pj;
        temp2 = *pj2;
        for (pi=pj-1,pi2=pj2-1;pi>=ar;pi--,pi2--) {
          if (*pi <= temp) break;
          *(pi+1)=*pi;
          *(pi2+1)=*pi2;
        }
        *(pi+1)=temp;
        *(pi2+1)=temp2;
      }

      /* check to see if stack is exhausted ==> DONE */
      if (top_s==bottom_s) PetscFunctionReturn(0);

      /* else pop another list from the stack */
      ar2 = *(--top_a);
      ar  = *(--top_a);
      size = *(--top_s);
    }
  }
  PetscFunctionReturn(0);
}

/******************************************************************************/
PetscErrorCode PCTFS_ivec_sort_companion_hack(PetscInt *ar,  PetscInt **ar2, PetscInt size)
{
   PetscInt *pi, *pj, temp, *ptr;
   PetscInt **top_a = (PetscInt **)offset_stack;
   PetscInt *top_s = size_stack, *bottom_s = size_stack;
   PetscInt **pi2, **pj2;
   PetscInt mid;

  PetscFunctionBegin;
  /* we're really interested in the offset of the last element */
  /* ==> length of the list is now size + 1                    */
  size--;

  /* do until we're done ... return when stack is exhausted */
  for (;;) {

    /* if list is large enough use quicksort partition exchange code */
    if (size > SORT_OPT) {

      /* start up pointer at element 1 and down at size     */
      mid = size>>1;
      pi = ar+1;
      pj = ar+mid;
      pi2 = ar2+1;
      pj2 = ar2+mid;

      /* find middle element in list and swap w/ element 1 */
      SWAP(*pi,*pj)
      P_SWAP(*pi2,*pj2)

      /* order element 0,1,size-1 st {M,L,...,U} w/L<=M<=U */
      /* note ==> pivot_value in index 0                   */
      pj = ar+size;
      pj2 = ar2+size;
      if (*pi > *pj) { SWAP(*pi,*pj) P_SWAP(*pi2,*pj2) }
      if (*ar > *pj) { SWAP(*ar,*pj) P_SWAP(*ar2,*pj2) }
      else if (*pi > *ar) { SWAP(*(ar),*(ar+1)) P_SWAP(*(ar2),*(ar2+1)) }

      /* partition about pivot_value ...                              */
      /* note lists of length 2 are not guaranteed to be sorted */
      for (;;) {

        /* walk up ... and down ... swap if equal to pivot! */
        do {pi++; pi2++;} while (*pi<*ar);
        do {pj--; pj2--;} while (*pj>*ar);

        /* if we've crossed we're done */
        if (pj<pi) break;

        /* else swap */
        SWAP(*pi,*pj)
        P_SWAP(*pi2,*pj2)
      }

      /* place pivot_value in it's correct location */
      SWAP(*ar,*pj)
      P_SWAP(*ar2,*pj2)

      /* test stack_size to see if we've exhausted our stack */
      if (top_s-bottom_s >= SORT_STACK) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_PLIB,"PCTFS_ivec_sort_companion_hack() :: STACK EXHAUSTED!!!");

      /* push right hand child iff length > 1 */
      if ((*top_s = size-((PetscInt) (pi-ar)))) {
        *(top_a++) = pi;
        *(top_a++) = (PetscInt*) pi2;
        size -= *top_s+2;
        top_s++;
      } else if (size -= *top_s+2) {;} /* set up for next loop iff there is something to do */
      else { /* might as well pop - note NR_OPT >=2 ==> we're ok! */
        ar2 = (PetscInt **) *(--top_a);
        ar  = *(--top_a);
        size = *(--top_s);
      }
    }


    else { /* else sort small list directly then pop another off stack */
      /* insertion sort for bottom */
      for (pj=ar+1, pj2=ar2+1;pj<=ar+size;pj++,pj2++) {
        temp = *pj;
        ptr = *pj2;
        for (pi=pj-1,pi2=pj2-1;pi>=ar;pi--,pi2--) {
          if (*pi <= temp) break;
          *(pi+1)=*pi;
          *(pi2+1)=*pi2;
        }
        *(pi+1)=temp;
        *(pi2+1)=ptr;
      }

      /* check to see if stack is exhausted ==> DONE */
      if (top_s==bottom_s) PetscFunctionReturn(0);

      /* else pop another list from the stack */
      ar2 = (PetscInt **)*(--top_a);
      ar  = *(--top_a);
      size = *(--top_s);
    }
  }
  PetscFunctionReturn(0);
}

/******************************************************************************/
PetscErrorCode PCTFS_SMI_sort(void *ar1, void *ar2, PetscInt size, PetscInt type)
{
  PetscFunctionBegin;
  if (type == SORT_INTEGER) {
    if (ar2) PCTFS_ivec_sort_companion((PetscInt*)ar1,(PetscInt*)ar2,size);
    else PCTFS_ivec_sort((PetscInt*)ar1,size);
  } else if (type == SORT_INT_PTR) {
    if (ar2) PCTFS_ivec_sort_companion_hack((PetscInt*)ar1,(PetscInt **)ar2,size);
    else PCTFS_ivec_sort((PetscInt*)ar1,size);
  } else SETERRQ(PETSC_COMM_SELF,PETSC_ERR_PLIB,"PCTFS_SMI_sort only does SORT_INTEGER!");
  PetscFunctionReturn(0);
}

/***********************************ivec.c*************************************/
PetscInt PCTFS_ivec_linear_search(PetscInt item,  PetscInt *list,  PetscInt n)
{
  PetscInt tmp = n-1;
  PetscFunctionBegin;
  while (n--)  { if (*list++ == item) { return(tmp-n); } }
  return(-1);
}

/***********************************ivec.c*************************************/
PetscInt PCTFS_ivec_binary_search(PetscInt item,  PetscInt *list,  PetscInt rh)
{
  PetscInt mid, lh=0;

  rh--;
  while (lh<=rh) {
    mid = (lh+rh)>>1;
    if (*(list+mid) == item) { return(mid); }
    if (*(list+mid) > item) { rh = mid-1; }
    else { lh = mid+1; }
  }
  return(-1);
}

/*********************************ivec.c*************************************/
PetscErrorCode PCTFS_rvec_copy(PetscScalar *arg1,  PetscScalar *arg2,  PetscInt n)
{
  PetscFunctionBegin;
  while (n--) { *arg1++ = *arg2++; }
  PetscFunctionReturn(0);
}

/*********************************ivec.c*************************************/
PetscErrorCode PCTFS_rvec_zero(PetscScalar *arg1,  PetscInt n)
{
  PetscFunctionBegin;
  while (n--) { *arg1++ = 0.0; }
  PetscFunctionReturn(0);
}

/***********************************ivec.c*************************************/
PetscErrorCode PCTFS_rvec_one(PetscScalar *arg1,  PetscInt n)
{
  PetscFunctionBegin;
  while (n--) { *arg1++ = 1.0; }
  PetscFunctionReturn(0);
}

/***********************************ivec.c*************************************/
PetscErrorCode PCTFS_rvec_set(PetscScalar *arg1,  PetscScalar arg2,  PetscInt n)
{
  PetscFunctionBegin;
  while (n--) { *arg1++ = arg2; }
  PetscFunctionReturn(0);
}

/***********************************ivec.c*************************************/
PetscErrorCode PCTFS_rvec_scale(PetscScalar *arg1,  PetscScalar arg2,  PetscInt n)
{
  PetscFunctionBegin;
  while (n--) { *arg1++ *= arg2; }
  PetscFunctionReturn(0);
}

/*********************************ivec.c*************************************/
PetscErrorCode PCTFS_rvec_add(PetscScalar *arg1,  PetscScalar *arg2,  PetscInt n)
{
  PetscFunctionBegin;
  while (n--) { *arg1++ += *arg2++; }
  PetscFunctionReturn(0);
}

/*********************************ivec.c*************************************/
PetscErrorCode PCTFS_rvec_mult(PetscScalar *arg1,  PetscScalar *arg2,  PetscInt n)
{
  PetscFunctionBegin;
  while (n--) { *arg1++ *= *arg2++; }
  PetscFunctionReturn(0);
}

/*********************************ivec.c*************************************/
PetscErrorCode PCTFS_rvec_max(PetscScalar *arg1,  PetscScalar *arg2,  PetscInt n)
{
  PetscFunctionBegin;
  while (n--) { *arg1 = PetscMax(*arg1,*arg2); arg1++; arg2++; }
  PetscFunctionReturn(0);
}

/*********************************ivec.c*************************************/
PetscErrorCode PCTFS_rvec_max_abs(PetscScalar *arg1,  PetscScalar *arg2,  PetscInt n)
{
  PetscFunctionBegin;
  while (n--) { *arg1 = MAX_FABS(*arg1,*arg2); arg1++; arg2++; }
  PetscFunctionReturn(0);
}

/*********************************ivec.c*************************************/
PetscErrorCode PCTFS_rvec_min(PetscScalar *arg1,  PetscScalar *arg2,  PetscInt n)
{
  PetscFunctionBegin;
  while (n--) { *arg1 = PetscMin(*arg1,*arg2); arg1++; arg2++; }
  PetscFunctionReturn(0);
}

/*********************************ivec.c*************************************/
PetscErrorCode PCTFS_rvec_min_abs(PetscScalar *arg1,  PetscScalar *arg2,  PetscInt n)
{
  PetscFunctionBegin;
  while (n--) { *arg1 = MIN_FABS(*arg1,*arg2); arg1++; arg2++; }
  PetscFunctionReturn(0);
}

/*********************************ivec.c*************************************/
PetscErrorCode PCTFS_rvec_exists(PetscScalar *arg1,  PetscScalar *arg2,  PetscInt n)
{
  PetscFunctionBegin;
  while (n--) { *arg1 = EXISTS(*arg1,*arg2); arg1++; arg2++; }
  PetscFunctionReturn(0);
}

/***********************************ivec.c*************************************/
PetscErrorCode PCTFS_rvec_non_uniform(PetscScalar *arg1, PetscScalar *arg2,  PetscInt n,  PetscInt *arg3)
{
  PetscInt i, j, type;

  PetscFunctionBegin;
  /* LATER: if we're really motivated we can sort and then unsort */
  for (i=0;i<n;) {

    /* clump 'em for now */
    j=i+1;
    type = arg3[i];
    while ((j<n)&&(arg3[j]==type)) { j++; }

    /* how many together */
    j -= i;

    /* call appropriate ivec function */
    if (type == GL_MAX)          { PCTFS_rvec_max(arg1,arg2,j); }
    else if (type == GL_MIN)     { PCTFS_rvec_min(arg1,arg2,j); }
    else if (type == GL_MULT)    { PCTFS_rvec_mult(arg1,arg2,j); }
    else if (type == GL_ADD)     { PCTFS_rvec_add(arg1,arg2,j); }
    else if (type == GL_MAX_ABS) { PCTFS_rvec_max_abs(arg1,arg2,j); }
    else if (type == GL_MIN_ABS) { PCTFS_rvec_min_abs(arg1,arg2,j); }
    else if (type == GL_EXISTS)  { PCTFS_rvec_exists(arg1,arg2,j); }
    else SETERRQ(PETSC_COMM_SELF,PETSC_ERR_PLIB,"unrecognized type passed to PCTFS_rvec_non_uniform()!");

    arg1+=j; arg2+=j; i+=j;
  }
  PetscFunctionReturn(0);
}

/***********************************ivec.c*************************************/
vfp PCTFS_rvec_fct_addr(PetscInt type)
{
  if (type == NON_UNIFORM)     { return((PetscErrorCode (*)(void*, void *, PetscInt, ...))&PCTFS_rvec_non_uniform); }
  else if (type == GL_MAX)     { return((PetscErrorCode (*)(void*, void *, PetscInt, ...))&PCTFS_rvec_max); }
  else if (type == GL_MIN)     { return((PetscErrorCode (*)(void*, void *, PetscInt, ...))&PCTFS_rvec_min); }
  else if (type == GL_MULT)    { return((PetscErrorCode (*)(void*, void *, PetscInt, ...))&PCTFS_rvec_mult); }
  else if (type == GL_ADD)     { return((PetscErrorCode (*)(void*, void *, PetscInt, ...))&PCTFS_rvec_add); }
  else if (type == GL_MAX_ABS) { return((PetscErrorCode (*)(void*, void *, PetscInt, ...))&PCTFS_rvec_max_abs); }
  else if (type == GL_MIN_ABS) { return((PetscErrorCode (*)(void*, void *, PetscInt, ...))&PCTFS_rvec_min_abs); }
  else if (type == GL_EXISTS)  { return((PetscErrorCode (*)(void*, void *, PetscInt, ...))&PCTFS_rvec_exists); }

  /* catch all ... not good if we get here */
  return(NULL);
}