mootClassfreqs.h

Go to the documentation of this file.

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

/*
   libmoot : moocow's part-of-speech tagging library
   Copyright (C) 2003-2017 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: mootClassfreqs.h
 * Author:  Bryan Jurish <moocow@cpan.org>
 * Description:
 *    Class for storage & retrieval of lexical-class frequencies (nested map<>)
 *============================================================================*/

#ifndef _moot_CLASSFREQS_H
#define _moot_CLASSFREQS_H

#include <mootLexfreqs.h> 

moot_BEGIN_NAMESPACE

class mootClassfreqs {
public:
  //------ public typedefs

  typedef mootLexfreqs::LexfreqSubtable ClassfreqSubtable;

  typedef mootLexfreqs::LexfreqEntry ClassfreqEntry;

  typedef mootTagSet LexClass;

  struct LexClassHash {
  public:
    inline size_t operator()(const LexClass &x) const {
      size_t hv = 0;
      moot_hash<mootTagString> hasher;
      for (LexClass::const_iterator xi = x.begin(); xi != x.end(); xi++) {
        hv = 5*hv + hasher(*xi);
      }
      return hv;
    };
  };
  struct LexClassEqual {
  public:
    inline size_t operator()(const LexClass &x, const LexClass &y) const {
      return x==y;
    };
  };

  typedef hash_map<LexClass,
                   ClassfreqEntry,
                   LexClassHash,
                   LexClassEqual>
          ClassfreqTable;

  typedef hash_map<mootTagString,CountT> TagfreqTable;

public:
  //------ public data
  ClassfreqTable    lctable;    
  TagfreqTable      tagtable;   
  CountT            totalcount; 
public:
  //------ public methods
  mootClassfreqs(size_t initial_bucket_count=0) : totalcount(0)
  {
    if (initial_bucket_count != 0) {
      lctable.resize(initial_bucket_count);
    }
  };

  ~mootClassfreqs() {
    clear();
  }

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

  void clear(void);

  inline void add_count(const LexClass &lclass,
                        const mootTagString &tag,
                        const CountT count)
  {
    //-- adjust token-table
    ClassfreqTable::iterator lci = lctable.find(lclass);
    if (lci == lctable.end()) {
      //-- new class
      lci = lctable.insert(ClassfreqTable::value_type(lclass,ClassfreqEntry(count))).first;
      lci->second.freqs[tag] = count;
    } else {
      //-- known class
      lci->second.count += count;

      ClassfreqSubtable::iterator lsi = lci->second.freqs.find(tag);
      if (lsi == lci->second.freqs.end()) {
        //-- unknown (tok,tag) pair
        lci->second.freqs[tag] = count;
      } else {
        //-- known (tok,tag) pair: just add
        lsi->second += count;
      }
    }

    //-- adjust total tag-count
    TagfreqTable::iterator lctagi = tagtable.find(tag);
    if (lctagi != tagtable.end()) {
      lctagi->second += count;
    } else {
      tagtable[tag] = count;
    }

    //-- adjust total token-count
    totalcount += count;
  };

  //------ public methods: lookup
  const CountT taglookup(const mootTagString &tag) const
  {
    TagfreqTable::const_iterator tagi = tagtable.find(tag);
    return tagi == tagtable.end() ? 0 : tagi->second;
  };

  size_t n_pairs(void);

  size_t n_impossible(void);

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

  bool load(const char *filename);

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

  bool save(const char *filename);

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


moot_END_NAMESPACE

#endif /* _moot_CLASSFREQS_H */