changeset 696:d8a404fbc4df

Rename variables to be consistent with the rest of the library.

--- a/trunk/carfac/carfac_test.cc	Wed Jun 26 23:35:47 2013 +0000
+++ b/trunk/carfac/carfac_test.cc	Thu Jun 27 15:30:46 2013 +0000
@@ -68,8 +68,8 @@
 // Reads a size rows vector of size columns Container objects from a
 // multi-column text file generated by the Matlab version of CARFAC.
 template <typename Container = ArrayX, bool ColMajor = true>
-vector<Container> Load2dTestData(const string& filename, const int rows,
-                                 const int columns) {
+vector<Container> Load2dTestData(const string& filename, int rows,
+                                 int columns) {
   string fullfile = kTestSourceDir + filename;
   ifstream file(fullfile.c_str());
   vector<Container> output;
@@ -96,19 +96,22 @@
 // Reads a two dimensional vector of audio data from a text file
 // containing the output of the Matlab wavread() function.
 vector<vector<float>> Load2dAudioVector(string filename, int timepoints,
-                                        int channels) {
-  return Load2dTestData<vector<float>, false>(filename, timepoints, channels);
+                                        int num_channels) {
+  return Load2dTestData<vector<float>, false>(filename, timepoints,
+                                              num_channels);
 }
 
 class CARFACTest : public testing::Test {
  protected:
-  deque<vector<ArrayX>> LoadTestData(
-      const string& basename, int n_timepoints, int n_ears, int n_ch) const {
-    deque<vector<ArrayX>> test_data(n_timepoints, vector<ArrayX>(n_ears));
-    for (int ear = 0; ear < n_ears; ++ear) {
+  deque<vector<ArrayX>> LoadTestData(const string& basename,
+                                     int num_samples,
+                                     int num_ears,
+                                     int num_channels) const {
+    deque<vector<ArrayX>> test_data(num_samples, vector<ArrayX>(num_ears));
+    for (int ear = 0; ear < num_ears; ++ear) {
       string filename = basename + std::to_string(ear + 1) + ".txt";
-      vector<ArrayX> data = Load2dTestData(filename, n_timepoints, n_ch);
-      for (int i = 0; i < n_timepoints; ++i) {
+      vector<ArrayX> data = Load2dTestData(filename, num_samples, num_channels);
+      for (int i = 0; i < num_samples; ++i) {
         test_data[i][ear] = data[i];
       }
     }
@@ -117,10 +120,12 @@
 
   void AssertCARFACOutputNear(const deque<vector<ArrayX>>& expected,
                               const deque<vector<ArrayX>>& actual,
-                              int n_timepoints, int n_ears, int n_ch) const {
-    for (int timepoint = 0; timepoint < n_timepoints; ++timepoint) {
-      for (int ear = 0; ear < n_ears; ++ear) {
-        for (int channel = 0; channel < n_ch; ++channel) {
+                              int num_samples,
+                              int num_ears,
+                              int num_channels) const {
+    for (int timepoint = 0; timepoint < num_samples; ++timepoint) {
+      for (int ear = 0; ear < num_ears; ++ear) {
+        for (int channel = 0; channel < num_channels; ++channel) {
           const float kPrecisionLevel = 1.0e-7;
           ASSERT_NEAR(expected[timepoint][ear](channel),
                       actual[timepoint][ear](channel),
@@ -136,12 +141,12 @@
 };
 
 TEST_F(CARFACTest, BinauralData) {
-  const int n_timepoints = 882;
-  const int n_ears = 2;
-  const int n_ch = 71;
+  const int kNumSamples = 882;
+  const int kNumEars = 2;
+  const int kNumChannels = 71;
   vector<vector<float>> sound_data =
-      Load2dAudioVector("file_signal_binaural_test.txt", n_timepoints, n_ears);
-  CARFAC carfac(n_ears, 22050, car_params_, ihc_params_, agc_params_);
+      Load2dAudioVector("file_signal_binaural_test.txt", kNumSamples, kNumEars);
+  CARFAC carfac(kNumEars, 22050, car_params_, ihc_params_, agc_params_);
   CARFACOutput output(true, true, false, false);
   const bool kOpenLoop = false;
   const int length = sound_data[0].size();
@@ -153,22 +158,22 @@
   WriteNAPOutput(output, "cpp_nap_output_2_binaural_test.txt", 1);
 
   deque<vector<ArrayX>> expected_nap =
-      LoadTestData("binaural_test_nap", n_timepoints, n_ears, n_ch);
+      LoadTestData("binaural_test_nap", kNumSamples, kNumEars, kNumChannels);
   AssertCARFACOutputNear(expected_nap, output.nap(),
-                         n_timepoints, n_ears, n_ch);
+                         kNumSamples, kNumEars, kNumChannels);
   deque<vector<ArrayX>> expected_bm =
-      LoadTestData("binaural_test_bm", n_timepoints, n_ears, n_ch);
+      LoadTestData("binaural_test_bm", kNumSamples, kNumEars, kNumChannels);
   AssertCARFACOutputNear(expected_bm, output.bm(),
-                         n_timepoints, n_ears, n_ch);
+                         kNumSamples, kNumEars, kNumChannels);
 }
 
 TEST_F(CARFACTest, LongBinauralData) {
-  const int n_timepoints = 2000;
-  const int n_ears = 2;
-  const int n_ch = 83;
+  const int kNumSamples = 2000;
+  const int kNumEars = 2;
+  const int kNumChannels = 83;
   vector<vector<float>> sound_data =
-      Load2dAudioVector("file_signal_long_test.txt", n_timepoints, n_ears);
-  CARFAC carfac(n_ears, 44100, car_params_, ihc_params_, agc_params_);
+      Load2dAudioVector("file_signal_long_test.txt", kNumSamples, kNumEars);
+  CARFAC carfac(kNumEars, 44100, car_params_, ihc_params_, agc_params_);
   CARFACOutput output(true, true, false, false);
   const bool kOpenLoop = false;
   const int length = sound_data[0].size();
@@ -180,11 +185,11 @@
   WriteNAPOutput(output, "cpp_nap_output_2_long_test.txt", 1);
 
   deque<vector<ArrayX>> expected_nap =
-      LoadTestData("long_test_nap", n_timepoints, n_ears, n_ch);
+      LoadTestData("long_test_nap", kNumSamples, kNumEars, kNumChannels);
   AssertCARFACOutputNear(expected_nap, output.nap(),
-                         n_timepoints, n_ears, n_ch);
+                         kNumSamples, kNumEars, kNumChannels);
   deque<vector<ArrayX>> expected_bm =
-      LoadTestData("long_test_bm", n_timepoints, n_ears, n_ch);
+      LoadTestData("long_test_bm", kNumSamples, kNumEars, kNumChannels);
   AssertCARFACOutputNear(expected_bm, output.bm(),
-                         n_timepoints, n_ears, n_ch);
+                         kNumSamples, kNumEars, kNumChannels);
 }

--- a/trunk/carfac/sai.cc	Wed Jun 26 23:35:47 2013 +0000
+++ b/trunk/carfac/sai.cc	Thu Jun 27 15:30:46 2013 +0000
@@ -30,10 +30,10 @@
          "SAI window_width must be larger than width.");
 
   int buffer_width = params_.width +
-      static_cast<int>((1 + static_cast<float>(params_.n_window_pos - 1)/2) *
+      static_cast<int>((1 + static_cast<float>(params_.num_window_pos - 1)/2) *
                        params_.window_width);
-  input_buffer_.setZero(params_.n_ch, buffer_width);
-  output_buffer_.setZero(params_.n_ch, params_.width);
+  input_buffer_.setZero(params_.num_channels, buffer_width);
+  output_buffer_.setZero(params_.num_channels, params_.width);
 
   window_.setLinSpaced(params_.window_width, kPi / params_.window_width, kPi)
       .sin();
@@ -48,21 +48,21 @@
                      ArrayXX* output_frame) {
   assert(!input.empty() || input.size() <= params_.window_width &&
          "Unexpected input size.");
-  assert(input[0].size() == params_.n_ch &&
+  assert(input[0].size() == params_.num_channels &&
          "Unexpected input frame size.");
 
   // Append new data to the input buffer.
-  int n_shift = input.size();
-  int shift_width = input_buffer_.cols() - n_shift;
-  input_buffer_.topLeftCorner(params_.n_ch, shift_width).swap(
-      input_buffer_.block(0, n_shift, params_.n_ch, shift_width));
+  int num_shift = input.size();
+  int shift_width = input_buffer_.cols() - num_shift;
+  input_buffer_.topLeftCorner(params_.num_channels, shift_width).swap(
+      input_buffer_.block(0, num_shift, params_.num_channels, shift_width));
   for (int i = 0; i < input.size(); ++i) {
     input_buffer_.block(0, shift_width + i, input[i].size(), 1) = input[i];
   }
   // Zero-pad the buffer if necessary.
   if (input.size() < params_.window_width) {
     int pad_width = params_.window_width - input.size();
-    input_buffer_.topRightCorner(params_.n_ch, pad_width).setZero();
+    input_buffer_.topRightCorner(params_.num_channels, pad_width).setZero();
   }
 
   StabilizeSegment(input_buffer_, &output_buffer_);
@@ -74,17 +74,17 @@
   // Windows are always approximately 50% overlapped.
   float window_hop = params_.window_width / 2;
   int window_start = (input_buffer.cols() - params_.window_width) -
-      (params_.n_window_pos - 1) * window_hop;
+      (params_.num_window_pos - 1) * window_hop;
   int window_range_start = window_start - params_.future_lags - 1;
   int offset_range_start = window_start - params_.width;
   assert(offset_range_start >= 0);
-  for (int i = 0; i < params_.n_ch; ++i) {
+  for (int i = 0; i < params_.num_channels; ++i) {
     // TODO(ronw): Rename this here and in the Matlab code since the
     // input doesn't have to contain naps.
     const ArrayX& nap_wave = input_buffer.row(i);
     // TODO(ronw): Smooth row.
 
-    for (int w = 0; w < params_.n_window_pos; ++w) {
+    for (int w = 0; w < params_.num_window_pos; ++w) {
       int current_window_offset = w * window_hop;
       // Choose a trigger point.
       int trigger_time;

--- a/trunk/carfac/sai.h	Wed Jun 26 23:35:47 2013 +0000
+++ b/trunk/carfac/sai.h	Thu Jun 27 15:30:46 2013 +0000
@@ -27,7 +27,7 @@
 // Design parameters for a single SAI.
 struct SAIParams {
   // Number of channels (height) of the SAI.
-  int n_ch;
+  int num_channels;
 
   // TODO(ronw): Consider parameterizing this as past_lags and
   // future_lags, with width == past_lags + 1 + future_lags.
@@ -37,7 +37,7 @@
   // Number of lag samples that should come from the future.
   int future_lags;
   // Number of windows (triggers) to consider during each SAI frame.
-  int n_window_pos;
+  int num_window_pos;
 
   // TODO(ronw): more carefully define terms "window" and "frame"
 
@@ -57,11 +57,11 @@
   // Reset the internal state.
   void Reset();
 
-  // Fills output_frame with a params_.n_ch by params_.width SAI frame
+  // Fills output_frame with a params_.num_channels by params_.width SAI frame
   // computed from the given input frames.
   //
   // The input should have dimensionality of params_.window_width by
-  // params_.n_ch.  Inputs containing too few frames are zero-padded.
+  // params_.num_channels.  Inputs containing too few frames are zero-padded.
   // FIXME: ArrayXX input type would be less awkward.
   void RunSegment(const std::vector<ArrayX>& input,
                   ArrayXX* output_output_frame);
@@ -77,9 +77,9 @@
   // Size: params_.window_width.
   ArrayX window_;
   // Buffer to store a large enough window of input frames to compute
-  // a full SAI frame.  Size: params_.n_ch by params_.buffer_width.
+  // a full SAI frame.  Size: params_.num_channels by params_.buffer_width.
   ArrayXX input_buffer_;
-  // Output frame buffer.  Size: params_.n_ch by params_.width.
+  // Output frame buffer.  Size: params_.num_channels by params_.width.
   ArrayXX output_buffer_;
 };
 

--- a/trunk/carfac/sai_test.cc	Wed Jun 26 23:35:47 2013 +0000
+++ b/trunk/carfac/sai_test.cc	Thu Jun 27 15:30:46 2013 +0000
@@ -36,10 +36,10 @@
 using testing::Values;
 using std::vector;
 
-vector<ArrayX> CreateZeroSegment(int n_ch, int length) {
+vector<ArrayX> CreateZeroSegment(int num_channels, int length) {
   vector<ArrayX> segment;
   for (int i = 0; i < length; ++i) {
-    segment.push_back(ArrayX::Zero(n_ch));
+    segment.push_back(ArrayX::Zero(num_channels));
   }
   return segment;
 }
@@ -77,16 +77,16 @@
  protected:
   void SetUp() {
     period_ = std::tr1::get<0>(GetParam());
-    n_ch_ = std::tr1::get<1>(GetParam());
+    num_channels_ = std::tr1::get<1>(GetParam());
   }
 
   int period_;
-  int n_ch_;
+  int num_channels_;
 };
 
 TEST_P(SAIPeriodicInputTest, MultiChannelPulseTrain) {
-  vector<ArrayX> segment = CreateZeroSegment(n_ch_, 38);
-  for (int i = 0; i < n_ch_; ++i) {
+  vector<ArrayX> segment = CreateZeroSegment(num_channels_, 38);
+  for (int i = 0; i < num_channels_; ++i) {
     // Begin each channel at a different phase.
     const int phase = i;
     for (int j = phase; j < segment.size(); j += period_) {
@@ -96,12 +96,12 @@
 
   SAIParams sai_params;
   sai_params.window_width = segment.size();
-  sai_params.n_ch = n_ch_;
+  sai_params.num_channels = num_channels_;
   sai_params.width = 15;
   // Half of the SAI should come from the future.
   // sai_params.future_lags = sai_params.width / 2;
   sai_params.future_lags = 0;
-  sai_params.n_window_pos = 2;
+  sai_params.num_window_pos = 2;
 
   SAI sai(sai_params);
   ArrayXX sai_frame;
@@ -109,7 +109,7 @@
 
   // The output should have peaks at the same positions, regardless of
   // input phase.
-  for (int i = 0; i < n_ch_; ++i) {
+  for (int i = 0; i < num_channels_; ++i) {
     const ArrayX& sai_channel = sai_frame.row(i);
     for (int j = sai_channel.size() - 1; j >= 0; j -= period_) {
       EXPECT_TRUE(HasPeakAt(sai_channel, j));
@@ -123,26 +123,26 @@
 }
 INSTANTIATE_TEST_CASE_P(PeriodicInputVariations, SAIPeriodicInputTest,
                         testing::Combine(Values(25, 10, 5, 2),  // periods.
-                                         Values(1, 2, 15)));  // n_ch.
+                                         Values(1, 2, 15)));  // num_channels.
 
 TEST(SAITest, CARFACIntegration) {
-  const int n_ears = 1;
-  const int length = 300;
-  vector<vector<float>> segment(n_ears, vector<float>(length, 0.0));
+  const int kNumEars = 1;
+  const int kNumSamples = 300;
+  vector<vector<float>> segment(kNumEars, vector<float>(kNumSamples, 0.0));
 
   // Sinusoid input.
   const float kFrequency = 10;
   Eigen::Map<Eigen::ArrayXf> segment_array(&segment[0][0], segment[0].size());
-  segment_array.setLinSpaced(length, 0.0, 2 * kFrequency * kPi);
+  segment_array.setLinSpaced(kNumSamples, 0.0, 2 * kFrequency * kPi);
   segment_array.sin();
 
   CARParams car_params;
   IHCParams ihc_params;
   AGCParams agc_params;
-  CARFAC carfac(n_ears, 800, car_params, ihc_params, agc_params);
+  CARFAC carfac(kNumEars, 800, car_params, ihc_params, agc_params);
   CARFACOutput output(true, false, false, false);
   const bool kOpenLoop = false;
-  carfac.RunSegment(segment, 0, length, kOpenLoop, &output);
+  carfac.RunSegment(segment, 0, kNumSamples, kOpenLoop, &output);
 
   vector<ArrayX> nap_segment;
   nap_segment.reserve(output.nap().size());
@@ -151,12 +151,12 @@
   }
 
   SAIParams sai_params;
-  sai_params.window_width = length;
-  sai_params.n_ch = carfac.num_channels();
+  sai_params.window_width = kNumSamples;
+  sai_params.num_channels = carfac.num_channels();
   sai_params.width = 20;
   // Half of the SAI should come from the future.
   sai_params.future_lags = sai_params.width / 2;
-  sai_params.n_window_pos = 2;
+  sai_params.num_window_pos = 2;
   SAI sai(sai_params);
   ArrayXX sai_frame;
   sai.RunSegment(nap_segment, &sai_frame);