do{ NI_free((rr)->name)     ;             \
     NI_free((rr)->userdef)  ;             \
     NI_free((rr)->comp_typ) ;             \
     NI_free((rr)->part_typ) ;             \
     NI_free((rr)->part_off) ;             \
     NI_free(rr)             ; } while(0)

( (c) == 'b' || (c) == 's' || (c) == 'i' ||  \
                           (c) == 'f' || (c) == 'd' || (c) == 'c' ||  \
                           (c) == 'r' || (c) == 'S' || (c) == 'L' ||  \
                           (c) == 'R'                               )

int type ;            \
  int nref ;            \
  char *idcode ;        \
  char *name

do{ int pp ;                               \
      for( pp=0 ; pp < (sar)->num ; pp++ )   \
        NI_free( (sar)->str[pp] );           \
      NI_free((sar)->str) ; NI_free(sar) ;   \
  } while(0)

do{ if( NI_is_vector_type((nn)->type) &&                     \
         NI_is_builtin_type((nn)->vec_typ) )                  \
       (nn)->type = NI_VECTOR_TYPE + (nn)->vec_typ + 1 ;      \
 } while(0)

( ((nd)->param[i]->type == NI_FLOAT_ONE_TYPE)           \
     ? ( ((NI_float_one *)(nd)->param[i])->val )          \
     : ( ((NI_float_vector *)(nd)->param[i])->vec[j] ) )

00041 {
00042    char *sa , *sb ;
00043    if( dt == NULL || str_a == NULL || str_b == NULL ) return ;
00044    sa = strdup(str_a) ; sb = strdup(str_b) ;
00045    addto_Htable( sa , (void *)sb , dt->hta ) ;
00046    addto_Htable( sb , (void *)sa , dt->htb ) ;
00047    return ;
00048 }

00130 {
00131    UINT jj ;
00132    int kk , ll=-1 ;
00133    char *key ;
00134 
00135    /* check for bad inputs */
00136 
00137    if( str == NULL || ht == NULL ) return ;
00138 
00139    if( vpt == NULL ){ removefrom_Htable( str , ht ) ; return ; }
00140 
00141    jj = hashkey(str) % ht->len ;      /* hash table row */
00142 
00143    key = strdup(str) ;                /* internal key string */
00144 
00145    if( ht->vtab[jj] == NULL ){        /* create this row in table */
00146 
00147      ht->vtab[jj] = (void **) calloc(3,sizeof(void *)) ;
00148      ht->ctab[jj] = (char **) calloc(3,sizeof(char *)) ;
00149      ht->ntab[jj] = 3 ;    /* made 2 extra entries */
00150 
00151      ht->vtab[jj][0] = vpt ;   /* save pointer */
00152      ht->ctab[jj][0] = key ;   /* save key string */
00153      ht->ntot ++ ;             /* 1 more in table */
00154 
00155    } else {                           /* search this row */
00156 
00157      for( kk=0 ; kk < ht->ntab[jj] ; kk++ ){
00158             if( ht->ctab[jj][kk] == NULL         ){ if(ll < 0) ll=kk; } /* add here? */
00159        else if( strcmp(key,ht->ctab[jj][kk]) == 0 ) break ;             /* found it? */
00160      }
00161 
00162      if( kk == ht->ntab[jj] ){   /* didn't find str in row already */
00163 
00164        if( ll >= 0 ){         /* have a NULL slot from scan above */
00165 
00166          ht->vtab[jj][ll] = vpt ;  /* save ptr */
00167          ht->ctab[jj][ll] = key ;  /* save key string */
00168          ht->ntot ++ ;             /* 1 more in table */
00169 
00170        } else {               /* must make row longer */
00171 
00172          ht->vtab[jj] = (void **) realloc( ht->vtab[jj] , (kk+3)*sizeof(void *)) ;
00173          ht->ctab[jj] = (char **) realloc( ht->ctab[jj] , (kk+3)*sizeof(char *)) ;
00174          ht->ntab[jj] = kk+3 ;
00175 
00176          ht->vtab[jj][kk] = vpt ;  /* save ptr */
00177          ht->ctab[jj][kk] = key ;  /* save key string */
00178          ht->ntot ++ ;             /* 1 more in table */
00179 
00180          ht->vtab[jj][kk+1] = ht->vtab[jj][kk+2] = NULL ;  /* created 2 extra */
00181          ht->ctab[jj][kk+1] = ht->ctab[jj][kk+2] = NULL ;  /* elements above */
00182 
00183        }
00184 
00185      } else {                    /* found str in row at index kk */
00186 
00187        if( vtkill && ht->vtab[jj][kk] != NULL ) free(ht->vtab[jj][kk]) ;
00188 
00189        ht->vtab[jj][kk] = vpt ;  /* replace old ptr with new */
00190        free(key) ;               /* don't need this */
00191      }
00192    }
00193 }

00020 {
00021    if( nn >= 1 && nn <= 2 ) ncrlf  = nn ;
00022    else                     nocrlf = !nocrlf ;
00023    return ;
00024 }

00032 {
00033    if( ll >= 16 && ll <= 76 ) linelen = 4*(ll/4) ; /* multiple of 4 */
00034    else                       linelen = 72 ;       /* default */
00035    return ;
00036 }

00178 {
00179    int ii,jj , nn,n3 ;
00180    byte a,b,c , w,x,y,z ;
00181 
00182    /*- sanity checks -*/
00183 
00184    if( nb64 == NULL || b64 == NULL ) return ;
00185    if( nbin <= 0    || bin == NULL ){ *nb64 = 0 ; *b64 = NULL ; return ; }
00186 
00187    /* calculate size of output (3 bytes in -> 4 bytes out, plus EOL */
00188 
00189    nn   = (int)((4.0*(linelen+ncrlf+1.0)/(3.0*linelen))*nbin + 256.0) ;
00190    *b64 = (byte *) malloc(sizeof(byte)*nn) ;
00191    if( *b64 == NULL ){ *nb64 = 0 ; return ; }  /* this is bad */
00192 
00193    /*- do blocks of 3 bytes in -*/
00194 
00195    load_encode_table() ;
00196    n3 = (nbin/3)*3 ;
00197    for( nn=jj=ii=0 ; ii < n3 ; ){
00198 
00199       /* encode next 3 bytes to 4 outputs */
00200 
00201       a = bin[ii++] ; b = bin[ii++] ; c = bin[ii++] ;
00202       B64_encode3(a,b,c,w,x,y,z) ;
00203       (*b64)[jj++] = w ;
00204       (*b64)[jj++] = x ;
00205       (*b64)[jj++] = y ;
00206       (*b64)[jj++] = z ;
00207 
00208       /* if we past the line length, add the EOL stuff */
00209 
00210       if( !nocrlf ){
00211         nn += 4 ; if( nn >= linelen ){
00212                      if( ncrlf == 2 ) (*b64)[jj++] = B64_EOL1 ;
00213                      (*b64)[jj++] = B64_EOL2 ;
00214                      nn = 0 ;
00215                   }
00216       }
00217    }
00218 
00219    /*- do the leftover data, if any (1 or 2 bytes) -*/
00220 
00221    if( ii < nbin ){
00222       if( ii == nbin-2 )
00223          B64_encode2(bin[ii],bin[ii+1],w,x,y,z) ;
00224       else
00225          B64_encode1(bin[ii],w,x,y,z) ;
00226 
00227       (*b64)[jj++] = w ;
00228       (*b64)[jj++] = x ;
00229       (*b64)[jj++] = y ;
00230       (*b64)[jj++] = z ; nn += 4 ;
00231    }
00232 
00233    /* if any output bytes are left, add EOL */
00234 
00235    if( nn > 0 && !nocrlf ){
00236       if( ncrlf == 2 ) (*b64)[jj++] = B64_EOL1 ;
00237       (*b64)[jj++] = B64_EOL2 ;
00238    }
00239 
00240    /* resize output array to be exact fit */
00241 
00242    *b64  = (byte *) realloc( *b64 , sizeof(byte)*jj ) ;
00243    *nb64 = jj ;
00244    return ;
00245 }

00093 {
00094    int ii,jj , nn ;
00095    byte a,b,c , w,x,y,z ;
00096 
00097    /*- sanity checks -*/
00098 
00099    if( nbin == NULL || bin == NULL ) return ;
00100 
00101    if( nb64 < 4 || b64 == NULL ){ *nbin = 0 ; *bin = NULL ; return ; }
00102 
00103    *bin = (byte *) malloc(sizeof(byte)*(2+3*nb64/4)) ;
00104    if( *bin == NULL ){ *nbin = 0 ; return ; }
00105 
00106    /*- some work -*/
00107 
00108    load_decode_table() ;
00109    for( ii=jj=0 ; ii < nb64 ; ){  /* scan inputs, skipping bad characters */
00110 
00111       /* get next 4 characters (use '=' if we hit the end early) */
00112 
00113       w = b64[ii++] ;
00114       while( !B64_goodchar(w) && ii < nb64 ) w = b64[ii++] ;
00115       x = (ii < nb64) ? b64[ii++] : '=' ;
00116       while( !B64_goodchar(x) && ii < nb64 ) x = b64[ii++] ;
00117       y = (ii < nb64) ? b64[ii++] : '=' ;
00118       while( !B64_goodchar(y) && ii < nb64 ) y = b64[ii++] ;
00119       z = (ii < nb64) ? b64[ii++] : '=' ;
00120       while( !B64_goodchar(z) && ii < nb64 ) z = b64[ii++] ;
00121 
00122       B64_decode4(w,x,y,z,a,b,c) ;           /* decode 4 bytes into 3 */
00123 
00124       if( z == '=' ){                        /* got to the end? */
00125          nn = B64_decode_count(w,x,y,z) ;    /* see how many to save */
00126          if( nn > 0 ) (*bin)[jj++] = a ;
00127          if( nn > 1 ) (*bin)[jj++] = b ;
00128          break ;                             /* end of decoding loop */
00129       }
00130 
00131       /* not at the end => save all 3 outputs, loop back */
00132 
00133       (*bin)[jj++] = a ; (*bin)[jj++] = b ; (*bin)[jj++] = c ;
00134    }
00135 
00136    /* resize output array to be exact fit */
00137 
00138    *bin  = (byte *) realloc( *bin , sizeof(byte)*jj ) ;
00139    *nbin = jj ;
00140    return ;
00141 }

00026 {
00027    if( dt == NULL ) return ;
00028    Htable_set_vtkill(1) ;
00029    destroy_Htable( dt->hta ) ;
00030    destroy_Htable( dt->htb ) ;
00031    Htable_set_vtkill(0) ; ;
00032    return ;
00033 }

00066 {
00067    int jj , kk ;
00068 
00069    if( ht == NULL ) return ;
00070 
00071    for( jj=0 ; jj < ht->len ; jj++ ){
00072      if( ht->vtab[jj] != NULL ){
00073        if( vtkill ){
00074          for( kk=0 ; kk < ht->ntab[jj] ; kk++ )
00075            if( ht->vtab[jj][kk] != NULL ) free(ht->vtab[jj][kk]) ;
00076        }
00077        free(ht->vtab[jj]) ;
00078      }
00079      if( ht->ctab[jj] != NULL ){
00080        for( kk=0 ; kk < ht->ntab[jj] ; kk++ )
00081          if( ht->ctab[jj][kk] != NULL ) free(ht->ctab[jj][kk]) ;
00082        free(ht->ctab[jj]) ;
00083      }
00084    }
00085    free(ht->vtab) ; free(ht->ctab) ; free(ht->ntab) ; free(ht) ;
00086    return ;
00087 }

00165 {
00166    NI_stream ns ;
00167    NI_element *nel ;
00168    int nn , ii ;
00169    Dtable *dt ;
00170    char **la , **lb ;
00171 
00172    if( nstr == NULL || *nstr == '\0' ) return NULL ;
00173 
00174    /* convert string to a NIML element */
00175 
00176    ns = NI_stream_open( "str:" , "r" ) ;
00177    NI_stream_setbuf( ns , nstr ) ;
00178    nel = (NI_element *)NI_read_element( ns , 1 ) ;
00179    NI_stream_close( ns ) ;
00180    if( nel == NULL ) return NULL ;
00181 
00182    /* see if element is OK for this purpose */
00183 
00184    if( NI_element_type(nel) != NI_ELEMENT_TYPE ){
00185      NI_free_element(nel) ; return NULL ;
00186    }
00187 
00188    if( nel->vec_len    <  1         ||  /* empty element?             */
00189        nel->vec_filled <  1         ||  /* no data was filled in?     */
00190        nel->vec_num    <  2         ||  /* less than 4 columns?       */
00191        nel->vec_typ[0] != NI_STRING ||  /* must be String, String     */
00192        nel->vec_typ[1] != NI_STRING   ){
00193 
00194      NI_free_element(nel) ; return NULL ;
00195    }
00196 
00197    la = (char **) nel->vec[0] ;  /* first column of String */
00198    lb = (char **) nel->vec[1] ;  /* second column of String */
00199 
00200    nn = nel->vec_filled ;
00201    ii = rint(sqrt(2*nn+1.0l)) ;
00202    if( ii < 7 ) ii = 7 ; else if( ii%2 == 0 ) ii++ ;
00203 
00204    /* make table, insert strings */
00205 
00206    dt = new_Dtable( ii ) ;
00207    for( ii=0 ; ii < nn ; ii++ )
00208      addto_Dtable( la[ii] , lb[ii] , dt ) ;
00209 
00210    NI_free_element(nel) ; return dt ;
00211 }

00135 {
00136    int nn , ii ;
00137    char **la , **lb , *stout ;
00138    NI_element *nel ;
00139    NI_stream ns ;
00140 
00141    nn = listize_Dtable( dt , &la , &lb ) ;
00142    if( nn == 0 || la == NULL || lb == NULL ) return (char *)NULL ;
00143 
00144    if( name == NULL || *name == '\0' ) name = "Dtable" ;
00145 
00146    nel = NI_new_data_element( name , nn ) ;
00147    NI_add_column( nel , NI_STRING , la ) ;
00148    NI_add_column( nel , NI_STRING , lb ) ;
00149    free(la) ; free(lb) ;
00150 
00151    ns = NI_stream_open( "str:" , "w" ) ;
00152    (void) NI_write_element( ns , nel , NI_TEXT_MODE ) ;
00153    NI_free_element( nel ) ;
00154    stout = strdup( NI_stream_getbuf(ns) ) ;
00155    NI_stream_close( ns ) ;
00156    nn = strlen(stout) ;
00157    for( ii=nn-1 ; ii > 0 && isspace(stout[ii]) ; ii-- ) ; /* trailing blanks */
00158    stout[ii+1] = '\0' ;
00159    return stout ;
00160 }

00053 {
00054    if( dt == NULL || str_a == NULL ) return NULL ;
00055    return (char *)findin_Htable( str_a , dt->hta ) ;
00056 }

00061 {
00062    if( dt == NULL || str_b == NULL ) return NULL ;
00063    return (char *)findin_Htable( str_b , dt->htb ) ;
00064 }

00096 {
00097    UINT jj ;
00098    int kk , ntab ;
00099    char *key , **ctab ;
00100    void ***vtab ;
00101 
00102    if( str == NULL || ht == NULL || ht->ntot == 0 ) return NULL ;
00103 
00104    jj = hashkey(str) % ht->len ;      /* hash table row */
00105 
00106    vtab = ht->vtab ;
00107 
00108    if( vtab[jj] == NULL ) return NULL ;  /* nothing there */
00109 
00110    key = str ;
00111 
00112    ctab = ht->ctab[jj] ; ntab = ht->ntab[jj] ;
00113 
00114    for( kk=0 ; kk < ntab ; kk++ )   /* scan for match of key to ctab */
00115      if( ctab[kk] != NULL && strcmp(key,ctab[kk]) == 0 )
00116        return vtab[jj][kk];
00117 
00118    return NULL ; /* no match found */
00119 }

00624 {
00625    NI_mallitem *ip ;
00626 
00627    if( fred == NULL ) return ;
00628 
00629    if( use_userfunc )                                          user_free(fred) ;
00630    else if( use_tracking && (ip=shift_tracker(fred)) != NULL ) free_track( ip ) ;
00631    else                                                        free( fred ) ;
00632 
00633 #ifdef NIML_DEBUG
00634 NI_dpr("hidden_NI_free: called from %s#%d\n",fnam,lnum) ;
00635 #endif
00636 
00637 }

00569 {
00570    void *p ;
00571 
00572         if( use_userfunc ){ p = user_malloc(n); if(p)memset(p,0,n); }
00573    else if( use_tracking )  p = calloc_track(1,n,fnam,lnum) ;
00574    else                     p = calloc(1,n) ;
00575 
00576    if( p == NULL ){
00577      fprintf(stderr,"** ERROR: NI_malloc() fails. Aauugghh!\n") ;
00578      NI_sleep(333); exit(1);
00579    }
00580 
00581 #ifdef NIML_DEBUG
00582 NI_dpr("hidden_NI_malloc: called from %s#%d\n",fnam,lnum) ;
00583 #endif
00584 
00585    return p ;
00586 }

00593 {
00594    NI_mallitem *ip ;
00595    void *q ;
00596 
00597    if( fred == NULL )
00598       return hidden_NI_malloc( n , fnam , lnum ) ;
00599 
00600    if( use_userfunc )
00601      q = user_realloc( fred , n ) ;
00602    else if( use_tracking && (ip=shift_tracker(fred)) != NULL )
00603      q = realloc_track( ip , n , fnam,lnum ) ;
00604    else
00605      q = realloc( fred , n ) ;
00606 
00607    if( q == NULL && n > 0 ){
00608       fprintf(stderr,"** ERROR: NI_realloc() fails. Ooooogg!\n");
00609       NI_sleep(333); exit(1);
00610    }
00611 
00612 #ifdef NIML_DEBUG
00613 NI_dpr("hidden_NI_realloc: called from %s#%d\n",fnam,lnum) ;
00614 #endif
00615 
00616    return q ;
00617 }

00018 { vtkill = vt ; }

00108 {
00109    char **la=NULL , **lb=NULL , *sa,*sb ;
00110    int jj,kk,nn ;
00111    Htable *ht ;
00112 
00113    if( dt == NULL || list_a == NULL || list_b == NULL ) return 0 ;
00114 
00115    ht = dt->hta ;
00116 
00117    for( nn=jj=0 ; jj < ht->len ; jj++ ){
00118      if( ht->vtab[jj] == NULL ) continue ;
00119      for( kk=0 ; kk < ht->ntab[jj] ; kk++ ){
00120        sa = (char *) ht->ctab[jj][kk] ; if( sa == NULL ) continue ;
00121        sb = (char *) ht->vtab[jj][kk] ; if( sb == NULL ) continue ;
00122        la = (char **) realloc( (void *)la , sizeof(char *)*(nn+1) ) ;
00123        lb = (char **) realloc( (void *)lb , sizeof(char *)*(nn+1) ) ;
00124        la[nn] = sa ; lb[nn] = sb ; nn++ ;
00125      }
00126    }
00127    *list_a = la ; *list_b = lb ; return nn ;
00128 }

00467 {
00468    MD5_CTX context;
00469    unsigned char digest[16];
00470 
00471    if( n < 0 || bytes == NULL ) return NULL ;
00472 
00473    MD5Init( &context ) ;
00474    MD5Update( &context, (unsigned char *)bytes, n ) ;
00475    MD5Final( digest, &context ) ;
00476 
00477    return MD5_to_B64( digest ) ;
00478 }

00501 {
00502   FILE *file;
00503   MD5_CTX context;
00504   int len;
00505   unsigned char buffer[1024] ;
00506   unsigned char digest[16] ;
00507 
00508   if( (file=fopen (filename, "rb")) == NULL ) return NULL ;
00509 
00510   MD5Init( &context ) ;
00511 
00512   while( len = fread(buffer, 1, 1024, file) )
00513       MD5Update( &context, buffer, len ) ;
00514 
00515   MD5Final( digest, &context );
00516   fclose (file);
00517 
00518   return MD5_to_B64( digest ) ;
00519 }

00488 {
00489    if( string == NULL ) string = "ElvisTheKing" ;
00490    return MD5_B64_array( strlen(string) , string ) ;
00491 }

00373 {
00374    char *st , *dy ;
00375    st = MD5_static_array( n , bytes ) ;
00376    if( st == NULL ) return NULL ;
00377    dy = (char *) malloc(33) ; strcpy(dy,st) ; return dy ;
00378 }

00434 {
00435    char *st , *dy ;
00436 
00437    st = MD5_static_file( filename ) ;
00438    if( st == NULL ) return NULL ;
00439    dy = (char *) malloc(33) ; strcpy(dy,st) ; return dy ;
00440 }

00397 {
00398    if( string == NULL ) string = "ElvisTheKing" ;
00399    return MD5_malloc_array( strlen(string)+1 , string ) ;
00400 }

00354 {
00355    MD5_CTX context;
00356    unsigned char digest[16];
00357 
00358    if( n < 0 || bytes == NULL ) return NULL ;
00359 
00360    MD5Init( &context ) ;
00361    MD5Update( &context, (unsigned char *)bytes, n ) ;
00362    MD5Final( digest, &context ) ;
00363 
00364    return MD5_static_printf(digest) ;
00365 }

00408 {
00409   FILE *file;
00410   MD5_CTX context;
00411   int len;
00412   unsigned char buffer[1024] ;
00413   unsigned char digest[16] ;
00414 
00415   if( (file = fopen(filename, "rb")) == NULL ) return NULL ;
00416 
00417   MD5Init( &context ) ;
00418 
00419   while( len = fread(buffer, 1, 1024, file) )
00420       MD5Update( &context, buffer, len ) ;
00421 
00422   MD5Final( digest, &context );
00423   fclose (file);
00424 
00425   return MD5_static_printf( digest ) ;
00426 }

00386 {
00387    if( string == NULL ) string = "ElvisTheKing" ;
00388    return MD5_static_array( strlen(string) , string ) ;
00389 }

00013 {
00014    Dtable *dt ;
00015    dt = (Dtable *) calloc( 1 , sizeof(Dtable) ) ;
00016    dt->hta = new_Htable( len ) ;
00017    dt->htb = new_Htable( len ) ;
00018    return dt ;
00019 }

00045 {
00046    Htable *ht ;
00047 
00048         if( len   <= 7 ) len = 7 ;  /* smallest allowed */
00049    else if( len%2 == 0 ) len++   ;  /* mustn't be even */
00050 
00051    ht = (Htable *) calloc( 1 , sizeof(Htable) ) ;
00052 
00053    ht->len  = len ;
00054    ht->vtab = (void ***) calloc( len , sizeof(void **) ) ;
00055    ht->ctab = (char ***) calloc( len , sizeof(char **) ) ;
00056    ht->ntab = (int *)    calloc( len , sizeof(int)     ) ;
00057 
00058    return ht ;
00059 }

00443 {
00444    int nn ;
00445    NI_rowtype *rt ;
00446 
00447    /* check for reasonable inputs */
00448 
00449    if( nel == NULL || nel->vec_len <= 0 )            return ;
00450    if( nel->type != NI_ELEMENT_TYPE )                return ;
00451    rt = NI_rowtype_find_code(typ) ; if( rt == NULL ) return ;
00452 
00453    /* get number of vectors currently in element */
00454 
00455    nn = nel->vec_num ;
00456 
00457    /* add 1 to the vec_typ array */
00458 
00459    nel->vec_typ     = NI_realloc( nel->vec_typ, int, sizeof(int)*(nn+1) ) ;
00460    nel->vec_typ[nn] = typ ;
00461 
00462    /* add 1 element to the vec array, and copy data into it */
00463 
00464    nel->vec = NI_realloc( nel->vec , void*, sizeof(void *)*(nn+1) ) ;
00465    if( arr != NULL )
00466      nel->vec[nn] = NI_copy_column( rt , nel->vec_len , arr ) ;
00467    else
00468      nel->vec[nn] = NI_malloc(void, rt->size * nel->vec_len ) ;
00469 
00470    /* add 1 to the count of vectors */
00471 
00472    nel->vec_num = nn+1 ;
00473    return ;
00474 }

00518 {
00519    int nn , ii ;
00520    NI_rowtype *rt ;
00521    char *idat ;
00522 
00523    /* check for reasonable inputs */
00524 
00525    if( nel == NULL || nel->vec_len <= 0 )            return ;
00526    if( nel->type != NI_ELEMENT_TYPE )                return ;
00527    rt = NI_rowtype_find_code(typ) ; if( rt == NULL ) return ;
00528 
00529    /* add an empty column */
00530 
00531    NI_add_column( nel , typ , NULL ) ;
00532    if( arr == NULL ) return ;          /* no input data ==> we're done */
00533 
00534    /* loop over inputs and put them in one at a time */
00535 
00536    nn   = nel->vec_num-1 ;
00537    idat = (char *) arr ;
00538 
00539    for( ii=0 ; ii < nel->vec_len ; ii++ )
00540      NI_insert_value( nel , ii , nn , idat + (ii*stride*rt->size) ) ;
00541 
00542    return ;
00543 }

00956 {
00957    int nn , tt=NI_element_type(nini) ;
00958 
00959    if( ngr == NULL || ngr->type != NI_GROUP_TYPE || tt < 0 ) return ;
00960 
00961    nn = ngr->part_num ;
00962 
00963    ngr->part_typ     = NI_realloc( ngr->part_typ , int, sizeof(int)*(nn+1) ) ;
00964    ngr->part_typ[nn] = tt ;
00965    ngr->part         = NI_realloc( ngr->part , void*, sizeof(void *)*(nn+1) );
00966    ngr->part[nn]     = nini ;
00967    ngr->part_num     = nn+1 ;
00968    return ;
00969 }