Skip to content

Commit

Permalink
Fix g++/clang++ '-Wextra' warnings
Browse files Browse the repository at this point in the history
  • Loading branch information
@renatocf
renatocf committed Jul 5, 2015
1 parent 87fe05d commit b8ae84e
Show file tree
Hide file tree
Showing 17 changed files with 189 additions and 173 deletions.
4 changes: 4 additions & 0 deletions include/model/DecodableModelCrtp.tcc
View file
Original file line number Diff line number Diff line change
Expand Up @@ -82,7 +82,11 @@ class DecodableModelCrtp : public ProbabilisticModelCrtp<Derived> {
using SGPtr = SimpleGeneratorPtr<Decorator, Derived>;

// Hidden name method inheritance
using Base::initializeCache;
using Base::evaluateSymbol;
using Base::evaluateSequence;

using Base::drawSymbol;
using Base::drawSequence;

// Overriden methods
Expand Down
13 changes: 6 additions & 7 deletions include/model/GeneralizedHiddenMarkovModel.hpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -125,13 +125,12 @@ class GeneralizedHiddenMarkovModel
Matrix &probabilities,
Labeling<Sequence>::Method method) const override;

// Virtual methods
virtual double backward(const Sequence &s,
Matrix &beta) const;
virtual double forward(const Sequence &s,
Matrix &alpha) const;
virtual void posteriorProbabilities(const Sequence &xs,
Matrix &probabilities) const;
double forward(const Sequence &sequence, Matrix &alpha) const override;

double backward(const Sequence &sequence, Matrix &beta) const override;

void posteriorProbabilities(const Sequence &sequence,
Matrix &probabilities) const override;

// Concrete methods
// Estimation<Labeling<Sequence>>
Expand Down
12 changes: 6 additions & 6 deletions include/model/HiddenMarkovModel.hpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -135,12 +135,12 @@ class HiddenMarkovModel
Labeling<Sequence>::Method method) const override;

// Virtual methods
virtual double backward(const Sequence &s,
Matrix &beta) const;
virtual double forward(const Sequence &s,
Matrix &alpha) const;
virtual void posteriorProbabilities(const Sequence &xs,
Matrix &probabilities) const;
virtual double backward(const Sequence &sequence,
Matrix &beta) const override;
virtual double forward(const Sequence &sequence,
Matrix &alpha) const override;
virtual void posteriorProbabilities(const Sequence &sequence,
Matrix &probabilities) const override;

// Concrete methods
// Estimation<Labeling<Sequence>>
Expand Down
9 changes: 5 additions & 4 deletions include/model/ProbabilisticModelCrtp.tcc
View file
Original file line number Diff line number Diff line change
Expand Up @@ -198,10 +198,11 @@ ProbabilisticModelCrtp<Derived>::evaluateSymbol(CEPtr<Standard> evaluator,

template<typename Derived>
Probability
ProbabilisticModelCrtp<Derived>::evaluateSequence(CEPtr<Standard> evaluator,
unsigned int begin,
unsigned int end,
unsigned int phase) const {
ProbabilisticModelCrtp<Derived>::evaluateSequence(
CEPtr<Standard> evaluator,
unsigned int begin,
unsigned int end,
unsigned int /* phase */) const {
auto &prefix_sum_array = evaluator->cache().prefix_sum_array;
return prefix_sum_array[end] - prefix_sum_array[begin];
}
Expand Down
2 changes: 1 addition & 1 deletion include/model/ProbabilisticModelDecorator.tcc
View file
Original file line number Diff line number Diff line change
Expand Up @@ -72,7 +72,7 @@ class ProbabilisticModelDecorator
}

// Overriden methods
Standard<Symbol> drawSymbol(SGPtr<Standard> generator,
Standard<Symbol> drawSymbol(SGPtr<Standard> /* generator */,
unsigned int pos,
unsigned int phase,
const Sequence &context) const override {
Expand Down
11 changes: 6 additions & 5 deletions src/model/DiscreteIIDModel.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -452,16 +452,17 @@ double DiscreteIIDModel::sj_bandwidth(const std::vector<double> &data) {

Probability DiscreteIIDModel::evaluateSymbol(SEPtr<Standard> evaluator,
unsigned int pos,
unsigned int phase) const {
unsigned int /* phase */) const {
return probabilityOf(evaluator->sequence()[pos]);
}

/*=============================== GENERATOR ================================*/

Standard<Symbol> DiscreteIIDModel::drawSymbol(SGPtr<Standard> generator,
unsigned int pos,
unsigned int phase,
const Sequence &context) const {
Standard<Symbol>
DiscreteIIDModel::drawSymbol(SGPtr<Standard> /* generator */,
unsigned int /* pos */,
unsigned int /* phase */,
const Sequence &/* context */) const {
return draw();
}

Expand Down
2 changes: 1 addition & 1 deletion src/model/FixedSequenceAtPosition.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -71,7 +71,7 @@ FixedSequenceAtPosition::evaluateSequence(SEPtr<Standard> evaluator,
/*============================== GENERATOR =================================*/

Standard<Sequence>
FixedSequenceAtPosition::drawSequence(SGPtr<Standard> generator,
FixedSequenceAtPosition::drawSequence(SGPtr<Standard> /* generator */,
unsigned int size,
unsigned int phase) const {
Sequence s = _model->standardGenerator()->drawSequence(size, phase);
Expand Down
110 changes: 55 additions & 55 deletions src/model/GeneralizedHiddenMarkovModel.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -71,72 +71,74 @@ GeneralizedHiddenMarkovModelPtr GeneralizedHiddenMarkovModel::make(

/*=============================== EVALUATOR ================================*/

void GeneralizedHiddenMarkovModel::initializeCache(CEPtr<Standard> evaluator,
unsigned int phase) {
void
GeneralizedHiddenMarkovModel::initializeCache(CEPtr<Standard> /* evaluator */,
unsigned int /* phase */) {
// TODO(igorbonadio)
}

/*----------------------------------------------------------------------------*/

Probability
GeneralizedHiddenMarkovModel::evaluateSymbol(SEPtr<Standard> evaluator,
unsigned int pos,
unsigned int phase) const {
GeneralizedHiddenMarkovModel::evaluateSymbol(SEPtr<Standard> /* evaluator */,
unsigned int /* pos */,
unsigned int /* phase */) const {
return -HUGE; // TODO(igorbonadio)
}

/*----------------------------------------------------------------------------*/

Probability
GeneralizedHiddenMarkovModel::evaluateSequence(SEPtr<Standard> evaluator,
unsigned int begin,
unsigned int end,
unsigned int phase) const {
GeneralizedHiddenMarkovModel::evaluateSequence(SEPtr<Standard> /* evaluator */,
unsigned int /* begin */,
unsigned int /* end */,
unsigned int /* phase */) const {
return -HUGE; // TODO(igorbonadio)
}

/*----------------------------------------------------------------------------*/

Probability
GeneralizedHiddenMarkovModel::evaluateSymbol(CEPtr<Standard> evaluator,
unsigned int pos,
unsigned int phase) const {
GeneralizedHiddenMarkovModel::evaluateSymbol(CEPtr<Standard> /* evaluator */,
unsigned int /* pos */,
unsigned int /* phase */) const {
return -HUGE; // TODO(igorbonadio)
}

/*----------------------------------------------------------------------------*/

Probability
GeneralizedHiddenMarkovModel::evaluateSequence(CEPtr<Standard> evaluator,
unsigned int begin,
unsigned int end,
unsigned int phase) const {
GeneralizedHiddenMarkovModel::evaluateSequence(CEPtr<Standard> /* evaluator */,
unsigned int /* begin */,
unsigned int /* end */,
unsigned int /* phase */) const {
return -HUGE; // TODO(igorbonadio)
}

/*----------------------------------------------------------------------------*/

void GeneralizedHiddenMarkovModel::initializeCache(CEPtr<Labeling> evaluator,
unsigned int phase) {
void
GeneralizedHiddenMarkovModel::initializeCache(CEPtr<Labeling> /* evaluator */,
unsigned int /* phase */) {
// TODO(igorbonadio)
}

/*----------------------------------------------------------------------------*/

Probability
GeneralizedHiddenMarkovModel::evaluateSymbol(SEPtr<Labeling> evaluator,
unsigned int pos,
unsigned int phase) const {
GeneralizedHiddenMarkovModel::evaluateSymbol(SEPtr<Labeling> /* evaluator */,
unsigned int /* pos */,
unsigned int /* phase */) const {
return -HUGE; // TODO(igorbonadio)
}

/*----------------------------------------------------------------------------*/

Probability
GeneralizedHiddenMarkovModel::evaluateSequence(SEPtr<Labeling> evaluator,
unsigned int begin,
unsigned int end,
unsigned int phase) const {
unsigned int /* begin */,
unsigned int /* end */,
unsigned int /* phase */) const {
double prob = 0;
auto segments = Segment::readSequence(evaluator->sequence().label());
for (unsigned int i = 0; i < segments.size(); i++) {
Expand Down Expand Up @@ -178,29 +180,29 @@ GeneralizedHiddenMarkovModel::evaluateSequence(CEPtr<Labeling> evaluator,
/*=============================== GENERATOR ================================*/

Standard<Symbol>
GeneralizedHiddenMarkovModel::drawSymbol(SGPtr<Standard> generator,
unsigned int pos,
unsigned int phase,
const Sequence &context) const {
GeneralizedHiddenMarkovModel::drawSymbol(SGPtr<Standard> /* generator */,
unsigned int /* pos */,
unsigned int /* phase */,
const Sequence &/* context */) const {
return Standard<Symbol>(INVALID_SYMBOL); // TODO(igorbonadio)
}

/*----------------------------------------------------------------------------*/

Labeling<Symbol>
GeneralizedHiddenMarkovModel::drawSymbol(SGPtr<Labeling> generator,
unsigned int pos,
unsigned int phase,
const Sequence &context) const {
GeneralizedHiddenMarkovModel::drawSymbol(SGPtr<Labeling> /* generator */,
unsigned int /* pos */,
unsigned int /* phase */,
const Sequence &/* context */) const {
return Labeling<Symbol>(INVALID_SYMBOL, INVALID_SYMBOL); // TODO(igorbonadio)
}

/*----------------------------------------------------------------------------*/

Labeling<Sequence>
GeneralizedHiddenMarkovModel::drawSequence(SGPtr<Labeling> generator,
GeneralizedHiddenMarkovModel::drawSequence(SGPtr<Labeling> /* generator */,
unsigned int size,
unsigned int phase) const {
unsigned int /* phase */) const {
// TODO(igorbonadio)
return Labeling<Sequence>(Sequence(INVALID_SYMBOL, size),
Sequence(INVALID_SYMBOL, size));
Expand Down Expand Up @@ -316,16 +318,14 @@ GeneralizedHiddenMarkovModel::posteriorDecoding(const Sequence &xs,
Labeling<Sequence>(xs, std::move(path)), -HUGE); // TODO(igorbonadio)
}

/*----------------------------------------------------------------------------*/
/* VIRTUAL METHODS */
/*----------------------------------------------------------------------------*/

double GeneralizedHiddenMarkovModel::forward(const Sequence &xs,
double GeneralizedHiddenMarkovModel::forward(const Sequence &sequence,
Matrix &alpha) const {
alpha = std::vector<std::vector<double>>(
_state_alphabet_size, std::vector<double>(xs.size()));
_state_alphabet_size, std::vector<double>(sequence.size()));

for (unsigned int i = 0; i < xs.size(); i++) {
for (unsigned int i = 0; i < sequence.size(); i++) {
for (unsigned int k = 0; k < _state_alphabet_size; k++) {
alpha[k][i] = -HUGE;
auto durations = _states[k]->durations();
Expand All @@ -336,7 +336,7 @@ double GeneralizedHiddenMarkovModel::forward(const Sequence &xs,
alpha[k][i] = log_sum(alpha[k][i],
_initial_probabilities->probabilityOf(k)
+ _states[k]->durationProbability(d)
+ _states[k]->observation()->standardEvaluator(xs)
+ _states[k]->observation()->standardEvaluator(sequence)
->evaluateSequence(i-d+1, i+1));
} else {
double sum = -HUGE;
Expand All @@ -346,7 +346,7 @@ double GeneralizedHiddenMarkovModel::forward(const Sequence &xs,
}
alpha[k][i] = log_sum(alpha[k][i],
sum + _states[k]->durationProbability(d)
+ _states[k]->observation()->standardEvaluator(xs)
+ _states[k]->observation()->standardEvaluator(sequence)
->evaluateSequence(i-d+1, i+1));
}
}
Expand All @@ -355,35 +355,35 @@ double GeneralizedHiddenMarkovModel::forward(const Sequence &xs,

double px = -HUGE;
for (unsigned int k = 0; k < _state_alphabet_size; k++) {
px = log_sum(px, alpha[k][xs.size()-1]);
px = log_sum(px, alpha[k][sequence.size()-1]);
}

return px;
}

/*----------------------------------------------------------------------------*/

double GeneralizedHiddenMarkovModel::backward(const Sequence &xs,
double GeneralizedHiddenMarkovModel::backward(const Sequence &sequence,
Matrix &beta) const {
beta = std::vector<std::vector<double>>(
_state_alphabet_size, std::vector<double>(xs.size()));
_state_alphabet_size, std::vector<double>(sequence.size()));

for (unsigned int k = 0; k < _state_alphabet_size; k++) {
beta[k][xs.size()-1] = 0.0;
beta[k][sequence.size()-1] = 0.0;
}

for (int i = xs.size()-2; i >= 0; i--) {
for (int i = sequence.size()-2; i >= 0; i--) {
for (unsigned int k = 0; k < _state_alphabet_size; k++) {
beta[k][i] = -HUGE;
for (auto p : _states[k]->successors()) {
double sum = -HUGE;
auto durations = _states[p]->durations();
for (unsigned int d = durations->begin();
!durations->end() && d < (xs.size() - i);
!durations->end() && d < (sequence.size() - i);
d = durations->next()) {
sum = log_sum(sum,
_states[p]->durationProbability(d)
+ _states[p]->observation()->standardEvaluator(xs)
+ _states[p]->observation()->standardEvaluator(sequence)
->evaluateSequence(i+1, i+d+1)
+ beta[p][i+d]);
}
Expand All @@ -398,11 +398,11 @@ double GeneralizedHiddenMarkovModel::backward(const Sequence &xs,
double sum = -HUGE;
auto durations = _states[k]->durations();
for (unsigned int d = durations->begin();
!durations->end() && d <= (xs.size());
!durations->end() && d <= (sequence.size());
d = durations->next()) {
sum = log_sum(sum,
_states[k]->durationProbability(d)
+ _states[k]->observation()->standardEvaluator(xs)
+ _states[k]->observation()->standardEvaluator(sequence)
->evaluateSequence(0, d)
+ beta[k][d-1]);
}
Expand All @@ -415,20 +415,20 @@ double GeneralizedHiddenMarkovModel::backward(const Sequence &xs,
/*----------------------------------------------------------------------------*/

void GeneralizedHiddenMarkovModel::posteriorProbabilities(
const Sequence &xs,
const Sequence &sequence,
Matrix &probabilities) const {
probabilities = std::vector<std::vector<double>>(
_state_alphabet_size,
std::vector<double>(xs.size()));
std::vector<double>(sequence.size()));

Matrix alpha; // forward
Matrix beta; // backward

double full = forward(xs, alpha);
backward(xs, beta);
double full = forward(sequence, alpha);
backward(sequence, beta);

for (unsigned int k = 0; k < _state_alphabet_size; k++)
for (unsigned int i = 0; i < xs.size(); i++)
for (unsigned int i = 0; i < sequence.size(); i++)
probabilities[k][i] = alpha[k][i] + beta[k][i] - full;
}

Expand Down
Loading

0 comments on commit b8ae84e

Please sign in to comment.