additional cpp convenience wrappers for fft and ifft

Author: 9prady9

include/af/signal.h

@@ -85,88 +85,127 @@ AFAPI array fft2(const array& in, double norm_factor, dim_type odim0=0, dim_type
 AFAPI array fft3(const array& in, double norm_factor, dim_type odim0=0, dim_type odim1=0, dim_type odim2=0);
 
 /**
-   C++ Interface for inverse fast fourier transform on one dimensional data
+   C++ Interface for fast fourier transform on one dimensional data
+
+   This version of fft function uses a default norm_factor paramter that is calculated internally
+   based on the input data.
 
    \param[in]  in is the input array
-   \param[in]  norm_factor is the normalization factor with which the input is scaled before the transformation is applied
    \param[in]  odim0 is the length of output data - used to either truncate or pad the input data
    \return     the transformed array
 
-   \ingroup signal_func_ifft
+   \ingroup signal_func_fft
  */
-AFAPI array ifft(const array& in, double norm_factor, dim_type odim0=0);
+AFAPI array fft(const array& in, dim_type odim0);
 
 /**
-   C++ Interface for inverse fast fourier transform on two dimensional data
+   C++ Interface for fast fourier transform on two dimensional data
+
+   This version of fft function uses a default norm_factor paramter that is calculated internally
+   based on the input data.
 
    \param[in]  in is the input array
-   \param[in]  norm_factor is the normalization factor with which the input is scaled before the transformation is applied
    \param[in]  odim0 is the length of output data along 0th dimension - used to either truncate/pad the input
    \param[in]  odim1 is the length of output data along 1st dimension - used to either truncate/pad the input
    \return     the transformed array
 
-   \ingroup signal_func_ifft2
+   \ingroup signal_func_fft2
  */
-AFAPI array ifft2(const array& in, double norm_factor, dim_type odim0=0, dim_type odim1=0);
+AFAPI array fft2(const array& in, dim_type odim0=0, dim_type odim1=0);
 
 /**
-   C++ Interface for inverse fast fourier transform on three dimensional data
+   C++ Interface for fast fourier transform on three dimensional data
+
+   This version of fft function uses a default norm_factor paramter that is calculated internally
+   based on the input data.
 
    \param[in]  in is the input array
-   \param[in]  norm_factor is the normalization factor with which the input is scaled before the transformation is applied
    \param[in]  odim0 is the length of output data along 0th dimension - used to either truncate/pad the input
    \param[in]  odim1 is the length of output data along 1st dimension - used to either truncate/pad the input
    \param[in]  odim2 is the length of output data along 2nd dimension - used to either truncate/pad the input
    \return     the transformed array
 
-   \ingroup signal_func_ifft3
+   \ingroup signal_func_fft3
  */
-AFAPI array ifft3(const array& in, double norm_factor, dim_type odim0=0, dim_type odim1=0, dim_type odim2=0);
+AFAPI array fft3(const array& in, dim_type odim0=0, dim_type odim1=0, dim_type odim2=0);
 
 /**
-   C++ Interface for fast fourier transform on one dimensional data
+   C++ Interface for fast fourier transform on any(1d, 2d, 3d) dimensional data
+
+   \param[in]  in is the input array
+   \param[in]  norm_factor is the normalization factor with which the input is scaled before the transformation is applied
+   \param[in]  outDims is an object of \ref dim4 that has the output array dimensions - used to either truncate or pad the input data
+   \return     the transformed array
+
+   \ingroup signal_func_fft
+ */
+AFAPI array fft(const array& in, double norm_factor, const dim4 outDims);
+
+/**
+   C++ Interface for fast fourier transform on any(1d, 2d, 3d) dimensional data
 
    This version of fft function uses a default norm_factor paramter that is calculated internally
    based on the input data.
 
    \param[in]  in is the input array
-   \param[in]  odim0 is the length of output data - used to either truncate or pad the input data
+   \param[in]  outDims is an object of \ref dim4 that has the output array dimensions - used to either truncate or pad the input data
    \return     the transformed array
 
    \ingroup signal_func_fft
  */
-AFAPI array fft(const array& in, dim_type odim0=0);
+AFAPI array fft(const array& in, const dim4 outDims);
 
 /**
-   C++ Interface for fast fourier transform on two dimensional data
+   C++ Interface for fast fourier transform on any(1d, 2d, 3d) dimensional data
 
    This version of fft function uses a default norm_factor paramter that is calculated internally
    based on the input data.
 
    \param[in]  in is the input array
+   \return     the transformed array
+
+   \ingroup signal_func_fft
+ */
+AFAPI array fft(const array& in);
+
+/**
+   C++ Interface for inverse fast fourier transform on one dimensional data
+
+   \param[in]  in is the input array
+   \param[in]  norm_factor is the normalization factor with which the input is scaled before the transformation is applied
+   \param[in]  odim0 is the length of output data - used to either truncate or pad the input data
+   \return     the transformed array
+
+   \ingroup signal_func_ifft
+ */
+AFAPI array ifft(const array& in, double norm_factor, dim_type odim0=0);
+
+/**
+   C++ Interface for inverse fast fourier transform on two dimensional data
+
+   \param[in]  in is the input array
+   \param[in]  norm_factor is the normalization factor with which the input is scaled before the transformation is applied
    \param[in]  odim0 is the length of output data along 0th dimension - used to either truncate/pad the input
    \param[in]  odim1 is the length of output data along 1st dimension - used to either truncate/pad the input
    \return     the transformed array
 
-   \ingroup signal_func_fft2
+   \ingroup signal_func_ifft2
  */
-AFAPI array fft2(const array& in, dim_type odim0=0, dim_type odim1=0);
+AFAPI array ifft2(const array& in, double norm_factor, dim_type odim0=0, dim_type odim1=0);
 
 /**
-   C++ Interface for fast fourier transform on three dimensional data
-
-   This version of fft function uses a default norm_factor paramter that is calculated internally
-   based on the input data.
+   C++ Interface for inverse fast fourier transform on three dimensional data
 
    \param[in]  in is the input array
+   \param[in]  norm_factor is the normalization factor with which the input is scaled before the transformation is applied
    \param[in]  odim0 is the length of output data along 0th dimension - used to either truncate/pad the input
    \param[in]  odim1 is the length of output data along 1st dimension - used to either truncate/pad the input
    \param[in]  odim2 is the length of output data along 2nd dimension - used to either truncate/pad the input
    \return     the transformed array
 
-   \ingroup signal_func_fft3
+   \ingroup signal_func_ifft3
  */
-AFAPI array fft3(const array& in, dim_type odim0=0, dim_type odim1=0, dim_type odim2=0);
+AFAPI array ifft3(const array& in, double norm_factor, dim_type odim0=0, dim_type odim1=0, dim_type odim2=0);
 
 /**
    C++ Interface for inverse fast fourier transform on one dimensional data
@@ -180,7 +219,7 @@ AFAPI array fft3(const array& in, dim_type odim0=0, dim_type odim1=0, dim_type o
 
    \ingroup signal_func_ifft
  */
-AFAPI array ifft(const array& in, dim_type odim0=0);
+AFAPI array ifft(const array& in, dim_type odim0);
 
 /**
    C++ Interface for inverse fast fourier transform on two dimensional data
@@ -213,6 +252,45 @@ AFAPI array ifft2(const array& in, dim_type odim0=0, dim_type odim1=0);
  */
 AFAPI array ifft3(const array& in, dim_type odim0=0, dim_type odim1=0, dim_type odim2=0);
 
+/**
+   C++ Interface for inverse fast fourier transform on any(1d, 2d, 3d) dimensional data
+
+   \param[in]  in is the input array
+   \param[in]  norm_factor is the normalization factor with which the input is scaled before the transformation is applied
+   \param[in]  outDims is an object of \ref dim4 that has the output array dimensions - used to either truncate or pad the input data
+   \return     the transformed array
+
+   \ingroup signal_func_fft
+ */
+AFAPI array ifft(const array& in, double norm_factor, const dim4 outDims);
+
+/**
+   C++ Interface for inverse fast fourier transform on any(1d, 2d, 3d) dimensional data
+
+   This version of fft function uses a default norm_factor paramter that is calculated internally
+   based on the input data.
+
+   \param[in]  in is the input array
+   \param[in]  outDims is an object of \ref dim4 that has the output array dimensions - used to either truncate or pad the input data
+   \return     the transformed array
+
+   \ingroup signal_func_fft
+ */
+AFAPI array ifft(const array& in, const dim4 outDims);
+
+/**
+   C++ Interface for inverse fast fourier transform on any(1d, 2d, 3d) dimensional data
+
+   This version of fft function uses a default norm_factor paramter that is calculated internally
+   based on the input data.
+
+   \param[in]  in is the input array
+   \return     the transformed array
+
+   \ingroup signal_func_fft
+ */
+AFAPI array ifft(const array& in);
+
 /**
    C++ Interface for convolution any(one through three) dimensional data
 

src/api/cpp/fft.cpp

@@ -13,6 +13,7 @@
 namespace af
 {
 
+
 array fft(const array& in, double norm_factor, dim_type odim0)
 {
     af_array out = 0;
@@ -34,48 +35,61 @@ array fft3(const array& in, double norm_factor, dim_type odim0, dim_type odim1,
     return array(out);
 }
 
-array ifft(const array& in, double norm_factor, dim_type odim0)
+array fft(const array& in, dim_type odim0)
 {
-    af_array out = 0;
-    AF_THROW(af_ifft(&out, in.get(), norm_factor, odim0));
-    return array(out);
+    return fft(in, 1.0, odim0);
 }
 
-array ifft2(const array& in, double norm_factor, dim_type odim0, dim_type odim1)
+array fft2(const array& in, dim_type odim0, dim_type odim1)
 {
-    af_array out = 0;
-    AF_THROW(af_ifft2(&out, in.get(), norm_factor, odim0, odim1));
-    return array(out);
+    return fft2(in, 1.0, odim0, odim1);
 }
 
-array ifft3(const array& in, double norm_factor, dim_type odim0, dim_type odim1, dim_type odim2)
+array fft3(const array& in, dim_type odim0, dim_type odim1, dim_type odim2)
 {
-    af_array out = 0;
-    AF_THROW(af_ifft3(&out, in.get(), norm_factor, odim0, odim1, odim2));
-    return array(out);
+    return fft3(in, 1.0, odim0, odim1, odim2);
 }
 
-array fft(const array& in, dim_type odim0)
+array fft(const array& in, double norm_factor, const dim4 outDims)
+{
+    array temp;
+    switch(in.dims().ndims()) {
+        case 1: temp = fft(in, norm_factor, outDims[0]); break;
+        case 2: temp = fft2(in, norm_factor, outDims[0], outDims[1]); break;
+        case 3: temp = fft3(in, norm_factor, outDims[0], outDims[1], outDims[2]); break;
+        default: AF_THROW(AF_ERR_NOT_SUPPORTED);
+    }
+    return temp;
+}
+
+array fft(const array& in, const dim4 outDims)
+{
+    return fft(in, 1.0, outDims);
+}
+
+array fft(const array& in)
+{
+    return fft(in, 1.0, dim4(0,0,0,0));
+}
+
+array ifft(const array& in, double norm_factor, dim_type odim0)
 {
-    double norm_factor = 1.0;
     af_array out = 0;
-    AF_THROW(af_fft(&out, in.get(), norm_factor, odim0));
+    AF_THROW(af_ifft(&out, in.get(), norm_factor, odim0));
     return array(out);
 }
 
-array fft2(const array& in, dim_type odim0, dim_type odim1)
+array ifft2(const array& in, double norm_factor, dim_type odim0, dim_type odim1)
 {
-    double norm_factor = 1.0;
     af_array out = 0;
-    AF_THROW(af_fft2(&out, in.get(), norm_factor, odim0, odim1));
+    AF_THROW(af_ifft2(&out, in.get(), norm_factor, odim0, odim1));
     return array(out);
 }
 
-array fft3(const array& in, dim_type odim0, dim_type odim1, dim_type odim2)
+array ifft3(const array& in, double norm_factor, dim_type odim0, dim_type odim1, dim_type odim2)
 {
-    double norm_factor = 1.0;
     af_array out = 0;
-    AF_THROW(af_fft3(&out, in.get(), norm_factor, odim0, odim1, odim2));
+    AF_THROW(af_ifft3(&out, in.get(), norm_factor, odim0, odim1, odim2));
     return array(out);
 }
 
@@ -84,9 +98,7 @@ array ifft(const array& in, dim_type odim0)
     const dim4 dims = in.dims();
     dim_type dim0 = odim0==0 ? dims[0] : odim0;
     double norm_factor = 1.0/dim0;
-    af_array out = 0;
-    AF_THROW(af_ifft(&out, in.get(), norm_factor, odim0));
-    return array(out);
+    return ifft(in, norm_factor, odim0);
 }
 
 array ifft2(const array& in, dim_type odim0, dim_type odim1)
@@ -95,9 +107,7 @@ array ifft2(const array& in, dim_type odim0, dim_type odim1)
     dim_type dim0 = odim0==0 ? dims[0] : odim0;
     dim_type dim1 = odim1==0 ? dims[1] : odim1;
     double norm_factor = 1.0/(dim0*dim1);
-    af_array out = 0;
-    AF_THROW(af_ifft2(&out, in.get(), norm_factor, odim0, odim1));
-    return array(out);
+    return ifft2(in, norm_factor, odim0, odim1);
 }
 
 array ifft3(const array& in, dim_type odim0, dim_type odim1, dim_type odim2)
@@ -107,9 +117,29 @@ array ifft3(const array& in, dim_type odim0, dim_type odim1, dim_type odim2)
     dim_type dim1 = odim1==0 ? dims[1] : odim1;
     dim_type dim2 = odim2==0 ? dims[2] : odim2;
     double norm_factor = 1.0/(dim0*dim1*dim2);
-    af_array out = 0;
-    AF_THROW(af_ifft3(&out, in.get(), norm_factor, odim0, odim1, odim2));
-    return array(out);
+    return ifft3(in, norm_factor, odim0, odim1, odim2);
+}
+
+array ifft(const array& in, double norm_factor, const dim4 outDims)
+{
+    array temp;
+    switch(in.dims().ndims()) {
+        case 1: temp =  ifft(in, norm_factor, outDims[0]); break;
+        case 2: temp = ifft2(in, norm_factor, outDims[0], outDims[1]); break;
+        case 3: temp = ifft3(in, norm_factor, outDims[0], outDims[1], outDims[2]); break;
+        default: AF_THROW(AF_ERR_NOT_SUPPORTED);
+    }
+    return temp;
+}
+
+array ifft(const array& in, const dim4 outDims)
+{
+    return ifft(in, 1.0, outDims);
+}
+
+array ifft(const array& in)
+{
+    return ifft(in, 1.0, dim4(0,0,0,0));
 }
 
 }