bayes/Bayes.h

/*----------------------------------------------------------------
 * project ....: bayes-irc
 * authors ....: shino
 * creation ...: 2004-10-26
 * revision ...: $Id: Bayes.h 25 2007-01-17 19:40:20Z shin0 $
 */

#ifndef BAYES_HPP__
#define BAYES_HPP__

#include <iostream>
#include <string>
#ifdef __GNUC__
#  include <ext/hash_map>
#else
#  include <hash_map>
#endif

#include "Score.h"
#include <boost/filesystem/path.hpp>
#include <boost/cstdint.hpp>

typedef boost::uintmax_t size_type;

#ifdef __GNUC__
// for some reason there is no hash-function for std::string in gcc
struct StringHash
{
    size_type operator()(const std::string& s) const
        { return __gnu_cxx::hash<const char*>()(s.c_str()); }
};

typedef __gnu_cxx::hash_map<std::string, size_type, StringHash> HashMap;
#elif defined _MSC_VER
typedef stdext::hash_map<std::string, size_type> HashMap;
#else
typedef std::hash_map<std::string, size_type> HashMap;
#endif

namespace Bayes {
    
    //==============================================================================
    // class HashTable

    class HashTable
        {
       public:
            HashTable();

            size_type getTotalWordCount() const { return m_nTotalCount; }

            size_type getWordCount(const std::string& word) const;

            template<typename Iter>
                void learn(Iter begin, Iter end);

            template<typename Iter>
                void unlearn(Iter begin, Iter end);

            static bool hasWhitespaces(const std::string& word);

            void read (std::istream& in);

            void write (std::ostream& out) const;

        protected:

            void learnWord(const std::string& word);

            void unlearnWord(const std::string& word);

        protected:
            HashMap m_tHashMap; 
            size_type m_nTotalCount; 
            static const char* const m_szWhitespaces; 
        private:
            friend std::ostream& operator<< (std::ostream& out, const HashTable& ht);
        };


    //------------------------------------------------------------------------------
    std::ostream& operator<< (std::ostream& out, const HashTable& ht);




    //==============================================================================
    // class BayesClassifier

    class BayesClassifier
        {
        public:
            typedef enum { 
                GOOD, 
                BAD 
            } ClassificationTable; 

        private:
            const double wordScore(const std::string& word) const;

            template<typename Iter>
                void unlearn(ClassificationTable table, Iter begin, Iter end);

            template<typename Iter>
                void learn(ClassificationTable table, Iter begin, Iter end);

        public:
            const Score score(const char* const text) const {
                return score(static_cast<const string>(text));
            }

            const Score score(const string& text) const;

            void learn(ClassificationTable table, const char* const text) {
                learn(table, static_cast<const string>(text));
            }

            void learn(ClassificationTable table, const string& text);

            void reclassify(ClassificationTable table, const char* const text) {
                reclassify(table, static_cast<const string>(text));
            }

            void reclassify(ClassificationTable table, const string& text);

            void load(const char* const file) {
                load(boost::filesystem::path(file, boost::filesystem::native));
            }

            void load(const std::string& file) {
                load(boost::filesystem::path(file, boost::filesystem::native));
            }

            void load(const boost::filesystem::path& file);

            void save(const char* const file) const {
                save(boost::filesystem::path(file, boost::filesystem::native));
            }
            
            void save(const std::string& file) const {
                save(boost::filesystem::path(file, boost::filesystem::native));
            }
            
            void save(const boost::filesystem::path& file) const;

        private:
            // use an array so we can use learn(size_t table, ...)
            HashTable m_atHashTables[2];
            static const int mScoredItems;
            static const char* const m_szTokenSeparators;
            static const char* const m_szTokenSeparatorsKept;
            friend std::ostream & operator<< (std::ostream& out, const BayesClassifier& base);
        };

    //------------------------------------------------------------------------------
    std::ostream& operator<< (std::ostream& out, const BayesClassifier& base);

} // namespace Bayes

#include "Bayes_impl.h"

#endif

---