[Dune] dune-common r5260 - trunk/common

Oliver Sander sander at mi.fu-berlin.de
Mon Sep 15 14:03:10 CEST 2008


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