VecOpCx.h

#ifndef PSCF_CPU_VEC_OP_CX_H
#define PSCF_CPU_VEC_OP_CX_H
 
/*
* PSCF - Polymer Self-Consistent Field
*
* Copyright 2015 - 2025, The Regents of the University of Minnesota
* Distributed under the terms of the GNU General Public License.
*/
 
#include "VecOp.h"
#include <fftw3.h>
 
// Forward declaration
namespace Util {
   template <typename T> class Array;
}
 
namespace Pscf {
 
   using namespace Util;
 
   /*
   * Functions for element-wise complex vector operations on a CPU.
   *
   * Naming conventions are the same as those described in the file 
   * cpu/VecOp.h, which contains declarations of analogous functions
   * for real-valued arrays. Many operations involving complex arrays 
   * are implemented in both purely complex form, in which all inputs
   * are complex numbers, and "mixed" form in which one or more of the 
   * inputs is a real array or a real scalar.
   *
   * Functions defined in this file use the complex type fftw_complex
   * that is defined for use with the FFTW fast Fourier transform
   * library.
   */
 
   namespace VecOp {
 
      // Real and imaginary parts

      void real(Array<double>& a, Array<fftw_complex> const & b);

      void imag(Array<double>& a, Array<fftw_complex> const & b);
 
      // Assignment

      void eqV(Array<fftw_complex>& a, Array<fftw_complex> const & b);

      void eqV(Array<fftw_complex>& a,
               Array<double> const & b,
               Array<double> const & c);

      void eqV(Array<fftw_complex>& a, Array<double> const & b);

      void eqS(Array<fftw_complex>& a, fftw_complex b);

      void eqS(Array<fftw_complex>& a, double b);
 
      // Addition

      void addVV(Array<fftw_complex>& a,
                 Array<fftw_complex> const & b,
                 Array<fftw_complex> const & c);

      void addVV(Array<fftw_complex> & a,
                 Array<fftw_complex> const & b,
                 Array<double> const & c);

      void addVS(Array<fftw_complex> & a,
                 Array<fftw_complex> const & b,
                 fftw_complex c);

      void addVS(Array<fftw_complex> & a,
                 Array<fftw_complex> const & b,
                 double c);
 
      // Subtraction

      void subVV(Array<fftw_complex> & a,
                 Array<fftw_complex> const & b,
                 Array<fftw_complex> const & c);

      void subVV(Array<fftw_complex> & a,
                 Array<fftw_complex> const & b,
                 Array<double> const & c);

      void subVS(Array<fftw_complex> & a,
                 Array<fftw_complex> const & b,
                 fftw_complex c);

      void subVS(Array<fftw_complex> & a,
                 Array<fftw_complex> const & b,
                 double c);
 
      // Multiplication

      void mulVV(Array<fftw_complex> & a,
                 Array<fftw_complex> const & b,
                 Array<fftw_complex> const & c);

      void mulVV(Array<fftw_complex> & a,
                 Array<fftw_complex> const & b,
                 Array<double> const & c);

      void mulVS(Array<fftw_complex> & a,
                 Array<fftw_complex> const & b,
                 fftw_complex c);

      void mulVS(Array<fftw_complex> & a,
                 Array<fftw_complex> const & b,
                 double c);
 
      // Division

      void divVV(Array<fftw_complex> & a,
                 Array<fftw_complex> const & b,
                 Array<fftw_complex> const & c);

      void divVV(Array<fftw_complex> & a,
                 Array<fftw_complex> const & b,
                 Array<double> const & c);

      void divVS(Array<fftw_complex> & a,
                 Array<fftw_complex> const & b,
                 fftw_complex c);

      void divVS(Array<fftw_complex> & a,
                       Array<fftw_complex> const & b,
                       double c);
 
      // In-place addition
 
      /*
      * Vector in-place addition, a[i] += b[i] (complex).
      *
      * \ingroup Pscf_Cpu_VecOp_Module
      *
      * \param a  complex array (LHS)
      * \param b  complex array (RHS)
      */
      void addEqV(Array<fftw_complex> & a, Array<fftw_complex> const & b);
 
      /*
      * Vector in-place addition, a[i] += (b[i], c[i]) (complex).
      *
      * This function add real array b to the real part of complex array a,
      * and adds real array c to the imaginary part of complex array a.
      *
      * \ingroup Pscf_Cpu_VecOp_Module
      *
      * \param a  complex array (LHS)
      * \param b  real array, increment of real part (RHS)
      * \param c  real array, increment of imaginary part (RHS)
      */
      void addEqV(Array<fftw_complex> & a, 
                  Array<double> const & b,
                  Array<double> const & c);
 
      /*
      * Vector in-place addition, a[i] += b[i] (mixed, reall array b).
      *
      * \ingroup Pscf_Cpu_VecOp_Module
      *
      * \param a  complex array (LHS)
      * \param b  real array (RHS)
      */
      void addEqV(Array<fftw_complex> & a, Array<double> const & b);
 
      /*
      * Vector-scalar in-place addition, a[i] += b (complex).
      *
      * \ingroup Pscf_Cpu_VecOp_Module
      *
      * \param a  complex array (LHS)
      * \param b  complex scalar (RHS)
      */
      void addEqS(Array<fftw_complex> & a, fftw_complex b);

      void addEqS(Array<fftw_complex> & a, double b);
 
      // In-place subtraction

      void subEqV(Array<fftw_complex>& a, Array<fftw_complex> const & b);

      void subEqV(Array<fftw_complex>& a, Array<double> const & b);

      void subEqS(Array<fftw_complex>& a, fftw_complex b);

      void subEqS(Array<fftw_complex>& a, double b);
 
      // In-place multiplication

      void mulEqV(Array<fftw_complex>& a, Array<fftw_complex> const & b);

      void mulEqV(Array<fftw_complex>& a, Array<double> const & b);

      void mulEqS(Array<fftw_complex>& a, fftw_complex const & b);

      void mulEqS(Array<fftw_complex>& a, double b);
 
      // In-place division

      void divEqV(Array<fftw_complex>& a, Array<fftw_complex> const & b);

      void divEqV(Array<fftw_complex>& a, Array<double> const & b);

      void divEqS(Array<fftw_complex>& a, fftw_complex b);

      void divEqS(Array<fftw_complex>& a, double b);
 
      // Exponentiation

      void expV(Array<fftw_complex> & a, Array<fftw_complex> const & b);
 
      // Complex Square

      void sqV(Array<fftw_complex> & a, Array<fftw_complex> const & b);
 
      // Even powers of complex absolute magnitude 

      void sqAbsV(Array<double> & a, Array<fftw_complex> const & b);

      void sqSqAbsV(Array<double> & a, Array<fftw_complex> const & b);
 
      // Combined Operations

      void divEqVc(Array<fftw_complex>& a,
                   Array<double> const & b,
                   double const c);
 
   } // namespace VecOp
 
} // namespace Pscf
#endif