Merge pull request #11 from boingoing/ref2

Replace pointer parameters with references
boingoing · Oct 17, 2023 · 644c7b6 · 644c7b6
2 parents d073713 + 6ba2369
commit 644c7b6
Show file tree

Hide file tree

Showing 8 changed files with 106 additions and 106 deletions.
diff --git a/src/FeedForwardNeuralNetwork.cc b/src/FeedForwardNeuralNetwork.cc
@@ -315,7 +315,7 @@ void FeedForwardNeuralNetwork::UpdateSlopes() {
   }
 }
 
-void FeedForwardNeuralNetwork::TrainOffline(TrainingData* training_data,
+void FeedForwardNeuralNetwork::TrainOffline(TrainingData& training_data,
                                             size_t epoch_count) {
   ResetPreviousSlopes();
   ResetWeightSteps();
@@ -327,7 +327,7 @@ void FeedForwardNeuralNetwork::TrainOffline(TrainingData* training_data,
     GetRandom().ShuffleVector(training_data);
 
     // Train the network using offline weight updates - batching.
-    for (const auto& example : *training_data) {
+    for (const auto& example : training_data) {
       // Run the network forward to get values in the output neurons.
       RunForward(example.input);
 
@@ -339,11 +339,11 @@ void FeedForwardNeuralNetwork::TrainOffline(TrainingData* training_data,
     }
 
     // Update weights.
-    UpdateWeightsOffline(i, training_data->size());
+    UpdateWeightsOffline(i, training_data.size());
   }
 }
 
-void FeedForwardNeuralNetwork::TrainOnline(TrainingData* training_data,
+void FeedForwardNeuralNetwork::TrainOnline(TrainingData& training_data,
                                            size_t epoch_count) {
   ResetWeightSteps();
 
@@ -352,7 +352,7 @@ void FeedForwardNeuralNetwork::TrainOnline(TrainingData* training_data,
     GetRandom().ShuffleVector(training_data);
 
     // Train the network using online weight updates - no batching.
-    for (const auto& example : *training_data) {
+    for (const auto& example : training_data) {
       // Run the network forward to get values in the output neurons.
       RunForward(example.input);
 
@@ -365,7 +365,7 @@ void FeedForwardNeuralNetwork::TrainOnline(TrainingData* training_data,
   }
 }
 
-void FeedForwardNeuralNetwork::Train(TrainingData* training_data,
+void FeedForwardNeuralNetwork::Train(TrainingData& training_data,
                                      size_t epoch_count) {
   switch (training_algorithm_type_) {
     case TrainingAlgorithmType::Backpropagation:

diff --git a/src/FeedForwardNeuralNetwork.h b/src/FeedForwardNeuralNetwork.h
@@ -225,7 +225,7 @@ class FeedForwardNeuralNetwork : public Perceptron {
    * @see TrainingAlgorithmType
    * @see TrainingData
    */
-  void Train(TrainingData* training_data, size_t epoch_count);
+  void Train(TrainingData& training_data, size_t epoch_count);
 
  protected:
   void UpdateSlopes();
@@ -241,8 +241,8 @@ class FeedForwardNeuralNetwork : public Perceptron {
   void ResetSlopes();
   void ResetPreviousSlopes();
 
-  void TrainOffline(TrainingData* training_data, size_t epoch_count);
-  void TrainOnline(TrainingData* training_data, size_t epoch_count);
+  void TrainOffline(TrainingData& training_data, size_t epoch_count);
+  void TrainOnline(TrainingData& training_data, size_t epoch_count);
 
  private:
   static constexpr double DefaultLearningRate = 0.7;

diff --git a/src/Perceptron.cc b/src/Perceptron.cc
@@ -295,11 +295,11 @@ void Perceptron::SetWeights(const std::vector<double>& weights) {
   weights_.assign(weights.cbegin(), weights.cend());
 }
 
-void Perceptron::GetOutput(std::vector<double>* output) const {
-  output->resize(GetOutputNeuronCount());
+void Perceptron::GetOutput(std::vector<double>& output) const {
+  output.resize(GetOutputNeuronCount());
   for (size_t i = 0; i < GetOutputNeuronCount(); i++) {
     const auto& neuron = GetOutputNeuron(i);
-    output->at(i) = neuron.value;
+    output[i] = neuron.value;
   }
 }
 

diff --git a/src/Perceptron.h b/src/Perceptron.h
@@ -133,7 +133,7 @@ class Perceptron : public MultiLayerNeuralTopology {
    * Writes all of the output neuron values into |output|.<br/>
    * Existing values in |output| will be discarded.
    */
-  void GetOutput(std::vector<double>* output) const;
+  void GetOutput(std::vector<double>& output) const;
 
   /**
    * Build the neural network.<br/>

diff --git a/src/RandomWrapper.h b/src/RandomWrapper.h
@@ -61,8 +61,8 @@ class RandomWrapper {
    * Shuffle the elements of |vec| into random positions.
    */
   template <typename T>
-  void ShuffleVector(std::vector<T>* vec) {
-    std::shuffle(vec->begin(), vec->end(), Engine());
+  void ShuffleVector(std::vector<T>& vec) {
+    std::shuffle(vec.begin(), vec.end(), Engine());
   }
 
  protected:

diff --git a/src/TrainingData.cc b/src/TrainingData.cc
@@ -14,44 +14,44 @@
 
 namespace {
 
-void SimpleScale(std::vector<double>* vec, double old_min, double factor,
+void SimpleScale(std::vector<double>& vec, double old_min, double factor,
                  double new_min) {
-  for (auto& val : *vec) {
+  for (auto& val : vec) {
     val = (val - old_min) * factor + new_min;
   }
 }
 
-void SimpleDescale(std::vector<double>* vec, double old_min, double factor,
+void SimpleDescale(std::vector<double>& vec, double old_min, double factor,
                    double new_min) {
-  for (auto& val : *vec) {
+  for (auto& val : vec) {
     val = (val - new_min) / factor + old_min;
   }
 }
 
-void StdevScale(std::vector<double>* vec, double mean, double stdev,
+void StdevScale(std::vector<double>& vec, double mean, double stdev,
                 double multiplier) {
-  for (auto& val : *vec) {
+  for (auto& val : vec) {
     val = (val - mean) / (stdev * multiplier);
   }
 }
 
-void StdevDescale(std::vector<double>* vec, double mean, double stdev,
+void StdevDescale(std::vector<double>& vec, double mean, double stdev,
                   double multiplier) {
-  for (auto& val : *vec) {
+  for (auto& val : vec) {
     val = (val * stdev * multiplier) + mean;
   }
 }
 
-void UniformNormScale(std::vector<double>* vec, double mean,
+void UniformNormScale(std::vector<double>& vec, double mean,
                       double uniform_norm, double multiplier) {
-  for (auto& val : *vec) {
+  for (auto& val : vec) {
     val = (val - mean) / (uniform_norm * multiplier);
   }
 }
 
-void UniformNormDescale(std::vector<double>* vec, double mean,
+void UniformNormDescale(std::vector<double>& vec, double mean,
                         double uniform_norm, double multiplier) {
-  for (auto& val : *vec) {
+  for (auto& val : vec) {
     val = (val * uniform_norm * multiplier) + mean;
   }
 }
@@ -193,9 +193,9 @@ void TrainingData::ScaleSimple() {
   CalculateMinMax();
 
   for (auto& example : *this) {
-    SimpleScale(&example.input, input_old_min_, input_factor_,
+    SimpleScale(example.input, input_old_min_, input_factor_,
                 simple_scaling_new_min_);
-    SimpleScale(&example.output, output_old_min_, output_factor_,
+    SimpleScale(example.output, output_old_min_, output_factor_,
                 simple_scaling_new_min_);
   }
 }
@@ -205,9 +205,9 @@ void TrainingData::ScaleStandardDeviation() {
   CalculateStdev();
 
   for (auto& example : *this) {
-    StdevScale(&example.input, input_mean_, input_standard_deviation_,
+    StdevScale(example.input, input_mean_, input_standard_deviation_,
                standard_deviation_multiplier_);
-    StdevScale(&example.output, output_mean_, output_standard_deviation_,
+    StdevScale(example.output, output_mean_, output_standard_deviation_,
                standard_deviation_multiplier_);
   }
 }
@@ -217,36 +217,36 @@ void TrainingData::ScaleUniformNorm() {
   CalculateUniformNorm();
 
   for (auto& example : *this) {
-    UniformNormScale(&example.input, input_mean_, input_uniform_norm_,
+    UniformNormScale(example.input, input_mean_, input_uniform_norm_,
                      uniform_norm_multiplier_);
-    UniformNormScale(&example.output, output_mean_, output_uniform_norm_,
+    UniformNormScale(example.output, output_mean_, output_uniform_norm_,
                      uniform_norm_multiplier_);
   }
 }
 
 void TrainingData::DescaleSimple() {
   for (auto& example : *this) {
-    SimpleDescale(&example.input, input_old_min_, input_factor_,
+    SimpleDescale(example.input, input_old_min_, input_factor_,
                   simple_scaling_new_min_);
-    SimpleDescale(&example.output, output_old_min_, output_factor_,
+    SimpleDescale(example.output, output_old_min_, output_factor_,
                   simple_scaling_new_min_);
   }
 }
 
 void TrainingData::DescaleStandardDeviation() {
   for (auto& example : *this) {
-    StdevDescale(&example.input, input_mean_, input_standard_deviation_,
+    StdevDescale(example.input, input_mean_, input_standard_deviation_,
                  standard_deviation_multiplier_);
-    StdevDescale(&example.output, output_mean_, output_standard_deviation_,
+    StdevDescale(example.output, output_mean_, output_standard_deviation_,
                  standard_deviation_multiplier_);
   }
 }
 
 void TrainingData::DescaleUniformNorm() {
   for (auto& example : *this) {
-    UniformNormDescale(&example.input, input_mean_, input_uniform_norm_,
+    UniformNormDescale(example.input, input_mean_, input_uniform_norm_,
                        uniform_norm_multiplier_);
-    UniformNormDescale(&example.output, output_mean_, output_uniform_norm_,
+    UniformNormDescale(example.output, output_mean_, output_uniform_norm_,
                        uniform_norm_multiplier_);
   }
 }
@@ -281,7 +281,7 @@ void TrainingData::Descale() {
   }
 }
 
-void TrainingData::ScaleInput(std::vector<double>* vec) const {
+void TrainingData::ScaleInput(std::vector<double>& vec) const {
   switch (scaling_algorithm_) {
     case ScalingAlgorithm::None:
       return;
@@ -299,7 +299,7 @@ void TrainingData::ScaleInput(std::vector<double>* vec) const {
   }
 }
 
-void TrainingData::ScaleOutput(std::vector<double>* vec) const {
+void TrainingData::ScaleOutput(std::vector<double>& vec) const {
   switch (scaling_algorithm_) {
     case ScalingAlgorithm::None:
       return;
@@ -317,7 +317,7 @@ void TrainingData::ScaleOutput(std::vector<double>* vec) const {
   }
 }
 
-void TrainingData::DescaleInput(std::vector<double>* vec) const {
+void TrainingData::DescaleInput(std::vector<double>& vec) const {
   switch (scaling_algorithm_) {
     case ScalingAlgorithm::None:
       return;
@@ -335,7 +335,7 @@ void TrainingData::DescaleInput(std::vector<double>* vec) const {
   }
 }
 
-void TrainingData::DescaleOutput(std::vector<double>* vec) const {
+void TrainingData::DescaleOutput(std::vector<double>& vec) const {
   switch (scaling_algorithm_) {
     case ScalingAlgorithm::None:
       return;

diff --git a/src/TrainingData.h b/src/TrainingData.h
@@ -135,28 +135,28 @@ class TrainingData : public std::vector<Example> {
    * Uses the scaling parameters calculated during a previous call to Scale.
    * @see Scale
    */
-  void ScaleInput(std::vector<double>* vec) const;
+  void ScaleInput(std::vector<double>& vec) const;
 
   /**
    * Scale one vector of output.<br/>
    * Uses the scaling parameters calculated during a previous call to Scale.
    * @see Scale
    */
-  void ScaleOutput(std::vector<double>* vec) const;
+  void ScaleOutput(std::vector<double>& vec) const;
 
   /**
    * Descale one vector of input.<br/>
    * Uses the scaling parameters calculated during a previous call to Scale.
    * @see Scale
    */
-  void DescaleInput(std::vector<double>* vec) const;
+  void DescaleInput(std::vector<double>& vec) const;
 
   /**
    * Descale one vector of output.<br/>
    * Uses the scaling parameters calculated during a previous call to Scale.
    * @see Scale
    */
-  void DescaleOutput(std::vector<double>* vec) const;
+  void DescaleOutput(std::vector<double>& vec) const;
 
   /**
    * Convert sequential data into examples.<br/>