quadrature(7rheolef) [debian man page]

quadrature(7rheolef)						    rheolef-6.1 					      quadrature(7rheolef)

NAME

       quadrature - quadrature formulae on the reference lement

SYNOPSYS

       The  quadrature	class  defines	a container for a quadrature formulae on the reference element (see reference_element(2)).  This container
       stores the nodes coordinates and the weights.

THE CONSTRUCTOR TAKES TWO ARGUMENTS

	the reference element K and the order r of the quadrature formulae.  The formulae is exact when computing the integral of a polynom p that
       degree is less or equal to order r.

			 n
	   /		___
	   | p(x) dx =	    p(x_q) w_q
	   / K		/__
			q=1

LIMITATIONS

       The formulae is optimal when it uses a minimal number of nodes n.  Optimal quadrature formula are hard-coded in this class.  Not all refer-
       ence elements and orders are yet implemented. This class will be completed in the future.

IMPLEMENTATION

       template<class T>
       class quadrature {
       public:

       // typedefs:

	   typedef typename quadrature_on_geo<T>::size_type		    size_type;
	   typedef quadrature_option_type::family_type			    family_type;
	   typedef typename std::vector<weighted_point<T> >::const_iterator const_iterator;

       // allocators:

	   quadrature (quadrature_option_type opt = quadrature_option_type());

       // modifiers:

	   void set_order  (size_type order);
	   void set_family (family_type ft);

       // accessors:

	   size_type	  get_order() const;
	   family_type	  get_family() const;
	   std::string	  get_family_name() const;
	   size_type	  size	(reference_element hat_K) const;
	   const_iterator begin (reference_element hat_K) const;
	   const_iterator end	(reference_element hat_K) const;
	   template<class U>
	   friend std::ostream& operator<< (std::ostream&, const quadrature<U>&);
       protected:
	   quadrature_option_type	 _options;
	   mutable quadrature_on_geo<T>  _quad [reference_element::max_variant];
	   mutable std::vector<bool>	 _initialized;
	   void _initialize (reference_element hat_K) const;
       private:
	   quadrature (const quadrature<T>&);
	   quadrature operator= (const quadrature<T>&);
       };

SEE ALSO

       reference_element(2)

rheolef-6.1							    rheolef-6.1 					      quadrature(7rheolef)

Vector(7rheolef)						    rheolef-6.1 						  Vector(7rheolef)

NAME

       Vector - STL vector<T> with reference counting

DESCRIPTION

	The class implement a reference counting wrapper for
	the STL vector<T> container class, with shallow copies.
	See also:
	@quotation The Standard Template Library, by Alexander Stephanov and Meng Lee.
	@end quotation

	This class provides the full vector<T>
	interface specification
	an could be used instead of vector<T>.

NOTE

	The write accessors

	       T& operator[](size_type)

	as in v[i]
	may checks the reference count for each access.
	For a loop, a better usage is:

	     Vector<T>::iterator i = v.begin();
	     Vector<T>::iterator last = v.end();
	     while (i != last) { ...}

	and the reference count check step occurs only two time,
	when accessing via begin() and end().

	Thus, in order to encourage users to do it, we declare private
	theses member functions. A synonym of operator[] is at.

IMPLEMENTATION

       template<class T>
       class Vector : private smart_pointer<vector_rep<T> > {

       public:

       // typedefs:

	   typedef iterator;
	   typedef const_iterator;
	   typedef pointer;
	   typedef reference;
	   typedef const_reference;
	   typedef size_type;
	   typedef difference_type;
	   typedef value_type;
	   typedef reverse_iterator;
	   typedef const_reverse_iterator;

       // allocation/deallocation:

	   explicit Vector (size_type n = 0, const T& value = T ());
	   Vector (const_iterator first, const_iterator last);
	   void reserve (size_type n);
	   void swap (Vector<T>& x) ;

       // accessors:

	   iterator		    begin ();
	   const_iterator	    begin () const;
	   iterator		    end ();
	   const_iterator	    end ()   const;
	   reverse_iterator	    rbegin();
	   const_reverse_iterator   rbegin() const;
	   reverse_iterator	    rend();
	   const_reverse_iterator   rend() const;
	   size_type size () const;
	   size_type max_size () const;
	   size_type capacity () const;
	   bool empty () const;
	   void resize (size_type sz, T v = T ()); // non-standard ?
       private:
	   const_reference operator[] (size_type n) const;
	   reference operator[] (size_type n);
       public:
	   const_reference at (size_type n) const; // non-standard ?
	   reference at (size_type n);
	   reference	     front ();
	   const_reference   front () const;
	   reference	     back ();
	   const_reference   back ()  const;

       // insert/erase:

	   void push_back (const T& x);
	   iterator insert (iterator position, const T& x = T ());
	   void insert (iterator position, size_type n, const T& x);
	   void insert (iterator position, const_iterator first, const_iterator last);
	   void pop_back ();
	   void erase (iterator position);
	   void erase (iterator first, iterator last);
       };

rheolef-6.1							    rheolef-6.1 						  Vector(7rheolef)