User Manual, Developers Guide and API Documentation

dlre.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. 16, 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_EVALUATION_STATISTICS_DLRE_HPP
#define WNS_EVALUATION_STATISTICS_DLRE_HPP

#include <WNS/evaluation/statistics/stateval.hpp>

#include <cstdlib>
#include <climits>
#include <cfloat>
#include <iomanip>

namespace wns { namespace evaluation { namespace statistics {
            class DLRE : public StatEval
            {
            public:

                 DLRE(std::vector<double> xValuesArr,
                      int level,
                      double error,
                      double preFirst,
                      std::string name,
                      std::string description,
                      bool forceRMinusAOk,
                      int maxNrv,
                      int skipInterval,
                      formatType format);

                DLRE(double xMin,
                     double xMax,
                     double intSize,
                     double error,
                     double preFirst,
                     std::string name,
                     std::string description,
                     bool forceRMinusAOk,
                     int maxNrv,
                     int skipInterval,
                     formatType format);

                DLRE(const wns::pyconfig::View& config);

                ~DLRE();

                class ResultLine
                {
                public:
                    ResultLine();

                    bool
                    operator != (const ResultLine& other) const;

                    double vf_;

                    double x_;

                    double relErr_;

                    double rho_;

                    double sigRho_;

                    int nx_;
                };

                virtual void
                reset();

                void
                setBase(double newBase);

                virtual void
                changeError(double newError);

                virtual double
                curXLev();

                virtual double
                p(double xt);

                virtual int
                minIndex() const;

                virtual int
                maxIndex() const;

                virtual void
                put(double value) = 0;

                virtual void
                getResultLine(const int index, ResultLine& line) const = 0;

                virtual void
                print(std::ostream& stream = std::cout) const = 0;

            protected:
                enum Phase {
                    initialize,
                    iterate,
                    finish} phase_;

                class Result
                {
                public:
                    Result();

                    bool operator != (const Result& other) const;

                    double x_;

                    int h_;

                    int sumh_;

                    int c_;
                };

                int
                getIndex(double value) const;

                void
                printAll(std::ostream& stream,
                         functionType functionType,
                         const double yMin) const;

                bool checkLargeSample(int index) const;

                enum ComparisonResult
                {
                    noIndex = -3,
                    greater = -2,
                    lower = -1
                };

                enum ReasonType
                {
                    ok,
                    minimum,
                    last
                };

                Result* results_;

                double relErrMax_;

                int maxNrv_;

                int wastedLeft_;

                int wastedRight_;

                int h_;

                int xOffset_;

                double xMin_;

                double xMax_;

                int indexMin_;

                int indexMax_;

                bool equiDist_;

                double intSize_;

                int curIndex_;

                double preRv_;

                int preIndex_;

                double base_;

                ReasonType reason_;

                int curLevelIndex_;

                int skipInterval_;

                bool forceRminusAOK_;

                static const int largeSampleNumTrials_;

                static const int largeSampleNumSortedValues_;

                static const int largeSampleNumTransitions_;

            private:
                void initNonEqui(int level,
                                 std::vector<double> xValuesArr,
                                 double preFirst);
                void initEqui(double xMin,
                              double xMax,
                              double intSize,
                              double preFirst);


                void printLevel(std::ostream& stream,
                                int level,
                                const std::string& errorString,
                                bool discretePointFlag,
                                functionType functionType) const;
            };
        } // statistics
    } // evaluation
} // wns

#endif  // WNS_EVALUATION_STATISTICS_DLRE_HPP

---