vector<double> powerSpectrum(vector<double> input)
{
size_t length = input.size();
if(length != size)
{
if(size >= 0)
{
gsl_fft_complex_workspace_free (work);
gsl_fft_complex_wavetable_free (complex);
}
complex = gsl_fft_complex_wavetable_alloc(length);
work = gsl_fft_complex_workspace_alloc(length);
size = length;
}
double reals[length*2];
for(size_t i = 0; i <length; i++)
{
reals[i*2] = input[i];
reals[i*2+1] = 0;
}
gsl_fft_complex_transform (reals, 1, length, complex, work, gsl_fft_forward);
for(int i = 0; i< length; i++)
{
input[i] = sqrt(reals[i*2]*reals[i*2] + reals[i*2+1]*reals[i*2+1])/length;
}
return input;
}
/* The indexs array specifies the row or column numbers for this
thread to work on. If forward1backwardn1 is one, then this is the
forward transform, meaning that in convolution there are two
images. If it is -1, then this is the final backward transform and
there is only one image to run FFTW on and the values in indexs will
always be smaller than p->s0 and p->s1. When there are two images,
then the index numbers are going to be at most double p->s0 and
p->s1. In this case, those index values which are smaller than p->s0
or p->s1 belong to the input image and those which are equal or
larger than larger belong to the kernel image (after subtraction for
p->s0 or p->s1).*/
void *
onedimensionfft(void *inparam)
{
struct fftonthreadparams *fp = (struct fftonthreadparams *)inparam;
struct convolveparams *p=fp->p;
double *d, *df;
size_t indmultip, maxindex;
gsl_fft_complex_workspace *work;
gsl_fft_complex_wavetable *wavetable;
double *data, *pimg=p->pimg, *pker=p->pker;
int forward1backwardn1=fp->forward1backwardn1;
size_t i, size, stride=fp->stride, *indexs=fp->indexs;
/* Set the number of points to transform,
indmultip: The value to be multiplied by the value in indexs to
specify the first pixel of the row or column.
*/
if(stride==1)
{ size=p->ps1; wavetable=fp->ps1wave; work=fp->ps1work;
maxindex=p->ps0; indmultip=p->ps1; }
else
{ size=p->ps0; wavetable=fp->ps0wave; work=fp->ps0work;
maxindex=p->ps1; indmultip=1; }
/* Go over all the rows or columns given for this thread.
NOTE: The final array (after the two FFT'd arrays are multiplied
by each other) is stored in p->pimg. So the check below works
both in the forward and the backward transformation.
*/
for(i=0; indexs[i]!=GAL_BLANK_SIZE_T; ++i)
{
data = ( indexs[i]<maxindex
? &pimg[ 2*indexs[i]*indmultip ] /* *2 because complex. */
: &pker[ 2*(indexs[i]-maxindex)*indmultip ] );
gsl_fft_complex_transform(data, stride, size, wavetable, work,
forward1backwardn1);
/* Normalize in the backward transform: */
if(forward1backwardn1==-1)
{
df=(d=data)+2*size*stride;
do {*d/=size; *(d+1)/=size; d+=2*stride;} while(d<df);
}
}
/* Wait until all other threads finish. */
if(p->cp.numthreads>1)
pthread_barrier_wait(fp->b);
return NULL;
}
/* in-place */
static VALUE rb_gsl_fft_complex_transform2(int argc, VALUE *argv, VALUE obj)
{
int flag = 0;
// local variable "status" was defined and set, but never used
//int status;
size_t stride, n;
gsl_fft_direction sign;
gsl_complex_packed_array data;
gsl_fft_complex_wavetable *table = NULL;
gsl_fft_complex_workspace *space = NULL;
CHECK_FIXNUM(argv[argc-1]);
sign = FIX2INT(argv[argc-1]);
flag = gsl_fft_get_argv_complex(argc-1, argv, obj, NULL, &data, &stride, &n, &table, &space);
/*status =*/ gsl_fft_complex_transform(data, stride, n, table, space, sign);
gsl_fft_free(flag, (GSL_FFT_Wavetable *) table, (GSL_FFT_Workspace *) space);
return obj;
}
static VALUE rb_gsl_fft_complex_transform(int argc, VALUE *argv, VALUE obj)
{
int flag = 0;
// local variable "status" was defined and set, but never used
//int status;
size_t stride, n;
gsl_vector_complex *vin, *vout;
gsl_fft_direction sign;
gsl_complex_packed_array data;
gsl_fft_complex_wavetable *table = NULL;
gsl_fft_complex_workspace *space = NULL;
CHECK_FIXNUM(argv[argc-1]);
sign = FIX2INT(argv[argc-1]);
flag = gsl_fft_get_argv_complex(argc-1, argv, obj, &vin, &data, &stride, &n, &table, &space);
vout = gsl_vector_complex_alloc(n);
gsl_vector_complex_memcpy(vout, vin);
/*status =*/ gsl_fft_complex_transform(vout->data, stride, n, table, space, sign);
gsl_fft_free(flag, (GSL_FFT_Wavetable *) table, (GSL_FFT_Workspace *) space);
return Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, vout);
}
