From 50b8371c71f29e0e2ad7afdcdc984612d4225b83 Mon Sep 17 00:00:00 2001
From: Michael ZBYSZYNSKI <michael.zbyszynski@l-acoustics.com>
Date: Tue, 14 Nov 2023 11:31:51 +0000
Subject: [PATCH] silence warnings, style

---
 dependencies/jsoncpp.cpp       |   2 +-
 dependencies/libsvm/libsvm.cpp |   2 +-
 src/rapidStream.cpp            | 449 +++++++++++++++++----------------
 src/regression.cpp             | 316 ++++++++++++-----------
 4 files changed, 384 insertions(+), 385 deletions(-)

diff --git a/dependencies/jsoncpp.cpp b/dependencies/jsoncpp.cpp
index 85abbab6..4c1b04c1 100644
--- a/dependencies/jsoncpp.cpp
+++ b/dependencies/jsoncpp.cpp
@@ -4206,7 +4206,7 @@ JSONCPP_STRING valueToString(double value, bool useSpecialFloats, unsigned int p
   int len = -1;
 
   char formatString[6];
-  sprintf(formatString, "%%.%dg", precision);
+  snprintf(formatString, 6, "%%.%dg", precision);
 
   // Print into the buffer. We need not request the alternative representation
   // that always has a decimal point because JSON doesn't distingish the
diff --git a/dependencies/libsvm/libsvm.cpp b/dependencies/libsvm/libsvm.cpp
index 7186344e..44b949d7 100644
--- a/dependencies/libsvm/libsvm.cpp
+++ b/dependencies/libsvm/libsvm.cpp
@@ -52,7 +52,7 @@ namespace LIBSVM {
         char buf[BUFSIZ];
         va_list ap;
         va_start(ap,fmt);
-        vsprintf(buf,fmt,ap);
+        vsnprintf(buf,BUFSIZ,fmt,ap);
         va_end(ap);
         (*svm_print_string)(buf);
     }
diff --git a/src/rapidStream.cpp b/src/rapidStream.cpp
index fcada46e..f121a43e 100644
--- a/src/rapidStream.cpp
+++ b/src/rapidStream.cpp
@@ -17,256 +17,259 @@
 
 namespace rapidLib
 {
-    template<typename T>
-    rapidStream<T>::rapidStream(std::size_t window_size) 
-    {
-        windowSize = window_size;
-        windowIndex = 0;
-        circularWindow.resize(windowSize);
-        std::fill(circularWindow.begin(), circularWindow.end(), 0);
-        
-        //Baysian Filter setup
-        bayesFilt.diffusion = powf(10., -2);
-        bayesFilt.jump_rate = powf(10., -10);
-        bayesFilt.mvc[0] = 1.;
-        bayesFilt.init();
-    }
 
-    template<typename T>
-    rapidStream<T>::rapidStream() 
-    {
-        windowSize = 3;
-        windowIndex = 0;
-        circularWindow.resize(windowSize);
-        std::fill(circularWindow.begin(), circularWindow.end(), 0);
+template<typename T>
+rapidStream<T>::rapidStream(std::size_t window_size) :
+windowSize(window_size),
+windowIndex(0)
+{
+  circularWindow.resize(windowSize);
+  std::fill(circularWindow.begin(), circularWindow.end(), 0);
+  
+  //Baysian Filter setup
+  bayesFilt.diffusion = powf(10., -2);
+  bayesFilt.jump_rate = powf(10., -10);
+  bayesFilt.mvc[0] = 1.;
+  bayesFilt.init();
+}
 
-        //Baysian Filter setup
-        bayesFilt.diffusion = powf(10., -2);
-        bayesFilt.jump_rate = powf(10., -10);
-        bayesFilt.mvc[0] = 1.;
-        bayesFilt.init();
-    }
+template<typename T>
+rapidStream<T>::rapidStream() :
+windowSize(3),
+windowIndex(0)
+{
+  circularWindow.resize(windowSize);
+  std::fill(circularWindow.begin(), circularWindow.end(), 0);
+  
+  //Baysian Filter setup
+  bayesFilt.diffusion = powf(10., -2);
+  bayesFilt.jump_rate = powf(10., -10);
+  bayesFilt.mvc[0] = 1.;
+  bayesFilt.init();
+}
 
-    template<typename T>
-    rapidStream<T>::~rapidStream() 
-    {
-        //delete[]circularWindow;
-    }
+template<typename T>
+rapidStream<T>::~rapidStream()
+{
+  //delete[]circularWindow;
+}
 
-    template<typename T>
-    void rapidStream<T>::clear() 
-    {
-        windowIndex = 0;
-        circularWindow.resize(windowSize);
-        std::fill(circularWindow.begin(), circularWindow.end(), 0);
-    }
+template<typename T>
+void rapidStream<T>::clear()
+{
+  windowIndex = 0;
+  circularWindow.resize(windowSize);
+  std::fill(circularWindow.begin(), circularWindow.end(), 0);
+}
 
-    template<typename T>
-    void rapidStream<T>::pushToWindow(T input) 
-    {
-        circularWindow[windowIndex] = input;
-        windowIndex = (windowIndex + 1) % windowSize;
-    }
+template<typename T>
+void rapidStream<T>::pushToWindow(T input)
+{
+  circularWindow[windowIndex] = input;
+  windowIndex = (windowIndex + 1) % windowSize;
+}
 
-    template<typename T>
-    inline T rapidStream<T>::calcCurrentVel(std::size_t i) const 
-    {
-        return circularWindow[(i + windowIndex) % windowSize] - circularWindow[(i + windowIndex - 1) % windowSize];
-    }
+template<typename T>
+inline T rapidStream<T>::calcCurrentVel(std::size_t i) const
+{
+  return circularWindow[(i + windowIndex) % windowSize] - circularWindow[(i + windowIndex - 1) % windowSize];
+}
 
-    template<typename T>
-    T rapidStream<T>::velocity() const 
-    {
-        return calcCurrentVel(-1);
-    };
+template<typename T>
+T rapidStream<T>::velocity() const
+{
+  return calcCurrentVel(-1);
+};
 
-    template<typename T>
-    T rapidStream<T>::acceleration() const 
-    {
-        return calcCurrentVel(-2) - calcCurrentVel(-3);
-    };
+template<typename T>
+T rapidStream<T>::acceleration() const
+{
+  return calcCurrentVel(-2) - calcCurrentVel(-3);
+};
+
+template<typename T>
+T rapidStream<T>::minimum() const
+{
+  return *std::min_element(circularWindow.begin(), circularWindow.end());
+}
 
-    template<typename T>
-    T rapidStream<T>::minimum() const 
+template<typename T>
+T rapidStream<T>::maximum() const
+{
+  return *std::max_element(circularWindow.begin(), circularWindow.end());;
+}
+
+template<typename T>
+uint32_t rapidStream<T>::numZeroCrossings() const
+{
+  uint32_t zeroCrossings {};
+  
+  //Is the begininng positive, negative, or 0?
+  int previous { 1 };
+  if (circularWindow[windowIndex] < 0)
+  {
+    previous = -1;
+  }
+  else if (circularWindow[windowIndex] == 0)
+  {
+    ++zeroCrossings;
+    previous = 0;
+  }
+  
+  for (std::size_t i { 1 }; i < windowSize; ++i)
+  {
+    const std::size_t index { (windowIndex + i) % windowSize};
+    
+    if (circularWindow[index] < 0 && previous >= 0) //Transition to negative
     {
-        return *std::min_element(circularWindow.begin(), circularWindow.end());
+      ++zeroCrossings;
+      previous = -1;
     }
-
-    template<typename T>
-    T rapidStream<T>::maximum() const 
+    else if (circularWindow[index] > 0 && previous <= 0) //Transition to positive
     {
-        return *std::max_element(circularWindow.begin(), circularWindow.end());;
+      ++zeroCrossings;
+      previous = 1;
     }
-
-    template<typename T>
-    uint32_t rapidStream<T>::numZeroCrossings() const 
+    else //Sample == 0
     {
-        uint32_t zeroCrossings = 0;
-        //Is the begininng positive, negative, or 0?
-        int previous = 1;
-        if (circularWindow[windowIndex] < 0) 
-        {
-            previous = -1;
-        }
-        else if (circularWindow[windowIndex] == 0) 
-        {
-            ++zeroCrossings;
-            previous = 0;
-        }
-
-        for (std::size_t i = 1; i < windowSize; ++i) 
-        {
-            std::size_t index = (windowIndex + i) % windowSize;
-            if (circularWindow[index] < 0 && previous >= 0) 
-            { //Transition to negative
-                ++zeroCrossings;
-                previous = -1;
-            }
-            else if (circularWindow[index] > 0 && previous <= 0) 
-            { //Transition to positive
-                ++zeroCrossings;
-                previous = 1;
-            }
-            else 
-            { //Sample == 0
-                previous = 0;
-            }
-        }
-        return zeroCrossings;
+      previous = 0;
     }
+  }
+  return zeroCrossings;
+}
 
 
-    template<typename T>
-    T rapidStream<T>::sum() const 
-    {
-        return std::accumulate(circularWindow.begin(), circularWindow.end(), 0);
-    }
+template<typename T>
+T rapidStream<T>::sum() const
+{
+  return std::accumulate(circularWindow.begin(), circularWindow.end(), 0);
+}
 
-    template<typename T>
-    T rapidStream<T>::mean() const 
-    {
-        return sum() / windowSize;
-    }
+template<typename T>
+T rapidStream<T>::mean() const
+{
+  return sum() / windowSize;
+}
 
-    template<typename T>
-    T rapidStream<T>::standardDeviation() const 
-    {
-        T newMean = mean();
-        T standardDeviation = 0.;
-        for (auto value:circularWindow)
-        {
-            standardDeviation += (T)pow(value - newMean, 2);
-        }
-        return sqrt(standardDeviation / windowSize);
-    }
+template<typename T>
+T rapidStream<T>::standardDeviation() const
+{
+  const T newMean { mean() };
+  T standardDeviation {};
+  
+  for (auto value : circularWindow)
+  {
+    standardDeviation += static_cast<T>(pow(value - newMean, 2));
+  }
+  return sqrt(standardDeviation / windowSize);
+}
 
-    template<typename T>
-    T rapidStream<T>::rms() const 
-    {
-        T rms = 0;
-        for (auto value:circularWindow) 
-        {
-            rms += value * value;
-        }
-        rms = rms / windowSize;
-        return sqrt(rms);
-    }
+template<typename T>
+T rapidStream<T>::rms() const
+{
+  T rms {};
+  
+  for (auto value:circularWindow)
+  {
+    rms += value * value;
+  }
+  
+  rms = rms / windowSize;
+  return sqrt(rms);
+}
 
-    template<typename T>
-    T rapidStream<T>::bayesFilter(T input) 
-    {
-        std::vector<float> inputVec = { float(input) };
-        bayesFilt.update(inputVec);
-        return T(bayesFilt.output[0]);
-    }
+template<typename T>
+T rapidStream<T>::bayesFilter(T input)
+{
+  std::vector<float> inputVec = { float(input) };
+  bayesFilt.update(inputVec);
+  return static_cast<T>(bayesFilt.output[0]);
+}
 
-    template<typename T>
-    void rapidStream<T>::bayesSetDiffusion(float diffusion) 
-    {
-        bayesFilt.diffusion = powf(10., diffusion);
-        bayesFilt.init();
-    }
+template<typename T>
+void rapidStream<T>::bayesSetDiffusion(float diffusion)
+{
+  bayesFilt.diffusion = powf(10., diffusion);
+  bayesFilt.init();
+}
 
-    template<typename T>
-    void rapidStream<T>::bayesSetJumpRate(float jump_rate) 
-    {
-        bayesFilt.jump_rate = powf(10., jump_rate);
-        bayesFilt.init();
-    }
+template<typename T>
+void rapidStream<T>::bayesSetJumpRate(float jump_rate)
+{
+  bayesFilt.jump_rate = powf(10., jump_rate);
+  bayesFilt.init();
+}
 
-    template<typename T>
-    void rapidStream<T>::bayesSetMVC(float mvc) 
-    {
-        bayesFilt.mvc[0] = mvc;
-        bayesFilt.init();
-    }
+template<typename T>
+void rapidStream<T>::bayesSetMVC(float mvc)
+{
+  bayesFilt.mvc[0] = mvc;
+  bayesFilt.init();
+}
 
-    template<typename T>
-    T rapidStream<T>::minVelocity() const
-    {
-        T minVel = std::numeric_limits<T>::infinity();
-        for (std::size_t i = 0; i < windowSize; ++i) 
-        {
-            T currentVel = calcCurrentVel(i);
-            if (currentVel < minVel) {
-                minVel = currentVel;
-            }
-        }
-        return minVel;
-    }
+template<typename T>
+T rapidStream<T>::minVelocity() const
+{
+  T minVel { std::numeric_limits<T>::infinity() };
+  
+  for (std::size_t i {}; i < windowSize; ++i)
+  {
+    const T currentVel { calcCurrentVel(i) };
+    if (currentVel < minVel)  minVel = currentVel;
+  }
+  
+  return minVel;
+}
 
-    template<typename T>
-    T rapidStream<T>::maxVelocity() const 
-    {
-        T maxVel = std::numeric_limits<T>::lowest();
-        for (std::size_t i = 0; i < windowSize; ++i) 
-        {
-            T currentVel = calcCurrentVel(i);
-            if (currentVel > maxVel) 
-            {
-                maxVel = currentVel;
-            }
-        }
-        return maxVel;
-    }
+template<typename T>
+T rapidStream<T>::maxVelocity() const
+{
+  T maxVel { std::numeric_limits<T>::lowest() };
+  
+  for (std::size_t i {}; i < windowSize; ++i)
+  {
+    const T currentVel { calcCurrentVel(i) };
+    if (currentVel > maxVel) maxVel = currentVel;
+  }
+  
+  return maxVel;
+}
 
-    template<typename T>
-    T rapidStream<T>::minAcceleration() const 
-    {
-        T minAccel = std::numeric_limits<T>::infinity();
-        T lastVel = calcCurrentVel(1);
-        for (std::size_t i = 2; i < windowSize; ++i) 
-        {
-            T currentVel = calcCurrentVel(i);
-            T currentAccel = currentVel - lastVel;
-            lastVel = currentVel;
-            if (currentAccel < minAccel) 
-            {
-                minAccel = currentAccel;
-            }
-        }
-        return minAccel;
-    }
+template<typename T>
+T rapidStream<T>::minAcceleration() const
+{
+  T minAccel { std::numeric_limits<T>::infinity() };
+  T lastVel { calcCurrentVel(1) };
+  
+  for (std::size_t i { 2 }; i < windowSize; ++i)
+  {
+    const T currentVel { calcCurrentVel(i) };
+    const T currentAccel { currentVel - lastVel };
+    lastVel = currentVel;
+    if (currentAccel < minAccel) minAccel = currentAccel;
+  }
+  
+  return minAccel;
+}
 
-    template<typename T>
-    T rapidStream<T>::maxAcceleration() const 
-    {
-        T maxAccel = std::numeric_limits<T>::lowest();
-        T lastVel = calcCurrentVel(1);
-        for (std::size_t i = 2; i < windowSize; ++i) 
-        {
-            T currentVel = calcCurrentVel(i);
-            T currentAccel = currentVel - lastVel;
-            lastVel = currentVel;
-            if (currentAccel > maxAccel) 
-            {
-                maxAccel = currentAccel;
-            }
-        }
-        return maxAccel;
-    }
+template<typename T>
+T rapidStream<T>::maxAcceleration() const
+{
+  T maxAccel { std::numeric_limits<T>::lowest() };
+  T lastVel { calcCurrentVel(1) };
+  
+  for (std::size_t i { 2 }; i < windowSize; ++i)
+  {
+    const T currentVel { calcCurrentVel(i) };
+    const T currentAccel { currentVel - lastVel };
+    lastVel = currentVel;
+    if (currentAccel > maxAccel) maxAccel = currentAccel;
+  }
+  
+  return maxAccel;
+}
 
-    //explicit instantiation
-    template class rapidStream<double>;
-    template class rapidStream<float>;
+//explicit instantiation
+template class rapidStream<double>;
+template class rapidStream<float>;
 };
diff --git a/src/regression.cpp b/src/regression.cpp
index 4e9b1ad2..3616c61b 100644
--- a/src/regression.cpp
+++ b/src/regression.cpp
@@ -18,234 +18,230 @@
 #endif
 
 template<typename T>
-regressionTemplate<T>::regressionTemplate()
+regressionTemplate<T>::regressionTemplate() :
+numHiddenLayers(1),
+numHiddenNodes(0), //this will be changed by training
+numEpochs(500)
 {
-    modelSet<T>::numInputs = -1;
-    modelSet<T>::numOutputs = -1;
-    numHiddenLayers = 1;
-    numHiddenNodes = 0; //this will be changed by training
-    numEpochs = 500;
-    modelSet<T>::isTraining = false;
+  modelSet<T>::numInputs = -1;
+  modelSet<T>::numOutputs = -1;
+  modelSet<T>::isTraining = false;
 };
 
 template<typename T>
 regressionTemplate<T>::regressionTemplate(const int &num_inputs, const int &num_outputs)
 {
-    modelSet<T>::numInputs = num_inputs;
-    modelSet<T>::numOutputs = num_outputs;
-    numHiddenLayers = 1;
-    numEpochs = 500;
-    numHiddenNodes = num_inputs;
-    modelSet<T>::isTraining = false;
-    created = false;
-    std::vector<size_t> whichInputs;
-
-    for (int i = 0; i < modelSet<T>::numInputs; ++i) 
-    {
-        whichInputs.push_back(i);
-    }
-
-    for (int i = 0; i < modelSet<T>::numOutputs; ++i) 
-    {
-        modelSet<T>::myModelSet.push_back(new neuralNetwork<T>(modelSet<T>::numInputs, whichInputs, numHiddenLayers, numHiddenNodes));
-    }
-    created = true;
+  modelSet<T>::numInputs = num_inputs;
+  modelSet<T>::numOutputs = num_outputs;
+  numHiddenLayers = 1;
+  numEpochs = 500;
+  numHiddenNodes = num_inputs;
+  modelSet<T>::isTraining = false;
+  created = false;
+  std::vector<size_t> whichInputs;
+  
+  for (int i {}; i < modelSet<T>::numInputs; ++i) whichInputs.push_back(i);
+  
+  for (int i {}; i < modelSet<T>::numOutputs; ++i)
+  {
+    modelSet<T>::myModelSet.push_back(new neuralNetwork<T>(modelSet<T>::numInputs, whichInputs, numHiddenLayers, numHiddenNodes));
+  }
+  
+  created = true;
 };
 
 template<typename T>
-regressionTemplate<T>::regressionTemplate(const std::vector<trainingExampleTemplate<T> > &training_set) 
+regressionTemplate<T>::regressionTemplate(const std::vector<trainingExampleTemplate<T> > &training_set)
 {
-    modelSet<T>::numInputs = -1;
-    modelSet<T>::numOutputs = -1;
-    modelSet<T>::isTraining = false;
-    train(training_set);
+  modelSet<T>::numInputs = -1;
+  modelSet<T>::numOutputs = -1;
+  modelSet<T>::isTraining = false;
+  train(training_set);
 };
 
 template<typename T>
 std::vector<size_t> regressionTemplate<T>::getNumHiddenLayers() const
 {
-    std::vector<size_t> vecNumHiddenLayers;
+  std::vector<size_t> vecNumHiddenLayers {};
   
-    if (std::begin(modelSet<T>::myModelSet) != std::end(modelSet<T>::myModelSet))
+  if (std::begin(modelSet<T>::myModelSet) != std::end(modelSet<T>::myModelSet))
+  {
+    for (const baseModel<T>* model : modelSet<T>::myModelSet)
     {
-        for (const baseModel<T>* model : modelSet<T>::myModelSet)
-        {
-            vecNumHiddenLayers.push_back(dynamic_cast<const neuralNetwork<T>*>(model)->getNumHiddenLayers()); //FIXME: I really dislike this design
-        }
-    } 
-    else 
-    {
-        vecNumHiddenLayers = { numHiddenLayers };
+      vecNumHiddenLayers.push_back(dynamic_cast<const neuralNetwork<T>*>(model)->getNumHiddenLayers()); //FIXME: I really dislike this design
     }
+  }
+  else
+  {
+    vecNumHiddenLayers = { numHiddenLayers };
+  }
   
-    return vecNumHiddenLayers;
+  return vecNumHiddenLayers;
 }
 
 template<typename T>
 void regressionTemplate<T>::setNumHiddenLayers(const int &num_hidden_layers)
 {
-    numHiddenLayers = num_hidden_layers;
-    //Set any existing models
-    if (std::begin(modelSet<T>::myModelSet) != std::end(modelSet<T>::myModelSet)) 
+  numHiddenLayers = num_hidden_layers;
+  //Set any existing models
+  if (std::begin(modelSet<T>::myModelSet) != std::end(modelSet<T>::myModelSet))
+  {
+    for (baseModel<T>* model : modelSet<T>::myModelSet)
     {
-        for (baseModel<T>* model : modelSet<T>::myModelSet) 
-        {
-            neuralNetwork<T>* nnModel = dynamic_cast<neuralNetwork<T>*>(model); //FIXME: I really dislike this design
-            nnModel->setNumHiddenLayers(num_hidden_layers);
-        }
+      dynamic_cast<neuralNetwork<T>*>(model)->setNumHiddenLayers(num_hidden_layers); //FIXME: I really dislike this design
     }
+  }
 }
 
 template<typename T>
 std::vector<size_t> regressionTemplate<T>::getNumHiddenNodes() const
 {
-    std::vector<size_t> vecNumHiddenNodes;
+  std::vector<size_t> vecNumHiddenNodes {};
   
-    if (std::begin(modelSet<T>::myModelSet) != std::end(modelSet<T>::myModelSet))
-    {
-        for (const baseModel<T>* model : modelSet<T>::myModelSet)
-        {
-            vecNumHiddenNodes.push_back( dynamic_cast<const neuralNetwork<T>*>(model)->getNumHiddenNodes()); //FIXME: I really dislike this design
-        }
-    } 
-    else 
+  if (std::begin(modelSet<T>::myModelSet) != std::end(modelSet<T>::myModelSet))
+  {
+    for (const baseModel<T>* model : modelSet<T>::myModelSet)
     {
-        vecNumHiddenNodes = { numHiddenNodes };
+      vecNumHiddenNodes.push_back(dynamic_cast<const neuralNetwork<T>*>(model)->getNumHiddenNodes()); //FIXME: I really dislike this design
     }
+  }
+  else
+  {
+    vecNumHiddenNodes = { numHiddenNodes };
+  }
   
-    return vecNumHiddenNodes;
+  return vecNumHiddenNodes;
 }
 
 template<typename T>
 void regressionTemplate<T>::setNumHiddenNodes(const int &num_hidden_nodes)
 {
-    numHiddenNodes = num_hidden_nodes;
-    //Set any existing models
-    if (std::begin(modelSet<T>::myModelSet) != std::end(modelSet<T>::myModelSet)) 
+  numHiddenNodes = num_hidden_nodes;
+  
+  //Set any existing models
+  if (std::begin(modelSet<T>::myModelSet) != std::end(modelSet<T>::myModelSet))
+  {
+    for (baseModel<T>* model : modelSet<T>::myModelSet)
     {
-        for (baseModel<T>* model : modelSet<T>::myModelSet) 
-        {
-            neuralNetwork<T>* nnModel = dynamic_cast<neuralNetwork<T>*>(model); //FIXME: I really dislike this design
-            nnModel->setNumHiddenNodes(num_hidden_nodes);
-        }
+      dynamic_cast<neuralNetwork<T>*>(model)->setNumHiddenNodes(num_hidden_nodes); //FIXME: I really dislike this design
     }
+  }
 }
 
 
 template<typename T>
-std::vector<size_t> regressionTemplate<T>::getNumEpochs() const 
+std::vector<size_t> regressionTemplate<T>::getNumEpochs() const
 {
-    std::vector<size_t> vecEpochs;
-    if (std::begin(modelSet<T>::myModelSet) != std::end(modelSet<T>::myModelSet)) 
-    {
-        for (baseModel<T>* model : modelSet<T>::myModelSet) 
-        {
-            neuralNetwork<T>* nnModel = dynamic_cast<neuralNetwork<T>*>(model); //FIXME: I really dislike this design
-            vecEpochs.push_back(nnModel->getEpochs());
-        }
-    } 
-    else 
+  std::vector<size_t> vecEpochs;
+  if (std::begin(modelSet<T>::myModelSet) != std::end(modelSet<T>::myModelSet))
+  {
+    for (const baseModel<T>* model : modelSet<T>::myModelSet)
     {
-        vecEpochs = { numEpochs };
+      vecEpochs.push_back(dynamic_cast<const neuralNetwork<T>*>(model)->getEpochs());  //FIXME: I really dislike this design
     }
-    return vecEpochs;
+  }
+  else
+  {
+    vecEpochs = { numEpochs };
+  }
+  return vecEpochs;
 }
 
 template<typename T>
-void regressionTemplate<T>::setNumEpochs(const size_t &epochs) 
+void regressionTemplate<T>::setNumEpochs(const size_t &epochs)
 {
-    numEpochs = epochs;
-    //set any existing models
-    if (std::begin(modelSet<T>::myModelSet) != std::end(modelSet<T>::myModelSet)) 
+  numEpochs = epochs;
+  
+  //set any existing models
+  if (std::begin(modelSet<T>::myModelSet) != std::end(modelSet<T>::myModelSet))
+  {
+    for (baseModel<T>* model : modelSet<T>::myModelSet)
     {
-        for (baseModel<T>* model : modelSet<T>::myModelSet) 
-        {
-            neuralNetwork<T>* nnModel = dynamic_cast<neuralNetwork<T>*>(model); //FIXME: I really dislike this design
-            nnModel->setEpochs(epochs);
-        }
+      dynamic_cast<neuralNetwork<T>*>(model)->setEpochs(epochs); //FIXME: I really dislike this design
     }
+  }
 }
 
 template<typename T>
-bool regressionTemplate<T>::train(const std::vector<trainingExampleTemplate<T> > &training_set) 
+bool regressionTemplate<T>::train(const std::vector<trainingExampleTemplate<T> > &training_set)
 {
-    //clock_t timer;
-    //timer = clock();
-    modelSet<T>::reset(); //FIXME: Should use modelSet if already created?
-    if (training_set.size() > 0) 
+  //clock_t timer;
+  //timer = clock();
+  modelSet<T>::reset(); //FIXME: Should use modelSet if already created?
+  if (training_set.size() > 0)
+  {
+    //create model(s) here
+    modelSet<T>::numInputs = int(training_set[0].input.size());
+    modelSet<T>::numOutputs = int(training_set[0].output.size());
+    
+    for (int i = 0; i < modelSet<T>::numInputs; ++i)
     {
-        //create model(s) here
-        modelSet<T>::numInputs = int(training_set[0].input.size());
-        modelSet<T>::numOutputs = int(training_set[0].output.size());
-
-        for (int i = 0; i < modelSet<T>::numInputs; ++i) 
-        {
-            modelSet<T>::inputNames.push_back("inputs-" + std::to_string(i + 1));
-        }
-        modelSet<T>::numOutputs = int(training_set[0].output.size());
-
-        for ( auto example : training_set) 
-        {
-            if (example.input.size() != modelSet<T>::numInputs) 
-            {
-                throw std::length_error("unequal feature vectors in input.");
-                return false;
-            }
-            if (example.output.size() != modelSet<T>::numOutputs) 
-            {
-                throw std::length_error("unequal output vectors.");
-                return false;
-            }
-        }
-
-        if(numHiddenNodes == 0) numHiddenNodes = modelSet<T>::numInputs;
-        std::vector<size_t> whichInputs;
-
-        for (int j = 0; j < modelSet<T>::numInputs; ++j) 
-        {
-            whichInputs.push_back(j);
-        }
-
-        for (int i = 0; i < modelSet<T>::numOutputs; ++i) 
-        {
-            modelSet<T>::myModelSet.push_back(new neuralNetwork<T>(modelSet<T>::numInputs, whichInputs, numHiddenLayers, numHiddenNodes));
-        }
-
-        if (numEpochs != 500) 
-        {
-            for (baseModel<T>* model : modelSet<T>::myModelSet) 
-            {
-                neuralNetwork<T>* nnModel = dynamic_cast<neuralNetwork<T>*>(model); //FIXME: I really dislike this design
-                nnModel->setEpochs(numEpochs);
-            }
-        }
-
-        //timer = clock() - timer;
-        bool result = modelSet<T>::train(training_set);
-        //std::cout << "Regression trained in " << (float)timer/CLOCKS_PER_SEC << " ms." << std::endl;
-        return result;
+      modelSet<T>::inputNames.push_back("inputs-" + std::to_string(i + 1));
     }
-    throw std::length_error("empty training set.");
-    return false;
+    modelSet<T>::numOutputs = int(training_set[0].output.size());
+    
+    for ( auto example : training_set)
+    {
+      if (example.input.size() != modelSet<T>::numInputs)
+      {
+        throw std::length_error("unequal feature vectors in input.");
+        return false;
+      }
+      if (example.output.size() != modelSet<T>::numOutputs)
+      {
+        throw std::length_error("unequal output vectors.");
+        return false;
+      }
+    }
+    
+    if(numHiddenNodes == 0) numHiddenNodes = modelSet<T>::numInputs;
+    std::vector<size_t> whichInputs;
+    
+    for (int j = 0; j < modelSet<T>::numInputs; ++j)
+    {
+      whichInputs.push_back(j);
+    }
+    
+    for (int i = 0; i < modelSet<T>::numOutputs; ++i)
+    {
+      modelSet<T>::myModelSet.push_back(new neuralNetwork<T>(modelSet<T>::numInputs, whichInputs, numHiddenLayers, numHiddenNodes));
+    }
+    
+    if (numEpochs != 500)
+    {
+      for (baseModel<T>* model : modelSet<T>::myModelSet)
+      {
+        neuralNetwork<T>* nnModel = dynamic_cast<neuralNetwork<T>*>(model); //FIXME: I really dislike this design
+        nnModel->setEpochs(numEpochs);
+      }
+    }
+    
+    //timer = clock() - timer;
+    bool result = modelSet<T>::train(training_set);
+    //std::cout << "Regression trained in " << (float)timer/CLOCKS_PER_SEC << " ms." << std::endl;
+    return result;
+  }
+  throw std::length_error("empty training set.");
+  return false;
 }
 
 template<typename T>
 float regressionTemplate<T>::getTrainingProgress()
 {
-    float progress = modelSet<T>::isTrained ? 1.f : 0.f;
-
-    if (modelSet<T>::isTraining)
+  float progress = modelSet<T>::isTrained ? 1.f : 0.f;
+  
+  if (modelSet<T>::isTraining)
+  {
+    for (baseModel<T>* model : modelSet<T>::myModelSet)
     {
-        for (baseModel<T>* model : modelSet<T>::myModelSet)
-        {
-            neuralNetwork<T>* nnModel = dynamic_cast<neuralNetwork<T>*>(model); //FIXME: I really dislike this design
-            progress += (nnModel->getCurrentEpoch() / nnModel->getEpochs());
-        }
-
-        progress /= modelSet<T>::myModelSet.size();
+      neuralNetwork<T>* nnModel = dynamic_cast<neuralNetwork<T>*>(model); //FIXME: I really dislike this design
+      progress += (nnModel->getCurrentEpoch() / nnModel->getEpochs());
     }
-
-    return progress;
+    
+    progress /= modelSet<T>::myModelSet.size();
+  }
+  
+  return progress;
 }
 
 //explicit instantiation