Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help
Math::GSL::FFT(3)     User Contributed Perl Documentation    Math::GSL::FFT(3)

NAME
       Math::GSL::FFT -	Fast Fourier Transforms	(FFT)

SYNOPSIS
	   use Math::GSL::FFT qw /:all/;
	   my $input1		   = [ 0 .. 7 ];
	   my $N1		   = @$input1;
	   my ($status1, $output1) = gsl_fft_real_radix2_transform ($input, 1, $N1);
	   my ($status2, $output2) = gsl_fft_halfcomplex_radix2_inverse($output2, 1, $N1);
	   # $input1 ==	$output2

	   my $input2		   = [ 0 .. 6 ];
	   my $N2		   = @$input;
	   my $workspace1	   = gsl_fft_real_workspace_alloc($N2);
	   my $wavetable1	   = gsl_fft_real_wavetable_alloc($N2);
	   my ($status3,$output3)  = gsl_fft_real_transform ($input, 1,	$N2, $wavetable1, $workspace1);
	   my $wavetable4	   = gsl_fft_halfcomplex_wavetable_alloc($N2);
	   my $workspace4	   = gsl_fft_real_workspace_alloc($N2);
	   my ($status4,$output4)  = gsl_fft_halfcomplex_inverse($output, 1, $N2, $wavetable4, $workspace4);

	   # $input2 ==	$output4

DESCRIPTION
       o   "gsl_fft_complex_radix2_forward($data, $stride, $n) "

	   This	function computes the forward FFTs of length $n	with stride
	   $stride, on the array reference $data using an in-place radix-2
	   decimation-in-time algorithm. The length of the transform $n	is
	   restricted to powers	of two.	For the	transform version of the
	   function the	sign argument can be either forward (-1) or backward
	   (+1). The functions return a	value of $GSL_SUCCESS if no errors
	   were	detected, or $GSL_EDOM if the length of	the data $n is not a
	   power of two.

       o   "gsl_fft_complex_radix2_backward "

       o   "gsl_fft_complex_radix2_inverse "

       o   "gsl_fft_complex_radix2_transform "

       o   "gsl_fft_complex_radix2_dif_forward "

       o   "gsl_fft_complex_radix2_dif_backward	"

       o   "gsl_fft_complex_radix2_dif_inverse "

       o   "gsl_fft_complex_radix2_dif_transform "

       o   "gsl_fft_complex_wavetable_alloc($n)"

	   This	function prepares a trigonometric lookup table for a complex
	   FFT of length $n. The function returns a pointer to the newly
	   allocated gsl_fft_complex_wavetable if no errors were detected, and
	   a null pointer in the case of error.	The length $n 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 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 same	wavetable can be used for both forward and
	   backward (or	inverse) transforms of a given length.

       o   "gsl_fft_complex_wavetable_free($wavetable)"

	   This	function frees the memory associated with the wavetable
	   $wavetable. The wavetable can be freed if no	further	FFTs of	the
	   same	length will be needed.

       o   "gsl_fft_complex_workspace_alloc($n)"

	   This	function allocates a workspace for a complex transform of
	   length $n.

       o   "gsl_fft_complex_workspace_free($workspace) "

	   This	function frees the memory associated with the workspace
	   $workspace. The workspace can be freed if no	further	FFTs of	the
	   same	length will be needed.

       o   "gsl_fft_complex_memcpy "

       o   "gsl_fft_complex_forward "

       o   "gsl_fft_complex_backward "

       o   "gsl_fft_complex_inverse "

       o   "gsl_fft_complex_transform "

       o   "gsl_fft_halfcomplex_radix2_backward($data, $stride,	$n)"

	   This	function computes the backwards	in-place radix-2 FFT of	length
	   $n and stride $stride on 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.

       o   "gsl_fft_halfcomplex_radix2_inverse($data, $stride, $n)"

	   This	function computes the inverse in-place radix-2 FFT of length
	   $n and stride $stride on 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.

       o   "gsl_fft_halfcomplex_radix2_transform"

       o   "gsl_fft_halfcomplex_wavetable_alloc($n)"

	   This	function prepares trigonometric	lookup tables for an FFT of
	   size	$n real	elements. The functions	return a pointer to the	newly
	   allocated struct if no errors were detected,	and a null pointer in
	   the case of error. The length $n 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 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
	   appropriate type of wavetable must be used for forward real or
	   inverse half-complex	transforms.

       o   "gsl_fft_halfcomplex_wavetable_free($wavetable)"

	   This	function frees the memory associated with the wavetable
	   $wavetable. The wavetable can be freed if no	further	FFTs of	the
	   same	length will be needed.

       o   "gsl_fft_halfcomplex_backward "

       o   "gsl_fft_halfcomplex_inverse	"

       o   "gsl_fft_halfcomplex_transform "

       o   "gsl_fft_halfcomplex_unpack "

       o   "gsl_fft_halfcomplex_radix2_unpack "

       o   "gsl_fft_real_radix2_transform($data, $stride, $n) "

	   This	function computes an in-place radix-2 FFT of length $n and
	   stride $stride on the real array reference $data. The output	is a
	   half-complex	sequence, which	is stored in-place. The	arrangement of
	   the half-complex terms uses the following scheme: for k < N/2 the
	   real	part of	the k-th term is stored	in location k, and the
	   corresponding imaginary part	is stored in location N-k.  Terms with
	   k > N/2 can be reconstructed	using the symmetry z_k = z^*_{N-k}.
	   The terms for k=0 and k=N/2 are both	purely real, and 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. The following table shows the correspondence	between	the
	   output data and the equivalent results obtained by considering the
	   input data as a complex sequence with zero imaginary	part,

		     complex[0].real	=    data[0]
		     complex[0].imag	=    0
		     complex[1].real	=    data[1]
		     complex[1].imag	=    data[N-1]
		     ...............	     ................
		     complex[k].real	=    data[k]
		     complex[k].imag	=    data[N-k]
		     ...............	     ................
		     complex[N/2].real	=    data[N/2]
		     complex[N/2].imag	=    0
		     ...............	     ................
		     complex[k'].real	=    data[k]	    k' = N - k
		     complex[k'].imag	=   -data[N-k]
		     ...............	     ................
		     complex[N-1].real	=    data[1]
		     complex[N-1].imag	=   -data[N-1]

	   Note	that the output	data can be converted into the full complex
	   sequence using the function gsl_fft_halfcomplex_unpack.

       o   "gsl_fft_real_wavetable_alloc($n)"

	   This	function prepares trigonometric	lookup tables for an FFT of
	   size	$n real	elements. The functions	return a pointer to the	newly
	   allocated struct if no errors were detected,	and a null pointer in
	   the case of error. The length $n 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 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
	   appropriate type of wavetable must be used for forward real or
	   inverse half-complex	transforms.

       o   "gsl_fft_real_wavetable_free($wavetable)"

	   This	function frees the memory associated with the wavetable
	   $wavetable. The wavetable can be freed if no	further	FFTs of	the
	   same	length will be needed.

       o   "gsl_fft_real_workspace_alloc($n)"

	   This	function allocates a workspace for a real transform of length
	   $n. The same	workspace can be used for both forward real and
	   inverse halfcomplex transforms.

       o   "gsl_fft_real_workspace_free($workspace)"

	   This	function frees the memory associated with the workspace
	   $workspace. The workspace can be freed if no	further	FFTs of	the
	   same	length will be needed.

       o   "gsl_fft_real_transform "

       o   "gsl_fft_real_unpack	"

       This module also	includes the following constants :

       o   $gsl_fft_forward

       o   $gsl_fft_backward

       For more	informations on	the functions, we refer	you to the GSL offcial
       documentation: <http://www.gnu.org/software/gsl/manual/html_node/>

AUTHORS
       Jonathan	"Duke" Leto <jonathan@leto.net>	and Thierry Moisan
       <thierry.moisan@gmail.com>

COPYRIGHT AND LICENSE
       Copyright (C) 2008-2020 Jonathan	"Duke" Leto and	Thierry	Moisan

       This program is free software; you can redistribute it and/or modify it
       under the same terms as Perl itself.

perl v5.32.0			  2020-08-10		     Math::GSL::FFT(3)

NAME | SYNOPSIS | DESCRIPTION | AUTHORS | COPYRIGHT AND LICENSE

Want to link to this manual page? Use this URL:
<https://www.freebsd.org/cgi/man.cgi?query=Math::GSL::FFT&sektion=3&manpath=FreeBSD+12.2-RELEASE+and+Ports>

home | help