NAME

       numbering - global degree of freedom numbering

SYNOPSYS

       The  numbering  class defines methods that furnish global numbering of degrees of freedom.
       This numbering depends upon the degrees of polynoms on elements and  upon  the  continuity
       requirement  at  inter-element  boundary.  For instance the "P1" continuous finite element
       approximation has one degree of freedom per vertice of the mesh, while  its  discontinuous
       counterpart  has  dim(basis) times the number of elements of the mesh, where dim(basis) is
       the size of the local finite element basis.

IMPLEMENTATION

       template <class T, class M = rheo_default_memory_model>
       class numbering : public smart_pointer<numbering_rep<T,M> > {
       public:

       // typedefs:

         typedef numbering_rep<T,M> rep;
         typedef smart_pointer<rep> base;
         typedef size_t             size_type;

       // allocators:

         numbering (std::string name = "");
         numbering (numbering_rep<T,M>* ptr);
         ~numbering() {}

       // accessors & modifiers:

         bool is_initialized() const { return base::operator->() != 0; }
         std::string name() const;
         size_type degree () const;
         void set_degree (size_type degree) const;
         bool is_continuous()    const;
         bool is_discontinuous() const { return !is_continuous(); }
         bool has_compact_support_inside_element()    const;
         const basis_basic<T>& get_basis() const { return base::data().get_basis(); }

         size_type     ndof   (const geo_size& gs, size_type map_dim) const;
         size_type dis_ndof   (const geo_size& gs, size_type map_dim) const;
         void      dis_idof   (const geo_size& gs, const geo_element& K, std::vector<size_type>& dis_idof) const;
         void set_ios_permutations (const class geo_basic<T,M>& omega,
                       array<size_type,M>&   idof2ios_dis_idof,
                       array<size_type,M>&   ios_idof2dis_idof) const;

       // comparator:

         bool operator== (const numbering<T,M>& y) const {
               if (! is_initialized() && ! y.is_initialized()) return true;
               if (! is_initialized() || ! y.is_initialized()) return false;
               return name() == y.name();
         }
       // i/o:

         void dump(std::ostream& out = std::cerr) const;
       };