Ignore:
Timestamp:
Feb 9, 2001, 6:08:57 PM (25 years ago)
Author:
ansari
Message:

Modifs interface FFTServer , Reza 9/2/2001

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/SophyaLib/NTools/fftservintf.cc

    r1371 r1390  
    66  \ingroup NTools
    77  Defines the interface for FFT (Fast Fourier Transform) operations.
    8   Warning: The interface is likely to be changed and simplified,
    9   using only SOPHYA::TArray Objects.
    108*/
    119
    … …  
    2220}
    2321
    24 /* --Methode-- */
    25 void FFTServerInterface::FFTForward(TVector< complex<r_8> > const &, TVector< complex<r_8> > &)
    26 {
    27   throw NotAvailableOperation("FFTServer::FFTForward(TVector...) Unsupported operation !");
    28 }
    29 
    30 /* --Methode-- */
    31 void FFTServerInterface::FFTBackward(TVector< complex<r_8> > const &, TVector< complex<r_8> > &)
    32 {
    33   throw NotAvailableOperation("FFTServer::FFTBackward(TVector...) Unsupported operation !");
    34 }
    35 
    36 /* --Methode-- */
    37 void FFTServerInterface::FFTForward(TVector< r_8 > const &, TVector< complex<r_8> > &)
    38 {
    39   throw NotAvailableOperation("FFTServer::FFTForward(TVector...) Unsupported operation !");
    40 }
    41 
    42 /* --Methode-- */
    43 void FFTServerInterface::FFTBackward(TVector< complex<r_8> > const &, TVector< r_8 > &)
    44 {
    45   throw NotAvailableOperation("FFTServer::FFTBackward(TVector...) Unsupported operation !");
    46 }
    47 
    48 /* --Methode-- */
    49 void FFTServerInterface::FFTForward(TMatrix< complex<r_8> > const &, TMatrix< complex<r_8> > &)
    50 {
    51   throw NotAvailableOperation("FFTServer::FFTForward(TMatrix...) Unsupported operation !");
    52 }
    53 
    54 /* --Methode-- */
    55 void FFTServerInterface::FFTBackward(TMatrix< complex<r_8> > const &, TMatrix< complex<r_8> > &)
    56 {
    57   throw NotAvailableOperation("FFTServer::FFTBackward(TMatrix...) Unsupported operation !");
    58 }
    59 
    60 /* --Methode-- */
    61 void FFTServerInterface::FFTForward(TMatrix< r_8 > const &, TMatrix< complex<r_8> > &)
    62 {
    63   throw NotAvailableOperation("FFTServer::FFTForward(TMatrix...) Unsupported operation !");
    64 }
    65 
    66 /* --Methode-- */
    67 void FFTServerInterface::FFTBackward(TMatrix< complex<r_8> > const &, TMatrix< r_8 > &)
    68 {
    69   throw NotAvailableOperation("FFTServer::FFTBackward(TMatrix...) Unsupported operation !");
     22// ----------------- Transforme pour les double -------------------
     23
     24/* --Methode-- */
     25void FFTServerInterface::FFTForward(TArray< complex<r_8> > const &, TArray< complex<r_8> > &)
     26{
     27  throw NotAvailableOperation("FFTServer::FFTForward(TArray...) Unsupported operation !");
     28}
     29
     30/* --Methode-- */
     31void FFTServerInterface::FFTBackward(TArray< complex<r_8> > const &, TArray< complex<r_8> > &)
     32{
     33  throw NotAvailableOperation("FFTServer::FFTBackward(TArray...) Unsupported operation !");
     34}
     35
     36/* --Methode-- */
     37void FFTServerInterface::FFTForward(TArray< r_8 > const &, TArray< complex<r_8> > &)
     38{
     39  throw NotAvailableOperation("FFTServer::FFTForward(TArray...) Unsupported operation !");
     40}
     41
     42/* --Methode-- */
     43void FFTServerInterface::FFTBackward(TArray< complex<r_8> > const &, TArray< r_8 > &)
     44{
     45  throw NotAvailableOperation("FFTServer::FFTBackward(TArray...) Unsupported operation !");
    7046}
    7147
    … …  
    7450
    7551/* --Methode-- */
    76 void FFTServerInterface::FFTForward(TVector< complex<r_4> > const &, TVector< complex<r_4> > &)
    77 {
    78   throw NotAvailableOperation("FFTServer::FFTForward(TVector r_4 ... ) Unsupported operation !");
    79 }
    80 
    81 /* --Methode-- */
    82 void FFTServerInterface::FFTBackward(TVector< complex<r_4> > const &, TVector< complex<r_4> > &)
    83 {
    84   throw NotAvailableOperation("FFTServer::FFTBackward(TVector r_4 ... ) Unsupported operation !");
    85 }
    86 
    87 /* --Methode-- */
    88 void FFTServerInterface::FFTForward(TVector< r_4 > const &, TVector< complex<r_4> > &)
    89 {
    90   throw NotAvailableOperation("FFTServer::FFTForward(TVector r_4 ... ) Unsupported operation !");
    91 }
    92 
    93 /* --Methode-- */
    94 void FFTServerInterface::FFTBackward(TVector< complex<r_4> > const &, TVector< r_4 > &)
    95 {
    96   throw NotAvailableOperation("FFTServer::FFTBackward(TVector r_4 ... ) Unsupported operation !");
    97 }
    98 
    99 /* --Methode-- */
    100 void FFTServerInterface::FFTForward(TMatrix< complex<r_4> > const &, TMatrix< complex<r_4> > &)
    101 {
    102   throw NotAvailableOperation("FFTServer::FFTForward(TMatrix r_4 ... ) Unsupported operation !");
    103 }
    104 
    105 /* --Methode-- */
    106 void FFTServerInterface::FFTBackward(TMatrix< complex<r_4> > const &, TMatrix< complex<r_4> > &)
    107 {
    108   throw NotAvailableOperation("FFTServer::FFTBackward(TMatrix r_4 ... ) Unsupported operation !");
    109 }
    110 
    111 /* --Methode-- */
    112 void FFTServerInterface::FFTForward(TMatrix< r_4 > const &, TMatrix< complex<r_4> > &)
    113 {
    114   throw NotAvailableOperation("FFTServer::FFTForward(TMatrix r_4 ... ) Unsupported operation !");
    115 }
    116 
    117 /* --Methode-- */
    118 void FFTServerInterface::FFTBackward(TMatrix< complex<r_4> > const &, TMatrix< r_4 > &)
    119 {
    120   throw NotAvailableOperation("FFTServer::FFTBackward(TMatrix r_4 ... ) Unsupported operation !");
    121 }
    122 
    123 
     52void FFTServerInterface::FFTForward(TArray< complex<r_4> > const &, TArray< complex<r_4> > &)
     53{
     54  throw NotAvailableOperation("FFTServer::FFTForward(TArray r_4 ... ) Unsupported operation !");
     55}
     56
     57/* --Methode-- */
     58void FFTServerInterface::FFTBackward(TArray< complex<r_4> > const &, TArray< complex<r_4> > &)
     59{
     60  throw NotAvailableOperation("FFTServer::FFTBackward(TArray r_4 ... ) Unsupported operation !");
     61}
     62
     63/* --Methode-- */
     64void FFTServerInterface::FFTForward(TArray< r_4 > const &, TArray< complex<r_4> > &)
     65{
     66  throw NotAvailableOperation("FFTServer::FFTForward(TArray r_4 ... ) Unsupported operation !");
     67}
     68
     69/* --Methode-- */
     70void FFTServerInterface::FFTBackward(TArray< complex<r_4> > const &, TArray< r_4 > &)
     71{
     72  throw NotAvailableOperation("FFTServer::FFTBackward(TArray r_4 ... ) Unsupported operation !");
     73}
     74
     75
     76
     77/* --Methode-- */
     78template <class T>
     79FFTArrayChecker<T>::FFTArrayChecker(bool checkpack, bool onedonly)
     80{
     81  _checkpack = checkpack;
     82  _onedonly = onedonly;
     83}
     84
     85/* --Methode-- */
     86template <class T>
     87FFTArrayChecker<T>::~FFTArrayChecker()
     88{
     89}
     90
     91/* --Methode-- */
     92template <class T>
     93int FFTArrayChecker<T>::CheckResize(TArray< complex<T> > const & in, TArray< complex<T> > & out)
     94{
     95  int k;
     96  if (in.Size() < 1)
     97    throw(SzMismatchError("FFTArrayChecker::CheckResize(complex in, complex out) - Unallocated input array !"));
     98  if (_checkpack)
     99    if ( !in.IsPacked() )
     100      throw(SzMismatchError("FFTArrayChecker::CheckResize(complex in, complex out) - Not packed input array !"));
     101  int ndg1 = 0;
     102  for(k=0; k<in.NbDimensions(); k++)
     103    if (in.Size(k) > 1)  ndg1++;
     104  if (_onedonly)
     105    if (ndg1++ > 1)
     106      throw(SzMismatchError("FFTArrayChecker::CheckResize(complex in, complex out) - Only 1-D array accepted !"));
     107 
     108  sa_size_t sz[BASEARRAY_MAXNDIMS];
     109  for(k=0; k<in.NbDimensions(); k++)
     110    sz[k] = in.Size(k);
     111  out.ReSize(in.NbDimensions(), sz);
     112
     113  return(ndg1);
     114}
     115
     116/* --Methode-- */
     117template <class T>
     118int FFTArrayChecker<T>::CheckResize(TArray< T > const & in, TArray< complex<T> > & out)
     119{
     120  int k;
     121  if (in.Size() < 1)
     122    throw(SzMismatchError("FFTArrayChecker::CheckResize(real in, complex out) - Unallocated input array !"));
     123  if (_checkpack)
     124    if ( !in.IsPacked() )
     125      throw(SzMismatchError("FFTArrayChecker::CheckResize(real in, complex out) - Not packed input array !"));
     126  int ndg1 = 0;
     127  for(k=0; k<in.NbDimensions(); k++)
     128    if (in.Size(k) > 1)  ndg1++;
     129  if (_onedonly)
     130    if (ndg1++ > 1)
     131      throw(SzMismatchError("FFTArrayChecker::CheckResize(real in, complex out) - Only 1-D array accepted !"));
     132 
     133  sa_size_t sz[BASEARRAY_MAXNDIMS];
     134  for(k=0; k<in.NbDimensions(); k++)
     135    sz[k] = in.Size(k)/2+1;
     136  out.ReSize(in.NbDimensions(), sz);
     137
     138  return(ndg1);
     139}
     140
     141/* --Methode-- */
     142template <class T>
     143int FFTArrayChecker<T>::CheckResize(TArray< complex<T> > const & in, TArray< T > & out)
     144{
     145  int k;
     146  if (in.Size() < 1)
     147    throw(SzMismatchError("FFTArrayChecker::CheckResize(complex in, real out) - Unallocated input array !"));
     148  if (_checkpack)
     149    if ( !in.IsPacked() )
     150      throw(SzMismatchError("FFTArrayChecker::CheckResize(complex in, real out) - Not packed input array !"));
     151  int ndg1 = 0;
     152  for(k=0; k<in.NbDimensions(); k++)
     153    if (in.Size(k) > 1)  ndg1++;
     154  if (_onedonly)
     155    if (ndg1++ > 1)
     156      throw(SzMismatchError("FFTArrayChecker::CheckResize(complex in, real out) - Only 1-D array accepted !"));
     157 
     158  sa_size_t sz[BASEARRAY_MAXNDIMS];
     159  for(k=0; k<in.NbDimensions(); k++)
     160    sz[k] = in.Size(k)*2-1;
     161  out.ReSize(in.NbDimensions(), sz);
     162
     163  return(ndg1);
     164
     165}
     166
     167/* --Methode-- */
     168template <class T>
     169void FFTArrayChecker<T>::ReShapetoReal( TArray< complex<T> > const & in, TArray< T >  & out)
     170{
     171  sa_size_t n = in.Size();
     172  //  int ncs = (fabs(in(n-1).imag()) > 1.e-12) ? ncs = 2*n-1 : ncs = n*2-2;
     173  sa_size_t ncs = 2*n-1;
     174  sa_size_t k;
     175  out[0] = in[0].real();
     176  for(k=1;k<n-1;k++) {
     177    out[2*k-1] = in[k].real();
     178    out[2*k] = in[k].imag();
     179  }
     180  //  if (ncs == n*2-2)  out[ncs-1] = in[n-1].real();
     181  //  else { out[ncs-2] = in[n-1].real();  out[ncs-1] = in[n-1].imag(); }
     182  out[ncs-2] = in[n-1].real();  out[ncs-1] = in[n-1].imag();
     183}
     184
     185/* --Methode-- */
     186template <class T>
     187void FFTArrayChecker<T>::ReShapetoCompl(TArray< T > const & in, TArray< complex<T> > & out)
     188{
     189  sa_size_t n =  in.Size();
     190  sa_size_t ncs = n/2+1;
     191  sa_size_t nc = (n%2 != 0) ? n/2+1 : n/2;
     192  out[0] = complex<T> (in[0],0.);
     193  for(int k=1;k<nc;k++)
     194    out[k] =  complex<T> (in[2*k-1], in[2*k]);
     195  if (n%2 == 0) out[ncs-1] = complex<r_8>(in[n-1], 0.);
     196}
     197
     198
     199#ifdef __CXX_PRAGMA_TEMPLATES__
     200#pragma define_template FFTArrayChecker<r_4>
     201#pragma define_template FFTArrayChecker<r_8>
     202#endif
     203
     204#if defined(ANSI_TEMPLATES) || defined(GNU_TEMPLATES)
     205template class FFTArrayChecker<r_4>;
     206template class FFTArrayChecker<r_8>;
     207#endif
Note: See TracChangeset for help on using the changeset viewer.