Clean interface + Inline doxygen

FunctionSpace/Basis.h

@@ -22,62 +22,52 @@ class Basis{
   int dim;
 
  public:
+  //! Deletes this Basis
+  //!
   virtual ~Basis(void);
-  
+
+  //! @return Returns the @em polynomial @em order of the Basis
   int getOrder(void) const;
+
+  //! @return Returns the @em type of the Basis:
+  //! @li 0 for 0-form
+  //! @li 1 for 1-form
+  //! @li 2 for 2-form
+  //! @li 3 for 3-form
+  //! @todo Check if the 'form numbering' is good
   int getType(void) const;
+  
+  //! @return Returns the number of Polynomial%s 
+  //! (or Vector%s of Polynomial%s) in the Basis
   int getSize(void) const;
+
+  //! @return Returns the node number of 
+  //! the @em geometric @em reference @em element
   int getNodeNbr(void) const;
+
+  //! @return Returns the @em dimension 
+  //! (1D, 2D or 3D) of the Basis
   int getDim(void) const;
-  
+
+  //! @return Returns:
+  //! @li @c true, if this is a 
+  //! @em scalar Basis (BasisScalar)
+  //! @li @c false, if this is a
+  //! @em vectorial Basis (BasisVector)
+  //!
+  //! @note
+  //! Scalar basis are sets of 
+  //! Polynomial%s@n
+  //! Vectorial basis are sets of 
+  //! Vector%s of Polynomial%s  
   bool isScalar(void) const;
 
  protected:
+  //! Instantiate a new Basis
+  //! @warning Users can't instantiate a Basis
   Basis(void);
 };
 
-/**
-   @fn Basis::~Basis(void)
-   @return Deletes this Basis
-
-   @fn int Basis::getOrder(void) const
-   @return Returns the @em polynomial @em order of the Basis
-
-   @fn int Basis::getType(void) const
-   @return Returns the @em type of the Basis:
-   @li 0 for 0-form
-   @li 1 for 1-form
-   @li 2 for 2-form
-   @li 3 for 3-form
-
-   @todo Check if the 'form numbering' is good
-   
-   @fn int Basis::getSize(void) const
-   @return Returns the number of Polynomial%s 
-   (or Vector%s of Polynomial%s) in the Basis
-
-   @fn int Basis::getNodeNbr(void) const
-   @return Returns the node number of 
-   the @em geometric @em reference @em element
- 
-   @fn int Basis::getDim(void) const
-   @return Returns the @em dimension 
-   (1D, 2D or 3D) of the Basis
-
-   @fn bool Basis::isScalar(void) const
-   @return Returns:
-   @li @c true, if this is a 
-   @em scalar Basis (BasisScalar)
-   @li @c false, if this is a
-   @em vectorial Basis (BasisVector)
-
-   @note
-   Scalar basis are sets of 
-   Polynomial%s@n
-   Vectorial basis are sets of 
-   Vector%s of Polynomial%s
-*/
-
 //////////////////////
 // Inline Functions //
 //////////////////////

FunctionSpace/BasisScalar.h

 #ifndef _BASISSCALAR_H_
 #define _BASISSCALAR_H_
 
+#include <vector>
 #include "Basis.h"
 #include "Polynomial.h"
 
@@ -15,33 +16,29 @@
 
 class BasisScalar: public Basis{
  protected:
-  Polynomial* basis;
+  std::vector<Polynomial>* basis;
 
  public:
+  //! Deletes this BasisScalar
+  //!
   virtual ~BasisScalar(void);
-
-  Polynomial* getBasis(void) const;
+  
+  //! @return Returns the set of @em Polynomial%s
+  //! defining this (scalar) Basis
+  const std::vector<Polynomial>& getBasis(void) const;
 
  protected:
+  //! Instantiate a new BasisScalar
+  //! @warning Users can't instantiate a BasisScalar
   BasisScalar(void);
 };
 
-/**
-   @fn BasisScalar::~BasisScalar
-   @return Deletes this Basis
-
-   @fn BasisScalar::getBasis
-   @return Returns the set of 
-   @em Polynomial%s
-   that defines this Basis
-*/
-
 //////////////////////
 // Inline Functions //
 //////////////////////
 
-inline Polynomial* BasisScalar::getBasis(void) const{
-  return basis;
+inline const std::vector<Polynomial>& BasisScalar::getBasis(void) const{
+  return *basis;
 }
 
 #endif

FunctionSpace/BasisVector.h

@@ -16,33 +16,29 @@
 
 class BasisVector: public Basis{
  protected:
-  std::vector<Polynomial>* basis;
+  std::vector<std::vector<Polynomial> >* basis;
 
  public:
+  //! Deletes this BasisVector
+  //!
   virtual ~BasisVector(void);
 
-  std::vector<Polynomial>* getBasis(void) const;
+  //! @return Returns the set of @em Polynomial%s
+  //! defining this (vectorial) Basis
+  const std::vector<std::vector<Polynomial> >& getBasis(void) const;
 
  protected:
+  //! Instantiate a new BasisVector
+  //! @warning Users can't instantiate a BasisVector
   BasisVector(void);
 };
 
-/**
-   @fn BasisVector::~BasisVector
-   @return Deletes this Basis
-
-   @fn BasisVector::getBasis
-   @return Returns the set of 
-   @em Vector%s @em of @em Polynomial%s
-   that defines this Basis
-*/
-
 //////////////////////
 // Inline Functions //
 //////////////////////
 
-inline std::vector<Polynomial>* BasisVector::getBasis(void) const{
-  return basis;
+inline const std::vector<std::vector<Polynomial> >& BasisVector::getBasis(void) const{
+  return *basis;
 }
 
 #endif

FunctionSpace/QuadEdgeBasis.cpp

@@ -74,10 +74,10 @@ QuadEdgeBasis::QuadEdgeBasis(const int order){
 
 
   // Basis //
-  basis = new std::vector<Polynomial>[size];
+  basis = new std::vector<std::vector<Polynomial> >(size);
 
   for(int i = 0; i < size; i++)
-    basis[i].resize(3);
+    (*basis)[i].resize(3);
 
 
   // Edge Based (Nedelec) // 
@@ -85,16 +85,16 @@ QuadEdgeBasis::QuadEdgeBasis(const int order){
   Polynomial oneHalf(0.5, 0, 0, 0);
 
   for(int e = 0; e < 4; e++){
-    basis[i] = 
+    (*basis)[i] = 
       (liftingSub[e]).gradient();
     
-    basis[i][0].mul(lagrangeSum[e]);
-    basis[i][1].mul(lagrangeSum[e]);
-    basis[i][2].mul(lagrangeSum[e]);
+    (*basis)[i][0].mul(lagrangeSum[e]);
+    (*basis)[i][1].mul(lagrangeSum[e]);
+    (*basis)[i][2].mul(lagrangeSum[e]);
 
-    basis[i][0].mul(oneHalf);
-    basis[i][1].mul(oneHalf);
-    basis[i][2].mul(oneHalf);
+    (*basis)[i][0].mul(oneHalf);
+    (*basis)[i][1].mul(oneHalf);
+    (*basis)[i][2].mul(oneHalf);
 
     i++;
   }
@@ -102,7 +102,7 @@ QuadEdgeBasis::QuadEdgeBasis(const int order){
   // Edge Based (High Order) //
   for(int l = 1; l < orderPlus; l++){
     for(int e = 0; e < 4; e++){
-      basis[i] = 
+      (*basis)[i] = 
 	(intLegendre[l].compose(liftingSub[e]) * lagrangeSum[e]).gradient();
      
       i++;
@@ -128,7 +128,7 @@ QuadEdgeBasis::QuadEdgeBasis(const int order){
   // Cell Based (Type 1) //
   for(int l1 = 1; l1 < orderPlus; l1++){
     for(int l2 = 1; l2 < orderPlus; l2++){
-      basis[i] = (iLegendreX[l1] * iLegendreY[l2]).gradient();
+      (*basis)[i] = (iLegendreX[l1] * iLegendreY[l2]).gradient();
 
       i++;
     }
@@ -137,9 +137,9 @@ QuadEdgeBasis::QuadEdgeBasis(const int order){
   // Cell Based (Type 2) //
   for(int l1 = 1; l1 < orderPlus; l1++){
     for(int l2 = 1; l2 < orderPlus; l2++){
-      basis[i][0] =  legendreX[l1] * iLegendreY[l2];
-      basis[i][1] = iLegendreX[l1] *  legendreY[l2] * -1;
-      basis[i][2] = zero;
+      (*basis)[i][0] =  legendreX[l1] * iLegendreY[l2];
+      (*basis)[i][1] = iLegendreX[l1] *  legendreY[l2] * -1;
+      (*basis)[i][2] = zero;
 
       i++;
     }
@@ -147,13 +147,13 @@ QuadEdgeBasis::QuadEdgeBasis(const int order){
 
   // Cell Based (Type 3) //
   for(int l = 1, iPlus = i + order; l < orderPlus; l++, iPlus++){
-    basis[i][0] = iLegendreY[l];
-    basis[i][1] = zero;
-    basis[i][2] = zero;
+    (*basis)[i][0] = iLegendreY[l];
+    (*basis)[i][1] = zero;
+    (*basis)[i][2] = zero;
 
-    basis[iPlus][0] = zero;
-    basis[iPlus][1] = iLegendreX[l];
-    basis[iPlus][2] = zero;
+    (*basis)[iPlus][0] = zero;
+    (*basis)[iPlus][1] = iLegendreX[l];
+    (*basis)[iPlus][2] = zero;
 
     i++;
   }
@@ -175,7 +175,7 @@ QuadEdgeBasis::QuadEdgeBasis(const int order){
 }
 
 QuadEdgeBasis::~QuadEdgeBasis(void){
-  delete[] basis;
+  delete basis;
 }
 
 /*
@@ -187,7 +187,7 @@ int main(void){
 
   QuadEdgeBasis b(P);
   
-  const std::vector<Polynomial>* basis = b.getBasis();
+  const std::vector<std::vector<Polynomial> >& basis = b.getBasis();
   
   printf("\n");
   printf("clear all;\n");

FunctionSpace/QuadEdgeBasis.h

@@ -17,17 +17,13 @@
 
 class QuadEdgeBasis: public BasisVector{
  public:
+  //! Returns a new Edge-Basis for Quads of the given order
+  //! @param order The order of the Basis
   QuadEdgeBasis(const int order);
+  
+  //! Deletes this Basis
+  //!
   virtual ~QuadEdgeBasis(void);
 };
 
-/**
-   @fn QuadEdgeBasis::QuadEdgeBasis(const int order)
-   @param order The order of the Basis
-   @return Returns a new Edge-Basis for Quads of the given order
-
-   @fn QuadEdgeBasis::~QuadEdgeBasis(void)
-   @return Deletes this Basis
-*/
-
 #endif

FunctionSpace/QuadNodeBasis.cpp

@@ -37,22 +37,22 @@ QuadNodeBasis::QuadNodeBasis(const int order){
 
 
   // Basis //
-  basis = new Polynomial[size];
+  basis = new std::vector<Polynomial>(size);
 
   // Vertex Based (Lagrange) // 
-  basis[0] = 
+  (*basis)[0] = 
     (Polynomial(1, 0, 0, 0) - Polynomial(1, 1, 0, 0)) *
     (Polynomial(1, 0, 0, 0) - Polynomial(1, 0, 1, 0));
 
-  basis[1] = 
+  (*basis)[1] = 
     (Polynomial(1, 1, 0, 0)) *
     (Polynomial(1, 0, 0, 0) - Polynomial(1, 0, 1, 0));
 
-  basis[2] = 
+  (*basis)[2] = 
     (Polynomial(1, 1, 0, 0)) *
     (Polynomial(1, 0, 1, 0));
 
-  basis[3] = 
+  (*basis)[3] = 
     (Polynomial(1, 0, 0, 0) - Polynomial(1, 1, 0, 0)) *
     (Polynomial(1, 0, 1, 0));
   
@@ -61,8 +61,8 @@ QuadNodeBasis::QuadNodeBasis(const int order){
 
   for(int l = 1; l < order; l++){
     for(int e1 = 0, e2 = 1; e1 < 4; e1++, e2 = (e2 + 1) % 4){
-      basis[i] = 
-	legendre[l].compose(lifting[e2] - lifting[e1]) * (basis[e1] + basis[e2]);
+      (*basis)[i] = 
+	legendre[l].compose(lifting[e2] - lifting[e1]) * ((*basis)[e1] + (*basis)[e2]);
             
       i++;
     }
@@ -77,7 +77,7 @@ QuadNodeBasis::QuadNodeBasis(const int order){
 
   for(int l1 = 1; l1 < order; l1++){
     for(int l2 = 1; l2 < order; l2++){
-      basis[i] = legendre[l1].compose(px) * legendre[l2].compose(py);
+      (*basis)[i] = legendre[l1].compose(px) * legendre[l2].compose(py);
 
       i++;
     }
@@ -89,7 +89,7 @@ QuadNodeBasis::QuadNodeBasis(const int order){
 }
 
 QuadNodeBasis::~QuadNodeBasis(void){
-  delete[] basis;
+  delete basis;
 }
 
 /*
@@ -100,7 +100,7 @@ int main(void){
 
   QuadNodeBasis b(P);
   
-  const Polynomial* basis = b.getBasis();
+  const std::vector<Polynomial>& basis = b.getBasis();
   
   printf("\n");
   printf("clear all;\n");

FunctionSpace/QuadNodeBasis.h

@@ -17,17 +17,13 @@
 
 class QuadNodeBasis: public BasisScalar{
  public:
+  //! Returns a new Node-Basis for Quads of the given order
+  //! @param order The order of the Basis
   QuadNodeBasis(const int order);
+
+  //! @return Deletes this Basis
+  //!
   virtual ~QuadNodeBasis(void);
 };
 
-/**
-   @fn QuadNodeBasis::QuadNodeBasis(const int order)
-   @param order The order of the Basis
-   @return Returns a new Node-Basis for Quads of the given order
-
-   @fn QuadNodeBasis::~QuadNodeBasis(void)
-   @return Deletes this Basis
-*/
-
 #endif

FunctionSpace/TriEdgeBasis.cpp

@@ -48,10 +48,10 @@ TriEdgeBasis::TriEdgeBasis(const int order){
 
 
   // Basis //
-  basis = new std::vector<Polynomial>[size];
+  basis = new std::vector<std::vector<Polynomial> >(size);
 
   for(int i = 0; i < size; i++)
-    basis[i].resize(3);
+    (*basis)[i].resize(3);
 
 
   // Edge Based (Nedelec) //
@@ -63,15 +63,15 @@ TriEdgeBasis::TriEdgeBasis(const int order){
     tmp[1].mul(lagrange[i]);
     tmp[2].mul(lagrange[i]);
 
-    basis[i] = lagrange[i].gradient();
+    (*basis)[i] = lagrange[i].gradient();
 
-    basis[i][0].mul(lagrange[j]);
-    basis[i][1].mul(lagrange[j]);
-    basis[i][2].mul(lagrange[j]);      
+    (*basis)[i][0].mul(lagrange[j]);
+    (*basis)[i][1].mul(lagrange[j]);
+    (*basis)[i][2].mul(lagrange[j]);      
 
-    basis[i][0].sub(tmp[0]);
-    basis[i][1].sub(tmp[1]);
-    basis[i][2].sub(tmp[2]);
+    (*basis)[i][0].sub(tmp[0]);
+    (*basis)[i][1].sub(tmp[1]);
+    (*basis)[i][2].sub(tmp[2]);
 
     i++;
   }
@@ -79,7 +79,7 @@ TriEdgeBasis::TriEdgeBasis(const int order){
   // Edge Based (High Order) //
   for(int l = 1; l < orderPlus; l++){
     for(int e = 0; e < 3; e++){
-      basis[i] = 
+      (*basis)[i] = 
 	(intLegendre[l].compose(lagrangeSub[e], lagrangeSum[e])).gradient();
 
       i++;
@@ -103,15 +103,15 @@ TriEdgeBasis::TriEdgeBasis(const int order){
       tmp[1].mul(u[l1]);
       tmp[2].mul(u[l1]);
 
-      basis[i] = u[l1].gradient();
+      (*basis)[i] = u[l1].gradient();
       
-      basis[i][0].mul(v[l2]);
-      basis[i][1].mul(v[l2]);
-      basis[i][2].mul(v[l2]);
+      (*basis)[i][0].mul(v[l2]);
+      (*basis)[i][1].mul(v[l2]);
+      (*basis)[i][2].mul(v[l2]);
 
-      basis[i][0].add(tmp[0]);
-      basis[i][1].add(tmp[1]);
-      basis[i][2].add(tmp[2]);
+      (*basis)[i][0].add(tmp[0]);
+      (*basis)[i][1].add(tmp[1]);
+      (*basis)[i][2].add(tmp[2]);
       
       i++;
     }
@@ -125,15 +125,15 @@ TriEdgeBasis::TriEdgeBasis(const int order){
       tmp[1].mul(u[l1]);
       tmp[2].mul(u[l1]);
 
-      basis[i] = u[l1].gradient();
+      (*basis)[i] = u[l1].gradient();
 
-      basis[i][0].mul(v[l2]);
-      basis[i][1].mul(v[l2]);
-      basis[i][2].mul(v[l2]);
+      (*basis)[i][0].mul(v[l2]);
+      (*basis)[i][1].mul(v[l2]);
+      (*basis)[i][2].mul(v[l2]);
 
-      basis[i][0].sub(tmp[0]);
-      basis[i][1].sub(tmp[1]);
-      basis[i][2].sub(tmp[2]);
+      (*basis)[i][0].sub(tmp[0]);
+      (*basis)[i][1].sub(tmp[1]);
+      (*basis)[i][2].sub(tmp[2]);
  
       i++;
     }
@@ -141,11 +141,11 @@ TriEdgeBasis::TriEdgeBasis(const int order){
 
   // Cell Based (Type 3) //
   for(int l = 0; l < orderMinus; l++){
-    basis[i] = basis[0];
+    (*basis)[i] = (*basis)[0];
 
-    basis[i][0].mul(v[l]);
-    basis[i][1].mul(v[l]);
-    basis[i][2].mul(v[l]);
+    (*basis)[i][0].mul(v[l]);
+    (*basis)[i][1].mul(v[l]);
+    (*basis)[i][2].mul(v[l]);
     
     i++;
   }
@@ -161,7 +161,7 @@ TriEdgeBasis::TriEdgeBasis(const int order){
 }
 
 TriEdgeBasis::~TriEdgeBasis(void){
-  delete[] basis;
+  delete basis;
 }
 
 /*
@@ -173,7 +173,7 @@ int main(void){
 
   TriEdgeBasis b(P);
   
-  const std::vector<Polynomial>* basis = b.getBasis();
+  const std::vector<std::vector<Polynomial> >& basis = b.getBasis();
   
   printf("\n");
   printf("clear all;\n");

FunctionSpace/TriEdgeBasis.h

@@ -17,18 +17,13 @@
 
 class TriEdgeBasis: public BasisVector{
  public:
+  //! Returns a new Edge-Basis for Triangles of the given order
+  //! @param order The order of the Basis
   TriEdgeBasis(const int order);
+  
+  //! Deletes this Basis
+  //!
   virtual ~TriEdgeBasis(void);
 };
 
-
-/**
-   @fn TriEdgeBasis::TriEdgeBasis(const int order)
-   @param order The order of the Basis
-   @return Returns a new Edge-Basis for Triangles of the given order
-
-   @fn TriEdgeBasis::~TriEdgeBasis(void)
-   @return Deletes this Basis
-*/
-
 #endif

FunctionSpace/TriNedelecBasis.cpp

@@ -21,10 +21,10 @@ TriNedelecBasis::TriNedelecBasis(void){
     Polynomial(1, 0, 1, 0);
 
   // Basis //
-  basis = new std::vector<Polynomial>[size];
+  basis = new std::vector<std::vector<Polynomial> >(size);
 
   for(int i = 0; i < size; i++)
-    basis[i].resize(3);
+    (*basis)[i].resize(3);
 
   for(int i = 0, j = 1; i < 3; i++, j = (j + 1) % 3){
     std::vector<Polynomial> tmp = lagrange[j].gradient();
@@ -32,15 +32,15 @@ TriNedelecBasis::TriNedelecBasis(void){
     tmp[1].mul(lagrange[i]);
     tmp[2].mul(lagrange[i]);
 
-    basis[i] = lagrange[i].gradient();
+    (*basis)[i] = lagrange[i].gradient();
 
-    basis[i][0].mul(lagrange[j]);
-    basis[i][1].mul(lagrange[j]);
-    basis[i][2].mul(lagrange[j]);
+    (*basis)[i][0].mul(lagrange[j]);
+    (*basis)[i][1].mul(lagrange[j]);
+    (*basis)[i][2].mul(lagrange[j]);
    
-    basis[i][0].sub(tmp[0]);
-    basis[i][1].sub(tmp[1]);
-    basis[i][2].sub(tmp[2]);
+    (*basis)[i][0].sub(tmp[0]);
+    (*basis)[i][1].sub(tmp[1]);
+    (*basis)[i][2].sub(tmp[2]);
   }
 
   // Free Temporary Sapce //
@@ -48,7 +48,7 @@ TriNedelecBasis::TriNedelecBasis(void){
 }
 
 TriNedelecBasis::~TriNedelecBasis(void){
-  delete[] basis;
+  delete basis;
 }
 
 /*
@@ -60,7 +60,7 @@ int main(void){
 
   TriNedelecBasis b;
   
-  const std::vector<Polynomial>* basis = b.getBasis();
+  const std::vector<std::vector<Polynomial> >& basis = b.getBasis();
   
   printf("\n");
   printf("clear all;\n");

FunctionSpace/TriNedelecBasis.h

@@ -13,17 +13,13 @@
 
 class TriNedelecBasis: public BasisVector{
  public:
+  //! Returns a new Nedelec Basis for Triangles
+  //!
   TriNedelecBasis(void);
+  
+  //! Deletes this Basis
+  //!
   virtual ~TriNedelecBasis(void);
 };
 
-
-/**
-   @fn TriNedelecBasis::TriNedelecBasis
-   @return Returns a new Nedelec Basis for Triangles
-
-   @fn TriNedelecBasis::~TriNedelecBasis(void)
-   @return Deletes this Basis
-*/
-
 #endif

FunctionSpace/TriNodeBasis.cpp

@@ -24,26 +24,26 @@ TriNodeBasis::TriNodeBasis(const int order){
  
 
   // Basis //
-  basis = new Polynomial[size];
+  basis = new std::vector<Polynomial>(size);
 
   // Vertex Based (Lagrange) // 
-  basis[0] = 
+  (*basis)[0] = 
     Polynomial(1, 0, 0, 0) - Polynomial(1, 1, 0, 0) - Polynomial(1, 0, 1, 0);
 
-  basis[1] = 
+  (*basis)[1] = 
     Polynomial(1, 1, 0, 0);
 
-  basis[2] = 
+  (*basis)[2] = 
     Polynomial(1, 0, 1, 0);
 
   
   // Lagrange Sum //
   for(int i = 0, j = 1; i < 3; i++, j = (j + 1) % 3)
-    lagrangeSum[i] = basis[i] + basis[j];
+    lagrangeSum[i] = (*basis)[i] + (*basis)[j];
 
   // Lagrange Sub //
   for(int i = 0, j = 1; i < 3; i++, j = (j + 1) % 3)
-    lagrangeSub[i] = basis[j] - basis[i];
+    lagrangeSub[i] = (*basis)[j] - (*basis)[i];
 
   
   // Edge Based //
@@ -51,7 +51,7 @@ TriNodeBasis::TriNodeBasis(const int order){
 
   for(int l = 1; l < order; l++){
     for(int e = 0; e < 3; e++){
-      basis[i] = 
+      (*basis)[i] = 
 	intLegendre[l].compose(lagrangeSub[e], lagrangeSum[e]);
             
       i++;
@@ -59,14 +59,14 @@ TriNodeBasis::TriNodeBasis(const int order){
   }
 
   // Cell Based //
-  Polynomial p             = basis[2] * 2 - Polynomial(1, 0, 0, 0);
+  Polynomial p             = (*basis)[2] * 2 - Polynomial(1, 0, 0, 0);
   const int  orderMinusTwo = order - 2;
   
   for(int l1 = 1; l1 < orderMinus; l1++){
     for(int l2 = 0; l2 + l1 - 1 < orderMinusTwo; l2++){
-      basis[i] = 
+      (*basis)[i] = 
 	intLegendre[l1].compose(lagrangeSub[0], lagrangeSum[0]) * 
-	   legendre[l2].compose(p) * basis[2];
+	   legendre[l2].compose(p) * (*basis)[2];
       
       i++;
     }
@@ -80,7 +80,7 @@ TriNodeBasis::TriNodeBasis(const int order){
 }
 
 TriNodeBasis::~TriNodeBasis(void){
-  delete[] basis;
+  delete basis;
 }
 
 /*
@@ -91,7 +91,7 @@ int main(void){
 
   TriNodeBasis b(P);
   
-  const Polynomial* basis = b.getBasis();
+  const std::vector<Polynomial>& basis = b.getBasis();
   
   printf("\n");
   printf("clear all;\n");

FunctionSpace/TriNodeBasis.h

@@ -17,17 +17,13 @@
 
 class TriNodeBasis: public BasisScalar{
  public:
+  //! Returns a new Node-Basis for Triangles of the given order
+  //! @param order The order of the Basis
   TriNodeBasis(const int order);
+  
+  //! Deletes this Basis
+  //!
   virtual ~TriNodeBasis(void);
 };
 
-/**
-   @fn TriNodeBasis::TriNodeBasis(const int order)
-   @param order The order of the Basis
-   @return Returns a new Node-Basis for Triangles of the given order
-
-   @fn TriNodeBasis::~TriNodeBasis(void)
-   @return Deletes this Basis
-*/
-
 #endif