eigenval.h

Go to the documentation of this file.

/////////////////////////////////////////////////////////////////////////////
///
/// @file eigenval.h
///
/// Eigenvalues of the Conley index map.
/// This file contains the definition of a simple class which can be used
/// to store the eigenvalues of the Conley index map,
/// gathered by their level.
///
/// @author Pawel Pilarczyk
///
/////////////////////////////////////////////////////////////////////////////
 
// Copyright (C) 1997-2014 by Pawel Pilarczyk.
//
// This file is part of my research software package. This 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 on February 16, 2008. Last revision: February 21, 2008.
 
 
#ifndef _CMGRAPHS_EIGENVAL_H_
#define _CMGRAPHS_EIGENVAL_H_
 
 
// include some standard C++ header files
#include <string>
#include <sstream>
#include <fstream>
#include <cmath>
#include <algorithm>
#include <vector>
 
// include selected header files from the CHomP library
#include "chomp/system/config.h"
#include "chomp/system/textfile.h"
#include "chomp/cubes/cube.h"
#include "chomp/multiwork/mw.h"
 
// include local header files
#include "config.h"
#include "typedefs.h"
#include "typedyns.h"
 
 
// --------------------------------------------------
// -------- eigenvalues of the Conley index ---------
// --------------------------------------------------
 
/// Eigenvalues of the Conley index map gathered by levels.
class IndexEigenValues
{
public:
        /// The constructor of an empty object.
        IndexEigenValues ();
 
        /// The constructor of an object based on the given Conley index.
        /// Calls the computation of nonzero eigenvalues of the given
        /// Conley index and acquires the computed eigenvalues.
        template <class ConleyIndexType>
        IndexEigenValues (const ConleyIndexType &index);
 
        // The default copy constructor, assignment operator
        // and destructor are OK.
 
        /// Returns the vector of the real parts of the eigenvalues
        /// at the given level for appending.
        std::vector<double> &re (unsigned int level);
 
        /// Returns the vector of the real parts of the eigenvalues
        /// at the given level for reading only.
        const std::vector<double> &re (unsigned int level) const;
 
        /// Returns the vector of the imaginary parts of the eigenvalues
        /// at the given level for appending.
        std::vector<double> &im (unsigned int level);
 
        /// Returns the vector of the imaginary parts of the eigenvalues
        /// at the given level for reading only.
        const std::vector<double> &im (unsigned int level) const;
 
        /// Returns the number of levels + 1. To be used in a loop
        /// "for (int level = 0; level < this -> maxLevel (); ++ level)".
        int maxLevel () const;
 
        /// Returns "true" if there are no eigenvalues at any level.
        /// Otherwise returns "false". Does not verify if the eigenvalues
        /// are zero or not.
        bool trivial () const;
 
        /// Writes the eigenvalues in a human-readable format to the output
        /// stream. The separator of eigenvalues and line separator can be
        /// provided for customized output.
        /// Returns the reference of the provided output stream.
        std::ostream &write (std::ostream &out,
                const char *valueSep = 0, const char *lineSep = 0) const;
 
private:
        /// The vector of the real part vectors.
        std::vector<std::vector<double> > reVectors;
 
        /// The vector of the imaginary part vectors.
        std::vector<std::vector<double> > imVectors;
 
        /// Makes sure that the vectors are large enough for the given level.
        void addVectors (unsigned int level);
 
}; /* class IndexEigenValues */
 
// --------------------------------------------------
 
inline IndexEigenValues::IndexEigenValues ()
{
        return;
} /* IndexEigenValues::IndexEigenValues */
 
template <class ConleyIndexType>
inline IndexEigenValues::IndexEigenValues (const ConleyIndexType &index)
{
        int dim = index. dim ();
        for (int level = 0; level <= dim; ++ level)
        {
                std::vector<double> reVector, imVector;
                index. eigenvalues (level, reVector, imVector);
                reVectors. push_back (reVector);
                imVectors. push_back (imVector);
        }
        return;
} /* IndexEigenValues::IndexEigenValues */
 
inline void IndexEigenValues::addVectors (unsigned int level)
{
        while (reVectors. size () <= level)
        {
                std::vector<double> emptyVector;
                reVectors. push_back (emptyVector);
                imVectors. push_back (emptyVector);
        }
        return;
} /* IndexEigenValues::addVectors */
 
inline std::vector<double> &IndexEigenValues::re (unsigned int level)
{
        addVectors (level);
        return reVectors [level];
} /* IndexEigenValues::re */
 
inline const std::vector<double> &IndexEigenValues::re (unsigned int level)
        const
{
        if (reVectors. size () <= level)
                throw "Undefined level of eigenvalues requested (re).";
        return reVectors [level];
} /* IndexEigenValues::re */
 
inline std::vector<double> &IndexEigenValues::im (unsigned int level)
{
        addVectors (level);
        return imVectors [level];
} /* IndexEigenValues::im */
 
inline const std::vector<double> &IndexEigenValues::im (unsigned int level)
        const
{
        if (imVectors. size () <= level)
                throw "Undefined level of eigenvalues requested (im).";
        return imVectors [level];
} /* IndexEigenValues::im */
 
inline int IndexEigenValues::maxLevel () const
{
        return reVectors. size ();
} /* IndexEigenValues::maxLevel */
 
inline bool IndexEigenValues::trivial () const
{
        int maxLevel = reVectors. size ();
        for (int level = 0; level < maxLevel; ++ level)
        {
                if (!reVectors [level]. empty ())
                        return false;
        }
        return true;
} /* IndexEigenValues::trivial */
 
// --------------------------------------------------
 
inline std::ostream &IndexEigenValues::write (std::ostream &out,
        const char *valueSep, const char *lineSep) const
{
        // set the default separators if necessary
        if (!valueSep)
                valueSep = ", ";
        if (!lineSep)
                lineSep = "\n";
 
        // output the eigenvalues at each nontrivial level
        int maxLevel = reVectors. size ();
        for (int level = 0; level < maxLevel; ++ level)
        {
                const std::vector<double> &re = reVectors [level];
                int nValues = re. size ();
                if (!nValues)
                        continue;
                const std::vector<double> &im = imVectors [level];
                out << "Eigenvalues " << level << ":" << lineSep << "(";
                for (int i = 0; i < nValues; ++ i)
                {
                        if (i)
                                out << valueSep;
                        if (re [i])
                        {
                                out << re [i];
                                if (im [i] > 0)
                                        out << "+";
                        }
                        if (im [i])
                                out << im [i] << "i";
                }
                out << ")." << lineSep;
        }
        return out;
} /* IndexEigenValues::write */
 
 
#endif // _CMGRAPHS_EIGENVAL_H_