pscfpp-man/cuda_2VecOp_8h_source.html

#ifndef PSCF_CUDA_VEC_OP_H

#define PSCF_CUDA_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.

*/


#include <pscf/cuda/cudaTypes.h>

#include <pscf/cuda/DeviceArray.h>


namespace Pscf {


   namespace VecOp {


      // Assignment operations:


      void eqV(DeviceArray<cudaReal>& a,

               DeviceArray<cudaReal> const & b,

               const int beginIdA, const int beginIdB, const int n);


      inline


      void eqV(DeviceArray<cudaReal>& a,

               DeviceArray<cudaReal> const & b)

      {  eqV(a, b, 0, 0, a.capacity()); }


      void eqV(Array<cudaReal>& a,

               DeviceArray<cudaReal> const & b,

               const int beginIdA, const int beginIdB, const int n);


      inline


      void eqV(Array<cudaReal>& a,

               DeviceArray<cudaReal> const & b)

      {  eqV(a, b, 0, 0, a.capacity()); }


      void eqV(DeviceArray<cudaReal>& a,

               Array<cudaReal> const & b,

               const int beginIdA, const int beginIdB, const int n);


      inline


      void eqV(DeviceArray<cudaReal>& a,

               Array<cudaReal> const & b)

      {  eqV(a, b, 0, 0, a.capacity()); }


      void eqV(DeviceArray<cudaComplex>& a,

               DeviceArray<cudaComplex> const & b,

               const int beginIdA, const int beginIdB, const int n);


      inline


      void eqV(DeviceArray<cudaComplex>& a,

               DeviceArray<cudaComplex> const & b)

      {  eqV(a, b, 0, 0, a.capacity()); }


      void eqS(DeviceArray<cudaReal>& a,

               const cudaReal b,

               const int beginIdA, const int n);


      inline


      void eqS(DeviceArray<cudaReal>& a, const cudaReal b)

      {  eqS(a, b, 0, a.capacity()); }


      void eqS(DeviceArray<cudaComplex>& a,

               const cudaComplex b,

               const int beginIdA, const int n);


      inline


      void eqS(DeviceArray<cudaComplex>& a, const cudaComplex b)

      {  eqS(a, b, 0, a.capacity()); }


      // Addition operations


      void addVV(DeviceArray<cudaReal>& a,

                 DeviceArray<cudaReal> const & b,

                 DeviceArray<cudaReal> const & c,

                 const int beginIdA, const int beginIdB, const int beginIdC,

                 const int n);


      inline


      void addVV(DeviceArray<cudaReal>& a,

                 DeviceArray<cudaReal> const & b,

                 DeviceArray<cudaReal> const & c)

      {  addVV(a, b, c, 0, 0, 0, a.capacity()); }


      void addVV(DeviceArray<cudaComplex>& a,

                 DeviceArray<cudaComplex> const & b,

                 DeviceArray<cudaComplex> const & c,

                 const int beginIdA, const int beginIdB, const int beginIdC,

                 const int n);


      inline


      void addVV(DeviceArray<cudaComplex>& a,

                 DeviceArray<cudaComplex> const & b,

                 DeviceArray<cudaComplex> const & c)

      {  addVV(a, b, c, 0, 0, 0, a.capacity()); }


      void addVV(DeviceArray<cudaComplex> & a,

                 DeviceArray<cudaReal> const & b,

                 DeviceArray<cudaComplex> const & c,

                 const int beginIdA, const int beginIdB, const int beginIdC,

                 const int n);


      inline


      void addVV(DeviceArray<cudaComplex>& a,

                 DeviceArray<cudaReal> const & b,

                 DeviceArray<cudaComplex> const & c)

      {  addVV(a, b, c, 0, 0, 0, a.capacity()); }


      void addVV(DeviceArray<cudaComplex>& a,

                 DeviceArray<cudaComplex> const & b,

                 DeviceArray<cudaReal> const & c,

                 const int beginIdA, const int beginIdB, const int beginIdC,

                 const int n);


      inline


      void addVV(DeviceArray<cudaComplex>& a,

                 DeviceArray<cudaComplex> const & b,

                 DeviceArray<cudaReal> const & c)

      {  addVV(a, b, c, 0, 0, 0, a.capacity()); }


      void addVS(DeviceArray<cudaReal>& a,

                 DeviceArray<cudaReal> const & b,

                 const cudaReal c,

                 const int beginIdA, const int beginIdB,

                 const int n);


      inline


      void addVS(DeviceArray<cudaReal>& a,

                 DeviceArray<cudaReal> const & b,

                 const cudaReal c)

      {  addVS(a, b, c, 0, 0, a.capacity()); }


      void addVS(DeviceArray<cudaComplex>& a,

                 DeviceArray<cudaComplex> const & b,

                 const cudaComplex c,

                 const int beginIdA, const int beginIdB,

                 const int n);


      inline


      void addVS(DeviceArray<cudaComplex>& a,

                 DeviceArray<cudaComplex> const & b,

                 const cudaComplex c)

      {  addVS(a, b, c, 0, 0, a.capacity()); }


      void addVS(DeviceArray<cudaComplex>& a,

                 DeviceArray<cudaReal> const & b,

                 const cudaComplex c,

                 const int beginIdA, const int beginIdB, const int n);


      inline


      void addVS(DeviceArray<cudaComplex>& a,

                 DeviceArray<cudaReal> const & b,

                 const cudaComplex c)

      {  addVS(a, b, c, 0, 0, a.capacity()); }


      void addVS(DeviceArray<cudaComplex>& a,

                 DeviceArray<cudaComplex> const & b,

                 const cudaReal c,

                 const int beginIdA, const int beginIdB, const int n);


      inline


      void addVS(DeviceArray<cudaComplex>& a,

                 DeviceArray<cudaComplex> const & b,

                 const cudaReal c)

      {  addVS(a, b, c, 0, 0, a.capacity()); }


      // Subtraction operations


      void subVV(DeviceArray<cudaReal>& a,

                 DeviceArray<cudaReal> const & b,

                 DeviceArray<cudaReal> const & c,

            const int beginIdA, const int beginIdB, const int beginIdC,

            const int n);


      inline


      void subVV(DeviceArray<cudaReal>& a, DeviceArray<cudaReal> const & b,

                 DeviceArray<cudaReal> const & c)

      {  subVV(a, b, c, 0, 0, 0, a.capacity()); }


      void subVV(DeviceArray<cudaComplex>& a,

                 DeviceArray<cudaComplex> const & b,

                 DeviceArray<cudaComplex> const & c, const int beginIdA,

                 const int beginIdB, const int beginIdC, const int n);


      inline


      void subVV(DeviceArray<cudaComplex>& a,

                 DeviceArray<cudaComplex> const & b,

                 DeviceArray<cudaComplex> const & c)

      {  subVV(a, b, c, 0, 0, 0, a.capacity()); }


      void subVV(DeviceArray<cudaComplex>& a,

                 DeviceArray<cudaReal> const & b,

                 DeviceArray<cudaComplex> const & c,

                 const int beginIdA,

                 const int beginIdB, const int beginIdC,

                 const int n);


      inline


      void subVV(DeviceArray<cudaComplex>& a,

                 DeviceArray<cudaReal> const & b,

                 DeviceArray<cudaComplex> const & c)

      {  subVV(a, b, c, 0, 0, 0, a.capacity()); }


      void subVV(DeviceArray<cudaComplex>& a,

                 DeviceArray<cudaComplex> const & b,

                 DeviceArray<cudaReal> const & c,

                 const int beginIdA,

                 const int beginIdB, const int beginIdC, const int n);


      inline


      void subVV(DeviceArray<cudaComplex>& a,

                 DeviceArray<cudaComplex> const & b,

                 DeviceArray<cudaReal> const & c)

      {  subVV(a, b, c, 0, 0, 0, a.capacity()); }


      void subVS(DeviceArray<cudaReal>& a,

                 DeviceArray<cudaReal> const & b,

                 const cudaReal c,

                 const int beginIdA, const int beginIdB,

                 const int n);


      inline


      void subVS(DeviceArray<cudaReal>& a,

                 DeviceArray<cudaReal> const & b,

                 const cudaReal c)

      {  subVS(a, b, c, 0, 0, a.capacity()); }


      void subVS(DeviceArray<cudaComplex>& a,

                 DeviceArray<cudaComplex> const & b,

                 const cudaComplex c,

                 const int beginIdA, const int beginIdB, const int n);


      inline


      void subVS(DeviceArray<cudaComplex>& a,

                 DeviceArray<cudaComplex> const & b,

                 const cudaComplex c)

      {  subVS(a, b, c, 0, 0, a.capacity()); }


      void subVS(DeviceArray<cudaComplex>& a,

                 DeviceArray<cudaReal> const & b,

                 const cudaComplex c,

            const int beginIdA, const int beginIdB, const int n);


      inline


      void subVS(DeviceArray<cudaComplex>& a,

                 DeviceArray<cudaReal> const & b,

                 const cudaComplex c)

      {  subVS(a, b, c, 0, 0, a.capacity()); }


      void subVS(DeviceArray<cudaComplex>& a,

                 DeviceArray<cudaComplex> const & b,

                 const cudaReal c,

                 const int beginIdA, const int beginIdB, const int n);


      inline


      void subVS(DeviceArray<cudaComplex>& a,

                 DeviceArray<cudaComplex> const & b,

                 const cudaReal c)

      {  subVS(a, b, c, 0, 0, a.capacity()); }


      // Multiplication operations


      void mulVV(DeviceArray<cudaReal>& a,

                 DeviceArray<cudaReal> const & b,

                 DeviceArray<cudaReal> const & c,

            const int beginIdA, const int beginIdB, const int beginIdC,

                 const int n);


      inline


      void mulVV(DeviceArray<cudaReal>& a,

                 DeviceArray<cudaReal> const & b,

                 DeviceArray<cudaReal> const & c)

      {  mulVV(a, b, c, 0, 0, 0, a.capacity()); }


      void mulVV(DeviceArray<cudaComplex>& a,

                 DeviceArray<cudaComplex> const & b,

                 DeviceArray<cudaComplex> const & c,

                 const int beginIdA, const int beginIdB, const int beginIdC,

                 const int n);


      inline


      void mulVV(DeviceArray<cudaComplex>& a,

                 DeviceArray<cudaComplex> const & b,

                 DeviceArray<cudaComplex> const & c)

      {  mulVV(a, b, c, 0, 0, 0, a.capacity()); }


      void mulVV(DeviceArray<cudaComplex>& a,

                 DeviceArray<cudaReal> const & b,

                 DeviceArray<cudaComplex> const & c, const int beginIdA,

                 const int beginIdB, const int beginIdC, const int n);


      inline


      void mulVV(DeviceArray<cudaComplex>& a,

                 DeviceArray<cudaReal> const & b,

                 DeviceArray<cudaComplex> const & c)

      {  mulVV(a, b, c, 0, 0, 0, a.capacity()); }


      void mulVV(DeviceArray<cudaComplex>& a,

                 DeviceArray<cudaComplex> const & b,

                 DeviceArray<cudaReal> const & c,

                 const int beginIdA, const int beginIdB, const int beginIdC,

                 const int n);


      inline


      void mulVV(DeviceArray<cudaComplex>& a,

                 DeviceArray<cudaComplex> const & b,

                 DeviceArray<cudaReal> const & c)

      {  mulVV(a, b, c, 0, 0, 0, a.capacity()); }


      void mulVS(DeviceArray<cudaReal>& a,

                 DeviceArray<cudaReal> const & b,

                 const cudaReal c,

                 const int beginIdA, const int beginIdB,

                 const int n);


      inline


      void mulVS(DeviceArray<cudaReal>& a,

                 DeviceArray<cudaReal> const & b,

                 const cudaReal c)

      {  mulVS(a, b, c, 0, 0, a.capacity()); }


      void mulVS(DeviceArray<cudaComplex>& a,

                 DeviceArray<cudaComplex> const & b,

                 const cudaComplex c,

                 const int beginIdA, const int beginIdB, const int n);


      inline


      void mulVS(DeviceArray<cudaComplex>& a,

                 DeviceArray<cudaComplex> const & b,

            const cudaComplex c)

      {  mulVS(a, b, c, 0, 0, a.capacity()); }


      void mulVS(DeviceArray<cudaComplex>& a,

                 DeviceArray<cudaReal> const & b,

                 const cudaComplex c,

                 const int beginIdA, const int beginIdB, const int n);


      inline


      void mulVS(DeviceArray<cudaComplex>& a,

                 DeviceArray<cudaReal> const & b,

            const cudaComplex c)

      {  mulVS(a, b, c, 0, 0, a.capacity()); }


      void mulVS(DeviceArray<cudaComplex>& a,

                 DeviceArray<cudaComplex> const & b,

                 const cudaReal c,

                 const int beginIdA, const int beginIdB, const int n);


      inline


      void mulVS(DeviceArray<cudaComplex>& a,

                        DeviceArray<cudaComplex> const & b,

                        const cudaReal c)

      {  mulVS(a, b, c, 0, 0, a.capacity()); }


      // Division operations


      void divVV(DeviceArray<cudaReal>& a,

                 DeviceArray<cudaReal> const & b,

                 DeviceArray<cudaReal> const & c,

                 const int beginIdA, const int beginIdB, const int beginIdC,

                 const int n);


      inline


      void divVV(DeviceArray<cudaReal>& a,

                 DeviceArray<cudaReal> const & b,

                 DeviceArray<cudaReal> const & c)

      {  divVV(a, b, c, 0, 0, 0, a.capacity()); }


      void divVV(DeviceArray<cudaComplex>& a,

                 DeviceArray<cudaComplex> const & b,

                 DeviceArray<cudaReal> const & c,

                 const int beginIdA, const int beginIdB, const int beginIdC,

                 const int n);


      inline


      void divVV(DeviceArray<cudaComplex>& a,

                 DeviceArray<cudaComplex> const & b,

                 DeviceArray<cudaReal> const & c)

      {  divVV(a, b, c, 0, 0, 0, a.capacity()); }


      void divVS(DeviceArray<cudaReal>& a,

                 DeviceArray<cudaReal> const & b,

                 const cudaReal c, const int beginIdA,

                 const int beginIdB, const int n);


      inline


      void divVS(DeviceArray<cudaReal>& a,

                 DeviceArray<cudaReal> const & b,

                 const cudaReal c)

      {  divVS(a, b, c, 0, 0, a.capacity()); }


      void divVS(DeviceArray<cudaComplex>& a,

                 DeviceArray<cudaComplex> const & b,

                 const cudaReal c,

                 const int beginIdA, const int beginIdB, const int n);


      inline


      void divVS(DeviceArray<cudaComplex>& a,

                 DeviceArray<cudaComplex> const & b,

                 const cudaReal c)

      {  divVS(a, b, c, 0, 0, a.capacity()); }


      void divSV(DeviceArray<cudaReal>& a,

                 const cudaReal b,

                 DeviceArray<cudaReal> const & c,

                 const int beginIdA, const int beginIdC, const int n);


      inline


      void divSV(DeviceArray<cudaReal>& a,

                 const cudaReal b,

                 DeviceArray<cudaReal> const & c)

      {  divSV(a, b, c, 0, 0, a.capacity()); }


      // In-place addition


      void addEqV(DeviceArray<cudaReal>& a,

                  DeviceArray<cudaReal> const & b,

                  const int beginIdA, const int beginIdB, const int n);


      inline


      void addEqV(DeviceArray<cudaReal>& a,

                  DeviceArray<cudaReal> const & b)

      {  addEqV(a, b, 0, 0, a.capacity()); }


      void addEqV(DeviceArray<cudaComplex>& a,

                  DeviceArray<cudaComplex> const & b,

                  const int beginIdA, const int beginIdB, const int n);


      inline


      void addEqV(DeviceArray<cudaComplex>& a,

                  DeviceArray<cudaComplex> const & b)

      {  addEqV(a, b, 0, 0, a.capacity()); }


      void addEqV(DeviceArray<cudaComplex>& a,

                  DeviceArray<cudaReal> const & b,

                  const int beginIdA, const int beginIdB, const int n);


      inline


      void addEqV(DeviceArray<cudaComplex>& a,

                  DeviceArray<cudaReal> const & b)

      {  addEqV(a, b, 0, 0, a.capacity()); }


      void addEqS(DeviceArray<cudaReal>& a,

                  const cudaReal b,

                  const int beginIdA, const int n);


      inline


      void addEqS(DeviceArray<cudaReal>& a, const cudaReal b)

      {  addEqS(a, b, 0, a.capacity()); }


      void addEqS(DeviceArray<cudaComplex>& a,

                  const cudaComplex b,

                  const int beginIdA, const int n);


      inline


      void addEqS(DeviceArray<cudaComplex>& a, const cudaComplex b)

      {  addEqS(a, b, 0, a.capacity()); }


      void addEqS(DeviceArray<cudaComplex>& a,

                  const cudaReal b,

                  const int beginIdA, const int n);


      inline


      void addEqS(DeviceArray<cudaComplex>& a, const cudaReal b)

      {  addEqS(a, b, 0, a.capacity()); }


      // In-place subtraction


      void subEqV(DeviceArray<cudaReal>& a,

                  DeviceArray<cudaReal> const & b,

                  const int beginIdA, const int beginIdB, const int n);


      inline


      void subEqV(DeviceArray<cudaReal>& a,

                  DeviceArray<cudaReal> const & b)

      {  subEqV(a, b, 0, 0, a.capacity()); }


      void subEqV(DeviceArray<cudaComplex>& a,

                  DeviceArray<cudaComplex> const & b,

                  const int beginIdA, const int beginIdB, const int n);


      inline


      void subEqV(DeviceArray<cudaComplex>& a,

                         DeviceArray<cudaComplex> const & b)

      {  subEqV(a, b, 0, 0, a.capacity()); }


      void subEqV(DeviceArray<cudaComplex>& a,

                  DeviceArray<cudaReal> const & b,

                  const int beginIdA, const int beginIdB, const int n);


      inline


      void subEqV(DeviceArray<cudaComplex>& a,

                  DeviceArray<cudaReal> const & b)

      {  subEqV(a, b, 0, 0, a.capacity()); }


      void subEqS(DeviceArray<cudaReal>& a, const cudaReal b,

                  const int beginIdA, const int n);


      inline


      void subEqS(DeviceArray<cudaReal>& a, const cudaReal b)

      {  subEqS(a, b, 0, a.capacity()); }


      void subEqS(DeviceArray<cudaComplex>& a, const cudaComplex b,

                  const int beginIdA, const int n);


      inline


      void subEqS(DeviceArray<cudaComplex>& a, const cudaComplex b)

      {  subEqS(a, b, 0, a.capacity()); }


      void subEqS(DeviceArray<cudaComplex>& a,

                  const cudaReal b,

                  const int beginIdA, const int n);


      inline


      void subEqS(DeviceArray<cudaComplex>& a, const cudaReal b)

      {  subEqS(a, b, 0, a.capacity()); }


      // In-place multiplication


      void mulEqV(DeviceArray<cudaReal>& a,

                  DeviceArray<cudaReal> const & b,

                  const int beginIdA, const int beginIdB, const int n);


      inline


      void mulEqV(DeviceArray<cudaReal>& a,

                  DeviceArray<cudaReal> const & b)

      {  mulEqV(a, b, 0, 0, a.capacity()); }


      void mulEqV(DeviceArray<cudaComplex>& a,

                  DeviceArray<cudaComplex> const & b,

                  const int beginIdA, const int beginIdB, const int n);


      inline


      void mulEqV(DeviceArray<cudaComplex>& a,

                  DeviceArray<cudaComplex> const & b)

      {  mulEqV(a, b, 0, 0, a.capacity()); }


      void mulEqV(DeviceArray<cudaComplex>& a,

                  DeviceArray<cudaReal> const & b,

                  const int beginIdA, const int beginIdB, const int n);


      inline


      void mulEqV(DeviceArray<cudaComplex>& a,

                  DeviceArray<cudaReal> const & b)

      {  mulEqV(a, b, 0, 0, a.capacity()); }


      void mulEqS(DeviceArray<cudaReal>& a, const cudaReal b,

                  const int beginIdA, const int n);


      inline


      void mulEqS(DeviceArray<cudaReal>& a, const cudaReal b)

      {  mulEqS(a, b, 0, a.capacity()); }


      void mulEqS(DeviceArray<cudaComplex>& a, const cudaComplex b,

                  const int beginIdA, const int n);


      inline


      void mulEqS(DeviceArray<cudaComplex>& a, const cudaComplex b)

      {  mulEqS(a, b, 0, a.capacity()); }


      void mulEqS(DeviceArray<cudaComplex>& a,

                  const cudaReal b,

                  const int beginIdA, const int n);


      inline


      void mulEqS(DeviceArray<cudaComplex>& a, const cudaReal b)

      {  mulEqS(a, b, 0, a.capacity()); }


      // In-place division


      void divEqV(DeviceArray<cudaReal>& a,

                  DeviceArray<cudaReal> const & b,

                  const int beginIdA, const int beginIdB, const int n);


      inline


      void divEqV(DeviceArray<cudaReal>& a,

                  DeviceArray<cudaReal> const & b)

      {  divEqV(a, b, 0, 0, a.capacity()); }


      void divEqV(DeviceArray<cudaComplex>& a,

                  DeviceArray<cudaReal> const & b,

                  const int beginIdA, const int beginIdB, const int n);


      inline


      void divEqV(DeviceArray<cudaComplex>& a,

                  DeviceArray<cudaReal> const & b)

      {  divEqV(a, b, 0, 0, a.capacity()); }


      void divEqS(DeviceArray<cudaReal>& a,

                  const cudaReal b,

                  const int beginIdA, const int n);


      inline


      void divEqS(DeviceArray<cudaReal>& a, const cudaReal b)

      {  divEqS(a, b, 0, a.capacity()); }


      void divEqS(DeviceArray<cudaComplex>& a,

                  const cudaReal b,

                  const int beginIdA, const int n);


      inline


      void divEqS(DeviceArray<cudaComplex>& a, const cudaReal b)

      {  divEqS(a, b, 0, a.capacity()); }


      // Exponentiation operations


      void expV(DeviceArray<cudaReal>& a,

                DeviceArray<cudaReal> const & b,

                const int beginIdA, const int beginIdB,

                const int n);


      inline


      void expV(DeviceArray<cudaReal>& a,

                DeviceArray<cudaReal> const & b)

      {  expV(a, b, 0, 0, a.capacity()); }


      void expV(DeviceArray<cudaComplex>& a,

                DeviceArray<cudaComplex> const & b,

                const int beginIdA, const int beginIdB,

                const int n);


      inline


      void expV(DeviceArray<cudaComplex>& a,

                DeviceArray<cudaComplex> const & b)

      {  expV(a, b, 0, 0, a.capacity()); }


      // Vector (element-wise) square


      void sqV(DeviceArray<cudaReal>& a,

               DeviceArray<cudaReal> const & b,

               const int beginIdA, const int beginIdB,

               const int n);


      inline


      void sqV(DeviceArray<cudaReal>& a,

               DeviceArray<cudaReal> const & b)

      {  sqV(a, b, 0, 0, a.capacity()); }


      void sqV(DeviceArray<cudaComplex>& a,

               DeviceArray<cudaComplex> const & b,

               const int beginIdA, const int beginIdB,

               const int n);


      inline


      void sqV(DeviceArray<cudaComplex>& a,

               DeviceArray<cudaComplex> const & b)

      {  sqV(a, b, 0, 0, a.capacity()); }


      // Absolute magnitude


      void absV(DeviceArray<cudaReal>& a,

                DeviceArray<cudaReal> const & b,

                const int beginIdA, const int beginIdB,

                const int n);


      inline


      void absV(DeviceArray<cudaReal>& a,

                DeviceArray<cudaReal> const & b)

      {  absV(a, b, 0, 0, a.capacity()); }


      void sqAbsV(DeviceArray<cudaReal>& a,

                  DeviceArray<cudaComplex> const & b,

                  const int beginIdA, const int beginIdB,

                  const int n);


      inline


      void sqAbsV(DeviceArray<cudaReal>& a,

                  DeviceArray<cudaComplex> const & b)

      {  sqAbsV(a, b, 0, 0, a.capacity()); }


   } // namespace VecOp

} // namespace Pscf


// Ensure that if VecOp.h is included, so is VecOpMisc.h

#include "VecOpMisc.h"

#endif

Pscf::DeviceArray
Dynamic array on the GPU device with aligned data.
Definition DeviceArray.h:96

Pscf::DeviceArray::capacity
int capacity() const
Return array capacity.
Definition DeviceArray.h:308

Util::Array
Array container class template.
Definition Array.h:40

Util::Array::capacity
int capacity() const
Return allocated size.
Definition Array.h:144

Pscf::VecOp::divEqS
void divEqS(Array< double > &a, double b)
Vector-scalar in-place division, a[i] /= b.
Definition VecOp.cpp:292

Pscf::VecOp::addEqV
void addEqV(Array< double > &a, Array< double > const &b)
Vector-vector in-place addition, a[i] += b[i] (real).
Definition VecOp.cpp:198

Pscf::VecOp::divEqV
void divEqV(Array< double > &a, Array< double > const &b)
Vector-vector in-place division, a[i] /= b[i].
Definition VecOp.cpp:279

Pscf::VecOp::addEqS
void addEqS(Array< double > &a, double b)
Vector-scalar in-place addition, a[i] += b (real).
Definition VecOp.cpp:211

Pscf::VecOp::sqV
void sqV(Array< double > &a, Array< double > const &b)
Vector element-wise square, a[i] = b[i]*b[i] (real).
Definition VecOp.cpp:334

Pscf::VecOp::mulEqV
void mulEqV(Array< double > &a, Array< double > const &b)
Vector-vector in-place multiplication, a[i] *= b[i] (real).
Definition VecOp.cpp:252

Pscf::VecOp::eqV
void eqV(Array< double > &a, Array< double > const &b, const int beginIdA, const int beginIdB, const int n)
Vector assignment, a[i] = b[i] (real, slice).
Definition VecOp.cpp:21

Pscf::VecOp::sqAbsV
void sqAbsV(Array< double > &a, Array< fftw_complex > const &b)
Square of absolute magnitude, a[i] = |b[i]|^2 (complex).
Definition VecOpCx.cpp:698

Pscf::VecOp::mulEqS
void mulEqS(Array< double > &a, double b)
Vector-scalar in-place multiplication, a[i] *= b (real).
Definition VecOp.cpp:265

Pscf::VecOp::subVV
void subVV(Array< double > &a, Array< double > const &b, Array< double > const &c)
Vector-vector subtraction, a[i] = b[i] - c[i] (real)
Definition VecOp.cpp:95

Pscf::VecOp::absV
void absV(Array< double > &a, Array< double > const &b)
Element-wise absolute magnitude, a[i] = abs(b[i]) (real).
Definition VecOp.cpp:349

Pscf::VecOp::expV
void expV(Array< double > &a, Array< double > const &b)
Vector exponentiation, a[i] = exp(b[i]) (real).
Definition VecOp.cpp:306

Pscf::VecOp::divVS
void divVS(Array< double > &a, Array< double > const &b, double c)
Vector-scalar division, a[i] = b[i] / c (real).
Definition VecOp.cpp:170

Pscf::VecOp::eqS
void eqS(Array< double > &a, double b)
Vector assignment, a[i] = b (real).
Definition VecOp.cpp:50

Pscf::VecOp::mulVV
void mulVV(Array< double > &a, Array< double > const &b, Array< double > const &c)
Vector-vector multiplication, a[i] = b[i] * c[i] (real).
Definition VecOp.cpp:125

Pscf::VecOp::subVS
void subVS(Array< double > &a, Array< double > const &b, double c)
Vector-scalar subtraction, a[i] = b[i] - c (real).
Definition VecOp.cpp:110

Pscf::VecOp::subEqV
void subEqV(Array< double > &a, Array< double > const &b)
Vector-vector in-place subtraction, a[i] -= b[i] (real).
Definition VecOp.cpp:225

Pscf::VecOp::addVV
void addVV(Array< double > &a, Array< double > const &b, Array< double > const &c)
Vector-vector addition, a[i] = b[i] + c[i] (real)
Definition VecOp.cpp:64

Pscf::VecOp::divSV
void divSV(Array< double > &a, double b, Array< double > const &c)
Vector division, a[i] = b / c[i].
Definition VecOp.cpp:183

Pscf::VecOp::addVS
void addVS(Array< double > &a, Array< double > const &b, double c)
Vector-scalar addition, a[i] = b[i] + c (real).
Definition VecOp.cpp:79

Pscf::VecOp::divVV
void divVV(Array< double > &a, Array< double > const &b, Array< double > const &c)
Vector-vector division, a[i] = b[i] / c[i] (real).
Definition VecOp.cpp:155

Pscf::VecOp::subEqS
void subEqS(Array< double > &a, double b)
Vector-scalar subtraction in-place, a[i] -= b (real).
Definition VecOp.cpp:238

Pscf::VecOp::mulVS
void mulVS(Array< double > &a, Array< double > const &b, double c)
Vector-scalar multiplication, a[i] = b[i] * c (real).
Definition VecOp.cpp:140

Pscf::VecOp
Vector operations on GPU or CPU.
Definition VecOp.cpp:14

Pscf
PSCF package top-level namespace.
Definition param_domain.dox:1

Pscf::cudaComplex
cufftDoubleComplex cudaComplex
Complex number type used in CPU code that uses FFTW.
Definition cudaTypes.h:22

Pscf::cudaReal
cufftDoubleReal cudaReal
Real number type used in CPU code that uses FFTW.
Definition cudaTypes.h:35