RWalib C Array Library User Guide > Array Indexing > alibGetRange
  

alibGetRange
Retrieves a contiguous subarray of an array. The PV-WAVE API for this routine is array indexing that uses any combination of scalars and range operators. This routine can be used for slicing and more generally for retrieving any m-dimensional box from any n-dimensional array (m <= n).
Prototypes
void alibGetRangeb( wvlong n, wvlong *d, wvlong *b, wvlong *e, UCHAR *p, UCHAR *q )
void alibGetRanges( wvlong n, wvlong *d, wvlong *b, wvlong *e, short *p, short *q )
void alibGetRangei( wvlong n, wvlong *d, wvlong *b, wvlong *e, int *p, int *q )
void alibGetRangel( wvlong n, wvlong *d, wvlong *b, wvlong *e, wvlong *p, wvlong *q )
void alibGetRangef( wvlong n, wvlong *d, wvlong *b, wvlong *e, float *p, float *q )
void alibGetRanged( wvlong n, wvlong *d, wvlong *b, wvlong *e, double *p, double *q )
void alibGetRangec( wvlong n, wvlong *d, wvlong *b, wvlong *e, COMPLEX *p, COMPLEX *q )
void alibGetRangez( wvlong n, wvlong *d, wvlong *b, wvlong *e, DCOMPLEX *p, DCOMPLEX *q )
Parameters
n — (Input) The number of dimensions in the source array.
*d — (Input) The n-element array of dimensions in the source array.
*b — (Input) The n-element array of beginning subscripts defining the 'lower-left' corner of the m-dimensional box to be retrieved from the source array.
*e — (Input) The n-element array of ending subscripts defining the 'upper-right' corner of the m-dimensional box to be retrieved from the source array. Note that if b[i] = e[i] for some i then m < n, e.g., as in slicing.
*p — (Input) The source array.
*q — (Input/Output) The destination array. On return, array q is a copy of the box in array p defined by corners b and e.
Example
Here we extract the interior of a one-dimensional, a two-dimensional, a three-dimensional, and a four-dimensional array.
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include "alib.h"
void main() {
   wvlong dims[4] = {3,4,5,6};
   wvlong begs[4] = {1,1,1,1};
   wvlong ends[4] = {1,2,3,4};
   short    *s, *s0;
   s0 = (short*)malloc(360*sizeof(short));
   s  = (short*)malloc(360*sizeof(short));
   alibinit( NULL, NULL, NULL, NULL );
   printf( "\n\n fabricate some test data" );
   alibIndexs( 360, 0, 1, s0 );
   printf( "\n\n print a 1d-array, then extract its interior and print it" );
   alibPrintArrays( 1, 1, 1, 6, s0, NULL );
   alibGetRanges( 1, &dims[3], &begs[3], &ends[3], s0, s );
   alibPrintArrays( 1, 1, 1, 4, s, NULL );
   printf( "\n\n print a 2d-array, then extract its interior and print it" );
   alibPrintArrays( 1, 1, 5, 6, s0, NULL );
   alibGetRanges( 2, &dims[2], &begs[2], &ends[2], s0, s );
   alibPrintArrays( 1, 1, 3, 4, s, NULL );
   printf( "\n\n print a 3d-array, then extract its interior and print it" );
   alibPrintArrays( 1, 4, 5, 6, s0, NULL );
   alibGetRanges( 3, &dims[1], &begs[1], &ends[1], s0, s );
   alibPrintArrays( 1, 2, 3, 4, s, NULL );
   printf( "\n\n print a 4d-array, then extract its interior and print it" );
   alibPrintArrays( 3, 4, 5, 6, s0, NULL );
   alibGetRanges( 4, dims, begs, ends, s0, s );
   alibPrintArrays( 1, 2, 3, 4, s, NULL );
}
 
Output:
 
 print a 1d-array, then extract its interior and print it
 
       0       1       2       3       4       5
 
       1       2       3       4
 
 print a 2d-array, then extract its interior and print it
 
       0       1       2       3       4       5
       6       7       8       9      10      11
      12      13      14      15      16      17
      18      19      20      21      22      23
      24      25      26      27      28      29
 
       7       8       9      10
      13      14      15      16
      19      20      21      22
 
 print a 3d-array, then extract its interior and print it
 
       0       1       2       3       4       5
       6       7       8       9      10      11
      12      13      14      15      16      17
      18      19      20      21      22      23
      24      25      26      27      28      29
 
      30      31      32      33      34      35
      36      37      38      39      40      41
      42      43      44      45      46      47
      48      49      50      51      52      53
      54      55      56      57      58      59
 
      60      61      62      63      64      65
      66      67      68      69      70      71
      72      73      74      75      76      77
      78      79      80      81      82      83
      84      85      86      87      88      89
 
      90      91      92      93      94      95
      96      97      98      99     100     101
     102     103     104     105     106     107
     108     109     110     111     112     113
     114     115     116     117     118     119
 
      37      38      39      40
      43      44      45      46
      49      50      51      52
 
      67      68      69      70
      73      74      75      76
      79      80      81      82
 
 print a 4d-array, then extract its interior and print it
 
       0       1       2       3       4       5
       6       7       8       9      10      11
      12      13      14      15      16      17
      18      19      20      21      22      23
      24      25      26      27      28      29
 
      30      31      32      33      34      35
      36      37      38      39      40      41
      42      43      44      45      46      47
      48      49      50      51      52      53
      54      55      56      57      58      59
 
      60      61      62      63      64      65
      66      67      68      69      70      71
      72      73      74      75      76      77
      78      79      80      81      82      83
      84      85      86      87      88      89
 
      90      91      92      93      94      95
      96      97      98      99     100     101
     102     103     104     105     106     107
     108     109     110     111     112     113
     114     115     116     117     118     119
 
     120     121     122     123     124     125
     126     127     128     129     130     131
     132     133     134     135     136     137
     138     139     140     141     142     143
     144     145     146     147     148     149
 
     150     151     152     153     154     155
     156     157     158     159     160     161
     162     163     164     165     166     167
     168     169     170     171     172     173
     174     175     176     177     178     179
 
     180     181     182     183     184     185
     186     187     188     189     190     191
     192     193     194     195     196     197
     198     199     200     201     202     203
     204     205     206     207     208     209
 
     210     211     212     213     214     215
     216     217     218     219     220     221
     222     223     224     225     226     227
     228     229     230     231     232     233
     234     235     236     237     238     239
 
     240     241     242     243     244     245
     246     247     248     249     250     251
     252     253     254     255     256     257
     258     259     260     261     262     263
     264     265     266     267     268     269
 
     270     271     272     273     274     275
     276     277     278     279     280     281
     282     283     284     285     286     287
     288     289     290     291     292     293
     294     295     296     297     298     299
 
     300     301     302     303     304     305
     306     307     308     309     310     311
     312     313     314     315     316     317
     318     319     320     321     322     323
     324     325     326     327     328     329
 
     330     331     332     333     334     335
     336     337     338     339     340     341
     342     343     344     345     346     347
     348     349     350     351     352     353
     354     355     356     357     358     359
 
     157     158     159     160
     163     164     165     166
     169     170     171     172
 
     187     188     189     190
     193     194     195     196
     199     200     201     202

Version 2017.0
Copyright © 2017, Rogue Wave Software, Inc. All Rights Reserved.