00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
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
00975
00976
00977 template <typename Number2> friend class Vector;
00978 };
00979
00983
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
01086
01087
01088
01089
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
01115
01116
01117
01118
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
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
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
01206
01207
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
01250
01251
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
01497
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
01515
01516
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
01531
01532
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
01590
01591
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
01605
01606
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
01621
01622
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
01640
01641
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
01656
01657
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
01673
01674
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
01693
01694
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
01716
01717
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
01731
01732
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
01745
01746
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
01760
01761
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
01775
01776
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
01802
01803
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
01819
01820
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
01838
01839
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
01860
01861
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
01878
01879
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 }
01898
01899 }
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