[Dune] dune-common r5260 - trunk/common
Oliver Sander
sander at mi.fu-berlin.de
Tue Sep 16 10:19:27 CEST 2008
How about something like
if (N==0)
p[0] = 0;
in the constructors? That way the memory in question gets initialized.
The conditional is known at compile time and will be optimized away.
:-)
Oliver
Martin Nolte schrieb:
> Of course there is: Derive FieldVector from a unified container (only
> implementing operator[] and specialize that. Have fun!
>
> Cheers,
>
> Martin
>
> Oliver Sander wrote:
>> Wow! That is a lot of code just to get rid of a warning. Isn't there
>> a simpler way for this?
>>
>> --
>> Oliver
>>
>> mnolte at dune-project.org schrieb:
>>> Author: mnolte
>>> Date: 2008-08-05 10:35:58 +0200 (Tue, 05 Aug 2008)
>>> New Revision: 5260
>>>
>>> Modified:
>>> trunk/common/fvector.hh
>>> Log:
>>> specialize FieldVector< K, 0 > (no content)
>>>
>>> without the specialization you could get a warning that p[ 0 ] is used
>>> uninitialized.
>>>
>>>
>>> Modified: trunk/common/fvector.hh
>>> ===================================================================
>>> --- trunk/common/fvector.hh 2008-08-01 23:22:34 UTC (rev 5259)
>>> +++ trunk/common/fvector.hh 2008-08-05 08:35:58 UTC (rev 5260)
>>> @@ -285,31 +285,19 @@
>>> };
>>> #endif
>>>
>>> -#ifdef DUNE_EXPRESSIONTEMPLATES
>>> - /** \brief Construct a vector space out of a tensor product of
>>> fields.
>>>
>>> - K is the field type (use float, double, complex, etc) and n
>>> - is the number of components.
>>> -
>>> - It is generally assumed that K is a numerical type compatible
>>> with double
>>> - (E.g. norms are always computed in double precision).
>>> -
>>> - */
>>> - template<class K, int SIZE>
>>> - class FieldVector
>>> - : public Dune::ExprTmpl::Vector< FieldVector<K,SIZE> >
>>> -#else
>>> /** \brief Construct a vector space out of a tensor product of
>>> fields.
>>> -
>>> - K is the field type (use float, double, complex, etc) and SIZE
>>> - is the number of components.
>>> -
>>> - It is generally assumed that K is a numerical type compatible
>>> with double
>>> - (E.g. norms are always computed in double precision).
>>> -
>>> - */
>>> - template<class K, int SIZE>
>>> + *
>>> + * K is the field type (use float, double, complex, etc) and
>>> SIZE + * is the number of components.
>>> + * + * It is generally assumed that K is a numerical type
>>> compatible with double
>>> + * (E.g. norms are always computed in double precision).
>>> + */
>>> + template< class K, int SIZE >
>>> class FieldVector
>>> +#ifdef DUNE_EXPRESSIONTEMPLATES
>>> + : public Dune :: ExprTmpl :: Vector< FieldVector< K, SIZE > >
>>> #endif
>>> {
>>> public:
>>> @@ -725,17 +713,14 @@
>>> // forward declarations
>>> template<class K, int n, int m> class FieldMatrix;
>>>
>>> +
>>> + + /** \brief Vectors containing only one component
>>> + */
>>> + template< class K >
>>> + class FieldVector< K, 1 >
>>> #ifdef DUNE_EXPRESSIONTEMPLATES
>>> - /**! Vectors containing only one component
>>> - */
>>> - template<class K>
>>> - class FieldVector<K,1>
>>> - : public Dune::ExprTmpl::Vector< FieldVector<K,1> >
>>> -#else
>>> - /**! Vectors containing only one component
>>> - */
>>> - template<class K>
>>> - class FieldVector<K,1>
>>> + : public Dune :: ExprTmpl :: Vector< FieldVector< K, 1 > >
>>> #endif
>>> {
>>> enum { n = 1 };
>>> @@ -1067,6 +1052,354 @@
>>> #endif
>>>
>>>
>>> +
>>> +
>>> + /** \brief Vectors containing zero components
>>> + */
>>> + template< class K >
>>> + class FieldVector< K, 0 >
>>> +#ifdef DUNE_EXPRESSIONTEMPLATES
>>> + : public Dune :: ExprTmpl :: Vector< FieldVector< K, 0 > >
>>> +#endif
>>> + {
>>> + public:
>>> + // remember size of vector + enum { dimension = 0 };
>>> +
>>> + //===== type definitions and constants
>>> +
>>> + //! export the type representing the field
>>> + typedef K field_type;
>>> +
>>> + //! export the type representing the components
>>> + typedef K block_type;
>>> +
>>> + //! The type used for the index access and size operation
>>> + typedef std :: size_t size_type;
>>> + + //! We are at the leaf of the block recursion
>>> + enum
>>> + {
>>> + //! The number of block levels we contain
>>> + blocklevel = 1
>>> + };
>>> +
>>> + //! export size
>>> + enum
>>> + {
>>> + //! The size of this vector.
>>> + size = 0
>>> + };
>>> +
>>> + //! Constructor making uninitialized vector
>>> + FieldVector ()
>>> + {}
>>> +
>>> + //! Constructor making vector with identical coordinates
>>> + inline explicit FieldVector ( const K &t );
>>> +
>>> +#ifdef DUNE_EXPRESSIONTEMPLATES
>>> + template< class E >
>>> + inline FieldVector ( Dune :: ExprTmpl :: Expression< E > op );
>>> + + template< class V >
>>> + inline FieldVector ( const Dune :: ExprTmpl :: Vector< V > &op );
>>> +#endif
>>> +
>>> + //! Assignment operator for scalar
>>> + inline FieldVector &operator= ( const K &k );
>>> +
>>> +#ifdef DUNE_EXPRESSIONTEMPLATES
>>> + template< class E >
>>> + inline FieldVector &operator= ( Dune :: ExprTmpl :: Expression<
>>> E > op );
>>> +
>>> + template< class V >
>>> + inline FieldVector &operator= ( const Dune :: ExprTmpl ::
>>> Vector< V > &op );
>>> +#endif
>>> +
>>> + //! random access + K &operator[] ( size_type i )
>>> + {
>>> + DUNE_THROW( MathError, "Index out of Range" );
>>> + }
>>> +
>>> + //! read only random access + const K &operator[] (
>>> size_type i ) const
>>> + {
>>> + DUNE_THROW( MathError, "Index out of Range" );
>>> + }
>>> +
>>> + //! Iterator class for sequential access
>>> + typedef FieldIterator< FieldVector< K, 0 >, K > Iterator;
>>> + //! typedef for stl compliant access
>>> + typedef Iterator iterator;
>>> +
>>> + //! begin iterator
>>> + Iterator begin ()
>>> + {
>>> + return Iterator( *this, 0 );
>>> + }
>>> +
>>> + //! end iterator
>>> + Iterator end ()
>>> + {
>>> + return Iterator( *this, size );
>>> + }
>>> +
>>> + //! begin iterator
>>> + Iterator rbegin ()
>>> + {
>>> + return Iterator( *this, size-1 );
>>> + }
>>> +
>>> + //! end iterator
>>> + Iterator rend ()
>>> + {
>>> + return Iterator( *this, -1 );
>>> + }
>>> +
>>> + //! return iterator to given element or end()
>>> + Iterator find ( size_type i )
>>> + {
>>> + return end ();
>>> + }
>>> +
>>> + //! ConstIterator class for sequential access
>>> + typedef FieldIterator< const FieldVector< K, 0 >, const K >
>>> ConstIterator;
>>> + //! typedef for stl compliant access
>>> + typedef ConstIterator const_iterator;
>>> +
>>> + //! begin ConstIterator
>>> + ConstIterator begin () const
>>> + {
>>> + return ConstIterator( *this, 0 );
>>> + }
>>> +
>>> + //! end ConstIterator
>>> + ConstIterator end () const
>>> + {
>>> + return ConstIterator( *this, size );
>>> + }
>>> +
>>> + //! begin ConstIterator
>>> + ConstIterator rbegin () const
>>> + {
>>> + return ConstIterator( *this, size-1 );
>>> + }
>>> +
>>> + //! end ConstIterator
>>> + ConstIterator rend () const
>>> + {
>>> + return ConstIterator( *this, -1 );
>>> + }
>>> +
>>> + //! return iterator to given element or end()
>>> + ConstIterator find ( size_type i ) const
>>> + {
>>> + return end ();
>>> + }
>>> + +#ifndef DUNE_EXPRESSIONTEMPLATES
>>> + //! vector space addition
>>> + FieldVector< K, size > &operator+= ( const FieldVector< K, size
>>> > &y )
>>> + {
>>> + return *this;
>>> + }
>>> +
>>> + //! vector space subtraction
>>> + FieldVector< K, size > &operator-= ( const FieldVector< K, size
>>> > &y )
>>> + {
>>> + return *this;
>>> + }
>>> +
>>> + //! Binary vector addition
>>> + FieldVector< K, size > operator+ ( const FieldVector< K, size >
>>> &b ) const
>>> + {
>>> + FieldVector< K, size > z = *this;
>>> + return (z += b);
>>> + }
>>> +
>>> + //! Binary vector subtraction
>>> + FieldVector< K, size > operator- ( const FieldVector< K, size >
>>> &b) const
>>> + {
>>> + FieldVector< K, size > z = *this;
>>> + return (z -= b);
>>> + }
>>> +
>>> + //! vector space add scalar to all comps
>>> + FieldVector< K, size > &operator+= ( const K &k )
>>> + {
>>> + return *this;
>>> + }
>>> +
>>> + //! vector space subtract scalar from all comps
>>> + FieldVector< K, size > &operator-= ( const K &k )
>>> + {
>>> + return *this;
>>> + }
>>> +
>>> + //! vector space multiplication with scalar + FieldVector<
>>> K, size > &operator*= ( const K &k )
>>> + {
>>> + return *this;
>>> + }
>>> +
>>> + //! vector space division by scalar
>>> + FieldVector< K, size > &operator/= ( const K &k )
>>> + {
>>> + return *this;
>>> + }
>>> +#endif
>>> +
>>> + //! Binary vector comparison
>>> + bool operator== ( const FieldVector< K, size > &y ) const
>>> + {
>>> + return true;
>>> + }
>>> +
>>> + //! vector space axpy operation
>>> + FieldVector< K, size > &axpy ( const K &a, const FieldVector &y )
>>> + {
>>> + return *this;
>>> + }
>>> +
>>> +#ifndef DUNE_EXPRESSIONTEMPLATES
>>> + //! scalar product
>>> + K operator* ( const FieldVector< K, size > &y ) const
>>> + {
>>> + return K( 0 );
>>> + }
>>> +
>>> + //! one norm (sum over absolute values of entries)
>>> + double one_norm () const
>>> + {
>>> + return 0.0;
>>> + }
>>> +
>>> + //! simplified one norm (uses Manhattan norm for complex values)
>>> + double one_norm_real () const
>>> + {
>>> + return 0.0;
>>> + }
>>> +
>>> + //! two norm sqrt(sum over squared values of entries)
>>> + double two_norm () const
>>> + {
>>> + return 0.0;
>>> + }
>>> +
>>> + //! square of two norm (sum over squared values of entries),
>>> need for block recursion
>>> + double two_norm2 () const
>>> + {
>>> + return 0.0;
>>> + }
>>> +
>>> + //! infinity norm (maximum of absolute values of entries)
>>> + double infinity_norm () const
>>> + {
>>> + return 0.0;
>>> + }
>>> +
>>> + //! simplified infinity norm (uses Manhattan norm for complex
>>> values)
>>> + double infinity_norm_real () const
>>> + {
>>> + return 0.0;
>>> + }
>>> +#endif
>>> +
>>> + //! number of blocks in the vector (are of size 1 here)
>>> + size_type N () const
>>> + {
>>> + return size;
>>> + }
>>> +
>>> + //! dimension of the vector space
>>> + size_type dim () const
>>> + {
>>> + return size;
>>> + }
>>> + };
>>> +
>>> +
>>> +
>>> +#ifndef DUNE_EXPRESSIONTEMPLATES
>>> +
>>> + template< class K >
>>> + inline FieldVector< K, 0 > :: FieldVector ( const K &t )
>>> + {}
>>> +
>>> + template< class K >
>>> + inline FieldVector< K, 0 > &
>>> + FieldVector< K, 0 > :: operator= ( const K &k )
>>> + {
>>> + return *this; + }
>>> + +#else
>>> +
>>> + template< class K >
>>> + inline FieldVector< K, 0 > :: FieldVector ( const K &t )
>>> + {
>>> +#ifdef DUNE_VVERBOSE
>>> + Dune::dvverb << INDENT << "FieldVector Copy Constructor Scalar"
>>> << std :: endl;
>>> +#endif
>>> + assignFrom( t );
>>> + }
>>> +
>>> + template< class K >
>>> + template< class E >
>>> + inline FieldVector< K, 0 > :: FieldVector ( Dune :: ExprTmpl ::
>>> Expression< E > op )
>>> + {
>>> +#ifdef DUNE_VVERBOSE
>>> + Dune::dvverb << INDENT << "FieldVector Copy Constructor
>>> Expression" << std :: endl;
>>> +#endif
>>> + assignFrom( op );
>>> + }
>>> +
>>> + template< class K >
>>> + template< class V >
>>> + inline FieldVector< K, 0 > :: FieldVector ( const Dune ::
>>> ExprTmpl :: Vector< V > &op )
>>> + {
>>> +#ifdef DUNE_VVERBOSE
>>> + Dune::dvverb << INDENT << "FieldVector Copy Operator Vector" <<
>>> std :: endl;
>>> +#endif
>>> + assignFrom( op );
>>> + }
>>> +
>>> + template< class K >
>>> + inline FieldVector< K, 0 > &
>>> + FieldVector< K, 0 > :: operator= ( const K &k )
>>> + {
>>> +#ifdef DUNE_VVERBOSE
>>> + Dune::dvverb << INDENT << "FieldVector Assignment Operator
>>> Scalar\n";
>>> +#endif
>>> + assignFrom( k );
>>> + return *this;
>>> + }
>>> +
>>> + template< class K >
>>> + template< class E >
>>> + inline FieldVector< K, 0 > &
>>> + FieldVector< K, 0 > :: operator= ( Dune :: ExprTmpl ::
>>> Expression< E > op )
>>> + {
>>> +#ifdef DUNE_VVERBOSE
>>> + Dune::dvverb << INDENT << "FieldVector Assignment Operator
>>> Expression" << std :: endl;
>>> +#endif
>>> + return assignFrom( op );
>>> + }
>>> +
>>> + template< class K >
>>> + template< class V >
>>> + inline FieldVector< K, 0 > &
>>> + FieldVector< K, 0 > :: operator= ( const Dune :: ExprTmpl ::
>>> Vector< V > &op )
>>> + {
>>> +#ifdef DUNE_VVERBOSE
>>> + Dune::dvverb << INDENT << "FieldVector Assignment Operator
>>> Vector" << std :: endl;
>>> +#endif
>>> + return assignFrom( op );
>>> + }
>>> +#endif
>>> +
>>> /** @} end documentation */
>>>
>>> } // end namespace
>>>
>>>
>>> _______________________________________________
>>> Dune-Commit mailing list
>>> Dune-Commit at dune-project.org
>>> http://lists.dune-project.org/mailman/listinfo/dune-commit
>>>
>>
>>
>
--
************************************************************************
* Oliver Sander ** email: sander at mi.fu-berlin.de *
* Freie Universität Berlin ** phone: + 49 (30) 838 75217 *
* Institut für Mathematik II ** URL : page.mi.fu-berlin.de/~sander *
* Arnimallee 6 ** -------------------------------------*
* 14195 Berlin, Germany ** Member of MATHEON (www.matheon.de) *
************************************************************************
More information about the Dune
mailing list