* doc installable

src/do

@@ -22,7 +22,6 @@
 #include "doSamplerUniform.h"
 #include "doSamplerNormal.h"
 
-#include "doDistribParams.h"
 #include "doVectorBounds.h"
 #include "doNormalParams.h"
 

src/doCMASA.h

@@ -140,7 +140,7 @@ public:
 
 
 	//-------------------------------------------------------------
-	// Temporary solution to store bounds valeur for each distribution.
+	// Temporary solution to store bounds values for each distribution.
 	//-------------------------------------------------------------
 
 	std::string bounds_results_destination("ResBounds");
@@ -151,7 +151,7 @@ public:
 	    ::system(ss.str().c_str());
 	}
 
-	::mkdir(bounds_results_destination.c_str(), 0755); // create a first time the
+	::mkdir(bounds_results_destination.c_str(), 0755); // create once directory
 
 	//-------------------------------------------------------------
 
@@ -283,8 +283,8 @@ public:
 		    std::ofstream ofs(ss.str().c_str());
 
 		    ofs << size << " ";
-		    std::copy(distrib.param(0).begin(), distrib.param(0).end(), std::ostream_iterator< double >(ofs, " "));
-		    std::copy(distrib.param(1).begin(), distrib.param(1).end(), std::ostream_iterator< double >(ofs, " "));
+		    std::copy(distrib.mean().begin(), distrib.mean().end(), std::ostream_iterator< double >(ofs, " "));
+		    std::copy(distrib.variance().begin(), distrib.variance().end(), std::ostream_iterator< double >(ofs, " "));
 		    ofs << std::endl;
 		}
 

src/doDistribParams.h

@@ -1,44 +0,0 @@
-#ifndef _doDistribParams_h
-#define _doDistribParams_h
-
-#include <vector>
-
-template < typename EOT >
-class doDistribParams
-{
-public:
-    doDistribParams(unsigned n = 2)
-	: _params(n)
-    {}
-
-    doDistribParams(const doDistribParams& p) { *this = p; }
-
-    doDistribParams& operator=(const doDistribParams& p)
-    {
-	if (this != &p)
-	    {
-		this->_params = p._params;
-	    }
-
-	return *this;
-    }
-
-    EOT& param(unsigned int i = 0){return _params[i];}
-
-    unsigned int param_size(){return _params.size();}
-
-    unsigned int size()
-    {
-	for (unsigned int i = 0, size = param_size(); i < size - 1; ++i)
-	    {
-		assert(param(i).size() == param(i + 1).size());
-	    }
-
-	return param(0).size();
-    }
-
-private:
-    std::vector< EOT > _params;
-};
-
-#endif // !_doDistribParams_h

src/doNormalParams.h

@@ -1,28 +1,29 @@
 #ifndef _doNormalParams_h
 #define _doNormalParams_h
 
-#include "doDistribParams.h"
-
 template < typename EOT >
-class doNormalParams : public doDistribParams< EOT >
+class doNormalParams
 {
 public:
-    doNormalParams(EOT _mean, EOT _variance)
-	: doDistribParams< EOT >(2)
+    doNormalParams(EOT mean, EOT variance)
+	: _mean(mean), _variance(variance)
     {
 	assert(_mean.size() > 0);
 	assert(_mean.size() == _variance.size());
-
-	mean() = _mean;
-	variance() = _variance;
     }
 
-    doNormalParams(const doNormalParams& p)
-	: doDistribParams< EOT >( p )
-    {}
+    EOT& mean(){return _mean;}
+    EOT& variance(){return _variance;}
 
-    EOT& mean(){return this->param(0);}
-    EOT& variance(){return this->param(1);}
+    unsigned int size()
+    {
+	assert(_mean.size() == _variance.size());
+	return _mean.size();
+    }
+
+private:
+    EOT _mean;
+    EOT _variance;
 };
 
 #endif // !_doNormalParams_h

src/doStats.h

@@ -110,4 +110,9 @@ protected:
     double _hv;
 };
 
+class doCholesky : public doStats
+{
+    
+};
+
 #endif // !_doStats_h

src/doVectorBounds.h

@@ -1,28 +1,30 @@
 #ifndef _doVectorBounds_h
 #define _doVectorBounds_h
 
-#include "doDistribParams.h"
-
 template < typename EOT >
-class doVectorBounds : public doDistribParams< EOT >
+class doVectorBounds
 {
 public:
-    doVectorBounds(EOT _min, EOT _max)
-	: doDistribParams< EOT >(2)
+    doVectorBounds(EOT min, EOT max)
+	: _min(min), _max(max)
     {
 	assert(_min.size() > 0);
 	assert(_min.size() == _max.size());
-
-	min() = _min;
-	max() = _max;
     }
 
-    doVectorBounds(const doVectorBounds& v)
-	: doDistribParams< EOT >( v )
-    {}
+    EOT& min(){return _min;}
+    EOT& max(){return _max;}
 
-    EOT& min(){return this->param(0);}
-    EOT& max(){return this->param(1);}
+
+    unsigned int size()
+    {
+	assert(_min.size() == _max.size());
+	return _min.size();
+    }
+
+private:
+    EOT _min;
+    EOT _max;
 };
 
 #endif // !_doVectorBounds_h