MFEM  v4.6.0
Finite element discretization library
tadvector.hpp
Go to the documentation of this file.
1 // Copyright (c) 2010-2023, Lawrence Livermore National Security, LLC. Produced
2 // at the Lawrence Livermore National Laboratory. All Rights reserved. See files
3 // LICENSE and NOTICE for details. LLNL-CODE-806117.
4 //
5 // This file is part of the MFEM library. For more information and source code
6 // availability visit https://mfem.org.
7 //
8 // MFEM is free software; you can redistribute it and/or modify it under the
9 // terms of the BSD-3 license. We welcome feedback and contributions, see file
10 // CONTRIBUTING.md for details.
11 
12 #ifndef MFEM_TADVECTOR
13 #define MFEM_TADVECTOR
14 
15 #include "mfem.hpp"
16 
17 #include <cmath>
18 #include <iostream>
19 #include <limits>
20 #if defined(_MSC_VER) && (_MSC_VER < 1800)
21 #include <float.h>
22 #define isfinite _finite
23 #endif
24 
25 namespace mfem
26 {
27 /// Templated vector data type.
28 /** The main goal of the TAutoDiffVector class is to serve as a data container
29  for representing vectors in classes, methods, and functions utilized with
30  automatic differentiation (AD). The functionality/interface is copied from
31  the standard MFEM dense vector mfem::Vector. The basic idea is to utilize
32  the templated vector class in combination with AD during the development
33  phase. The AD parts can be replaced with optimized code once the initial
34  development of the application is complete. The common interface between
35  TAutoDiffVector and Vector will ease the transition from AD to
36  hand-optimized code as it does not require a change in the interface or the
37  code structure. TAutoDiffVector is intended to be utilized for dense serial
38  vectors. */
39 template<typename dtype>
41 {
42 protected:
43  dtype *data;
44  int size;
45  int capacity;
46 
47 public:
48  /// Default constructor for Vector. Sets size = 0 and data = NULL.
50  {
51  data = nullptr;
52  size = 0;
53  capacity = 0;
54  }
55 
56  /// Copy constructor. Allocates a new data array and copies the data.
58  {
59  const int s = v.Size();
60  if (s > 0)
61  {
62  size = s;
63  data = new dtype[s];
64  capacity = s;
65  for (int i = 0; i < s; i++)
66  {
67  data[i] = v[i];
68  }
69  }
70  else
71  {
72  size = 0;
73  capacity = 0;
74  data = nullptr;
75  }
76  }
77 
79  {
80  const int s = v.Size();
81  if (s > 0)
82  {
83  size = s;
84  capacity = s;
85  data = new dtype[s];
86  for (int i = 0; i < s; i++)
87  {
88  data[i] = v[i];
89  }
90  }
91  else
92  {
93  size = 0;
94  capacity = 0;
95  data = nullptr;
96  }
97  }
98 
99  /// @brief Creates vector of size s.
100  /// @warning Entries are not initialized to zero!
101  explicit TAutoDiffVector(int s)
102  {
103  if (s > 0)
104  {
105  size = s;
106  capacity = s;
107  data = new dtype[size];
108  }
109  else
110  {
111  size = 0;
112  capacity = 0;
113  data = nullptr;
114  }
115  }
116 
117  /// Creates a vector referencing an array of doubles, owned by someone else.
118  /** The pointer @a _data can be NULL. The data array can be replaced later
119  with SetData(). */
120  TAutoDiffVector(dtype *_data, int _size)
121  {
122  if (capacity > 0)
123  {
124  delete[] data;
125  capacity = 0;
126  }
127  size = _size;
128  data = _data;
129  }
130 
131  /// Reads a vector from multiple files
132  void Load(std::istream **in, int np, int *dim)
133  {
134  int i, j, s;
135 
136  s = 0;
137  for (i = 0; i < np; i++)
138  {
139  s += dim[i];
140  }
141  SetSize(s);
142 
143  int p = 0;
144  double tmpd;
145  for (i = 0; i < np; i++)
146  {
147  for (j = 0; j < dim[i]; j++)
148  {
149  *in[i] >> tmpd;
150  data[p++] = dtype(tmpd);
151  }
152  }
153  }
154 
155  /// Load a vector from an input stream.
156  void Load(std::istream &in, int Size)
157  {
158  SetSize(Size);
159  double tmpd;
160  for (int i = 0; i < size; i++)
161  {
162  in >> tmpd;
163  data[i] = dtype(tmpd);
164  }
165  }
166 
167  /// Load a vector from an input stream, reading the size from the stream.
168  void Load(std::istream &in)
169  {
170  int s;
171  in >> s;
172  Load(in, s);
173  }
174 
175  /// @brief Resize the vector to size @a s.
176  /** If the new size is less than or equal to Capacity() then the internal
177  data array remains the same. Otherwise, the old array is deleted, if
178  owned, and a new array of size @a s is allocated without copying the
179  previous content of the Vector.
180  @warning In the second case above (new size greater than current one),
181  the vector will allocate new data array, even if it did not own the
182  original data! Also, new entries are not initialized! */
183  void SetSize(int s)
184  {
185  if (s == size)
186  {
187  return;
188  }
189 
190  if (s <= capacity)
191  {
192  size = s;
193  return;
194  }
195 
196  delete[] data;
197  data = new dtype[s];
198  size = s;
199  capacity = s;
200  }
201 
202  /// Set the Vector data and size.
203  /** The Vector does not assume ownership of the new data. The new size is
204  @warning This method should be called only when OwnsData() is false.
205  @sa NewDataAndSize(). */
206  void SetDataAndSize(dtype *d, int s)
207  {
208  if (OwnsData())
209  {
210  delete[] data;
211  capacity = 0;
212  }
213  data = d;
214  size = s;
215  }
216 
217  /// Set the Vector data and size, deleting the old data, if owned.
218  /** The Vector does not assume ownership of the new data. The new size is
219  also used as the new Capacity().
220  @sa SetDataAndSize(). */
221  void NewDataAndSize(dtype *d, int s) { SetDataAndSize(d, s); }
222 
223  /// Reset the Vector to be a reference to a sub-vector of @a base.
224  inline void MakeRef(TAutoDiffVector<dtype> &base, int offset, int size_)
225  {
226  NewDataAndSize(base.GetData() + offset, size_);
227  }
228 
229  /** @brief Reset the Vector to be a reference to a sub-vector of @a base
230  without changing its current size. */
231  inline void MakeRef(TAutoDiffVector<dtype> &base, int offset)
232  {
233  int tsiz = size;
234  NewDataAndSize(base.GetData() + offset, tsiz);
235  }
236 
237  /// Destroy a vector
238  void Destroy()
239  {
240  size = 0;
241  capacity = 0;
242  delete[] data;
243  }
244 
245  /// Returns the size of the vector.
246  inline int Size() const { return size; }
247 
248  /// Return the size of the currently allocated data array.
249  /** It is always true that Capacity() >= Size(). */
250  inline int Capacity() const { return capacity; }
251 
252  /// Return a pointer to the beginning of the Vector data.
253  /** @warning This method should be used with caution as it gives write access
254  to the data of const-qualified Vector%s. */
255  inline dtype *GetData() const
256  {
257  return const_cast<dtype *>((const dtype *) data);
258  }
259 
260  /// Conversion to `double *`.
261  /** @note This conversion function makes it possible to use [] for indexing
262  in addition to the overloaded operator()(int). */
263  inline operator dtype *() { return data; }
264 
265  /// Conversion to `const double *`.
266  /** @note This conversion function makes it possible to use [] for indexing
267  in addition to the overloaded operator()(int). */
268  inline operator const dtype *() const { return data; }
269 
270  /// Read the Vector data (host pointer) ownership flag.
271  inline bool OwnsData() const { return (capacity > 0); }
272 
273  /// Changes the ownership of the data; after the call the Vector is empty
274  inline void StealData(dtype **p)
275  {
276  *p = data;
277  delete[] data;
278  size = 0;
279  capacity = 0;
280  }
281 
282  /// Changes the ownership of the data; after the call the Vector is empty
283  inline dtype *StealData()
284  {
285  dtype *p;
286  StealData(&p);
287  return p;
288  }
289 
290  /// Access Vector entries. Index i = 0 .. size-1.
291  dtype &Elem(int i) { return operator()(i); }
292  /// Read only access to Vector entries. Index i = 0 .. size-1.
293  const dtype &Elem(int i) const { return operator()(i); }
294 
295  /// Access Vector entries using () for 0-based indexing.
296  /** @note If MFEM_DEBUG is enabled, bounds checking is performed. */
297  inline dtype &operator()(int i)
298  {
299  MFEM_ASSERT(data && i >= 0 && i < size,
300  "index [" << i << "] is out of range [0," << size << ")");
301 
302  return data[i];
303  }
304 
305  /// Read only access to Vector entries using () for 0-based indexing.
306  /** @note If MFEM_DEBUG is enabled, bounds checking is performed. */
307  inline const dtype &operator()(int i) const
308  {
309  MFEM_ASSERT(data && i >= 0 && i < size,
310  "index [" << i << "] is out of range [0," << size << ")");
311 
312  return data[i];
313  }
314 
315  /// Dot product with a `dtype *` array.
316  dtype operator*(const dtype *v) const
317  {
318  dtype dot = 0.0;
319  for (int i = 0; i < size; i++)
320  {
321  dot += data[i] * v[i];
322  }
323  return dot;
324  }
325 
326  /// Return the inner-product.
327  dtype operator*(const TAutoDiffVector<dtype> &v) const
328  {
329  MFEM_ASSERT(size == v.Size(), "incompatible Vectors!");
330  dtype dot = 0.0;
331  for (int i = 0; i < size; i++)
332  {
333  dot += data[i] * v[i];
334  }
335  return dot;
336  }
337 
338  dtype operator*(const Vector &v) const
339  {
340  MFEM_ASSERT(size == v.Size(), "incompatible Vectors!");
341  dtype dot = 0.0;
342  for (int i = 0; i < size; i++)
343  {
344  dot += data[i] * v[i];
345  }
346  return dot;
347  }
348 
349  /// Copy Size() entries from @a v.
351  {
352  for (int i = 0; i < size; i++)
353  {
354  data[i] = v[i];
355  }
356  return *this;
357  }
358 
359  /// Copy assignment.
360  /** @note Defining this method overwrites the implicitly defined copy
361  assignment operator. */
363  {
364  SetSize(v.Size());
365  for (int i = 0; i < size; i++)
366  {
367  data[i] = v[i];
368  }
369  return *this;
370  }
371 
373  {
374  SetSize(v.Size());
375  for (int i = 0; i < size; i++)
376  {
377  data[i] = v[i];
378  }
379  return *this;
380  }
381 
382  /// Redefine '=' for vector = constant.
383  template<typename ivtype>
384  TAutoDiffVector &operator=(ivtype value)
385  {
386  for (int i = 0; i < size; i++)
387  {
388  data[i] = (dtype) value;
389  }
390  return *this;
391  }
392 
393  template<typename ivtype>
395  {
396  for (int i = 0; i < size; i++)
397  {
398  data[i] = data[i] * c;
399  }
400  return *this;
401  }
402 
403  template<typename ivtype>
405  {
406  for (int i = 0; i < size; i++)
407  {
408  data[i] = data[i] / c;
409  }
410  return *this;
411  }
412 
414  {
415  MFEM_ASSERT(size == v.Size(), "incompatible Vectors!");
416  for (int i = 0; i < size; i++)
417  {
418  data[i] = data[i] - v[i];
419  }
420  return *this;
421  }
422 
423  template<typename ivtype>
425  {
426  for (int i = 0; i < size; i++)
427  {
428  data[i] = data[i] - v;
429  }
430  return *this;
431  }
432 
434  {
435  MFEM_ASSERT(size == v.Size(), "incompatible Vectors!");
436  for (int i = 0; i < size; i++)
437  {
438  data[i] = data[i] + v[i];
439  }
440  return *this;
441  }
442 
443  template<typename ivtype>
445  {
446  for (int i = 0; i < size; i++)
447  {
448  data[i] = data[i] + v;
449  }
450  return *this;
451  }
452 
453  /// (*this) += a * Va
454  template<typename ivtype, typename vtype>
455  TAutoDiffVector &Add(const ivtype a, const vtype &v)
456  {
457  MFEM_ASSERT(size == v.Size(), "incompatible Vectors!");
458  for (int i = 0; i < size; i++)
459  {
460  data[i] = data[i] + a * v[i];
461  }
462  return *this;
463  }
464 
465  /// (*this) = a * x
466  template<typename ivtype, typename vtype>
467  TAutoDiffVector &Set(const ivtype a, const vtype &v)
468  {
469  MFEM_ASSERT(size == v.Size(), "incompatible Vectors!");
470  for (int i = 0; i < size; i++)
471  {
472  data[i] = a * v[i];
473  }
474  return *this;
475  }
476 
477  template<typename vtype>
478  void SetVector(const vtype &v, int offset)
479  {
480  MFEM_ASSERT(v.Size() + offset <= size, "invalid sub-vector");
481  for (int i = 0; i < size; i++)
482  {
483  data[i + offset] = v[i];
484  }
485  }
486 
487  /// (*this) = -(*this)
488  void Neg()
489  {
490  for (int i = 0; i < size; i++)
491  {
492  data[i] = -data[i];
493  }
494  }
495 
496  /// Swap the contents of two Vectors
497  inline void Swap(TAutoDiffVector<dtype> &other)
498  {
499  Swap(data, other.data);
500  Swap(size, other.size);
501  Swap(capacity, other.capacity);
502  }
503 
504  /// Set v = v1 + v2.
505  template<typename vtype1, typename vtype2>
506  friend void add(const vtype1 &v1, const vtype2 &v2, TAutoDiffVector<dtype> &v)
507  {
508  MFEM_ASSERT(v1.Size() == v.Size(), "incompatible Vectors!");
509  MFEM_ASSERT(v2.Size() == v.Size(), "incompatible Vectors!");
510  for (int i = 0; i < v.Size(); i++)
511  {
512  v[i] = v1[i] + v2[i];
513  }
514  }
515 
516  /// Set v = v1 + alpha * v2.
517  template<typename vtype1, typename vtype2>
518  friend void add(const vtype1 &v1,
519  dtype alpha,
520  const vtype2 &v2,
522  {
523  MFEM_ASSERT(v1.Size() == v.Size(), "incompatible Vectors!");
524  MFEM_ASSERT(v2.Size() == v.Size(), "incompatible Vectors!");
525  for (int i = 0; i < v.Size(); i++)
526  {
527  v[i] = v1[i] + alpha * v2[i];
528  }
529  }
530 
531  template<typename vtype1, typename vtype2>
532  friend void add(const dtype a,
533  const vtype1 &x,
534  const dtype b,
535  const vtype2 &y,
537  {
538  MFEM_ASSERT(x.Size() == y.Size() && x.Size() == z.Size(),
539  "incompatible Vectors!");
540 
541  for (int i = 0; i < z.Size(); i++)
542  {
543  z[i] = a * x[i] + b * y[i];
544  }
545  }
546 
547  template<typename vtype1, typename vtype2>
548  friend void add(const dtype a,
549  const vtype1 &x,
550  const vtype2 &y,
552  {
553  MFEM_ASSERT(x.Size() == y.Size() && x.Size() == z.Size(),
554  "incompatible Vectors!");
555 
556  for (int i = 0; i < z.Size(); i++)
557  {
558  z[i] = a * x[i] + y[i];
559  }
560  }
561 
562  template<typename vtype1, typename vtype2>
563  friend void subtract(const vtype1 &x, const vtype2 &y,
565  {
566  MFEM_ASSERT(x.Size() == y.Size() && x.Size() == z.Size(),
567  "incompatible Vectors!");
568  for (int i = 0; i < z.Size(); i++)
569  {
570  z[i] = x[i] - y[i];
571  }
572  }
573 
574  template<typename ivtype, typename vtype1, typename vtype2>
575  friend void subtract(const ivtype a,
576  const vtype1 &x,
577  const vtype2 &y,
579  {
580  MFEM_ASSERT(x.Size() == y.Size() && x.Size() == z.Size(),
581  "incompatible Vectors!");
582  for (int i = 0; i < z.Size(); i++)
583  {
584  z[i] = a * (x[i] - y[i]);
585  }
586  }
587 
588  /// Destroys vector.
589  ~TAutoDiffVector() { delete[] data; }
590 
591  /// Prints vector to stream @a os with @a width entries per line.
592  void Print(std::ostream &os = mfem::out, int width = 8) const
593  {
594  if (!size)
595  {
596  return;
597  }
598  for (int i = 0; 1;)
599  {
600  os << data[i];
601  i++;
602  if (i == size)
603  {
604  break;
605  }
606  if (i % width == 0)
607  {
608  os << '\n';
609  }
610  else
611  {
612  os << ' ';
613  }
614  }
615  os << '\n';
616  }
617 
618  /// Set random values in the vector.
619  void Randomize(int seed = 0)
620  {
621  // static unsigned int seed = time(0);
622  const double max = (double) (RAND_MAX) + 1.;
623 
624  if (seed == 0)
625  {
626  seed = (int) time(0);
627  }
628 
629  // srand(seed++);
630  srand((unsigned) seed);
631 
632  for (int i = 0; i < size; i++)
633  {
634  data[i] = std::abs(rand() / max);
635  }
636  }
637  /// Returns the l2 norm of the vector.
638  dtype Norml2() const
639  {
640  // Scale entries of Vector on the fly, using algorithms from std::hypot()
641  // and LAPACK's drm2. This scaling ensures that the argument of each call
642  // to std::pow is <= 1 to avoid overflow.
643  if (0 == size)
644  {
645  return 0.0;
646  } // end if 0 == size
647 
648  if (1 == size)
649  {
650  return abs(data[0]);
651  } // end if 1 == size
652 
653  dtype scale = 0.0;
654  dtype sum = 0.0;
655 
656  for (int i = 0; i < size; i++)
657  {
658  if (data[i] != 0.0)
659  {
660  const dtype absdata = abs(data[i]);
661  if (scale <= absdata)
662  {
663  const dtype sqr_arg = scale / absdata;
664  sum = 1.0 + sum * (sqr_arg * sqr_arg);
665  scale = absdata;
666  continue;
667  } // end if scale <= absdata
668  const dtype sqr_arg = absdata / scale;
669  sum += (sqr_arg * sqr_arg); // else scale > absdata
670  } // end if data[i] != 0
671  }
672  return scale * sqrt(sum);
673  }
674 
675  /// Returns the l_infinity norm of the vector.
676  dtype Normlinf() const
677  {
678  dtype max = 0.0;
679  for (int i = 0; i < size; i++)
680  {
681  max = max(abs(data[i]), max);
682  }
683  return max;
684  }
685  /// Returns the l_1 norm of the vector.
686  dtype Norml1() const
687  {
688  dtype sum = 0.0;
689  for (int i = 0; i < size; i++)
690  {
691  sum += abs(data[i]);
692  }
693  return sum;
694  }
695 };
696 
697 } // namespace mfem
698 
699 #endif
TAutoDiffVector & operator+=(const TAutoDiffVector< dtype > &v)
Definition: tadvector.hpp:433
TAutoDiffVector & operator-=(const TAutoDiffVector< dtype > &v)
Definition: tadvector.hpp:413
dtype Norml2() const
Returns the l2 norm of the vector.
Definition: tadvector.hpp:638
void Load(std::istream **in, int np, int *dim)
Reads a vector from multiple files.
Definition: tadvector.hpp:132
void NewDataAndSize(dtype *d, int s)
Set the Vector data and size, deleting the old data, if owned.
Definition: tadvector.hpp:221
dtype & operator()(int i)
Access Vector entries using () for 0-based indexing.
Definition: tadvector.hpp:297
TAutoDiffVector< dtype > & operator=(const dtype *v)
Copy Size() entries from v.
Definition: tadvector.hpp:350
int Size() const
Returns the size of the vector.
Definition: vector.hpp:197
~TAutoDiffVector()
Destroys vector.
Definition: tadvector.hpp:589
TAutoDiffVector & operator=(ivtype value)
Redefine &#39;=&#39; for vector = constant.
Definition: tadvector.hpp:384
TAutoDiffVector()
Default constructor for Vector. Sets size = 0 and data = NULL.
Definition: tadvector.hpp:49
TAutoDiffVector< dtype > & operator=(const Vector &v)
Definition: tadvector.hpp:372
int Capacity() const
Return the size of the currently allocated data array.
Definition: tadvector.hpp:250
dtype operator*(const TAutoDiffVector< dtype > &v) const
Return the inner-product.
Definition: tadvector.hpp:327
const dtype & Elem(int i) const
Read only access to Vector entries. Index i = 0 .. size-1.
Definition: tadvector.hpp:293
dtype * GetData() const
Return a pointer to the beginning of the Vector data.
Definition: tadvector.hpp:255
TAutoDiffVector(int s)
Creates vector of size s.
Definition: tadvector.hpp:101
friend void subtract(const vtype1 &x, const vtype2 &y, TAutoDiffVector< dtype > &z)
Definition: tadvector.hpp:563
void StealData(dtype **p)
Changes the ownership of the data; after the call the Vector is empty.
Definition: tadvector.hpp:274
friend void add(const vtype1 &v1, dtype alpha, const vtype2 &v2, TAutoDiffVector< dtype > &v)
Set v = v1 + alpha * v2.
Definition: tadvector.hpp:518
void Randomize(int seed=0)
Set random values in the vector.
Definition: tadvector.hpp:619
void SetVector(const vtype &v, int offset)
Definition: tadvector.hpp:478
double b
Definition: lissajous.cpp:42
TAutoDiffVector(const TAutoDiffVector< dtype > &v)
Copy constructor. Allocates a new data array and copies the data.
Definition: tadvector.hpp:57
friend void add(const dtype a, const vtype1 &x, const dtype b, const vtype2 &y, TAutoDiffVector< dtype > &z)
Definition: tadvector.hpp:532
TAutoDiffVector & Add(const ivtype a, const vtype &v)
(*this) += a * Va
Definition: tadvector.hpp:455
void Neg()
(*this) = -(*this)
Definition: tadvector.hpp:488
void SetSize(int s)
Resize the vector to size s.
Definition: tadvector.hpp:183
const dtype & operator()(int i) const
Read only access to Vector entries using () for 0-based indexing.
Definition: tadvector.hpp:307
TAutoDiffVector & operator/=(ivtype c)
Definition: tadvector.hpp:404
TAutoDiffVector & operator+=(ivtype v)
Definition: tadvector.hpp:444
OutStream out(std::cout)
Global stream used by the library for standard output. Initially it uses the same std::streambuf as s...
Definition: globals.hpp:66
friend void add(const vtype1 &v1, const vtype2 &v2, TAutoDiffVector< dtype > &v)
Set v = v1 + v2.
Definition: tadvector.hpp:506
friend void add(const dtype a, const vtype1 &x, const vtype2 &y, TAutoDiffVector< dtype > &z)
Definition: tadvector.hpp:548
void SetDataAndSize(dtype *d, int s)
Set the Vector data and size.
Definition: tadvector.hpp:206
void MakeRef(TAutoDiffVector< dtype > &base, int offset)
Reset the Vector to be a reference to a sub-vector of base without changing its current size...
Definition: tadvector.hpp:231
dtype * StealData()
Changes the ownership of the data; after the call the Vector is empty.
Definition: tadvector.hpp:283
TAutoDiffVector & Set(const ivtype a, const vtype &v)
(*this) = a * x
Definition: tadvector.hpp:467
bool OwnsData() const
Read the Vector data (host pointer) ownership flag.
Definition: tadvector.hpp:271
void Load(std::istream &in, int Size)
Load a vector from an input stream.
Definition: tadvector.hpp:156
int Size() const
Returns the size of the vector.
Definition: tadvector.hpp:246
void Swap(TAutoDiffVector< dtype > &other)
Swap the contents of two Vectors.
Definition: tadvector.hpp:497
double a
Definition: lissajous.cpp:41
friend void subtract(const ivtype a, const vtype1 &x, const vtype2 &y, TAutoDiffVector< dtype > &z)
Definition: tadvector.hpp:575
void MakeRef(TAutoDiffVector< dtype > &base, int offset, int size_)
Reset the Vector to be a reference to a sub-vector of base.
Definition: tadvector.hpp:224
TAutoDiffVector & operator*=(ivtype c)
Definition: tadvector.hpp:394
void Load(std::istream &in)
Load a vector from an input stream, reading the size from the stream.
Definition: tadvector.hpp:168
int dim
Definition: ex24.cpp:53
TAutoDiffVector & operator-=(ivtype v)
Definition: tadvector.hpp:424
dtype operator*(const dtype *v) const
Dot product with a dtype * array.
Definition: tadvector.hpp:316
Templated vector data type.
Definition: tadvector.hpp:40
const double alpha
Definition: ex15.cpp:369
void Destroy()
Destroy a vector.
Definition: tadvector.hpp:238
Vector data type.
Definition: vector.hpp:58
dtype Norml1() const
Returns the l_1 norm of the vector.
Definition: tadvector.hpp:686
void Print(std::ostream &os=mfem::out, int width=8) const
Prints vector to stream os with width entries per line.
Definition: tadvector.hpp:592
RefCoord s[3]
TAutoDiffVector(dtype *_data, int _size)
Creates a vector referencing an array of doubles, owned by someone else.
Definition: tadvector.hpp:120
TAutoDiffVector(const Vector &v)
Definition: tadvector.hpp:78
TAutoDiffVector< dtype > & operator=(const TAutoDiffVector< dtype > &v)
Copy assignment.
Definition: tadvector.hpp:362
dtype operator*(const Vector &v) const
Definition: tadvector.hpp:338
dtype Normlinf() const
Returns the l_infinity norm of the vector.
Definition: tadvector.hpp:676
dtype & Elem(int i)
Access Vector entries. Index i = 0 .. size-1.
Definition: tadvector.hpp:291