mootNgrams.h

Go to the documentation of this file.

/* -*- Mode: C++ -*- */

/*
   libmoot : moocow's part-of-speech tagging library
   Copyright (C) 2003-2009 by Bryan Jurish <moocow@cpan.org>

   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 3 of the License, or (at your option) any later version.
   
   This library 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
   Lesser General Public License for more details.
   
   You should have received a copy of the GNU Lesser General Public
   License along with this library; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/

/*============================================================================
 * File: mootNgrams.h
 * Author:  Bryan Jurish <moocow@cpan.org>
 * Description:
 *    Class for storage & retrieval of N-Gram counts
 *============================================================================*/

#ifndef _moot_NGRAMS_H
#define _moot_NGRAMS_H

#include <mootToken.h>

moot_BEGIN_NAMESPACE

class mootNgrams {

public:
  //------ public typedefs

  typedef CountT NgramCount;

  typedef map<mootTagString,NgramCount> TrigramTable;

  class BigramEntry {
  public:
    CountT       count;   
    TrigramTable  freqs;   
  public:
    BigramEntry(const CountT bg_count=0) : count(bg_count) {};
  };

  typedef map<mootTagString,BigramEntry> BigramTable;
  
  class UnigramEntry {
  public:
    CountT       count;   
    BigramTable  freqs;   
  public:
    UnigramEntry(const CountT ug_count=0) : count(ug_count) {};
  };

  typedef map<mootTagString,UnigramEntry> NgramTable;

  class Ngram : public deque<mootTagString> {
  public:
    Ngram(void) {};
    Ngram(const mootTagString &tag1) {
      push_back(tag1);
    };
    Ngram(const mootTagString &tag1, const mootTagString &tag2) {
      push_back(tag1);
      push_back(tag2);
    };
    Ngram(const mootTagString &tag1, const mootTagString &tag2, const mootTagString &tag3) {
      push_back(tag1);
      push_back(tag2);
      push_back(tag3);
    };

    ~Ngram(void) {
      clear();
    };

    /*----------------
     * Accessors
     */
    const mootTagString &tag1(void) const { return (*this)[0]; } ;
    const mootTagString &tag2(void) const { return (*this)[1]; };
    const mootTagString &tag3(void) const { return (*this)[2]; };

    /*----------------
     * Manipulators
     */
    void push(const mootTagString &tag_new=mootTagString("")) {
      if (size() >= 3) pop_front();
      push_back(tag_new);
    };

    string as_string(void) const {
      string s = "<";
      for (const_iterator i = begin(); i != end(); i++) {
        s.append(*i);
        s.push_back(',');
      }
      if (s.size() > 1) {
        s[s.size()-1] = '>';
      } else {
        s.push_back('>');
      }
      return s;
    };
  };

public:
  //------ public data
  NgramTable  ngtable;  
  NgramCount  ugtotal;  
public:
  //------ public methods: constructurs etc.
  mootNgrams(void) : ugtotal(0) {};

  ~mootNgrams() {
    clear(); 
  };

  //------ public methods: manipulation

  void clear(void) {
    ngtable.clear();
    ugtotal = 0;
  };

  //------ public methods: information

  inline size_t n_unigrams(void) const
  { return ngtable.size(); };

  size_t n_bigrams(void) const;

  size_t n_trigrams(void) const;


  //------ public methods: counting
  inline void add_count(const mootTagString &tag, const NgramCount count)
  {
    ngtable[tag].count += count;
    ugtotal += count;
  };

  inline void add_count(const mootTagString &tag1, const mootTagString &tag2, const NgramCount count)
  {
    ngtable[tag1].freqs[tag2].count += count;
  };

  inline void add_count(const mootTagString &tag1, const mootTagString &tag2, const mootTagString &tag3, const NgramCount count)
  {
    ngtable[tag1].freqs[tag2].freqs[tag3] += count;
  };

  inline void add_count(const Ngram &ngram, const NgramCount count)
  {
    switch (ngram.size()) {
    case 0:
      break;
    case 1:
      add_count(ngram[0],count);
      break;
    case 2:
      add_count(ngram[0],ngram[1],count);
      break;
    case 3:
      add_count(ngram[0],ngram[1],ngram[2],count);
      break;
    default:
      //-- max: bash to trigrams
      add_count(ngram[ngram.size()-3],ngram[ngram.size()-2],ngram[ngram.size()-1],count);
      break;
    }
  };


  inline void add_counts(const Ngram &ngram, const NgramCount count)
  {
    size_t ngsize = ngram.size();
    if (ngsize < 1) return;

    NgramTable::iterator ngi1 = ngtable.find(ngram.tag1());
    if (ngi1 == ngtable.end()) {
      ngi1 = ngtable.insert(pair<mootTagString,UnigramEntry>(ngram.tag1(),UnigramEntry())).first;
    }
    ngi1->second.count += count;
    ugtotal += count;

    if (ngsize < 2) return;
    BigramTable::iterator ngi2 = ngi1->second.freqs.find(ngram.tag2());
    if (ngi2 == ngi1->second.freqs.end()) {
      ngi2 = ngi1->second.freqs.insert(pair<mootTagString,
                                            BigramEntry>  (ngram.tag2(),BigramEntry())).first;
    }
    ngi2->second.count += count;

    if (ngsize < 3) return;
    TrigramTable::iterator ngi3 = ngi2->second.freqs.find(ngram.tag3());
    if (ngi3 == ngi2->second.freqs.end()) {
      ngi2->second.freqs[ngram.tag3()] = count;
    } else {
      ngi3->second += count;
    }
  };

  //------ public methods: lookup

  inline const NgramCount lookup(const mootTagString &tag) const
  {
    NgramTable::const_iterator ugi = ngtable.find(tag);
    return ugi == ngtable.end() ? 0 : ugi->second.count;
  };

  inline const NgramCount lookup(const mootTagString &tag1, const mootTagString &tag2) const
  {
    NgramTable::const_iterator ugi = ngtable.find(tag1);
    if (ugi == ngtable.end()) return 0;
    BigramTable::const_iterator bgi = ugi->second.freqs.find(tag2);
    return bgi == ugi->second.freqs.end() ? 0 : bgi->second.count;
  };

  inline const NgramCount lookup(const mootTagString &tag1, const mootTagString &tag2, const mootTagString &tag3) const
  {
    NgramTable::const_iterator ugi = ngtable.find(tag1);
    if (ugi == ngtable.end()) return 0;
    BigramTable::const_iterator bgi = ugi->second.freqs.find(tag2);
    if (bgi == ugi->second.freqs.end()) return 0;
    TrigramTable::const_iterator tgi = bgi->second.freqs.find(tag3);
    return tgi == bgi->second.freqs.end() ? 0 : tgi->second;
  };

  //------ public methods: i/o

  bool load(const char *filename);

  bool load(FILE *file, const char *filename = NULL);

  bool save(const char *filename, bool compact=false);

  bool save(FILE *file, const char *filename = NULL, bool compact=false);
};

moot_END_NAMESPACE

#endif /* _moot_NGRAMS_H */