include/deal.II/lac/parallel_vector.h

00001 //---------------------------------------------------------------------------
00002 //    @f$Id: parallel_vector.h 25492 2012-05-05 15:11:20Z kormann @f$
00003 //    Version: @f$Name@f$
00004 //
00005 //    Copyright (C) 2011, 2012 by deal.II authors
00006 //
00007 //    This file is subject to QPL and may not be  distributed
00008 //    without copyright and license information. Please refer
00009 //    to the file deal.II/doc/license.html for the  text  and
00010 //    further information on this license.
00011 //
00012 //---------------------------------------------------------------------------
00013 #ifndef __deal2__parallel_vector_h
00014 #define __deal2__parallel_vector_h
00015 
00016 #include <deal.II/base/config.h>
00017 #include <deal.II/base/index_set.h>
00018 #include <deal.II/base/mpi.h>
00019 #include <deal.II/base/template_constraints.h>
00020 #include <deal.II/base/types.h>
00021 #include <deal.II/base/utilities.h>
00022 #include <deal.II/base/memory_consumption.h>
00023 #include <deal.II/base/partitioner.h>
00024 #include <deal.II/base/thread_management.h>
00025 #include <deal.II/lac/vector_view.h>
00026 
00027 #include <cstring>
00028 
00029 
00030 DEAL_II_NAMESPACE_OPEN
00031 
00032 namespace parallel
00033 {
00034   namespace distributed
00035   {
00036 
00083     template <typename Number>
00084     class Vector : public Subscriptor
00085     {
00086       public:
00093         typedef Number                                            value_type;
00094         typedef value_type                                       *pointer;
00095         typedef const value_type                                 *const_pointer;
00096         typedef value_type                                       *iterator;
00097         typedef const value_type                                 *const_iterator;
00098         typedef value_type                                       &reference;
00099         typedef const value_type                                 &const_reference;
00100         typedef size_t                                            size_type;
00101         typedef typename numbers::NumberTraits<Number>::real_type real_type;
00102 
00110         Vector ();
00111 
00116         Vector (const Vector<Number> &in_vector);
00117 
00123         Vector (const unsigned int size);
00124 
00144         Vector (const IndexSet &local_range,
00145                 const IndexSet &ghost_indices,
00146                 const MPI_Comm  communicator);
00147 
00156         Vector (const std_cxx1x::shared_ptr<const Utilities::MPI::Partitioner> &partitioner);
00157 
00161         ~Vector ();
00162 
00168         void reinit (const unsigned int size,
00169                      const bool         fast = false);
00170 
00184         template <typename Number2>
00185         void reinit(const Vector<Number2> &in_vector,
00186                     const bool             fast = false);
00187 
00207         void reinit (const IndexSet &local_range,
00208                      const IndexSet &ghost_indices,
00209                      const MPI_Comm  communicator);
00210 
00219         void reinit (const std_cxx1x::shared_ptr<const Utilities::MPI::Partitioner> &partitioner);
00220 
00249         void swap (Vector<Number> &v);
00250 
00256         Vector<Number> &
00257         operator = (const Vector<Number>  &in_vector);
00258 
00264         template <typename Number2>
00265         Vector<Number> &
00266         operator = (const Vector<Number2> &in_vector);
00267 
00274         void copy_from (const Vector<Number> &in_vector,
00275                         const bool            call_update_ghost_values = false);
00276 
00283         Vector<Number>& operator = (const Number s);
00284 
00306         void compress (const bool add_ghost_data = true);
00307 
00319         void update_ghost_values () const;
00320 
00341         void compress_start (const unsigned int communication_channel = 0);
00342 
00357         void compress_finish (const bool add_ghost_data = true);
00358 
00359 
00380         void update_ghost_values_start (const unsigned int communication_channel = 0) const;
00381 
00382 
00392         void update_ghost_values_finish () const;
00393 
00399         void zero_out_ghosts ();
00400 
00409         bool all_zero () const;
00410 
00425         bool is_non_negative () const;
00426 
00430         template <typename Number2>
00431         bool operator == (const Vector<Number2> &v) const;
00432 
00436         template <typename Number2>
00437         bool operator != (const Vector<Number2> &v) const;
00438 
00442         template <typename Number2>
00443         Number operator * (const Vector<Number2> &V) const;
00444 
00451         real_type norm_sqr () const;
00452 
00457         Number mean_value () const;
00458 
00465         real_type l1_norm () const;
00466 
00473         real_type l2_norm () const;
00474 
00481         real_type lp_norm (const real_type p) const;
00482 
00488         real_type linfty_norm () const;
00489 
00495         types::global_dof_index size () const;
00496 
00501         unsigned int local_size() const;
00502 
00510         std::pair<types::global_dof_index, types::global_dof_index> local_range () const;
00511 
00516         bool in_local_range (const types::global_dof_index global_index) const;
00517 
00522         unsigned int n_ghost_entries () const;
00523 
00531         bool is_ghost_entry (const types::global_dof_index global_index) const;
00532 
00540         iterator begin ();
00541 
00546         const_iterator begin () const;
00547 
00553         iterator end ();
00554 
00560         const_iterator end () const;
00562 
00563 
00568 
00577         Number operator () (const types::global_dof_index global_index) const;
00578 
00587         Number& operator () (const types::global_dof_index global_index);
00588 
00600         Number operator [] (const types::global_dof_index global_index) const;
00601 
00613         Number& operator [] (const types::global_dof_index global_index);
00614 
00624         Number local_element (const unsigned int local_index) const;
00625 
00634         Number& local_element (const unsigned int local_index);
00636 
00637 
00642 
00647         Vector<Number> & operator += (const Vector<Number> &V);
00648 
00653         Vector<Number> & operator -= (const Vector<Number> &V);
00654 
00663         template <typename OtherNumber>
00664         void add (const std::vector<unsigned int> &indices,
00665                   const std::vector<OtherNumber>  &values);
00666 
00674         template <typename OtherNumber>
00675         void add (const std::vector<unsigned int>     &indices,
00676                   const ::Vector<OtherNumber> &values);
00677 
00687         template <typename OtherNumber>
00688         void add (const unsigned int  n_elements,
00689                   const unsigned int *indices,
00690                   const OtherNumber  *values);
00691 
00697         void add (const Number s);
00698 
00703         void add (const Vector<Number> &V);
00704 
00709         void add (const Number a, const Vector<Number> &V);
00710 
00715         void add (const Number a, const Vector<Number> &V,
00716                   const Number b, const Vector<Number> &W);
00717 
00723         void sadd (const Number          s,
00724                    const Vector<Number> &V);
00725 
00730         void sadd (const Number          s,
00731                    const Number          a,
00732                    const Vector<Number> &V);
00733 
00737         void sadd (const Number          s,
00738                    const Number          a,
00739                    const Vector<Number> &V,
00740                    const Number          b,
00741                    const Vector<Number> &W);
00742 
00747         void sadd (const Number          s,
00748                    const Number          a,
00749                    const Vector<Number> &V,
00750                    const Number          b,
00751                    const Vector<Number> &W,
00752                    const Number          c,
00753                    const Vector<Number> &X);
00754 
00765         void scale (const Number factor);
00766 
00767 
00773         Vector<Number> & operator *= (const Number factor);
00774 
00780         Vector<Number> & operator /= (const Number factor);
00781 
00791         void scale (const Vector<Number> &scaling_factors);
00792 
00802         template <typename Number2>
00803         void scale (const Vector<Number2> &scaling_factors);
00804 
00808         void equ (const Number a, const Vector<Number>& u);
00809 
00813         template <typename Number2>
00814         void equ (const Number a, const Vector<Number2>& u);
00815 
00819         void equ (const Number a, const Vector<Number>& u,
00820                   const Number b, const Vector<Number>& v);
00821 
00825         void equ (const Number a, const Vector<Number>& u,
00826                   const Number b, const Vector<Number>& v,
00827                   const Number c, const Vector<Number>& w);
00828 
00845         void ratio (const Vector<Number> &a,
00846                     const Vector<Number> &b);
00848 
00849 
00871         bool
00872         partitioners_are_compatible (const Utilities::MPI::Partitioner &part) const;
00873 
00874 
00879         void print (std::ostream       &out,
00880                     const unsigned int  precision  = 3,
00881                     const bool          scientific = true,
00882                     const bool          across     = true) const;
00883 
00888         std::size_t memory_consumption () const;
00890 
00891       private:
00898         std_cxx1x::shared_ptr<const Utilities::MPI::Partitioner> partitioner;
00899 
00904         unsigned int    allocated_size;
00905 
00910         Number         *val;
00911 
00918         mutable Number *import_data;
00919 
00925         VectorView<Number> vector_view;
00926 
00927 #ifdef DEAL_II_COMPILER_SUPPORTS_MPI
00928 
00940         std::vector<MPI_Request>   compress_requests;
00941 
00947         mutable std::vector<MPI_Request>   update_ghost_values_requests;
00948 #endif
00949 
00958         mutable Threads::ThreadMutex mutex;
00959 
00965         void clear_mpi_requests ();
00966 
00971         void resize_val (const unsigned int new_allocated_size);
00972 
00973                                          /*
00974                                           * Make all other vector types
00975                                           * friends.
00976                                           */
00977         template <typename Number2> friend class Vector;
00978     };
00979 
00983 /*----------------------- Inline functions ----------------------------------*/
00984 
00985 #ifndef DOXYGEN
00986 
00987     template <typename Number>
00988     inline
00989     Vector<Number>::Vector ()
00990                     :
00991                     partitioner (new Utilities::MPI::Partitioner()),
00992                     allocated_size (0),
00993                     val (0),
00994                     import_data (0),
00995                     vector_view (0, static_cast<Number*>(0))
00996     {}
00997 
00998 
00999 
01000     template <typename Number>
01001     inline
01002     Vector<Number>::Vector (const Vector<Number> &v)
01003                     :
01004                     Subscriptor(),
01005                     allocated_size (0),
01006                     val (0),
01007                     import_data (0),
01008                     vector_view (0, static_cast<Number*>(0))
01009     {
01010       reinit (v, true);
01011       vector_view = v.vector_view;
01012     }
01013 
01014 
01015 
01016     template <typename Number>
01017     inline
01018     Vector<Number>::Vector (const IndexSet &local_range,
01019                             const IndexSet &ghost_indices,
01020                             const MPI_Comm  communicator)
01021                     :
01022                     allocated_size (0),
01023                     val (0),
01024                     import_data (0),
01025                     vector_view (0, static_cast<Number*>(0))
01026     {
01027       reinit (local_range, ghost_indices, communicator);
01028     }
01029 
01030 
01031 
01032     template <typename Number>
01033     inline
01034     Vector<Number>::Vector (const unsigned int size)
01035                     :
01036                     allocated_size (0),
01037                     val (0),
01038                     import_data (0),
01039                     vector_view (0, static_cast<Number*>(0))
01040     {
01041       reinit (size, false);
01042     }
01043 
01044 
01045 
01046     template <typename Number>
01047     inline
01048     Vector<Number>::
01049     Vector (const std_cxx1x::shared_ptr<const Utilities::MPI::Partitioner> &partitioner)
01050                     :
01051                     allocated_size (0),
01052                     val (0),
01053                     import_data (0),
01054                     vector_view (0, static_cast<Number*>(0))
01055     {
01056       reinit (partitioner);
01057     }
01058 
01059 
01060 
01061     template <typename Number>
01062     inline
01063     Vector<Number>::~Vector ()
01064     {
01065       if (val != 0)
01066         delete[] val;
01067       val = 0;
01068 
01069       if (import_data != 0)
01070         delete[] import_data;
01071       import_data = 0;
01072 
01073       clear_mpi_requests();
01074     }
01075 
01076 
01077 
01078     template <typename Number>
01079     inline
01080     Vector<Number>&
01081     Vector<Number>::operator = (const Vector<Number>& c)
01082     {
01083       Assert (c.partitioner.get() != 0, ExcNotInitialized());
01084 
01085                                        // check whether the two vectors use the same
01086                                        // parallel partitioner. if not, check if all
01087                                        // local ranges are the same (that way, we can
01088                                        // exchange data between different parallel
01089                                        // layouts)
01090       if (partitioner.get() == 0)
01091         reinit (c, true);
01092       else if (partitioner.get() != c.partitioner.get())
01093         {
01094           unsigned int local_ranges_different_loc = (local_range() !=
01095                                                      c.local_range());
01096           if(Utilities::MPI::max(local_ranges_different_loc,
01097                                  partitioner->get_communicator()) != 0)
01098             reinit (c, true);
01099         }
01100       vector_view = c.vector_view;
01101       return *this;
01102     }
01103 
01104 
01105 
01106     template <typename Number>
01107     template <typename Number2>
01108     inline
01109     Vector<Number>&
01110     Vector<Number>::operator = (const Vector<Number2> &c)
01111     {
01112       Assert (c.partitioner.get() != 0, ExcNotInitialized());
01113 
01114                                        // check whether the two vectors use the same
01115                                        // parallel partitioner. if not, check if all
01116                                        // local ranges are the same (that way, we can
01117                                        // exchange data between different parallel
01118                                        // layouts)
01119       if (partitioner.get() == 0)
01120         reinit (c, true);
01121       else if (partitioner.get() != c.partitioner.get())
01122         {
01123           unsigned int local_ranges_different_loc = (local_range() !=
01124                                                      c.local_range());
01125           if(Utilities::MPI::max(local_ranges_different_loc,
01126                                  partitioner->get_communicator()) != 0)
01127             reinit (c, true);
01128         }
01129       vector_view.reinit (partitioner->local_size(), val);
01130       if (partitioner->local_size() > 0)
01131         vector_view.equ (1., c.vector_view);
01132       return *this;
01133     }
01134 
01135 
01136 
01137     template <typename Number>
01138     inline
01139     void
01140     Vector<Number>::compress (const bool add_ghost_data)
01141     {
01142       compress_start ();
01143       compress_finish (add_ghost_data);
01144     }
01145 
01146 
01147 
01148     template <typename Number>
01149     inline
01150     void
01151     Vector<Number>::update_ghost_values () const
01152     {
01153       update_ghost_values_start ();
01154       update_ghost_values_finish ();
01155     }
01156 
01157 
01158 
01159     template <typename Number>
01160     inline
01161     void
01162     Vector<Number>::zero_out_ghosts ()
01163     {
01164       std::fill_n (&val[partitioner->local_size()],
01165                    partitioner->n_ghost_indices(),
01166                    Number());
01167     }
01168 
01169 
01170 
01171     template <typename Number>
01172     inline
01173     bool
01174     Vector<Number>::all_zero () const
01175     {
01176                                        // use int instead of bool
01177       int local_result = (partitioner->local_size()>0 ?
01178                           -vector_view.all_zero () : -1);
01179       return - Utilities::MPI::max(local_result,partitioner->get_communicator());
01180     }
01181 
01182 
01183 
01184     template <typename Number>
01185     inline
01186     bool
01187     Vector<Number>::is_non_negative () const
01188     {
01189                                        // use int instead of bool
01190       int local_result = (partitioner->local_size()>0 ?
01191                           -vector_view.is_non_negative () : -1);
01192       return  - Utilities::MPI::max(local_result,partitioner->get_communicator());
01193     }
01194 
01195 
01196 
01197     template <typename Number>
01198     template <typename Number2>
01199     inline
01200     bool
01201     Vector<Number>::operator == (const Vector<Number2> &v) const
01202     {
01203       AssertDimension (local_size(), v.local_size());
01204 
01205                                        // MPI does not support bools, so use unsigned
01206                                        // int instead. Two vectors are equal if the
01207                                        // check for non-equal fails on all processors
01208       unsigned int local_result = (partitioner->local_size()>0 ?
01209                                    vector_view.template operator !=
01210                                    <Number2>(v.vector_view)
01211                                    : 0 );
01212       unsigned int result = Utilities::MPI::max(local_result,
01213                                                 partitioner->get_communicator());
01214       return result==0;
01215     }
01216 
01217 
01218 
01219     template <typename Number>
01220     template <typename Number2>
01221     inline
01222     bool
01223     Vector<Number>::operator != (const Vector<Number2> &v) const
01224     {
01225       return !(operator == (v));
01226     }
01227 
01228 
01229 
01230     template <typename Number>
01231     template <typename Number2>
01232     inline
01233     Number
01234     Vector<Number>::operator * (const Vector<Number2> &V) const
01235     {
01236       Number local_result = (partitioner->local_size()>0 ?
01237                              vector_view.operator* (V.vector_view)
01238                              : 0);
01239       return Utilities::MPI::sum (local_result, partitioner->get_communicator());
01240     }
01241 
01242 
01243 
01244     template <typename Number>
01245     inline
01246     typename Vector<Number>::real_type
01247     Vector<Number>::norm_sqr () const
01248     {
01249                                        // on some processors, the size might be zero,
01250                                        // which is not allowed by the base
01251                                        // class. Therefore, insert a check here
01252       Number local_result = (partitioner->local_size()>0 ?
01253                              vector_view.norm_sqr()
01254                              : 0);
01255       return Utilities::MPI::sum(local_result,partitioner->get_communicator());
01256     }
01257 
01258 
01259 
01260     template <typename Number>
01261     inline
01262     Number
01263     Vector<Number>::mean_value () const
01264     {
01265       Number local_result =
01266         (partitioner->local_size()>0 ?
01267          vector_view.mean_value()
01268          : 0)
01269         *((real_type)partitioner->local_size()/(real_type)partitioner->size());
01270       return Utilities::MPI::sum (local_result, partitioner->get_communicator());
01271     }
01272 
01273 
01274 
01275     template <typename Number>
01276     inline
01277     typename Vector<Number>::real_type
01278     Vector<Number>::l1_norm () const
01279     {
01280       Number local_result = (partitioner->local_size()>0 ?
01281                              vector_view.l1_norm()
01282                              : 0);
01283       return Utilities::MPI::sum(local_result, partitioner->get_communicator());
01284     }
01285 
01286 
01287 
01288     template <typename Number>
01289     inline
01290     typename Vector<Number>::real_type
01291     Vector<Number>::l2_norm () const
01292     {
01293       return std::sqrt(norm_sqr());
01294     }
01295 
01296 
01297 
01298     template <typename Number>
01299     inline
01300     typename Vector<Number>::real_type
01301     Vector<Number>::lp_norm (const real_type p) const
01302     {
01303       const Number local_result = (partitioner->local_size()>0 ?
01304                                    std::pow(vector_view.lp_norm(p),p)
01305                                    : 0);
01306       return std::pow (Utilities::MPI::sum(local_result,
01307                                            partitioner->get_communicator()),
01308                        static_cast<Number>(1.0/p));
01309     }
01310 
01311 
01312 
01313     template <typename Number>
01314     inline
01315     typename Vector<Number>::real_type
01316     Vector<Number>::linfty_norm () const
01317     {
01318       const Number local_result = (partitioner->local_size()>0 ?
01319                                    vector_view.linfty_norm()
01320                                    : 0);
01321       return Utilities::MPI::max (local_result, partitioner->get_communicator());
01322     }
01323 
01324 
01325 
01326     template <typename Number>
01327     inline
01328     types::global_dof_index Vector<Number>::size () const
01329     {
01330       return partitioner->size();
01331     }
01332 
01333 
01334 
01335     template <typename Number>
01336     inline
01337     unsigned int Vector<Number>::local_size () const
01338     {
01339       return partitioner->local_size();
01340     }
01341 
01342 
01343 
01344     template <typename Number>
01345     inline
01346     std::pair<types::global_dof_index, types::global_dof_index>
01347     Vector<Number>::local_range () const
01348     {
01349       return partitioner->local_range();
01350     }
01351 
01352 
01353 
01354     template <typename Number>
01355     inline
01356     bool
01357     Vector<Number>::in_local_range
01358     (const types::global_dof_index global_index) const
01359     {
01360       return partitioner->in_local_range (global_index);
01361     }
01362 
01363 
01364 
01365     template <typename Number>
01366     inline
01367     unsigned int
01368     Vector<Number>::n_ghost_entries () const
01369     {
01370       return partitioner->n_ghost_indices();
01371     }
01372 
01373 
01374 
01375     template <typename Number>
01376     inline
01377     bool
01378     Vector<Number>::is_ghost_entry (const types::global_dof_index global_index) const
01379     {
01380       return partitioner->is_ghost_entry (global_index);
01381     }
01382 
01383 
01384 
01385     template <typename Number>
01386     inline
01387     typename Vector<Number>::iterator
01388     Vector<Number>::begin ()
01389     {
01390       return vector_view.begin();
01391     }
01392 
01393 
01394 
01395     template <typename Number>
01396     inline
01397     typename Vector<Number>::const_iterator
01398     Vector<Number>::begin () const
01399     {
01400       return vector_view.begin();
01401     }
01402 
01403 
01404 
01405     template <typename Number>
01406     inline
01407     typename Vector<Number>::iterator
01408     Vector<Number>::end ()
01409     {
01410       return vector_view.end();
01411     }
01412 
01413 
01414 
01415     template <typename Number>
01416     inline
01417     typename Vector<Number>::const_iterator
01418     Vector<Number>::end () const
01419     {
01420       return vector_view.end();
01421     }
01422 
01423 
01424 
01425     template <typename Number>
01426     inline
01427     Number
01428     Vector<Number>::operator() (const types::global_dof_index global_index) const
01429     {
01430       return val[partitioner->global_to_local(global_index)];
01431     }
01432 
01433 
01434 
01435     template <typename Number>
01436     inline
01437     Number&
01438     Vector<Number>::operator() (const types::global_dof_index global_index)
01439     {
01440       return val[partitioner->global_to_local (global_index)];
01441     }
01442 
01443 
01444 
01445     template <typename Number>
01446     inline
01447     Number
01448     Vector<Number>::operator[] (const types::global_dof_index global_index) const
01449     {
01450       return operator()(global_index);
01451     }
01452 
01453 
01454 
01455     template <typename Number>
01456     inline
01457     Number&
01458     Vector<Number>::operator[] (const types::global_dof_index global_index)
01459     {
01460       return operator()(global_index);
01461     }
01462 
01463 
01464 
01465     template <typename Number>
01466     inline
01467     Number
01468     Vector<Number>::local_element (const unsigned int local_index) const
01469     {
01470       AssertIndexRange (local_index,
01471                         partitioner->local_size()+
01472                         partitioner->n_ghost_indices());
01473       return val[local_index];
01474     }
01475 
01476 
01477 
01478     template <typename Number>
01479     inline
01480     Number&
01481     Vector<Number>::local_element (const unsigned int local_index)
01482     {
01483       AssertIndexRange (local_index,
01484                         partitioner->local_size()+
01485                         partitioner->n_ghost_indices());
01486       return val[local_index];
01487     }
01488 
01489 
01490 
01491     template <typename Number>
01492     inline
01493     Vector<Number>&
01494     Vector<Number>::operator = (const Number s)
01495     {
01496                                        // if we call Vector::operator=0, we want to
01497                                        // zero out all the entries plus ghosts.
01498       if (partitioner->local_size() > 0)
01499         vector_view.::template Vector<Number>::operator= (s);
01500       if (s==Number())
01501         zero_out_ghosts();
01502 
01503       return *this;
01504     }
01505 
01506 
01507 
01508     template <typename Number>
01509     inline
01510     Vector<Number> &
01511     Vector<Number>::operator += (const Vector<Number> &v)
01512     {
01513       AssertDimension (local_size(), v.local_size());
01514                                        // ::Vector does not allow empty fields
01515                                        // but this might happen on some processors
01516                                        // for parallel implementation
01517       if(local_size()>0)
01518         vector_view += v.vector_view;
01519       return *this;
01520     }
01521 
01522 
01523 
01524     template <typename Number>
01525     inline
01526     Vector<Number> &
01527     Vector<Number>::operator -= (const Vector<Number> &v)
01528     {
01529       AssertDimension (local_size(), v.local_size());
01530                                        // ::Vector does not allow empty fields
01531                                        // but this might happen on some processors
01532                                        // for parallel implementation
01533       if(local_size()>0)
01534         vector_view -= v.vector_view;
01535       return *this;
01536     }
01537 
01538 
01539 
01540     template <typename Number>
01541     template <typename OtherNumber>
01542     inline
01543     void
01544     Vector<Number>::add (const std::vector<unsigned int> &indices,
01545                          const std::vector<OtherNumber>  &values)
01546     {
01547       AssertDimension (indices.size(), values.size());
01548       add (indices.size(), &indices[0], &values[0]);
01549     }
01550 
01551 
01552 
01553     template <typename Number>
01554     template <typename OtherNumber>
01555     inline
01556     void
01557     Vector<Number>::add (const std::vector<unsigned int>    &indices,
01558                          const ::Vector<OtherNumber>&values)
01559     {
01560       AssertDimension (indices.size(), values.size());
01561       add (indices.size(), &indices[0], values.begin());
01562     }
01563 
01564 
01565 
01566     template <typename Number>
01567     template <typename OtherNumber>
01568     inline
01569     void
01570     Vector<Number>::add (const unsigned int  n_indices,
01571                          const unsigned int *indices,
01572                          const OtherNumber  *values)
01573     {
01574       for (unsigned int i=0; i<n_indices; ++i)
01575         {
01576           Assert (numbers::is_finite(values[i]),
01577                   ExcMessage("The given value is not finite but either infinite or Not A Number (NaN)"));
01578           this->operator()(indices[i]) += values[i];
01579         }
01580     }
01581 
01582 
01583 
01584     template <typename Number>
01585     inline
01586     void
01587     Vector<Number>::add (const Number a)
01588     {
01589                                        // ::Vector does not allow empty fields
01590                                        // but this might happen on some processors
01591                                        // for parallel implementation
01592       if(local_size()>0)
01593         vector_view.add (a);
01594     }
01595 
01596 
01597 
01598     template <typename Number>
01599     inline
01600     void
01601     Vector<Number>::add (const Vector<Number>& v)
01602     {
01603       AssertDimension (local_size(), v.local_size());
01604                                        // ::Vector does not allow empty fields
01605                                        // but this might happen on some processors
01606                                        // for parallel implementation
01607       if(local_size()>0)
01608         vector_view.add (v.vector_view);
01609     }
01610 
01611 
01612 
01613     template <typename Number>
01614     inline
01615     void
01616     Vector<Number>::add (const Number a,
01617                          const Vector<Number>& v)
01618     {
01619       AssertDimension (local_size(), v.local_size());
01620                                        // ::Vector does not allow empty fields
01621                                        // but this might happen on some processors
01622                                        // for parallel implementation
01623       if(local_size()>0)
01624         vector_view.add (a, v.vector_view);
01625     }
01626 
01627 
01628 
01629     template <typename Number>
01630     inline
01631     void
01632     Vector<Number>::add (const Number a,
01633                          const Vector<Number>& v,
01634                          const Number b,
01635                          const Vector<Number>& w)
01636     {
01637       AssertDimension (local_size(), v.local_size());
01638       AssertDimension (local_size(), w.local_size());
01639                                        // ::Vector does not allow empty fields
01640                                        // but this might happen on some processors
01641                                        // for parallel implementation
01642       if(local_size()>0)
01643         vector_view.add (a, v.vector_view, b, w.vector_view);
01644     }
01645 
01646 
01647 
01648     template <typename Number>
01649     inline
01650     void
01651     Vector<Number>::sadd (const Number x,
01652                           const Vector<Number>& v)
01653     {
01654       AssertDimension (local_size(), v.local_size());
01655                                        // ::Vector does not allow empty fields
01656                                        // but this might happen on some processors
01657                                        // for parallel implementation
01658       if(local_size()>0)
01659         vector_view.sadd (x, v.vector_view);
01660     }
01661 
01662 
01663 
01664     template <typename Number>
01665     inline
01666     void
01667     Vector<Number>::sadd (const Number x,
01668                           const Number a,
01669                           const Vector<Number>& v)
01670     {
01671       AssertDimension (local_size(), v.local_size());
01672                                        // ::Vector does not allow empty fields
01673                                        // but this might happen on some processors
01674                                        // for parallel implementation
01675       if(local_size()>0)
01676         vector_view.sadd (x, a, v.vector_view);
01677     }
01678 
01679 
01680 
01681     template <typename Number>
01682     inline
01683     void
01684     Vector<Number>::sadd (const Number x,
01685                           const Number a,
01686                           const Vector<Number>& v,
01687                           const Number b,
01688                           const Vector<Number>& w)
01689     {
01690       AssertDimension (local_size(), v.local_size());
01691       AssertDimension (local_size(), w.local_size());
01692                                        // ::Vector does not allow empty fields
01693                                        // but this might happen on some processors
01694                                        // for parallel implementation
01695       if(local_size()>0)
01696         vector_view.sadd (x, a, v.vector_view, b, w.vector_view);
01697     }
01698 
01699 
01700 
01701     template <typename Number>
01702     inline
01703     void
01704     Vector<Number>::sadd (const Number s,
01705                           const Number a,
01706                           const Vector<Number>& v,
01707                           const Number b,
01708                           const Vector<Number>& w,
01709                           const Number c,
01710                           const Vector<Number>& x)
01711     {
01712       AssertDimension (local_size(), v.local_size());
01713       AssertDimension (local_size(), w.local_size());
01714       AssertDimension (local_size(), x.local_size());
01715                                        // ::Vector does not allow empty fields
01716                                        // but this might happen on some processors
01717                                        // for parallel implementation
01718       if(local_size()>0)
01719         vector_view.sadd (s, a, v.vector_view, b, w.vector_view,
01720                           c, x.vector_view);
01721     }
01722 
01723 
01724 
01725     template <typename Number>
01726     inline
01727     void
01728     Vector<Number>::scale (const Number factor)
01729     {
01730                                        // ::Vector does not allow empty fields
01731                                        // but this might happen on some processors
01732                                        // for parallel implementation
01733       if(local_size()>0)
01734         vector_view.scale (factor);
01735     }
01736 
01737 
01738 
01739     template <typename Number>
01740     inline
01741     Vector<Number>&
01742     Vector<Number>::operator *= (const Number factor)
01743     {
01744                                        // ::Vector does not allow empty fields
01745                                        // but this might happen on some processors
01746                                        // for parallel implementation
01747       if(local_size()>0)
01748         vector_view.operator *= (factor);
01749       return *this;
01750     }
01751 
01752 
01753 
01754     template <typename Number>
01755     inline
01756     Vector<Number>&
01757     Vector<Number>::operator /= (const Number factor)
01758     {
01759                                        // ::Vector does not allow empty fields
01760                                        // but this might happen on some processors
01761                                        // for parallel implementation
01762       if(local_size()>0)
01763         vector_view.operator /= (factor);
01764       return *this;
01765     }
01766 
01767 
01768 
01769     template <typename Number>
01770     inline
01771     void
01772     Vector<Number>::scale (const Vector<Number> &scaling_factors)
01773     {
01774                                        // ::Vector does not allow empty fields
01775                                        // but this might happen on some processors
01776                                        // for parallel implementation
01777       if(local_size()>0)
01778         vector_view.scale (scaling_factors.vector_view);
01779     }
01780 
01781 
01782 
01783     template <typename Number>
01784     template <typename Number2>
01785     inline
01786     void
01787     Vector<Number>::scale (const Vector<Number2> &scaling_factors)
01788     {
01789       vector_view.template scale<Number2> (scaling_factors.vector_view);
01790     }
01791 
01792 
01793 
01794     template <typename Number>
01795     inline
01796     void
01797     Vector<Number>::equ (const Number a,
01798                          const Vector<Number>& v)
01799     {
01800       AssertDimension (local_size(), v.local_size());
01801                                        // ::Vector does not allow empty fields
01802                                        // but this might happen on some processors
01803                                        // for parallel implementation
01804       if(local_size()>0)
01805         vector_view.equ (a, v.vector_view);
01806     }
01807 
01808 
01809 
01810     template <typename Number>
01811     template <typename Number2>
01812     inline
01813     void
01814     Vector<Number>::equ (const Number a,
01815                          const Vector<Number2>& v)
01816     {
01817       AssertDimension (local_size(), v.local_size());
01818                                        // ::Vector does not allow empty fields
01819                                        // but this might happen on some processors
01820                                        // for parallel implementation
01821       if(local_size()>0)
01822         vector_view.equ (a, v.vector_view);
01823     }
01824 
01825 
01826 
01827     template <typename Number>
01828     inline
01829     void
01830     Vector<Number>::equ (const Number a,
01831                          const Vector<Number>& v,
01832                          const Number b,
01833                          const Vector<Number>& w)
01834     {
01835       AssertDimension (local_size(), v.local_size());
01836       AssertDimension (local_size(), w.local_size());
01837                                        // ::Vector does not allow empty fields
01838                                        // but this might happen on some processors
01839                                        // for parallel implementation
01840       if(local_size()>0)
01841         vector_view.equ (a, v.vector_view, b, w.vector_view);
01842     }
01843 
01844 
01845 
01846     template <typename Number>
01847     inline
01848     void
01849     Vector<Number>::equ (const Number a,
01850                          const Vector<Number>& v,
01851                          const Number b,
01852                          const Vector<Number>& w,
01853                          const Number c,
01854                          const Vector<Number>& x)
01855     {
01856       AssertDimension (local_size(), v.local_size());
01857       AssertDimension (local_size(), w.local_size());
01858       AssertDimension (local_size(), w.local_size());
01859                                        // ::Vector does not allow empty fields
01860                                        // but this might happen on some processors
01861                                        // for parallel implementation
01862       if(local_size()>0)
01863         vector_view.equ (a, v.vector_view, b, w.vector_view,
01864                          c, x.vector_view);
01865     }
01866 
01867 
01868 
01869     template <typename Number>
01870     inline
01871     void
01872     Vector<Number>::ratio (const Vector<Number>& a,
01873                            const Vector<Number>& b)
01874     {
01875       AssertDimension (local_size(), a.local_size());
01876       AssertDimension (local_size(), b.local_size());
01877                                        // ::Vector does not allow empty fields
01878                                        // but this might happen on some processors
01879                                        // for parallel implementation
01880       if(local_size()>0)
01881         vector_view.ratio (a.vector_view, b.vector_view);
01882     }
01883 
01884 
01885 
01886     template <typename Number>
01887     inline
01888     bool
01889     Vector<Number>::partitioners_are_compatible
01890     (const Utilities::MPI::Partitioner &part) const
01891     {
01892       return partitioner->is_compatible (part);
01893     }
01894 
01895 #endif  // ifndef DOXYGEN
01896 
01897   } // end of namespace distributed
01898 
01899 } // end of namespace parallel
01900 
01901 
01902 
01911 template <typename Number>
01912 inline
01913 void swap (parallel::distributed::Vector<Number> &u,
01914            parallel::distributed::Vector<Number> &v)
01915 {
01916   u.swap (v);
01917 }
01918 
01919 
01920 DEAL_II_NAMESPACE_CLOSE
01921 
01922 #endif
01923 
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines

deal.II documentation generated on Wed May 23 2012 06:07:37 by doxygen 1.7.3