User Manual, Developers Guide and API Documentation

NLinear.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 _NLINEAR_HPP
#define _NLINEAR_HPP

#include <cmath>
#include <list>
#include <WNS/Interpolation.hpp>

namespace wns
{
    template<typename T,
         InterpolationDefs::SizeType N,
         InterpolationDefs::SizeType M = N>
    class NLinear : public Interpolation<T, N>
    {
        typedef Interpolation<T, N> SuperType;
    public:
        typedef typename SuperType::CoordType CoordType;
        typedef typename SuperType::DiscreteContainer DiscreteContainer;

        typedef typename SuperType::InitType InitType;

        typedef const NLinear<T, N-1, M> HyperplaneType;

        typedef const HyperplaneType& ConstReference;

        typedef std::list<CoordType> CoordList;

        NLinear(const DiscreteContainer& discreteValues,
            const void *const universe = 0,
            CoordList *const coords = 0)
            : SuperType(discreteValues),
              coords((coords == 0) ? new CoordList() : coords),
              deleteCoords(coords == 0),
              //  what value this has actually doesn't matter
              hyperplane(discreteValues[0],
                     (universe == 0) ? &discreteValues : universe,
                     this->coords)      // because we use this ^
        {}

        virtual ~NLinear()
        {
            if (deleteCoords) delete coords;
        }

        virtual ConstReference operator[](const CoordType& coord) const
        {
            coords->push_back(coord);
            return hyperplane;
        }

    private:
        CoordList* const coords;

        const bool deleteCoords;

        HyperplaneType hyperplane;
    };

    template<typename T,
         InterpolationDefs::SizeType M>
    class NLinear<T, 1, M> : public Interpolation<T, 1>
    {
        typedef Interpolation<T, 1> SuperType;
    public:
        typedef typename SuperType::ValueType ValueType;
        typedef typename SuperType::CoordType CoordType;
        typedef typename SuperType::DiscreteContainer DiscreteContainer;
        typedef typename SuperType::InitType InitType;
        typedef typename DiscreteContainer::IndexType IndexType;

        typedef std::list<CoordType> CoordList;

        NLinear(const DiscreteContainer& discreteValues,
            const void *const universe = 0,
            CoordList *const coords = 0)
            : SuperType(discreteValues),
              universe((universe == 0) ? &discreteValues : universe),
              coords((coords == 0) ? new CoordList() : coords),
              deleteCoords(coords == 0)
        {}

        virtual ~NLinear()
        {
            if (deleteCoords) delete coords;
        }

        virtual ValueType operator[](const CoordType& coord) const
        {
            coords->push_back(coord);
            const ValueType v = this->interpolate(*coords);
            coords->clear();
            return v;
        }

    private:
        typedef typename Interpolation<T, M>::DiscreteContainer UniverseType;
        typedef std::list<IndexType> IndexList;

        const void *const universe;
        CoordList *const coords;
        const bool deleteCoords;

        ValueType interpolate(const CoordList& coords,
                      const IndexList& indices = IndexList()) const
        {
            if (coords.empty()) {
                // If coords is empty, there is nothing to interpolate.
                // So just return the values in the discreteContainer.
                return static_cast<const UniverseType *const>(universe)->at(indices.begin(), indices.end());
            }
            else {
                // calculate new indices
                const CoordType& x = coords.back();
                const IndexType x1 = (IndexType)(std::floor(x));
                const IndexType x2 = (IndexType)(std::ceil(x));
                // shorten coordlist
                CoordList c = CoordList(coords);
                c.pop_back();
                // construct new index lists
                IndexList i1 = IndexList(indices); i1.push_front(x1);
                IndexList i2 = IndexList(indices); i2.push_front(x2);
                // recursivly get values to interpolate
                const ValueType f1 = interpolate(c, i1);
                const ValueType f2 = interpolate(c, i2);
                // interpolate and return
                return f1 + (f2 - f1) * (x - x1);
            }
        }
    };

}

#endif // _NLINEAR_HPP

---