Tanl Linguistic Pipeline

tag/Tanlpos/SuffixGuesser.h

/*
**  Tanl
**  tag/TanlPos/SuffixGuesser.h
**  ----------------------------------------------------------------------
**  Copyright (c) 2005  Giuseppe Attardi (attardi@di.unipi.it).
**  ----------------------------------------------------------------------
**
**  This file is part of Tanl.
**
**  Tanl is free software; you can redistribute it and/or modify it
**  under the terms of the GNU General Public License, version 3,
**  as published by the Free Software Foundation.
**
**  Tanl is distributed in the hope that it will be useful,
**  but WITHOUT ANY WARRANTY; without even the implied warranty of
**  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
**  GNU General Public License for more details.
**
**  You should have received a copy of the GNU General Public License
**  along with this program.  If not, see <http://www.gnu.org/licenses/>.
**  ----------------------------------------------------------------------
*/

#ifndef Tanl_POS_suffix_guesser_H
#define Tanl_POS_suffix_guesser_H

#include "Tag.h"

// standard
#include <map>
#include <string>
#include <vector>

namespace Tanl { namespace POS {

#define EMPTY_NODE (new TrieNode()) 


typedef std::map<TagID, int> TagCounts;

struct Counts
{
        Counts() : count(0) {}

        Counts(Counts* cpy) :
                count(cpy->count)
        {
                TagCounts temp(cpy->tagCounts);
                tagCounts = temp;
        }

        void serialize(std::ostream &out);

    void serialize(std::istream &in);

        Counts* update(TagID tag, int count);

        int count; 
        TagCounts tagCounts; 
};

struct TrieNode : public std::map<char, TrieNode*>
{
        Counts* tag_info; 
        bool terminal; 

        TrieNode() : tag_info(0), terminal(false) { }

        ~TrieNode()
        {
                if (tag_info) delete tag_info;
                FOR_EACH(TrieNode, (*this), it)
                        delete it->second;
        }

        void set_tag_info(Counts* tag);

        void serialize(std::ostream &out);

        void serialize(std::istream &in);

        TrieNode* add_char(Counts* legacy_counts, bool after_branch, int ix,
                        int stop, std::string& word, TagID tag, int count);

        bool empty_node();

        struct counts_iterator
        {
                std::string& word; 
                int     stop; 
                int     ix; 
                TrieNode*       node; 
                Counts* legacy_counts; 
                Counts  empty_counts; 

                counts_iterator(std::string& word, TrieNode* node) :
                        word(word),
                        ix(word.length() - 1),
                        stop(0),
                        node(node),
                        legacy_counts(&empty_counts)
                { }

                Counts* next()
                {
                        // Verifies whether there is anything to iterate
                        if (!node)
                                return 0;

                        // Saves the actual Counts object
                        Counts* ct;
                        if (node->tag_info)
                                ct = node->tag_info;
                        else
                                ct = legacy_counts;

                        // Prepare the iterator for the next round
                        if (ix >= stop)
                        {
                                legacy_counts = ct;
                                TrieNode::const_iterator tit = node->find(word[ix]);
                                if (tit == node->end())
                                        node = 0;
                                else
                                        node = tit->second;
                                ix--;
                        }
                        else
                                node = 0;

                        // Return saved Counts object
                        return ct;
                }
        };
};

struct SuffixGuesser
{    
        double  theta; 
        TrieNode        trie; 
        Counts  empty_counts; 

        void serialize(std::ostream &out);

        void serialize(std::istream &in);

        void add_word(int n, std::string& word, TagID tag, int count);

        double tagprob(std::string& word, int tagid);

        double tagprobs(std::string& word, std::vector<double>& probs);

        static double calculate_theta(std::vector<double>& apriori_tag_probs);
};

} // namespace POS
} // namespace Tanl

#endif // Tanl_POS_suffix_guesser_H

 

Copyright © 2005-2011 G. Attardi. Generated on 4 Mar 2011 by doxygen 1.6.1.