constraints.c#152        seg->rank = nclistlength(dimset);
#154 if(cdfnode->array.stringdim != NULLseg->rank--;
#155        for(j=0;j<seg->rank;j++) {
#186 seg->rank = nclistlength(node->array.dimset0);
#358 int rank = seg->rank;
#366 rank--; /* remove sequence pseudo-rank */
#367     if(rank > 0
#368 && rank != nclistlength(node->array.dimset0))
#411        for(j=0;j<segment->rank;j++) {
#428 dimindex += segment->rank;
#465    unsigned int rank;
#467    if(seg->rank == 0) return 1;
#471    rank = nclistlength(dimset);
#473    for(i=0;i<rank;i++) {
#653    seg->rank = 0;
#669 if(seg1->rank != seg2->rank)
#671 for(j=0;j<seg1->rank;j++) {
#714        segment->rank = localrank;
#828        for(j=0;j<seg->rank;j++) {
dapdump.c#592dumpslices(DCEsliceslice, unsigned int rank)
#599    for(i=0;i<rank;i++,slice++) {
dapdump.h#63extern char* dumpslices(DCEsliceslice, unsigned int rank);
dapodom.c#23    odom->rank = (stopindex - startindex);
#24    for(i=0;i<odom->rank;i++) {
#41dapodom_new(size_t rank,
#48    odom->rank = rank;
#49    assert(odom->rank <= NC_MAX_VAR_DIMS);
#50    for(i=0;i<odom->rank;i++) {
#81    if(odom->rank == 0) {
#83    } else for(i=0;i<odom->rank;i++) {
#107    for(i=0;i<odom->rank;i++) {
#118    if(odom->rank == 0) return 0;
#119    for(i=odom->rank-1;i>=0;i--) {
#134    for(i=0;i<odom->rank;i++) {
#156    for(i=0;i<odom->rank;i++) {
dapodom.h#10    int            rank;
#25extern Dapodometerdapodom_new(size_t rank,
dapparse.c#239    unsigned int rank = oclistlength(dimensions);
#241    node->array.rank = rank;
#242    for(i=0;i<rank;i++) {
dceconstraints.c#294 for(j=0;j<addedseg->rank;j++) {
#295     if(j < mergedseg->rank)
#300 if(addedseg->rank > mergedseg->rank)
#301     mergedseg->rank = addedseg->rank;
#364 if(orig->rank > 0)
#365     memcpy(clone->slices,orig->slices,orig->rank*sizeof(DCEslice));
#515 target->rank = 0;
#635        int rank = segment->rank;
#643            for(i=0;i<rank;i++) {
#925    for(i=0;i<seg->rank;i++) {
#950        lastseg->rank = 0;
#978        for(i=0;i<segment->rank;i++) {
#1072        int rank = segment->rank;
#1076        snprintf(tmp,sizeof(tmp)," rank=%lu",(unsigned long)rank);
#1082 if(rank > 0) {
#1084            for(i=0;i<rank;i++) {
dceconstraints.h#36    size_t rank;
dceparse.c#99 segment->rank = nclistlength(slices);
dumplib.c#1156 int rank = tinfo->ranks[fidx];
#1160 slen = tinfo->sides[fidx][rank-1];
#1162 for(j=0; j < rank-1; j++) {
#1627   int rank;
#1632   &offset, &ftype, &rank,
#1634   if(rank > 0) sides = (int *) emalloc(rank * sizeof(int));
#1639   tinfo->ranks[fidx] = rank;
#1640   if (rank > 0)
#1641       tinfo->sides[fidx] = (int *) emalloc(rank * sizeof(int));
#1643   for(i = 0; i < ranki++) {
#1647   if (rank > 0)
dvarget.c#19    int            rank;
#33     int rank,
#38    odom->rank = rank;
#39    assert(odom->rank <= NC_MAX_VAR_DIMS);
#40    for(i=0;i<odom->rank;i++) {
#65    if(odom->rank == 0) return 0;
#66    for(i=odom->rank-1;i>=0;i--) {
#140   int rank;
#183   status = nc_inq_varndims(ncidvarid, &rank);
#188   NC_getshape(ncid,varid,rank,varshape);
#191   if (rank == 0) {
#203   for(i=0;i<rank;i++) {
#237   odom_init(&odom,rank,mystart,myedges,mystride);
dvarput.c#13    int            rank;
#23     int rank,
#28    odom->rank = rank;
#29    assert(odom->rank <= NC_MAX_VAR_DIMS);
#30    for(i=0;i<odom->rank;i++) {
#49    if(odom->rank == 0) return 0;
#50    for(i=odom->rank-1;i>=0;i--) {
#126   int rank;
#171   status = nc_inq_varndims(ncidvarid, &rank);
#181   NC_getshape(ncid,varid,rank,varshape);
#184   if (rank == 0) {
#196   for(i=0;i<rank;i++) {
#246   odom_init(&odom,rank,mystart,myedges,mystride);
genbin.c#375             int rank, size_t* start, size_t* count)
#378 return genbin_writeattr(generator,sym,memory,rank,start,count);
#380 return genbin_writevar(generator,sym,memory,rank,start,count);
#388                int rank, size_t* start,
#400    { int i; for(i=0;i<rank;i++) count[i] = indices[i] - start[i];}
#407    for(i=0;i<rank;i++)
#411    for(i=0;i<rank;i++)
#418    if(rank == 0) {
#431           int rank, size_t* start, size_t* count)
genc.c#31                       int rank, size_t* start, size_t* count);
#946           int rank, size_t* start, size_t* count)
#949 genc_writeattr(generator,sym,code,rank,start,count);
#951 genc_writevar(generator,sym,code,rank,start,count);
#958           int rank, size_t* start, size_t* count)
#981    if(rank == 0) {
#1018         for(i=0;i<rank;i++) length *= count[i];
#1037 rank);
#1038 for(i=0;i<rank;i++) {
#1047 rank);
#1048 for(i=0;i<rank;i++) {
#1071               int rank, size_t* start, size_t* count)
genchar.c#60    int rank = rankfor(dimset);
#63    int nc3unlim = (nunlim <= 1 && (firstunlim == 0 || firstunlim == rank)); /* netcdf-3 case of at most 1 unlim in 0th dimension */
#84    int rank = dimset->ndims;
#88    int islastgroup = (lastunlimited == rank || dimindex >= lastunlimited || dimindex == rank-1);
#91    ASSERT(rank > 0);
#222    int rank = rankfor(dimset);
#225    ASSERT((findlastunlimited(dimset) == rank
#290    xproduct = crossproduct(dimset,dimindex,rank-1);
#293    if(rank == 0) {
#296    } else if(rank == 1) {
#298        expectedsize = (xproduct * declsizefor(dimset,rank-1));
#299    } else if(isunlimited(dimset,rank-1)) {/* last dimension is unlimited */
#301        expectedsize = (xproduct*declsizefor(dimset,rank-1));
#303 unitsize =  declsizefor(dimset,rank-1);
generate.c#47    for(i=0;i<odom->rank;i++) {
#81    int rank = dimset->ndims;
#96    if(rank == 0) {/*scalar case*/
#136    int rank = dimset->ndims;
#143    int isnc3unlim = (nunlim <= 1 && (firstunlim == 0 || firstunlim == rank)); /* netcdf-3 case of at most 1 unlim in 0th dimension */
#145    ASSERT(rank > 0);
#155            writer(generator,vsym,code,odom->rank,odom->start,odom->count);
#157            writer(generator,vsym,code,odom->rank,0,bbLength(charbuf));
#180                writer(generator,vsym,code,rank,odom->start,odom->count);
#196            writer(generator,vsym,code,odom->rank,odom->start,odom->count);
#225    int rank = dimset->ndims;
#229    int islastgroup = (lastunlimited == rank || dimindex >= lastunlimited || dimindex == rank-1);
#232    ASSERT(rank > 0);
#233    ASSERT((dimindex >= 0 && dimindex < rank));
#244            subodom = newsubodometer(odom,dimset,dimindex,rank);
#407    int rank = rankfor(dimset);
#423        size_t xproduct = crossproduct(dimset,0,rank); /* compute total number of elements */
genf77.c#706             int rank, size_t* start, size_t* count)
#709 genf77_writeattr(generator,sym,code,rank,start,count);
#711 genf77_writevar(generator,sym,code,rank,start,count);
#719           int rank, size_t* start, size_t* count)
#735    } else if(rank == 0) {
#777                        f77name(vsym),(unsigned int)rank);
#780                        f77name(vsym),(unsigned int)rank);
#786        for(i=rank-1;i>=0;i--) {
#789 (i==(rank-1)?"":","),
#853        int rank, size_t* start, size_t* count)
genj.c#33                       int rank, size_t* start, size_t* count);
#417           int rank, size_t* start, size_t* count)
#420 genj_writeattr(generator,sym,code,rank,start,count);
#422 genj_writevar(generator,sym,code,rank,start,count);
#429              int rank, size_t* start, size_t* count)
#438    if(rank == 0) {
#461 for(i=0;i<rank;i++) {
#502 for(i=0;i<rank;i++) {
#518               int rank, size_t* start, size_t* count)
getvara.c#440     seg->rank = 0;
#442     seg->rank--;
#541            odom = dapodom_fromsegment(segment,0,segment->rank);
#550                                 xgetvar,dimindex+segment->rank,
#565     ASSERT((segment->rank == 1));
#698    for(point=-1,i=0;i<odom->rank;i++) {
#706    else if(point == (odom->rank - 1))
nc4file.c#2513   int32 rank;
#2610      if (SDgetinfo(var->sdsidvar->name, &rankNULL, &data_type, &num_atts))
#2615      if(!(dimsize = (int32*)malloc(sizeof(int32)*rank)))
#2618      if (SDgetinfo(var->sdsidvar->name, &rankdimsize, &data_type, &num_atts)) {
#2623      var->ndims = rank;
#2647    rankvar->type_info->nc_typeid));
nc_iter.c#20static int nc_blkio_init(size_t bufsize, size_t value_size, int rank,
#100        for(i = iter->right_dim + 1; i < iter->ranki++) {
#106        iter->more = up_start(iter->rankiter->dimsizesiter->right_dim,
#123    for(i = 0; i < iter->ranki++) {
#136       int rank,  /* number of dimensions for variable */
#144    iter->rank = rank;
#147    for(i = 0; i < ranki++)
#150    iter->right_dim = rank - 1;
#151    for(i = ranki > 0; i--) {
nc_iter.h#29    int rank;      /* number of dimensions */
nccopy.c#1038    start = (size_t *) emalloc((iterp->rank + 1) * sizeof(size_t));
#1039    count = (size_t *) emalloc((iterp->rank + 1) * sizeof(size_t));
ncd2dispatch.c#1554    int i,rank;
#1569    rank = nclistlength(var->array.dimset0);
#1570    for(i=0;i<rank;i++) {
#1947    unsigned int rank;
#1953 rank = nclistlength(ncdims);
#1954 if(rank == 0) { /* use instance size of the type */
#1965 makecdfpathstring(var,"."),rank,size);
nciter.c#22       int rank,  /* number of dimensions for variable */
#31    iter->rank = rank;
#37 iter->right_dim = rank - 1;
#38 for(i = ranki > 0; i--) {
#61    for(i = 0; i < ranki++) {
#256     for(i = iter->right_dim + 1; i < iter->ranki++) {
#261     for(i = 0; i < iter->ranki++) {
#272     iter->more = up_start(iter->rankiter->dimsizesiter->right_dim,
#287     iter->more = up_start_by_chunks(iter->rankiter->dimsizes,
#290     for(i = 0; i < iter->ranki++) {
#302    for(i = 0; i < iter->ranki++) {
nciter.h#29    int rank;      /* number of dimensions */
ncpdispatch.c#580    int rank = 0;
#589    statusncmpi_inq_varndims(nc->int_ncidvarid, &rank);
#593    for (d = 0; d < rankd++) {
#674    int rank;
#683    status = ncmpi_inq_varndims(nc->int_ncidvarid, &rank);
#687    for (d = 0; d < rankd++) {
#769    int rank = 0;
#778    statusncmpi_inq_varndims(nc->int_ncidvarid, &rank);
#782    for (d = 0; d < rankd++) {
#865    int rank;
#874    status = ncmpi_inq_varndims(nc->int_ncidvarid, &rank);
#878    for (d = 0; d < rankd++) {
#962    int rank = 0;
#971    statusncmpi_inq_varndims(nc->int_ncidvarid, &rank);
#975    for (d = 0; d < rankd++) {
#1060    int rank;
#1069    status = ncmpi_inq_varndims(nc->int_ncidvarid, &rank);
#1073    for (d = 0; d < rankd++) {
oc.c#235    if(rankp) *rankp = node->array.rank;
#356    if(rankp) *rankp = node->array.rank;
#597    if(node->array.rank == 0) return OCTHROW(OCTHROW(OC_ESCALAR));
#599        for(i=0;i<node->array.rank;i++) {
#629    if(node->array.rank == 0) return OCTHROW(OCTHROW(OC_ESCALAR));
#630    if(index >= node->array.rank) return OCTHROW(OCTHROW(OC_EINDEX));
#686    if(node->array.rank == 0) return OCTHROW(OCTHROW(OC_ESCALAR));
#689        for(i=0;i<node->array.rank;i++) {
#1375    size_t countrank;
#1388    rank = pattern->array.rank;
#1389    count = octotaldimsize(rank,edges);
#1461    size_t rank,startpoint;
#1474    rank = pattern->array.rank;
#1476    if(rank == 0) {
#1482 startpoint = ocarrayoffset(rank,pattern->array.sizes,start);
occompile.c#98 if(xnode->array.rank == 0) {/* scalar */
#105            nelements = octotaldimsize(xnode->array.rank,xnode->array.sizes);
#295    int scalar = (xnode->array.rank == 0);
#301        nelements = octotaldimsize(xnode->array.rank,xnode->array.sizes);
#414 return (node->array.rank == 0 ? 1 : 0); /* Toplevel if scalar */
ocdata.c#119    size_t index,rank;
#125    rank = pattern->array.rank;
#128    if(pattern->octype != OC_Structure || rank == 0)
#132    if(!ocvalidateindices(rank,pattern->array.sizes,indices))
#136    index = ocarrayoffset(rank,pattern->array.sizes,indices);
#199                       pattern->array.rank,
#257    isscalar = (pattern->array.rank == 0 ? 1 : 0);
#306    scalar = (pattern->array.rank == 0);
ocdump.c#192    for(i=0;i<node->array.rank;i++) {
#548    size_t i,rank;
#562    rank = pattern->array.rank;
#565    if(rank > 0)
#566        crossproduct = octotaldimsize(pattern->array.rank,pattern->array.sizes);
#618    if(rank > 0) {
#664     if(pattern->array.rank > 0) {
#665         off_t xproduct = octotaldimsize(pattern->array.rank,pattern->array.sizes);
ocnode.c#33 if(node->array.rank > 0) {
#34     node->array.sizes = (size_t*)malloc(node->array.rank*sizeof(size_t));
#35     for(j=0;j<node->array.rank;j++) {
#465    if(dxd->array.rank != dds->array.rank) {
#495    if(dds->array.rank > 0) {
#543 || pathnode->array.rank > 0) {
ocnode.h#22    size_t rank; /* == |dimensions|*/
ocutil.c#65        unsigned int rank = node->array.rank;
#66 for(j=0;j<rank;j++) {
#162octotaldimsize(size_t rank, size_t* sizes)
#166    for(i=0;i<rank;i++) {
#473ocarrayoffset(size_t rank, size_t* sizes, size_t* indices)
#477    for(i=0;i<rank;i++) {
#486ocarrayindices(size_t index, size_t rank, size_t* sizes, size_t* indices)
#489    for(i=rank-1;i>=0;i--) {
#500ocedgeoffset(size_t rank, size_t* sizes, size_t* edges)
#504    for(i=0;i<rank;i++) {
#512ocvalidateindices(size_t rank, size_t* sizes, size_t* indices)
#515    for(i=0;i<rank;i++) {
#526    int isscalar = (node->array.rank == 0);
ocutil.h#30extern size_t ocarrayoffset(size_t rank, size_t*, size_t*);
#31extern void ocarrayindices(size_t index, size_t rank, size_t*, size_t*);
#32extern size_t ocedgeoffset(size_t rank, size_t*, size_t*);
#34extern int ocvalidateindices(size_t rank, size_t*, size_t*);
odom.c#25    odom->rank = dimset->ndims;
#26    ASSERT(odom->rank <= NC_MAX_VAR_DIMS);
#27    for(i=0;i<odom->rank;i++) {
#51    odom->rank = (stop - start);
#52    ASSERT(odom->rank <= NC_MAX_VAR_DIMS);
#69    if(odom->origin->rank == 0) {
#71    } else for(i=0;i<odom->rank;i++) {
#89    ASSERT(odom->rank > 0);
#103    int last = odom->rank-1;
#104    ASSERT(odom->rank > 0);
#135    for(i=0;i<odom->rank;i++) {
odom.h#10    int rank;
parallel_vara.c#84    int ijranknprocsverbose=1, err;
#91    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
#100            default:  if (rank==0) usage(argv[0]);
#121             buf[i][j] = rank;
#157    start[1] = NX * rank;
test_partvar.c#41    int rank;
#54static Odomodom_create(int rank);
#61static size_t subslice(int rank, size_t* count, int startdim);
#160subslice(int rank, size_t* count, int startdim)
#164    for(i=startdim;i<rank;i++)
#192odom_create(int rank)
#196    odom->rank = rank;
#197    odom->index = (size_t*)calloc(sizeof(size_t)*rank,1);
#198    odom->stop = (size_t*)calloc(sizeof(size_t)*rank,1);
#199    odom->start = (size_t*)calloc(sizeof(size_t)*rank,1);
#200    odom->count = (size_t*)calloc(sizeof(size_t)*rank,1);
#219    for(i=0;i<odom->rank;i++) {
#223    for(i=0;i<odom->rank;i++) {
#239    if(odom->rank == 0) return 0;
#240    for(i=odom->rank-1;i>=0;i--) {
#255    for(i=0;i<odom->rank;i++) {
test_put.c#23    const int rank,
#30    return MAX(minMIN(maxhash4typerankindexitype)));
#40    const int rank,
#47    return MAX(minMIN(maxhash4typerankindexitype)));
#57    const int rank,
#64    return MAX(minMIN(maxhash4typerankindexitype)));
#74    const int rank,
#81    return MAX(minMIN(maxhash4typerankindexitype)));
#91    const int rank,
#98    return MAX(minMIN(maxhash4typerankindexitype)));
#108    const int rank,
#115    return MAX(minMIN(maxhash4typerankindexitype)));
#125    const int rank,
#132    return MAX(minMIN(maxhash4typerankindexitype)));
#142    const int rank,
#149    return MAX(minMIN(maxhash4typerankindexitype)));
#159    const int rank,
#166    return MAX(minMIN(maxhash4typerankindexitype)));
#176    const int rank,
#183    return MAX(minMIN(maxhash4typerankindexitype)));
#193    const int rank,
#200    return MAX(minMIN(maxhash4typerankindexitype)));
#210    const int rank,
#217    return MAX(minMIN(maxhash4typerankindexitype)));
test_vara.c#37    int rank;
#50static Odomodom_create(int rank);
#148static Odomodom_create(int rank)
#152    odom->rank = rank;
#153    odom->index = (size_t*)calloc(sizeof(size_t)*rank,1);
#154    odom->stop = (size_t*)calloc(sizeof(size_t)*rank,1);
#155    odom->start = (size_t*)calloc(sizeof(size_t)*rank,1);
#156    odom->count = (size_t*)calloc(sizeof(size_t)*rank,1);
#174    for(i=0;i<odom->rank;i++) {
#178    for(i=0;i<odom->rank;i++) {
#192    if(odom->rank == 0) return 0;
#193    for(i=odom->rank-1;i>=0;i--) {
#207    for(i=0;i<odom->rank;i++) {
tests.h#536double hash( const nc_type type, const int rank, const size_t *index );
#540    const int rank,
tst_chunk_hdf4.c#31   int rank;
#47      if(nc_inq_varndims(ncid,varid,&rank)) ERR;
#58      for(d=0;d<rank;d++) {
#76      if(nc_inq_varndims(ncid,varid,&rank)) ERR;
tst_formatx_pnetcdf.c#31    int nprocsrank;
#39    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
#41    if (nprocs > 1 && rank == 0)
#43    if (rank > 0) goto fn_exit;
tst_h4_lendian.c#61    int32 dims[2], start[2], edges[2], rank;
tst_parallel3.c#706    int rankprocs;
#716    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
#738    start[0] = rank;
#741    count[1] = rank;
tst_pnetcdf.c#27    int ijranknprocsncidcmodevarid[NVARS], dimid[2], *buf;
#38    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
#40    if (nprocs > 1 && rank == 0)
#42    if (rank > 0) goto fn_exit;
util.c#377hash( const nc_type type, const int rank, const size_t *index )
#385    if (abs(rank) == 1 && index[0] <= 3) {
#468 result = rank < 0 ? base * 7 : base * (rank + 1);
#469 for (d = 0; d < abs(rank); d++)
#482hash( const nc_type type, const int rank, const size_t *index )
#490    if (abs(rank) == 1 && index[0] <= 3) {
#573 result = rank < 0 ? base * 7 : base * (rank + 1);
#574 for (d = 0; d < abs(rank); d++)
#584    const int rank,
#590    result = hashtyperankindex );
#672 size_t rank;
#684 for (rank = 0, vn = 0, xtype = 0, an = 0;  rank <= MAX_RANKrank++)
#687 const size_t nvars = product(rankmax_dim_len);
#693 const int ntypes = rank < 2 ? numTypes : 1;
#703 var_rank[vn] = rank;
#704 var_natts[vn] = rank == 0 ? vn % (MAX_NATTS + 1) : 0;
#716 assert(toMixedBase (jjrankmax_dim_lentmp) == 0);
#718 (void) toMixedBase (jjrankmax_dim_lentmp);
#722 for (dn = 0; dn < rankdn++)
#724 for (dn = 0, var_nels[vn] = 1; dn < rankdn++)
vardata.c#432    int rank = vp->ndims;
#433    size_t ncols = rank > 0 ? vdims[rank - 1] : 1; /* number of values in a row */
#439    if (rank > 0)
#441    for(i = level + 1; i < ranki++) {
#448    if(rank - level > 1) {      /* this level is just d0 next levels */
#449 size_t *local_cor = emalloc((rank + 1) * sizeof(size_t));
#450 size_t *local_edg = emalloc((rank + 1) * sizeof(size_t));
#451 for(i = 0; i < ranki++) {
#470 if(formatting_specs.brief_data_cmnts && rank > 1 && ncols > 0) {
#494 for(j = 0; j < rank - 1; j++) {


HyperKWIC - Version 7.20DA executed at 11:37 on 27 Oct 2017 | Polyhedron Solutions - INTERNAL USE | COMMERCIAL (Any O/S) SN 4AKIed