Persistent_cohomology_column.h

/*    This file is part of the Gudhi Library. The Gudhi library
 *    (Geometric Understanding in Higher Dimensions) is a generic C++
 *    library for computational topology.
 *
 *    Author(s):       Clément Maria
 *
 *    Copyright (C) 2014  INRIA Sophia Antipolis-Méditerranée (France)
 *
 *    This program is free software: you can redistribute it and/or modify
 *    it under the terms of the GNU General Public License as published by
 *    the Free Software Foundation, either version 3 of the License, or
 *    (at your option) any later version.
 *
 *    This program 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 SRC_PERSISTENT_COHOMOLOGY_INCLUDE_GUDHI_PERSISTENT_COHOMOLOGY_PERSISTENT_COHOMOLOGY_COLUMN_H_
#define SRC_PERSISTENT_COHOMOLOGY_INCLUDE_GUDHI_PERSISTENT_COHOMOLOGY_PERSISTENT_COHOMOLOGY_COLUMN_H_

#include <list>

#include "boost/tuple/tuple.hpp"
#include "boost/intrusive/set.hpp"
#include "boost/intrusive/list.hpp"

namespace Gudhi {

namespace persistent_cohomology {

template<typename SimplexKey, typename ArithmeticElement>
class Persistent_cohomology_column;

struct cam_h_tag;
// for horizontal traversal in the CAM
struct cam_v_tag;
// for vertical traversal in the CAM

typedef boost::intrusive::list_base_hook<boost::intrusive::tag<cam_h_tag>,
    boost::intrusive::link_mode<boost::intrusive::auto_unlink>  // allows .unlink()
> base_hook_cam_h;

typedef boost::intrusive::list_base_hook<boost::intrusive::tag<cam_v_tag>,
    boost::intrusive::link_mode<boost::intrusive::normal_link>  // faster hook, less safe
> base_hook_cam_v;

template<typename SimplexKey, typename ArithmeticElement>
class Persistent_cohomology_cell : public base_hook_cam_h,
    public base_hook_cam_v {
 public:
  template<class T1, class T2> friend class Persistent_cohomology;
  friend class Persistent_cohomology_column<SimplexKey, ArithmeticElement>;

  typedef Persistent_cohomology_column<SimplexKey, ArithmeticElement> Column;

  Persistent_cohomology_cell(SimplexKey key, ArithmeticElement x,
                             Column * self_col)
      : key_(key),
        coefficient_(x),
        self_col_(self_col) {
  }

  SimplexKey key_;
  ArithmeticElement coefficient_;
  Column * self_col_;
};

/* 
 * \brief Sparse column for the Compressed Annotation Matrix.
 *
 * The non-zero coefficients of the column are stored in a
 * boost::intrusive::list. Contains a hook to be stored in a
 * boost::intrusive::set.
 */
template<typename SimplexKey, typename ArithmeticElement>
class Persistent_cohomology_column : public boost::intrusive::set_base_hook<
    boost::intrusive::link_mode<boost::intrusive::normal_link> > {
 private:
  template<class T1, class T2> friend class Persistent_cohomology;

  typedef Persistent_cohomology_cell<SimplexKey, ArithmeticElement> Cell;
  typedef boost::intrusive::list<Cell,
      boost::intrusive::constant_time_size<false>,
      boost::intrusive::base_hook<base_hook_cam_v> > Col_type;

  explicit Persistent_cohomology_column(SimplexKey key) {
    class_key_ = key;
    col_ = Col_type();
  }
 public:
  Persistent_cohomology_column(Persistent_cohomology_column const &other)
      : col_(),
        class_key_(other.class_key_) {
    if (!other.col_.empty())
      std::cerr << "Copying a non-empty column.\n";
  }

  bool is_null() {
    return col_.empty();
  }
  SimplexKey class_key() {
    return class_key_;
  }

  friend bool operator<(const Persistent_cohomology_column& c1,
                        const Persistent_cohomology_column& c2) {
    typename Col_type::const_iterator it1 = c1.col_.begin();
    typename Col_type::const_iterator it2 = c2.col_.begin();
    while (it1 != c1.col_.end() && it2 != c2.col_.end()) {
      if (it1->key_ == it2->key_) {
        if (it1->coefficient_ == it2->coefficient_) {
          ++it1;
          ++it2;
        } else {
          return it1->coefficient_ < it2->coefficient_;
        }
      } else {
        return it1->key_ < it2->key_;
      }
    }
    return (it2 != c2.col_.end());
  }

  Col_type col_;
  SimplexKey class_key_;
};

}  // namespace persistent_cohomology

}  // namespace Gudhi

#endif  // SRC_PERSISTENT_COHOMOLOGY_INCLUDE_GUDHI_PERSISTENT_COHOMOLOGY_PERSISTENT_COHOMOLOGY_COLUMN_H_