p1788 0.1.0

data/ext/libieeep1788_copy/p1788/infsup/base_interval_io_impl.hpp

@@ -0,0 +1,59 @@
+//
+//                              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_INFSUP_BASE_INTERVAL_IO_IMPL_HPP
+#define LIBIEEEP1788_P1788_INFSUP_BASE_INTERVAL_IO_IMPL_HPP
+
+namespace p1788
+{
+
+namespace infsup
+{
+
+
+template<typename T, template<typename> class Flavor, typename RepType, class ConcreteInterval, typename CharT, typename Traits>
+std::basic_ostream<CharT, Traits>& operator<<(
+    std::basic_ostream<CharT, Traits>& os,
+    base_interval<T, Flavor, RepType, ConcreteInterval> const& x)
+{
+    return Flavor<T>::operator_interval_to_text(os, x.rep_);
+}
+
+template<typename T, template<typename> class Flavor, typename RepType, class ConcreteInterval, typename CharT, typename Traits>
+std::basic_istream<CharT, Traits>& operator>>(
+    std::basic_istream<CharT, Traits>& is,
+    base_interval<T, Flavor, RepType, ConcreteInterval>& x)
+{
+    return Flavor<T>::operator_text_to_interval(is, x.rep_);
+}
+
+
+
+} // namespace infsup
+
+} // namespace p1788
+
+
+#endif // LIBIEEEP1788_P1788_INFSUP_BASE_INTERVAL_IO_IMPL_HPP

data/ext/libieeep1788_copy/p1788/infsup/base_interval_mul_rev_to_pair_func_impl.hpp

@@ -0,0 +1,88 @@
+//
+//                              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_INFSUP_BASE_INTERVAL_MUL_REV_TO_PAIR_FUNC_HPP
+#define LIBIEEEP1788_P1788_INFSUP_BASE_INTERVAL_MUL_REV_TO_PAIR_FUNC_HPP
+
+namespace p1788
+{
+
+namespace infsup
+{
+
+// cancel_plus
+
+// static
+template<typename T, template<typename> class Flavor, typename RepType, class ConcreteInterval>
+std::pair<ConcreteInterval, ConcreteInterval>
+base_interval<T,Flavor,RepType,ConcreteInterval>::mul_rev_to_pair(base_interval<T, Flavor, RepType, ConcreteInterval> const& b,
+        base_interval<T, Flavor, RepType, ConcreteInterval> const& c)
+{
+    auto tmp = Flavor<T>::mul_rev_to_pair(b.rep_, c.rep_);
+
+    return std::pair<ConcreteInterval, ConcreteInterval>(concrete_interval(tmp.first), concrete_interval(tmp.second));
+}
+
+// static mixed type
+template<typename T, template<typename> class Flavor, typename RepType, class ConcreteInterval>
+template<typename T1, typename RepType1, class ConcreteInterval1, typename T2, typename RepType2, class ConcreteInterval2>
+std::pair<ConcreteInterval, ConcreteInterval>
+base_interval<T,Flavor,RepType,ConcreteInterval>::mul_rev_to_pair(base_interval<T1, Flavor, RepType1, ConcreteInterval1> const& b,
+        base_interval<T2, Flavor, RepType2, ConcreteInterval2> const& c)
+{
+    // assert that only bare intervals or decorated intervals are used
+    static_assert( (std::is_same<typename Flavor<T>::representation, RepType>::value
+                    && std::is_same<typename Flavor<T1>::representation, RepType1>::value
+                    && std::is_same<typename Flavor<T2>::representation, RepType2>::value)
+                   || (std::is_same<typename Flavor<T>::representation_dec, RepType>::value
+                       && std::is_same<typename Flavor<T1>::representation_dec, RepType1>::value
+                       && std::is_same<typename Flavor<T2>::representation_dec, RepType2>::value),
+                   "It is not supported by mixed type operations to use "
+                   "interval and decorated_interval types together!"
+                 );
+
+    // call of mixed-type version
+    auto tmp = Flavor<T>::mul_rev_to_pair(b.rep_, c.rep_);
+
+    return std::pair<ConcreteInterval, ConcreteInterval>(concrete_interval(tmp.first), concrete_interval(tmp.second));
+}
+
+// function
+template<typename T, template<typename> class Flavor, typename RepType, class ConcreteInterval>
+std::pair<ConcreteInterval, ConcreteInterval>
+mul_rev_to_pair(base_interval<T, Flavor, RepType, ConcreteInterval> const& b,
+                base_interval<T, Flavor, RepType, ConcreteInterval> const& c)
+{
+    return base_interval<T,Flavor,RepType,ConcreteInterval>::mul_rev_to_pair(b, c);
+}
+
+
+} // namespace infsup
+
+} // namespace p1788
+
+
+#endif // LIBIEEEP1788_P1788_INFSUP_BASE_INTERVAL_MUL_REV_TO_PAIR_FUNC_HPP
+

data/ext/libieeep1788_copy/p1788/infsup/base_interval_num_func_impl.hpp

@@ -0,0 +1,345 @@
+//
+//                              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_INFSUP_BASE_INTERVAL_NUM_FUNC_IMPL_HPP
+#define LIBIEEEP1788_P1788_INFSUP_BASE_INTERVAL_NUM_FUNC_IMPL_HPP
+
+namespace p1788
+{
+
+namespace infsup
+{
+
+// inf
+
+// static
+template<typename T, template<typename> class Flavor, typename RepType, class ConcreteInterval>
+T base_interval<T,Flavor,RepType,ConcreteInterval>::inf(base_interval<T, Flavor, RepType, ConcreteInterval> const& x)
+{
+    return Flavor<T>::inf(x.rep_);
+}
+
+// static mixed type
+template<typename T, template<typename> class Flavor, typename RepType, class ConcreteInterval>
+template<typename T_, typename RepType_, class ConcreteInterval_>
+T base_interval<T,Flavor,RepType,ConcreteInterval>::inf(base_interval<T_, Flavor, RepType_, ConcreteInterval_> const& x)
+{
+    // assert that only bare intervals or decorated intervals are used
+    static_assert( (std::is_same<typename Flavor<T>::representation, RepType>::value
+                    && std::is_same<typename Flavor<T_>::representation, RepType_>::value)
+                    || (std::is_same<typename Flavor<T>::representation_dec, RepType>::value
+                    && std::is_same<typename Flavor<T_>::representation_dec, RepType_>::value),
+                    "It is not supported by mixed type operations to use "
+                    "interval and decorated_interval types together!"
+                   );
+
+    // call of mixed-type version
+    return Flavor<T>::inf(x.rep_);
+}
+
+
+// function
+template<typename T, template<typename> class Flavor, typename RepType, class ConcreteInterval>
+T inf(base_interval<T, Flavor, RepType, ConcreteInterval> const& x)
+{
+    return base_interval<T,Flavor,RepType,ConcreteInterval>::inf(x);
+}
+
+
+
+
+// sup
+
+// static
+template<typename T, template<typename> class Flavor, typename RepType, class ConcreteInterval>
+T base_interval<T,Flavor,RepType,ConcreteInterval>::sup(base_interval<T, Flavor, RepType, ConcreteInterval> const& x)
+{
+    return Flavor<T>::sup(x.rep_);
+}
+
+// static mixed type
+template<typename T, template<typename> class Flavor, typename RepType, class ConcreteInterval>
+template<typename T_, typename RepType_, class ConcreteInterval_>
+T base_interval<T,Flavor,RepType,ConcreteInterval>::sup(base_interval<T_, Flavor, RepType_, ConcreteInterval_> const& x)
+{
+    // assert that only bare intervals or decorated intervals are used
+    static_assert( (std::is_same<typename Flavor<T>::representation, RepType>::value
+                    && std::is_same<typename Flavor<T_>::representation, RepType_>::value)
+                    || (std::is_same<typename Flavor<T>::representation_dec, RepType>::value
+                    && std::is_same<typename Flavor<T_>::representation_dec, RepType_>::value),
+                    "It is not supported by mixed type operations to use "
+                    "interval and decorated_interval types together!"
+                   );
+
+    // call of mixed-type version
+    return Flavor<T>::sup(x.rep_);
+}
+
+
+// function
+template<typename T, template<typename> class Flavor, typename RepType, class ConcreteInterval>
+T sup(base_interval<T, Flavor, RepType, ConcreteInterval> const& x)
+{
+    return base_interval<T,Flavor,RepType,ConcreteInterval>::sup(x);
+}
+
+
+
+
+// mid
+
+// static
+template<typename T, template<typename> class Flavor, typename RepType, class ConcreteInterval>
+T base_interval<T,Flavor,RepType,ConcreteInterval>::mid(base_interval<T, Flavor, RepType, ConcreteInterval> const& x)
+{
+    return Flavor<T>::mid(x.rep_);
+}
+
+// static mixed type
+template<typename T, template<typename> class Flavor, typename RepType, class ConcreteInterval>
+template<typename T_, typename RepType_, class ConcreteInterval_>
+T base_interval<T,Flavor,RepType,ConcreteInterval>::mid(base_interval<T_, Flavor, RepType_, ConcreteInterval_> const& x)
+{
+    // assert that only bare intervals or decorated intervals are used
+    static_assert( (std::is_same<typename Flavor<T>::representation, RepType>::value
+                    && std::is_same<typename Flavor<T_>::representation, RepType_>::value)
+                    || (std::is_same<typename Flavor<T>::representation_dec, RepType>::value
+                    && std::is_same<typename Flavor<T_>::representation_dec, RepType_>::value),
+                    "It is not supported by mixed type operations to use "
+                    "interval and decorated_interval types together!"
+                   );
+
+    // call of mixed-type version
+    return Flavor<T>::mid(x.rep_);
+}
+
+
+// function
+template<typename T, template<typename> class Flavor, typename RepType, class ConcreteInterval>
+T mid(base_interval<T, Flavor, RepType, ConcreteInterval> const& x)
+{
+    return base_interval<T,Flavor,RepType,ConcreteInterval>::mid(x);
+}
+
+
+
+
+// rad
+
+// static
+template<typename T, template<typename> class Flavor, typename RepType, class ConcreteInterval>
+T base_interval<T,Flavor,RepType,ConcreteInterval>::rad(base_interval<T, Flavor, RepType, ConcreteInterval> const& x)
+{
+    return Flavor<T>::rad(x.rep_);
+}
+
+// static mixed type
+template<typename T, template<typename> class Flavor, typename RepType, class ConcreteInterval>
+template<typename T_, typename RepType_, class ConcreteInterval_>
+T base_interval<T,Flavor,RepType,ConcreteInterval>::rad(base_interval<T_, Flavor, RepType_, ConcreteInterval_> const& x)
+{
+    // assert that only bare intervals or decorated intervals are used
+    static_assert( (std::is_same<typename Flavor<T>::representation, RepType>::value
+                    && std::is_same<typename Flavor<T_>::representation, RepType_>::value)
+                    || (std::is_same<typename Flavor<T>::representation_dec, RepType>::value
+                    && std::is_same<typename Flavor<T_>::representation_dec, RepType_>::value),
+                    "It is not supported by mixed type operations to use "
+                    "interval and decorated_interval types together!"
+                   );
+
+    // call of mixed-type version
+    return Flavor<T>::rad(x.rep_);
+}
+
+
+// function
+template<typename T, template<typename> class Flavor, typename RepType, class ConcreteInterval>
+T rad(base_interval<T, Flavor, RepType, ConcreteInterval> const& x)
+{
+    return base_interval<T,Flavor,RepType,ConcreteInterval>::rad(x);
+}
+
+
+
+
+// mid_rad
+
+// static
+template<typename T, template<typename> class Flavor, typename RepType, class ConcreteInterval>
+std::pair<T,T> base_interval<T,Flavor,RepType,ConcreteInterval>::mid_rad(base_interval<T, Flavor, RepType, ConcreteInterval> const& x)
+{
+    return Flavor<T>::mid_rad(x.rep_);
+}
+
+// static mixed type
+template<typename T, template<typename> class Flavor, typename RepType, class ConcreteInterval>
+template<typename T_, typename RepType_, class ConcreteInterval_>
+std::pair<T,T> base_interval<T,Flavor,RepType,ConcreteInterval>::mid_rad(base_interval<T_, Flavor, RepType_, ConcreteInterval_> const& x)
+{
+    // assert that only bare intervals or decorated intervals are used
+    static_assert( (std::is_same<typename Flavor<T>::representation, RepType>::value
+                    && std::is_same<typename Flavor<T_>::representation, RepType_>::value)
+                    || (std::is_same<typename Flavor<T>::representation_dec, RepType>::value
+                    && std::is_same<typename Flavor<T_>::representation_dec, RepType_>::value),
+                    "It is not supported by mixed type operations to use "
+                    "interval and decorated_interval types together!"
+                   );
+
+    // call of mixed-type version
+    return Flavor<T>::mid_rad(x.rep_);
+}
+
+
+// function
+template<typename T, template<typename> class Flavor, typename RepType, class ConcreteInterval>
+std::pair<T,T> mid_rad(base_interval<T, Flavor, RepType, ConcreteInterval> const& x)
+{
+    return base_interval<T,Flavor,RepType,ConcreteInterval>::mid_rad(x);
+}
+
+
+
+
+// wid
+
+// static
+template<typename T, template<typename> class Flavor, typename RepType, class ConcreteInterval>
+T base_interval<T,Flavor,RepType,ConcreteInterval>::wid(base_interval<T, Flavor, RepType, ConcreteInterval> const& x)
+{
+    return Flavor<T>::wid(x.rep_);
+}
+
+// static mixed type
+template<typename T, template<typename> class Flavor, typename RepType, class ConcreteInterval>
+template<typename T_, typename RepType_, class ConcreteInterval_>
+T base_interval<T,Flavor,RepType,ConcreteInterval>::wid(base_interval<T_, Flavor, RepType_, ConcreteInterval_> const& x)
+{
+    // assert that only bare intervals or decorated intervals are used
+    static_assert( (std::is_same<typename Flavor<T>::representation, RepType>::value
+                    && std::is_same<typename Flavor<T_>::representation, RepType_>::value)
+                    || (std::is_same<typename Flavor<T>::representation_dec, RepType>::value
+                    && std::is_same<typename Flavor<T_>::representation_dec, RepType_>::value),
+                    "It is not supported by mixed type operations to use "
+                    "interval and decorated_interval types together!"
+                   );
+
+    // call of mixed-type version
+    return Flavor<T>::wid(x.rep_);
+}
+
+
+// function
+template<typename T, template<typename> class Flavor, typename RepType, class ConcreteInterval>
+T wid(base_interval<T, Flavor, RepType, ConcreteInterval> const& x)
+{
+    return base_interval<T,Flavor,RepType,ConcreteInterval>::wid(x);
+}
+
+
+
+
+// mag
+
+// static
+template<typename T, template<typename> class Flavor, typename RepType, class ConcreteInterval>
+T base_interval<T,Flavor,RepType,ConcreteInterval>::mag(base_interval<T, Flavor, RepType, ConcreteInterval> const& x)
+{
+    return Flavor<T>::mag(x.rep_);
+}
+
+// static mixed type
+template<typename T, template<typename> class Flavor, typename RepType, class ConcreteInterval>
+template<typename T_, typename RepType_, class ConcreteInterval_>
+T base_interval<T,Flavor,RepType,ConcreteInterval>::mag(base_interval<T_, Flavor, RepType_, ConcreteInterval_> const& x)
+{
+    // assert that only bare intervals or decorated intervals are used
+    static_assert( (std::is_same<typename Flavor<T>::representation, RepType>::value
+                    && std::is_same<typename Flavor<T_>::representation, RepType_>::value)
+                    || (std::is_same<typename Flavor<T>::representation_dec, RepType>::value
+                    && std::is_same<typename Flavor<T_>::representation_dec, RepType_>::value),
+                    "It is not supported by mixed type operations to use "
+                    "interval and decorated_interval types together!"
+                   );
+
+    // call of mixed-type version
+    return Flavor<T>::mag(x.rep_);
+}
+
+
+// function
+template<typename T, template<typename> class Flavor, typename RepType, class ConcreteInterval>
+T mag(base_interval<T, Flavor, RepType, ConcreteInterval> const& x)
+{
+    return base_interval<T,Flavor,RepType,ConcreteInterval>::mag(x);
+}
+
+
+
+
+// mig
+
+// static
+template<typename T, template<typename> class Flavor, typename RepType, class ConcreteInterval>
+T base_interval<T,Flavor,RepType,ConcreteInterval>::mig(base_interval<T, Flavor, RepType, ConcreteInterval> const& x)
+{
+    return Flavor<T>::mig(x.rep_);
+}
+
+// static mixed type
+template<typename T, template<typename> class Flavor, typename RepType, class ConcreteInterval>
+template<typename T_, typename RepType_, class ConcreteInterval_>
+T base_interval<T,Flavor,RepType,ConcreteInterval>::mig(base_interval<T_, Flavor, RepType_, ConcreteInterval_> const& x)
+{
+    // assert that only bare intervals or decorated intervals are used
+    static_assert( (std::is_same<typename Flavor<T>::representation, RepType>::value
+                    && std::is_same<typename Flavor<T_>::representation, RepType_>::value)
+                    || (std::is_same<typename Flavor<T>::representation_dec, RepType>::value
+                    && std::is_same<typename Flavor<T_>::representation_dec, RepType_>::value),
+                    "It is not supported by mixed type operations to use "
+                    "interval and decorated_interval types together!"
+                   );
+
+    // call of mixed-type version
+    return Flavor<T>::mig(x.rep_);
+}
+
+
+// function
+template<typename T, template<typename> class Flavor, typename RepType, class ConcreteInterval>
+T mig(base_interval<T, Flavor, RepType, ConcreteInterval> const& x)
+{
+    return base_interval<T,Flavor,RepType,ConcreteInterval>::mig(x);
+}
+
+
+
+
+
+} // namespace infsup
+
+} // namespace p1788
+
+
+#endif // LIBIEEEP1788_P1788_INFSUP_BASE_INTERVAL_NUM_FUNC_IMPL_HPP

data/ext/libieeep1788_copy/p1788/infsup/base_interval_rec_bool_func_impl.hpp

@@ -0,0 +1,92 @@
+//
+//                              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_INFSUP_BASE_INTERVAL_REC_BOOL_FUNC_IMPL_HPP
+#define LIBIEEEP1788_P1788_INFSUP_BASE_INTERVAL_REC_BOOL_FUNC_IMPL_HPP
+
+namespace p1788
+{
+
+namespace infsup
+{
+
+// is_common_interval
+
+// static
+template<typename T, template<typename> class Flavor, typename RepType, class ConcreteInterval>
+bool base_interval<T, Flavor, RepType, ConcreteInterval>::is_common_interval(base_interval<T, Flavor, RepType, ConcreteInterval> const& x)
+{
+    return Flavor<T>::is_common_interval(x.rep_);
+}
+
+// function
+template<typename T, template<typename> class Flavor, typename RepType, class ConcreteInterval>
+bool is_common_interval(base_interval<T, Flavor, RepType, ConcreteInterval> const& x)
+{
+    return base_interval<T, Flavor, RepType, ConcreteInterval>::is_common_interval(x);
+}
+
+
+// is_singleton
+
+// static
+template<typename T, template<typename> class Flavor, typename RepType, class ConcreteInterval>
+bool base_interval<T, Flavor, RepType, ConcreteInterval>::is_singleton(base_interval<T, Flavor, RepType, ConcreteInterval> const& x)
+{
+    return Flavor<T>::is_singleton(x.rep_);
+}
+
+// function
+template<typename T, template<typename> class Flavor, typename RepType, class ConcreteInterval>
+bool is_singleton(base_interval<T, Flavor, RepType, ConcreteInterval> const& x)
+{
+    return base_interval<T, Flavor, RepType, ConcreteInterval>::is_singleton(x);
+}
+
+
+// is_member
+
+// static
+template<typename T, template<typename> class Flavor, typename RepType, class ConcreteInterval>
+template<typename T_>
+bool base_interval<T, Flavor, RepType, ConcreteInterval>::is_member(T_ m, base_interval<T, Flavor, RepType, ConcreteInterval> const& x)
+{
+    return Flavor<T>::is_member(m, x.rep_);
+}
+
+// function
+template<typename T_, typename T, template<typename> class Flavor, typename RepType, class ConcreteInterval>
+bool is_member(T_ m, base_interval<T, Flavor, RepType, ConcreteInterval> const& x)
+{
+    return base_interval<T, Flavor, RepType, ConcreteInterval>::is_member(m, x);
+}
+
+
+} // namespace infsup
+
+} // namespace p1788
+
+
+#endif // LIBIEEEP1788_P1788_INFSUP_BASE_INTERVAL_REC_BOOL_FUNC_IMPL_HPP

data/ext/libieeep1788_copy/p1788/infsup/base_interval_rec_overlap_impl.hpp

@@ -0,0 +1,72 @@
+//
+//                              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_INFSUP_BASE_INTERVAL_REC_OVERLAP_FUNC_HPP
+#define LIBIEEEP1788_P1788_INFSUP_BASE_INTERVAL_REC_OVERLAP_FUNC_HPP
+
+namespace p1788
+{
+
+namespace infsup
+{
+
+
+// overlap
+
+// static
+template<typename T, template<typename> class Flavor, typename RepType, class ConcreteInterval>
+template<typename T_, typename RepType_, class ConcreteInterval_>
+p1788::overlapping::overlapping_state
+base_interval<T, Flavor, RepType, ConcreteInterval>::overlap(base_interval<T, Flavor, RepType, ConcreteInterval> const& x,
+        base_interval<T_, Flavor, RepType_, ConcreteInterval_> const& y)
+{
+    // assert that only bare intervals or decorated intervals are used
+    static_assert( (std::is_same<typename Flavor<T>::representation, RepType>::value
+                    && std::is_same<typename Flavor<T_>::representation, RepType_>::value)
+                   || (std::is_same<typename Flavor<T>::representation_dec, RepType>::value
+                       && std::is_same<typename Flavor<T_>::representation_dec, RepType_>::value),
+                   "It is not supported by mixed type operations to use "
+                   "interval and decorated_interval types together!"
+                 );
+
+    return Flavor<T>::overlap(x.rep_, y.rep_);
+}
+
+// function
+template<typename T1, template<typename> class Flavor, typename RepType1, class ConcreteInterval1, typename T2, typename RepType2, class ConcreteInterval2>
+p1788::overlapping::overlapping_state
+overlap(base_interval<T1, Flavor, RepType1, ConcreteInterval1> const& x, base_interval<T2, Flavor, RepType2, ConcreteInterval2> const& y)
+{
+    return base_interval<T1, Flavor, RepType1, ConcreteInterval1>::overlap(x, y);
+}
+
+
+
+} // namespace infsup
+
+} // namespace p1788
+
+
+#endif // LIBIEEEP1788_P1788_INFSUP_BASE_INTERVAL_REC_OVERLAP_FUNC_HPP