Index: NeuralNet.h
===================================================================
--- NeuralNet.h	(revision 112)
+++ NeuralNet.h	(revision 113)
@@ -12,8 +12,8 @@
     int mNumHidden;
     int mNumOutputs;

-    Matrix::Matrix *mWin;
-    Matrix::Matrix *mWout;
+    Matrix::Matrix mWin;
+    Matrix::Matrix mWout;

     std::vector<double> mInputActivation;
     std::vector<double> mHiddenActivation;
@@ -21,7 +21,6 @@

     public:
     NeuralNet(int numInputs, int numHidden, int numOutput);
-    ~NeuralNet();
     std::vector<double> update(const std::vector<double> &inputs);
     double backprop(const std::vector<double> &target, double learningRate);

Index: Util.cpp
===================================================================
--- Util.cpp	(revision 112)
+++ Util.cpp	(revision 113)
@@ -7,6 +7,7 @@
 #include <cstdlib>
 #include <cassert>
 #include <cmath>
+#include <vector>

 // Convert a std::string to a double
 double util::str2double(const std::string &s) {
@@ -57,7 +58,7 @@
         const std::vector<double> &actual) {
     assert(expected.size() == actual.size());
     double sum = 0.0;
-    for(int i = 0; i < expected.size(); ++i) {
+    for(size_t i = 0; i < expected.size(); ++i) {
         sum += pow(expected[i] - actual[i], 2.0);
     }

@@ -68,7 +69,7 @@
     assert(a.size() == b.size());

     double sum = 0;
-    for(int i = 0; i < a.size(); ++i) {
+    for(size_t i = 0; i < a.size(); ++i) {
         sum += a[i] * b[i];
     }

@@ -81,9 +82,9 @@
     return (double) rand() / (double) RAND_MAX - 0.5;
 }

-bool util::classify(const std::vector<double> &result, int correctIndex)
+bool util::classify(const std::vector<double> &result, size_t correctIndex)
 {
-    for (int i=0; i<result.size(); i++)
+    for (size_t i=0; i<result.size(); i++)
     {
         if (i != correctIndex && result[i] > result[correctIndex])
         {
Index: Util.h
===================================================================
--- Util.h	(revision 112)
+++ Util.h	(revision 113)
@@ -23,22 +23,9 @@

     double multiplyVect(const std::vector<double> &a, const std::vector<double> &b);

-    double forward_neuron_response(const std::vector<double> &weights,
-            const std::vector<double> &inputs);
-
-    double output_neuron_delta(const double &expected,
-            const double &actual,
-            const std::vector<double> &weights,
-            const std::vector<double> &inputs);
-
-    double hidden_neuron_delta(const std::vector<double> &inputs,
-            const std::vector<double> &odelta,
-            const std::vector<double> &hweights,
-            const std::vector<double> &oweights);
-
     double small_random();

-    bool classify(const std::vector<double> &result, int correctIndex);
+    bool classify(const std::vector<double> &result, size_t correctIndex);
 }

 #endif /* _UTIL_H */
Index: SConstruct
===================================================================
--- SConstruct	(revision 112)
+++ SConstruct	(revision 113)
@@ -1,6 +1,5 @@
 env = Environment()
 buildenv = env.Clone()
-buildenv.Append(CFLAGS = Split("-g -O2 -Wall"))
 buildenv.Append(CXXFLAGS = Split("-g -O2 -Wall"))
 Export('buildenv')

Index: NeuralNet.cpp
===================================================================
--- NeuralNet.cpp	(revision 112)
+++ NeuralNet.cpp	(revision 113)
@@ -4,28 +4,18 @@
 #include <iostream>

 NeuralNet::NeuralNet(int numInputs, int numHidden, int numOutput)
+    : mNumInputs(numInputs + 1),
+    mNumHidden(numHidden),
+    mNumOutputs(numOutput),
+    mWin(mNumInputs, mNumHidden),
+    mWout(mNumHidden, mNumOutputs),
+    mInputActivation(mNumInputs, 1.0),
+    mHiddenActivation(mNumHidden),
+    mOutputActivation(mNumOutputs)
 {
-    // Add an additional input as the bias node
-    mNumInputs = numInputs + 1;
-    mNumHidden = numHidden;
-    mNumOutputs = numOutput;
-
-    mWin = new Matrix::Matrix(mNumInputs, mNumHidden);
-    mWout = new Matrix::Matrix(mNumHidden, mNumOutputs);
-
-    mInputActivation = std::vector<double>(mNumInputs, 1.0);
-    mHiddenActivation = std::vector<double>(mNumHidden, 1.0);
-    mOutputActivation = std::vector<double>(mNumOutputs, 1.0);
-
     initialize();
 }

-NeuralNet::~NeuralNet()
-{
-    delete mWin;
-    delete mWout;
-}
-
 std::vector<double> NeuralNet::update(const std::vector<double> &inputs)
 {
     using namespace util;
@@ -34,13 +24,13 @@
     for (int hiddenIdx = 0; hiddenIdx < mNumHidden; ++hiddenIdx)
     {
         mHiddenActivation[hiddenIdx] =
-            sigmoid(multiplyVect(mInputActivation, mWin->getColVector(hiddenIdx)));
+            sigmoid(multiplyVect(mInputActivation, mWin.getColVector(hiddenIdx)));
     }

     for (int outputIdx = 0; outputIdx < mNumOutputs; ++outputIdx)
     {
         mOutputActivation[outputIdx] =
-            sigmoid(multiplyVect(mHiddenActivation, mWout->getColVector(outputIdx)));
+            sigmoid(multiplyVect(mHiddenActivation, mWout.getColVector(outputIdx)));
     }

     return mOutputActivation;
@@ -61,7 +51,7 @@
     // Compute hidden deltas
     for (int j = 0; j < mNumHidden; j++)
     {
-        double error = util::multiplyVect(output_deltas, mWout->getRowVector(j));
+        double error = util::multiplyVect(output_deltas, mWout.getRowVector(j));
         hidden_deltas[j] = util::d_sigmoid(mHiddenActivation[j]) * error;
     }

@@ -70,10 +60,10 @@
     {
         for (int i = 0; i < mNumOutputs; i++)
         {
-            double new_weight = mWout->get(j, i) +
+            double new_weight = mWout.get(j, i) +
                 learningRate * (output_deltas[i] * mOutputActivation[j]);

-            mWout->setElement(j, i, new_weight);
+            mWout.setElement(j, i, new_weight);
         }
     }

@@ -82,10 +72,10 @@
     {
         for (int j = 0; j < mNumHidden; j++)
         {
-            double new_weight = mWin->get(k, j) +
+            double new_weight = mWin.get(k, j) +
                 learningRate * (hidden_deltas[j] * mInputActivation[k]);

-            mWin->setElement(k, j, new_weight);
+            mWin.setElement(k, j, new_weight);
         }
     }

@@ -99,7 +89,7 @@
     {
         for (int j = 0; j < mNumHidden; j++)
         {
-            mWin->setElement(i,j, util::small_random());
+            mWin.setElement(i,j, util::small_random());
         }
     }

@@ -107,7 +97,7 @@
     {
         for (int j = 0; j < mNumOutputs; j++)
         {
-            mWout->setElement(i,j, util::small_random());
+            mWout.setElement(i,j, util::small_random());
         }
     }
 }