* This is a simple scalar statistic, like a counter.
  * @sa Stat, ScalarBase, StatStor
  */
-template<int N = 0>
-class Scalar : public DataWrap<Scalar<N>, ScalarBase<StatStor>, ScalarInfo>
+class Scalar : public DataWrap<Scalar, ScalarBase<StatStor>, ScalarInfo>
 {
   public:
     /** The base implementation. */
  * A stat that calculates the per tick average of a value.
  * @sa Stat, ScalarBase, AvgStor
  */
-template<int N = 0>
-class Average : public DataWrap<Average<N>, ScalarBase<AvgStor>, ScalarInfo>
+class Average : public DataWrap<Average, ScalarBase<AvgStor>, ScalarInfo>
 {
   public:
     /** The base implementation. */
  * A vector of scalar stats.
  * @sa Stat, VectorBase, StatStor
  */
-template<int N = 0>
-class Vector : public DataWrapVec<Vector<N>, VectorBase<StatStor>, VectorInfo>
+class Vector : public DataWrapVec<Vector, VectorBase<StatStor>, VectorInfo>
 {
   public:
     /** The base implementation. */
  * A vector of Average stats.
  * @sa Stat, VectorBase, AvgStor
  */
-template<int N = 0>
 class AverageVector
-    : public DataWrapVec<AverageVector<N>, VectorBase<AvgStor>, VectorInfo>
+    : public DataWrapVec<AverageVector, VectorBase<AvgStor>, VectorInfo>
 {
   public:
     /**
  * A 2-Dimensional vecto of scalar stats.
  * @sa Stat, Vector2dBase, StatStor
  */
-template<int N = 0>
 class Vector2d
-    : public DataWrapVec2d<Vector2d<N>, Vector2dBase<StatStor>, Vector2dInfo>
+    : public DataWrapVec2d<Vector2d, Vector2dBase<StatStor>, Vector2dInfo>
 {
   public:
     Vector2d &
  * A simple distribution stat.
  * @sa Stat, DistBase, DistStor
  */
-template<int N = 0>
 class Distribution
-    : public DataWrap<Distribution<N>, DistBase<DistStor>, DistInfo>
+    : public DataWrap<Distribution, DistBase<DistStor>, DistInfo>
 {
   public:
     /** Base implementation. */
  * Calculates the mean and variance of all the samples.
  * @sa Stat, DistBase, FancyStor
  */
-template<int N = 0>
 class StandardDeviation
-    : public DataWrap<StandardDeviation<N>, DistBase<FancyStor>, DistInfo>
+    : public DataWrap<StandardDeviation, DistBase<FancyStor>, DistInfo>
 {
   public:
     /** The base implementation */
  * Calculates the per tick mean and variance of the samples.
  * @sa Stat, DistBase, AvgFancy
  */
-template<int N = 0>
 class AverageDeviation
-    : public DataWrap<AverageDeviation<N>, DistBase<AvgFancy>, DistInfo>
+    : public DataWrap<AverageDeviation, DistBase<AvgFancy>, DistInfo>
 {
   public:
     /** The base implementation */
  * A vector of distributions.
  * @sa Stat, VectorDistBase, DistStor
  */
-template<int N = 0>
 class VectorDistribution
-    : public DataWrapVec<VectorDistribution<N>,
+    : public DataWrapVec<VectorDistribution,
                          VectorDistBase<DistStor>,
                          VectorDistInfo>
 {
  * This is a vector of StandardDeviation stats.
  * @sa Stat, VectorDistBase, FancyStor
  */
-template<int N = 0>
 class VectorStandardDeviation
-    : public DataWrapVec<VectorStandardDeviation<N>,
+    : public DataWrapVec<VectorStandardDeviation,
                          VectorDistBase<FancyStor>,
                          VectorDistInfo>
 {
  * This is a vector of AverageDeviation stats.
  * @sa Stat, VectorDistBase, AvgFancy
  */
-template<int N = 0>
 class VectorAverageDeviation
-    : public DataWrapVec<VectorAverageDeviation<N>,
+    : public DataWrapVec<VectorAverageDeviation,
                          VectorDistBase<AvgFancy>,
                          VectorDistInfo>
 {
      * Create a new ScalarStatNode.
      * @param s The ScalarStat to place in a node.
      */
-    template <int N>
-    Temp(const Scalar<N> &s)
+    Temp(const Scalar &s)
         : node(new ScalarStatNode(s.info()))
     { }
 
      * Create a new ScalarStatNode.
      * @param s The ScalarStat to place in a node.
      */
-    template <int N>
-    Temp(const Average<N> &s)
+    Temp(const Average &s)
         : node(new ScalarStatNode(s.info()))
     { }
 
      * Create a new VectorStatNode.
      * @param s The VectorStat to place in a node.
      */
-    template <int N>
-    Temp(const Vector<N> &s)
+    Temp(const Vector &s)
         : node(new VectorStatNode(s.info()))
     { }