int WebRtcIsac_Fftns(unsigned int ndim, const int dims[], double Re[], double Im[], int iSign, double scaling, FFTstr *fftstate) { size_t nSpan, nPass, nTotal; unsigned int i; int ret, max_factors, max_perm; /* * tally the number of elements in the data array * and determine the number of dimensions */ nTotal = 1; if (ndim && dims [0]) { for (i = 0; i < ndim; i++) { if (dims [i] <= 0) { return -1; } nTotal *= dims [i]; } } else { ndim = 0; for (i = 0; dims [i]; i++) { if (dims [i] <= 0) { return -1; } nTotal *= dims [i]; ndim++; } } /* determine maximum number of factors and permuations */ #if 1 /* * follow John Beale's example, just use the largest dimension and don't * worry about excess allocation. May be someone else will do it? */ max_factors = max_perm = 1; for (i = 0; i < ndim; i++) { nSpan = dims [i]; if ((int)nSpan > max_factors) { max_factors = (int)nSpan; } if ((int)nSpan > max_perm) { max_perm = (int)nSpan; } } #else /* use the constants used in the original Fortran code */ max_factors = 23; max_perm = 209; #endif /* loop over the dimensions: */ nPass = 1; for (i = 0; i < ndim; i++) { nSpan = dims [i]; nPass *= nSpan; ret = FFTRADIX (Re, Im, nTotal, nSpan, nPass, iSign, max_factors, max_perm, fftstate); /* exit, clean-up already done */ if (ret) return ret; } /* Divide through by the normalizing constant: */ if (scaling && scaling != 1.0) { if (iSign < 0) iSign = -iSign; if (scaling < 0.0) { scaling = (double)nTotal; if (scaling < -1.0) scaling = sqrt (scaling); } scaling = 1.0 / scaling; /* multiply is often faster */ for (i = 0; i < nTotal; i += iSign) { Re [i] *= scaling; Im [i] *= scaling; } } return 0; }
int FFTN (int ndim, const unsigned int dims [], REAL Re [], REAL Im [], int iSign, double scaling) { unsigned int nTotal; unsigned int maxFactors, maxPerm; /* * tally the number of elements in the data array * and determine the number of dimensions */ nTotal = 1; if (ndim) { if (dims != NULL) { int i; /* number of dimensions was specified */ for (i = 0; i < ndim; i++) { if (dims [i] <= 0) goto Dimension_Error; nTotal *= dims [i]; } } else nTotal *= ndim; } else { int i; /* determine # of dimensions from zero-terminated list */ if (dims == NULL) goto Dimension_Error; for (ndim = i = 0; dims [i]; i++) { if (dims [i] <= 0) goto Dimension_Error; nTotal *= dims [i]; ndim++; } } /* determine maximum number of factors and permuations */ #if 1 /* * follow John Beale's example, just use the largest dimension and don't * worry about excess allocation. May be someone else will do it? */ if (dims != NULL) { int i; for (maxFactors = maxPerm = 1, i = 0; i < ndim; i++) { if (dims [i] > maxFactors) maxFactors = dims [i]; if (dims [i] > maxPerm) maxPerm = dims [i]; } } else { maxFactors = maxPerm = nTotal; } #else /* use the constants used in the original Fortran code */ maxFactors = 23; maxPerm = 209; #endif /* loop over the dimensions: */ if (dims != NULL) { unsigned int nSpan = 1; int i; for (i = 0; i < ndim; i++) { int ret; nSpan *= dims [i]; ret = FFTRADIX (Re, Im, nTotal, dims [i], nSpan, iSign, maxFactors, maxPerm); /* exit, clean-up already done */ if (ret) return ret; } } else { int ret; ret = FFTRADIX (Re, Im, nTotal, nTotal, nTotal, iSign, maxFactors, maxPerm); /* exit, clean-up already done */ if (ret) return ret; } /* Divide through by the normalizing constant: */ if (scaling && scaling != 1.0) { size_t ist; if (iSign < 0) iSign = -iSign; if (scaling < 0.0) scaling = (scaling < -1.0) ? sqrt (nTotal) : nTotal; scaling = 1.0 / scaling; /* multiply is often faster */ for (ist = 0; ist < nTotal; ist += iSign) { Re_Data (ist) *= scaling; Im_Data (ist) *= scaling; } } return 0; Dimension_Error: fprintf (stderr, "Error: " FFTNS "() - dimension error\n"); fft_free (); /* free-up memory */ return -1; }