GNU.WIKI: The GNU/Linux Knowledge Base

  [HOME] [PHP Manual] [HowTo] [ABS] [MAN1] [MAN2] [MAN3] [MAN4] [MAN5] [MAN6] [MAN7] [MAN8] [MAN9]

  [0-9] [Aa] [Bb] [Cc] [Dd] [Ee] [Ff] [Gg] [Hh] [Ii] [Jj] [Kk] [Ll] [Mm] [Nn] [Oo] [Pp] [Qq] [Rr] [Ss] [Tt] [Uu] [Vv] [Ww] [Xx] [Yy] [Zz]


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
       reference  elements  and orders are yet implemented. This class will be
       completed in the future.

IMPLEMENTATION

       template<class T>
       class quadrature : public smart_pointer<quadrature_rep<T> > {
       public:

       // typedefs:

           typedef quadrature_rep<T>              rep;
           typedef smart_pointer<rep>             base;
           typedef typename rep::size_type        size_type;
           typedef typename rep::family_type      family_type;
           typedef typename rep::const_iterator   const_iterator;
           typedef typename rep::orientation_type orientation_type;

       // allocators:

           quadrature (quadrature_option_type opt = quadrature_option_type())
            : base(new_macro(rep(opt))) {}

       // modifiers:

           void set_order  (size_type order) { base::data().set_order(order); }
           void set_family (family_type ft)  { base::data().set_family(ft); }

       // accessors:

           size_type      get_order() const { return base::data().get_order();}
           family_type    get_family() const { return base::data().get_family();}
           std::string    get_family_name() const { return base::data().get_family_name();}
           const quadrature_option_type& get_options() const { return base::data().get_options(); }
           size_type      size  (reference_element hat_K) const { return base::data().size(hat_K); }
           const_iterator begin (reference_element hat_K) const { return base::data().begin(hat_K); }
           const_iterator end   (reference_element hat_K) const { return base::data().end(hat_K); }
           const weighted_point<T>& operator() (reference_element hat_K, size_type q) const
                                                                { return base::data().operator() (hat_K,q); }
           template<class U>
           friend std::ostream& operator<< (std::ostream& os, const quadrature<U>& q) {
               return os << q.data(); }

       // side accessor:

           void side_initialize (
               reference_element             tilde_K,
               size_type                     loc_isid,
               reference_element             hat_S,
               size_type                     shift,
               orientation_type              orient) const {
                   base::data().side_initialize (tilde_K, loc_isid, hat_S, shift, orient);
           }
       };

SEE ALSO

       reference_element(2)



  All copyrights belong to their respective owners. Other content (c) 2014-2017, GNU.WIKI. Please report site errors to webmaster@gnu.wiki.
Page load time: 0.172 seconds. Last modified: November 09 2017 18:38:06.