[aimc] r295 committed - Style fixes....

[ai...@googlecode.com]

Revision: 295
Author: ro...@google.com
Date: Tue Jun 11 13:41:15 2013
Log: Style fixes.

- Fix most lint errors found by
http://google-styleguide.googlecode.com/svn/trunk/cpplint/cpplint.py
- Clean up commenting style.
- Alphabetize #includes and using statements.


http://code.google.com/p/aimc/source/detail?r=295

Modified:
/trunk/carfac/agc.h
/trunk/carfac/car.h
/trunk/carfac/carfac.cc
/trunk/carfac/carfac.h
/trunk/carfac/carfac_output.cc
/trunk/carfac/carfac_output.h
/trunk/carfac/carfac_test.cc
/trunk/carfac/carfac_util.h
/trunk/carfac/ear.cc
/trunk/carfac/ear.h
/trunk/carfac/ihc.h
/trunk/carfac/sai.h

=======================================
--- /trunk/carfac/agc.h Tue Jun 4 11:30:22 2013
+++ /trunk/carfac/agc.h Tue Jun 11 13:41:15 2013
@@ -24,8 +24,11 @@
#define CARFAC_AGC_H

#include <vector>
+
#include "common.h"

+// Automatic gain control (AGC) parameters, which are used to design the
AGC
+// filters.
struct AGCParams {
AGCParams() {
num_stages = 4;
@@ -53,6 +56,8 @@
std::vector<FPType> agc2_scales;
};

+// Automatic gain control filter coefficients, which are derived from a
set of
+// AGCParams.
struct AGCCoeffs {
int num_agc_stages;
FPType agc_stage_gain;
@@ -71,6 +76,7 @@
FPType decim;
};

+// Automatic gain control filter state.
struct AGCState {
ArrayX agc_memory;
ArrayX input_accum;
=======================================
--- /trunk/carfac/car.h Tue Jun 4 11:30:22 2013
+++ /trunk/carfac/car.h Tue Jun 11 13:41:15 2013
@@ -26,11 +26,10 @@
#include "common.h"

// A CARParams structure stores the necessary information needed by a
CARFAC
-// object to design the set of coefficients implementing 'The Cascade of
+// object to design the set of CARCoeffs implementing 'The Cascade of
// Asymmetric Resonators' described in the chapter of the same name in
Lyon's
-// book "Human and Machine Hearing".
+// book "Human and Machine Hearing".
struct CARParams {
- // The constructor initializes using default parameter values.
CARParams() {
velocity_scale = 0.1;
v_offset = 0.04;
@@ -41,14 +40,15 @@
high_f_damping_compression = 0.5;
erb_per_step = 0.5;
min_pole_hz = 30;
- erb_break_freq = 165.3; // This is the Greenwood map's break
frequency.
- // This represents Glassberg and Moore's high-cf ratio.
- erb_q = 1000/(24.7*4.37);
- };
- FPType velocity_scale; // This is used for the velocity nonlinearity.
+ erb_break_freq = 165.3; // The Greenwood map's break frequency in
Hertz.
+ // Glassberg and Moore's high-cf ratio.
+ erb_q = 1000 / (24.7 * 4.37);
+ }
+
+ FPType velocity_scale; // Used for the velocity nonlinearity.
FPType v_offset; // The offset gives us quadratic part.
- FPType min_zeta; // This is the minimum damping factor in mid-freq
channels.
- FPType max_zeta; // This is the maximum damping factor in mid-freq
channels.
+ FPType min_zeta; // The minimum damping factor in mid-freq channels.
+ FPType max_zeta; // The maximum damping factor in mid-freq channels.
FPType first_pole_theta;
FPType zero_ratio; // This is how far zero is above the pole.
FPType high_f_damping_compression; // A range from 0 to 1 to compress
theta.
@@ -58,8 +58,7 @@
FPType erb_q;
};

-// The CAR coefficients are designed by the CARFAC::DesignCARCoeffs method,
-// which is called during initial construction and resetting of a CARFAC
object.
+// CAR filter coefficients, which are derived from a set of CARParams.
struct CARCoeffs {
FPType velocity_scale;
FPType v_offset;
@@ -72,6 +71,7 @@
};


+// CAR filter state.
struct CARState {
ArrayX z1_memory;
ArrayX z2_memory;
=======================================
--- /trunk/carfac/carfac.cc Tue Jun 11 10:59:08 2013
+++ /trunk/carfac/carfac.cc Tue Jun 11 13:41:15 2013
@@ -60,25 +60,29 @@
std::vector<AGCCoeffs> agc_coeffs;
DesignCARCoeffs(car_params_, sample_rate_, pole_freqs_, &car_coeffs);
DesignIHCCoeffs(ihc_params_, sample_rate_, &ihc_coeffs);
- // This code initializes the coefficients for each of the AGC stages.
DesignAGCCoeffs(agc_params_, sample_rate_, &agc_coeffs);
// Once we have the coefficient structure we can design the ears.
- ears_.clear();
ears_.reserve(num_ears_);
for (int i = 0; i < num_ears_; ++i) {
- ears_.push_back(new Ear(num_channels_, car_coeffs, ihc_coeffs,
agc_coeffs));
+ if (ears_.size() > i && ears_[i] != NULL) {
+ // Reset any existing ears.
+ ears_[i]->Reset(num_channels_, car_coeffs, ihc_coeffs, agc_coeffs);
+ } else {
+ ears_.push_back(
+ new Ear(num_channels_, car_coeffs, ihc_coeffs, agc_coeffs));
+ }
}
}

void CARFAC::RunSegment(const vector<vector<float>>& sound_data,
const int32_t start, const int32_t length,
const bool open_loop, CARFACOutput* seg_output) {
+ assert(sound_data.size() == num_ears_);
// A nested loop structure is used to iterate through the individual
samples
// for each ear (audio channel).
bool updated; // This variable is used by the AGC stage.
for (int32_t timepoint = 0; timepoint < length; ++timepoint) {
for (int audio_channel = 0; audio_channel < num_ears_;
++audio_channel) {
- // First we create a reference to the current Ear object.
Ear* ear = ears_[audio_channel];
// This stores the audio sample currently being processed.
FPType input = sound_data[audio_channel][start + timepoint];
@@ -94,7 +98,7 @@
if (num_ears_ > 1) {
CrossCouple();
}
- if (! open_loop) {
+ if (!open_loop) {
CloseAGCLoop();
}
}
@@ -190,7 +194,7 @@
x = CARFACDetect(x);
conduct_at_0 = x(0);
if (ihc_params.one_capacitor) {
- FPType ro = 1 / conduct_at_10 ;
+ FPType ro = 1 / conduct_at_10;
FPType c = ihc_params.tau1_out / ro;
FPType ri = ihc_params.tau1_in / c;
FPType saturation_output = 1 / ((2 * ro) + ri);
@@ -198,7 +202,7 @@
FPType current = 1 / (ri + r0);
ihc_coeffs->cap1_voltage = 1 - (current * ri);
ihc_coeffs->just_half_wave_rectify = false;
- ihc_coeffs->lpf_coeff = 1 - exp( -1 / (ihc_params.tau_lpf *
sample_rate));
+ ihc_coeffs->lpf_coeff = 1 - exp(-1 / (ihc_params.tau_lpf *
sample_rate));
ihc_coeffs->out1_rate = ro / (ihc_params.tau1_out * sample_rate);
ihc_coeffs->in1_rate = 1 / (ihc_params.tau1_in * sample_rate);
ihc_coeffs->one_capacitor = ihc_params.one_capacitor;
@@ -248,7 +252,7 @@
FPType mix_coeff = agc_params.agc_mix_coeff;
agc_coeff.decimation = agc_params.decimation[stage];
FPType total_dc_gain = previous_stage_gain;
- // Here we calculate the parameters for the current stage.
+ // Calculate the parameters for the current stage.
FPType tau = time_constants[stage];
agc_coeff.decim = decim;
agc_coeff.decim *= agc_coeff.decimation;
@@ -266,9 +270,9 @@
int n_taps = 0;
bool fir_ok = false;
int n_iterations = 1;
- // This section initializes the FIR coeffs settings at each stage.
+ // Initialize the FIR coefficient settings at each stage.
FPType fir_left, fir_mid, fir_right;
- while (! fir_ok) {
+ while (!fir_ok) {
switch (n_taps) {
case 0:
n_taps = 3;
@@ -341,6 +345,6 @@
}

FPType CARFAC::ERBHz(const FPType center_frequency_hz,
- const FPType erb_break_freq, const FPType erb_q) {
+ const FPType erb_break_freq, const FPType erb_q)
const {
return (erb_break_freq + center_frequency_hz) / erb_q;
}
=======================================
--- /trunk/carfac/carfac.h Tue Jun 11 10:59:08 2013
+++ /trunk/carfac/carfac.h Tue Jun 11 13:41:15 2013
@@ -25,28 +25,25 @@

#include <vector>

+#include "agc.h"
+#include "car.h"
+#include "carfac_output.h"
+#include "carfac_util.h"
#include "common.h"
-#include "carfac_util.h"
-#include "car.h"
+#include "ear.h"
#include "ihc.h"
-#include "agc.h"
-#include "ear.h"
-#include "carfac_output.h"

-// This is the top-level class implementing the CAR-FAC C++ model. See the
-// chapter entitled 'The CAR-FAC Digital Cochlear Model' in Lyon's
book "Human
-// and Machine Hearing" for an overview.
+// Top-level class implementing the CAR-FAC C++ model. See the chapter
entitled
+// 'The CAR-FAC Digital Cochlear Model' in Lyon's book "Human and Machine
+// Hearing" for an overview.
//
// A CARFAC object knows how to design its details from a modest set of
// parameters, and knows how to process sound signals to produce "neural
-// activity patterns" (NAPs) which are stored in a CARFACOutput object
during
-// the call to CARFAC::RunSegment.
+// activity patterns" (NAPs) using CARFAC::RunSegment.
class CARFAC {
public:
- // The 'Design' method takes a set of CAR, IHC and AGC parameters along
with
- // arguments specifying the number of 'ears' (audio file channels) and
sample
- // rate. This initializes a vector of 'Ear' objects -- one for mono, two
for
- // stereo, or more.
+ // Constructs a vector of Ear objects, one for each input audio channel,
+ // using the given CAR, IHC and AGC parameters.
CARFAC(const int num_ears, const FPType sample_rate,
const CARParams& car_params, const IHCParams& ihc_params,
const AGCParams& agc_params);
@@ -55,8 +52,11 @@
const CARParams& car_params, const IHCParams& ihc_params,
const AGCParams& agc_params);

- // The 'RunSegment' method processes individual sound segments and
stores the
- // output of the model in a CARFACOutput object.
+ // Processes an individual sound segment and copies the model output to
+ // seg_output.
+ //
+ // The input sound_data should contain a vector of audio samples for each
+ // ear.
void RunSegment(const std::vector<std::vector<float>>& sound_data,
const int32_t start, const int32_t length,
const bool open_loop, CARFACOutput* seg_output);
@@ -71,13 +71,13 @@
void CrossCouple();
void CloseAGCLoop();

- // Function: ERBHz
- // Auditory filter nominal Equivalent Rectangular Bandwidth
+ // Computes the nominal Equivalent Rectangular Bandwidth (ERB) of an
auditory
+ // filter at the given center frequency.
// Ref: Glasberg and Moore: Hearing Research, 47 (1990), 103-138
// See also the section 'Auditory Frequency Scales' of the
chapter 'Acoustic
// Approaches and Auditory Influence' in "Human and Machine Hearing".
FPType ERBHz(const FPType center_frequency_hz, const FPType
erb_break_freq,
- const FPType erb_q);
+ const FPType erb_q) const;

CARParams car_params_;
IHCParams ihc_params_;
@@ -87,7 +87,7 @@
int num_channels_;
FPType max_channels_per_octave_;

- // We store a vector of Ear objects for mono/stereo/multichannel
processing:
+ // One Ear per input audio channel.
std::vector<Ear*> ears_;
ArrayX pole_freqs_;

=======================================
--- /trunk/carfac/carfac_output.cc Tue Jun 11 10:59:08 2013
+++ /trunk/carfac/carfac_output.cc Tue Jun 11 13:41:15 2013
@@ -24,15 +24,12 @@

using std::vector;

-CARFACOutput::CARFACOutput(const bool store_nap, const bool
store_nap_decim,
- const bool store_bm, const bool store_ohc,
- const bool store_agc) {
+CARFACOutput::CARFACOutput(const bool store_nap, const bool store_bm,
+ const bool store_ohc, const bool store_agc) {
store_nap_ = store_nap;
- store_nap_decim_ = store_nap_decim;
store_bm_ = store_bm;
store_ohc_ = store_ohc;
store_agc_ = store_agc;
-
}

void CARFACOutput::AppendOutput(const vector<Ear*>& ears) {
=======================================
--- /trunk/carfac/carfac_output.h Tue Jun 11 10:59:08 2013
+++ /trunk/carfac/carfac_output.h Tue Jun 11 13:41:15 2013
@@ -29,42 +29,44 @@
#include "common.h"
#include "ear.h"

-// A CARFACOutput object can store up to 5 different types of output from a
-// CARFAC model, and is provided as an argument to the CARFAC::RunSegment
-// method.
+// Container for the different types of output from a CARFAC model. See
the
+// private members below for details.
class CARFACOutput {
public:
- // The constructor takes five boolean values as arguments which indicate
- // the portions of the CARFAC model's output to be stored.
- CARFACOutput(const bool store_nap, const bool store_nap_decim,
- const bool store_bm, const bool store_ohc, const bool
store_agc);
+ // The boolean argument indicate which portions of the CARFAC model's
output
+ // should be stored by subsequent calls to AppendOutput.
+ //
+ // TODO(ronw): Consider removing store_nap, unless there is a reasonable
use
+ // case for setting it to false?
+ CARFACOutput(const bool store_nap, const bool store_bm, const bool
store_ohc,
+ const bool store_agc);

- // The AppendOutput method is called on a sample by sample basis by the
- // CARFAC::RunSegemtn method, appending a single frame of n_ears x
n_channels
- // data to the end of the individual data members selected for storage.
+ // Appends a single frame of n_ears x n_channels data to the end of the
+ // individual data members selected for storage. This is called on a
sample
+ // by sample basis by CARFAC::RunSegment.
void AppendOutput(const std::vector<Ear*>& ears);

const std::deque<std::vector<ArrayX>>& nap() const { return nap_; }
const std::deque<std::vector<ArrayX>>& bm() const { return bm_; }
- const std::deque<std::vector<ArrayX>>& nap_decim() const {
- return nap_decim_;
- }
const std::deque<std::vector<ArrayX>>& ohc() const { return ohc_; }
const std::deque<std::vector<ArrayX>>& agc() const { return agc_; }

private:
bool store_nap_;
- bool store_nap_decim_;
bool store_bm_;
bool store_ohc_;
bool store_agc_;

// CARFAC outputs are stored in nested containers with dimensions:
// n_frames x n_ears x n_channels.
+
+ // Neural activity pattern rates.
std::deque<std::vector<ArrayX>> nap_;
- std::deque<std::vector<ArrayX>> nap_decim_;
+ // Basilar membrane displacement.
std::deque<std::vector<ArrayX>> bm_;
+ // Outer hair cell state.
std::deque<std::vector<ArrayX>> ohc_;
+ // Automatic gain control state.
std::deque<std::vector<ArrayX>> agc_;

DISALLOW_COPY_AND_ASSIGN(CARFACOutput);
=======================================
--- /trunk/carfac/carfac_test.cc Tue Jun 4 11:30:22 2013
+++ /trunk/carfac/carfac_test.cc Tue Jun 11 13:41:15 2013
@@ -20,22 +20,22 @@
// See the License for the specific language governing permissions and
// limitations under the License.

+#include <fstream>
#include <string>
-#include <fstream>
#include <vector>

#include "gtest/gtest.h"

+#include "agc.h"
#include "car.h"
-#include "ihc.h"
-#include "agc.h"
#include "carfac.h"
#include "common.h"
+#include "ihc.h"

-using std::vector;
-using std::string;
using std::ifstream;
using std::ofstream;
+using std::string;
+using std::vector;

// This is the 'test_data' subdirectory of aimc/carfac that specifies
where to
// locate the text files produced by 'CARFAC_GenerateTestData.m' for
comparing
@@ -47,7 +47,8 @@
// Three helper functions are defined here for loading the test data
generated
// by the Matlab version of CARFAC.
// This loads one-dimensional ArrayXs from single-column text files.
-void WriteNAPOutput(CARFACOutput& output, const string filename, int ear) {
+void WriteNAPOutput(const CARFACOutput& output, const string filename,
+ int ear) {
string fullfile = kTestSourceDir + filename;
ofstream ofile(fullfile.c_str());
int32_t num_timepoints = output.nap().size();
@@ -56,7 +57,7 @@
for (int32_t i = 0; i < num_timepoints; ++i) {
for (int j = 0; j < channels; ++j) {
ofile << output.nap()[i][ear](j);
- if ( j < channels - 1) {
+ if (j < channels - 1) {
ofile << " ";
}
}
@@ -145,7 +146,7 @@
IHCParams ihc_params;
AGCParams agc_params;
CARFAC mycf(num_ears, 22050, car_params, ihc_params, agc_params);
- CARFACOutput my_output(true, false, true, false, false);
+ CARFACOutput my_output(true, true, false, false);
const bool kOpenLoop = false;
const int length = sound_data[0].size();
mycf.RunSegment(sound_data, 0, length, kOpenLoop, &my_output);
@@ -197,7 +198,7 @@
IHCParams ihc_params;
AGCParams agc_params;
CARFAC mycf(num_ears, 44100, car_params, ihc_params, agc_params);
- CARFACOutput my_output(true, false, true, false, false);
+ CARFACOutput my_output(true, true, false, false);
const bool kOpenLoop = false;
const int length = sound_data[0].size();
mycf.RunSegment(sound_data, 0, length, kOpenLoop, &my_output);
=======================================
--- /trunk/carfac/carfac_util.h Tue Jun 4 11:30:22 2013
+++ /trunk/carfac/carfac_util.h Tue Jun 11 13:41:15 2013
@@ -25,9 +25,8 @@

#include "common.h"

-// Function CARFACDetect
-// This returns the IHC detection nonilnearity function of the filter
output
-// values. This is here because it is called both in design and run
phases.
+// Returns the IHC detection nonilnearity function of the filter output
values.
+// This is here because it is called both in design and run phases.
ArrayX CARFACDetect(const ArrayX& x);

#endif // CARFAC_CARFAC_UTIL_H
=======================================
--- /trunk/carfac/ear.cc Tue Jun 11 10:59:08 2013
+++ /trunk/carfac/ear.cc Tue Jun 11 13:41:15 2013
@@ -21,6 +21,7 @@
// limitations under the License.

#include <assert.h>
+
#include "ear.h"

Ear::Ear(const int num_channels, const CARCoeffs& car_coeffs,
@@ -54,7 +55,7 @@

void Ear::ResetIHCState() {
ihc_state_.ihc_accum = ArrayX::Zero(num_channels_);
- if (! ihc_coeffs_.just_half_wave_rectify) {
+ if (!ihc_coeffs_.just_half_wave_rectify) {
ihc_state_.ac_coupler.setZero(num_channels_);
ihc_state_.lpf1_state.setConstant(num_channels_,
ihc_coeffs_.rest_output);
ihc_state_.lpf2_state.setConstant(num_channels_,
ihc_coeffs_.rest_output);
@@ -78,9 +79,9 @@
}

void Ear::CARStep(const FPType input) {
- // This interpolates g.
+ // Interpolates g.
car_state_.g_memory = car_state_.g_memory + car_state_.dg_memory;
- // This calculates the AGC interpolation state.
+ // Calculates the AGC interpolation state.
car_state_.zb_memory = car_state_.zb_memory + car_state_.dzb_memory;
// This updates the nonlinear function of 'velocity' along with zA,
which is
// a delay of z2.
@@ -114,7 +115,7 @@
// rational function. This makes the result go to zero at high
// absolute velocities, so it will do nothing there.
void Ear::OHCNonlinearFunction(const ArrayX& velocities,
- ArrayX* nonlinear_fun) {
+ ArrayX* nonlinear_fun) const {
*nonlinear_fun = (1 + ((velocities * car_coeffs_.velocity_scale) +
car_coeffs_.v_offset).square()).inverse();
}
@@ -210,7 +211,7 @@
}

void Ear::AGCSpatialSmooth(const AGCCoeffs& agc_coeffs,
- ArrayX* stage_state) {
+ ArrayX* stage_state) const {
int num_iterations = agc_coeffs.agc_spatial_iterations;
bool use_fir;
use_fir = (num_iterations < 4) ? true : false;
@@ -263,11 +264,11 @@

void Ear::AGCSmoothDoubleExponential(const FPType pole_z1,
const FPType pole_z2,
- ArrayX* stage_state) {
+ ArrayX* stage_state) const {
int32_t num_points = stage_state->size();
FPType input;
FPType state = 0.0;
- // TODO (alexbrandmeyer): I'm assuming one dimensional input for now,
but this
+ // TODO(alexbrandmeyer): I'm assuming one dimensional input for now, but
this
// should be verified with Dick for the final version
for (int i = num_points - 11; i < num_points; ++i) {
input = (*stage_state)(i);
@@ -284,7 +285,7 @@
}
}

-ArrayX Ear::StageGValue(const ArrayX& undamping) {
+ArrayX Ear::StageGValue(const ArrayX& undamping) const {
ArrayX r = car_coeffs_.r1_coeffs + car_coeffs_.zr_coeffs * undamping;
return (1 - 2 * r * car_coeffs_.a0_coeffs + (r * r)) /
(1 - 2 * r * car_coeffs_.a0_coeffs + car_coeffs_.h_coeffs * r *
=======================================
--- /trunk/carfac/ear.h Tue Jun 11 10:59:08 2013
+++ /trunk/carfac/ear.h Tue Jun 11 13:41:15 2013
@@ -25,15 +25,15 @@

#include <vector>

+#include "agc.h"
+#include "car.h"
+#include "carfac_util.h"
#include "common.h"
-#include "carfac_util.h"
-#include "car.h"
-#include "agc.h"
#include "ihc.h"

// The Ear object carries out the three steps of the CARFAC model on a
single
// channel of audio data, and stores information about the CAR, IHC and AGC
-// coefficients and states.
+// filter coefficients and states.
class Ear {
public:
Ear(const int num_channels, const CARCoeffs& car_coeffs,
@@ -73,40 +73,47 @@
// coupling of the ears.
const int agc_num_stages() const { return agc_coeffs_.size(); }
const int agc_decim_phase(const int stage) const {
- return agc_state_[stage].decim_phase; }
+ return agc_state_[stage].decim_phase;
+ }
const FPType agc_mix_coeff(const int stage) const {
- return agc_coeffs_[stage].agc_mix_coeffs; }
+ return agc_coeffs_[stage].agc_mix_coeffs;
+ }
const ArrayX& agc_memory(const int stage) const {
- return agc_state_[stage].agc_memory; }
+ return agc_state_[stage].agc_memory;
+ }
const int agc_decimation(const int stage) const {
- return agc_coeffs_[stage].decimation; }
+ return agc_coeffs_[stage].decimation;
+ }

- // This returns the stage G value during the closing of the AGC loop.
- ArrayX StageGValue(const ArrayX& undamping);
+ // Returns the stage G value during the closing of the AGC loop.
+ ArrayX StageGValue(const ArrayX& undamping) const;

- // This function sets the AGC memory during the cross coupling stage.
+ // Sets the AGC memory during the cross coupling stage.
void set_agc_memory(const int stage, const ArrayX& new_values) {
- agc_state_[stage].agc_memory = new_values; }
+ agc_state_[stage].agc_memory = new_values;
+ }

- // These are the setter functions for the CAR memory states.
+ // Setter functions for the CAR memory states.
void set_dzb_memory(const ArrayX& new_values) {
- car_state_.dzb_memory = new_values; }
+ car_state_.dzb_memory = new_values;
+ }
void set_dg_memory(const ArrayX& new_values) {
- car_state_.dg_memory = new_values; }
+ car_state_.dg_memory = new_values;
+ }

private:
- // These methodsinitialize the model state variables prior to runtime.
+ // Initializes the model state variables prior to runtime.
void ResetIHCState();
void ResetAGCState();
void ResetCARState();

- // These are the helper sub-functions called during the model runtime.
+ // Helper sub-functions called during the model runtime.
void OHCNonlinearFunction(const ArrayX& velocities,
- ArrayX* nonlinear_fun);
+ ArrayX* nonlinear_fun) const;
bool AGCRecurse(const int stage, ArrayX agc_in);
- void AGCSpatialSmooth(const AGCCoeffs& agc_coeffs , ArrayX* stage_state);
+ void AGCSpatialSmooth(const AGCCoeffs& agc_coeffs, ArrayX* stage_state)
const;
void AGCSmoothDoubleExponential(const FPType pole_z1, const FPType
pole_z2,
- ArrayX* stage_state);
+ ArrayX* stage_state) const;

CARCoeffs car_coeffs_;
CARState car_state_;
=======================================
--- /trunk/carfac/ihc.h Tue Jun 4 11:30:22 2013
+++ /trunk/carfac/ihc.h Tue Jun 11 13:41:15 2013
@@ -25,6 +25,7 @@

#include "common.h"

+// Inner hair cell (IHC) parameters, which are used to design the IHC
filters.
struct IHCParams {
IHCParams() {
just_half_wave_rectify = false;
@@ -35,7 +36,8 @@
tau2_out = 0.0025;
tau2_in = 0.005;
ac_corner_hz = 20.0;
- };
+ }
+
bool just_half_wave_rectify;
bool one_capacitor;
FPType tau_lpf;
@@ -46,6 +48,8 @@
FPType ac_corner_hz;
};

+// Inner hair cell filter coefficients, which are derived from a set of
+// IHCParams.
struct IHCCoeffs {
bool just_half_wave_rectify;
bool one_capacitor;
@@ -63,6 +67,7 @@
FPType cap2_voltage;
};

+// Inner hair cell filter state.
struct IHCState {
ArrayX ihc_out;
ArrayX ihc_accum;