NumericalStream.h

Go to the documentation of this file.

/*
 * Copyright (C) 2012 by
 *   MetraLabs GmbH (MLAB), GERMANY
 * and
 *   Neuroinformatics and Cognitive Robotics Labs (NICR) at TU Ilmenau, GERMANY
 * All rights reserved.
 *
 * Contact: info@mira-project.org
 *
 * Commercial Usage:
 *   Licensees holding valid commercial licenses may use this file in
 *   accordance with the commercial license agreement provided with the
 *   software or, alternatively, in accordance with the terms contained in
 *   a written agreement between you and MLAB or NICR.
 *
 * GNU General Public License Usage:
 *   Alternatively, this file may be used under the terms of the GNU
 *   General Public License version 3.0 as published by the Free Software
 *   Foundation and appearing in the file LICENSE.GPL3 included in the
 *   packaging of this file. Please review the following information to
 *   ensure the GNU General Public License version 3.0 requirements will be
 *   met: http://www.gnu.org/copyleft/gpl.html.
 *   Alternatively you may (at your option) use any later version of the GNU
 *   General Public License if such license has been publicly approved by
 *   MLAB and NICR (or its successors, if any).
 *
 * IN NO EVENT SHALL "MLAB" OR "NICR" BE LIABLE TO ANY PARTY FOR DIRECT,
 * INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF
 * THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF "MLAB" OR
 * "NICR" HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * "MLAB" AND "NICR" SPECIFICALLY DISCLAIM ANY WARRANTIES, INCLUDING,
 * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
 * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
 * ON AN "AS IS" BASIS, AND "MLAB" AND "NICR" HAVE NO OBLIGATION TO
 * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS OR MODIFICATIONS.
 */

#ifndef _MIRA_NUMERICAL_STREAM_H_
#define _MIRA_NUMERICAL_STREAM_H_

#include <iostream>

#include <math/Math.h>

namespace mira {


class NumericalOstream
{
public:
    NumericalOstream(std::ostream& s) : out(s) {}

    template <typename T>
    NumericalOstream& operator<< (const T& val) {
        out << val;
        return *this;
    }

    // for manipulators like (endl, etc)
    NumericalOstream& operator<<(std::ostream&(*pf)(std::ostream&)) {
        out << pf;
        return *this;
    }

    // specializations for all 3 floating point types
    NumericalOstream& operator<< (float val) {
        fpOutput(val);
        return *this;
    }

    NumericalOstream& operator<< (double val) {
        fpOutput(val);
        return *this;
    }

    NumericalOstream& operator<< (long double val) {
        fpOutput(val);
        return *this;
    }

public:

    std::ostream& out;

private:

    // handles special cases and writes "nan", "inf", etc.
    template <typename T>
    inline void fpOutput(const T& value)
    {
        if(boost::math::isnan(value))
            out << "nan"; // hard coded constants here, since parser is hard coded, too.
        else if(boost::math::isinf(value)) {
            if(value>0)
                out << "inf";
            else
                out << "-inf";
        }
        else
            out << value;
    }
};


class NumericalIstream
{
public:
    NumericalIstream(std::istream& s) : in(s) {}

    template <typename T>
    NumericalIstream& operator>> (T& val)   {
        in >> val;
        return *this;
    }

    // for manipulators
    NumericalIstream& operator>>(std::istream&(*pf)(std::istream&)) {
        in >> pf;
        return *this;
    }

    // specializations for all 3 floating point types
    NumericalIstream& operator>> (float& val) {
        fpInput(val);
        return *this;
    }

    NumericalIstream& operator>> (double& val) {
        fpInput(val);
        return *this;
    }

    NumericalIstream& operator>> (long double& val) {
        fpInput(val);
        return *this;
    }

public:

    std::istream& in;

private:

    // handles special cases and parses "nan", "inf", etc.
    template <typename T>
    inline void fpInput(T& value)
    {

        // read the potential sign and put that character back
        // we need it only to detect the -inf below.
        char sign;
        in >> sign;
        in.putback(sign);

        std::streamoff p0 = in.tellg();

        // try to read the value first
        in >> value;

        if(!in.fail())
            return; // everything was fine

        // if we reach here, we have no number, try to parse nan, inf, etc. instead

        in.clear(); // reset error state of stream

        // if the - sign was not read by the above >> value operator, then eat it now
        if(sign=='-' && in.tellg()==p0) {
            in.read(&sign,1);
            assert(sign=='-');
        }

        // read the next 3 chars that may contain nan, inf, etc.
        char buf[3] = {0,0,0};
        in.read(buf,3);
        if(!in.fail()) {
            // read nan
            if(buf[0]=='n' && buf[1]=='a' && buf[2]=='n') {
                value = std::numeric_limits<T>::quiet_NaN();
                return;
            }

            // read inf
            if(buf[0]=='i' && buf[1]=='n' && buf[2]=='f') {
                if(sign=='-')
                    value = -std::numeric_limits<T>::infinity();
                else
                    value = std::numeric_limits<T>::infinity();
                return;
            }
        }

        // if we reach here we have a parse error
        in.clear();

        // putback all chars that we have read
        while(((std::streamoff)in.tellg()) > p0)
            in.unget();

        // and go into fail mode
        in.setstate(std::ios::badbit);
    }
};



}

#endif