1 files changed, 29 insertions, 29 deletions

diff --git a/utils/mfcr.h b/utils/mfcr.h
index 396d0205..df988f51 100644
--- a/utils/mfcr.h
+++ b/utils/mfcr.h
@@ -43,29 +43,29 @@ class MFCR {
     num_floors_(num_floors),
     num_tables_(),
     num_customers_(),
-    d_(d),
+    discount_(d),
     alpha_(alpha),
-    d_prior_alpha_(std::numeric_limits<double>::quiet_NaN()),
-    d_prior_beta_(std::numeric_limits<double>::quiet_NaN()),
+    discount_prior_alpha_(std::numeric_limits<double>::quiet_NaN()),
+    discount_prior_beta_(std::numeric_limits<double>::quiet_NaN()),
     alpha_prior_shape_(std::numeric_limits<double>::quiet_NaN()),
     alpha_prior_rate_(std::numeric_limits<double>::quiet_NaN()) {}
 
-  MFCR(unsigned num_floors, double d_alpha, double d_beta, double alpha_shape, double alpha_rate, double d = 0.9, double alpha = 10.0) :
+  MFCR(unsigned num_floors, double discount_alpha, double discount_beta, double alpha_shape, double alpha_rate, double d = 0.9, double alpha = 10.0) :
     num_floors_(num_floors),
     num_tables_(),
     num_customers_(),
-    d_(d),
+    discount_(d),
     alpha_(alpha),
-    d_prior_alpha_(d_alpha),
-    d_prior_beta_(d_beta),
+    discount_prior_alpha_(discount_alpha),
+    discount_prior_beta_(discount_beta),
     alpha_prior_shape_(alpha_shape),
     alpha_prior_rate_(alpha_rate) {}
 
-  double d() const { return d_; }
+  double discount() const { return discount_; }
   double alpha() const { return alpha_; }
 
-  bool has_d_prior() const {
-    return !std::isnan(d_prior_alpha_);
+  bool has_discount_prior() const {
+    return !std::isnan(discount_prior_alpha_);
   }
 
   bool has_alpha_prior() const {
@@ -122,15 +122,15 @@ class MFCR {
     int floor = -1;
     bool share_table = false;
     if (loc.total_dish_count_) {
-      const double p_empty = (alpha_ + num_tables_ * d_) * marg_p0;
-      const double p_share = (loc.total_dish_count_ - loc.table_counts_.size() * d_);
+      const double p_empty = (alpha_ + num_tables_ * discount_) * marg_p0;
+      const double p_share = (loc.total_dish_count_ - loc.table_counts_.size() * discount_);
       share_table = rng->SelectSample(p_empty, p_share);
     }
     if (share_table) {
-      double r = rng->next() * (loc.total_dish_count_ - loc.table_counts_.size() * d_);
+      double r = rng->next() * (loc.total_dish_count_ - loc.table_counts_.size() * discount_);
       for (typename std::list<TableCount>::iterator ti = loc.table_counts_.begin();
            ti != loc.table_counts_.end(); ++ti) {
-        r -= ti->count - d_;
+        r -= ti->count - discount_;
         if (r <= 0.0) {
           ++ti->count;
           floor = ti->floor;
@@ -206,25 +206,25 @@ class MFCR {
     const double marg_p0 = std::inner_product(p0s.begin(), p0s.end(), lambdas.begin(), 0.0);
     assert(marg_p0 <= 1.0);
     const typename std::tr1::unordered_map<Dish, DishLocations, DishHash>::const_iterator it = dish_locs_.find(dish);
-    const double r = num_tables_ * d_ + alpha_;
+    const double r = num_tables_ * discount_ + alpha_;
     if (it == dish_locs_.end()) {
       return r * marg_p0 / (num_customers_ + alpha_);
     } else {
-      return (it->second.total_dish_count_ - d_ * it->second.table_counts_.size() + r * marg_p0) /
+      return (it->second.total_dish_count_ - discount_ * it->second.table_counts_.size() + r * marg_p0) /
                (num_customers_ + alpha_);
     }
   }
 
   double log_crp_prob() const {
-    return log_crp_prob(d_, alpha_);
+    return log_crp_prob(discount_, alpha_);
   }
 
   // taken from http://en.wikipedia.org/wiki/Chinese_restaurant_process
   // does not include draws from G_w's
   double log_crp_prob(const double& d, const double& alpha) const {
     double lp = 0.0;
-    if (has_d_prior())
-      lp = Md::log_beta_density(d, d_prior_alpha_, d_prior_beta_);
+    if (has_discount_prior())
+      lp = Md::log_beta_density(d, discount_prior_alpha_, discount_prior_beta_);
     if (has_alpha_prior())
       lp += Md::log_gamma_density(alpha, alpha_prior_shape_, alpha_prior_rate_);
     assert(lp <= 0.0);
@@ -251,7 +251,7 @@ class MFCR {
   }
 
   void resample_hyperparameters(MT19937* rng, const unsigned nloop = 5, const unsigned niterations = 10) {
-    assert(has_d_prior() || has_alpha_prior());
+    assert(has_discount_prior() || has_alpha_prior());
     DiscountResampler dr(*this);
     ConcentrationResampler cr(*this);
     for (int iter = 0; iter < nloop; ++iter) {
@@ -259,8 +259,8 @@ class MFCR {
         alpha_ = slice_sampler1d(cr, alpha_, *rng, 0.0,
                                std::numeric_limits<double>::infinity(), 0.0, niterations, 100*niterations);
       }
-      if (has_d_prior()) {
-        d_ = slice_sampler1d(dr, d_, *rng, std::numeric_limits<double>::min(),
+      if (has_discount_prior()) {
+        discount_ = slice_sampler1d(dr, discount_, *rng, std::numeric_limits<double>::min(),
                                1.0, 0.0, niterations, 100*niterations);
       }
     }
@@ -279,8 +279,8 @@ class MFCR {
   struct ConcentrationResampler {
     ConcentrationResampler(const MFCR& crp) : crp_(crp) {}
     const MFCR& crp_;
-    double operator()(const double& proposed_alpha) const {
-      return crp_.log_crp_prob(crp_.d_, proposed_alpha);
+    double operator()(const double& proposediscount_alpha) const {
+      return crp_.log_crp_prob(crp_.discount_, proposediscount_alpha);
     }
   };
 
@@ -292,7 +292,7 @@ class MFCR {
   };
 
   void Print(std::ostream* out) const {
-    (*out) << "MFCR(d=" << d_ << ",alpha=" << alpha_ << ") customers=" << num_customers_ << std::endl;
+    (*out) << "MFCR(d=" << discount_ << ",alpha=" << alpha_ << ") customers=" << num_customers_ << std::endl;
     for (typename std::tr1::unordered_map<Dish, DishLocations, DishHash>::const_iterator it = dish_locs_.begin();
          it != dish_locs_.end(); ++it) {
       (*out) << it->first << " (" << it->second.total_dish_count_ << " on " << it->second.table_counts_.size() << " tables): ";
@@ -317,12 +317,12 @@ class MFCR {
   unsigned num_customers_;
   std::tr1::unordered_map<Dish, DishLocations, DishHash> dish_locs_;
 
-  double d_;
+  double discount_;
   double alpha_;
 
-  // optional beta prior on d_ (NaN if no prior)
-  double d_prior_alpha_;
-  double d_prior_beta_;
+  // optional beta prior on discount_ (NaN if no prior)
+  double discount_prior_alpha_;
+  double discount_prior_beta_;
 
   // optional gamma prior on alpha_ (NaN if no prior)
   double alpha_prior_shape_;