|
NCEPLIBS-ip 5.3.0
|
A concatenation of several subroutines from the FFTPACK collection. More...
Go to the source code of this file.
Functions/Subroutines | |
| subroutine | csfft (isign, n, scale, x, y, table, work, isys) |
| Compute a complex discrete Fourier transform of real data. | |
| subroutine | dcrft (init, x, ldx, y, ldy, n, m, isign, scale, table, n1, wrk, n2, z, nz) |
Computes a set of m real discrete n-point Fourier transforms of complex conjugate even data. | |
| subroutine | drcft (init, x, ldx, y, ldy, n, m, isign, scale, table, n1, wrk, n2, z, nz) |
| Compute a set of m complex discrete n-point Fourier transforms of real data. | |
| subroutine | radb2 (ido, l1, cc, ch, wa1) |
| Perform the backward radix-2 FFT step. | |
| subroutine | radb3 (ido, l1, cc, ch, wa1, wa2) |
| Perform the backward radix-3 FFT step. | |
| subroutine | radb4 (ido, l1, cc, ch, wa1, wa2, wa3) |
| Perform the backward radix-4 FFT step. | |
| subroutine | radb5 (ido, l1, cc, ch, wa1, wa2, wa3, wa4) |
| Perform the backward radix-5 FFT step. | |
| subroutine | radbg (ido, ip, l1, idl1, cc, c1, c2, ch, ch2, wa) |
| Computes the backward FFT stage using a generalized FFT algorithm. | |
| subroutine | radf2 (ido, l1, cc, ch, wa1) |
| Perform a radix-2 FFT step for even-odd decomposition of data. | |
| subroutine | radf3 (ido, l1, cc, ch, wa1, wa2) |
| Performs a radix-3 FFT step for decomposing the data into three components. | |
| subroutine | radf4 (ido, l1, cc, ch, wa1, wa2, wa3) |
| Perform a radix-4 FFT step for decomposing the data into four components. | |
| subroutine | radf5 (ido, l1, cc, ch, wa1, wa2, wa3, wa4) |
| Perform a radix-5 FFT step for decomposing the data into five components. | |
| subroutine | radfg (ido, ip, l1, idl1, cc, c1, c2, ch, ch2, wa) |
| Compute a general radix-based FFT step. | |
| subroutine | rfftb (n, r, wsave) |
| Compute the real periodic sequence from its Fourier coefs. | |
| subroutine | rfftb1 (n, c, ch, wa, ifac) |
| Compute the inverse fast Fourier transform (IFFT) using a mixed-radix algorithm. | |
| subroutine | rfftf (n, r, wsave) |
| Compute a forward transform of a real periodic sequence. | |
| subroutine | rfftf1 (n, c, ch, wa, ifac) |
| Compute the real forward fast Fourier transform (FFT) using a mixed-radix algorithm. | |
| subroutine | rffti (n, wsave) |
Initialize the array wsave which is used in both rfftf() and rfftb(). | |
| subroutine | rffti1 (n, wa, ifac) |
| Compute the initialization factors for the real-input FFT. | |
| subroutine | scfft (isign, n, scale, x, y, table, work, isys) |
| Compute a real-to-complex discrete Fourier transform. | |
| subroutine | scrft (init, x, ldx, y, ldy, n, m, isign, scale, table, n1, wrk, n2, z, nz) |
| Compute a set of m real discrete n-point Fourier transforms of complex conjugate even data. | |
| subroutine | srcft (init, x, ldx, y, ldy, n, m, isign, scale, table, n1, wrk, n2, z, nz) |
| Compute a set of m complex discrete n-point Fourier transforms of real data. | |
A concatenation of several subroutines from the FFTPACK collection.
FFTPACK is a package of Fortran subprograms for the fast Fourier transform of periodic and other symmetric sequences. It includes complex, real, sine, cosine, and quarter-wave transforms.
See FFTPACK documentation, IRIX man pages, and IBM ESSL documentation for further historical context for various subroutines included in this file.
Reference:
Definition in file fftpack.F.
| subroutine csfft | ( | integer | isign, |
| integer | n, | ||
| real | scale, | ||
| real, dimension(*) | x, | ||
| real, dimension(*) | y, | ||
| real, dimension(*) | table, | ||
| real, dimension(*) | work, | ||
| integer | isys ) |
Compute a complex discrete Fourier transform of real data.
This subroutine performs a Fourier transform on real input data. It supports initialization of the trigonometric coefficient table and forward or inverse transformations. The isign parameter determines the operation mode.
| isign | Operation mode: 0 for initialization, 1 for inverse transform |
| n | Number of data points in the transform |
| scale | Scaling factor applied to the transformed values |
| x | Input array of real values, length at least n+1 |
| y | Output array storing the transformed values, length at least n |
| table | Work array used for storing trigonometric coefficients |
| work | Work array used for intermediate computations |
| isys | Dummy parameter |
| subroutine dcrft | ( | integer | init, |
| real, dimension(2*ldx,*) | x, | ||
| integer | ldx, | ||
| real, dimension(ldy,*) | y, | ||
| integer | ldy, | ||
| integer | n, | ||
| integer | m, | ||
| integer | isign, | ||
| real | scale, | ||
| real, dimension(44002) | table, | ||
| integer | n1, | ||
| real, dimension(*) | wrk, | ||
| integer | n2, | ||
| real, optional | z, | ||
| integer, optional | nz ) |
Computes a set of m real discrete n-point Fourier transforms of complex conjugate even data.
The 'd' stands for double precision, but this is historical and may be ignored, and this subroutine is identical to scrft().
| init | Initialization flag; if nonzero, initializes the transformation |
| x | Input array of real values, dimensions (2*ldx, m) |
| ldx | Leading dimension of the input array x |
| y | Output array storing the transformed values, dimensions (ldy, m) |
| ldy | Leading dimension of the output array y |
| n | Number of data points in each transform (first dimension of y) |
| m | Number of transforms to be computed (second dimension of y) |
| isign | Sign indicator for the transform direction (not explicitly used) |
| scale | Scaling factor applied to the transformed values after computation |
| table | Work array of size 44002, precomputed during initialization |
| n1 | Auxiliary parameter |
| wrk | Work array used for intermediate storage during computation |
| n2 | Auxiliary parameter |
| z | Optional dummy parameter for compatibility |
| nz | Optional dummy parameter for compatibility |
Definition at line 42 of file fftpack.F.
References rfftb(), and rffti().
Referenced by spffte().
| subroutine drcft | ( | integer | init, |
| real, dimension(ldx,*) | x, | ||
| integer | ldx, | ||
| real, dimension(2*ldy,*) | y, | ||
| integer | ldy, | ||
| integer | n, | ||
| integer | m, | ||
| integer | isign, | ||
| real | scale, | ||
| real, dimension(44002) | table, | ||
| integer | n1, | ||
| real, dimension(*) | wrk, | ||
| integer | n2, | ||
| real, optional | z, | ||
| integer, optional | nz ) |
Compute a set of m complex discrete n-point Fourier transforms of real data.
This subroutine performs multiple (m) discrete Fourier transforms of length n on real input data. The transforms are computed using the real-to-complex Fast Fourier Transform (FFT) approach. The subroutine requires two invocations: once with init set to a non-zero value to initialize work storage, the second with init=0 to perform the DFT.
The 'd' stands for double precision, but this is historical and may be ignored, and this subroutine is identical to srcft().
| init | Initialization flag; if nonzero, initializes the transformation |
| x | Input array of real values, dimensions (ldx, m) |
| ldx | Leading dimension of the input array x |
| y | Output array storing the transformed values, dimensions (2*ldy, m) |
| ldy | Leading dimension of the output array y |
| n | Number of data points in each transform (first dimension of y) |
| m | Number of independent transforms to be computed (second dimension of y) |
| isign | Sign indicator for the transform direction (not explicitly used) |
| scale | Scaling factor applied to the transformed values |
| table | Work array of size 44002 |
| n1 | Auxiliary parameter |
| wrk | Work array used for intermediate storage during computation |
| n2 | Auxiliary parameter |
| z | Optional dummy parameter for compatibility |
| nz | Optional dummy parameter for compatibility |
Definition at line 187 of file fftpack.F.
References rfftf(), and rffti().
Referenced by spffte().
| subroutine radb2 | ( | ido, | |
| l1, | |||
| dimension(ido,2,l1) | cc, | ||
| dimension(ido,l1,2) | ch, | ||
| dimension(*) | wa1 ) |
Perform the backward radix-2 FFT step.
This subroutine computes one stage of the backward Fast Fourier Transform (FFT) using a radix-2 decomposition. It is used as part of the larger FFT process and applies twiddle factors to transform the input data.
| ido | The leading dimension, representing the number of data points in a transform section |
| l1 | The number of radix-2 stages processed in this step |
| cc | Input complex array containing intermediate FFT data |
| ch | Output complex array storing transformed data |
| wa1 | Twiddle factors array for weighting the FFT computation |
Definition at line 613 of file fftpack.F.
Referenced by rfftb1().
| subroutine radb3 | ( | ido, | |
| l1, | |||
| dimension(ido,3,l1) | cc, | ||
| dimension(ido,l1,3) | ch, | ||
| dimension(*) | wa1, | ||
| dimension(*) | wa2 ) |
Perform the backward radix-3 FFT step.
This subroutine computes one stage of the backward Fast Fourier Transform (FFT) using a radix-3 decomposition. It applies twiddle factors and combines intermediate results to reconstruct transformed data.
| ido | The leading dimension, representing the number of data points in a transform section |
| l1 | The number of radix-3 stages processed in this step |
| cc | Input complex array containing intermediate FFT data |
| ch | Output complex array storing transformed data |
| wa1 | Twiddle factors array for the first rotation |
| wa2 | Twiddle factors array for the second rotation |
Definition at line 662 of file fftpack.F.
Referenced by rfftb1().
| subroutine radb4 | ( | ido, | |
| l1, | |||
| dimension(ido,4,l1) | cc, | ||
| dimension(ido,l1,4) | ch, | ||
| dimension(*) | wa1, | ||
| dimension(*) | wa2, | ||
| dimension(*) | wa3 ) |
Perform the backward radix-4 FFT step.
This subroutine computes one stage of the backward Fast Fourier Transform (FFT) using a radix-4 decomposition. It applies the FFT formulae by processing the input data and performing necessary rotations and twiddle factor multiplications. The result is stored in the output array ch.
| ido | The leading dimension, representing the number of data points in a transform section |
| l1 | The number of radix-4 stages processed in this step |
| cc | Input complex array containing intermediate FFT data |
| ch | Output complex array storing transformed data |
| wa1 | Twiddle factors array for the first rotation |
| wa2 | Twiddle factors array for the second rotation |
| wa3 | Twiddle factors array for the third rotation |
Definition at line 717 of file fftpack.F.
Referenced by rfftb1().
| subroutine radb5 | ( | ido, | |
| l1, | |||
| dimension(ido,5,l1) | cc, | ||
| dimension(ido,l1,5) | ch, | ||
| dimension(*) | wa1, | ||
| dimension(*) | wa2, | ||
| dimension(*) | wa3, | ||
| dimension(*) | wa4 ) |
Perform the backward radix-5 FFT step.
This subroutine computes one stage of the backward Fast Fourier Transform (FFT) using a radix-5 decomposition. It processes input data in sections, applies necessary rotations and twiddle factors, and stores the transformed results in the output array ch. The operation involves calculating intermediate results for each data point and applying appropriate scaling and twiddle factor multiplication.
| ido | The leading dimension, representing the number of data points in a transform section |
| l1 | The number of radix-5 stages processed in this step |
| cc | Input complex array containing intermediate FFT data |
| ch | Output complex array storing transformed data |
| wa1 | Twiddle factors array for the first rotation |
| wa2 | Twiddle factors array for the second rotation |
| wa3 | Twiddle factors array for the third rotation |
| wa4 | Twiddle factors array for the fourth rotation |
Definition at line 801 of file fftpack.F.
Referenced by rfftb1().
| subroutine radbg | ( | ido, | |
| ip, | |||
| l1, | |||
| idl1, | |||
| dimension(ido,ip,l1) | cc, | ||
| dimension(ido,l1,ip) | c1, | ||
| dimension(idl1,ip) | c2, | ||
| dimension(ido,l1,ip) | ch, | ||
| dimension(idl1,ip) | ch2, | ||
| dimension(*) | wa ) |
Computes the backward FFT stage using a generalized FFT algorithm.
This subroutine performs a backward Fast Fourier Transform (FFT) step with a generalized radix-ip approach. It computes the necessary intermediate steps, applying the inverse FFT transformation to the complex input data stored in cc, and stores the result in the output arrays ch and c2. Twiddle factors, stored in wa, are used for scaling and rotations at each stage of the computation.
| ido | The leading dimension for data points in a transform section |
| ip | The number of subgroups in the FFT (radix) |
| l1 | The number of radix stages to process |
| idl1 | The leading dimension for another input array |
| cc | Input complex array containing intermediate FFT data |
| c1 | Array containing the first set of intermediate FFT results |
| c2 | Array to store additional intermediate FFT results |
| ch | Output complex array to store the final transformed data |
| ch2 | Output complex array storing intermediate results for the second stage of transformation |
| wa | Array containing the twiddle factors used in the FFT |
Definition at line 887 of file fftpack.F.
Referenced by rfftb1().
| subroutine radf2 | ( | ido, | |
| l1, | |||
| dimension(ido,l1,2) | cc, | ||
| dimension(ido,2,l1) | ch, | ||
| dimension(*) | wa1 ) |
Perform a radix-2 FFT step for even-odd decomposition of data.
This subroutine computes a single stage of the radix-2 Fast Fourier Transform (FFT) by separating the even and odd indexed values from the input data array cc, and stores the results in the output array ch. It processes intermediate data with the twiddle factors from wa1 for scaling and rotation.
| ido | The size of the FFT sub-segment (number of data points to process) |
| l1 | The number of stages to process in the FFT |
| cc | Input complex array of size ido x l1 x 2, containing the data for the FFT transformation |
| ch | Output complex array of size ido x 2 x l1, where the transformed data will be stored |
| wa1 | Array of twiddle factors used to scale and rotate the data during the FFT calculation |
Definition at line 1073 of file fftpack.F.
Referenced by rfftf1().
| subroutine radf3 | ( | ido, | |
| l1, | |||
| dimension(ido,l1,3) | cc, | ||
| dimension(ido,3,l1) | ch, | ||
| dimension(*) | wa1, | ||
| dimension(*) | wa2 ) |
Performs a radix-3 FFT step for decomposing the data into three components.
This subroutine computes a single stage of the radix-3 Fast Fourier Transform (FFT) by separating the input data cc into three components (one for each of the three terms in the FFT). The output data is stored in the array ch, with twiddle factors applied from the arrays wa1 and wa2. This subroutine operates for various sizes of FFT sub-segments, controlled by the parameter ido.
The subroutine handles different configurations based on the value of ido, which affects how the data is processed.
| ido | The size of the FFT sub-segment (number of data points to process) |
| l1 | The number of stages to process in the FFT |
| cc | Input complex array of size ido x l1 x 3, containing the data for the FFT transformation |
| ch | Output complex array of size ido x 3 x l1, where the transformed data will be stored |
| wa1 | Array of twiddle factors for the first part of the FFT calculation |
| wa2 | Array of twiddle factors for the second part of the FFT calculation |
Definition at line 1129 of file fftpack.F.
Referenced by rfftf1().
| subroutine radf4 | ( | ido, | |
| l1, | |||
| dimension(ido,l1,4) | cc, | ||
| dimension(ido,4,l1) | ch, | ||
| dimension(*) | wa1, | ||
| dimension(*) | wa2, | ||
| dimension(*) | wa3 ) |
Perform a radix-4 FFT step for decomposing the data into four components.
This subroutine computes a single stage of the radix-4 Fast Fourier Transform (FFT) by separating the input data cc into four components (one for each of the four terms in the FFT). The output data is stored in the array ch, with twiddle factors applied from the arrays wa1, wa2, and wa3. This subroutine operates for various sizes of FFT sub-segments, controlled by the parameter ido.
| ido | The size of the FFT sub-segment (number of data points to process) |
| l1 | The number of stages to process in the FFT |
| cc | Input complex array of size ido x l1 x 4, containing the data for the FFT transformation |
| ch | Output complex array of size ido x 4 x l1, where the transformed data will be stored |
| wa1 | Array of twiddle factors for the first part of the FFT calculation |
| wa2 | Array of twiddle factors for the second part of the FFT calculation |
| wa3 | Array of twiddle factors for the third part of the FFT calculation |
Definition at line 1185 of file fftpack.F.
Referenced by rfftf1().
| subroutine radf5 | ( | ido, | |
| l1, | |||
| dimension(ido,l1,5) | cc, | ||
| dimension(ido,5,l1) | ch, | ||
| dimension(*) | wa1, | ||
| dimension(*) | wa2, | ||
| dimension(*) | wa3, | ||
| dimension(*) | wa4 ) |
Perform a radix-5 FFT step for decomposing the data into five components.
This subroutine computes a single stage of the radix-5 Fast Fourier Transform (FFT) by separating the input data cc into five components (one for each of the five terms in the FFT). The output data is stored in the array ch, with twiddle factors applied from the arrays wa1, wa2, wa3, and wa4. This subroutine operates for various sizes of FFT sub-segments, controlled by the parameter ido.
| ido | The size of the FFT sub-segment (number of data points to process) |
| l1 | The number of stages to process in the FFT |
| cc | Input complex array of size ido x l1 x 5, containing the data for the FFT transformation |
| ch | Output complex array of size ido x 5 x l1, where the transformed data will be stored |
| wa1 | Array of twiddle factors for the first part of the FFT calculation |
| wa2 | Array of twiddle factors for the second part of the FFT calculation |
| wa3 | Array of twiddle factors for the third part of the FFT calculation |
| wa4 | Array of twiddle factors for the fourth part of the FFT calculation |
Definition at line 1267 of file fftpack.F.
Referenced by rfftf1().
| subroutine radfg | ( | ido, | |
| ip, | |||
| l1, | |||
| idl1, | |||
| dimension(ido,ip,l1) | cc, | ||
| dimension(ido,l1,ip) | c1, | ||
| dimension(idl1,ip) | c2, | ||
| dimension(ido,l1,ip) | ch, | ||
| dimension(idl1,ip) | ch2, | ||
| dimension(*) | wa ) |
Compute a general radix-based FFT step.
This subroutine implements a mixed-radix Fast Fourier Transform (FFT) step, decomposing the input data for an arbitrary radix ip. It reorganizes the input data cc and applies twiddle factors from wa to generate the output in ch and ch2.
The transformation is influenced by ido, which controls the number of data points per FFT sub-segment, and l1, which determines the number of processing stages.
| ido | The number of data points per sub-segment |
| ip | The radix of the FFT step |
| l1 | The number of stages to process |
| idl1 | The transformed data length parameter, dependent on l1 |
| cc | Input complex array of size ido x ip x l1, containing the data to transform |
| c1 | Temporary working array for intermediate calculations |
| c2 | Temporary working array for intermediate calculations |
| ch | Output complex array of size ido x l1 x ip, where transformed data is stored |
| ch2 | Another working output array used for intermediate transformations |
| wa | Twiddle factor array used to apply phase shifts in the FFT calculation |
Definition at line 1350 of file fftpack.F.
Referenced by rfftf1().
| subroutine rfftb | ( | n, | |
| dimension(*) | r, | ||
| dimension(*) | wsave ) |
Compute the real periodic sequence from its Fourier coefs.
| n | The length of the array r to be transformed |
| r | A real array of length n which contains the sequence to be transformed |
| wsave | A work array which must be dimensioned at least 2*n+15; must not be destroyed between calls of rfftf() or rfftb() |
rfftf() followed by a call of rfftb() will multiply the input sequence by n.Definition at line 351 of file fftpack.F.
References rfftb1().
| subroutine rfftb1 | ( | n, | |
| real, dimension(*) | c, | ||
| real, dimension(*) | ch, | ||
| real, dimension(*) | wa, | ||
| real, dimension(*) | ifac ) |
Compute the inverse fast Fourier transform (IFFT) using a mixed-radix algorithm.
This subroutine is a low-level component of the real-to-complex IFFT computation. It applies a series of radix-based backward FFTs (radb2(), radb3(), radb4(), radb5(), and radbg()) to transform real input data back from the frequency domain to the time domain.
| n | Number of data points in the transform |
| c | Input/output array of real values; on input, it contains transformed data, and on output, it stores the inverse-transformed real data |
| ch | Work array used for intermediate calculations |
| wa | Sine and cosine trigonometric table used for the transformation |
| ifac | Integer factorization array used to determine the radix decomposition |
Definition at line 386 of file fftpack.F.
References radb2(), radb3(), radb4(), radb5(), and radbg().
Referenced by rfftb().
| subroutine rfftf | ( | n, | |
| dimension(*) | r, | ||
| dimension(*) | wsave ) |
Compute a forward transform of a real periodic sequence.
The wsave array must be initialized by calling subroutine rffti(n,wsave) and a different wsave array must be used for each different value of n. This initialization does not have to be repeated so long as n remains unchanged thus subsequent transforms can be obtained faster than the first.
rfftf() followed by a call of rfftb() will multiply the input sequence by n.| n | The length of the array r to be transformed |
| r | A real array of length n which contains the sequence to be transformed |
| wsave | A work array which must be dimensioned at least 2*n+15; must not be destroyed between calls of rfftf() or rfftb() |
Definition at line 334 of file fftpack.F.
References rfftf1().
| subroutine rfftf1 | ( | n, | |
| real, dimension(*) | c, | ||
| real, dimension(*) | ch, | ||
| real, dimension(*) | wa, | ||
| real, dimension(*) | ifac ) |
Compute the real forward fast Fourier transform (FFT) using a mixed-radix algorithm.
This subroutine performs the FFT by applying a sequence of radix-based forward transformations (radf2(), radf3(), radf4(), radf5(), and radfg()). It is a low-level routine used internally for computing the real-input FFT.
| n | Number of data points in the transform |
| c | Input/output array of real values; on input, it contains time-domain data, and on output, it stores the transformed frequency-domain data |
| ch | Work array used for intermediate calculations |
| wa | Sine and cosine trigonometric table used for the transformation |
| ifac | Integer factorization array used to determine the radix decomposition |
Definition at line 460 of file fftpack.F.
References radf2(), radf3(), radf4(), radf5(), and radfg().
Referenced by rfftf().
| subroutine rffti | ( | n, | |
| dimension(*) | wsave ) |
Initialize the array wsave which is used in both rfftf() and rfftb().
| n | The length of the sequence to be transformed |
| wsave | A work array which must be dimensioned at least 2*n+15; must not be destroyed between calls of rfftf() or rfftb() |
Definition at line 364 of file fftpack.F.
References rffti1().
Referenced by csfft(), dcrft(), drcft(), scfft(), scrft(), and srcft().
| subroutine rffti1 | ( | n, | |
| real, dimension(*) | wa, | ||
| real, dimension(*) | ifac ) |
Compute the initialization factors for the real-input FFT.
This subroutine prepares the trigonometric table and factorization for the real-input Fast Fourier Transform (FFT). It determines the prime factorization of N and computes the necessary twiddle factors for efficient computation.
| n | The length of the input data array |
| wa | Output array containing computed trigonometric factors |
| ifac | Output integer array storing the factorization of n for FFT processing |
Definition at line 532 of file fftpack.F.
Referenced by rffti().
| subroutine scfft | ( | integer | isign, |
| integer | n, | ||
| real | scale, | ||
| real, dimension(*) | x, | ||
| real, dimension(*) | y, | ||
| real, dimension(*) | table, | ||
| real, dimension(*) | work, | ||
| integer | isys ) |
Compute a real-to-complex discrete Fourier transform.
This subroutine performs a Fourier transform on real input data. It supports initialization of the trigonometric coefficient table and forward transformation.
| isign | Operation mode: 0 for initialization, -1 for forward transform |
| n | Number of data points in the transform |
| scale | Scaling factor applied to the transformed values |
| x | Input array of real values, length at least n |
| y | Output array storing the transformed values, length at least n+1 |
| table | Work array used for storing trigonometric coefficients |
| work | Work array used for intermediate computations |
| isys | Dummy parameter |
| subroutine scrft | ( | integer | init, |
| real, dimension(2*ldx,*) | x, | ||
| integer | ldx, | ||
| real, dimension(ldy,*) | y, | ||
| integer | ldy, | ||
| integer | n, | ||
| integer | m, | ||
| integer | isign, | ||
| real | scale, | ||
| real, dimension(44002) | table, | ||
| integer | n1, | ||
| real, dimension(*) | wrk, | ||
| integer | n2, | ||
| real, optional | z, | ||
| integer, optional | nz ) |
Compute a set of m real discrete n-point Fourier transforms of complex conjugate even data.
The 's' stands for single precision, but this is historical and may be ignored, and this subroutine is identical to dcrft().
| init | Initialization flag; if nonzero, initializes the transformation |
| x | Input array of real values, dimensions (2*ldx, m) |
| ldx | Leading dimension of the input array x |
| y | Output array storing the transformed values, dimensions (ldy, m) |
| ldy | Leading dimension of the output array y |
| n | Number of data points in each transform (first dimension of y) |
| m | Number of transforms to be computed (second dimension of y) |
| isign | Sign indicator for the transform direction (not explicitly used) |
| scale | Scaling factor applied to the transformed values after computation |
| table | Work array of size 44002, precomputed during initialization |
| n1 | Auxiliary parameter |
| wrk | Work array used for intermediate storage during computation |
| n2 | Auxiliary parameter |
| z | Optional dummy parameter for compatibility |
| nz | Optional dummy parameter for compatibility |
Definition at line 92 of file fftpack.F.
| subroutine srcft | ( | integer | init, |
| real, dimension(ldx,*) | x, | ||
| integer | ldx, | ||
| real, dimension(2*ldy,*) | y, | ||
| integer | ldy, | ||
| integer | n, | ||
| integer | m, | ||
| integer | isign, | ||
| real | scale, | ||
| real, dimension(44002) | table, | ||
| integer | n1, | ||
| real, dimension(*) | wrk, | ||
| integer | n2, | ||
| real, optional | z, | ||
| integer, optional | nz ) |
Compute a set of m complex discrete n-point Fourier transforms of real data.
This subroutine performs multiple (m) discrete Fourier transforms of length n on real input data. The transforms are computed using the real-to-complex Fast Fourier Transform (FFT) approach. The subroutine requires two invocations: once with init set to a non-zero value to initialize work storage, the second with init=0 to perform the DFT.
The 's' stands for single precision, but this is historical and may be ignored, and this subroutine is identical to drcft().
| init | Initialization flag; if nonzero, initializes the transformation |
| x | Input array of real values, dimensions (ldx, m) |
| ldx | Leading dimension of the input array x |
| y | Output array storing the transformed values, dimensions (2*ldy, m) |
| ldy | Leading dimension of the output array y |
| n | Number of data points in each transform (first dimension of y) |
| m | Number of independent transforms to be computed (second dimension of y) |
| isign | Sign indicator for the transform direction (not explicitly used) |
| scale | Scaling factor applied to the transformed values |
| table | Work array of size 44002 |
| n1 | Auxiliary parameter |
| wrk | Work array used for intermediate storage during computation |
| n2 | Auxiliary parameter |
| z | Optional dummy parameter for compatibility |
| nz | Optional dummy parameter for compatibility |
Definition at line 246 of file fftpack.F.
