cpu/VecOp.h

#ifndef PSCF_CPU_VEC_OP_H
#define PSCF_CPU_VEC_OP_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.
*/
 
// Forward declaration
namespace Util {
   template <typename T> class Array;
}
 
namespace Pscf {
 
   using namespace Util;

   namespace VecOp {
 
      /*
      * This file and VecOp.cpp only contain declarations and definitions
      * for operations that involve only real arrays and scalars.
      * Corresponding declarations and definitions for vector operations
      * that involve complex-valued arrays and/or scalars are given in
      * the files VecOpCx.h and VecOpCx.cpp, respectively.
      */
 
      // Assignment

      void eqV(Array<double>& a, Array<double> const & b,
               const int beginIdA, const int beginIdB, const int n);

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

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

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

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

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

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

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

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

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

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

      void divSV(Array<double>& a, double b, Array<double> const & c);
 
      // In-place addition

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

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

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

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

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

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

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

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

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

      void expVc(Array<double>& a,
                 Array<double> const & b, const double c);
 
      // Square

      void sqV(Array<double>& a, Array<double> const & b);
 
      // Absolute magnitude

      void absV(Array<double>& a, Array<double> const & b);
 
      // Addition of scaled vectors (linear combinations)

      void addVcVc(Array<double>& a,
                   Array<double> const & b1, const double c1,
                   Array<double> const & b2, const double c2);

      void addVcS(Array<double>& a,
                  Array<double> const & b, const double c,
                  const double s);

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

      void addVcVcS(Array<double>& a,
                   Array<double> const & b1, const double c1,
                   Array<double> const & b2, const double c2,
                   const double s);

      void addVcVcVc(Array<double>& a,
                     Array<double> const & b1, const double c1,
                     Array<double> const & b2, const double c2,
                     Array<double> const & b3, const double c3);
 
      // Pair operations (two output arrays and a shared input)

      void eqVPair(Array<double>& a1,
                   Array<double>& a2,
                   Array<double> const & b);

      void mulVVPair(Array<double>& a1, Array<double>& a2,
                     Array<double> const & b1,
                     Array<double> const & b2,
                     Array<double> const & c);

      void mulEqVPair(Array<double>& a1,
                      Array<double>& a2,
                      Array<double> const & b);
 
   } // namespace VecOp
 
} // namespace Pscf
#endif