p1788 0.1.0

data/ext/libieeep1788_copy/p1788/util/mixed_type_traits.hpp

@@ -0,0 +1,140 @@
+//   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_UTIL_MIXED_TYPE_TRAITS_HPP
+#define LIBIEEEP1788_P1788_UTIL_MIXED_TYPE_TRAITS_HPP
+
+#include <type_traits>
+
+#include "p1788/infsup/forward_declaration.hpp"
+
+namespace p1788
+{
+
+namespace util
+{
+
+
+
+// \brief Trait to determine the precision oder of the type T
+//
+// The order should be realized by an enum class for each group of coherent
+// types, e.g. IEEE 754 binary floating point {float, double, long double}.
+// Hence, only types of the same group are comparable.
+//
+// \param T type
+// \return field value contains the order
+//
+//
+template<typename T>
+class type_precision_order
+    : public std::integral_constant<int, 0>
+{
+    static_assert(!std::is_same<T,T>::value,
+                  "Type is not supported!");
+};
+
+
+
+
+template<typename... Types> class max_precision_type
+{
+    static_assert(sizeof...(Types) > 0,
+                  "max_precision_interval_type for an empty argument list!");
+};
+
+
+template<typename First, typename Second, typename... Tail>
+class max_precision_type<First, Second, Tail...>
+{
+public:
+    static_assert(std::is_same<typename type_precision_order<First>::value_type,
+                  typename type_precision_order<Second>::value_type>::value,
+                  "Different type groups!");
+
+    typedef typename max_precision_type<
+    typename std::conditional<
+    (type_precision_order<First>::value > type_precision_order<Second>::value),
+    First,
+    Second
+    >::type,
+    Tail...
+    >::type type;
+};
+
+template<typename Type>
+class max_precision_type<Type>
+{
+public:
+    typedef Type type;
+};
+
+
+
+
+
+
+//------------------------------------------------------------------------------
+//  IEEE 754 Binary specialization for type_precision_order
+//------------------------------------------------------------------------------
+
+enum class ieee754_binary_precision_order : unsigned int
+{
+    float_type,
+    double_type,
+    long_double_type
+};
+
+
+// Ignore the warning about non-virtual destructors
+// on GCC  push the last diagnostic state and disable -Weffc++
+//TODO support other compiler
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Weffc++"
+
+template<>
+class type_precision_order<float>
+    : public std::integral_constant<ieee754_binary_precision_order,
+      ieee754_binary_precision_order::float_type>
+{ };
+
+template<>
+class type_precision_order<double>
+    : public std::integral_constant<ieee754_binary_precision_order,
+      ieee754_binary_precision_order::double_type>
+{ };
+
+template<>
+class type_precision_order<long double>
+    : public std::integral_constant<ieee754_binary_precision_order,
+      ieee754_binary_precision_order::long_double_type>
+{ };
+
+// on GCC  enable the diagnostic state -Weffc++ again
+#pragma GCC diagnostic pop
+
+
+} // namespace util
+
+} // namespace p1788
+
+#endif // LIBIEEEP1788_P1788_UTIL_MIXED_TYPE_TRAITS_HPP

data/ext/libieeep1788_copy/p1788/util/mpfr_util.hpp

@@ -0,0 +1,77 @@
+//   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_UTIL_EFT_HPP
+#define LIBIEEEP1788_P1788_UTIL_EFT_HPP
+
+#include <utility>
+
+#include "p1788/util/mpfr_var.hpp"
+
+namespace p1788
+{
+
+namespace util
+{
+
+template<typename T>
+inline std::pair<T,T> two_sum(T const& a, T const& b)
+{
+    static_assert(std::numeric_limits<T>::is_iec559, "Only IEEE 754 binary compliant types are supported!");
+
+    // Typedef for the corresponding mpfr wrapper class representing the IEEE 754 binary floating point format of type T
+    typedef p1788::util::mpfr_var<
+    std::numeric_limits<T>::digits,
+        std::numeric_limits<T>::has_denorm != std::denorm_present ? std::numeric_limits<T>::min_exponent
+        : std::numeric_limits<T>::min_exponent - std::numeric_limits<T>::digits + 1,
+        std::numeric_limits<T>::max_exponent,
+        std::numeric_limits<T>::has_denorm == std::denorm_present
+        >   mpfr_var;
+
+    mpfr_var::setup();
+
+    mpfr_var a_(a, MPFR_RNDN);
+    mpfr_var b_(b, MPFR_RNDN);
+
+    mpfr_var s;
+    mpfr_var a_delta;
+    mpfr_var b_delta;
+
+    s.subnormalize(mpfr_add(s(), a_(), b_(), MPFR_RNDN), MPFR_RNDN);
+    a_delta.subnormalize(mpfr_sub(a_delta(), s(), b_(), MPFR_RNDN), MPFR_RNDN);
+    b_delta.subnormalize(mpfr_sub(b_delta(), s(), a_delta(), MPFR_RNDN), MPFR_RNDN);
+
+    a_delta.subnormalize(mpfr_sub(a_delta(), a_(), a_delta(), MPFR_RNDN), MPFR_RNDN);
+    b_delta.subnormalize(mpfr_sub(b_delta(), b_(), b_delta(), MPFR_RNDN), MPFR_RNDN);
+
+    a_delta.subnormalize(mpfr_add(a_delta(), a_delta(), b_delta(), MPFR_RNDN), MPFR_RNDN);
+
+    return std::pair<T,T>(s.template get<T>(MPFR_RNDN), a_delta.template get<T>(MPFR_RNDN));
+}
+
+
+
+} // namespace util
+
+} // namespace p1788
+
+#endif // LIBIEEEP1788_P1788_UTIL_EFT_HPP

data/ext/libieeep1788_copy/p1788/util/mpfr_var.hpp

@@ -0,0 +1,119 @@
+//
+//                              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_UTIL_MPFR_VAR_HPP
+#define LIBIEEEP1788_P1788_UTIL_MPFR_VAR_HPP
+
+#define MPFR_USE_INTMAX_T
+
+#include <mpfr.h>
+#include <string>
+
+#include "p1788/io/io_manip.hpp"
+
+//------------------------------------------------------------------------------
+// Generic wrapper for MPFR mpfr_t types
+//------------------------------------------------------------------------------
+
+namespace p1788
+{
+
+namespace util
+{
+
+// Wrapper class for mpfr_t
+template<mpfr_prec_t PREC_, mpfr_exp_t EMIN_, mpfr_exp_t EMAX_, bool SUBNORMALIZE_>
+class mpfr_var
+{
+    // Check range
+    static_assert(PREC_ > 0, "PREC_ is not greater then 0!");
+    static_assert(EMIN_ < 0, "EMIN_ is not less than 0!");
+    static_assert(EMAX_ > 0, "EMAX_ is not less than 0!");
+
+public:
+
+    static const mpfr_prec_t PREC = PREC_;
+    static const mpfr_exp_t EMIN = EMIN_;
+    static const mpfr_exp_t EMAX = EMAX_;
+    static const bool SUBNORMALIZE = SUBNORMALIZE_;
+
+    // initialze mpfr system
+    static void setup();
+
+    // clears mpfr cache
+    static void free_cache();
+
+    // Constructors - initialize mpfr_t var with corresponding value  using the rounding mode rnd
+    mpfr_var();
+
+    mpfr_var(unsigned long int op, mpfr_rnd_t rnd);
+    mpfr_var(long int op, mpfr_rnd_t rnd);
+    mpfr_var(float op, mpfr_rnd_t rnd);
+    mpfr_var(double op, mpfr_rnd_t rnd);
+    mpfr_var(long double op, mpfr_rnd_t rnd);
+
+    // Destructor
+    ~mpfr_var();
+
+    // writes corresponding value to mpfr_t var using the rounding mode rnd
+    void set(unsigned long int op, mpfr_rnd_t rnd);
+    void set(long int op, mpfr_rnd_t rnd);
+    void set(float op, mpfr_rnd_t rnd);
+    void set(double op, mpfr_rnd_t rnd);
+    void set(long double op, mpfr_rnd_t rnd);
+
+    // Generic getter - it is possible to round the value to a preferred type using the rounding mode rnd
+    template<typename T>
+    T get(mpfr_rnd_t rnd);
+
+    // Returns a string representation
+    // It is possible to specify the outputformat
+    std::string get_str(mpfr_rnd_t rnd,
+                        p1788::io::number_representation_flags rep,
+                        size_t width,
+                        size_t precision,
+                        p1788::io::text_representation_flags text_rep);
+
+    // Reference to the underlying mpfr_t
+    mpfr_t& operator() ();
+    mpfr_t const& operator() () const;
+
+    // subnormalization
+    int subnormalize(int t, mpfr_rnd_t rnd);
+
+private:
+    mpfr_t var_;
+
+};
+
+
+} // namespace util
+
+} // namespace p1788
+
+
+#include "p1788/util/mpfr_var_impl.hpp"
+
+#endif // LIBIEEEP1788_P1788_UTIL_MPFR_VAR_HPP