/usr/include/deal.II/lac/vector_view.h is in libdeal.ii-dev 6.3.1-1.1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 | //---------------------------------------------------------------------------
// $Id: vector_view.h 19762 2009-10-08 13:06:21Z bangerth $
// Version: $Name$
//
// Copyright (C) 2009 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
// to the file deal.II/doc/license.html for the text and
// further information on this license.
//
//---------------------------------------------------------------------------
#ifndef __dealii__vector_view_h
#define __dealii__vector_view_h
#include <base/config.h>
#include <base/exceptions.h>
#include <base/subscriptor.h>
#include <lac/vector.h>
#include <cstdio>
DEAL_II_NAMESPACE_OPEN
/*! @addtogroup Vectors
*@{
*/
/**
* View of a numerical vector of data. This class provides an
* interface compatible with the Vector<double> class (from which it
* is inherited), that allows fast access to locations of memory
* already allocated with arrays of type Number.
*
* This is in the same style of the vector view in the Trilinos
* library.
*
* You should consider using the VectorView object ONLY when ALL of
* the following requirements are met:
*
* 1. Your application requires a Vector<Number> object.
*
* 2. All you have at your disposal is a Number* pointer.
*
* 3. You are ABSOLUTELY SURE that the above pointer points to a
* valid area of memory of the correct size.
*
* 4. You really believe that making a copy of that memory would be
* too expensive.
*
* 5. You really know what you are doing.
*
* Notice that NO CHECKS are performed on the actual memory, and if
* you try to access illegal areas of memory, your computer will
* suffer from it. Once again, use this class ONLY if you know exactly
* what you are doing.
*
* Two constructors are provided. One for read-write access, and one
* for read only access, and you are allowed to use this class on
* objects of type const Number*. However you should be aware of the
* fact that the constness of the array pointed to is ignored, which
* means that you should only use the const constructor when the
* actual object you are constructing is itself a constant object.
* As a corollary, you will be allowed to call even functions of
* the base class that change data of the array; this being a violation
* of the C++ type model, you should make sure that this only happens
* if it is really valid and, in general, if
* you know what you are doing.
*
* Since this class does not own the memory that you are accessing,
* you have to make sure that the lifetime of the section of memory you
* are viewing is longer than this object. No attempt is made to
* ensure that this is the case.
*
* An example usage of this class is the following:
*
@code
// Create an array of length 5;
double * array = new double[5];
// Now create a view of the above array that is compatible with the
// Vector<double> class
VectorView<double> view(5, array);
view(1) = 4;
// The following line should output 4.
cout << array[1] << endl;
// If debug mode is on, then the following triggers an execption:
view(6) = 4;
// But notice that no checks are performed, so this is legal but WILL
// NOT work
VectorView<double> wrong_view(10, array);
// Now no assert will be thrown if you type wrong_view(6), but most
// likely a seg fault will occur.
view(6) = 4;
// Notice that this construction is legal. It will create a copy of
// the array.
const Vector<double> const_copy(view);
// Now this is the correct way to instantiate a constant view of the
// above vector:
const VectorView<double> correct_const_copy_view(5, const_copy.begin());
// While this will compile, BUT WILL NOT COMPLAIN if you try to write
// on it!
VectorView<double> wrong_const_copy_view(5, const_copy.begin());
// Now writing to elements of wrong_const_copy_view is allowed, and
// will change the same memory as the const_copy object.
wrong_const_copy_view(1) = 5;
if(copy_view(1) == wrong_const_copy_view(1)) cout << "Tautology";
@endcode
*
*
* @note Instantiations for this template are provided for
* <tt>@<float@>, @<double@>, @<long double@>,
* @<std::complex@<float@>@>, @<std::complex@<double@>@>,
* @<std::complex@<long double@>@></tt>; others can be generated in
* application programs (see the section on @ref Instantiations in the
* manual).
*
* @author Luca Heltai, 2009
*/
template<typename Number>
class VectorView : public Vector<Number>
{
public:
/**
* Read write constructor. Takes the size
* of the vector, just like the standard
* one, but the data is picked starting
* from the location of the pointer @p
* ptr.
*/
VectorView(const unsigned int new_size, Number *ptr);
/**
* The constant constructor is the same
* as above, however you will not be able
* to access the data for write access.
*
* You should only use this class by
* constructing it as a const
* VectorView<double>(size, ptr) object.
*
* Undefined behavior will occur if you
* construct it as a non const object or
* attempt to write on it.
*/
VectorView(const unsigned int new_size, const Number *ptr);
/**
* This desctructor will only reset the
* internal sizes and the internal
* pointers, but it will NOT clear the
* memory. */
~VectorView();
/**
* Implicit cast to const
* Vector<Number>. This cast
* allows the use of this object
* everywhere a const
* Vector<double> is required.
*/
operator const Vector<Number> &() const;
/**
* The reinit function of this object has
* a behavior which is different from the
* one of the base class. VectorView does
* not handle memory, and you should not
* attempt to resize the memory that is
* pointed to by this object using the
* reinit function. You can, however,
* resize the view that you have of the
* original object. Notice that it is
* your own responsability to ensure that
* the memory you are pointing to is big
* enough.
*
* Similarly to what happens in the base
* class, if fast is false, then the
* entire content of the vector is set to
* 0, otherwise the content of the memory
* is left unchanged.
*
* Notice that the following snippet of
* code may not produce what you expect:
*
* @code
* // Create a vector of length 1.
* Vector<double> long_vector(1);
*
* // Make a view of it
* VectorView<double> view_of_long_vector(1, long_vector.begin());
*
* // Resize the original vector to a bigger size
* long_vector.reinit(100);
*
* // And the view, leaving the memory untouched
* view_of_long_vector.reinit(100, true);
* @endcode
*
* In the above case, the
* Vector<double>::reinit method is
* called, and a NEW area of memory is
* reserved, possibly not starting at the
* same place as before. Hoever, the
* VectorView<double> object keeps
* pointing to the same old area. After
* the two reinits, any call to
* view_of_long_vector(i), with i>0 might
* cause an attempt to access invalid
* areas of memory, or might function
* properly, depending on wether or not
* the system was able to allocate some
* memory consecutively after the
* original allocation.
*
* In any case, you should not rely on
* this behavior, and you should only
* call this reinit function if you
* really know what you are doing.
*/
virtual void reinit (const unsigned int N,
const bool fast=false);
/** This reinit function is
equivalent to constructing a
new object with the given
size, starting from the
pointer ptr. */
void reinit(const unsigned int N, Number * ptr);
/** This reinit function is
equivalent to constructing a
new object with the given
size, starting from the
pointer ptr. The same
considerations made for the
constructor apply here. */
void reinit(const unsigned int N, const Number * ptr);
/**
* This function is here to prevent
* memory corruption. It should never be
* called, and will throw an exception if
* you try to do so. */
virtual void swap (Vector<Number> &v);
};
/*@}*/
/*----------------------- Inline functions ----------------------------------*/
#ifndef DOXYGEN
template<typename Number>
inline
VectorView<Number>::VectorView(const unsigned int new_size, Number * ptr)
{
this->vec_size = new_size;
this->max_vec_size = new_size;
this->val = ptr;
}
template<typename Number>
inline
VectorView<Number>::VectorView(const unsigned int new_size, const Number * ptr)
{
this->vec_size = new_size;
this->max_vec_size = new_size;
this->val = const_cast<Number*>(ptr);
}
template<typename Number>
inline
VectorView<Number>::~VectorView()
{
// avoid that the base class releases
// memory it doesn't own
this->vec_size = 0;
this->max_vec_size = 0;
this->val = 0;
}
template<typename Number>
inline
VectorView<Number>::operator const Vector<Number> &() const
{
return static_cast<const Vector<Number> &> (*this);
}
template<typename Number>
inline
void VectorView<Number>::reinit(const unsigned int N, const bool fast)
{
this->vec_size = N;
this->max_vec_size = N;
if(fast == false)
Vector<Number>::operator=(static_cast<Number>(0));
}
template<typename Number>
inline
void VectorView<Number>::reinit(const unsigned int new_size, Number * ptr)
{
this->vec_size = new_size;
this->max_vec_size = new_size;
this->val = ptr;
}
template<typename Number>
inline
void VectorView<Number>::reinit(const unsigned int new_size, const Number * ptr)
{
this->vec_size = new_size;
this->max_vec_size = new_size;
this->val = const_cast<Number*>(ptr);
}
template<typename Number>
inline
void VectorView<Number>::swap(Vector<Number> &)
{
AssertThrow(false, ExcMessage("Cant' swap a VectorView with a Vector!"));
}
#endif
DEAL_II_NAMESPACE_CLOSE
#endif
|