algstruct.h

Go to the documentation of this file.

 
 
 
// This file copyright (C) 1997-2016 by Pawel Pilarczyk.
//
// This file is part of the "chomp" program. It 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 software 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 software; see the file "license.txt". If not,
// please, see <https://www.gnu.org/licenses/>.
 
// Started in March 2006. Last revision: April 19, 2006.
 
 
#ifndef _CAPD_HOMENGIN_ALGSTRUCT_H_
#define _CAPD_HOMENGIN_ALGSTRUCT_H_
 
#include "chomp/system/config.h"
#include "chomp/system/textfile.h"
#include "chomp/system/timeused.h"
#include "chomp/system/arg.h"
#include "chomp/homology/homtools.h"
 
#include "capd/auxil/CRef.h"
#include "capd/homologicalAlgebra/HomologySignature.h"
 
#include <cstdlib>
#include <ctime>
#include <new>
#include <exception>
#include <iostream>
#include <fstream>
#include <iomanip>
#include <vector>
#include <sstream>
 
 
namespace chomp {
namespace homengin {
 
// --------------------------------------------------
// -------------- ALGEBRAIC STRUCTURE ---------------
// --------------------------------------------------
 
template<class euclidom>
class algstruct
{
public:
 algstruct ();
 
 ~algstruct ();
 
 int countLevels () const;
 
 void setBetti (int level, int number);
 
 void addBetti (int level, int howmuch);
 
 int getBetti (int level) const;
 
 void addTorsion (int level, euclidom coef);
 
 const euclidom &getTorsion (int level, int n) const;
 
 int countTorsion (int level) const;
 
 std::ostream &describe (std::ostream &out) const;
 
 std::ostream &showBetti (std::ostream &out) const;
 
private:
 std::vector<int> betti;
 
 std::vector<std::vector<euclidom> > torsion;
}; /* class algstruct */
 
// --------------------------------------------------
 
template <class euclidom>
inline algstruct<euclidom>::algstruct ()
{
 return;
} /* algstruct::algstruct */
 
template <class euclidom>
inline algstruct<euclidom>::~algstruct ()
{
 return;
} /* algstruct::~algstruct */
 
// --------------------------------------------------
 
template <class euclidom>
inline int algstruct<euclidom>::countLevels () const
{
 int nBetti = betti. size ();
 int nTorsion = torsion. size ();
 return (nBetti > nTorsion) ? nBetti : nTorsion;
} /* algstruct::countLevels */
 
template <class euclidom>
inline void algstruct<euclidom>::setBetti (int level, int number)
{
 if (level < 0)
  return;
 if (number <= 0)
  return;
 for (int nBetti = betti. size (); nBetti < level; ++ nBetti)
  betti. push_back (0);
 if (static_cast<unsigned> (level) < betti. size ())
  betti [level] = number;
 else
  betti. push_back (number);
 return;
} /* algstruct::setBetti */
 
template <class euclidom>
inline void algstruct<euclidom>::addBetti (int level, int howmuch)
{
 if (level < 0)
  return;
 if (static_cast<unsigned> (level) < betti. size ())
  betti [level] += howmuch;
 else
  setBetti (level, howmuch);
 return;
} /* algstruct::addBetti */
 
template <class euclidom>
inline int algstruct<euclidom>::getBetti (int level) const
{
 if (level < 0)
  return 0;
 if (static_cast<unsigned> (level) < betti. size ())
  return betti [level];
 else
  return 0;
} /* algstruct::getBetti */
 
template <class euclidom>
inline void algstruct<euclidom>::addTorsion (int level, euclidom coef)
{
 if (level < 0)
  return;
 std::vector<euclidom> empty;
 for (int nTorsion = torsion. size (); nTorsion <= level; ++ nTorsion)
  torsion. push_back (empty);
 torsion [level]. push_back (coef);
 return;
} /* algstruct::addTorsion */
 
template <class euclidom>
inline const euclidom &algstruct<euclidom>::getTorsion (int level, int n)
 const
{
 static euclidom e;
 
 if ((level < 0) || (n < 0))
  return e;
 if ((static_cast<unsigned> (level) < torsion. size ()) &&
  (static_cast<unsigned> (n) < torsion [level]. size ()))
  return torsion [level] [n];
 else
  return e;
} /* algstruct::getTorsion */
 
template <class euclidom>
inline int algstruct<euclidom>::countTorsion (int level) const
{
 if (level < 0)
  return 0;
 if (static_cast<unsigned> (level) < torsion. size ())
  return torsion [level]. size ();
 return 0;
} /* algstruct::countTorsion */
 
 
// --------------------------------------------------
 
template <class euclidom>
inline const char *ringsymbol ()
{
 return euclidom::ringsymbol ();
} /* ringsymbol */
 
template <>
inline const char *ringsymbol<int> ()
{
 return "Z";
} /* ringsymbol */
 
template <class euclidom>
std::ostream &algstruct<euclidom>::describe (std::ostream &out) const
{
 int nBetti = betti. size ();
 int nTorsion = torsion. size ();
 for (int i = 0; (i < nBetti) || (i < nTorsion); ++ i)
 {
  if (i)
   out << ", ";
  else
   out << '(';
  bool zero = true;
  if ((i < nBetti) && (betti [i] > 0))
  {
   zero = false;
   out << ringsymbol<euclidom> ();
   if (betti [i] > 1)
    out << '^' << betti [i];
   if ((i < nTorsion) && (torsion [i]. size ()))
    out << " + ";
  }
  if (i < nTorsion)
  {
   std::vector<euclidom> tor = torsion [i];
   for (unsigned j = 0; j < tor. size (); ++ j)
   {
    zero = false;
    if (j)
     out << " + ";
    out << ringsymbol<euclidom> () <<
     '_' << tor [j];
   }
  }
  if (zero)
   out << 0;
 }
 if (nBetti || nTorsion)
  out << ')';
 else
  out << '0';
 return out;
} /* algstruct::describe */
 
template <class euclidom>
std::ostream &algstruct<euclidom>::showBetti (std::ostream &out) const
{
 bool first = true;
 for (std::vector<int>::const_iterator it = betti. begin ();
  it != betti. end (); ++ it)
 {
  if (first)
   first = false;
  else
   out << ' ';
  out << *it;
 }
 return out;
} /* algstruct::showBetti */
 
template <class euclidom>
inline std::ostream &operator << (std::ostream &out,
 const algstruct<euclidom> &s)
{
 return s. describe (out);
} /* operator << */
 
template <class euclidom>
void hom2struct (const chomp::homology::chain<euclidom> *hom, int maxlevel,
 algstruct<euclidom> &h)
{
 for (int q = 0; q <= maxlevel; ++ q)
 {
  const chomp::homology::chain<euclidom> &c = hom [q];
  for (int i = 0; i < c. size (); ++ i)
  {
   const euclidom &e = c. coef (i);
   if (e. delta () == 1)
    h. addBetti (q, 1);
   else
    h. addTorsion (q, e);
  }
 }
 return;
} /* hom2struct */
 
template <class euclidom>
void sign2struct (const CRef<HomologySignature<int> > &homSignCR,
 algstruct<euclidom> &h)
{
 int dim = (*homSignCR). topDim ();
 for (int i = 0; i <= dim; ++ i)
 {
  h. setBetti (i, (*homSignCR). bettiNumber (i));
  FGAGrpSignature<int> &s = (*homSignCR) [i];
  for (int j = 0; j < s. numberOfTorsionCoefs (); ++ j)
  {
   euclidom e;
   e = s. torsionCoef (j);
   h. addTorsion (i, e);
  }
 }
 return;
} /* sign2struct */
 
 
} // namespace homengin
} // namespace chomp
 
#endif // _CAPD_HOMENGIN_ALGSTRUCT_H_