rdoc/fft.rdoc in rb-gsl-1.16.0.2 vs rdoc/fft.rdoc in rb-gsl-1.16.0.3.rc1

- old
+ new

@@ -1,69 +1,69 @@ # # = Fast Fourier Transforms # Contents: -# 1. {Mathematical Definitions}[link:rdoc/fft_rdoc.html#1] -# 1. {Complex data FFTs}[link:rdoc/fft_rdoc.html#2] -# 1. {Overview of complex data FFTs}[link:rdoc/fft_rdoc.html#2.1] -# 1. {Radix-2 FFT routines for complex data}[link:rdoc/fft_rdoc.html#2.2] -# 1. {Example of the complex Radix-2 FFT}[link:rdoc/fft_rdoc.html#2.2.1] -# 1. {Mixed-radix FFT routines for complex data}[link:rdoc/fft_rdoc.html#2.3] -# 1. {GSL::FFT::ComplexWavetable class}[link:rdoc/fft_rdoc.html#2.3.1] -# 1. {GSL::FFT::ComplexWorkspace class}[link:rdoc/fft_rdoc.html#2.3.2] -# 1. {Methods to compute the transform}[link:rdoc/fft_rdoc.html#2.3.3] -# 1. {Example of the mixed-radix FFT}[link:rdoc/fft_rdoc.html#2.3.4] -# 1. {Real data FFTs}[link:rdoc/fft_rdoc.html#3] -# 1. {Overview of real data FFTs}[link:rdoc/fft_rdoc.html#3.1] -# 1. {Radix-2 FFT routines for real data}[link:rdoc/fft_rdoc.html#3.2] -# 1. {Mixed-radix FFT routines for real data}[link:rdoc/fft_rdoc.html#3.3] -# 1. {Data storage scheme}[link:rdoc/fft_rdoc.html#3.3.1] -# 1. {Wavetable and Workspace classes}[link:rdoc/fft_rdoc.html#3.3.2] -# 1. {Methods for real FFTs}[link:rdoc/fft_rdoc.html#3.3.3] -# 1. {Examples}[link:rdoc/fft_rdoc.html#3.3.4] +# 1. {Mathematical Definitions}[link:fft_rdoc.html#label-Mathematical+Definitions] +# 1. {Complex data FFTs}[link:fft_rdoc.html#label-Complex+data+FFTs] +# 1. {Overview of complex data FFTs}[link:fft_rdoc.html#label-Overview+of+complex+data+FFTs] +# 1. {Radix-2 FFT routines for complex data}[link:fft_rdoc.html#label-Radix-2+FFT+routines+for+complex+data] +# 1. {Example of the complex Radix-2 FFT}[link:fft_rdoc.html#label-Example+of+complex+Radix-2+FFT] +# 1. {Mixed-radix FFT routines for complex data}[link:fft_rdoc.html#label-Mixed-radix+FFT+routines+for+complex+data] +# 1. {GSL::FFT::ComplexWavetable class}[link:fft_rdoc.html#label-ComplexWavetable+class] +# 1. {GSL::FFT::ComplexWorkspace class}[link:fft_rdoc.html#label-ComplexWorkspace+class] +# 1. {Methods to compute the transform}[link:fft_rdoc.html#label-Methods+to+compute+transform] +# 1. {Example of the mixed-radix FFT}[link:fft_rdoc.html#label-Example+to+use+the+mixed-radix+FFT+algorithm] +# 1. {Real data FFTs}[link:fft_rdoc.html#label-Real+data+FFTs] +# 1. {Overview of real data FFTs}[link:fft_rdoc.html#label-Overview+of+real+data+FFTs] +# 1. {Radix-2 FFT routines for real data}[link:fft_rdoc.html#label-Radix-2+FFT+routines+for+real+data] +# 1. {Mixed-radix FFT routines for real data}[link:fft_rdoc.html#label-Mixed-radix+FFT+routines+for+real+data] +# 1. {Data storage scheme}[link:fft_rdoc.html#label-Data+storage+scheme] +# 1. {Wavetable and Workspace classes}[link:fft_rdoc.html#label-Wavetable+and+Workspace+classes] +# 1. {Methods for real FFTs}[link:fft_rdoc.html#label-Methods+for+mixed-radix+real+FFTs] +# 1. {Examples}[link:fft_rdoc.html#label-Examples] # -# == {}[link:index.html"name="1] Mathematical Definitions -# Fast Fourier Transforms are efficient algorithms for calculating the discrete -# fourier transform (DFT), +# == Mathematical Definitions +# Fast Fourier Transforms are efficient algorithms for calculating the discrete +# fourier transform (DFT), # -# The DFT usually arises as an approximation to the continuous fourier transform -# when functions are sampled at discrete intervals in space or time. -# The naive evaluation of the discrete fourier transform is a matrix-vector -# multiplication W\vec{z}. A general matrix-vector multiplication takes O(N^2) -# operations for N data-points. Fast fourier transform algorithms use a -# divide-and-conquer strategy to factorize the matrix W into smaller -# sub-matrices, corresponding to the integer factors of the length N. -# If N can be factorized into a product of integers f_1 f_2 ... f_n then the -# DFT can be computed in O(N \sum f_i) operations. For a radix-2 FFT this -# gives an operation count of O(N \log_2 N). +# The DFT usually arises as an approximation to the continuous fourier transform +# when functions are sampled at discrete intervals in space or time. +# The naive evaluation of the discrete fourier transform is a matrix-vector +# multiplication W\vec{z}. A general matrix-vector multiplication takes O(N^2) +# operations for N data-points. Fast fourier transform algorithms use a +# divide-and-conquer strategy to factorize the matrix W into smaller +# sub-matrices, corresponding to the integer factors of the length N. +# If N can be factorized into a product of integers f_1 f_2 ... f_n then the +# DFT can be computed in O(N \sum f_i) operations. For a radix-2 FFT this +# gives an operation count of O(N \log_2 N). # # All the FFT functions offer three types of transform: forwards, inverse and -# backwards, based on the same mathematical definitions. The definition of the -# forward fourier transform, x = FFT(z), is, and the definition of the inverse -# fourier transform, x = IFFT(z), is, The factor of 1/N makes this a true -# inverse. For example, a call to gsl_fft_complex_forward followed by a call -# to gsl_fft_complex_inverse should return the original data (within numerical -# errors). +# backwards, based on the same mathematical definitions. The definition of the +# forward fourier transform, x = FFT(z), is, and the definition of the inverse +# fourier transform, x = IFFT(z), is, The factor of 1/N makes this a true +# inverse. For example, a call to gsl_fft_complex_forward followed by a call +# to gsl_fft_complex_inverse should return the original data (within numerical +# errors). # -# In general there are two possible choices for the sign of the exponential +# In general there are two possible choices for the sign of the exponential # in the transform/ inverse-transform pair. GSL follows the same convention as -# FFTPACK, using a negative exponential for the forward transform. -# The advantage of this convention is that the inverse transform recreates -# the original function with simple fourier synthesis. Numerical Recipes uses -# the opposite convention, a positive exponential in the forward transform. +# FFTPACK, using a negative exponential for the forward transform. +# The advantage of this convention is that the inverse transform recreates +# the original function with simple fourier synthesis. Numerical Recipes uses +# the opposite convention, a positive exponential in the forward transform. # -# The backwards FFT is simply our terminology for an unscaled version of the -# inverse FFT, When the overall scale of the result is unimportant it is often +# The backwards FFT is simply our terminology for an unscaled version of the +# inverse FFT, When the overall scale of the result is unimportant it is often # convenient to use the backwards FFT instead of the inverse to save unnecessary -# divisions. +# divisions. # # -# == {}[link:index.html"name="2] Complex data FFTs -# === {}[link:index.html"name="2.1] Overview of complex data FFTs +# == Complex data FFTs +# === Overview of complex data FFTs # The complex data FFT routines are provided as instance methods of -# {GSL::Vector::Complex}[link:rdoc/vector_complex_rdoc.html]. +# {GSL::Vector::Complex}[link:vector_complex_rdoc.html]. # -# Here is a table which shows the layout of the array data, and the correspondence +# Here is a table which shows the layout of the array data, and the correspondence # between the time-domain complex data z, and the frequency-domain complex data x. # # index z x = FFT(z) # # 0 z(t = 0) x(f = 0) @@ -80,11 +80,11 @@ # # When N is even the location N/2 contains the most positive and negative # frequencies +1/(2 Delta), -1/(2 Delta) which are equivalent. If N is odd then # general structure of the table above still applies, but N/2 does not appear. # -# {GSL::Vector::Complex}[link:rdoc/vector_complex_rdoc.html] provides four methods for +# {GSL::Vector::Complex}[link:vector_complex_rdoc.html] provides four methods for # shifting the frequency domain data between <b>FFT order</b>, shown in the table # above, and <b>natural order</b>, which has the most negative freqeuncy component # first, the zero frequency component in the middle, and the most positive # frequency component last. # @@ -108,18 +108,18 @@ # <tt>GSL::Vector::Complex</tt> object containing the shifted data. The # <tt>#ifftshift!</tt> method modifies <tt>self</tt> in-place and returns # <tt>self</tt>. Note that <tt>#fftshift</tt> and <tt>#ifftshift</tt> are equivalent # for even lengths, but not for odd lengths. # -# === {}[link:index.html"name="2.2] Radix-2 FFT routines for complex data -# The radix-2 algorithms are simple and compact, although not necessarily the -# most efficient. They use the Cooley-Tukey algorithm to compute complex -# FFTs for lengths which are a power of 2 -- no additional storage is required. -# The corresponding self-sorting mixed-radix routines offer better performance +# === Radix-2 FFT routines for complex data +# The radix-2 algorithms are simple and compact, although not necessarily the +# most efficient. They use the Cooley-Tukey algorithm to compute complex +# FFTs for lengths which are a power of 2 -- no additional storage is required. +# The corresponding self-sorting mixed-radix routines offer better performance # at the expense of requiring additional working space. # -# <b>The FFT methods described below return FFTed data, and the input vector is +# <b>The FFT methods described below return FFTed data, and the input vector is # not changed. Use methods with '!' as <tt>tranform!</tt> for in-place transform.</b> # # --- # * GSL::Vector::Complex#radix2_forward # * GSL::Vector::Complex#radix2_backward @@ -134,24 +134,24 @@ # --- # * GSL::Vector::Complex#radix2_transform(sign) # # # The sign argument can be either <tt>GSL::FFT::FORWARD</tt> or <tt>GSL::FFT::BACKWARD</tt>. -# +# # --- # * GSL::Vector::Complex#radix2_dif_forward # * GSL::Vector::Complex#radix2_dif_backward # * GSL::Vector::Complex#radix2_dif_inverse # * GSL::Vector::Complex#radix2_dif_transform # # # These are decimation-in-frequency versions of the radix-2 FFT functions. # -# ==== {}[link:index.html"name="2.2.1] Example of complex Radix-2 FFT -# Here is an example program which computes the FFT of a short pulse in a -# sample of length 128. To make the resulting Fourier transform real the pulse -# is defined for equal positive and negative times (-10 ... 10), where the +# ==== Example of complex Radix-2 FFT +# Here is an example program which computes the FFT of a short pulse in a +# sample of length 128. To make the resulting Fourier transform real the pulse +# is defined for equal positive and negative times (-10 ... 10), where the # negative times wrap around the end of the array. # # require("gsl") # include GSL # @@ -174,43 +174,43 @@ # ffted /= Math::sqrt(n) # for i in 0...n do # printf("%d %e %e\n", i, ffted[i].re, ffted[i].im) # end # -# === {}[link:index.html"name="2.3] Mixed-radix FFT routines for complex data +# === Mixed-radix FFT routines for complex data # -# ==== {}[link:index.html"name="2.3.1] GSL::FFT::ComplexWavetable class +# ==== ComplexWavetable class # --- # * GSL::FFT::ComplexWavetable.alloc(n) # # # This method prepares a trigonometric lookup table for a complex FFT of length <tt>n</tt>. -# The length <tt>n</tt> is factorized into a product of subtransforms, and the factors and their -# trigonometric coefficients are stored in the wavetable. The trigonometric coefficients are -# computed using direct calls to sin and cos, for accuracy. Recursion relations could be used -# to compute the lookup table faster, but if an application performs many FFTs of the same -# length then this computation is a one-off overhead which does not affect the final +# The length <tt>n</tt> is factorized into a product of subtransforms, and the factors and their +# trigonometric coefficients are stored in the wavetable. The trigonometric coefficients are +# computed using direct calls to sin and cos, for accuracy. Recursion relations could be used +# to compute the lookup table faster, but if an application performs many FFTs of the same +# length then this computation is a one-off overhead which does not affect the final # throughput. # # The <tt>Wavetable</tt> object can be used repeatedly for any transform of the same length. -# The table is not modified by calls to any of the other FFT functions. The same wavetable +# The table is not modified by calls to any of the other FFT functions. The same wavetable # can be used for both forward and backward (or inverse) transforms of a given length. # # --- # * GSL::FFT::ComplexWavetable#n # * GSL::FFT::ComplexWavetable#nf # * GSL::FFT::ComplexWavetable#factor # # -# ==== {}[link:index.html"name="2.3.2] GSL::FFT::ComplexWorkspace class +# ==== ComplexWorkspace class # --- # * GSL::FFT::ComplexWorkspace.alloc(n) # # # Creates a workspace for a complex transform of length <tt>n</tt>. # -# ==== {}[link:index.html"name="2.3.3] Methods to compute transform +# ==== Methods to compute transform # <b>The FFT methods described below return FFTed data, and the input vector is not changed. Use methods with '!' as <tt>tranform!</tt> for in-place transform.</b> # # --- # * GSL::Vector::Complex#forward(table, work) # * GSL::Vector::Complex#forward(table) @@ -224,20 +224,20 @@ # These methods compute forward, backward and inverse FFTs of the complex # vector <tt>self</tt>, using a mixed radix decimation-in-frequency algorithm. # There is no restriction on the length. Efficient modules are provided for # subtransforms of length 2, 3, 4, 5, 6 and 7. Any remaining factors are # computed with a slow, O(n^2), general-n module. -# +# # The caller can supply a <tt>table</tt> containing the trigonometric lookup # tables and a workspace <tt>work</tt> (they are optional). -# +# # The sign argument for the method <tt>transform</tt> can be either # <tt>GSL::FFT::FORWARD</tt> or <tt>GSL::FFT::BACKWARD</tt>. # # These methods return the FFTed data, and the input data is not changed. # -# ==== {}[link:index.html"name="2.3.4] Example to use the mixed-radix FFT algorithm +# ==== Example to use the mixed-radix FFT algorithm # require 'gsl' # include GSL # # n = 630 # data = FFT::Vector::Complex[n] @@ -257,26 +257,26 @@ # ffted /= Math::sqrt(n) # for i in 0...n do # printf("%d %e %e\n", i, data[i].re, data[i].im) # end # -# == {}[link:index.html"name="3] Real data FFTs -# === {}[link:index.html"name="3.1] Overview of real data FFTs +# == Real data FFTs +# === Overview of real data FFTs # # The functions for real data FFTs are provided as instance methods of -# {GSL::Vector}[link:rdoc/vector.class]. While they are similar to those for +# {GSL::Vector}[link:vector_rdoc.html]. While they are similar to those for # complex data, there is an important difference in the data storage layout # between forward and inverse transforms. The Fourier transform of a real # sequence is not real. It is a complex sequence with a special symmetry. A # sequence with this symmetry is called <tt>conjugate-complex</tt> or # <tt>half-complex</tt> and requires only as much storage as the original real # sequence instead of twice as much. # # Forward transforms of real sequences produce half complex sequences of the same # length. Backward and inverse transforms of half complex sequences produce real # sequences of the same length. In both cases, the input and output sequences -# are instances of {GSL::Vector}[link:rdoc/vector_rdoc.html]. +# are instances of {GSL::Vector}[link:vector_rdoc.html]. # # The precise storage arrangements of half complex seqeunces depend on the # algorithm, and are different for radix-2 and mixed-radix routines. The radix-2 # functions operate in-place, which constrains the locations where each element # can be stored. The restriction forces real and imaginary parts to be stored far @@ -284,13 +284,13 @@ # the real and imaginary parts of a given term in neighboring locations (which is # desirable for better locality of memory accesses). This means that a half # complex sequence produces by a radix-2 forward transform <b>cannot</b> be # recovered by a mixed-radix inverse transform (and vice versa). # -# === {}[link:index.html"name="3.2] Radix-2 FFT routines for real data +# === Radix-2 FFT routines for real data # The routines for readix-2 real FFTs are provided as instance methods of -# {GSL::Vector}[link:rdoc/vector_rdoc.html]. +# {GSL::Vector}[link:vector_rdoc.html]. # # <b>The FFT methods described below return FFTed data, and the input vector is # not changed. Use methods with '!' as <tt>radix2_tranform!</tt> for in-place # transform.</b> # @@ -310,27 +310,27 @@ # count as a special case. Their real parts are stored in locations 0 and N/2 # respectively, while their imaginary parts which are zero are not stored. # # These methods return the FFTed data, and the input data is not changed. # -# The following table shows the correspondence between the output <tt>self</tt> -# and the equivalent results obtained by considering the input data as a +# The following table shows the correspondence between the output <tt>self</tt> +# and the equivalent results obtained by considering the input data as a # complex sequence with zero imaginary part, # -# complex[0].real = self[0] -# complex[0].imag = 0 -# complex[1].real = self[1] +# complex[0].real = self[0] +# complex[0].imag = 0 +# complex[1].real = self[1] # complex[1].imag = self[N-1] # ............... ................ # complex[k].real = self[k] -# complex[k].imag = self[N-k] +# complex[k].imag = self[N-k] # ............... ................ # complex[N/2].real = self[N/2] # complex[N/2].real = 0 # ............... ................ # complex[k'].real = self[k] k' = N - k -# complex[k'].imag = -self[N-k] +# complex[k'].imag = -self[N-k] # ............... ................ # complex[N-1].real = self[1] # complex[N-1].imag = -self[N-1] # # --- @@ -342,94 +342,94 @@ # # These methods compute the inverse or backwards radix-2 FFT of the # half-complex sequence data stored according the output scheme used by # gsl_fft_real_radix2. The result is a real array stored in natural order. # -# == {}[link:index.html"name="4] Mixed-radix FFT routines for real data +# == Mixed-radix FFT routines for real data # -# This section describes mixed-radix FFT algorithms for real data. -# The mixed-radix functions work for FFTs of any length. They are a -# reimplementation of the real-FFT routines in the Fortran FFTPACK library -# by Paul Swarztrauber. -# The theory behind the algorithm is explained in the article -# <tt>Fast Mixed-Radix Real Fourier Transforms</tt> by Clive Temperton. -# The routines here use the same indexing scheme and basic algorithms as -# FFTPACK. +# This section describes mixed-radix FFT algorithms for real data. +# The mixed-radix functions work for FFTs of any length. They are a +# reimplementation of the real-FFT routines in the Fortran FFTPACK library +# by Paul Swarztrauber. +# The theory behind the algorithm is explained in the article +# <tt>Fast Mixed-Radix Real Fourier Transforms</tt> by Clive Temperton. +# The routines here use the same indexing scheme and basic algorithms as +# FFTPACK. # # The functions use the FFTPACK storage convention for half-complex sequences. # In this convention the half-complex transform of a real sequence is stored with # frequencies in increasing order, starting at zero, with the real and imaginary # parts of each frequency in neighboring locations. When a value is known to be # real the imaginary part is not stored. The imaginary part of the zero-frequency # component is never stored. It is known to be zero since the zero frequency # component is simply the sum of the input data (all real). For a sequence of # even length the imaginary part of the frequency n/2 is not stored either, since -# the symmetry z_k = z_{N-k}^* implies that this is purely real too. +# the symmetry z_k = z_{N-k}^* implies that this is purely real too. # # -# === {}[link:index.html"name="4.1] Data storage scheme +# === Data storage scheme # -# The storage scheme is best shown by some examples. -# The table below shows the output for an odd-length sequence, n=5. -# The two columns give the correspondence between the 5 values in the -# half-complex sequence computed <tt>real_transform</tt>, <tt>halfcomplex[]</tt> -# and the values <tt>complex[]</tt> that would be returned if the same real input -# sequence were passed to <tt>complex_backward</tt> as a complex sequence +# The storage scheme is best shown by some examples. +# The table below shows the output for an odd-length sequence, n=5. +# The two columns give the correspondence between the 5 values in the +# half-complex sequence computed <tt>real_transform</tt>, <tt>halfcomplex[]</tt> +# and the values <tt>complex[]</tt> that would be returned if the same real input +# sequence were passed to <tt>complex_backward</tt> as a complex sequence # (with imaginary parts set to 0), # -# complex[0].real = halfcomplex[0] +# complex[0].real = halfcomplex[0] # complex[0].imag = 0 -# complex[1].real = halfcomplex[1] +# complex[1].real = halfcomplex[1] # complex[1].imag = halfcomplex[2] # complex[2].real = halfcomplex[3] # complex[2].imag = halfcomplex[4] # complex[3].real = halfcomplex[3] # complex[3].imag = -halfcomplex[4] # complex[4].real = halfcomplex[1] # complex[4].imag = -halfcomplex[2] # # The upper elements of the <tt>complex</tt> array, <tt>complex[3]</tt> and <tt>complex[4]</tt> -# are filled in using the symmetry condition. The imaginary part of +# are filled in using the symmetry condition. The imaginary part of # the zero-frequency term <tt>complex[0].imag</tt> is known to be zero by the symmetry. # -# The next table shows the output for an even-length sequence, +# The next table shows the output for an even-length sequence, # n=5 In the even case there are two values which are purely real, # # complex[0].real = halfcomplex[0] # complex[0].imag = 0 -# complex[1].real = halfcomplex[1] -# complex[1].imag = halfcomplex[2] -# complex[2].real = halfcomplex[3] -# complex[2].imag = halfcomplex[4] -# complex[3].real = halfcomplex[5] -# complex[3].imag = 0 -# complex[4].real = halfcomplex[3] +# complex[1].real = halfcomplex[1] +# complex[1].imag = halfcomplex[2] +# complex[2].real = halfcomplex[3] +# complex[2].imag = halfcomplex[4] +# complex[3].real = halfcomplex[5] +# complex[3].imag = 0 +# complex[4].real = halfcomplex[3] # complex[4].imag = -halfcomplex[4] -# complex[5].real = halfcomplex[1] -# complex[5].imag = -halfcomplex[2] +# complex[5].real = halfcomplex[1] +# complex[5].imag = -halfcomplex[2] # -# The upper elements of the <tt>complex</tt> array, <tt>complex[4]</tt> -# and <tt>complex[5]</tt> are filled in using the symmetry condition. +# The upper elements of the <tt>complex</tt> array, <tt>complex[4]</tt> +# and <tt>complex[5]</tt> are filled in using the symmetry condition. # Both <tt>complex[0].imag</tt> and <tt>complex[3].imag</tt> are known to be zero. # -# ==== {}[link:index.html"name="4.1.1] Wavetable and Workspace classes +# ==== Wavetable and Workspace classes # --- # * GSL::FFT::RealWavetable.alloc(n) # * GSL::FFT::HalfComplexWavetable.alloc(n) # # -# These methods create trigonometric lookup tables for an FFT of size <tt>n</tt> -# real elements. The length <tt>n</tt> is factorized into a product of subtransforms, +# These methods create trigonometric lookup tables for an FFT of size <tt>n</tt> +# real elements. The length <tt>n</tt> is factorized into a product of subtransforms, # and the factors and their trigonometric coefficients are stored in the wavetable. -# The trigonometric coefficients are computed using direct calls to sin and cos, -# for accuracy. Recursion relations could be used to compute the lookup table -# faster, but if an application performs many FFTs of the same length then -# computing the wavetable is a one-off overhead which does not affect the final +# The trigonometric coefficients are computed using direct calls to sin and cos, +# for accuracy. Recursion relations could be used to compute the lookup table +# faster, but if an application performs many FFTs of the same length then +# computing the wavetable is a one-off overhead which does not affect the final # throughput. # -# The wavetable structure can be used repeatedly for any transform of the same -# length. The table is not modified by calls to any of the other FFT functions. +# The wavetable structure can be used repeatedly for any transform of the same +# length. The table is not modified by calls to any of the other FFT functions. # The appropriate type of wavetable must be used for forward real or inverse # half-complex transforms. # # --- # * GSL::FFT::RealWorkspace.alloc(n) @@ -437,11 +437,11 @@ # # This method creates a workspace object for a real transform of length # <tt>n</tt>. The same workspace can be used for both forward real and inverse # halfcomplex transforms. # -# ==== {}[link:index.html"name="4.1.2] Methods for mixed-radix real FFTs +# ==== Methods for mixed-radix real FFTs # # <b>The FFT methods described below return FFTed data, and the input vector is not changed. Use methods with '!' as <tt>real_tranform!</tt> for in-place transform.</b> # # --- # * GSL::Vector#real_transform(table, work) @@ -452,29 +452,29 @@ # These methods compute the FFT of <tt>self</tt>, a real or half-complex array, # using a mixed radix decimation-in-frequency algorithm. For # <tt>real_transform</tt> <tt>self</tt> is an array of time-ordered real data. For # <tt>halfcomplex_transform</tt> <tt>self</tt> contains Fourier coefficients in the # half-complex ordering described above. There is no restriction on the -# length <tt>n</tt>. +# length <tt>n</tt>. # -# Efficient modules are provided for subtransforms of length 2, 3, 4 and 5. -# Any remaining factors are computed with a slow, O(n^2), general-n module. +# Efficient modules are provided for subtransforms of length 2, 3, 4 and 5. +# Any remaining factors are computed with a slow, O(n^2), general-n module. # -# The caller can supply a <tt>table</tt> containing trigonometric lookup tables +# The caller can supply a <tt>table</tt> containing trigonometric lookup tables # and a workspace <tt>work</tt> (optional). # # These methods return the FFTed data, and the input data is not changed. # # --- # * GSL::Vector#halfcomplex_inverse(table, work) # * GSL::Vector#halfcomplex_backward(table, work) # * GSL::Vector#ifft # # -# == {}[link:index.html"name="5] Examples +# == Examples # -# === {}[link:index.html"name="5.1] Example 1 +# === Example 1 # # #!/usr/bin/env ruby # require("gsl") # include GSL # @@ -491,11 +491,11 @@ # mag = y2.abs # phase = y2.arg # f = Vector.linspace(0, SAMPLING/2, mag.size) # graph(f, mag, "-C -g 3 -x 0 200 -X 'Frequency [Hz]'") # -# === {}[link:index.html"name="5.2] Example 2 +# === Example 2 # #!/usr/bin/env ruby # require("gsl") # include GSL # # n = 100 @@ -505,31 +505,31 @@ # data[i] = 1.0 # end # # rtable = FFT::RealWavetable.alloc(n) # rwork = FFT::RealWorkspace.alloc(n) -# +# # #ffted = data.real_transform(rtable, rwork) # #ffted = data.real_transform(rtable) # #ffted = data.real_transform(rwork) # #ffted = data.real_transform() # ffted = data.fft # # for i in 11...n do # ffted[i] = 0.0 # end -# +# # hctable = FFT::HalfComplexWavetable.alloc(n) -# +# # #data2 = ffted.halfcomplex_inverse(hctable, rwork) # #data2 = ffted.halfcomplex_inverse() # data2 = ffted.ifft # # graph(nil, data, data2, "-T X -C -g 3 -L 'Real-halfcomplex' -x 0 #{data.size}") # -# {prev}[link:rdoc/eigen_rdoc.html] -# {next}[link:rdoc/wavelet_rdoc.html] +# {prev}[link:eigen_rdoc.html] +# {next}[link:wavelet_rdoc.html] # -# {Reference index}[link:rdoc/ref_rdoc.html] +# {Reference index}[link:ref_rdoc.html] # {top}[link:index.html] # #