User Manual, Developers Guide and API Documentation

MarkovBase.hpp

Go to the documentation of this file.

/*******************************************************************************
 * This file is part of openWNS (open Wireless Network Simulator)
 * _____________________________________________________________________________
 *
 * Copyright (C) 2004-2007
 * Chair of Communication Networks (ComNets)
 * Kopernikusstr. 5, D-52074 Aachen, Germany
 * phone: ++49-241-80-27910,
 * fax: ++49-241-80-22242
 * email: info@openwns.org
 * www: http://www.openwns.org
 * _____________________________________________________________________________
 *
 * openWNS is free software; you can redistribute it and/or modify it under the
 * terms of the GNU Lesser General Public License version 2 as published by the
 * Free Software Foundation;
 *
 * openWNS 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 Lesser General Public License for more
 * details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 ******************************************************************************/
#ifndef WNS_MARKOVCHAIN_MARKOVBASE_HPP
#define WNS_MARKOVCHAIN_MARKOVBASE_HPP

#include <WNS/logger/Logger.hpp>

#include <boost/numeric/ublas/matrix.hpp>
#include <boost/numeric/ublas/io.hpp>

namespace wns {  namespace markovchain {

    typedef boost::numeric::ublas::matrix<double> TransitionMatrixType;

    template<class T>
        class MarkovBase
        {
    public:

                friend std::ostream&
                operator <<(std::ostream& os, const MarkovBase& markov)
                {
                        os << "TransitionMatrix=";
                        os << markov.transitionsMatrix;
                        return os;
                }

        MarkovBase(int _numberOfChains) :
            numberOfStates(0),
            numberOfChains(_numberOfChains),
            startStates(std::vector<int>(numberOfChains,0)),
            actualStates(std::vector<int>(numberOfChains)),
            nextStates(std::vector<int>(numberOfChains)),
            nextTransitionTime(std::vector<double>(numberOfChains,0.0)),
            logger(std::string("WNS"), std::string("MarkovModel"))
        {
            for (int chainNumber = 0; chainNumber<numberOfChains; chainNumber++) {
                startStates[chainNumber]=0; // initial value
            }
            actualStates = startStates;
            MESSAGE_SINGLE(VERBOSE, logger, "MarkovBase(C=" <<_numberOfChains<< ") called");
        }

        MarkovBase(int nos,
               int noc,
               std::vector<T> states,
               TransitionMatrixType matrix,
               std::vector<int> sStates) :
            numberOfStates(nos),
            numberOfChains(noc),
            vectorOfStates(states),
            transitionsMatrix(matrix),
            startStates(sStates),
            actualStates(std::vector<int>(numberOfChains)),
            nextStates(std::vector<int>(numberOfChains)),
            nextTransitionTime(std::vector<double>(numberOfChains,0.0)),
            logger(std::string("Mrkv"), std::string("MarkovModel"))
        {
            actualStates = startStates;
            MESSAGE_SINGLE(VERBOSE,logger, "MarkovBase(C=" << noc << ",...) called");
        }

        virtual
        ~MarkovBase()
        {
            MESSAGE_SINGLE(VERBOSE, logger, "~MarkovBase() called");
        }

        void
        setNumberOfStates(int _numberOfStates)
        {
            numberOfStates = _numberOfStates;
            prepareTransitionMatrixAndVectorOfStates();
        }

        const std::vector<T>&
        getStates() const
        {
            assure(numberOfStates > 0, "numberOfStates uninitialized");
            return vectorOfStates;
        }

        int
        getActualStateIndex(int actualchain) const
        {
            return actualStates[actualchain];
        }

        double
        getStateProbability(int stateIndex) const
        {
            assure(!stateProbabilities.empty(),"stateProbabilities is empty");
            assure(stateProbabilities[0]>=0.0, "calculateStateProbabilities() has not been called before");
            return stateProbabilities[stateIndex];
        }

        const std::vector<double>& getStateProbabilities() const
        {
            return stateProbabilities;
        }


        const T*
        getStateContent(int index) const
        {
            assure(!vectorOfStates.empty(),"vectorOfStates is empty");
            return &(vectorOfStates[index]);
        }
        void
        setStartStates(std::vector<int> states)
        {
            startStates = states;
        }


        void
        setTransitionMatrixElement(int row, int col, double value)
        {
            assure((row >= 0) && (row < numberOfStates), "wrong dimension");
            assure((col >= 0) && (col < numberOfStates), "wrong dimension");
            transitionsMatrix(row, col) = value;
        }

        double
        getTransitionMatrixElement(int row, int col) const
        {
            assure((row >= 0) && (row < numberOfStates), "wrong dimension");
            assure((col >= 0) && (col < numberOfStates), "wrong dimension");
            return transitionsMatrix(row, col);
        }

        // wish: double&    operator[](int row, int col)

        void
        setTransitionMatrix(const TransitionMatrixType& matrix)
        {
            transitionsMatrix = matrix; // copy
        }

        int
        readNumberOfStates (std::istream& in)
        {
            std::string line;
            int nos = -1;
            while (in.good() && nos < 0) {
                std::getline(in, line);
                int comment_pos = line.find_first_not_of(" \t");
                if (line[comment_pos] != '#') {
                    std::string ident;
                    std::size_t pos_eq = line.find("=", 0);
                    if (pos_eq != std::string::npos) {
                        line.replace(pos_eq, 1, " ");
                        std::istringstream instream(line);
                        instream >> ident;
                        instream >> nos;
                        numberOfStates = nos;
                    }
                }
            }
            prepareTransitionMatrixAndVectorOfStates();
            return nos;
        }

        void
        readTransitionsFromFile(std::istream& in)
        {
            std::string line;
            assure((numberOfStates > 0), "numberOfStates in not defined");
            int row = 0;
            while (in.good() && row < numberOfStates) {
                std::getline(in, line);
                int comment_pos = line.find_first_not_of(" \t");
                if (line[comment_pos] != '#') {
                    std::istringstream instream(line);
                    double value;
                    for (int col = 0; col < numberOfStates; col++) {
                        instream >> value;
                        transitionsMatrix(row, col) = value;
                    }
                    row++;
                }
            }
            MESSAGE_BEGIN(VERBOSE, MarkovBase<T>::logger, m, "transitionMatrix=\n");
            m << transitionsMatrix;
            MESSAGE_END();
        }

    protected:
        virtual void
        calculateStateProbabilities() // = 0 problematic because of MarkovBaseTest
        {
            assure(0, "cannot calculateStateProbabilities in MarkovBase");
        }

        int numberOfStates;

        int numberOfChains;

        std::vector<T> vectorOfStates;

        TransitionMatrixType transitionsMatrix;

        std::vector<int> startStates;

        std::vector<int> actualStates;

        std::vector<int> nextStates;

        std::vector<double> nextTransitionTime;

        std::vector<double> stateProbabilities;

        wns::logger::Logger logger;

    private:
        friend class MarkovBaseTest;

        void
        prepareTransitionMatrixAndVectorOfStates()
        {
            assure(numberOfStates > 0, "numberOfStates uninitialized");
            transitionsMatrix = TransitionMatrixType(numberOfStates, numberOfStates);
            vectorOfStates = std::vector<T>(numberOfStates);
            stateProbabilities = std::vector<double>(numberOfStates,-1.0);
        }

    };//MarkovBase

} // markovchain
} // wns

#endif //WNS_MARKOVCHAIN_MARKOVBASE_HPP

---