p1788 0.1.0

data/ext/libieeep1788_copy/p1788/decoration/decoration.hpp

@@ -0,0 +1,265 @@
+//
+//                              libieeep1788
+//
+//   An implementation of the preliminary IEEE P1788 standard for
+//   interval arithmetic
+//
+//
+//   Copyright 2013 - 2015
+//
+//   Marco Nehmeier (nehmeier@informatik.uni-wuerzburg.de)
+//   Department of Computer Science,
+//   University of Wuerzburg, Germany
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//       http://www.apache.org/licenses/LICENSE-2.0
+//
+//   Unless required by applicable law or agreed to in writing, software
+//   distributed under the License is distributed on an "AS IS" BASIS,
+//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//   See the License for the specific language governing permissions and
+//   limitations under the License.
+
+#ifndef LIBIEEEP1788_P1788_DECORATION_DECORATION_HPP
+#define LIBIEEEP1788_P1788_DECORATION_DECORATION_HPP
+
+#include <iostream>
+#include <algorithm>
+#include <cstdint>
+
+#include "p1788/io/io_manip.hpp"
+#include "p1788/util/io.hpp"
+#include "p1788/exception/exception.hpp"
+
+namespace p1788
+{
+
+namespace decoration
+{
+
+/// \brief Enum describing the 5 different interval decorations
+///
+/// The 5 different values are an ordered set with the following
+/// property
+///
+/// <c>com</c> > <c>dac</c> > <c>def</c> > <c>trv</c> > <c>ill</c>
+///
+/// and the common comparison operators (<c>==</c>, <c>!=</c>, <c><</c>, <c><=</c>, <c>></c>, <c>>=</c>)
+/// are supported.
+///
+/// \note To follow the interchange representations specified by IEEE P1788
+/// the decoration enum is based on an unsigned 8Bit integer using the
+/// the corresponding Bit patterns for the particular values.
+enum class decoration : uint8_t
+{
+    ill = 0x00,    ///< ill (00000000)
+    trv = 0x04,    ///< trivial (00000100)
+    def = 0x08,    ///< defined (00001000)
+    dac = 0x0C,   ///< defined and continuous (00001100)
+    com = 0x10    ///< common (00010000)
+};
+
+
+
+bool is_valid(decoration dec)
+{
+    switch(dec)
+    {
+    case decoration::ill:
+    case decoration::trv:
+    case decoration::def:
+    case decoration::dac:
+    case decoration::com:
+        return true;
+    }
+
+
+    // invalid: signal invalid operand
+    return !p1788::exception::signal_invalid_operand();
+}
+
+
+
+// -----------------------------------------------------------------------------
+// Input and output
+// -----------------------------------------------------------------------------
+
+
+/// \brief Operator for writing a decoration onto an output stream.
+///
+/// \param os Output stream
+/// \param dec Decoration to write onto the output stream \p os
+/// \return Output stream \p os to support operator chaining
+///
+/// \note The function pays attention to the output manipulators
+/// \link p1788::io::dec_alpha(std::basic_ostream<CharT, Traits>& os) dec_alpha \endlink ,
+/// and \link p1788::io::dec_numeric(std::basic_ostream<CharT, Traits>& os) dec_numeric \endlink
+/// as well as to
+/// \link p1788::io::lower_case(std::basic_ostream<CharT, Traits>& os) lower_case \endlink
+/// and \link p1788::io::upper_case(std::basic_ostream<CharT, Traits>& os) upper_case \endlink .
+template<typename CharT, typename Traits>
+std::basic_ostream<CharT, Traits>& operator<<(
+    std::basic_ostream<CharT, Traits>& os,
+    decoration dec)
+{
+    // numeric
+    if (os.iword(p1788::io::dec_manip_id) == p1788::io::dec_numeric_representation)
+    {
+        return os << static_cast<unsigned int>(dec);
+    }
+
+    // alphabetic
+    switch (dec)
+    {
+    case decoration::ill:
+        switch (os.iword(p1788::io::text_representation_manip_id))
+        {
+        case p1788::io::upper_case_text_representation:
+            return os << "ILL";
+        default:
+            return os << "ill";
+        }
+    case decoration::trv:
+        switch (os.iword(p1788::io::text_representation_manip_id))
+        {
+        case p1788::io::upper_case_text_representation:
+            return os << "TRV";
+        default:
+            return os << "trv";
+        }
+    case decoration::def:
+        switch (os.iword(p1788::io::text_representation_manip_id))
+        {
+        case p1788::io::upper_case_text_representation:
+            return os << "DEF";
+        default:
+            return os << "def";
+        }
+    case decoration::dac:
+        switch (os.iword(p1788::io::text_representation_manip_id))
+        {
+        case p1788::io::upper_case_text_representation:
+            return os << "DAC";
+        default:
+            return os << "dac";
+        }
+    case decoration::com:
+        switch (os.iword(p1788::io::text_representation_manip_id))
+        {
+        case p1788::io::upper_case_text_representation:
+            return os << "COM";
+        default:
+            return os << "com";
+        }
+    }
+
+    // Something went wrong ;-)
+    return os;
+}
+
+/// \brief Operator for reading a decoration from an input stream.
+///
+/// \param is Input stream
+/// \param dec Decoration read from the input stream \p is
+/// \return Input stream \p is to support operator chaining
+///
+/// \note The function pays attention to the standard manipulator <c>std::ios_base::skipws</c>.
+///
+/// \note If no valid textual or numeric representation could be read from the input stream \p is
+/// then \p dec is set to decoration::ill and the <c>failbit</c>
+/// of the stream is set.
+template<typename CharT, typename Traits>
+std::basic_istream<CharT, Traits>& operator>>(
+    std::basic_istream<CharT, Traits>& is,
+    decoration& dec )
+{
+    // remove whitespaces if necessary
+    if (is.flags() & std::ios_base::skipws)
+    {
+        p1788::util::remove_ws(is);
+    }
+
+    if (is)
+    {
+        // starts with digit
+        if (std::isdigit(is.peek()))
+        {
+            unsigned int n;
+            is >> n;
+
+            if (is)
+            {
+                switch (n)
+                {
+                case 0x00:  // ill
+                    dec = decoration::ill;
+                    return is;
+                case 0x04:  // trv
+                    dec = decoration::trv;
+                    return is;
+                case 0x08:  // def
+                    dec = decoration::def;
+                    return is;
+                case 0x0C:  // dac
+                    dec = decoration::dac;
+                    return is;
+                case 0x10:  // com
+                    dec = decoration::com;
+                    return is;
+                }
+            }
+        }
+        else    // alphabetic
+        {
+            std::string s;
+            s.resize(3);
+            is.read(&s[0], 3);
+
+            if (is)
+            {
+                p1788::util::ascii_to_lower(s);
+
+                if (s == "ill")
+                {
+                    dec = decoration::ill;
+                    return is;
+                }
+                else if (s == "trv")
+                {
+                    dec = decoration::trv;
+                    return is;
+                }
+                else if (s == "def")
+                {
+                    dec = decoration::def;
+                    return is;
+                }
+                else if (s == "dac")
+                {
+                    dec = decoration::dac;
+                    return is;
+                }
+                else if (s == "com")
+                {
+                    dec = decoration::com;
+                    return is;
+                }
+            }
+        }
+    }
+
+    // failed
+    is.setstate(std::ios_base::failbit);
+    return is;
+}
+
+
+} // namespace decoration
+
+} // namespace p1788
+
+
+#endif // LIBIEEEP1788_P1788_DECORATION_DECORATION_HPP

data/ext/libieeep1788_copy/p1788/exception/exception.hpp

@@ -0,0 +1,302 @@
+//
+//                              libieeep1788
+//
+//   An implementation of the preliminary IEEE P1788 standard for
+//   interval arithmetic
+//
+//
+//   Copyright 2013 - 2015
+//
+//   Marco Nehmeier (nehmeier@informatik.uni-wuerzburg.de)
+//   Department of Computer Science,
+//   University of Wuerzburg, Germany
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//       http://www.apache.org/licenses/LICENSE-2.0
+//
+//   Unless required by applicable law or agreed to in writing, software
+//   distributed under the License is distributed on an "AS IS" BASIS,
+//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//   See the License for the specific language governing permissions and
+//   limitations under the License.
+
+#ifndef LIBIEEEP1788_P1788_EXCEPTION_EXCEPTION_HPP
+#define LIBIEEEP1788_P1788_EXCEPTION_EXCEPTION_HPP
+
+#include <stdexcept>
+
+namespace p1788
+{
+
+namespace exception
+{
+
+//TODO Exception Handler!
+
+
+/// \brief Bit-patterns for the different kinds of exceptions
+///
+/// \note The bitwise operators <c>&</c>, <c>|</c>, <c>^</c>, <c>~</c>,
+/// <c>&=</c>, <c>|=</c>, <c>^=</c> are supported.
+enum exception_bits
+{
+    none_bit = 0,                           ///< No exception
+    undefined_operation_bit = 1,            ///< No level 1 value exists
+    possibly_undefined_operation_bit = 2,   ///< Not sure if a level 1 value exists
+    interval_part_of_nai_bit = 4,           ///< A NaI is converted into a bare interval
+    invalid_operand_bit = 8                 ///< Invalid input for an operation
+};
+
+
+// bitwise AND for exception_bits
+inline exception_bits operator& (exception_bits x, exception_bits y)
+{
+    return exception_bits(static_cast<int>(x) & static_cast<int>(y));
+}
+
+// bitwise OR for exception_bits
+inline exception_bits operator| (exception_bits x, exception_bits y)
+{
+    return exception_bits(static_cast<int>(x) | static_cast<int>(y));
+}
+
+// bitwise XOR for exception_bits
+inline exception_bits operator^ (exception_bits x, exception_bits y)
+{
+    return exception_bits(static_cast<int>(x) ^ static_cast<int>(y));
+}
+
+// bitwise NOT for exception_bits
+inline exception_bits operator~ (exception_bits x)
+{
+    return exception_bits(~static_cast<int>(x));
+}
+
+// bitwise AND assignment for exception_bits
+inline exception_bits& operator&= (exception_bits& x, exception_bits y)
+{
+    return x = x & y;
+}
+
+// bitwise OR assignment for exception_bits
+inline exception_bits& operator|= (exception_bits& x, exception_bits y)
+{
+    return x = x | y;
+}
+
+// bitwise NOT assignment for exception_bits
+inline exception_bits& operator^= (exception_bits& x, exception_bits y)
+{
+    return x = x ^ y;
+}
+
+
+/// \brief CWD specifying which exception type should be thrown.
+///
+/// \return The current cwd of the active thread.
+inline exception_bits& cwd()
+{
+    // Thread local cwd
+    static exception_bits exception_cwd_ = none_bit;
+
+    return exception_cwd_;
+}
+
+
+/// \brief Set the control word of the active thread specifying which exception type should be thrown.
+///
+/// \param new_state New control word
+/// \return New control word
+///
+inline exception_bits set_throw_exception_cwd(exception_bits new_state)
+{
+    return (cwd() = new_state);
+}
+
+/// \brief Control word of the active thread specifying which exception type should be thrown.
+///
+/// \return exception_bits Current control word
+inline exception_bits get_throw_exception_cwd()
+{
+    return cwd();
+}
+
+/// \brief Exception class specifying an undefined operation
+///
+class exception : public std::runtime_error
+{
+public:
+    exception(std::string s)
+        : std::runtime_error(s)
+    { }
+};
+
+
+/// \brief Exception class specifying an undefined operation
+///
+class undefined_operation_exception : public exception
+{
+public:
+    undefined_operation_exception()
+        : exception("Undefined operation exception!")
+    { }
+};
+
+/// \brief Exception class specifying a possibly undefined operation
+///
+class possibly_undefined_operation_exception : public exception
+{
+public:
+    possibly_undefined_operation_exception()
+        : exception("possibly undefined operation exception!")
+    { }
+};
+
+/// \brief Exception class specifying an interval part of NaI exception
+///
+class interval_part_of_nai_exception : public exception
+{
+public:
+    interval_part_of_nai_exception()
+        : exception("Interval part of NaI exception!")
+    { }
+};
+
+/// \brief Exception class specifying an invalid operand
+///
+class invalid_operand_exception : public exception
+{
+public:
+    invalid_operand_exception()
+        : exception("Invalid operand exception!")
+    { }
+};
+
+
+
+/// \brief The current exception state.
+///
+/// \return The current exception state of the active thread.
+inline exception_bits& state()
+{
+    // Thread local exception state
+    static exception_bits exception_state_ = none_bit;
+
+    return exception_state_;
+}
+
+/// \brief Clears the exception state.
+///
+/// \return The current exception state of the active thread (= <c>none_bit</c>).
+/// \note Thread local storage is used for the exception state.
+inline exception_bits clear()
+{
+    return state() = none_bit;
+}
+
+/// \brief Checks exception state for an undefined operation.
+/// \return true if the <c>undefined_operation_bit</c> is set.
+/// \note Thread local storage is used for the exception state.
+inline bool undefined_operation()
+{
+    return state() & undefined_operation_bit;
+}
+
+/// \brief Checks exception state for a possibly undefined operation.
+/// \return true if the <c>possibly_undefined_operation_bit</c> is set.
+/// \note Thread local storage is used for the exception state.
+inline bool possibly_undefined_operation()
+{
+    return state() & possibly_undefined_operation_bit;
+}
+
+/// \brief Checks exception state for an interval part of NaI exception.
+/// \return true if the <c>interval_part_of_nai_bit</c> is set.
+/// \note Thread local storage is used for the exception state.
+inline bool interval_part_of_nai()
+{
+    return state() & interval_part_of_nai_bit;
+}
+
+/// \brief Checks exception state for an invalid operation.
+/// \return true if the <c>interval_part_of_nai_bit</c> is set.
+/// \note Thread local storage is used for the exception state.
+inline bool invalid_operand()
+{
+    return state() & invalid_operand_bit;
+}
+
+/// \brief Adds the flag for an undefined operation to the exception state.
+///
+/// \return The current exception state of the active thread (= old exception state <c>| undefined_operation_bit</c>) if no exception is thrown.
+/// \exception undefined_operation_exception  Throws exception if the <c>undefined_operation_bit</c> is set for the <c>throw_exception_cwd</c>.
+/// \note Thread local storage is used for the exception state.
+inline exception_bits signal_undefined_operation()
+{
+    state() |= undefined_operation_bit;
+
+    // Throw exception if necessary
+    if (cwd() & undefined_operation_bit)
+        throw undefined_operation_exception();
+
+    return state();
+}
+
+/// \brief Adds the flag for a possibly undefined operation to the exception state.
+///
+/// \return The current exception state of the active thread (= old exception state <c>| possibly_undefined_operation_bit</c>) if no exception is thrown.
+/// \exception possibly_undefined_operation_exception  Throws exception if the <c>possibly_undefined_operation_bit</c> is set for the <c>throw_exception_cwd</c>.
+/// \note Thread local storage is used for the exception state.
+inline exception_bits signal_possibly_undefined_operation()
+{
+    state() |= possibly_undefined_operation_bit;
+
+    // Throw exception if necessary
+    if (cwd() & possibly_undefined_operation_bit)
+        throw possibly_undefined_operation_exception();
+
+    return state();
+}
+
+/// \brief Adds the flag for an interval part of NaI exception to the exception state.
+///
+/// \return The current exception state of the active thread (= old exception state <c>| interval_part_of_nai_bit</c>) if no exception is thrown.
+/// \exception interval_part_of_nai_exception  Throws exception if the <c>interval_part_of_nai_bit</c> is set for the <c>throw_exception_cwd</c>.
+/// \note Thread local storage is used for the exception state.
+inline exception_bits signal_interval_part_of_nai()
+{
+    state() |= interval_part_of_nai_bit;
+
+    // Throw exception if necessary
+    if (cwd() & interval_part_of_nai_bit)
+        throw interval_part_of_nai_exception();
+
+    return state();
+}
+
+/// \brief Adds the flag for an invalid operand to the exception state.
+///
+/// \return The current exception state of the active thread (= old exception state <c>| invalid_operand_bit</c>) if no exception is thrown.
+/// \exception invalid_operand_exception  Throws exception if the <c>invalid_operand_bit</c> is set for the <c>throw_exception_cwd</c>.
+/// \note Thread local storage is used for the exception state.
+inline exception_bits signal_invalid_operand()
+{
+    state() |= invalid_operand_bit;
+
+    // Throw exception if necessary
+    if (cwd() & invalid_operand_bit)
+        throw invalid_operand_exception();
+
+    return state();
+}
+
+
+} // namespace exception
+
+} // namespace p1788
+
+
+#endif // LIBIEEEP1788_P1788_EXCEPTION_EXCEPTION_HPP