Reference documentation for deal.II version 8.1.0
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Groups Pages
vector.h
1 // ---------------------------------------------------------------------
2 // @f$Id: vector.h 31932 2013-12-08 02:15:54Z heister @f$
3 //
4 // Copyright (C) 1999 - 2013 by the deal.II authors
5 //
6 // This file is part of the deal.II library.
7 //
8 // The deal.II library is free software; you can use it, redistribute
9 // it, and/or modify it under the terms of the GNU Lesser General
10 // Public License as published by the Free Software Foundation; either
11 // version 2.1 of the License, or (at your option) any later version.
12 // The full text of the license can be found in the file LICENSE at
13 // the top level of the deal.II distribution.
14 //
15 // ---------------------------------------------------------------------
16 
17 #ifndef __deal2__vector_h
18 #define __deal2__vector_h
19 
20 
21 #include <deal.II/base/config.h>
22 #include <deal.II/base/logstream.h>
24 #include <deal.II/base/subscriptor.h>
25 #include <deal.II/base/index_set.h>
26 #include <boost/serialization/array.hpp>
27 #include <boost/serialization/split_member.hpp>
28 
29 #include <cstdio>
30 #include <iostream>
31 #include <cstring>
32 #include <vector>
33 
34 DEAL_II_NAMESPACE_OPEN
35 
36 
37 #ifdef DEAL_II_WITH_PETSC
38 namespace PETScWrappers
39 {
40  class Vector;
41  namespace MPI
42  {
43  class Vector;
44  }
45 }
46 #endif
47 
48 #ifdef DEAL_II_WITH_TRILINOS
49 namespace TrilinosWrappers
50 {
51  namespace MPI
52  {
53  class Vector;
54  }
55  class Vector;
56 }
57 #endif
58 
59 template<typename number> class LAPACKFullMatrix;
60 
61 template <typename> class BlockVector;
62 
63 template <typename> class VectorView;
64 
65 
66 
67 
83 {
84  enum values { unknown, insert, add };
85 };
86 
87 
109 template <typename Number>
110 class Vector : public Subscriptor
111 {
112 public:
119  typedef Number value_type;
120  typedef value_type *pointer;
121  typedef const value_type *const_pointer;
122  typedef value_type *iterator;
123  typedef const value_type *const_iterator;
124  typedef value_type &reference;
125  typedef const value_type &const_reference;
126  typedef types::global_dof_index size_type;
127 
148 
160  static const bool supports_distributed_data = false;
161 
162 public:
163 
172  Vector ();
173 
183  Vector (const Vector<Number> &v);
184 
185 
186 #ifndef DEAL_II_EXPLICIT_CONSTRUCTOR_BUG
187 
207  template <typename OtherNumber>
208  explicit
209  Vector (const Vector<OtherNumber> &v);
210 #endif
211 
212 #ifdef DEAL_II_WITH_PETSC
213 
220  Vector (const PETScWrappers::Vector &v);
221 
239 #endif
240 
241 #ifdef DEAL_II_WITH_TRILINOS
242 
264 
274  Vector (const TrilinosWrappers::Vector &v);
275 #endif
276 
294  explicit Vector (const size_type n);
295 
303  template <typename InputIterator>
304  Vector (const InputIterator first,
305  const InputIterator last);
306 
313  virtual ~Vector ();
314 
334  void compress (::VectorOperation::values operation
335  =::VectorOperation::unknown) const;
336 
362  virtual void reinit (const size_type N,
363  const bool fast=false);
364 
374  template <typename Number2>
375  void reinit (const Vector<Number2> &V,
376  const bool fast=false);
377 
406  virtual void swap (Vector<Number> &v);
407 
427  Vector<Number> &operator = (const Number s);
428 
434 
439  template <typename Number2>
441 
448 
449 #ifdef DEAL_II_WITH_PETSC
450 
460 
481 #endif
482 
483 
484 #ifdef DEAL_II_WITH_TRILINOS
485 
507 
519 #endif
520 
530  template <typename Number2>
531  bool operator == (const Vector<Number2> &v) const;
532 
541  template <typename Number2>
542  bool operator != (const Vector<Number2> &v) const;
543 
560  template <typename Number2>
561  Number operator * (const Vector<Number2> &V) const;
562 
566  real_type norm_sqr () const;
567 
572  Number mean_value () const;
573 
578  real_type l1_norm () const;
579 
585  real_type l2_norm () const;
586 
593  real_type lp_norm (const real_type p) const;
594 
599  real_type linfty_norm () const;
600 
607  bool in_local_range (const size_type global_index) const;
608 
628 
632  std::size_t size () const;
633 
642  bool all_zero () const;
643 
658  bool is_non_negative () const;
659 
667  iterator begin ();
668 
673  const_iterator begin () const;
674 
679  iterator end ();
680 
685  const_iterator end () const;
687 
688 
697  Number operator() (const size_type i) const;
698 
703  Number &operator() (const size_type i);
704 
711  Number operator[] (const size_type i) const;
712 
719  Number &operator[] (const size_type i);
720 
731  template <typename OtherNumber>
732  void extract_subvector_to (const std::vector<size_type> &indices,
733  std::vector<OtherNumber> &values) const;
734 
739  template <typename ForwardIterator, typename OutputIterator>
740  void extract_subvector_to (ForwardIterator indices_begin,
741  const ForwardIterator indices_end,
742  OutputIterator values_begin) const;
744 
745 
750 
756 
762 
771  template <typename OtherNumber>
772  void add (const std::vector<size_type> &indices,
773  const std::vector<OtherNumber> &values);
774 
782  template <typename OtherNumber>
783  void add (const std::vector<size_type> &indices,
784  const Vector<OtherNumber> &values);
785 
795  template <typename OtherNumber>
796  void add (const size_type n_elements,
797  const size_type *indices,
798  const OtherNumber *values);
799 
805  void add (const Number s);
806 
811  void add (const Vector<Number> &V);
812 
817  void add (const Number a, const Vector<Number> &V);
818 
823  void add (const Number a, const Vector<Number> &V,
824  const Number b, const Vector<Number> &W);
825 
831  void sadd (const Number s,
832  const Vector<Number> &V);
833 
838  void sadd (const Number s,
839  const Number a,
840  const Vector<Number> &V);
841 
845  void sadd (const Number s,
846  const Number a,
847  const Vector<Number> &V,
848  const Number b,
849  const Vector<Number> &W);
850 
855  void sadd (const Number s,
856  const Number a,
857  const Vector<Number> &V,
858  const Number b,
859  const Vector<Number> &W,
860  const Number c,
861  const Vector<Number> &X);
862 
873  void scale (const Number factor) DEAL_II_DEPRECATED
874  {
875  this->operator *= (factor);
876  }
877 
878 
884  Vector<Number> &operator *= (const Number factor);
885 
891  Vector<Number> &operator /= (const Number factor);
892 
902  void scale (const Vector<Number> &scaling_factors);
903 
913  template <typename Number2>
914  void scale (const Vector<Number2> &scaling_factors);
915 
919  void equ (const Number a, const Vector<Number> &u);
920 
924  template <typename Number2>
925  void equ (const Number a, const Vector<Number2> &u);
926 
930  void equ (const Number a, const Vector<Number> &u,
931  const Number b, const Vector<Number> &v);
932 
936  void equ (const Number a, const Vector<Number> &u,
937  const Number b, const Vector<Number> &v,
938  const Number c, const Vector<Number> &w);
939 
956  void ratio (const Vector<Number> &a,
957  const Vector<Number> &b);
958 
974  void update_ghost_values () const;
976 
977 
989  void print (const char *format = 0) const;
990 
1005  void print (std::ostream &out,
1006  const unsigned int precision = 3,
1007  const bool scientific = true,
1008  const bool across = true) const;
1009 
1022  void print (LogStream &out,
1023  const unsigned int width = 6,
1024  const bool across = true) const;
1025 
1035  void block_write (std::ostream &out) const;
1036 
1056  void block_read (std::istream &in);
1057 
1063  std::size_t memory_consumption () const;
1065 
1070  template <class Archive>
1071  void save (Archive &ar, const unsigned int version) const;
1072 
1077  template <class Archive>
1078  void load (Archive &ar, const unsigned int version);
1079 
1080  BOOST_SERIALIZATION_SPLIT_MEMBER()
1081 
1082 protected:
1083 
1090  size_type vec_size;
1091 
1104  size_type max_vec_size;
1105 
1110  Number *val;
1111 
1116  template <typename Number2> friend class Vector;
1117 
1122  friend class LAPACKFullMatrix<Number>;
1123 
1128  friend class VectorView<Number>;
1129 };
1130 
1132 /*----------------------- Inline functions ----------------------------------*/
1133 
1134 
1135 #ifndef DOXYGEN
1136 
1137 
1138 template <typename Number>
1139 inline
1141  :
1142  vec_size(0),
1143  max_vec_size(0),
1144  val(0)
1145 {}
1146 
1147 
1148 
1149 template <typename Number>
1150 template <typename InputIterator>
1151 Vector<Number>::Vector (const InputIterator first, const InputIterator last)
1152  :
1153  vec_size (0),
1154  max_vec_size (0),
1155  val (0)
1156 {
1157  // allocate memory. do not
1158  // initialize it, as we will copy
1159  // over to it in a second
1160  reinit (std::distance (first, last), true);
1161  std::copy (first, last, begin());
1162 }
1163 
1164 
1165 
1166 template <typename Number>
1167 inline
1169  :
1170  vec_size(0),
1171  max_vec_size(0),
1172  val(0)
1173 {
1174  reinit (n, false);
1175 }
1176 
1177 
1178 
1179 template <typename Number>
1180 inline
1182 {
1183  if (val)
1184  {
1185  delete[] val;
1186  val=0;
1187  }
1188 }
1189 
1190 
1191 
1192 template <typename Number>
1193 inline
1194 void Vector<Number>::reinit (const size_type n, const bool fast)
1195 {
1196  if (n==0)
1197  {
1198  if (val) delete[] val;
1199  val = 0;
1200  max_vec_size = vec_size = 0;
1201  return;
1202  };
1203 
1204  if (n>max_vec_size)
1205  {
1206  if (val) delete[] val;
1207  val = new value_type[n];
1208  Assert (val != 0, ExcOutOfMemory());
1209  max_vec_size = n;
1210  };
1211  vec_size = n;
1212  if (fast == false)
1213  *this = static_cast<Number>(0);
1214 }
1215 
1216 
1217 
1218 // declare function that is implemented in vector.templates.h
1219 namespace internal
1220 {
1221  namespace Vector
1222  {
1223  template <typename T, typename U>
1224  void copy_vector (const ::Vector<T> &src,
1225  ::Vector<U> &dst);
1226  }
1227 }
1228 
1229 
1230 
1231 template <typename Number>
1232 inline
1235 {
1236  internal::Vector::copy_vector (v, *this);
1237  return *this;
1238 }
1239 
1240 
1241 
1242 template <typename Number>
1243 template <typename Number2>
1244 inline
1247 {
1248  internal::Vector::copy_vector (v, *this);
1249  return *this;
1250 }
1251 
1252 
1253 
1254 template <typename Number>
1255 inline
1256 std::size_t Vector<Number>::size () const
1257 {
1258  return vec_size;
1259 }
1260 
1261 
1262 template <typename Number>
1263 inline
1265 (const size_type) const
1266 {
1267  return true;
1268 }
1269 
1270 
1271 
1272 template <typename Number>
1273 inline
1274 typename Vector<Number>::iterator
1276 {
1277  return &val[0];
1278 }
1279 
1280 
1281 
1282 template <typename Number>
1283 inline
1285 Vector<Number>::begin () const
1286 {
1287  return &val[0];
1288 }
1289 
1290 
1291 
1292 template <typename Number>
1293 inline
1294 typename Vector<Number>::iterator
1296 {
1297  return &val[vec_size];
1298 }
1299 
1300 
1301 
1302 template <typename Number>
1303 inline
1305 Vector<Number>::end () const
1306 {
1307  return &val[vec_size];
1308 }
1309 
1310 
1311 
1312 template <typename Number>
1313 inline
1314 Number Vector<Number>::operator() (const size_type i) const
1315 {
1316  Assert (i<vec_size, ExcIndexRange(i,0,vec_size));
1317  return val[i];
1318 }
1319 
1320 
1321 
1322 template <typename Number>
1323 inline
1324 Number &Vector<Number>::operator() (const size_type i)
1325 {
1326  Assert (i<vec_size, ExcIndexRangeType<size_type>(i,0,vec_size));
1327  return val[i];
1328 }
1329 
1330 
1331 
1332 template <typename Number>
1333 inline
1334 Number Vector<Number>::operator[] (const size_type i) const
1335 {
1336  return operator()(i);
1337 }
1338 
1339 
1340 
1341 template <typename Number>
1342 inline
1343 Number &Vector<Number>::operator[] (const size_type i)
1344 {
1345  return operator()(i);
1346 }
1347 
1348 
1349 
1350 template <typename Number>
1351 template <typename OtherNumber>
1352 inline
1353 void Vector<Number>::extract_subvector_to (const std::vector<size_type> &indices,
1354  std::vector<OtherNumber> &values) const
1355 {
1356  for (size_type i = 0; i < indices.size(); ++i)
1357  values[i] = operator()(indices[i]);
1358 }
1359 
1360 
1361 
1362 template <typename Number>
1363 template <typename ForwardIterator, typename OutputIterator>
1364 inline
1365 void Vector<Number>::extract_subvector_to (ForwardIterator indices_begin,
1366  const ForwardIterator indices_end,
1367  OutputIterator values_begin) const
1368 {
1369  while (indices_begin != indices_end)
1370  {
1371  *values_begin = operator()(*indices_begin);
1372  indices_begin++;
1373  values_begin++;
1374  }
1375 }
1376 
1377 
1378 
1379 template <typename Number>
1380 inline
1382 Vector<Number>::operator /= (const Number factor)
1383 {
1385  Assert (factor != Number(0.), ExcZero() );
1386 
1387  this->operator *= (Number(1.)/factor);
1388  return *this;
1389 }
1390 
1391 
1392 
1393 template <typename Number>
1394 template <typename OtherNumber>
1395 inline
1396 void
1397 Vector<Number>::add (const std::vector<size_type> &indices,
1398  const std::vector<OtherNumber> &values)
1399 {
1400  Assert (indices.size() == values.size(),
1401  ExcDimensionMismatch(indices.size(), values.size()));
1402  add (indices.size(), &indices[0], &values[0]);
1403 }
1404 
1405 
1406 
1407 template <typename Number>
1408 template <typename OtherNumber>
1409 inline
1410 void
1411 Vector<Number>::add (const std::vector<size_type> &indices,
1412  const Vector<OtherNumber> &values)
1413 {
1414  Assert (indices.size() == values.size(),
1415  ExcDimensionMismatch(indices.size(), values.size()));
1416  add (indices.size(), &indices[0], values.val);
1417 }
1418 
1419 
1420 
1421 template <typename Number>
1422 template <typename OtherNumber>
1423 inline
1424 void
1425 Vector<Number>::add (const size_type n_indices,
1426  const size_type *indices,
1427  const OtherNumber *values)
1428 {
1429  for (size_type i=0; i<n_indices; ++i)
1430  {
1431  Assert (indices[i] < vec_size, ExcIndexRange(indices[i],0,vec_size));
1432  Assert (numbers::is_finite(values[i]),
1433  ExcMessage("The given value is not finite but either infinite or Not A Number (NaN)"));
1434 
1435  val[indices[i]] += values[i];
1436  }
1437 }
1438 
1439 
1440 
1441 template <typename Number>
1442 template <typename Number2>
1443 inline
1444 bool
1446 {
1447  return ! (*this == v);
1448 }
1449 
1450 
1451 
1452 template <typename Number>
1453 inline
1454 void
1455 Vector<Number>::compress (::VectorOperation::values) const
1456 {}
1457 
1458 
1459 
1460 template <typename Number>
1461 inline
1462 void
1464 {}
1465 
1466 
1467 
1468 // Moved from vector.templates.h as an inline function by Luca Heltai
1469 // on 2009/04/12 to prevent strange compiling errors, after making
1470 // swap virtual.
1471 template <typename Number>
1472 inline
1473 void
1475 {
1476  std::swap (vec_size, v.vec_size);
1477  std::swap (max_vec_size, v.max_vec_size);
1478  std::swap (val, v.val);
1479 }
1480 
1481 
1482 
1483 template <typename Number>
1484 template <class Archive>
1485 inline
1486 void
1487 Vector<Number>::save (Archive &ar, const unsigned int) const
1488 {
1489  // forward to serialization
1490  // function in the base class.
1491  ar &static_cast<const Subscriptor &>(*this);
1492 
1493  ar &vec_size &max_vec_size ;
1494  ar &boost::serialization::make_array(val, max_vec_size);
1495 }
1496 
1497 
1498 
1499 template <typename Number>
1500 template <class Archive>
1501 inline
1502 void
1503 Vector<Number>::load (Archive &ar, const unsigned int)
1504 {
1505  // forward to serialization
1506  // function in the base class.
1507  ar &static_cast<Subscriptor &>(*this);
1508 
1509  ar &vec_size &max_vec_size ;
1510 
1511  val = new Number[max_vec_size];
1512  ar &boost::serialization::make_array(val, max_vec_size);
1513 }
1514 
1515 
1516 #endif
1517 
1518 
1532 template <typename Number>
1533 inline
1535 {
1536  u.swap (v);
1537 }
1538 
1539 
1543 template <typename number>
1544 inline
1545 std::ostream &
1546 operator << (std::ostream &os, const Vector<number> &v)
1547 {
1548  v.print(os);
1549  return os;
1550 }
1551 
1555 template <typename number>
1556 inline
1557 LogStream &
1558 operator << (LogStream &os, const Vector<number> &v)
1559 {
1560  v.print(os);
1561  return os;
1562 }
1563 
1564 
1567 DEAL_II_NAMESPACE_CLOSE
1568 
1569 #endif
std::size_t memory_consumption() const
bool all_zero() const
Vector< Number > & operator*=(const Number factor)
::ExceptionBase & ExcOutOfMemory()
size_type max_vec_size
Definition: vector.h:1104
::ExceptionBase & ExcMessage(std::string arg1)
numbers::NumberTraits< Number >::real_type real_type
Definition: vector.h:147
Vector< Number > & operator+=(const Vector< Number > &V)
IndexSet locally_owned_elements() const
Number mean_value() const
bool is_non_negative() const
iterator end()
void ratio(const Vector< Number > &a, const Vector< Number > &b)
Number operator*(const Vector< Number2 > &V) const
bool operator!=(const Vector< Number2 > &v) const
real_type linfty_norm() const
bool is_finite(const double x)
size_type vec_size
Definition: vector.h:1090
real_type lp_norm(const real_type p) const
void compress(::VectorOperation::values operation=::VectorOperation::unknown) const
void extract_subvector_to(const std::vector< size_type > &indices, std::vector< OtherNumber > &values) const
void block_write(std::ostream &out) const
void scale(const Number factor) DEAL_II_DEPRECATED
Definition: vector.h:873
Vector< Number > & operator=(const Number s)
unsigned int global_dof_index
Definition: types.h:100
#define Assert(cond, exc)
Definition: exceptions.h:299
Number operator[](const size_type i) const
Vector< Number > & operator/=(const Number factor)
iterator begin()
::ExceptionBase & ExcIndexRange(int arg1, int arg2, int arg3)
virtual void reinit(const size_type N, const bool fast=false)
real_type l2_norm() const
bool in_local_range(const size_type global_index) const
BlockCompressedSparsityPattern CompressedBlockSparsityPattern DEAL_II_DEPRECATED
bool operator==(const Vector< Number2 > &v) const
real_type norm_sqr() const
void print(const char *format=0) const
void block_read(std::istream &in)
void equ(const Number a, const Vector< Number > &u)
void swap(Vector< Number > &u, Vector< Number > &v)
Definition: vector.h:1534
Number * val
Definition: vector.h:1110
void load(Archive &ar, const unsigned int version)
::ExceptionBase & ExcNumberNotFinite()
Vector< Number > & operator-=(const Vector< Number > &V)
Number value_type
Definition: vector.h:119
void add(const std::vector< size_type > &indices, const std::vector< OtherNumber > &values)
void sadd(const Number s, const Vector< Number > &V)
std::size_t size() const
void save(Archive &ar, const unsigned int version) const
Number operator()(const size_type i) const
::ExceptionBase & ExcDimensionMismatch(std::size_t arg1, std::size_t arg2)
virtual void swap(Vector< Number > &v)
virtual ~Vector()
void update_ghost_values() const
::ExceptionBase & ExcZero()
real_type l1_norm() const
static const bool supports_distributed_data
Definition: vector.h:160