Changeset 473 for trunk/user/fft


Ignore:
Timestamp:
Aug 21, 2018, 6:01:01 PM (6 years ago)
Author:
alain
Message:

Fix several GCC warning related to the -Wextra compilation option.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/user/fft/fft.c

    r469 r473  
    8888#define CHECK                   0
    8989#define DEBUG_MAIN              1
    90 #define DEBUG_FFT1D             0
     90#define DEBUG_FFT1D             1
    9191#define DEBUG_ONCE              0
    9292#define MODE                    COSIN
    … …  
    102102unsigned int   y_size;                     // number of clusters per column in the mesh
    103103unsigned int   ncores;                     // number of cores per cluster
    104 long           nthreads;                   // total number of threads (one thread per core)
    105 long           nclusters;                  // total number of clusters
    106 long           M = DEFAULT_M;              // log2(number of points)
    107 long           N;                          // number of points (N = 2^M)         
    108 long           rootN;                      // rootN = 2^M/2   
    109 long           rows_per_thread;            // number of data "rows" handled by a single thread
    110 long           points_per_cluster;         // number of data points per cluster
     104unsigned int   nthreads;                   // total number of threads (one thread per core)
     105unsigned int   nclusters;                  // total number of clusters
     106unsigned int   M = DEFAULT_M;              // log2(number of points)
     107unsigned int   N;                          // number of points (N = 2^M)         
     108unsigned int   rootN;                      // rootN = 2^M/2   
     109unsigned int   rows_per_thread;            // number of data "rows" handled by a single thread
     110unsigned int   points_per_cluster;         // number of data points per cluster
    111111
    112112// arrays of pointers on distributed buffers (one sub-buffer per cluster)
    … …  
    129129pthread_t       trdid[THREADS_MAX];        // kernel threads identifiers
    130130pthread_attr_t  attr[THREADS_MAX];         // POSIX thread attributes
    131 long            args[THREADS_MAX];         // slave function arguments
     131unsigned int    args[THREADS_MAX];         // slave function arguments
    132132
    133133/////////////////////////////////////////////////////////////////////////////////
    … …  
    137137void slave();
    138138
    139 double CheckSum(double ** x);
     139double CheckSum();
    140140
    141141void InitX(double ** x , unsigned int mode);
    … …  
    145145void InitT(double ** u);
    146146
    147 long BitReverse( long k );
    148 
    149 void FFT1D( long direction , double ** x , double ** tmp , double * upriv,
    150             double ** twid , long MyNum , long MyFirst , long MyLast );
    151 
    152 void TwiddleOneCol(long direction, long j, double ** u, double ** x, long offset_x );
    153 
    154 void Scale( double **x, long offset_x );
    155 
    156 void Transpose( double ** src, double ** dest, long MyFirst, long MyLast );
    157 
    158 void Copy( double ** src, double ** dest, long MyFirst , long MyLast );
    159 
    160 void Reverse( double ** x, long offset_x );
    161 
    162 void FFT1DOnce( long direction , double * u , double ** x , long offset_x );
    163 
    164 void PrintArray( double ** x , long size );
    165 
    166 void SimpleDft( long direction , long size , double ** src , long src_offset ,
    167                 double ** dst , long dst_offset );
     147unsigned int BitReverse( unsigned int k );
     148
     149void FFT1D( int          direction,
     150            double    ** x,
     151            double    ** tmp,
     152            double     * upriv,
     153            double    ** twid,
     154            unsigned int MyNum,
     155            unsigned int MyFirst,
     156            unsigned int MyLast );
     157
     158void TwiddleOneCol( int          direction,
     159                    unsigned int j,
     160                    double    ** u,
     161                    double    ** x,
     162                    unsigned int offset_x );
     163
     164void Scale( double    ** x,
     165            unsigned int offset_x );
     166
     167void Transpose( double    ** src,
     168                double    ** dest,
     169                unsigned int MyFirst,
     170                unsigned int MyLast );
     171
     172void Copy( double    ** src,
     173           double    ** dest,
     174           unsigned int MyFirst,
     175           unsigned int MyLast );
     176
     177void Reverse( double    ** x,
     178              unsigned int offset_x );
     179
     180void FFT1DOnce( int          direction,
     181                double     * u,
     182                double    ** x,
     183                unsigned int offset_x );
     184
     185void PrintArray( double ** x,
     186                 unsigned int size );
     187
     188void SimpleDft( int          direction,
     189                unsigned int size,
     190                double    ** src,
     191                unsigned int src_offset,
     192                double    ** dst,
     193                unsigned int dst_offset );
    168194
    169195///////////////////////////////////////////////////////////////////
    … …  
    256282    // allocate memory for the distributed data[i], trans[i], umain[i], twid[i] buffers
    257283    // the index (i) is a continuous cluster index
    258     long data_size   = (N / nclusters) * 2 * sizeof(double);
    259     long coefs_size  = (rootN / nclusters) * 2 * sizeof(double);
     284    unsigned int data_size   = (N / nclusters) * 2 * sizeof(double);
     285    unsigned int coefs_size  = (rootN / nclusters) * 2 * sizeof(double);
    260286    for (x = 0 ; x < x_size ; x++)
    261287    {
    … …  
    278304
    279305#if CHECK
    280 ck1 = CheckSum( data );
     306ck1 = CheckSum();
    281307#endif
    282308
    … …  
    298324    barrierattr.y_size   = y_size;
    299325    barrierattr.nthreads = ncores;
    300     pthread_barrier_init( &barrier, &barrierattr , nthreads);
     326    if( pthread_barrier_init( &barrier, &barrierattr , nthreads) )
     327    {
     328        printf("\n[FFT ERROR] cannot initialize barrier\n");
     329        exit( 0 );
     330    }
     331
     332    printf("\n[FFT] main completes barrier init\n");
    301333
    302334    // launch other threads to execute the slave() function
    … …  
    331363                    }
    332364#if DEBUG_MAIN
    333 printf("\n[FFT] thread %x created\n", trdid[tid] );
     365printf("\n[FFT] main created thread %x\n", trdid[tid] );
    334366#endif
    335367                }
    … …  
    354386            {
    355387                // compute thread continuous index
    356                 long tid = (((x * y_size) + y) * ncores) + lid;
     388                tid = (((x * y_size) + y) * ncores) + lid;
    357389
    358390                if( tid != main_tid )
    … …  
    386418
    387419#if CHECK
    388 ck3 = CheckSum( data );
     420ck3 = CheckSum();
    389421printf("\n*** Results ***\n");
    390422printf("Checksum difference is %f (%f, %f)\n", ck1 - ck3, ck1, ck3);
    … …  
    446478// This function is executed in parallel by all threads.
    447479///////////////////////////////////////////////////////////////
    448 void slave( long * tid )
    449 {
    450     long       i;
    451     long       MyNum;           // continuous thread index
    452     long       MyFirst;         // index first row allocated to thread
    453     long       MyLast;          // index last row allocated to thread
    454     double   * upriv;
    455     long       c_id;
    456     long       c_offset;
     480void slave( unsigned int * tid )
     481{
     482    unsigned int   i;
     483    unsigned int   MyNum;           // continuous thread index
     484    unsigned int   MyFirst;         // index first row allocated to thread
     485    unsigned int   MyLast;          // index last row allocated to thread
     486    double       * upriv;
     487    unsigned int   c_id;
     488    unsigned int   c_offset;
    457489
    458490    unsigned long long  parallel_start;
    … …  
    517549// buffer, to the dst[nclusters][points_per_cluster] distributed buffer.
    518550////////////////////////////////////////////////////////////////////////////////////////
    519 void SimpleDft( long      direction,
    520                 long      size,           // number of points
    521                 double ** src,            // source distributed buffer
    522                 long      src_offset,     // offset in source array
    523                 double ** dst,            // destination distributed buffer
    524                 long      dst_offset )    // offset in destination array
    525 {
    526     long    n , k;
    527     double  phi;            // 2*PI*n*k/N
    528     double  u_r;            // cos( phi )
    529     double  u_c;            // sin( phi )
    530     double  d_r;            // Re(data[n])
    531     double  d_c;            // Im(data[n])
    532     double  accu_r;         // Re(accu)
    533     double  accu_c;         // Im(accu)
    534     long    c_id;           // distributed buffer cluster index
    535     long    c_offset;       // offset in distributed buffer
     551void SimpleDft( int             direction,      // 1 direct / -1 reverse
     552                unsigned int    size,           // number of points
     553                double       ** src,            // source distributed buffer
     554                unsigned int    src_offset,     // offset in source array
     555                double       ** dst,            // destination distributed buffer
     556                unsigned int    dst_offset )    // offset in destination array
     557{
     558    unsigned int  n , k;
     559    double        phi;            // 2*PI*n*k/N
     560    double        u_r;            // cos( phi )
     561    double        u_c;            // sin( phi )
     562    double        d_r;            // Re(data[n])
     563    double        d_c;            // Im(data[n])
     564    double        accu_r;         // Re(accu)
     565    double        accu_c;         // Im(accu)
     566    unsigned int  c_id;           // distributed buffer cluster index
     567    unsigned int  c_offset;       // offset in distributed buffer
    536568
    537569    for ( k = 0 ; k < size ; k++ )       // loop on the output data points
    … …  
    551583            c_id     = (src_offset + n) / (points_per_cluster);
    552584            c_offset = (src_offset + n) % (points_per_cluster);
    553             d_r      = data[c_id][2*c_offset];
    554             d_c      = data[c_id][2*c_offset+1];
     585            d_r      = src[c_id][2*c_offset];
     586            d_c      = src[c_id][2*c_offset+1];
    555587
    556588            // increment accu
    … …  
    575607}  // end SimpleDft()
    576608
    577 ////////////////////////////
    578 double CheckSum(double ** x)
    579 {
    580     long i , j;
     609/////////////////
     610double CheckSum()
     611{
     612    unsigned int        i , j;
    581613    double       cks;
    582     long c_id;
    583     long c_offset;
     614    unsigned int        c_id;
     615    unsigned int        c_offset;
    584616
    585617    cks = 0.0;
    … …  
    602634           unsigned int   mode )
    603635{
    604     long    i , j;
    605     long    c_id;
    606     long    c_offset;
    607     long    index;
     636    unsigned int    i , j;
     637    unsigned int    c_id;
     638    unsigned int    c_offset;
     639    unsigned int    index;
    608640
    609641    for ( j = 0 ; j < rootN ; j++ )      // loop on row index
    … …  
    618650            if ( mode == RANDOM )               
    619651            {
    620                 data[c_id][2*c_offset]   = ( (double)rand() ) / 65536;
    621                 data[c_id][2*c_offset+1] = ( (double)rand() ) / 65536;
     652                x[c_id][2*c_offset]   = ( (double)rand() ) / 65536;
     653                x[c_id][2*c_offset+1] = ( (double)rand() ) / 65536;
    622654            }
    623655           
    … …  
    627659            {
    628660                double phi = (double)( 2 * PI * index) / N;
    629                 data[c_id][2*c_offset]   = cos( phi );
    630                 data[c_id][2*c_offset+1] = sin( phi );
     661                x[c_id][2*c_offset]   = cos( phi );
     662                x[c_id][2*c_offset+1] = sin( phi );
    631663            }
    632664
    … …  
    634666            if ( mode == CONSTANT )               
    635667            {
    636                 data[c_id][2*c_offset]   = 1.0;
    637                 data[c_id][2*c_offset+1] = 0.0;
     668                x[c_id][2*c_offset]   = 1.0;
     669                x[c_id][2*c_offset+1] = 0.0;
    638670            }
    639671        }
    … …  
    644676void InitU( double ** u )
    645677{
    646     long    q;
    647     long    j;
    648     long    base;
    649     long    n1;
    650     long    c_id;
    651     long    c_offset;
     678    unsigned int    q;
     679    unsigned int    j;
     680    unsigned int    base;
     681    unsigned int    n1;
     682    unsigned int    c_id;
     683    unsigned int    c_offset;
    652684    double  phi;
    653     long    stop = 0;
    654 
    655     for (q = 0 ; ((1 << q) < N) && (stop == 0) ; q++)
     685    unsigned int    stop = 0;
     686
     687    for (q = 0 ; ((unsigned int)(1 << q) < N) && (stop == 0) ; q++)
    656688    { 
    657689        n1 = 1 << q;
    … …  
    673705void InitT( double ** u )
    674706{
    675     long    i, j;
    676     long    index;
    677     long    c_id;
    678     long    c_offset;
     707    unsigned int    i, j;
     708    unsigned int    index;
     709    unsigned int    c_id;
     710    unsigned int    c_offset;
    679711    double  phi;
    680712
    … …  
    697729// This function returns an index value that is the bit reverse of the input value.
    698730////////////////////////////////////////////////////////////////////////////////////////
    699 long BitReverse( long k )
    700 {
    701     long i;
    702     long j;
    703     long tmp;
     731unsigned int BitReverse( unsigned int k )
     732{
     733    unsigned int i;
     734    unsigned int j;
     735    unsigned int tmp;
    704736
    705737    j = 0;
    … …  
    724756// on the rootN points contained in a row.
    725757////////////////////////////////////////////////////////////////////////////////////////
    726 void FFT1D( long       direction,       // direct : 1 / inverse : -1
    727             double **  x,               // input & output distributed data points array
    728             double **  tmp,             // auxiliary distributed data points array
    729             double *   upriv,           // local array containing coefs for rootN FFT
    730             double **  twid,            // distributed arrays containing N twiddle factors
    731             long       MyNum,
    732             long       MyFirst,
    733             long       MyLast )
    734 {
    735     long j;
     758void FFT1D( int              direction,       // direct 1 / inverse -1
     759            double       **  x,               // input & output distributed data points array
     760            double       **  tmp,             // auxiliary distributed data points array
     761            double        *  upriv,           // local array containing coefs for rootN FFT
     762            double       **  twid,            // distributed arrays containing N twiddle factors
     763            unsigned int     MyNum,           // thread continuous index
     764            unsigned int     MyFirst,
     765            unsigned int     MyLast )
     766{
     767    unsigned int j;
    736768    unsigned long long barrier_start;
    737769    unsigned long long barrier_stop;
    … …  
    741773
    742774#if DEBUG_FFT1D
    743 printf("\n@@@ tmp after first transpose\n");
    744 PrintArray( tmp , N );
     775printf("\n[FFT] %s : thread %x after first transpose\n", __FUNCTION__, MyNum);
     776if( VERBOSE ) PrintArray( tmp , N );
    745777#endif
    746778
    … …  
    755787    for (j = MyFirst; j < MyLast; j++)
    756788    {
     789printf("@@@  before FFT1Once / j = %d\n", j );
    757790        FFT1DOnce( direction , upriv , tmp , j * rootN );
     791printf("@@@  after  FFT1Once / j = %d\n", j );
    758792        TwiddleOneCol( direction , j , twid , tmp , j * rootN );
     793printf("@@@  after  Twiddle  / j = %d\n", j );
    759794    } 
    760795
    761796#if DEBUG_FFT1D
    762 printf("\n@@@ tmp after columns FFT + twiddle \n");
    763 PrintArray( tmp , N );
     797printf("\n[FFT] %s : thread %x after first twiddle\n", __FUNCTION__, MyNum);
     798if( VERBOSE ) PrintArray( tmp , N );
    764799#endif
    765800
    … …  
    775810
    776811#if DEBUG_FFT1D
    777 printf("\n@@@ x after second transpose \n");
    778 PrintArray( x , N );
     812printf("\n[FFT] %s : thread %x after second transpose\n", __FUNCTION__, MyNum);
     813if( VERBOSE ) PrintArray( x , N );
    779814#endif
    780815
    … …  
    794829
    795830#if DEBUG_FFT1D
    796 printf("\n@@@ x after rows FFT + scaling \n");
    797 PrintArray( x , N );
     831printf("\n[FFT] %s : thread %x after FFT on rows\n", __FUNCTION__, MyNum);
     832if( VERBOSE ) PrintArray( x , N );
    798833#endif
    799834
    … …  
    809844
    810845#if DEBUG_FFT1D
    811 printf("\n@@@ tmp after third transpose \n");
    812 PrintArray( tmp , N );
     846printf("\n[FFT] %s : thread %x after third transpose\n", __FUNCTION__, MyNum);
     847if( VERBOSE ) PrintArray( x , N );
    813848#endif
    814849
    … …  
    824859
    825860#if DEBUG_FFT1D
    826 printf("\n@@@ x after final copy \n");
    827 PrintArray( x , N );
     861printf("\n[FFT] %s : thread %x after final copy\n", __FUNCTION__, MyNum);
     862if( VERBOSE ) PrintArray( x , N );
    828863#endif
    829864
    … …  
    835870// x[] array by the corresponding twiddle factor, contained in the u[] array.
    836871/////////////////////////////////////////////////////////////////////////////////////
    837 void TwiddleOneCol( long      direction,
    838                     long      j,              // y coordinate in 2D view of coef array
    839                     double ** u,              // coef array base address
    840                     double ** x,              // data array base address
    841                     long      offset_x )      // first point in N points data array
    842 {
    843     long i;
     872void TwiddleOneCol( int             direction,
     873                    unsigned int    j,              // y coordinate in 2D view of coef array
     874                    double       ** u,              // coef array base address
     875                    double       ** x,              // data array base address
     876                    unsigned int    offset_x )      // first point in N points data array
     877{
     878    unsigned int i;
    844879    double       omega_r;
    845880    double       omega_c;
    846881    double       x_r;
    847882    double       x_c;
    848     long        c_id;
    849     long        c_offset;
     883    unsigned int c_id;
     884    unsigned int c_offset;
    850885
    851886    for (i = 0; i < rootN ; i++)  // loop on the rootN points
    … …  
    868903}  // end TwiddleOneCol()
    869904
    870 ////////////////////////
    871 void Scale( double ** x,           // data array base address
    872             long      offset_x )   // first point of the row to be scaled
    873 {
    874     long i;
    875     long c_id;
    876     long c_offset;
     905////////////////////////////
     906void Scale( double      ** x,           // data array base address
     907            unsigned int   offset_x )   // first point of the row to be scaled
     908{
     909    unsigned int i;
     910    unsigned int c_id;
     911    unsigned int c_offset;
    877912
    878913    for (i = 0; i < rootN ; i++)
    … …  
    880915        c_id      = (offset_x + i) / (points_per_cluster);
    881916        c_offset  = (offset_x + i) % (points_per_cluster);
    882         data[c_id][2*c_offset]     /= N;
    883         data[c_id][2*c_offset + 1] /= N;
     917        x[c_id][2*c_offset]     /= N;
     918        x[c_id][2*c_offset + 1] /= N;
    884919    }
    885920}
    886921
    887 ////////////////////////////
    888 void Transpose( double ** src,      // source buffer (array of pointers)
    889                 double ** dest,     // destination buffer (array of pointers)
    890                 long      MyFirst,  // first row allocated to the thread
    891                 long      MyLast )  // last row allocated to the thread
    892 {
    893     long row;               // row index
    894     long point;             // data point index in a row
    895 
    896     long index_src;         // absolute index in the source N points array
    897     long c_id_src;          // cluster for the source buffer
    898     long c_offset_src;      // offset in the source buffer
    899 
    900     long index_dst;         // absolute index in the dest N points array
    901     long c_id_dst;          // cluster for the dest buffer
    902     long c_offset_dst;      // offset in the dest buffer
     922///////////////////////////////////
     923void Transpose( double      ** src,      // source buffer (array of pointers)
     924                double      ** dest,     // destination buffer (array of pointers)
     925                unsigned int   MyFirst,  // first row allocated to the thread
     926                unsigned int   MyLast )  // last row allocated to the thread
     927{
     928    unsigned int row;               // row index
     929    unsigned int point;             // data point index in a row
     930
     931    unsigned int index_src;         // absolute index in the source N points array
     932    unsigned int c_id_src;          // cluster for the source buffer
     933    unsigned int c_offset_src;      // offset in the source buffer
     934
     935    unsigned int index_dst;         // absolute index in the dest N points array
     936    unsigned int c_id_dst;          // cluster for the dest buffer
     937    unsigned int c_offset_dst;      // offset in the dest buffer
    903938
    904939   
    … …  
    924959}  // end Transpose()
    925960
    926 /////////////////////////
    927 void Copy( double ** src,      // source buffer (array of pointers)
    928            double ** dest,     // destination buffer (array of pointers)
    929            long      MyFirst,  // first row allocated to the thread
    930            long      MyLast )  // last row allocated to the thread
    931 {
    932     long row;                  // row index
    933     long point;                // data point index in a row
    934 
    935     long index;                // absolute index in the N points array
    936     long c_id;                 // cluster index
    937     long c_offset;             // offset in local buffer
     961//////////////////////////////
     962void Copy( double      ** src,      // source buffer (array of pointers)
     963           double      ** dest,     // destination buffer (array of pointers)
     964           unsigned int   MyFirst,  // first row allocated to the thread
     965           unsigned int   MyLast )  // last row allocated to the thread
     966{
     967    unsigned int row;                  // row index
     968    unsigned int point;                // data point index in a row
     969
     970    unsigned int index;                // absolute index in the N points array
     971    unsigned int c_id;                 // cluster index
     972    unsigned int c_offset;             // offset in local buffer
    938973
    939974    // scan all data points allocated to the thread
    … …  
    952987}  // end Copy()
    953988
    954 //////////////////////////
    955 void Reverse( double ** x,
    956               long      offset_x )
    957 {
    958     long j, k;
    959     long c_id_j;
    960     long c_offset_j;
    961     long c_id_k;
    962     long c_offset_k;
     989///////////////////////////////
     990void Reverse( double      ** x,
     991              unsigned int   offset_x )
     992{
     993    unsigned int j, k;
     994    unsigned int c_id_j;
     995    unsigned int c_offset_j;
     996    unsigned int c_id_k;
     997    unsigned int c_offset_k;
    963998
    964999    for (k = 0 ; k < rootN ; k++)
    … …  
    9821017// (i.e. rootN points) of the x[nclusters][points_per_cluster] array.
    9831018/////////////////////////////////////////////////////////////////////////////
    984 void FFT1DOnce( long      direction,  // direct / inverse
    985                 double * u,          // private coefs array
    986                 double ** x,          // array of pointers on distributed buffers
    987                 long      offset_x )  // absolute offset in the x array
    988 {
    989     long     j;
    990     long     k;
    991     long     q;
    992     long     L;
    993     long     r;
    994     long     Lstar;
     1019void FFT1DOnce( int            direction,  // 1 direct / -1 inverse
     1020                double       * u,          // private coefs array
     1021                double      ** x,          // array of pointers on distributed buffers
     1022                unsigned int   offset_x )  // absolute offset in the x array
     1023{
     1024    unsigned int     j;
     1025    unsigned int     k;
     1026    unsigned int     q;
     1027    unsigned int     L;
     1028    unsigned int     r;
     1029    unsigned int     Lstar;
    9951030    double * u1;
    9961031
    997     long     offset_x1;     // index first butterfly input
    998     long     offset_x2;     // index second butterfly output
    999 
    1000     double   omega_r;       // real part butterfy coef
    1001     double   omega_c;       // complex part butterfly coef
    1002 
    1003     double   tau_r;
    1004     double   tau_c;
    1005 
    1006     double   d1_r;          // real part first butterfly input
    1007     double   d1_c;          // imag part first butterfly input
    1008     double   d2_r;          // real part second butterfly input
    1009     double   d2_c;          // imag part second butterfly input
    1010 
    1011     long     c_id_1;        // cluster index for first butterfly input
    1012     long     c_offset_1;    // offset for first butterfly input
    1013     long     c_id_2;        // cluster index for second butterfly input
    1014     long     c_offset_2;    // offset for second butterfly input
     1032    unsigned int     offset_x1;     // index first butterfly input
     1033    unsigned int     offset_x2;     // index second butterfly output
     1034
     1035    double           omega_r;       // real part butterfy coef
     1036    double           omega_c;       // complex part butterfly coef
     1037
     1038    double           tau_r;
     1039    double           tau_c;
     1040
     1041    double           d1_r;          // real part first butterfly input
     1042    double           d1_c;          // imag part first butterfly input
     1043    double           d2_r;          // real part second butterfly input
     1044    double           d2_c;          // imag part second butterfly input
     1045
     1046    unsigned int     c_id_1;        // cluster index for first butterfly input
     1047    unsigned int     c_offset_1;    // offset for first butterfly input
     1048    unsigned int     c_id_2;        // cluster index for second butterfly input
     1049    unsigned int     c_offset_2;    // offset for second butterfly input
    10151050
    10161051#if DEBUG_ONCE
    … …  
    10201055for ( p = 0 ; p < rootN ; p++ )
    10211056{
    1022     long index    = offset_x + p;
    1023     long c_id     = index / (points_per_cluster);
    1024     long c_offset = index % (points_per_cluster);
     1057    unsigned int index    = offset_x + p;
     1058    unsigned int c_id     = index / (points_per_cluster);
     1059    unsigned int c_offset = index % (points_per_cluster);
    10251060    printf("%f , %f | ", x[c_id][2*c_offset] , x[c_id][2*c_offset+1] );
    10261061}
    … …  
    10351070for ( p = 0 ; p < rootN ; p++ )
    10361071{
    1037     long index    = offset_x + p;
    1038     long c_id     = index / (points_per_cluster);
    1039     long c_offset = index % (points_per_cluster);
     1072    unsigned int index    = offset_x + p;
     1073    unsigned int c_id     = index / (points_per_cluster);
     1074    unsigned int c_offset = index % (points_per_cluster);
    10401075    printf("%f , %f | ", x[c_id][2*c_offset] , x[c_id][2*c_offset+1] );
    10411076}
    … …  
    11061141for ( p = 0 ; p < rootN ; p++ )
    11071142{
    1108     long index    = offset_x + p;
    1109     long c_id     = index / (points_per_cluster);
    1110     long c_offset = index % (points_per_cluster);
     1143    unsigned int index    = offset_x + p;
     1144    unsigned int c_id     = index / (points_per_cluster);
     1145    unsigned int c_offset = index % (points_per_cluster);
    11111146    printf("%f , %f | ", x[c_id][2*c_offset] , x[c_id][2*c_offset+1] );
    11121147}
    … …  
    11161151}  // end FFT1DOnce()
    11171152
    1118 //////////////////////////////////
    1119 void PrintArray( double ** array,
    1120                  long      size )
    1121 {
    1122     long  i;
    1123     long  c_id;
    1124     long  c_offset;
     1153///////////////////////////////////////
     1154void PrintArray( double       ** array,
     1155                 unsigned int    size )
     1156{
     1157    unsigned int  i;
     1158    unsigned int  c_id;
     1159    unsigned int  c_offset;
    11251160
    11261161    // float display
Note: See TracChangeset for help on using the changeset viewer.