diogo/yap-6.3
Archived
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

f(void) vs f()

Browse Source 
"In fact, the f(void) style has been called an "abomination" by Bjarne Stroustrup, the creator of C++, Dennis Ritchie, the co-creator of C, and Doug McIlroy, head of the research department where Unix was born."
This commit is contained in:
Tiago Gomes 2013-02-28 19:45:37 +00:00
parent c8b639f495
commit 902624f557
45 changed files with 493 additions and 493 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
packages/CLPBN/horus/BayesBallGraph.cpp
View File

@ -56,7 +56,7 @@ BayesBallGraph::getNode (VarId vid)
void
BayesBallGraph::setIndexes (void)
BayesBallGraph::setIndexes()
{
for (size_t i = 0; i < nodes_.size(); i++) {
nodes_[i]->setIndex (i);
@ -66,7 +66,7 @@ BayesBallGraph::setIndexes (void)
void
BayesBallGraph::clear (void)
BayesBallGraph::clear()
{
for (size_t i = 0; i < nodes_.size(); i++) {
nodes_[i]->clear();

30
packages/CLPBN/horus/BayesBallGraph.h
View File

@ -15,31 +15,31 @@ class BBNode : public Var {
BBNode (Var* v) : Var (v), visited_(false),
markedAbove_(false), markedBelow_(false) { }
const std::vector<BBNode*>& childs (void) const { return childs_; }
const std::vector<BBNode*>& childs() const { return childs_; }
std::vector<BBNode*>& childs (void) { return childs_; }
std::vector<BBNode*>& childs() { return childs_; }
const std::vector<BBNode*>& parents (void) const { return parents_; }
const std::vector<BBNode*>& parents() const { return parents_; }
std::vector<BBNode*>& parents (void) { return parents_; }
std::vector<BBNode*>& parents() { return parents_; }
void addParent (BBNode* p) { parents_.push_back (p); }
void addChild (BBNode* c) { childs_.push_back (c); }
bool isVisited (void) const { return visited_; }
bool isVisited() const { return visited_; }
void setAsVisited (void) { visited_ = true; }
void setAsVisited() { visited_ = true; }
bool isMarkedAbove (void) const { return markedAbove_; }
bool isMarkedAbove() const { return markedAbove_; }
void markAbove (void) { markedAbove_ = true; }
void markAbove() { markedAbove_ = true; }
bool isMarkedBelow (void) const { return markedBelow_; }
bool isMarkedBelow() const { return markedBelow_; }
void markBelow (void) { markedBelow_ = true; }
void markBelow() { markedBelow_ = true; }
void clear (void) { visited_ = markedAbove_ = markedBelow_ = false; }
void clear() { visited_ = markedAbove_ = markedBelow_ = false; }
private:
bool visited_;
@ -53,9 +53,9 @@ class BBNode : public Var {
class BayesBallGraph {
public:
BayesBallGraph (void) { }
BayesBallGraph() { }
bool empty (void) const { return nodes_.empty(); }
bool empty() const { return nodes_.empty(); }
void addNode (BBNode* n);
@ -65,9 +65,9 @@ class BayesBallGraph {
BBNode* getNode (VarId vid);
void setIndexes (void);
void setIndexes();
void clear (void);
void clear();
void exportToGraphViz (const char*);

24
packages/CLPBN/horus/BeliefProp.cpp
View File

@ -27,7 +27,7 @@ BeliefProp::BeliefProp (const FactorGraph& fg)
BeliefProp::~BeliefProp (void)
BeliefProp::~BeliefProp()
{
for (size_t i = 0; i < varsI_.size(); i++) {
delete varsI_[i];
@ -54,7 +54,7 @@ BeliefProp::solveQuery (VarIds queryVids)
void
BeliefProp::printSolverFlags (void) const
BeliefProp::printSolverFlags() const
{
std::stringstream ss;
ss << "belief propagation [" ;
@ -172,7 +172,7 @@ BeliefProp::BpLink::BpLink (FacNode* fn, VarNode* vn)
void
BeliefProp::BpLink::clearResidual (void)
BeliefProp::BpLink::clearResidual()
{
residual_ = 0.0;
}
@ -180,7 +180,7 @@ BeliefProp::BpLink::clearResidual (void)
void
BeliefProp::BpLink::updateResidual (void)
BeliefProp::BpLink::updateResidual()
{
residual_ = LogAware::getMaxNorm (v1_, v2_);
}
@ -188,7 +188,7 @@ BeliefProp::BpLink::updateResidual (void)
void
BeliefProp::BpLink::updateMessage (void)
BeliefProp::BpLink::updateMessage()
{
swap (currMsg_, nextMsg_);
}
@ -196,7 +196,7 @@ BeliefProp::BpLink::updateMessage (void)
std::string
BeliefProp::BpLink::toString (void) const
BeliefProp::BpLink::toString() const
{
std::stringstream ss;
ss << fac_->getLabel();
@ -251,7 +251,7 @@ BeliefProp::updateMessage (BpLink* link)
void
BeliefProp::runSolver (void)
BeliefProp::runSolver()
{
initializeSolver();
nIters_ = 0;
@ -299,7 +299,7 @@ BeliefProp::runSolver (void)
void
BeliefProp::createLinks (void)
BeliefProp::createLinks()
{
const FacNodes& facNodes = fg.facNodes();
for (size_t i = 0; i < facNodes.size(); i++) {
@ -313,7 +313,7 @@ BeliefProp::createLinks (void)
void
BeliefProp::maxResidualSchedule (void)
BeliefProp::maxResidualSchedule()
{
if (nIters_ == 1) {
for (size_t i = 0; i < links_.size(); i++) {
@ -487,7 +487,7 @@ BeliefProp::getJointByConditioning (const VarIds& jointVarIds) const
void
BeliefProp::initializeSolver (void)
BeliefProp::initializeSolver()
{
const VarNodes& varNodes = fg.varNodes();
varsI_.reserve (varNodes.size());
@ -511,7 +511,7 @@ BeliefProp::initializeSolver (void)
bool
BeliefProp::converged (void)
BeliefProp::converged()
{
if (links_.empty()) {
return true;
@ -560,7 +560,7 @@ BeliefProp::converged (void)
void
BeliefProp::printLinkInformation (void) const
BeliefProp::printLinkInformation() const
{
using std::cout;
using std::endl;

46
packages/CLPBN/horus/BeliefProp.h
View File

@ -25,11 +25,11 @@ class BeliefProp : public GroundSolver {
BeliefProp (const FactorGraph&);
virtual ~BeliefProp (void);
virtual ~BeliefProp();
Params solveQuery (VarIds);
virtual void printSolverFlags (void) const;
virtual void printSolverFlags() const;
virtual Params getPosterioriOf (VarId);
@ -37,15 +37,15 @@ class BeliefProp : public GroundSolver {
Params getFactorJoint (FacNode* fn, const VarIds&);
static double accuracy (void) { return accuracy_; }
static double accuracy() { return accuracy_; }
static void setAccuracy (double acc) { accuracy_ = acc; }
static unsigned maxIterations (void) { return maxIter_; }
static unsigned maxIterations() { return maxIter_; }
static void setMaxIterations (unsigned mi) { maxIter_ = mi; }
static MsgSchedule msgSchedule (void) { return schedule_; }
static MsgSchedule msgSchedule() { return schedule_; }
static void setMsgSchedule (MsgSchedule sch) { schedule_ = sch; }
@ -54,25 +54,25 @@ class BeliefProp : public GroundSolver {
public:
BpLink (FacNode* fn, VarNode* vn);
virtual ~BpLink (void) { };
virtual ~BpLink() { };
FacNode* facNode (void) const { return fac_; }
FacNode* facNode() const { return fac_; }
VarNode* varNode (void) const { return var_; }
VarNode* varNode() const { return var_; }
const Params& message (void) const { return *currMsg_; }
const Params& message() const { return *currMsg_; }
Params& nextMessage (void) { return *nextMsg_; }
Params& nextMessage() { return *nextMsg_; }
double residual (void) const { return residual_; }
double residual() const { return residual_; }
void clearResidual (void);
void clearResidual();
void updateResidual (void);
void updateResidual();
virtual void updateMessage (void);
virtual void updateMessage();
std::string toString (void) const;
std::string toString() const;
protected:
FacNode* fac_;
@ -106,11 +106,11 @@ class BeliefProp : public GroundSolver {
void updateMessage (BpLink* link);
void runSolver (void);
void runSolver();
virtual void createLinks (void);
virtual void createLinks();
virtual void maxResidualSchedule (void);
virtual void maxResidualSchedule();
virtual void calcFactorToVarMsg (BpLink*);
@ -133,11 +133,11 @@ class BeliefProp : public GroundSolver {
private:
class SPNodeInfo {
public:
SPNodeInfo (void) { }
SPNodeInfo() { }
void addBpLink (BeliefProp::BpLink* link) { links_.push_back (link); }
const BpLinks& getLinks (void) { return links_; }
const BpLinks& getLinks() { return links_; }
private:
BpLinks links_;
@ -145,11 +145,11 @@ class BeliefProp : public GroundSolver {
DISALLOW_COPY_AND_ASSIGN (SPNodeInfo);
};
void initializeSolver (void);
void initializeSolver();
bool converged (void);
bool converged();
virtual void printLinkInformation (void) const;
virtual void printLinkInformation() const;
DISALLOW_COPY_AND_ASSIGN (BeliefProp);
};

12
packages/CLPBN/horus/ConstraintTree.cpp
View File

@ -41,7 +41,7 @@ CTNode::removeChild (CTNode* child)
void
CTNode::removeChilds (void)
CTNode::removeChilds()
{
childs_.clear();
}
@ -58,7 +58,7 @@ CTNode::removeAndDeleteChild (CTNode* child)
void
CTNode::removeAndDeleteAllChilds (void)
CTNode::removeAndDeleteAllChilds()
{
for (CTChilds::const_iterator chIt = childs_.begin();
chIt != childs_.end(); ++ chIt) {
@ -70,7 +70,7 @@ CTNode::removeAndDeleteAllChilds (void)
SymbolSet
CTNode::childSymbols (void) const
CTNode::childSymbols() const
{
SymbolSet symbols;
for (CTChilds::const_iterator chIt = childs_.begin();
@ -232,7 +232,7 @@ ConstraintTree::ConstraintTree (
ConstraintTree::~ConstraintTree (void)
ConstraintTree::~ConstraintTree()
{
CTNode::deleteSubtree (root_);
}
@ -464,7 +464,7 @@ ConstraintTree::ConstraintTree::isSingleton (LogVar X)
LogVarSet
ConstraintTree::singletons (void)
ConstraintTree::singletons()
{
LogVarSet singletons;
for (size_t i = 0; i < logVars_.size(); i++) {
@ -1115,7 +1115,7 @@ ConstraintTree::getTuples (
unsigned
ConstraintTree::size (void) const
ConstraintTree::size() const
{
return countTuples (root_);
}

42
packages/CLPBN/horus/ConstraintTree.h
View File

@ -38,23 +38,23 @@ class CTNode {
CTNode (Symbol s, unsigned l, const CTChilds& chs = CTChilds())
: symbol_(s), childs_(chs), level_(l) { }
unsigned level (void) const { return level_; }
unsigned level() const { return level_; }
void setLevel (unsigned level) { level_ = level; }
Symbol symbol (void) const { return symbol_; }
Symbol symbol() const { return symbol_; }
void setSymbol (Symbol s) { symbol_ = s; }
CTChilds& childs (void) { return childs_; }
CTChilds& childs() { return childs_; }
const CTChilds& childs (void) const { return childs_; }
const CTChilds& childs() const { return childs_; }
size_t nrChilds (void) const { return childs_.size(); }
size_t nrChilds() const { return childs_.size(); }
bool isRoot (void) const { return level_ == 0; }
bool isRoot() const { return level_ == 0; }
bool isLeaf (void) const { return childs_.empty(); }
bool isLeaf() const { return childs_.empty(); }
CTChilds::iterator findSymbol (Symbol symb);
@ -62,13 +62,13 @@ class CTNode {
void removeChild (CTNode*);
void removeChilds (void);
void removeChilds();
void removeAndDeleteChild (CTNode*);
void removeAndDeleteAllChilds (void);
void removeAndDeleteAllChilds();
SymbolSet childSymbols (void) const;
SymbolSet childSymbols() const;
static CTNode* copySubtree (const CTNode*);
@ -113,17 +113,17 @@ class ConstraintTree {
ConstraintTree (const CTChilds& rootChilds, const LogVars& logVars);
~ConstraintTree (void);
~ConstraintTree();
CTNode* root (void) const { return root_; }
CTNode* root() const { return root_; }
bool empty (void) const { return root_->childs().empty(); }
bool empty() const { return root_->childs().empty(); }
const LogVars& logVars (void) const;
const LogVars& logVars() const;
const LogVarSet& logVarSet (void) const;
const LogVarSet& logVarSet() const;
size_t nrLogVars (void) const;
size_t nrLogVars() const;
void addTuple (const Tuple&);
@ -149,13 +149,13 @@ class ConstraintTree {
bool isSingleton (LogVar);
LogVarSet singletons (void);
LogVarSet singletons();
TupleSet tupleSet (unsigned = 0) const;
TupleSet tupleSet (const LogVars&);
unsigned size (void) const;
unsigned size() const;
unsigned nrSymbols (LogVar);
@ -217,7 +217,7 @@ class ConstraintTree {
inline const LogVars&
ConstraintTree::logVars (void) const
ConstraintTree::logVars() const
{
assert (LogVarSet (logVars_) == logVarSet_);
return logVars_;
@ -226,7 +226,7 @@ ConstraintTree::logVars (void) const
inline const LogVarSet&
ConstraintTree::logVarSet (void) const
ConstraintTree::logVarSet() const
{
assert (LogVarSet (logVars_) == logVarSet_);
return logVarSet_;
@ -235,7 +235,7 @@ ConstraintTree::logVarSet (void) const
inline size_t
ConstraintTree::nrLogVars (void) const
ConstraintTree::nrLogVars() const
{
assert (LogVarSet (logVars_) == logVarSet_);
return logVars_.size();

26
packages/CLPBN/horus/CountingBp.cpp
View File

@ -13,11 +13,11 @@ class VarCluster {
public:
VarCluster (const VarNodes& vs) : members_(vs) { }
const VarNode* first (void) const { return members_.front(); }
const VarNode* first() const { return members_.front(); }
const VarNodes& members (void) const { return members_; }
const VarNodes& members() const { return members_; }
VarNode* representative (void) const { return repr_; }
VarNode* representative() const { return repr_; }
void setRepresentative (VarNode* vn) { repr_ = vn; }
@ -38,15 +38,15 @@ class FacCluster {
FacCluster (const FacNodes& fcs, const VarClusters& vcs)
: members_(fcs), varClusters_(vcs) { }
const FacNode* first (void) const { return members_.front(); }
const FacNode* first() const { return members_.front(); }
const FacNodes& members (void) const { return members_; }
const FacNodes& members() const { return members_; }
FacNode* representative (void) const { return repr_; }
FacNode* representative() const { return repr_; }
void setRepresentative (FacNode* fn) { repr_ = fn; }
VarClusters& varClusters (void) { return varClusters_; }
VarClusters& varClusters() { return varClusters_; }
FacNodes members_;
FacNode* repr_;
@ -72,7 +72,7 @@ CountingBp::CountingBp (const FactorGraph& fg)
CountingBp::~CountingBp (void)
CountingBp::~CountingBp()
{
delete solver_;
delete compressedFg_;
@ -87,7 +87,7 @@ CountingBp::~CountingBp (void)
void
CountingBp::printSolverFlags (void) const
CountingBp::printSolverFlags() const
{
std::stringstream ss;
ss << "counting bp [" ;
@ -179,7 +179,7 @@ CountingBp::findIdenticalFactors()
void
CountingBp::setInitialColors (void)
CountingBp::setInitialColors()
{
varColors_.resize (fg.nrVarNodes());
facColors_.resize (fg.nrFacNodes());
@ -219,7 +219,7 @@ CountingBp::setInitialColors (void)
void
CountingBp::createGroups (void)
CountingBp::createGroups()
{
VarSignMap varGroups;
FacSignMap facGroups;
@ -373,7 +373,7 @@ CountingBp::getRepresentative (FacNode* fn)
FactorGraph*
CountingBp::getCompressedFactorGraph (void)
CountingBp::getCompressedFactorGraph()
{
FactorGraph* fg = new FactorGraph();
for (size_t i = 0; i < varClusters_.size(); i++) {
@ -402,7 +402,7 @@ CountingBp::getCompressedFactorGraph (void)
std::vector<std::vector<unsigned>>
CountingBp::getWeights (void) const
CountingBp::getWeights() const
{
std::vector<std::vector<unsigned>> weights;
weights.reserve (facClusters_.size());

18
packages/CLPBN/horus/CountingBp.h
View File

@ -55,9 +55,9 @@ class CountingBp : public GroundSolver {
public:
CountingBp (const FactorGraph& fg);
~CountingBp (void);
~CountingBp();
void printSolverFlags (void) const;
void printSolverFlags() const;
Params solveQuery (VarIds);
@ -79,7 +79,7 @@ class CountingBp : public GroundSolver {
typedef std::unordered_map<FacSignature, FacNodes> FacSignMap;
typedef std::unordered_map<VarId, VarCluster*> VarClusterMap;
Color getNewColor (void);
Color getNewColor();
Color getColor (const VarNode* vn) const;
@ -89,11 +89,11 @@ class CountingBp : public GroundSolver {
void setColor (const FacNode* fn, Color c);
void findIdenticalFactors (void);
void findIdenticalFactors();
void setInitialColors (void);
void setInitialColors();
void createGroups (void);
void createGroups();
void createClusters (const VarSignMap&, const FacSignMap&);
@ -107,9 +107,9 @@ class CountingBp : public GroundSolver {
FacNode* getRepresentative (FacNode*);
FactorGraph* getCompressedFactorGraph (void);
FactorGraph* getCompressedFactorGraph();
std::vector<std::vector<unsigned>> getWeights (void) const;
std::vector<std::vector<unsigned>> getWeights() const;
unsigned getWeight (const FacCluster*, const VarCluster*,
size_t index) const;
@ -131,7 +131,7 @@ class CountingBp : public GroundSolver {
inline CountingBp::Color
CountingBp::getNewColor (void)
CountingBp::getNewColor()
{
++ freeColor_;
return freeColor_ - 1;

6
packages/CLPBN/horus/ElimGraph.cpp
View File

@ -41,7 +41,7 @@ ElimGraph::ElimGraph (const std::vector<Factor*>& factors)
ElimGraph::~ElimGraph (void)
ElimGraph::~ElimGraph()
{
for (size_t i = 0; i < nodes_.size(); i++) {
delete nodes_[i];
@ -77,7 +77,7 @@ ElimGraph::getEliminatingOrder (const VarIds& excludedVids)
void
ElimGraph::print (void) const
ElimGraph::print() const
{
for (size_t i = 0; i < nodes_.size(); i++) {
std::cout << "node " << nodes_[i]->label() << " neighs:" ;
@ -177,7 +177,7 @@ ElimGraph::getEGNode (VarId vid) const
ElimGraph::EGNode*
ElimGraph::getLowestCostNode (void) const
ElimGraph::getLowestCostNode() const
{
EGNode* bestNode = 0;
unsigned minCost = Util::maxUnsigned();

10
packages/CLPBN/horus/ElimGraph.h
View File

@ -25,18 +25,18 @@ class ElimGraph {
ElimGraph (const Factors&);
~ElimGraph (void);
~ElimGraph();
VarIds getEliminatingOrder (const VarIds&);
void print (void) const;
void print() const;
void exportToGraphViz (const char*, bool = true,
const VarIds& = VarIds()) const;
static VarIds getEliminationOrder (const Factors&, VarIds);
static ElimHeuristic elimHeuristic (void) { return elimHeuristic_; }
static ElimHeuristic elimHeuristic() { return elimHeuristic_; }
static void setElimHeuristic (ElimHeuristic eh) { elimHeuristic_ = eh; }
@ -55,7 +55,7 @@ class ElimGraph {
bool isNeighbor (EGNode* n) const { return neighs_.contains (n); }
const EGNeighs& neighbors (void) const { return neighs_; }
const EGNeighs& neighbors() const { return neighs_; }
private:
EGNeighs neighs_;
@ -77,7 +77,7 @@ class ElimGraph {
EGNode* getEGNode (VarId) const;
EGNode* getLowestCostNode (void) const;
EGNode* getLowestCostNode() const;
void connectAllNeighbors (const EGNode*);

8
packages/CLPBN/horus/Factor.cpp
View File

@ -110,7 +110,7 @@ Factor::multiply (Factor& g)
std::string
Factor::getLabel (void) const
Factor::getLabel() const
{
std::stringstream ss;
ss << "f(" ;
@ -125,7 +125,7 @@ Factor::getLabel (void) const
void
Factor::print (void) const
Factor::print() const
{
Vars vars;
for (size_t i = 0; i < args_.size(); i++) {
@ -146,7 +146,7 @@ Factor::print (void) const
void
Factor::sumOutFirstVariable (void)
Factor::sumOutFirstVariable()
{
size_t sep = params_.size() / 2;
if (Globals::logDomain) {
@ -169,7 +169,7 @@ Factor::sumOutFirstVariable (void)
void
Factor::sumOutLastVariable (void)
Factor::sumOutLastVariable()
{
Params::iterator first1 = params_.begin();
Params::iterator first2 = params_.begin();

32
packages/CLPBN/horus/Factor.h
View File

@ -15,27 +15,27 @@ namespace Horus {
template <typename T>
class TFactor {
public:
const std::vector<T>& arguments (void) const { return args_; }
const std::vector<T>& arguments() const { return args_; }
std::vector<T>& arguments (void) { return args_; }
std::vector<T>& arguments() { return args_; }
const Ranges& ranges (void) const { return ranges_; }
const Ranges& ranges() const { return ranges_; }
const Params& params (void) const { return params_; }
const Params& params() const { return params_; }
Params& params (void) { return params_; }
Params& params() { return params_; }
size_t nrArguments (void) const { return args_.size(); }
size_t nrArguments() const { return args_.size(); }
size_t size (void) const { return params_.size(); }
size_t size() const { return params_.size(); }
unsigned distId (void) const { return distId_; }
unsigned distId() const { return distId_; }
void setDistId (unsigned id) { distId_ = id; }
void normalize (void) { LogAware::normalize (params_); }
void normalize() { LogAware::normalize (params_); }
void randomize (void);
void randomize();
void setParams (const Params& newParams);
@ -77,7 +77,7 @@ class TFactor {
template <typename T> inline void
TFactor<T>::randomize (void)
TFactor<T>::randomize()
{
for (size_t i = 0; i < params_.size(); ++i) {
params_[i] = (double) std::rand() / RAND_MAX;
@ -328,7 +328,7 @@ TFactor<T>::cartesianProduct (
class Factor : public TFactor<VarId> {
public:
Factor (void) { }
Factor() { }
Factor (const Factor&);
@ -348,14 +348,14 @@ class Factor : public TFactor<VarId> {
void multiply (Factor&);
std::string getLabel (void) const;
std::string getLabel() const;
void print (void) const;
void print() const;
private:
void sumOutFirstVariable (void);
void sumOutFirstVariable();
void sumOutLastVariable (void);
void sumOutLastVariable();
void sumOutArgs (const std::vector<bool>& mask);

10
packages/CLPBN/horus/FactorGraph.cpp
View File

@ -36,7 +36,7 @@ FactorGraph::FactorGraph (const FactorGraph& fg)
FactorGraph::~FactorGraph (void)
FactorGraph::~FactorGraph()
{
for (size_t i = 0; i < varNodes_.size(); i++) {
delete varNodes_[i];
@ -246,7 +246,7 @@ FactorGraph::addEdge (VarNode* vn, FacNode* fn)
bool
FactorGraph::isTree (void) const
FactorGraph::isTree() const
{
return !containsCycle();
}
@ -254,7 +254,7 @@ FactorGraph::isTree (void) const
BayesBallGraph&
FactorGraph::getStructure (void)
FactorGraph::getStructure()
{
assert (bayesFactors_);
if (structure_.empty()) {
@ -274,7 +274,7 @@ FactorGraph::getStructure (void)
void
FactorGraph::print (void) const
FactorGraph::print() const
{
using std::cout;
using std::endl;
@ -422,7 +422,7 @@ FactorGraph::ignoreLines (std::ifstream& is) const
bool
FactorGraph::containsCycle (void) const
FactorGraph::containsCycle() const
{
std::vector<bool> visitedVars (varNodes_.size(), false);
std::vector<bool> visitedFactors (facNodes_.size(), false);

60
packages/CLPBN/horus/FactorGraph.h
View File

@ -26,7 +26,7 @@ class VarNode : public Var {
void addNeighbor (FacNode* fn) { neighs_.push_back (fn); }
const FacNodes& neighbors (void) const { return neighs_; }
const FacNodes& neighbors() const { return neighs_; }
private:
FacNodes neighs_;
@ -40,19 +40,19 @@ class FacNode {
public:
FacNode (const Factor& f) : factor_(f), index_(-1) { }
const Factor& factor (void) const { return factor_; }
const Factor& factor() const { return factor_; }
Factor& factor (void) { return factor_; }
Factor& factor() { return factor_; }
void addNeighbor (VarNode* vn) { neighs_.push_back (vn); }
const VarNodes& neighbors (void) const { return neighs_; }
const VarNodes& neighbors() const { return neighs_; }
size_t getIndex (void) const { return index_; }
size_t getIndex() const { return index_; }
void setIndex (size_t index) { index_ = index; }
std::string getLabel (void) { return factor_.getLabel(); }
std::string getLabel() { return factor_.getLabel(); }
private:
VarNodes neighs_;
@ -66,23 +66,23 @@ class FacNode {
class FactorGraph {
public:
FactorGraph (void) : bayesFactors_(false) { }
FactorGraph() : bayesFactors_(false) { }
FactorGraph (const FactorGraph&);
~FactorGraph (void);
~FactorGraph();
const VarNodes& varNodes (void) const { return varNodes_; }
const VarNodes& varNodes() const { return varNodes_; }
const FacNodes& facNodes (void) const { return facNodes_; }
const FacNodes& facNodes() const { return facNodes_; }
void setFactorsAsBayesian (void) { bayesFactors_ = true; }
void setFactorsAsBayesian() { bayesFactors_ = true; }
bool bayesianFactors (void) const { return bayesFactors_; }
bool bayesianFactors() const { return bayesFactors_; }
size_t nrVarNodes (void) const { return varNodes_.size(); }
size_t nrVarNodes() const { return varNodes_.size(); }
size_t nrFacNodes (void) const { return facNodes_.size(); }
size_t nrFacNodes() const { return facNodes_.size(); }
VarNode* getVarNode (VarId vid) const;
@ -98,11 +98,11 @@ class FactorGraph {
void addEdge (VarNode*, FacNode*);
bool isTree (void) const;
bool isTree() const;
BayesBallGraph& getStructure (void);
BayesBallGraph& getStructure();
void print (void) const;
void print() const;
void exportToLibDai (const char*) const;
@ -110,36 +110,36 @@ class FactorGraph {
void exportToGraphViz (const char*) const;
static bool exportToLibDai (void) { return exportLd_; }
static bool exportToLibDai() { return exportLd_; }
static bool exportToUai (void) { return exportUai_; }
static bool exportToUai() { return exportUai_; }
static bool exportGraphViz (void) { return exportGv_; }
static bool exportGraphViz() { return exportGv_; }
static bool printFactorGraph (void) { return printFg_; }
static bool printFactorGraph() { return printFg_; }
static void enableExportToLibDai (void) { exportLd_ = true; }
static void enableExportToLibDai() { exportLd_ = true; }
static void disableExportToLibDai (void) { exportLd_ = false; }
static void disableExportToLibDai() { exportLd_ = false; }
static void enableExportToUai (void) { exportUai_ = true; }
static void enableExportToUai() { exportUai_ = true; }
static void disableExportToUai (void) { exportUai_ = false; }
static void disableExportToUai() { exportUai_ = false; }
static void enableExportToGraphViz (void) { exportGv_ = true; }
static void enableExportToGraphViz() { exportGv_ = true; }
static void disableExportToGraphViz (void) { exportGv_ = false; }
static void disableExportToGraphViz() { exportGv_ = false; }
static void enablePrintFactorGraph (void) { printFg_ = true; }
static void enablePrintFactorGraph() { printFg_ = true; }
static void disablePrintFactorGraph (void) { printFg_ = false; }
static void disablePrintFactorGraph() { printFg_ = false; }
private:
typedef std::unordered_map<unsigned, VarNode*> VarMap;
void ignoreLines (std::ifstream&) const;
bool containsCycle (void) const;
bool containsCycle() const;
bool containsCycle (const VarNode*, const FacNode*,
std::vector<bool>&, std::vector<bool>&) const;

2
packages/CLPBN/horus/GroundSolver.cpp
View File

@ -42,7 +42,7 @@ GroundSolver::printAnswer (const VarIds& vids)
void
GroundSolver::printAllPosterioris (void)
GroundSolver::printAllPosterioris()
{
VarNodes vars = fg.varNodes();
std::sort (vars.begin(), vars.end(), sortByVarId());

4
packages/CLPBN/horus/GroundSolver.h
View File

@ -15,11 +15,11 @@ class GroundSolver {
virtual Params solveQuery (VarIds queryVids) = 0;
virtual void printSolverFlags (void) const = 0;
virtual void printSolverFlags() const = 0;
void printAnswer (const VarIds& vids);
void printAllPosterioris (void);
void printAllPosterioris();
static Params getJointByConditioning (GroundSolverType,
FactorGraph, const VarIds& jointVarIds);

6
packages/CLPBN/horus/Histogram.cpp
View File

@ -19,7 +19,7 @@ HistogramSet::HistogramSet (unsigned size, unsigned range)
void
HistogramSet::nextHistogram (void)
HistogramSet::nextHistogram()
{
for (size_t i = hist_.size() - 1; i-- > 0; ) {
if (hist_[i] > 0) {
@ -45,7 +45,7 @@ HistogramSet::operator[] (size_t idx) const
unsigned
HistogramSet::nrHistograms (void) const
HistogramSet::nrHistograms() const
{
return HistogramSet::nrHistograms (size_, hist_.size());
}
@ -53,7 +53,7 @@ HistogramSet::nrHistograms (void) const
void
HistogramSet::reset (void)
HistogramSet::reset()
{
std::fill (hist_.begin() + 1, hist_.end(), 0);
hist_[0] = size_;

6
packages/CLPBN/horus/Histogram.h
View File

@ -15,13 +15,13 @@ class HistogramSet {
public:
HistogramSet (unsigned, unsigned);
void nextHistogram (void);
void nextHistogram();
unsigned operator[] (size_t idx) const;
unsigned nrHistograms (void) const;
unsigned nrHistograms() const;
void reset (void);
void reset();
static std::vector<Histogram> getHistograms (unsigned, unsigned);

22
packages/CLPBN/horus/HorusYap.cpp
View File

@ -42,7 +42,7 @@ typedef std::pair<ParfactorList*, ObservedFormulas*> LiftedNetwork;
int
createLiftedNetwork (void)
createLiftedNetwork()
{
Parfactors parfactors;
YAP_Term parfactorList = YAP_ARG1;
@ -80,7 +80,7 @@ createLiftedNetwork (void)
int
createGroundNetwork (void)
createGroundNetwork()
{
std::string factorsType ((char*) YAP_AtomName (YAP_AtomOfTerm (YAP_ARG1)));
FactorGraph* fg = new FactorGraph();
@ -136,7 +136,7 @@ createGroundNetwork (void)
int
runLiftedSolver (void)
runLiftedSolver()
{
LiftedNetwork* network = (LiftedNetwork*) YAP_IntOfTerm (YAP_ARG1);
ParfactorList copy (*network->first);
@ -194,7 +194,7 @@ runLiftedSolver (void)
int
runGroundSolver (void)
runGroundSolver()
{
FactorGraph* fg = (FactorGraph*) YAP_IntOfTerm (YAP_ARG1);
@ -245,7 +245,7 @@ runGroundSolver (void)
int
setParfactorsParams (void)
setParfactorsParams()
{
LiftedNetwork* network = (LiftedNetwork*) YAP_IntOfTerm (YAP_ARG1);
ParfactorList* pfList = network->first;
@ -272,7 +272,7 @@ setParfactorsParams (void)
int
setFactorsParams (void)
setFactorsParams()
{
FactorGraph* fg = (FactorGraph*) YAP_IntOfTerm (YAP_ARG1);
YAP_Term distIdsList = YAP_ARG2;
@ -298,7 +298,7 @@ setFactorsParams (void)
int
setVarsInformation (void)
setVarsInformation()
{
Var::clearVarsInfo();
std::vector<std::string> labels;
@ -328,7 +328,7 @@ setVarsInformation (void)
int
setHorusFlag (void)
setHorusFlag()
{
std::string option ((char*) YAP_AtomName (YAP_AtomOfTerm (YAP_ARG1)));
std::string value;
@ -353,7 +353,7 @@ setHorusFlag (void)
int
freeGroundNetwork (void)
freeGroundNetwork()
{
delete (FactorGraph*) YAP_IntOfTerm (YAP_ARG1);
return TRUE;
@ -362,7 +362,7 @@ freeGroundNetwork (void)
int
freeLiftedNetwork (void)
freeLiftedNetwork()
{
LiftedNetwork* network = (LiftedNetwork*) YAP_IntOfTerm (YAP_ARG1);
delete network->first;
@ -557,7 +557,7 @@ fillSolutionList (const std::vector<Params>& results)
extern "C" void
init_predicates (void)
init_predicates()
{
YAP_UserCPredicate ("cpp_create_lifted_network",
createLiftedNetwork, 3);

44
packages/CLPBN/horus/Indexer.h
View File

@ -14,28 +14,28 @@ class Indexer {
public:
Indexer (const Ranges& ranges, bool calcOffsets = true);
void increment (void);
void increment();
void incrementDimension (size_t dim);
void incrementExceptDimension (size_t dim);
Indexer& operator++ (void);
Indexer& operator++();
operator size_t (void) const;
operator size_t() const;
unsigned operator[] (size_t dim) const;
bool valid (void) const;
bool valid() const;
void reset (void);
void reset();
void resetDimension (size_t dim);
size_t size (void) const;
size_t size() const;
private:
void calculateOffsets (void);
void calculateOffsets();
friend std::ostream& operator<< (std::ostream&, const Indexer&);
@ -63,7 +63,7 @@ Indexer::Indexer (const Ranges& ranges, bool calcOffsets)
inline void
Indexer::increment (void)
Indexer::increment()
{
for (size_t i = ranges_.size(); i-- > 0; ) {
indices_[i] ++;
@ -112,7 +112,7 @@ Indexer::incrementExceptDimension (size_t dim)
inline Indexer&
Indexer::operator++ (void)
Indexer::operator++()
{
increment();
return *this;
@ -121,7 +121,7 @@ Indexer::operator++ (void)
inline
Indexer::operator size_t (void) const
Indexer::operator size_t() const
{
return index_;
}
@ -139,7 +139,7 @@ Indexer::operator[] (size_t dim) const
inline bool
Indexer::valid (void) const
Indexer::valid() const
{
return index_ < size_;
}
@ -147,7 +147,7 @@ Indexer::valid (void) const
inline void
Indexer::reset (void)
Indexer::reset()
{
index_ = 0;
std::fill (indices_.begin(), indices_.end(), 0);
@ -165,7 +165,7 @@ Indexer::resetDimension (size_t dim)
inline size_t
Indexer::size (void) const
Indexer::size() const
{
return size_ ;
}
@ -173,7 +173,7 @@ Indexer::size (void) const
inline void
Indexer::calculateOffsets (void)
Indexer::calculateOffsets()
{
size_t prod = 1;
offsets_.resize (ranges_.size());
@ -198,15 +198,15 @@ class MapIndexer {
const std::vector<T>& wantedArgs,
const Ranges& wantedRanges);
MapIndexer& operator++ (void);
MapIndexer& operator++();
operator size_t (void) const;
operator size_t() const;
unsigned operator[] (size_t dim) const;
bool valid (void) const;
bool valid() const;
void reset (void);
void reset();
private:
friend std::ostream& operator<< (std::ostream&, const MapIndexer&);
@ -284,7 +284,7 @@ MapIndexer::MapIndexer (
inline MapIndexer&
MapIndexer::operator++ (void)
MapIndexer::operator++()
{
assert (valid_);
for (size_t i = ranges_.size(); i-- > 0; ) {
@ -304,7 +304,7 @@ MapIndexer::operator++ (void)
inline
MapIndexer::operator size_t (void) const
MapIndexer::operator size_t() const
{
assert (valid());
return index_;
@ -323,7 +323,7 @@ MapIndexer::operator[] (size_t dim) const
inline bool
MapIndexer::valid (void) const
MapIndexer::valid() const
{
return valid_;
}
@ -331,7 +331,7 @@ MapIndexer::valid (void) const
inline void
MapIndexer::reset (void)
MapIndexer::reset()
{
index_ = 0;
std::fill (indices_.begin(), indices_.end(), 0);

12
packages/CLPBN/horus/LiftedBp.cpp
View File

@ -20,7 +20,7 @@ LiftedBp::LiftedBp (const ParfactorList& parfactorList)
LiftedBp::~LiftedBp (void)
LiftedBp::~LiftedBp()
{
delete solver_;
delete fg_;
@ -64,7 +64,7 @@ LiftedBp::solveQuery (const Grounds& query)
void
LiftedBp::printSolverFlags (void) const
LiftedBp::printSolverFlags() const
{
std::stringstream ss;
ss << "lifted bp [" ;
@ -86,7 +86,7 @@ LiftedBp::printSolverFlags (void) const
void
LiftedBp::refineParfactors (void)
LiftedBp::refineParfactors()
{
pfList_ = parfactorList;
while (iterate() == false);
@ -100,7 +100,7 @@ LiftedBp::refineParfactors (void)
bool
LiftedBp::iterate (void)
LiftedBp::iterate()
{
ParfactorList::iterator it = pfList_.begin();
while (it != pfList_.end()) {
@ -141,7 +141,7 @@ LiftedBp::getQueryGroups (const Grounds& query)
void
LiftedBp::createFactorGraph (void)
LiftedBp::createFactorGraph()
{
fg_ = new FactorGraph();
ParfactorList::const_iterator it = pfList_.begin();
@ -158,7 +158,7 @@ LiftedBp::createFactorGraph (void)
std::vector<std::vector<unsigned>>
LiftedBp::getWeights (void) const
LiftedBp::getWeights() const
{
std::vector<std::vector<unsigned>> weights;
weights.reserve (pfList_.size());

12
packages/CLPBN/horus/LiftedBp.h
View File

@ -16,22 +16,22 @@ class LiftedBp : public LiftedSolver{
public:
LiftedBp (const ParfactorList& pfList);
~LiftedBp (void);
~LiftedBp();
Params solveQuery (const Grounds&);
void printSolverFlags (void) const;
void printSolverFlags() const;
private:
void refineParfactors (void);
void refineParfactors();
bool iterate (void);
bool iterate();
std::vector<PrvGroup> getQueryGroups (const Grounds&);
void createFactorGraph (void);
void createFactorGraph();
std::vector<std::vector<unsigned>> getWeights (void) const;
std::vector<std::vector<unsigned>> getWeights() const;
unsigned rangeOfGround (const Ground&);

126
packages/CLPBN/horus/LiftedKc.cpp
View File

@ -30,25 +30,25 @@ enum CircuitNodeType {
class CircuitNode {
public:
CircuitNode (void) { }
CircuitNode() { }
virtual ~CircuitNode (void) { }
virtual ~CircuitNode() { }
virtual double weight (void) const = 0;
virtual double weight() const = 0;
};
class OrNode : public CircuitNode {
public:
OrNode (void) : CircuitNode(), leftBranch_(0), rightBranch_(0) { }
OrNode() : CircuitNode(), leftBranch_(0), rightBranch_(0) { }
~OrNode (void);
~OrNode();
CircuitNode** leftBranch (void) { return &leftBranch_; }
CircuitNode** rightBranch (void) { return &rightBranch_; }
CircuitNode** leftBranch () { return &leftBranch_; }
CircuitNode** rightBranch() { return &rightBranch_; }
double weight (void) const;
double weight() const;
private:
CircuitNode* leftBranch_;
@ -59,17 +59,17 @@ class OrNode : public CircuitNode {
class AndNode : public CircuitNode {
public:
AndNode (void) : CircuitNode(), leftBranch_(0), rightBranch_(0) { }
AndNode() : CircuitNode(), leftBranch_(0), rightBranch_(0) { }
AndNode (CircuitNode* leftBranch, CircuitNode* rightBranch)
: CircuitNode(), leftBranch_(leftBranch), rightBranch_(rightBranch) { }
~AndNode (void);
~AndNode();
CircuitNode** leftBranch (void) { return &leftBranch_; }
CircuitNode** rightBranch (void) { return &rightBranch_; }
CircuitNode** leftBranch () { return &leftBranch_; }
CircuitNode** rightBranch() { return &rightBranch_; }
double weight (void) const;
double weight() const;
private:
CircuitNode* leftBranch_;
@ -83,17 +83,17 @@ class SetOrNode : public CircuitNode {
SetOrNode (unsigned nrGroundings)
: CircuitNode(), follow_(0), nrGroundings_(nrGroundings) { }
~SetOrNode (void);
~SetOrNode();
CircuitNode** follow (void) { return &follow_; }
CircuitNode** follow() { return &follow_; }
static unsigned nrPositives (void) { return nrPos_; }
static unsigned nrPositives() { return nrPos_; }
static unsigned nrNegatives (void) { return nrNeg_; }
static unsigned nrNegatives() { return nrNeg_; }
static bool isSet (void) { return nrPos_ >= 0; }
static bool isSet() { return nrPos_ >= 0; }
double weight (void) const;
double weight() const;
private:
CircuitNode* follow_;
@ -109,11 +109,11 @@ class SetAndNode : public CircuitNode {
SetAndNode (unsigned nrGroundings)
: CircuitNode(), follow_(0), nrGroundings_(nrGroundings) { }
~SetAndNode (void);
~SetAndNode();
CircuitNode** follow (void) { return &follow_; }
CircuitNode** follow() { return &follow_; }
double weight (void) const;
double weight() const;
private:
CircuitNode* follow_;
@ -124,16 +124,16 @@ class SetAndNode : public CircuitNode {
class IncExcNode : public CircuitNode {
public:
IncExcNode (void)
IncExcNode()
: CircuitNode(), plus1Branch_(0), plus2Branch_(0), minusBranch_(0) { }
~IncExcNode (void);
~IncExcNode();
CircuitNode** plus1Branch (void) { return &plus1Branch_; }
CircuitNode** plus2Branch (void) { return &plus2Branch_; }
CircuitNode** minusBranch (void) { return &minusBranch_; }
CircuitNode** plus1Branch() { return &plus1Branch_; }
CircuitNode** plus2Branch() { return &plus2Branch_; }
CircuitNode** minusBranch() { return &minusBranch_; }
double weight (void) const;
double weight() const;
private:
CircuitNode* plus1Branch_;
@ -148,13 +148,13 @@ class LeafNode : public CircuitNode {
LeafNode (Clause* clause, const LiftedWCNF& lwcnf)
: CircuitNode(), clause_(clause), lwcnf_(lwcnf) { }
~LeafNode (void);
~LeafNode();
const Clause* clause (void) const { return clause_; }
const Clause* clause() const { return clause_; }
Clause* clause (void) { return clause_; }
Clause* clause() { return clause_; }
double weight (void) const;
double weight() const;
private:
Clause* clause_;
@ -168,13 +168,13 @@ class SmoothNode : public CircuitNode {
SmoothNode (const Clauses& clauses, const LiftedWCNF& lwcnf)
: CircuitNode(), clauses_(clauses), lwcnf_(lwcnf) { }
~SmoothNode (void);
~SmoothNode();
const Clauses& clauses (void) const { return clauses_; }
const Clauses& clauses() const { return clauses_; }
Clauses clauses (void) { return clauses_; }
Clauses clauses() { return clauses_; }
double weight (void) const;
double weight() const;
private:
Clauses clauses_;
@ -185,18 +185,18 @@ class SmoothNode : public CircuitNode {
class TrueNode : public CircuitNode {
public:
TrueNode (void) : CircuitNode() { }
TrueNode() : CircuitNode() { }
double weight (void) const;
double weight() const;
};
class CompilationFailedNode : public CircuitNode {
public:
CompilationFailedNode (void) : CircuitNode() { }
CompilationFailedNode() : CircuitNode() { }
double weight (void) const;
double weight() const;
};
@ -205,11 +205,11 @@ class LiftedCircuit {
public:
LiftedCircuit (const LiftedWCNF* lwcnf);
~LiftedCircuit (void);
~LiftedCircuit();
bool isCompilationSucceeded (void) const;
bool isCompilationSucceeded() const;
double getWeightedModelCount (void) const;
double getWeightedModelCount() const;
void exportToGraphViz (const char*);
@ -275,7 +275,7 @@ class LiftedCircuit {
OrNode::~OrNode (void)
OrNode::~OrNode()
{
delete leftBranch_;
delete rightBranch_;
@ -284,7 +284,7 @@ OrNode::~OrNode (void)
double
OrNode::weight (void) const
OrNode::weight() const
{
double lw = leftBranch_->weight();
double rw = rightBranch_->weight();
@ -293,7 +293,7 @@ OrNode::weight (void) const
AndNode::~AndNode (void)
AndNode::~AndNode()
{
delete leftBranch_;
delete rightBranch_;
@ -302,7 +302,7 @@ AndNode::~AndNode (void)
double
AndNode::weight (void) const
AndNode::weight() const
{
double lw = leftBranch_->weight();
double rw = rightBranch_->weight();
@ -316,7 +316,7 @@ int SetOrNode::nrNeg_ = -1;
SetOrNode::~SetOrNode (void)
SetOrNode::~SetOrNode()
{
delete follow_;
}
@ -324,7 +324,7 @@ SetOrNode::~SetOrNode (void)
double
SetOrNode::weight (void) const
SetOrNode::weight() const
{
double weightSum = LogAware::addIdenty();
for (unsigned i = 0; i < nrGroundings_ + 1; i++) {
@ -346,7 +346,7 @@ SetOrNode::weight (void) const
SetAndNode::~SetAndNode (void)
SetAndNode::~SetAndNode()
{
delete follow_;
}
@ -354,14 +354,14 @@ SetAndNode::~SetAndNode (void)
double
SetAndNode::weight (void) const
SetAndNode::weight() const
{
return LogAware::pow (follow_->weight(), nrGroundings_);
}
IncExcNode::~IncExcNode (void)
IncExcNode::~IncExcNode()
{
delete plus1Branch_;
delete plus2Branch_;
@ -371,7 +371,7 @@ IncExcNode::~IncExcNode (void)
double
IncExcNode::weight (void) const
IncExcNode::weight() const
{
double w = 0.0;
if (Globals::logDomain) {
@ -386,7 +386,7 @@ IncExcNode::weight (void) const
LeafNode::~LeafNode (void)
LeafNode::~LeafNode()
{
delete clause_;
}
@ -394,7 +394,7 @@ LeafNode::~LeafNode (void)
double
LeafNode::weight (void) const
LeafNode::weight() const
{
assert (clause_->isUnit());
if (clause_->posCountedLogVars().empty() == false
@ -431,7 +431,7 @@ LeafNode::weight (void) const
SmoothNode::~SmoothNode (void)
SmoothNode::~SmoothNode()
{
Clause::deleteClauses (clauses_);
}
@ -439,7 +439,7 @@ SmoothNode::~SmoothNode (void)
double
SmoothNode::weight (void) const
SmoothNode::weight() const
{
Clauses cs = clauses();
double totalWeight = LogAware::multIdenty();
@ -474,7 +474,7 @@ SmoothNode::weight (void) const
double
TrueNode::weight (void) const
TrueNode::weight() const
{
return LogAware::multIdenty();
}
@ -482,7 +482,7 @@ TrueNode::weight (void) const
double
CompilationFailedNode::weight (void) const
CompilationFailedNode::weight() const
{
// weighted model counting in compilation
// failed nodes should give NaN
@ -515,7 +515,7 @@ LiftedCircuit::LiftedCircuit (const LiftedWCNF* lwcnf)
LiftedCircuit::~LiftedCircuit (void)
LiftedCircuit::~LiftedCircuit()
{
delete root_;
std::unordered_map<CircuitNode*, Clauses>::iterator it
@ -529,7 +529,7 @@ LiftedCircuit::~LiftedCircuit (void)
bool
LiftedCircuit::isCompilationSucceeded (void) const
LiftedCircuit::isCompilationSucceeded() const
{
return compilationSucceeded_;
}
@ -537,7 +537,7 @@ LiftedCircuit::isCompilationSucceeded (void) const
double
LiftedCircuit::getWeightedModelCount (void) const
LiftedCircuit::getWeightedModelCount() const
{
assert (compilationSucceeded_);
return root_->weight();
@ -1568,7 +1568,7 @@ LiftedKc::solveQuery (const Grounds& query)
void
LiftedKc::printSolverFlags (void) const
LiftedKc::printSolverFlags() const
{
std::stringstream ss;
ss << "lifted kc [" ;

2
packages/CLPBN/horus/LiftedKc.h
View File

@ -14,7 +14,7 @@ class LiftedKc : public LiftedSolver {
Params solveQuery (const Grounds&);
void printSolverFlags (void) const;
void printSolverFlags() const;
private:
DISALLOW_COPY_AND_ASSIGN (LiftedKc);

2
packages/CLPBN/horus/LiftedSolver.h
View File

@ -15,7 +15,7 @@ class LiftedSolver {
virtual Params solveQuery (const Grounds& query) = 0;
virtual void printSolverFlags (void) const = 0;
virtual void printSolverFlags() const = 0;
protected:
const ParfactorList& parfactorList;

4
packages/CLPBN/horus/LiftedUtils.cpp
View File

@ -28,7 +28,7 @@ getSymbol (const std::string& symbolName)
void
printSymbolDictionary (void)
printSymbolDictionary()
{
std::unordered_map<std::string, unsigned>::const_iterator it
= symbolDict.begin();
@ -98,7 +98,7 @@ operator<< (std::ostream& os, const Ground& gr)
LogVars
Substitution::getDiscardedLogVars (void) const
Substitution::getDiscardedLogVars() const
{
LogVars discardedLvs;
std::set<LogVar> doneLvs;

36
packages/CLPBN/horus/LiftedUtils.h
View File

@ -14,15 +14,15 @@ namespace Horus {
class Symbol {
public:
Symbol (void) : id_(Util::maxUnsigned()) { }
Symbol() : id_(Util::maxUnsigned()) { }
Symbol (unsigned id) : id_(id) { }
operator unsigned (void) const { return id_; }
operator unsigned() const { return id_; }
bool valid (void) const { return id_ != Util::maxUnsigned(); }
bool valid() const { return id_ != Util::maxUnsigned(); }
static Symbol invalid (void) { return Symbol(); }
static Symbol invalid() { return Symbol(); }
private:
friend std::ostream& operator<< (std::ostream&, const Symbol&);
@ -33,15 +33,15 @@ class Symbol {
class LogVar {
public:
LogVar (void) : id_(Util::maxUnsigned()) { }
LogVar() : id_(Util::maxUnsigned()) { }
LogVar (unsigned id) : id_(id) { }
operator unsigned (void) const { return id_; }
operator unsigned() const { return id_; }
LogVar& operator++ (void);
LogVar& operator++();
bool valid (void) const;
bool valid() const;
private:
friend std::ostream& operator<< (std::ostream&, const LogVar&);
@ -52,7 +52,7 @@ class LogVar {
inline LogVar&
LogVar::operator++ (void)
LogVar::operator++()
{
assert (valid());
id_ ++;
@ -62,7 +62,7 @@ LogVar::operator++ (void)
inline bool
LogVar::valid (void) const
LogVar::valid() const
{
return id_ != Util::maxUnsigned();
}
@ -103,7 +103,7 @@ namespace LiftedUtils {
Symbol getSymbol (const std::string&);
void printSymbolDictionary (void);
void printSymbolDictionary();
}
@ -116,13 +116,13 @@ class Ground {
Ground (Symbol f, const Symbols& args)
: functor_(f), args_(args) { }
Symbol functor (void) const { return functor_; }
Symbol functor() const { return functor_; }
Symbols args (void) const { return args_; }
Symbols args() const { return args_; }
size_t arity (void) const { return args_.size(); }
size_t arity() const { return args_.size(); }
bool isAtom (void) const { return args_.empty(); }
bool isAtom() const { return args_.empty(); }
private:
friend std::ostream& operator<< (std::ostream&, const Ground&);
@ -145,9 +145,9 @@ class Substitution {
bool containsReplacementFor (LogVar X) const;
size_t nrReplacements (void) const;
size_t nrReplacements() const;
LogVars getDiscardedLogVars (void) const;
LogVars getDiscardedLogVars() const;
private:
friend std::ostream& operator<< (
@ -199,7 +199,7 @@ Substitution::containsReplacementFor (LogVar X) const
inline size_t
Substitution::nrReplacements (void) const
Substitution::nrReplacements() const
{
return subs_.size();
}

62
packages/CLPBN/horus/LiftedVe.cpp
View File

@ -18,13 +18,13 @@ namespace Horus {
class LiftedOperator {
public:
virtual ~LiftedOperator (void) { }
virtual ~LiftedOperator() { }
virtual double getLogCost (void) = 0;
virtual double getLogCost() = 0;
virtual void apply (void) = 0;
virtual void apply() = 0;
virtual std::string toString (void) = 0;
virtual std::string toString() = 0;
static std::vector<LiftedOperator*> getValidOps (
ParfactorList&, const Grounds&);
@ -48,13 +48,13 @@ class ProductOperator : public LiftedOperator {
ParfactorList& pfList)
: g1_(g1), g2_(g2), pfList_(pfList) { }
double getLogCost (void);
double getLogCost();
void apply (void);
void apply();
static std::vector<ProductOperator*> getValidOps (ParfactorList&);
std::string toString (void);
std::string toString();
private:
static bool validOp (Parfactor*, Parfactor*);
@ -73,14 +73,14 @@ class SumOutOperator : public LiftedOperator {
SumOutOperator (PrvGroup group, ParfactorList& pfList)
: group_(group), pfList_(pfList) { }
double getLogCost (void);
double getLogCost();
void apply (void);
void apply();
static std::vector<SumOutOperator*> getValidOps (
ParfactorList&, const Grounds&);
std::string toString (void);
std::string toString();
private:
static bool validOp (PrvGroup, ParfactorList&, const Grounds&);
@ -103,13 +103,13 @@ class CountingOperator : public LiftedOperator {
ParfactorList& pfList)
: pfIter_(pfIter), X_(X), pfList_(pfList) { }
double getLogCost (void);
double getLogCost();
void apply (void);
void apply();
static std::vector<CountingOperator*> getValidOps (ParfactorList&);
std::string toString (void);
std::string toString();
private:
static bool validOp (Parfactor*, LogVar);
@ -131,16 +131,16 @@ class GroundOperator : public LiftedOperator {
ParfactorList& pfList)
: group_(group), lvIndex_(lvIndex), pfList_(pfList) { }
double getLogCost (void);
double getLogCost();
void apply (void);
void apply();
static std::vector<GroundOperator*> getValidOps (ParfactorList&);
std::string toString (void);
std::string toString();
private:
std::vector<std::pair<PrvGroup, unsigned>> getAffectedFormulas (void);
std::vector<std::pair<PrvGroup, unsigned>> getAffectedFormulas();
PrvGroup group_;
unsigned lvIndex_;
@ -212,7 +212,7 @@ LiftedOperator::getParfactorsWithGroup (
double
ProductOperator::getLogCost (void)
ProductOperator::getLogCost()
{
return std::log (0.0);
}
@ -220,7 +220,7 @@ ProductOperator::getLogCost (void)
void
ProductOperator::apply (void)
ProductOperator::apply()
{
Parfactor* g1 = *g1_;
Parfactor* g2 = *g2_;
@ -272,7 +272,7 @@ ProductOperator::getValidOps (ParfactorList& pfList)
std::string
ProductOperator::toString (void)
ProductOperator::toString()
{
std::stringstream ss;
ss << "just multiplicate " ;
@ -311,7 +311,7 @@ ProductOperator::validOp (Parfactor* g1, Parfactor* g2)
double
SumOutOperator::getLogCost (void)
SumOutOperator::getLogCost()
{
TinySet<PrvGroup> groupSet;
ParfactorList::const_iterator pfIter = pfList_.begin();
@ -346,7 +346,7 @@ SumOutOperator::getLogCost (void)
void
SumOutOperator::apply (void)
SumOutOperator::apply()
{
std::vector<ParfactorList::iterator> iters;
iters = getParfactorsWithGroup (pfList_, group_);
@ -405,7 +405,7 @@ SumOutOperator::getValidOps (
std::string
SumOutOperator::toString (void)
SumOutOperator::toString()
{
std::stringstream ss;
std::vector<ParfactorList::iterator> pfIters;
@ -478,7 +478,7 @@ SumOutOperator::isToEliminate (
double
CountingOperator::getLogCost (void)
CountingOperator::getLogCost()
{
double cost = 0.0;
size_t fIdx = (*pfIter_)->indexOfLogVar (X_);
@ -513,7 +513,7 @@ CountingOperator::getLogCost (void)
void
CountingOperator::apply (void)
CountingOperator::apply()
{
if ((*pfIter_)->constr()->isCountNormalized (X_)) {
(*pfIter_)->countConvert (X_);
@ -558,7 +558,7 @@ CountingOperator::getValidOps (ParfactorList& pfList)
std::string
CountingOperator::toString (void)
CountingOperator::toString()
{
std::stringstream ss;
ss << "count convert " << X_ << " in " ;
@ -598,7 +598,7 @@ CountingOperator::validOp (Parfactor* g, LogVar X)
double
GroundOperator::getLogCost (void)
GroundOperator::getLogCost()
{
std::vector<std::pair<PrvGroup, unsigned>> affectedFormulas;
affectedFormulas = getAffectedFormulas();
@ -651,7 +651,7 @@ GroundOperator::getLogCost (void)
void
GroundOperator::apply (void)
GroundOperator::apply()
{
ParfactorList::iterator pfIter;
pfIter = getParfactorsWithGroup (pfList_, group_).front();
@ -708,7 +708,7 @@ GroundOperator::getValidOps (ParfactorList& pfList)
std::string
GroundOperator::toString (void)
GroundOperator::toString()
{
std::stringstream ss;
std::vector<ParfactorList::iterator> pfIters;
@ -736,7 +736,7 @@ GroundOperator::toString (void)
std::vector<std::pair<PrvGroup, unsigned>>
GroundOperator::getAffectedFormulas (void)
GroundOperator::getAffectedFormulas()
{
std::vector<std::pair<PrvGroup, unsigned>> affectedFormulas;
affectedFormulas.push_back (std::make_pair (group_, lvIndex_));
@ -788,7 +788,7 @@ LiftedVe::solveQuery (const Grounds& query)
void
LiftedVe::printSolverFlags (void) const
LiftedVe::printSolverFlags() const
{
std::stringstream ss;
ss << "lve [" ;

2
packages/CLPBN/horus/LiftedVe.h
View File

@ -17,7 +17,7 @@ class LiftedVe : public LiftedSolver {
Params solveQuery (const Grounds&);
void printSolverFlags (void) const;
void printSolverFlags() const;
private:
void runSolver (const Grounds&);

14
packages/CLPBN/horus/LiftedWCNF.cpp
View File

@ -226,7 +226,7 @@ Clause::isIpgLogVar (LogVar X) const
TinySet<LiteralId>
Clause::lidSet (void) const
Clause::lidSet() const
{
TinySet<LiteralId> lidSet;
for (size_t i = 0; i < literals_.size(); i++) {
@ -238,7 +238,7 @@ Clause::lidSet (void) const
LogVarSet
Clause::ipgCandidates (void) const
Clause::ipgCandidates() const
{
LogVarSet candidates;
LogVarSet allLvs = constr_.logVarSet();
@ -396,7 +396,7 @@ operator<< (std::ostream& os, const LitLvTypes& lit)
void
LitLvTypes::setAllFullLogVars (void)
LitLvTypes::setAllFullLogVars()
{
std::fill (lvTypes_.begin(), lvTypes_.end(), LogVarType::fullLvt);
}
@ -470,7 +470,7 @@ LiftedWCNF::LiftedWCNF (const ParfactorList& pfList)
LiftedWCNF::~LiftedWCNF (void)
LiftedWCNF::~LiftedWCNF()
{
Clause::deleteClauses (clauses_);
}
@ -624,7 +624,7 @@ LiftedWCNF::addParameterClauses (const ParfactorList& pfList)
void
LiftedWCNF::printFormulaIndicators (void) const
LiftedWCNF::printFormulaIndicators() const
{
if (map_.empty()) {
return;
@ -653,7 +653,7 @@ LiftedWCNF::printFormulaIndicators (void) const
void
LiftedWCNF::printWeights (void) const
LiftedWCNF::printWeights() const
{
std::unordered_map<LiteralId, std::pair<double,double>>::const_iterator it
= weights_.begin();
@ -668,7 +668,7 @@ LiftedWCNF::printWeights (void) const
void
LiftedWCNF::printClauses (void) const
LiftedWCNF::printClauses() const
{
Clause::printClauses (clauses_);
}

56
packages/CLPBN/horus/LiftedWCNF.h
View File

@ -33,19 +33,19 @@ class Literal {
Literal (const Literal& lit, bool negated)
: lid_(lit.lid_), logVars_(lit.logVars_), negated_(negated) { }
LiteralId lid (void) const { return lid_; }
LiteralId lid() const { return lid_; }
LogVars logVars (void) const { return logVars_; }
LogVars logVars() const { return logVars_; }
size_t nrLogVars (void) const { return logVars_.size(); }
size_t nrLogVars() const { return logVars_.size(); }
LogVarSet logVarSet (void) const { return LogVarSet (logVars_); }
LogVarSet logVarSet() const { return LogVarSet (logVars_); }
void complement (void) { negated_ = !negated_; }
void complement() { negated_ = !negated_; }
bool isPositive (void) const { return negated_ == false; }
bool isPositive() const { return negated_ == false; }
bool isNegative (void) const { return negated_; }
bool isNegative() const { return negated_; }
bool isGround (ConstraintTree constr, const LogVarSet& ipgLogVars) const;
@ -77,19 +77,19 @@ class Clause {
void addLiteral (const Literal& l) { literals_.push_back (l); }
const Literals& literals (void) const { return literals_; }
const Literals& literals() const { return literals_; }
Literals& literals (void) { return literals_; }
Literals& literals() { return literals_; }
size_t nrLiterals (void) const { return literals_.size(); }
size_t nrLiterals() const { return literals_.size(); }
const ConstraintTree& constr (void) const { return constr_; }
const ConstraintTree& constr() const { return constr_; }
ConstraintTree constr (void) { return constr_; }
ConstraintTree constr() { return constr_; }
bool isUnit (void) const { return literals_.size() == 1; }
bool isUnit() const { return literals_.size() == 1; }
LogVarSet ipgLogVars (void) const { return ipgLvs_; }
LogVarSet ipgLogVars() const { return ipgLvs_; }
void addIpgLogVar (LogVar X) { ipgLvs_.insert (X); }
@ -97,13 +97,13 @@ class Clause {
void addNegCountedLogVar (LogVar X) { negCountedLvs_.insert (X); }
LogVarSet posCountedLogVars (void) const { return posCountedLvs_; }
LogVarSet posCountedLogVars() const { return posCountedLvs_; }
LogVarSet negCountedLogVars (void) const { return negCountedLvs_; }
LogVarSet negCountedLogVars() const { return negCountedLvs_; }
unsigned nrPosCountedLogVars (void) const { return posCountedLvs_.size(); }
unsigned nrPosCountedLogVars() const { return posCountedLvs_.size(); }
unsigned nrNegCountedLogVars (void) const { return negCountedLvs_.size(); }
unsigned nrNegCountedLogVars() const { return negCountedLvs_.size(); }
void addLiteralComplemented (const Literal& lit);
@ -127,9 +127,9 @@ class Clause {
bool isIpgLogVar (LogVar X) const;
TinySet<LiteralId> lidSet (void) const;
TinySet<LiteralId> lidSet() const;
LogVarSet ipgCandidates (void) const;
LogVarSet ipgCandidates() const;
LogVarTypes logVarTypes (size_t litIdx) const;
@ -167,11 +167,11 @@ class LitLvTypes {
LitLvTypes (LiteralId lid, const LogVarTypes& lvTypes) :
lid_(lid), lvTypes_(lvTypes) { }
LiteralId lid (void) const { return lid_; }
LiteralId lid() const { return lid_; }
const LogVarTypes& logVarTypes (void) const { return lvTypes_; }
const LogVarTypes& logVarTypes() const { return lvTypes_; }
void setAllFullLogVars (void);
void setAllFullLogVars();
private:
friend std::ostream& operator<< (std::ostream&, const LitLvTypes&);
@ -206,9 +206,9 @@ class LiftedWCNF {
public:
LiftedWCNF (const ParfactorList& pfList);
~LiftedWCNF (void);
~LiftedWCNF();
const Clauses& clauses (void) const { return clauses_; }
const Clauses& clauses() const { return clauses_; }
void addWeight (LiteralId lid, double posW, double negW);
@ -220,11 +220,11 @@ class LiftedWCNF {
Clause* createClause (LiteralId lid) const;
void printFormulaIndicators (void) const;
void printFormulaIndicators() const;
void printWeights (void) const;
void printWeights() const;
void printClauses (void) const;
void printClauses() const;
private:
LiteralId getLiteralId (PrvGroup prvGroup, unsigned range);

20
packages/CLPBN/horus/Parfactor.cpp
View File

@ -91,7 +91,7 @@ Parfactor::Parfactor (const Parfactor& g)
Parfactor::~Parfactor (void)
Parfactor::~Parfactor()
{
delete constr_;
}
@ -99,7 +99,7 @@ Parfactor::~Parfactor (void)
LogVarSet
Parfactor::countedLogVars (void) const
Parfactor::countedLogVars() const
{
LogVarSet set;
for (size_t i = 0; i < args_.size(); i++) {
@ -113,7 +113,7 @@ Parfactor::countedLogVars (void) const
LogVarSet
Parfactor::uncountedLogVars (void) const
Parfactor::uncountedLogVars() const
{
return constr_->logVarSet() - countedLogVars();
}
@ -121,7 +121,7 @@ Parfactor::uncountedLogVars (void) const
LogVarSet
Parfactor::elimLogVars (void) const
Parfactor::elimLogVars() const
{
LogVarSet requiredToElim = constr_->logVarSet();
requiredToElim -= constr_->singletons();
@ -398,7 +398,7 @@ Parfactor::absorveEvidence (const ProbFormula& formula, unsigned evidence)
void
Parfactor::setNewGroups (void)
Parfactor::setNewGroups()
{
for (size_t i = 0; i < args_.size(); i++) {
args_[i].setGroup (ProbFormula::getNewGroup());
@ -573,7 +573,7 @@ Parfactor::nrFormulasWithGroup (PrvGroup group) const
std::vector<PrvGroup>
Parfactor::getAllGroups (void) const
Parfactor::getAllGroups() const
{
std::vector<PrvGroup> groups (args_.size());
for (size_t i = 0; i < args_.size(); i++) {
@ -585,7 +585,7 @@ Parfactor::getAllGroups (void) const
std::string
Parfactor::getLabel (void) const
Parfactor::getLabel() const
{
std::stringstream ss;
ss << "phi(" ;
@ -642,7 +642,7 @@ Parfactor::print (bool printParams) const
void
Parfactor::printParameters (void) const
Parfactor::printParameters() const
{
std::vector<std::string> jointStrings;
Indexer indexer (ranges_);
@ -676,7 +676,7 @@ Parfactor::printParameters (void) const
void
Parfactor::printProjections (void) const
Parfactor::printProjections() const
{
ConstraintTree copy (*constr_);
@ -768,7 +768,7 @@ Parfactor::simplifyCountingFormulas (size_t fIdx)
void
Parfactor::simplifyGrounds (void)
Parfactor::simplifyGrounds()
{
if (args_.size() == 1) {
return;

28
packages/CLPBN/horus/Parfactor.h
View File

@ -24,21 +24,21 @@ class Parfactor : public TFactor<ProbFormula> {
Parfactor (const Parfactor&);
~Parfactor (void);
~Parfactor();
ConstraintTree* constr (void) { return constr_; }
ConstraintTree* constr() { return constr_; }
const ConstraintTree* constr (void) const { return constr_; }
const ConstraintTree* constr() const { return constr_; }
const LogVars& logVars (void) const { return constr_->logVars(); }
const LogVars& logVars() const { return constr_->logVars(); }
const LogVarSet& logVarSet (void) const { return constr_->logVarSet(); }
const LogVarSet& logVarSet() const { return constr_->logVarSet(); }
LogVarSet countedLogVars (void) const;
LogVarSet countedLogVars() const;
LogVarSet uncountedLogVars (void) const;
LogVarSet uncountedLogVars() const;
LogVarSet elimLogVars (void) const;
LogVarSet elimLogVars() const;
LogVarSet exclusiveLogVars (size_t fIdx) const;
@ -58,7 +58,7 @@ class Parfactor : public TFactor<ProbFormula> {
void absorveEvidence (const ProbFormula&, unsigned);
void setNewGroups (void);
void setNewGroups();
void applySubstitution (const Substitution&);
@ -82,17 +82,17 @@ class Parfactor : public TFactor<ProbFormula> {
unsigned nrFormulasWithGroup (PrvGroup) const;
std::vector<PrvGroup> getAllGroups (void) const;
std::vector<PrvGroup> getAllGroups() const;
void print (bool = false) const;
void printParameters (void) const;
void printParameters() const;
void printProjections (void) const;
void printProjections() const;
std::string getLabel (void) const;
std::string getLabel() const;
void simplifyGrounds (void);
void simplifyGrounds();
static bool canMultiply (Parfactor*, Parfactor*);

6
packages/CLPBN/horus/ParfactorList.cpp
View File

@ -27,7 +27,7 @@ ParfactorList::ParfactorList (const Parfactors& pfs)
ParfactorList::~ParfactorList (void)
ParfactorList::~ParfactorList()
{
ParfactorList::const_iterator it = pfList_.begin();
while (it != pfList_.end()) {
@ -97,7 +97,7 @@ ParfactorList::removeAndDelete (std::list<Parfactor*>::iterator it)
bool
ParfactorList::isAllShattered (void) const
ParfactorList::isAllShattered() const
{
if (pfList_.size() <= 1) {
return true;
@ -119,7 +119,7 @@ ParfactorList::isAllShattered (void) const
void
ParfactorList::print (void) const
ParfactorList::print() const
{
struct sortByParams {
bool operator() (const Parfactor* pf1, const Parfactor* pf2)

22
packages/CLPBN/horus/ParfactorList.h
View File

@ -14,31 +14,31 @@ class Parfactor;
class ParfactorList {
public:
ParfactorList (void) { }
ParfactorList() { }
ParfactorList (const ParfactorList&);
ParfactorList (const Parfactors&);
~ParfactorList (void);
~ParfactorList();
const std::list<Parfactor*>& parfactors (void) const { return pfList_; }
const std::list<Parfactor*>& parfactors() const { return pfList_; }
void clear (void) { pfList_.clear(); }
void clear() { pfList_.clear(); }
size_t size (void) const { return pfList_.size(); }
size_t size() const { return pfList_.size(); }
typedef std::list<Parfactor*>::iterator iterator;
iterator begin (void) { return pfList_.begin(); }
iterator begin() { return pfList_.begin(); }
iterator end (void) { return pfList_.end(); }
iterator end() { return pfList_.end(); }
typedef std::list<Parfactor*>::const_iterator const_iterator;
const_iterator begin (void) const { return pfList_.begin(); }
const_iterator begin() const { return pfList_.begin(); }
const_iterator end (void) const { return pfList_.end(); }
const_iterator end() const { return pfList_.end(); }
void add (Parfactor* pf);
@ -55,9 +55,9 @@ class ParfactorList {
std::list<Parfactor*>::iterator removeAndDelete (
std::list<Parfactor*>::iterator);
bool isAllShattered (void) const;
bool isAllShattered() const;
void print (void) const;
void print() const;
ParfactorList& operator= (const ParfactorList& pfList);

10
packages/CLPBN/horus/ProbFormula.cpp
View File

@ -45,7 +45,7 @@ ProbFormula::indexOf (LogVar X) const
bool
ProbFormula::isAtom (void) const
ProbFormula::isAtom() const
{
return logVars_.empty();
}
@ -53,7 +53,7 @@ ProbFormula::isAtom (void) const
bool
ProbFormula::isCounting (void) const
ProbFormula::isCounting() const
{
return countedLogVar_.valid();
}
@ -61,7 +61,7 @@ ProbFormula::isCounting (void) const
LogVar
ProbFormula::countedLogVar (void) const
ProbFormula::countedLogVar() const
{
assert (isCounting());
return countedLogVar_;
@ -78,7 +78,7 @@ ProbFormula::setCountedLogVar (LogVar lv)
void
ProbFormula::clearCountedLogVar (void)
ProbFormula::clearCountedLogVar()
{
countedLogVar_ = LogVar();
}
@ -131,7 +131,7 @@ operator<< (std::ostream& os, const ProbFormula& f)
PrvGroup
ProbFormula::getNewGroup (void)
ProbFormula::getNewGroup()
{
freeGroup_ ++;
assert (freeGroup_ != std::numeric_limits<PrvGroup>::max());

34
packages/CLPBN/horus/ProbFormula.h
View File

@ -24,19 +24,19 @@ class ProbFormula {
: functor_(f), range_(r),
group_(std::numeric_limits<PrvGroup>::max()) { }
Symbol functor (void) const { return functor_; }
Symbol functor() const { return functor_; }
unsigned arity (void) const { return logVars_.size(); }
unsigned arity() const { return logVars_.size(); }
unsigned range (void) const { return range_; }
unsigned range() const { return range_; }
LogVars& logVars (void) { return logVars_; }
LogVars& logVars() { return logVars_; }
const LogVars& logVars (void) const { return logVars_; }
const LogVars& logVars() const { return logVars_; }
LogVarSet logVarSet (void) const { return LogVarSet (logVars_); }
LogVarSet logVarSet() const { return LogVarSet (logVars_); }
PrvGroup group (void) const { return group_; }
PrvGroup group() const { return group_; }
void setGroup (PrvGroup g) { group_ = g; }
@ -48,19 +48,19 @@ class ProbFormula {
size_t indexOf (LogVar) const;
bool isAtom (void) const;
bool isAtom() const;
bool isCounting (void) const;
bool isCounting() const;
LogVar countedLogVar (void) const;
LogVar countedLogVar() const;
void setCountedLogVar (LogVar);
void clearCountedLogVar (void);
void clearCountedLogVar();
void rename (LogVar, LogVar);
static PrvGroup getNewGroup (void);
static PrvGroup getNewGroup();
private:
friend bool operator== (
@ -86,17 +86,17 @@ class ObservedFormula {
ObservedFormula (Symbol f, unsigned ev, const Tuple& tuple);
Symbol functor (void) const { return functor_; }
Symbol functor() const { return functor_; }
unsigned arity (void) const { return arity_; }
unsigned arity() const { return arity_; }
unsigned evidence (void) const { return evidence_; }
unsigned evidence() const { return evidence_; }
void setEvidence (unsigned ev) { evidence_ = ev; }
ConstraintTree& constr (void) { return constr_; }
ConstraintTree& constr() { return constr_; }
bool isAtom (void) const { return arity_ == 0; }
bool isAtom() const { return arity_ == 0; }
void addTuple (const Tuple& tuple) { constr_.addTuple (tuple); }

44
packages/CLPBN/horus/TinySet.h
View File

@ -62,33 +62,33 @@ class TinySet {
T& operator[] (typename std::vector<T>::size_type i);
T front (void) const;
T front() const;
T& front (void);
T& front();
T back (void) const;
T back() const;
T& back (void);
T& back();
const std::vector<T>& elements (void) const;
const std::vector<T>& elements() const;
bool empty (void) const;
bool empty() const;
typename std::vector<T>::size_type size (void) const;
typename std::vector<T>::size_type size() const;
void clear (void);
void clear();
void reserve (typename std::vector<T>::size_type size);
iterator begin (void) { return vec_.begin(); }
iterator end (void) { return vec_.end(); }
const_iterator begin (void) const { return vec_.begin(); }
const_iterator end (void) const { return vec_.end(); }
iterator begin() { return vec_.begin(); }
iterator end () { return vec_.end(); }
const_iterator begin() const { return vec_.begin(); }
const_iterator end () const { return vec_.end(); }
private:
iterator unique_cmp (iterator first, iterator last);
bool consistent (void) const;
bool consistent() const;
friend bool operator== (const TinySet& s1, const TinySet& s2)
{
@ -303,7 +303,7 @@ TinySet<T,C>::operator[] (typename std::vector<T>::size_type i)
template <typename T, typename C> inline T
TinySet<T,C>::front (void) const
TinySet<T,C>::front() const
{
return vec_.front();
}
@ -311,7 +311,7 @@ TinySet<T,C>::front (void) const
template <typename T, typename C> inline T&
TinySet<T,C>::front (void)
TinySet<T,C>::front()
{
return vec_.front();
}
@ -319,7 +319,7 @@ TinySet<T,C>::front (void)
template <typename T, typename C> inline T
TinySet<T,C>::back (void) const
TinySet<T,C>::back() const
{
return vec_.back();
}
@ -327,7 +327,7 @@ TinySet<T,C>::back (void) const
template <typename T, typename C> inline T&
TinySet<T,C>::back (void)
TinySet<T,C>::back()
{
return vec_.back();
}
@ -335,7 +335,7 @@ TinySet<T,C>::back (void)
template <typename T, typename C> inline const std::vector<T>&
TinySet<T,C>::elements (void) const
TinySet<T,C>::elements() const
{
return vec_;
}
@ -343,7 +343,7 @@ TinySet<T,C>::elements (void) const
template <typename T, typename C> inline bool
TinySet<T,C>::empty (void) const
TinySet<T,C>::empty() const
{
return vec_.empty();
}
@ -351,7 +351,7 @@ TinySet<T,C>::empty (void) const
template <typename T, typename C> inline typename std::vector<T>::size_type
TinySet<T,C>::size (void) const
TinySet<T,C>::size() const
{
return vec_.size();
}
@ -359,7 +359,7 @@ TinySet<T,C>::size (void) const
template <typename T, typename C> inline void
TinySet<T,C>::clear (void)
TinySet<T,C>::clear()
{
vec_.clear();
}
@ -392,7 +392,7 @@ TinySet<T,C>::unique_cmp (iterator first, iterator last)
template <typename T, typename C> inline bool
TinySet<T,C>::consistent (void) const
TinySet<T,C>::consistent() const
{
typename std::vector<T>::size_type i;
for (i = 0; i < vec_.size() - 1; i++) {

4
packages/CLPBN/horus/Util.h
View File

@ -68,7 +68,7 @@ toString (const bool&);
double logSum (double, double);
unsigned maxUnsigned (void);
unsigned maxUnsigned();
unsigned stringToUnsigned (std::string);
@ -258,7 +258,7 @@ Util::logSum (double x, double y)
inline unsigned
Util::maxUnsigned (void)
Util::maxUnsigned()
{
return std::numeric_limits<unsigned>::max();
}

8
packages/CLPBN/horus/Var.cpp
View File

@ -48,7 +48,7 @@ Var::setEvidence (int evidence)
std::string
Var::label (void) const
Var::label() const
{
if (Var::varsHaveInfo()) {
return Var::getVarInfo (varId_).label;
@ -61,7 +61,7 @@ Var::label (void) const
States
Var::states (void) const
Var::states() const
{
if (Var::varsHaveInfo()) {
return Var::getVarInfo (varId_).states;
@ -97,7 +97,7 @@ Var::getVarInfo (VarId vid)
bool
Var::varsHaveInfo (void)
Var::varsHaveInfo()
{
return varsInfo_.empty() == false;
}
@ -105,7 +105,7 @@ Var::varsHaveInfo (void)
void
Var::clearVarsInfo (void)
Var::clearVarsInfo()
{
varsInfo_.clear();
}

26
packages/CLPBN/horus/Var.h
View File

@ -26,21 +26,21 @@ class Var {
Var (VarId, unsigned, int = Constants::unobserved);
virtual ~Var (void) { };
virtual ~Var() { };
VarId varId (void) const { return varId_; }
VarId varId() const { return varId_; }
unsigned range (void) const { return range_; }
unsigned range() const { return range_; }
int getEvidence (void) const { return evidence_; }
int getEvidence() const { return evidence_; }
size_t getIndex (void) const { return index_; }
size_t getIndex() const { return index_; }
void setIndex (size_t idx) { index_ = idx; }
bool hasEvidence (void) const;
bool hasEvidence() const;
operator size_t (void) const;
operator size_t() const;
bool operator== (const Var& var) const;
@ -50,18 +50,18 @@ class Var {
void setEvidence (int);
std::string label (void) const;
std::string label() const;
States states (void) const;
States states() const;
static void addVarInfo (
VarId vid, std::string label, const States& states);
static VarInfo getVarInfo (VarId vid);
static bool varsHaveInfo (void);
static bool varsHaveInfo();
static void clearVarsInfo (void);
static void clearVarsInfo();
private:
VarId varId_;
@ -77,7 +77,7 @@ class Var {
inline bool
Var::hasEvidence (void) const
Var::hasEvidence() const
{
return evidence_ != Constants::unobserved;
}
@ -85,7 +85,7 @@ Var::hasEvidence (void) const
inline
Var::operator size_t (void) const
Var::operator size_t() const
{
return index_;
}

8
packages/CLPBN/horus/VarElim.cpp
View File

@ -37,7 +37,7 @@ VarElim::solveQuery (VarIds queryVids)
void
VarElim::printSolverFlags (void) const
VarElim::printSolverFlags() const
{
std::stringstream ss;
ss << "variable elimination [" ;
@ -58,7 +58,7 @@ VarElim::printSolverFlags (void) const
void
VarElim::createFactorList (void)
VarElim::createFactorList()
{
const FacNodes& facNodes = fg.facNodes();
factorList_.reserve (facNodes.size() * 2);
@ -80,7 +80,7 @@ VarElim::createFactorList (void)
void
VarElim::absorveEvidence (void)
VarElim::absorveEvidence()
{
if (Globals::verbosity > 2) {
Util::printDashedLine();
@ -190,7 +190,7 @@ VarElim::eliminate (VarId vid)
void
VarElim::printActiveFactors (void)
VarElim::printActiveFactors()
{
for (size_t i = 0; i < factorList_.size(); i++) {
if (factorList_[i]) {

10
packages/CLPBN/horus/VarElim.h
View File

@ -15,22 +15,22 @@ class VarElim : public GroundSolver {
public:
VarElim (const FactorGraph& fg) : GroundSolver (fg) { }
~VarElim (void) { }
~VarElim() { }
Params solveQuery (VarIds);
void printSolverFlags (void) const;
void printSolverFlags() const;
private:
void createFactorList (void);
void createFactorList();
void absorveEvidence (void);
void absorveEvidence();
Params processFactorList (const VarIds&);
void eliminate (VarId);
void printActiveFactors (void);
void printActiveFactors();
Factors factorList_;
unsigned largestFactorSize_;

8
packages/CLPBN/horus/WeightedBp.cpp
View File

@ -18,7 +18,7 @@ WeightedBp::WeightedBp (
WeightedBp::~WeightedBp (void)
WeightedBp::~WeightedBp()
{
for (size_t i = 0; i < links_.size(); i++) {
delete links_[i];
@ -77,7 +77,7 @@ WeightedBp::WeightedLink::WeightedLink (
void
WeightedBp::createLinks (void)
WeightedBp::createLinks()
{
using std::cout;
using std::endl;
@ -110,7 +110,7 @@ WeightedBp::createLinks (void)
void
WeightedBp::maxResidualSchedule (void)
WeightedBp::maxResidualSchedule()
{
if (nIters_ == 1) {
for (size_t i = 0; i < links_.size(); i++) {
@ -314,7 +314,7 @@ WeightedBp::getVarToFactorMsg (const BpLink* _link) const
void
WeightedBp::printLinkInformation (void) const
WeightedBp::printLinkInformation() const
{
using std::cout;
using std::endl;

18
packages/CLPBN/horus/WeightedBp.h
View File

@ -11,7 +11,7 @@ class WeightedBp : public BeliefProp {
WeightedBp (const FactorGraph& fg,
const std::vector<std::vector<unsigned>>& weights);
~WeightedBp (void);
~WeightedBp();
Params getPosterioriOf (VarId);
@ -21,13 +21,13 @@ class WeightedBp : public BeliefProp {
WeightedLink (FacNode* fn, VarNode* vn, size_t idx,
unsigned weight);
size_t index (void) const { return index_; }
size_t index() const { return index_; }
unsigned weight (void) const { return weight_; }
unsigned weight() const { return weight_; }
const Params& powMessage (void) const { return pwdMsg_; }
const Params& powMessage() const { return pwdMsg_; }
void updateMessage (void);
void updateMessage();
private:
size_t index_;
@ -37,15 +37,15 @@ class WeightedBp : public BeliefProp {
DISALLOW_COPY_AND_ASSIGN (WeightedLink);
};
void createLinks (void);
void createLinks();
void maxResidualSchedule (void);
void maxResidualSchedule();
void calcFactorToVarMsg (BpLink*);
Params getVarToFactorMsg (const BpLink*) const;
void printLinkInformation (void) const;
void printLinkInformation() const;
std::vector<std::vector<unsigned>> weights_;
@ -56,7 +56,7 @@ class WeightedBp : public BeliefProp {
inline void
WeightedBp::WeightedLink::updateMessage (void)
WeightedBp::WeightedLink::updateMessage()
{
pwdMsg_ = *nextMsg_;
swap (currMsg_, nextMsg_);