Thyra ANA Operator/VectorBase Interfaces and Related Software: Thyra::ExplicitMutableVectorView< Scalar

List of all members.


Public Member Functions
	ExplicitMutableVectorView (VectorBase< Scalar > &v, const Range1D &rng=Range1D(), const bool forceUnitStride=false)
	Construct an explicit mutable (non-const) view of a subset of elements.
	~ExplicitMutableVectorView ()
	Commits back the the explicit view on the `VectorBase` object `v` passed to `ExplicitMutableVectorView()`.
const RTOpPack::MutableSubVectorT< Scalar > &	sv () const
	Returns the explicit view as an `RTOpPack::SubVectorT<Scalar>` object.
RTOp_index_type	globalOffset () const
	Returns the global offset for the explicit view.
RTOp_index_type	subDim () const
	Returns the dimension of the explicit view.
Scalar *	values () const
	Return a pointer to a `Scalar` array containing the explicit view.
ptrdiff_t	stride () const
	Return the stride between elements in the array returned from `this->values()`.
Scalar &	operator[] (RTOp_index_type i) const
	Zero-based indexing: Preconditions: `values()!=NULL && (0 <= i <= subDim()-1)`.
Scalar &	operator() (RTOp_index_type i) const
	One-based indexing: Preconditions: `values()!=NULL && (1 <= i <= subDim())`.

Detailed Description

template<class Scalar>
class Thyra::ExplicitMutableVectorView< Scalar >

This utility class makes it easy to explicitly access a contiguous subset of elements in any VectorBase object and change the VectorBase object.

Warning! Creating an explicit view of an arbitrary VectorBase object may be a very expensive operation (such as with distributed-memory vectors) and should only be done in special cases (such as when the vector is an in-core vector). There several specialized use cases where creating these types of explicit views are necessary but in most cases this should not be done.

The following functions show four different ways to access a range of elements from in any VectorBase object and then add to them the values form a raw C++ array.

 //
 // Add-to using unit-strided pointer access
 //
 template<class Scalar>
 void addToArrayPointerUnit(
   const Thyra::Range1D            &rng
   ,const Scalar                   x[]   // Size == rng.size()
   ,Thyra::VectorBase<Scalar>      *v
   )
 {
    Thyra::ExplicitMutableVectorView<Scalar> v_ev(rng,*v,true);  // Force unit stride
    const Scalar *v_ptr = v_ev.values();                         // Get pointer to unit-stride data
    for( int k = 0; k < n; ++k )                                 // For each element in view:
      v_ptr[k] += x[k];                                          //   Add-to elements
    // When this function returns then v_ev will be destroyed and the view will be committed back and *v modified
 }

 //
 // Add-to using non-unit-strided pointer access
 //
 template<class Scalar>
 void addToArrayPointerNonunit(
   const Thyra::Range1D          &rng
   ,const Scalar                 x[]   // Size == rng.size()
   ,Thyra::VectorBase<Scalar>    *v
   )
 {
    Thyra::ExplicitMutableVectorView<Scalar> v_ev(rng,*v);   // Allow non-unit stride
    const Scalar          *v_ptr    = v_ev.values();         // Get pointer to non-unit-stride data
    const Thyra::Index  *v_stride = v_ev.stride();           // Get stride between vector data
    for( int k = 0; k < rng.size(); ++k, v_ptr += v_stride ) // For each element in view:
      *v_ptr + x[k];                                         //   Add-to elements
    // When this function returns then v_ev will be destroyed and the view will be committed back and *v modified
 }

 //
 // Add-to using possibly non-unit stride with zero-based overloaded function operator[]()
 //
 template<class Scalar>
 void addToArrayZeroBasedOperator(
   const Thyra::Range1D          &rng
   ,const Scalar                 x[]   // Size == rng.size()
   ,Thyra::VectorBase<Scalar>    *v
   )
 {
    Thyra::ExplicitMutableVectorView<Scalar> v_ev(rng,*v);   // Allow non-unit stride 
    for( int k = 0; k < rng.size(); ++k )                    // For each element in view:
      v_ev[k] += x[k];                                       //   Add-to elements using operator[]()
    // When this function returns then v_ev will be destroyed and the view will be committed back and *v modified
 }

 //
 // Add-to using possibly non-unit stride with one-based overloaded function operator()()
 //
 template<class Scalar>
 void addToArrayOneBasedOperator(
   const Thyra::Range1D          &rng
   ,const Scalar                 x[]   // Size == rng.size()
   ,Thyra::VectorBase<Scalar>    *v
   )
 {
    Thyra::ExplicitMutableVectorView<Scalar> v_ev(rng,*v); // Allow non-unit stride 
    for( int k = 0; k < rng.size(); ++k )                  // For each element in view:
      v_ev(k+1) += x[k];                                   //   Add-to elements using operator()()
    // When this function returns then v_ev will be destroyed and the view will be committed back and *v modified
 }

If one wants to only read the elements in a VectorBase object then one should use the utility class ExplicitVectorView.

The default constructor, copy constructor and assignment operators are not allowed.

Constructor & Destructor Documentation

template<class Scalar>
Thyra::ExplicitMutableVectorView< Scalar >::ExplicitMutableVectorView	(	VectorBase< Scalar > &	v,
		const Range1D &	rng = `Range1D()`,
		const bool	forceUnitStride = `false`
	)	`[inline]`

Construct an explicit mutable (non-const) view of a subset of elements.

Parameters:

	v	[in] The vector that a view will be taken. This object must be maintained until `this` is destroyed. The elements in `v` are not guaranteed to be updated until `this` is destroyed.
	rng	[in] the range of element indices that the explicit view will be taken.
	forceUnitStride	[in] If `true` then the view will have unit stride.

Preconditions:

[rng.full_range()==false] rng.ubound() <= v.space()->dim()

Postconditions:

this->sv() returns the created view
this->globalOffset()==rng.lbound()-1
this->subDim()==rng.size()
this->values() returns a pointer to a Scalar array
this->stride() returns the stride between the elements pointed it in this->values()
[forceUnitStride==true] this->stride()==1

Definition at line 325 of file Thyra_ExplicitVectorView.hpp.

Thyra::ExplicitMutableVectorView< Scalar > Class Template Reference
[Thyra Operator/Vector Interfaces as an API for the Development of Abstract Numerical Algorithms (ANAs)]

Public Member Functions

Detailed Description

template<class Scalar>
class Thyra::ExplicitMutableVectorView< Scalar >

Constructor & Destructor Documentation

Member Function Documentation

Thyra::ExplicitMutableVectorView< Scalar > Class Template Reference [Thyra Operator/Vector Interfaces as an API for the Development of Abstract Numerical Algorithms (ANAs)]

Public Member Functions

Detailed Description

template<class Scalar> class Thyra::ExplicitMutableVectorView< Scalar >

Constructor & Destructor Documentation

Member Function Documentation

Thyra::ExplicitMutableVectorView< Scalar > Class Template Reference
[Thyra Operator/Vector Interfaces as an API for the Development of Abstract Numerical Algorithms (ANAs)]

template<class Scalar>
class Thyra::ExplicitMutableVectorView< Scalar >