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)

vec(2rheolef)                                                       rheolef-6.1                                                      vec(2rheolef)

NAME

       vec - vector in distributed environment (rheolef-6.1)

SYNOPSYS

       STL-like vector container for a sequential or distributed memory machine model.  Additional operation fom classical algebra.

EXAMPLE

       A sample usage of the class is:

            int main(int argc, char**argv) {
               environment distributed(argc, argv);
               vec<double> x(100, 3.14);
               dout << x << endl;
            }

IMPLEMENTATION NOTE

       Implementation use array<T,M>.

IMPLEMENTATION

       template <class T, class M = rheo_default_memory_model>
       class vec : public array<T, M> {
       public:

       // typedef:

           typedef array<T, M> base;
           typedef typename base::size_type                         size_type;
           typedef std::ptrdiff_t                                   difference_type;
       #ifdef TODO
           // pb compile avec boost sur foehn:
           typedef typename base::difference_type                   difference_type;
       #endif // TODO
           typedef basic_range<size_type, difference_type>          range_type;
           typedef typename base::reference                         reference;
           typedef typename base::const_reference                   const_reference;
           typedef typename base::iterator                          iterator;
           typedef typename base::const_iterator                    const_iterator;

       // allocator/deallocator:

           vec (const distributor& ownership,
               const T&  init_val = std::numeric_limits<T>::max());

           vec(size_type dis_size = 0,
               const T&  init_val = std::numeric_limits<T>::max());

           void resize (
               const distributor& ownership,
               const T&  init_val = std::numeric_limits<T>::max());

           void resize (
               size_type size = 0,
               const T&  init_val = std::numeric_limits<T>::max());

       // accessors:

           const_reference operator[] (size_type i) const;
           reference       operator[] (size_type i);

           T max_abs () const;

       // range:

           vec(const vec_range<T,M>& vr);
           vec(const vec_range_const<T,M>& vr);
           vec<T,M>& operator= (const vec_range<T,M>& vr);
           vec<T,M>& operator= (const vec_range_const<T,M>& vr);

           vec_range_const<T,M> operator[] (const range_type& r) const;
           vec_range<T,M>       operator[] (const range_type& r);

       // assignment to a constant:

           vec<T,M>& operator= (const int& expr);
           vec<T,M>& operator= (const T& expr);

       // expression template:

           template<typename Expr>
           vec (const Expr& expr);

           template<typename Expr>
           vec<T,M>& operator= (const vec_expr<Expr>& expr);

           template<typename Expr>
           vec<T,M>& operator+= (const Expr& expr);

           template<typename Expr>
           vec<T,M>& operator-= (const Expr& expr);

       // initializer list (c++ 2011):

       #ifdef _RHEOLEF_HAVE_STD_INITIALIZER_LIST
           vec (const std::initializer_list<vec_concat_value<T,M> >& init_list);
           vec<T,M>& operator= (const std::initializer_list<vec_concat_value<T,M> >& init_list);
       #endif // _RHEOLEF_HAVE_STD_INITIALIZER_LIST
       };

rheolef-6.1                                                         rheolef-6.1                                                      vec(2rheolef)