void *performXCorr(){ int d; if(fillingB1){ d = xcorr(ch1b0, ch0b0, SMPSZ); }else{ d = xcorr(ch1b1, ch0b1, SMPSZ); } printf("%d\n", d); return 0; }
void cFilterSpatial<T>::filterSpatial(cData3<T>& data, eXCorrRes shape) { const std::string funcName("void cFilterSpatial<T>::filterSpatial(" "cData3<T>& data, eXCorrRes shape)"); data.requireNonEmpty(funcName); _kernel.requireNonEmpty(funcName); require(data.getDimension() == _kernel.getDimension(), funcName + ": data and _kernel have different dimensions"); cData3<T> other(data.getSize() + _kernel.getSize() - 1); switch (data.getDimension()) { case 1: xcorr(_kernel.getAddrData(), _kernel.getNrow(), data.getAddrData(), data.getNrow(), other.getAddrData(), XCORR_RES_FULL); break; case 2: xcorr(_kernel.getAddrData(), _kernel.getNrow(), _kernel.getNcol(), data.getAddrData(), data.getNrow(), data.getNcol(), other.getAddrData(), XCORR_RES_FULL); break; case 3: xcorr(_kernel.getAddrData(), _kernel.getNrow(), _kernel.getNcol(), _kernel.getNsec(), data.getAddrData(), data.getNrow(), data.getNcol(), data.getNsec(), other.getAddrData(), XCORR_RES_FULL); break; default: ERROR(funcName, "unsupported dimension"); } // cropping switch (shape) { case XCORR_RES_FULL: data = other; break; case XCORR_RES_SAME: array_crop(other.getAddrData(), other.getNrow(), other.getNcol(), other.getNsec(), data.getAddrData(), data.getNrow(), data.getNcol(), data.getNsec(), (_kernel.getNrow()-1)/2, (_kernel.getNcol()-1)/2, (_kernel.getNsec()-1)/2); break; case XCORR_RES_VALID: ERROR(funcName, "unsupported xcorr mode"); break; default: ERROR(funcName, "unsupported xcorr mode"); } }
int main(int argc, char** argv) { std::cout.precision(10); options opt(argc, argv, 14); if (!opt.valid) std::abort(); boost::timer tm; double t1 = tm.elapsed(); // lattice structure int n = opt.N; int ibond = n; std::vector<int> ipair; for (int i = 0; i < ibond; ++i) { ipair.push_back(i); ipair.push_back((i + 1) % n); } // Hamiltonian parameters std::vector<double> bondwt(ibond, -1); std::vector<double> zrtio(ibond, 1); // table of configurations and Hamiltonian operator subspace ss(n, 0); hamiltonian hop(ss, ipair, bondwt, zrtio); // Hamiltonian matrix matrix_type elemnt; elm3(hop, elemnt); double t2 = tm.elapsed(); std::vector<double> E; matrix_type v; int nvec = 1; diag(elemnt, E, v, nvec); double t3 = tm.elapsed(); int ne = 4; std::cout << "[Eigenvalues]\n"; for (int i = 0; i < ne; ++i) std::cout << '\t' << E[i]; std::cout << std::endl; // // Do not forget to call elm3 again before calling check3 elm3(hop, elemnt); check3(elemnt, v, 0); double t4 = tm.elapsed(); std::vector<int> npair; npair.push_back(1); npair.push_back(2); std::vector<double> sxx(1); xcorr(ss, npair, v, 0, sxx); std::cout << "sxx: " << sxx[0] << std::endl; std::vector<double> szz(1); zcorr(ss, npair, v, 0, szz); std::cout << "szz: " << szz[0] << std::endl; double t5 = tm.elapsed(); std::cerr << "initialize " << (t2-t1) << " sec\n" << "diagonalization " << (t3-t2) << " sec\n" << "check " << (t4-t3) << " sec\n" << "correlation " << (t5-t4) << " sec\n"; }
cvec xcorr(const cvec &x, const cvec &y, const int max_lag, const std::string scaleopt) { cvec out(2*x.length() - 1); //Initial size does ont matter, it will get adjusted xcorr(x, y, out, max_lag, scaleopt, false); return out; }
vec xcorr(const vec &x, const vec &y, const int max_lag, const std::string scaleopt) { cvec out(2*x.length() - 1); //Initial size does ont matter, it will get adjusted xcorr(to_cvec(x), to_cvec(y), out, max_lag, scaleopt, false); return real(out); }
std::pair<float, float> delay(const std::vector<int16_t>& buffer, unsigned int ch1, unsigned int ch2, int range){ std::vector<std::pair<float, float> > corrs = xcorr(buffer, ch1, ch2, range+2); //TODO: Should this +2 be gone now? float ac1 = dotWithOffset(buffer, ch1, ch1, 0); float ac2 = dotWithOffset(buffer, ch2, ch2, 0); int maxOffset = 0; std::pair<float, float> maxVal = corrs[0]; for(int i=1; i<corrs.size(); i++){ if(corrs[i].second > maxVal.second){ maxVal = corrs[i]; maxOffset = i; } else if(corrs[i].second == maxVal.second && std::abs(corrs[i].first) < std::abs(maxVal.first)){ maxVal = corrs[i]; maxOffset = i; } } return std::make_pair(maxVal.first, maxVal.second/std::sqrt(ac1*ac2)); }
void corr() { int i; int tmp; int tmp_nfft = nfft/2; Complex *rm = (Complex *)malloc( nfft * sizeof( Complex )); for(i = 0; i < nfft; i++) { tmp = pri.n - i -1; tmp = (tmp>0) ? tmp : (-tmp); *(rm+i) = xcorr(pri.dt, pri.n, tmp); } Complex *nf = fft(rm, nfft, nfft); free(rm); if( ret.x ) free(ret.x); if( ret.y ) free( ret.y ); ret.x = (double *)malloc( (tmp_nfft) *sizeof(double)); ret.y = (double *)malloc( (tmp_nfft) *sizeof(double)); for(i = 0; i < tmp_nfft; i++) { double l = abs( *(nf+i) ); *(ret.y+i) = 10*log10(l); *(ret.x+i) = i*fs/nfft; } free(nf); ret.xlabel = "(Hz)"; ret.ylabel = "(db)"; ret.n = tmp_nfft; }
/** * Process input data stream */ void DoubleClickFilter::process() { // Store latest input (shift the buffer for( int k=0; k<mInputStream.rows; k++ ) { mInputStream.at< float >(k, 0) = mInputStream.at< float >(k+1, 0); } mInputStream.at< float >( mInputStream.rows-1, 0) = Input; // Find maximum cross correlation with a pattern double max = 0.0; for( int i=0; i<mPatterns.size(); i++ ) { double x = xcorr( mPatterns.at(i), mInputStream ); max = qMax( max, x ); } XCorr = max; // If the pattern matches the input stream the xcorr is > Threshold, // in this case trigger the detected() signal. if( max >= Threshold ) { emit detected(); Detected = true; } else { Detected = false; } }
void xcorr(const vec &x, const vec &y, vec &out, const int max_lag, const std::string scaleopt) { cvec xx = to_cvec(x); cvec yy = to_cvec(y); cvec oo = to_cvec(out); xcorr(xx, yy, oo, max_lag, scaleopt, false); out = real(oo); }
}END_TEST START_TEST(test_correct_code_xcorr) { si32 * result; si8 input1[10] = { 0, 1, 0, 1, 1, 1, 0, 0, 0, 0 }; si32 input1Size = 10; si8 input2[5] = { 0, 1, 1, 1, 0 }; si32 input2Size = 5; si32 trueVal[10] = { 1, -1, 5, 1, -1, -3, -2, -1, 0, 1 }; si32 inda = 0; result = xcorr(input1, input1Size, input2, input2Size); ck_assert(result != NULL); for (inda = 0; inda < 10; inda++) { ck_assert_int_eq(trueVal[inda], result[inda]); } free(result); }END_TEST
void normxcorrmw(T *tplData, size_t tplNrow, size_t tplNcol, size_t tplNsec, T *tplWght, T *refData, size_t refNrow, size_t refNcol, size_t refNsec, T *refWght, T *resData, T *mskData, eXCorrRes shape) { assert(tplData != NULL && refData != NULL && resData != NULL); assert(tplWght != NULL && refWght != NULL && mskData != NULL); assert(tplNrow > 0 && tplNcol > 0 && tplNsec > 0); assert(refNrow > 0 && refNcol > 0 && refNsec > 0); T *tplDataTmp = NULL, *refDataTmp = NULL, *tplWghtTmp = NULL, *refWghtTmp = NULL, *fftTmp1 = NULL, *fftTmp2 = NULL; size_t resNrow = 0, resNcol = 0, resNsec = 0, tplSize, refSize, resSize; if (shape != XCORR_RES_FULL && shape != XCORR_RES_VALID) { shape = XCORR_RES_FULL; } switch (shape) { case XCORR_RES_FULL: resNrow = refNrow + tplNrow - 1; resNcol = refNcol + tplNcol - 1; resNsec = refNsec + tplNsec - 1; break; case XCORR_RES_VALID: resNrow = refNrow - tplNrow + 1; resNcol = refNcol - tplNcol + 1; resNsec = refNsec - tplNsec + 1; break; default: ERROR("normxcorrmw", "unsupported xcorr mode"); } tplSize = tplNrow * tplNcol * tplNsec; refSize = refNrow * refNcol * refNsec; resSize = resNrow * resNcol * resNsec; // allocate arrays as copies of input arrays array_new(tplDataTmp, tplSize); array_new(refDataTmp, refSize); memcpy(tplDataTmp, tplData, tplSize*sizeof(T)); memcpy(refDataTmp, refData, refSize*sizeof(T)); array_new(tplWghtTmp, tplSize); array_new(refWghtTmp, tplSize); memcpy(tplWghtTmp, tplWght, tplSize*sizeof(T)); memcpy(refWghtTmp, refWght, tplSize*sizeof(T)); // weight and template normalization xcorrNormTemplateWCC2(tplDataTmp, tplSize, mskData, tplWghtTmp, refWghtTmp); // allocate temporary arrays array_new(fftTmp1, resSize); array_new(fftTmp2, resSize); // numerator xcorr(tplDataTmp, tplNrow, tplNcol, tplNsec, refDataTmp, refNrow, refNcol, refNsec, resData, shape); // denominator xcorr(refWghtTmp, tplNrow, tplNcol, tplNsec, refDataTmp, refNrow, refNcol, refNsec, fftTmp1, shape); array_math_sqr(refDataTmp, refSize); xcorr(refWghtTmp, tplNrow, tplNcol, tplNsec, refDataTmp, refNrow, refNcol, refNsec, fftTmp2, shape); // NCC xcorrCombineResultWCC(resData, fftTmp1, fftTmp2, array_reduce_sum(tplDataTmp, tplSize), resSize); // deallocate array_delete(tplDataTmp); array_delete(refDataTmp); array_delete(tplWghtTmp); array_delete(refWghtTmp); array_delete(fftTmp1); array_delete(fftTmp2); }
void ecorr(T *tplData, size_t tplNrow, T *refData, size_t refNrow, T *resData, eXCorrRes shape) { assert(tplData != NULL && refData != NULL && resData != NULL); assert(tplNrow > 0); assert(refNrow > 0); T *tplDataTmp = NULL, *refDataTmp = NULL, *fftTmp1 = NULL, *mskData = NULL; size_t resNrow = 0, tplSize, refSize, resSize; if (shape != XCORR_RES_FULL && shape != XCORR_RES_VALID) { shape = XCORR_RES_FULL; } switch (shape) { case XCORR_RES_FULL: resNrow = refNrow + tplNrow - 1; break; case XCORR_RES_VALID: resNrow = refNrow - tplNrow + 1; break; default: ERROR("ecorr", "unsupported xcorr mode"); } tplSize = tplNrow; refSize = refNrow; resSize = resNrow; // allocate arrays as copies of input arrays array_new(tplDataTmp, tplSize); array_new(refDataTmp, refSize); memcpy(tplDataTmp, tplData, tplSize*sizeof(T)); memcpy(refDataTmp, refData, refSize*sizeof(T)); // template normalization array_new(mskData, tplSize); array_setval(mskData, (T) 1, tplSize); xcorrNormTemplateECC(tplDataTmp, tplSize); // allocate temporary arrays array_new(fftTmp1, resSize); // numerator xcorr(tplDataTmp, tplNrow, refDataTmp, refNrow, resData, shape); // denominator array_math_sqr(refDataTmp, refSize); xcorr(mskData, tplNrow, refDataTmp, refNrow, fftTmp1, shape); // ECC xcorrCombineResultECC(resData, fftTmp1, resSize); // deallocate array_delete(tplDataTmp); array_delete(refDataTmp); array_delete(mskData); array_delete(fftTmp1); }
int main(int argc, char *argv[]) { FILE *fd1; FILE *fd2; wave_t *wave1; wave_t *wave2; buffer_t *buffer1; buffer_t *buffer2; int bytesread; int length = 512; if (argc < 2) { fprintf(stderr, "Usage: %s <file>\n", argv[0]); exit(EXIT_FAILURE); } // LOAD wave to compare with Square1.wav if (!(fd1 = fopen(argv[1], "rb"))) { fprintf(stderr, "Couldn't open \"%s\".\n", argv[1]); exit(EXIT_FAILURE); } if (!(wave2 = waveopen(fd1))) { fprintf(stderr, "Couldn't open \"%s\" as a .wav file.\n", argv[1]); exit(EXIT_FAILURE); } // LOAD Pulse1.wav if (!(fd2 = fopen("./wavs/Pulse1.wav", "rb"))) { fprintf(stderr, "Couldn't open \"%s\".\n", "Square1.wav"); exit(EXIT_FAILURE); } if (!(wave1 = waveopen(fd2))) { fprintf(stderr, "Couldn't open \"%s\" as a .wav file.\n", argv[1]); exit(EXIT_FAILURE); } wavegetprop(wave1, WAVE_LENGTH, &length); //length = 16; buffer1 = mkbuffer(wave1, length); buffer2 = mkbuffer(wave2, length); if (!(bytesread = getpcm(wave1, buffer1))) { fprintf(stderr, "Couldn't stream pcm data!\n"); exit(EXIT_FAILURE); } if (!(bytesread = getpcm(wave2, buffer2))) { fprintf(stderr, "Couldn't stream pcm data!\n"); exit(EXIT_FAILURE); } char2double(wave1, buffer1); char2double(wave2, buffer2); /*int16_t **sample; sample = (int16_t **)buffer->pcm; for(int i = 0; i < buffer->length; i++){ printf("sample %d = %i \n", i, sample[0][i]); }*/ print_waveinfo(wave1); /* Test signal processing routines --------------------------------------------------------------*/ printf("\nSIGNAL PROCESSING RESULTS:\n"); double **R = xcorr(0, buffer1, buffer2); qsort(R[1], 2*length - 1, sizeof(double), doublecmp); printf("max xcorr o/p = %f \n", R[1][2*length-2]); /* for(int i = 1024 - 300; i < 1024 + 300; i++) printf("index %d R=%f @ lag = %f \n", i, R[1][i],R[0][i]); look at the output and lag 100 should have R ~= 1;*/ /* clean up mem allocs */ free(R[0]); free(R[1]); free(R); rmbuffer(wave1, buffer1); rmbuffer(wave2, buffer2); waveclose(wave1); waveclose(wave2); fclose(fd1); fclose(fd2); return 0; }
int main (int argc, const char * argv[]) { // choose which zero of autocorrelation should be set as delay parameter int delay_choice =2; int embed_dimension =3; int num_neighbours = 15; long num_of_points_retained=500; int percentile =70; long output_len=2*(((float)percentile)/100)*num_of_points_retained; printf("%ld output_len =",output_len); float *output = malloc(output_len* sizeof(float)); printf("Density based subsampling running \n"); if (argc != 2) { fprintf(stderr, "Expecting wav file as argument\n"); return 1; } // Open sound file that comes in as a command line argument SF_INFO sndInfo; SNDFILE *sndFile = sf_open(argv[1], SFM_READ, &sndInfo); if (sndFile == NULL) { fprintf(stderr, "Error reading source file '%s': %s\n", argv[1], sf_strerror(sndFile)); return 1; } // Check format - 16bit PCM if (sndInfo.format != (SF_FORMAT_WAV | SF_FORMAT_PCM_16)) { fprintf(stderr, "Input should be 16bit Wav\n"); sf_close(sndFile); return 1; } // Now we know the length of the wav file, we can create a buffer for it, in this case, we are creating a double array. // Allocate memory float *buffer = malloc(sndInfo.frames * sizeof(float)* sndInfo.channels); if (buffer == NULL) { fprintf(stderr, "Could not allocate memory for data\n"); sf_close(sndFile); return 1; } // This next step, actually reads in the wav file data. This function automatically converts the whichever format the audio file data is in to doubles. The library can convert to a number of different formats. // Load data long numFrames = sf_readf_float(sndFile, buffer, sndInfo.frames); // Check correct number of samples loaded if (numFrames != sndInfo.frames) { fprintf(stderr, "Did not read enough samples for source\n"); sf_close(sndFile); free(buffer); return 1; } // Now just output some info about the wav file printf("Read %ld samples from %s, Sample rate: %d, Length: %fs\n", numFrames, argv[1], sndInfo.samplerate, (float)numFrames/sndInfo.samplerate); // extract a single channel out float *buffer_singlechannel = malloc(sndInfo.frames * sizeof(float)); long i=0; for (long f=0 ; f<numFrames ; f++) { buffer_singlechannel[f]= buffer[i]; // Channel 1 i+=sndInfo.channels; } // free the buffer with multiple channel input free(buffer); // array to store the autocorrelation function double *buffer_autocorrelation = malloc((2*sndInfo.frames +1)* sizeof(double)); // calculate autocorrelation xcorr( buffer_singlechannel, buffer_singlechannel, buffer_autocorrelation, sndInfo.frames, 0,sndInfo.frames, 1, 1, sndInfo.frames,sndInfo.frames, sndInfo.frames, sndInfo.frames); // choose delay to be second zero of auto correlation long long delay = zeroCrossing(buffer_autocorrelation, 2*sndInfo.frames +1, delay_choice); printf("Delay chosen = %lld\n",delay); long long delay_embd_length= (sndInfo.frames -(delay*embed_dimension)+2)* embed_dimension; //create delay embedding and store in a linear array in row major form float *buffer_delayembedding =malloc(delay_embd_length*sizeof(float)); long long k1=0; for (long long l=(delay*embed_dimension)-2; l<sndInfo.frames; l=l+1) { buffer_delayembedding[k1]=buffer_singlechannel[l]; buffer_delayembedding[k1+1]=buffer_singlechannel[l-delay]; buffer_delayembedding[k1+2]=buffer_singlechannel[l-2*delay]; // printf("%f %f %f\n", buffer_delayembedding[k1],buffer_delayembedding[k1+1],buffer_delayembedding[k1+2]); k1=k1+embed_dimension; } int *array =malloc(num_of_points_retained *sizeof(int)); random_selector( delay_embd_length/ embed_dimension ,num_of_points_retained , array); for (int i=0; i<num_of_points_retained; i++) { // printf("%d\n",array[i]); } float *buffer_delayembedding_selec =malloc(num_of_points_retained*embed_dimension*sizeof(float)); float * density_vals =malloc(num_of_points_retained* sizeof(float)); printf("total len = %lld\n ", delay_embd_length/3 ); printf("buffer len = %ld\n", num_of_points_retained*embed_dimension); printf("num_of_points_retained = %ld\n", num_of_points_retained); for (int i=0; i<num_of_points_retained; i=i+1) { int loc=(array[i]-1)*embed_dimension; // printf("i :%d loc=%d array[i]: %d \n",i, loc, array[i]); buffer_delayembedding_selec[3*i]=buffer_delayembedding[loc]; buffer_delayembedding_selec[3*i+1]=buffer_delayembedding[loc+1]; buffer_delayembedding_selec[3*i+2]=buffer_delayembedding[loc+2]; // printf("buffer selec [%d] = %f ", 3*i, buffer_delayembedding_selec[3*i]); // printf("[%d] = %f ", 3*i+1, buffer_delayembedding_selec[3*i+1]); // printf("[%d] = %f \n", 3*i+2, buffer_delayembedding_selec[3*i+2]); } // for (int i=0; i<delay_embd_length/ embed_dimension ; i++) // { // printf("% d th original :%f %f %f\n",i, buffer_delayembedding [3*i],buffer_delayembedding [3*i+1],buffer_delayembedding [3*i+2]); // } knn (buffer_delayembedding_selec, density_vals , (num_of_points_retained), num_neighbours); // free all arrays used till now except the single channel wave file and close the sndFile object sf_close(sndFile); //desnity based subsampling float * density_vals_temp =malloc(num_of_points_retained* sizeof(float)); memcpy(density_vals_temp,density_vals,num_of_points_retained* sizeof(float)); qsort(density_vals_temp, num_of_points_retained, sizeof(float), cmpfunc); float key=findNumber(100-percentile,density_vals_temp,500); // Function call and the print statement // printf(" \n %d percentile: %.4lf \n", percentile, key); printf(" \n the linear array output contains the subsampled point cloud \n"); //for (int kk=0; kk<num_of_points_retained; kk++) { // printf("%d index %f \n", kk,density_vals_temp[kk]); //} free(density_vals_temp); int counter2=0; for( int counter = 0 ; counter < num_of_points_retained; counter++) { if (density_vals[counter]>=key && counter2<output_len/2) { output[2*counter2]=buffer_delayembedding_selec[3*counter]; output[2*counter2+1]=buffer_delayembedding_selec[3*counter+1]; //printf("%d output %.4lf , %.4lf\n", counter2,output[2*counter2],output[2*counter2+1]); //printf("%d output %.4lf , %.4lf\n", counter,buffer_delayembedding_selec[3*counter],buffer_delayembedding_selec[3*counter+1]); counter2++; } } free(buffer_singlechannel); free(buffer_autocorrelation); free(buffer_delayembedding); free(array); free(buffer_delayembedding_selec); free(density_vals); printf("Density based subsampling End\n"); free(output); return 0; }
int main(int argc, char* argv[]) { int n, nw, w, iw, i0=0, maxshift, i, i2, n2, nc; float dt,h, eps, lam; bool verb, taper; float **dat, **dat2, **win, **win2, *coord, *shift, *warp, *xc; map2 str; sf_file in, out, other, xcr; sf_init(argc,argv); in = sf_input("in"); other = sf_input("other"); out = sf_output("out"); xcr = sf_output("xcorr"); if (!sf_histint(in,"n1",&n)) sf_error("No n1= in input"); if (!sf_histfloat(in,"d1",&dt)) sf_error("No d1= in input"); n2 = sf_leftsize(in,1); if (!sf_getint("nw",&nw)) sf_error ("Need nw="); /* number of windows */ if (!sf_getint("w",&w)) sf_error ("Need w="); /* window size */ if (!sf_getfloat("h",&h)) h=0.5*(w-1); /* window overlap */ if (!sf_getint("maxshift",&maxshift)) maxshift=w/2; nc=2*maxshift-1; /* maximum correlation lag */ if (!sf_getfloat("eps",&eps)) eps=0.01; /* vertical smoothness (for picking) */ if (!sf_getfloat("lam",&lam)) lam=0.5; /* horizontal smoothness (for picking) */ if (!sf_getbool("verb",&verb)) verb=false; /* verbosity flag */ if (!sf_getbool("taper",&taper)) taper=true; /* window tapering */ dat = sf_floatalloc2(n,n2); dat2 = sf_floatalloc2(n,n2); win = sf_floatalloc2(w,n2); win2 = sf_floatalloc2(w,n2); coord = sf_floatalloc(nw); shift = sf_floatalloc(nw); warp = sf_floatalloc(n); xc = sf_floatalloc(nc); window1_init (w,nw,n,h,w-h); str = stretch2_init (n,1.,1.,nw,eps,lam); sf_floatread (dat[0],n*n2,in); sf_floatread (dat2[0],n*n2,other); sf_putint(xcr,"n1",nc); sf_putint(xcr,"n2",nw); sf_putfloat(xcr,"o2",(0.5*w+1.)*dt); sf_putfloat(xcr,"d2",(n-w)*dt/(nw-1.)); sf_putfloat(xcr,"o1",-maxshift*dt); for (iw=0; iw < nw; iw++) { for (i2=0; i2 < n2; i2++) { i0 = window1_apply(iw,dat[i2] ,taper,taper,win[i2] ); i0 = window1_apply(iw,dat2[i2],taper,taper,win2[i2]); } coord[iw] = i0 + 0.5*(w+1.); shift[iw] = xcorr (w,n2,win[0], win2[0],nc,xc); sf_floatwrite(xc,nc,xcr); if (verb) sf_warning("shift[%d]=%g",iw,shift[iw]); } stretch2_define (str, coord, false); stretch2_apply (str, shift, warp); for (i=0; i < n; i++) { warp[i] *= dt; } for (i2=0; i2 < n2; i2++) { sf_floatwrite (warp,n,out); } exit(0); }
void xcorr(subspace const& ss, std::vector<int> const& npair, std::vector<double> const& x, std::vector<double>& sxx) { xcorr(ss, npair, &x[0], sxx); }