data.h

#ifndef __DATA_H__
#define __DATA_H__

#include <cstdlib>
#include <time.h>
#include <iostream>
#include <set>
#include <functional>
#include <vector>


// may be insufficient if you have 16 bit int's
typedef unsigned int hash_value;



// typedef unsigned long int simplex;
typedef int vertex;
typedef int simplex;

class flip;
class flips;
class vertices_lookup;


// a set of vertices; usually vertices of a simplex
class vertices: public std::set<vertex,std::less<vertex> >
{
 private:
  static int n;
  static int d;
  static vertices_lookup lookup;
 protected:
 public:
  vertices();
  vertices(const simplex&);
  const simplex vertices_to_simplex() const;
  const vertices & simplex_to_vertices(const simplex &); // uses lookup-table
  void set_dimensions(int N, int D);
  friend std::ostream & operator << (std::ostream &, const vertices &);
  friend bool operator==(const vertices &, const vertices &);
  bool full_set() const { return this->size() == n; }
};

// tables used by vertices to make computation faster
class vertices_lookup
{
 private:
  int n,d;
  std::vector<vertices> SimplexToVertices;
  std::vector<std::vector<int> > fast_binomial;
 protected:
  vertices manual_vertices_to_simplex(const simplex &) const;
 public:
  void generate_tables(int N, int D);
  const vertices & simplex_to_vertices(const simplex &) const;
  int get_binomial(int i, int j) const;
};


// total order on the vertices
struct vertices_order
{
  bool operator() (const vertices &, const vertices &) const;
};


// simplical complex, data compressed by vertices_to_simplex
class compact_simplices: public std::vector<simplex>
{
 private:
 protected:
 public:
  compact_simplices();
  virtual ~compact_simplices();
  hash_value hash_function() const;
  friend std::ostream & operator <<
    (std::ostream &, const compact_simplices &);
  friend const bool operator==
    (const compact_simplices &, const compact_simplices &);
};

// same but with complete vertex information
class simplices: public compact_simplices
{
 private:
  std::vector<vertices> v;
 protected:
  void compress();
  void decompress();
 public:
  simplices() { };
  simplices(const std::set<vertices,vertices_order> &);
  simplices(const compact_simplices &);
  bool starshaped(const vertex) const;
  bool fine() const;
  virtual ~simplices();
  const std::vector<vertices> & get_vertices() const { return(v); }
  friend std::ostream & operator << (std::ostream & out, const simplices & s);
};

class flip
{
 private:
  std::vector<vertices> deltaplus, deltaminus;
 protected:
 public:
  flip();
  flip(const std::vector<vertices>& pos, const std::vector<vertices>& neg);
  flip(const flip &);
  virtual ~flip();
  flip & operator =(const flip &);
  friend std::ostream & operator <<(std::ostream &, const flip &);
  const std::vector<vertices> & get_deltaplus()  const { return deltaplus; };
  const std::vector<vertices> & get_deltaminus() const { return deltaminus;};
  void mirror();
};

class flips: public std::vector<flip>
{
 protected:
  void sort_flips_containing();
 public:
  flips();
  virtual ~flips();
};


class goodcircuit
{
 private:
  std::vector<std::vector<vertices> > supported;
  flip supporter;
  std::vector<std::set<vertices,vertices_order> > link;
  std::set<vertices,vertices_order> bistellarneighbor;
  bool good;
 public:
  goodcircuit(const simplices &, const flip &);
  bool is_good() const { return(good); }
  void do_flip(const simplices &, const flip &);
  simplices get_neighbor() const { return(bistellarneighbor); }
};




#endif