relation.h

Go to the documentation of this file.

//
//    FreeLing - Open Source Language Analyzers
//
//    Copyright (C) 2014   TALP Research Center
//                         Universitat Politecnica de Catalunya
//
//    This library is free software; you can redistribute it and/or
//    modify it under the terms of the GNU Affero 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
//    Affero General Public License for more details.
//
//    You should have received a copy of the GNU Affero 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
//
//    contact: Lluis Padro (padro@lsi.upc.es)
//             TALP Research Center
//             despatx C6.212 - Campus Nord UPC
//             08034 Barcelona.  SPAIN
//

#ifndef _LEXCHAIN_RELATION
#define _LEXCHAIN_RELATION

#include <set>
#include <string>
#include <vector>
#include <unordered_map>

#include "freeling/morfo/semdb.h"
#include "freeling/morfo/language.h"

namespace freeling {


  struct word_pos {
    const freeling::word &w;
    const freeling::sentence &s;
    int n_paragraph;
    int n_sentence;
    int position;

    word_pos(const freeling::word &w_p, const freeling::sentence &s_p,
             int n_paragraph, int n_sentence, int position);

    bool operator==(word_pos other) const;

    bool operator<(word_pos other) const;

    bool operator>(word_pos other) const;

    std::wstring toString() const;
  };


  struct related_words {
    const word_pos &w1;
    const word_pos &w2;
    double relatedness;

    related_words(const word_pos &w_p1, const word_pos &w_p2, double relatedness);

    std::wstring toString() const;
  };


  class relation {
  public:

    const std::wstring label;
    static int max_distance;

    relation(const std::wstring s, const std::wstring t);

    ~relation();

    bool is_compatible(const freeling::word &w) const;

    virtual bool compute_word (const freeling::word &w, const freeling::sentence &s,
                               const freeling::document &doc, int n_paragraph,
                               int n_sentence, int position, std::list<word_pos> &words,
                               std::list<related_words> &relations, std::unordered_map<std::wstring,
                               std::pair<int, word_pos*> > &unique_words) const = 0;

    virtual double get_homogeneity_index(const std::list<word_pos> &words,
                                         const std::list<related_words> &relations,
                                         const std::unordered_map<std::wstring,
                                         std::pair<int, word_pos*> > &unique_words) const = 0;

    virtual std::list<word_pos> order_words_by_weight(const std::unordered_map<std::wstring,
                                                      std::pair<int, word_pos*> > &unique_words) const = 0;


  protected:

    const freeling::regexp compatible_tag;
  };


  class same_word : public relation {

  public:

    same_word(std::wstring expr);

    double get_homogeneity_index(const std::list<word_pos> &words,
                                 const std::list<related_words> &relations,
                                 const std::unordered_map<std::wstring,
                                 std::pair<int, word_pos*> > &unique_words) const;

    bool compute_word (const freeling::word &w, const freeling::sentence &s,
                       const freeling::document &doc, int n_paragraph,
                       int n_sentence, int position, std::list<word_pos> &words,
                       std::list<related_words> &relations, std::unordered_map<std::wstring,
                       std::pair<int, word_pos*> > &unique_words) const;

    std::list<word_pos> order_words_by_weight(const std::unordered_map<std::wstring,
                                              std::pair<int, word_pos*> > &unique_words) const;
  };


  class hypernymy : public relation {

  public:

    hypernymy(int k, double alpha, const std::wstring &semfile, std::wstring expr);

    double get_homogeneity_index(const std::list<word_pos> &words,
                                 const std::list<related_words> &relations,
                                 const std::unordered_map<std::wstring,
                                 std::pair<int, word_pos*> > &unique_words) const;

    bool compute_word (const freeling::word &w, const freeling::sentence &s,
                       const freeling::document &doc, int n_paragraph, int n_sentence,
                       int position, std::list<word_pos> &words, std::list<related_words> &relations,
                       std::unordered_map<std::wstring, std::pair<int, word_pos*> > &unique_words) const;

    std::list<word_pos> order_words_by_weight(const std::unordered_map<std::wstring,
                                              std::pair<int, word_pos*> > &unique_words) const;

  private:

    static freeling::semanticDB * semdb;
    static int depth;
    static double alpha;

    int hypernymyAux(std::wstring s1, std::wstring s2, int k) const;

    const word_pos &count_relations(int n, const std::list<related_words> &relations) const;
  };


  class same_coref_group : public relation {

  public:

    same_coref_group(std::wstring expr);

    double get_homogeneity_index(const std::list<word_pos> &words,
                                 const std::list<related_words> &relations,
                                 const std::unordered_map<std::wstring,
                                 std::pair<int, word_pos*> > &unique_words) const;

    bool compute_word (const freeling::word &w, const freeling::sentence &s,
                       const freeling::document &doc, int n_paragraph, int n_sentence,
                       int position, std::list<word_pos> &words, std::list<related_words> &relations,
                       std::unordered_map<std::wstring, std::pair<int, word_pos*> > &unique_words) const;

    std::list<word_pos> order_words_by_weight(const std::unordered_map<std::wstring,
                                              std::pair<int, word_pos*> > &unique_words) const;
  };

}

#endif