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-2008 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 2 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, write to the
// Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
// MA 02111-1307, USA.

// 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"


// --------------------------------------------------
// -------- 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.
        IndexEigenValues (const theConleyIndexType &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 */

inline IndexEigenValues::IndexEigenValues (const theConleyIndexType &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_

---