]> https://gitweb.dealii.org/ - dealii.git/commitdiff
Update documentation of *::Vector::add_and_dot for complex vectors.
authorWolfgang Bangerth <bangerth@colostate.edu>
Thu, 18 Jan 2018 04:03:47 +0000 (21:03 -0700)
committerWolfgang Bangerth <bangerth@colostate.edu>
Thu, 18 Jan 2018 04:03:47 +0000 (21:03 -0700)
include/deal.II/lac/block_vector_base.h
include/deal.II/lac/cuda_vector.h
include/deal.II/lac/la_parallel_block_vector.h
include/deal.II/lac/la_parallel_vector.h
include/deal.II/lac/la_vector.h
include/deal.II/lac/petsc_vector_base.h
include/deal.II/lac/trilinos_epetra_vector.h
include/deal.II/lac/trilinos_vector.h
include/deal.II/lac/vector.h
include/deal.II/lac/vector_space_vector.h

index 99a446afe6aefbe31411b0c5649007d3dc725f13..f1936311db501b49732b992f169139f9b6d527e7 100644 (file)
@@ -823,6 +823,9 @@ public:
    * means to load the calling vector @p this twice. Since most vector
    * operations are memory transfer limited, this reduces the time by 25\% (or
    * 50\% if @p W equals @p this).
+   *
+   * For complex-valued vectors, the scalar product in the second step is implemented as
+   * $\left<v,w\right>=\sum_i v_i \bar{w_i}$.
    */
   value_type add_and_dot (const value_type       a,
                           const BlockVectorBase &V,
index 95292245c00179006d0de5655a693b66e0f5887f..6370afe42bcd9eb002acfd5a74329cd921849e81 100644 (file)
@@ -214,6 +214,9 @@ namespace LinearAlgebra
        * calling separate methods means to load the calling vector @p this
        * twice. Since most vector operations are memory transfer limited, this
        * reduces the time by 25\% (or 50\% if @p W equals @p this).
+       *
+       * For complex-valued vectors, the scalar product in the second step is implemented as
+       * $\left<v,w\right>=\sum_i v_i \bar{w_i}$.
        */
       virtual Number add_and_dot(const Number                     a,
                                  const VectorSpaceVector<Number> &V,
index 2dd164b7a90a61a1692b68ffaa4482c0464b5e7c..b257286e60ccdd1aa4e2e4377df9cf9318d7730e 100644 (file)
@@ -549,6 +549,9 @@ namespace LinearAlgebra
        * separate methods means to load the calling vector @p this twice. Since
        * most vector operations are memory transfer limited, this reduces the
        * time by 25\% (or 50\% if @p W equals @p this).
+       *
+       * For complex-valued vectors, the scalar product in the second step is implemented as
+       * $\left<v,w\right>=\sum_i v_i \bar{w_i}$.
        */
       virtual Number add_and_dot(const Number a,
                                  const VectorSpaceVector<Number> &V,
index f10736a373b694d0a1b0071d606c98ce8089f05e..6bf234994f57c45a9e6556ab74a651874a388631 100644 (file)
@@ -665,6 +665,9 @@ namespace LinearAlgebra
        * separate methods means to load the calling vector @p this twice. Since
        * most vector operations are memory transfer limited, this reduces the
        * time by 25\% (or 50\% if @p W equals @p this).
+       *
+       * For complex-valued vectors, the scalar product in the second step is implemented as
+       * $\left<v,w\right>=\sum_i v_i \bar{w_i}$.
        */
       virtual Number add_and_dot(const Number a,
                                  const VectorSpaceVector<Number> &V,
@@ -1095,7 +1098,8 @@ namespace LinearAlgebra
 
       /**
        * Local part of the addition followed by an inner product of two
-       * vectors.
+       * vectors. The same applies for complex-valued vectors as for
+       * the add_and_dot() function.
        */
       Number add_and_dot_local (const Number          a,
                                 const Vector<Number> &V,
index 08c27c47e3eb83f35c64eb6fb025f523adc6b7ab..f0198e0c90c72d0d03e2101d27cdb69bc4dbc0c3 100644 (file)
@@ -262,6 +262,16 @@ namespace LinearAlgebra
      * this->add(a, V);
      * return_value = *this * W;
      * @endcode
+     *
+     * The reason this function exists is that this operation involves less
+     * memory transfer than calling the two functions separately. This method
+     * only needs to load three vectors, @p this, @p V, @p W, whereas calling
+     * separate methods means to load the calling vector @p this twice. Since
+     * most vector operations are memory transfer limited, this reduces the time
+     * by 25\% (or 50\% if @p W equals @p this).
+     *
+     * For complex-valued vectors, the scalar product in the second step is implemented as
+     * $\left<v,w\right>=\sum_i v_i \bar{w_i}$.
      */
     virtual Number add_and_dot(const Number a,
                                const VectorSpaceVector<Number> &V,
index 96209c8af2a61bf96103beb4c5fc065f30297627..9d55dac1430e5cdb4d81d7b1c181b4d5b20a536e 100644 (file)
@@ -547,6 +547,9 @@ namespace PETScWrappers
      * transfer. However, for PETSc vectors such a combined operation is not
      * natively supported and thus the cost is completely equivalent as
      * calling the two methods separately.
+     *
+     * For complex-valued vectors, the scalar product in the second step is implemented as
+     * $\left<v,w\right>=\sum_i v_i \bar{w_i}$.
      */
     PetscScalar add_and_dot (const PetscScalar a,
                              const VectorBase &V,
index 53faf8da1e0dabfd61772b1888a466613a8ea003..b381858183ba4a9682c047fd2f37a8b9cd3e91e0 100644 (file)
@@ -229,6 +229,9 @@ namespace LinearAlgebra
        * reduces the time by 25\% (or 50\% if @p W equals @p this).
        *
        * The vectors need to have the same layout.
+       *
+       * For complex-valued vectors, the scalar product in the second step is implemented as
+       * $\left<v,w\right>=\sum_i v_i \bar{w_i}$.
        */
       virtual double add_and_dot(const double a,
                                  const VectorSpaceVector<double> &V,
index 261e77833b55ef9aaaad7f36e5d455e1ffd1c0e4..384ac93138b8846e2be9e5f7ab625b8b185e0d91 100644 (file)
@@ -839,6 +839,9 @@ namespace TrilinosWrappers
        * transfer. However, for Trilinos vectors such a combined operation is
        * not natively supported and thus the cost is completely equivalent as
        * calling the two methods separately.
+       *
+       * For complex-valued vectors, the scalar product in the second step is implemented as
+       * $\left<v,w\right>=\sum_i v_i \bar{w_i}$.
        */
       TrilinosScalar add_and_dot (const TrilinosScalar a,
                                   const Vector    &V,
index 7e712c095b088cf4b5406c21c3b118cafed500e9..8d3f4d5cfa178fd8208cfc7851f8acf3a45eeb70 100644 (file)
@@ -494,13 +494,17 @@ public:
    * most vector operations are memory transfer limited, this reduces the time
    * by 25\% (or 50\% if @p W equals @p this).
    *
+   * For complex-valued vectors, the scalar product in the second step is implemented as
+   * $\left<v,w\right>=\sum_i v_i \bar{w_i}$.
+   *
    * @dealiiOperationIsMultithreaded The algorithm uses pairwise summation
    * with the same order of summation in every run, which gives fully
    * repeatable results from one run to another.
    */
-  Number add_and_dot (const Number          a,
-                      const Vector<Number> &V,
-                      const Vector<Number> &W);
+  Number
+  add_and_dot (const Number          a,
+               const Vector<Number> &V,
+               const Vector<Number> &W);
 
   //@}
 
index 337de25b0dbc36af13cc43ab2a6340bae2bf3b43..4b109b532b466c3284b2d883c1708424d624567c 100644 (file)
@@ -184,6 +184,9 @@ namespace LinearAlgebra
      * separate methods means to load the calling vector @p this twice. Since
      * most vector operations are memory transfer limited, this reduces the
      * time by 25\% (or 50\% if @p W equals @p this).
+     *
+     * For complex-valued vectors, the scalar product in the second step is implemented as
+     * $\left<v,w\right>=\sum_i v_i \bar{w_i}$.
      */
     virtual Number add_and_dot(const Number a,
                                const VectorSpaceVector<Number> &V,

In the beginning the Universe was created. This has made a lot of people very angry and has been widely regarded as a bad move.

Douglas Adams


Typeset in Trocchi and Trocchi Bold Sans Serif.