p1788 0.1.0

data/ext/libieeep1788_copy/p1788/flavor/infsup/setbased/mpfr_bin_ieee754_flavor_set_op_impl.hpp

@@ -0,0 +1,216 @@
+//
+//                              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_FLAVOR_INFSUP_SETBASED_MPFR_BIN_IEEE754_FLAVOR_SET_OP_IMPL_HPP
+#define LIBIEEEP1788_P1788_FLAVOR_INFSUP_SETBASED_MPFR_BIN_IEEE754_FLAVOR_SET_OP_IMPL_HPP
+
+
+namespace p1788
+{
+
+namespace flavor
+{
+
+namespace infsup
+{
+
+namespace setbased
+{
+
+// intersection ( bare interval )
+template<typename T>
+typename mpfr_bin_ieee754_flavor<T>::representation
+mpfr_bin_ieee754_flavor<T>::intersection(mpfr_bin_ieee754_flavor<T>::representation const& x,
+                                      mpfr_bin_ieee754_flavor<T>::representation const& y)
+{
+    if (!is_valid(x) || !is_valid(y))
+        return empty();
+
+    if (disjoint(x, y))
+        return empty();
+    else
+        return representation(std::max(x.first, y.first),
+                              std::min(x.second, y.second));
+}
+
+// intersection ( bare interval ) mixed type
+template<typename T>
+template<typename T1, typename T2>
+typename mpfr_bin_ieee754_flavor<T>::representation
+mpfr_bin_ieee754_flavor<T>::intersection(mpfr_bin_ieee754_flavor<T>::representation_type<T1> const& x,
+                                      mpfr_bin_ieee754_flavor<T>::representation_type<T2> const& y)
+{
+    static_assert(std::numeric_limits<T1>::is_iec559, "Only IEEE 754 binary compliant types are supported!");
+    static_assert(std::numeric_limits<T2>::is_iec559, "Only IEEE 754 binary compliant types are supported!");
+
+    if (!mpfr_bin_ieee754_flavor<T1>::is_valid(x) || !mpfr_bin_ieee754_flavor<T2>::is_valid(y))
+        return empty();
+
+    // determine max. precision
+    typedef typename p1788::util::max_precision_type<T,T1,T2>::type T_MAX;
+
+    // 1.) convert inputs to max precision; 2.) compute result in max precision; 3.) convert result to desired precision
+    // Error free for floating point inf-sup intervals due to  outward rounding
+    return convert_hull(
+               mpfr_bin_ieee754_flavor<T_MAX>::intersection(
+                   mpfr_bin_ieee754_flavor<T_MAX>::convert_hull(x),
+                   mpfr_bin_ieee754_flavor<T_MAX>::convert_hull(y)
+               )
+           );
+}
+
+// intersection ( decorated interval )
+template<typename T>
+typename mpfr_bin_ieee754_flavor<T>::representation_dec
+mpfr_bin_ieee754_flavor<T>::intersection(mpfr_bin_ieee754_flavor<T>::representation_dec const& x,
+                                      mpfr_bin_ieee754_flavor<T>::representation_dec const& y)
+{
+    if (!is_valid(x) || !is_valid(y) || is_nai(x) || is_nai(y))
+        return nai();
+
+    return representation_dec(intersection(x.first, y.first), p1788::decoration::decoration::trv);
+}
+
+// intersection ( decorated interval ) mixed type
+template<typename T>
+template<typename T1, typename T2>
+typename mpfr_bin_ieee754_flavor<T>::representation_dec
+mpfr_bin_ieee754_flavor<T>::intersection(mpfr_bin_ieee754_flavor<T>::representation_dec_type<T1> const& x,
+                                      mpfr_bin_ieee754_flavor<T>::representation_dec_type<T2> const& y)
+{
+    static_assert(std::numeric_limits<T1>::is_iec559, "Only IEEE 754 binary compliant types are supported!");
+    static_assert(std::numeric_limits<T2>::is_iec559, "Only IEEE 754 binary compliant types are supported!");
+
+    if (!mpfr_bin_ieee754_flavor<T1>::is_valid(x) || !mpfr_bin_ieee754_flavor<T2>::is_valid(y)
+        || mpfr_bin_ieee754_flavor<T1>::is_nai(x) || mpfr_bin_ieee754_flavor<T2>::is_nai(y))
+        return nai();
+
+    // determine max. precision
+    typedef typename p1788::util::max_precision_type<T,T1,T2>::type T_MAX;
+
+    // 1.) convert inputs to max precision; 2.) compute result in max precision; 3.) convert result to desired precision
+    // Error free for floating point inf-sup intervals due to  outward rounding
+    return convert_hull(
+               mpfr_bin_ieee754_flavor<T_MAX>::intersection(
+                   mpfr_bin_ieee754_flavor<T_MAX>::convert_hull(x),
+                   mpfr_bin_ieee754_flavor<T_MAX>::convert_hull(y)
+               )
+           );
+}
+
+// convex_hull ( bare interval )
+template<typename T>
+typename mpfr_bin_ieee754_flavor<T>::representation
+mpfr_bin_ieee754_flavor<T>::convex_hull(mpfr_bin_ieee754_flavor<T>::representation const& x,
+                                 mpfr_bin_ieee754_flavor<T>::representation const& y)
+{
+    if (!is_valid(x) || !is_valid(y))
+        return empty();
+
+    if (is_empty(x))
+        return y;
+    else if (is_empty(y))
+        return x;
+    else
+        return representation(std::min(x.first, y.first),
+                              std::max(x.second, y.second));
+}
+
+// convex_hull ( bare interval ) mixed type
+template<typename T>
+template<typename T1, typename T2>
+typename mpfr_bin_ieee754_flavor<T>::representation
+mpfr_bin_ieee754_flavor<T>::convex_hull(mpfr_bin_ieee754_flavor<T>::representation_type<T1> const& x,
+                                 mpfr_bin_ieee754_flavor<T>::representation_type<T2> const& y)
+{
+    static_assert(std::numeric_limits<T1>::is_iec559, "Only IEEE 754 binary compliant types are supported!");
+    static_assert(std::numeric_limits<T2>::is_iec559, "Only IEEE 754 binary compliant types are supported!");
+
+    if (!mpfr_bin_ieee754_flavor<T1>::is_valid(x) || !mpfr_bin_ieee754_flavor<T2>::is_valid(y))
+        return empty();
+
+    // determine max. precision
+    typedef typename p1788::util::max_precision_type<T,T1,T2>::type T_MAX;
+
+    // 1.) convert inputs to max precision; 2.) compute result in max precision; 3.) convert result to desired precision
+    // Error free for floating point inf-sup intervals due to  outward rounding
+    return convert_hull(
+               mpfr_bin_ieee754_flavor<T_MAX>::convex_hull(
+                   mpfr_bin_ieee754_flavor<T_MAX>::convert_hull(x),
+                   mpfr_bin_ieee754_flavor<T_MAX>::convert_hull(y)
+               )
+           );
+}
+
+// convex_hull ( decorated interval )
+template<typename T>
+typename mpfr_bin_ieee754_flavor<T>::representation_dec
+mpfr_bin_ieee754_flavor<T>::convex_hull(mpfr_bin_ieee754_flavor<T>::representation_dec const& x,
+                                 mpfr_bin_ieee754_flavor<T>::representation_dec const& y)
+{
+    if (!is_valid(x) || !is_valid(y) || is_nai(x) || is_nai(y))
+        return nai();
+
+    return representation_dec(convex_hull(x.first, y.first), p1788::decoration::decoration::trv);
+}
+
+// convex_hull ( decorated interval ) mixed type
+template<typename T>
+template<typename T1, typename T2>
+typename mpfr_bin_ieee754_flavor<T>::representation_dec
+mpfr_bin_ieee754_flavor<T>::convex_hull(mpfr_bin_ieee754_flavor<T>::representation_dec_type<T1> const& x,
+                                 mpfr_bin_ieee754_flavor<T>::representation_dec_type<T2> const& y)
+{
+    static_assert(std::numeric_limits<T1>::is_iec559, "Only IEEE 754 binary compliant types are supported!");
+    static_assert(std::numeric_limits<T2>::is_iec559, "Only IEEE 754 binary compliant types are supported!");
+
+    if (!mpfr_bin_ieee754_flavor<T1>::is_valid(x) || !mpfr_bin_ieee754_flavor<T2>::is_valid(y)
+        || mpfr_bin_ieee754_flavor<T1>::is_nai(x) || mpfr_bin_ieee754_flavor<T2>::is_nai(y))
+        return nai();
+
+    // determine max. precision
+    typedef typename p1788::util::max_precision_type<T,T1,T2>::type T_MAX;
+
+    // 1.) convert inputs to max precision; 2.) compute result in max precision; 3.) convert result to desired precision
+    // Error free for floating point inf-sup intervals due to  outward rounding
+    return convert_hull(
+               mpfr_bin_ieee754_flavor<T_MAX>::convex_hull(
+                   mpfr_bin_ieee754_flavor<T_MAX>::convert_hull(x),
+                   mpfr_bin_ieee754_flavor<T_MAX>::convert_hull(y)
+               )
+           );
+}
+
+
+} // namespace setbased
+
+} // namespace infsup
+
+} // namespace flavor
+
+} // namespace p1788
+
+
+#endif // LIBIEEEP1788_P1788_FLAVOR_INFSUP_SETBASED_MPFR_BIN_IEEE754_FLAVOR_SET_OP_IMPL_HPP

data/ext/libieeep1788_copy/p1788/flavor/infsup/setbased/mpfr_bin_ieee754_flavor_setup_func_impl.hpp

@@ -0,0 +1,68 @@
+//
+//                              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_FLAVOR_INFSUP_SETBASED_MPFR_BIN_IEEE754_FLAVOR_SETUP_FUNC_IMPL_HPP
+#define LIBIEEEP1788_P1788_FLAVOR_INFSUP_SETBASED_MPFR_BIN_IEEE754_FLAVOR_SETUP_FUNC_IMPL_HPP
+
+
+namespace p1788
+{
+
+namespace flavor
+{
+
+namespace infsup
+{
+
+namespace setbased
+{
+
+
+template<typename T>
+void
+mpfr_bin_ieee754_flavor<T>::setup()
+{
+    // nothing to do
+}
+
+template<typename T>
+void
+mpfr_bin_ieee754_flavor<T>::teardown()
+{
+    // frees the mpfr cache
+    mpfr_var::free_cache();
+}
+
+
+} // namespace setbased
+
+} // namespace infsup
+
+} // namespace flavor
+
+} // namespace p1788
+
+
+#endif // LIBIEEEP1788_P1788_FLAVOR_INFSUP_SETBASED_MPFR_BIN_IEEE754_FLAVOR_SETUP_FUNC_IMPL_HPP

data/ext/libieeep1788_copy/p1788/flavor/infsup/setbased/mpfr_bin_ieee754_flavor_util_func_impl.hpp

@@ -0,0 +1,135 @@
+//
+//                              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_FLAVOR_INFSUP_SETBASED_MPFR_BIN_IEEE754_FLAVOR_UTIL_FUNC_IMPL_HPP
+#define LIBIEEEP1788_P1788_FLAVOR_INFSUP_SETBASED_MPFR_BIN_IEEE754_FLAVOR_UTIL_FUNC_IMPL_HPP
+
+namespace p1788
+{
+
+namespace flavor
+{
+
+namespace infsup
+{
+
+namespace setbased
+{
+
+// convert T_ to T with rounding to -oo
+template<typename T>
+template<typename T_>
+T mpfr_bin_ieee754_flavor<T>::convert_rndd(T_ x)
+{
+    static_assert(std::numeric_limits<T_>::is_iec559, "Only IEEE 754 binary compliant types are supported!");
+
+    mpfr_var::setup();
+
+    mpfr_var xx(x, MPFR_RNDD);
+
+    T res = xx.template get<T>(MPFR_RNDD);
+
+    return res == 0.0 ? -0.0 : res;     // maps +-0.0 to -0.0
+}
+
+// convert T_ to T with rounding to nearest
+template<typename T>
+template<typename T_>
+T mpfr_bin_ieee754_flavor<T>::convert_rndn(T_ x)
+{
+    static_assert(std::numeric_limits<T_>::is_iec559, "Only IEEE 754 binary compliant types are supported!");
+
+    mpfr_var::setup();
+
+    mpfr_var xx(x, MPFR_RNDN);
+
+    T res = xx.template get<T>(MPFR_RNDN);
+
+    return res == 0.0 ? +0.0 : res;     // maps +-0.0 to +0.0
+}
+
+// convert T_ to T with rounding to +oo
+template<typename T>
+template<typename T_>
+T mpfr_bin_ieee754_flavor<T>::convert_rndu(T_ x)
+{
+    static_assert(std::numeric_limits<T_>::is_iec559, "Only IEEE 754 binary compliant types are supported!");
+
+    mpfr_var::setup();
+
+    mpfr_var xx(x, MPFR_RNDU);
+
+    T res = xx.template get<T>(MPFR_RNDU);
+
+    return res == 0.0 ? +0.0 : res;     // maps +-0.0 to +0.0
+}
+
+
+// convert bare interval with bounds T_ to bare interval with bounds T with outward rounding
+template<typename T>
+template<typename T_>
+typename mpfr_bin_ieee754_flavor<T>::representation
+mpfr_bin_ieee754_flavor<T>::convert_hull(representation_type<T_> const& x)
+{
+    static_assert(std::numeric_limits<T_>::is_iec559, "Only IEEE 754 binary compliant types are supported!");
+
+    return representation(convert_rndd(x.first), convert_rndu(x.second));
+}
+
+// convert decorated interval with bounds T_ to decorated interval with bounds T with outward rounding
+template<typename T>
+template<typename T_>
+typename mpfr_bin_ieee754_flavor<T>::representation_dec
+mpfr_bin_ieee754_flavor<T>::convert_hull(representation_dec_type<T_> const& x)
+{
+    static_assert(std::numeric_limits<T_>::is_iec559, "Only IEEE 754 binary compliant types are supported!");
+
+    if (mpfr_bin_ieee754_flavor<T_>::is_nai(x))
+        return nai();
+
+    representation bare(convert_rndd(x.first.first), convert_rndu(x.first.second));
+
+    if (x.second == p1788::decoration::decoration::com
+            && (bare.first == -std::numeric_limits<T>::infinity() || bare.second == std::numeric_limits<T>::infinity()))
+    {
+        return representation_dec(bare, p1788::decoration::decoration::dac);
+    }
+    else
+    {
+        return representation_dec(bare, x.second);
+    }
+}
+
+
+} // namespace setbased
+
+} // namespace infsup
+
+} // namespace flavor
+
+} // namespace p1788
+
+
+#endif // LIBIEEEP1788_P1788_FLAVOR_INFSUP_SETBASED_MPFR_BIN_IEEE754_FLAVOR_UTIL_FUNC_IMPL_HPP

data/ext/libieeep1788_copy/p1788/flavor/infsup/setbased/mpfr_bin_ieee754_flavor_validation_func_impl.hpp

@@ -0,0 +1,93 @@
+//
+//                              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_FLAVOR_INFSUP_SETBASED_MPFR_BIN_IEEE754_FLAVOR_VALIDATION_FUNC_IMPL_HPP
+#define LIBIEEEP1788_P1788_FLAVOR_INFSUP_SETBASED_MPFR_BIN_IEEE754_FLAVOR_VALIDATION_FUNC_IMPL_HPP
+
+namespace p1788
+{
+
+namespace flavor
+{
+
+namespace infsup
+{
+
+namespace setbased
+{
+
+
+// Check if x is a valid bare interval representation
+template<typename T>
+bool mpfr_bin_ieee754_flavor<T>::is_valid(representation const& x)
+{
+    if ((std::isnan(x.first) && std::isnan(x.second))
+            || (x.first <= x.second
+                &&  x.first != std::numeric_limits<T>::infinity()
+                && x.second != -std::numeric_limits<T>::infinity()))
+    {
+        return true;
+    }
+
+    // invalid: signal invalid operand
+    return !p1788::exception::signal_invalid_operand();
+}
+
+// Check if x is a valid decorated interval representation
+template<typename T>
+bool mpfr_bin_ieee754_flavor<T>::is_valid(representation_dec const& x)
+{
+    if ((std::isnan(x.first.first) && std::isnan(x.first.second)
+            && (x.second == p1788::decoration::decoration::ill
+                || x.second == p1788::decoration::decoration::trv))
+            || (x.second != p1788::decoration::decoration::ill
+                && (x.first.first <= x.first.second
+                    &&  x.first.first != std::numeric_limits<T>::infinity()
+                    && x.first.second != -std::numeric_limits<T>::infinity()
+                    && (x.second != p1788::decoration::decoration::com
+                        || (x.first.first != -std::numeric_limits<T>::infinity()
+                            && x.first.second != std::numeric_limits<T>::infinity()))
+                   )
+               )
+       )
+    {
+        return true;
+    }
+
+    // invalid: signal invalid operand
+    return !p1788::exception::signal_invalid_operand();
+}
+
+
+} // namespace setbased
+
+} // namespace infsup
+
+} // namespace flavor
+
+} // namespace p1788
+
+
+#endif // LIBIEEEP1788_P1788_FLAVOR_INFSUP_SETBASED_MPFR_BIN_IEEE754_FLAVOR_VALIDATION_FUNC_IMPL_HPP