changed pointers to references

1 files changed, 26 insertions, 26 deletions

diff --git a/vowpalwabbit/cbify.cc b/vowpalwabbit/cbify.cc
index d41975ae..6c20dc22 100644
--- a/vowpalwabbit/cbify.cc
+++ b/vowpalwabbit/cbify.cc
@@ -17,28 +17,28 @@ namespace CBIFY {
     CB::label cb_label;
   };
   
-  void do_uniform(cbify* data, example* ec)
+  void do_uniform(cbify* data, example& ec)
   {
     //Draw an action
     uint32_t action = (uint32_t)ceil(frand48() * data->k);
     
-    ec->final_prediction = (float)action;
+    ec.final_prediction = (float)action;
   }
   
-  void do_loss(example* ec)
+  void do_loss(example& ec)
   {
-    OAA::mc_label* ld = (OAA::mc_label*)ec->ld;//New loss
+    OAA::mc_label* ld = (OAA::mc_label*)ec.ld;//New loss
     
-    if (ld->label != ec->final_prediction)
-      ec->loss = 1.;
+    if (ld->label != ec.final_prediction)
+      ec.loss = 1.;
     else
-      ec->loss = 0.;
+      ec.loss = 0.;
   }
 
   template <bool is_learn>
-  void predict_or_learn_first(cbify* data, learner& base, example* ec)
+  void predict_or_learn_first(cbify* data, learner& base, example& ec)
   {//Explore tau times, then act according to optimal.
-    OAA::mc_label* ld = (OAA::mc_label*)ec->ld;
+    OAA::mc_label* ld = (OAA::mc_label*)ec.ld;
     //Use CB to find current prediction for remaining rounds.
     if (data->tau > 0)
       {
@@ -46,63 +46,63 @@ namespace CBIFY {
 	do_loss(ec);
 	data->tau--;
 	cout << "tau--" << endl;
-	uint32_t action = (uint32_t)ec->final_prediction;
-	CB::cb_class l = {ec->loss, action, 1.f / data->k};
+	uint32_t action = (uint32_t)ec.final_prediction;
+	CB::cb_class l = {ec.loss, action, 1.f / data->k};
 	data->cb_label.costs.erase();
 	data->cb_label.costs.push_back(l);
-	ec->ld = &(data->cb_label);
+	ec.ld = &(data->cb_label);
 	if (is_learn)
 	  base.learn(ec);
 	else
 	  base.predict(ec);
-	ec->final_prediction = (float)action;
-	ec->loss = l.cost;
+	ec.final_prediction = (float)action;
+	ec.loss = l.cost;
       }
     else
       {
 	data->cb_label.costs.erase();
-	ec->ld = &(data->cb_label);
+	ec.ld = &(data->cb_label);
 	if (is_learn)
 	  base.learn(ec);
 	else
 	  base.predict(ec);
 	do_loss(ec);
       }
-    ec->ld = ld;
+    ec.ld = ld;
   }
   
   template <bool is_learn>
-  void predict_or_learn_greedy(cbify* data, learner& base, example* ec)
+  void predict_or_learn_greedy(cbify* data, learner& base, example& ec)
   {//Explore uniform random an epsilon fraction of the time.
-    OAA::mc_label* ld = (OAA::mc_label*)ec->ld;
+    OAA::mc_label* ld = (OAA::mc_label*)ec.ld;
     
     data->cb_label.costs.erase();
-    ec->ld = &(data->cb_label);
+    ec.ld = &(data->cb_label);
     base.predict(ec);
     do_loss(ec);
-    uint32_t action = (uint32_t)ec->final_prediction;
+    uint32_t action = (uint32_t)ec.final_prediction;
 
     float base_prob = data->epsilon / data->k;
     if (frand48() < 1. - data->epsilon)
       {
-	CB::cb_class l = {ec->loss, action, 1.f - data->epsilon + base_prob};
+	CB::cb_class l = {ec.loss, action, 1.f - data->epsilon + base_prob};
 	data->cb_label.costs.push_back(l);
       }
     else
       {
 	do_uniform(data, ec);
 	do_loss(ec);
-	action = (uint32_t)ec->final_prediction;
-	CB::cb_class l = {ec->loss, (uint32_t)ec->final_prediction, base_prob};
+	action = (uint32_t)ec.final_prediction;
+	CB::cb_class l = {ec.loss, (uint32_t)ec.final_prediction, base_prob};
 	data->cb_label.costs.push_back(l);
       }
 
     if (is_learn)
 	base.learn(ec);
 
-    ec->final_prediction = (float)action;
-    ec->loss = data->cb_label.costs[0].cost;
-    ec->ld = ld;
+    ec.final_prediction = (float)action;
+    ec.loss = data->cb_label.costs[0].cost;
+    ec.ld = ld;
   }
 
     void learn_bagging(void* d, learner& base, example* ec)