From: Paolo Carlini Date: Tue, 10 Jan 2006 18:15:34 +0000 (+0000) Subject: complex: New file... X-Git-Url: https://git.libre-soc.org/?a=commitdiff_plain;h=84a7b1fccfb7444fbee02496958ae8df5b90b15b;p=gcc.git complex: New file... 2006-01-10 Paolo Carlini * include/tr1/complex: New file, hosts the additions to header described in TR1, Chapter 8 [tr.c99]. * include/Makefile.am: Add. * include/Makefile.in: Regenerate. * testsuite/tr1/8_c_compatibility/complex/functions.cc: New. From-SVN: r109550 --- diff --git a/libstdc++-v3/ChangeLog b/libstdc++-v3/ChangeLog index 34a6f9b73c3..9f5713e7d37 100644 --- a/libstdc++-v3/ChangeLog +++ b/libstdc++-v3/ChangeLog @@ -1,3 +1,11 @@ +2006-01-10 Paolo Carlini + + * include/tr1/complex: New file, hosts the additions to header + described in TR1, Chapter 8 [tr.c99]. + * include/Makefile.am: Add. + * include/Makefile.in: Regenerate. + * testsuite/tr1/8_c_compatibility/complex/functions.cc: New. + 2006-01-09 Paolo Carlini PR libstdc++/25658 diff --git a/libstdc++-v3/include/Makefile.am b/libstdc++-v3/include/Makefile.am index e71b76a0ec1..68b1d81d80a 100644 --- a/libstdc++-v3/include/Makefile.am +++ b/libstdc++-v3/include/Makefile.am @@ -483,21 +483,22 @@ tr1_headers = \ ${tr1_srcdir}/bind_repeat.h \ ${tr1_srcdir}/bind_iterate.h \ ${tr1_srcdir}/boost_shared_ptr.h \ - ${tr1_srcdir}/mu_iterate.h \ + ${tr1_srcdir}/complex \ ${tr1_srcdir}/functional \ ${tr1_srcdir}/functional_iterate.h \ + ${tr1_srcdir}/hashtable \ ${tr1_srcdir}/memory \ + ${tr1_srcdir}/mu_iterate.h \ ${tr1_srcdir}/ref_fwd.h \ ${tr1_srcdir}/ref_wrap_iterate.h \ ${tr1_srcdir}/repeat.h \ ${tr1_srcdir}/tuple \ ${tr1_srcdir}/tuple_iterate.h \ - ${tr1_srcdir}/utility \ ${tr1_srcdir}/type_traits \ ${tr1_srcdir}/type_traits_fwd.h \ - ${tr1_srcdir}/hashtable \ ${tr1_srcdir}/unordered_set \ - ${tr1_srcdir}/unordered_map + ${tr1_srcdir}/unordered_map \ + ${tr1_srcdir}/utility # This is the common subset of files that all three "C" header models use. diff --git a/libstdc++-v3/include/Makefile.in b/libstdc++-v3/include/Makefile.in index 6c97c63c249..9b9c82253b4 100644 --- a/libstdc++-v3/include/Makefile.in +++ b/libstdc++-v3/include/Makefile.in @@ -701,21 +701,22 @@ tr1_headers = \ ${tr1_srcdir}/bind_repeat.h \ ${tr1_srcdir}/bind_iterate.h \ ${tr1_srcdir}/boost_shared_ptr.h \ - ${tr1_srcdir}/mu_iterate.h \ + ${tr1_srcdir}/complex \ ${tr1_srcdir}/functional \ ${tr1_srcdir}/functional_iterate.h \ + ${tr1_srcdir}/hashtable \ ${tr1_srcdir}/memory \ + ${tr1_srcdir}/mu_iterate.h \ ${tr1_srcdir}/ref_fwd.h \ ${tr1_srcdir}/ref_wrap_iterate.h \ ${tr1_srcdir}/repeat.h \ ${tr1_srcdir}/tuple \ ${tr1_srcdir}/tuple_iterate.h \ - ${tr1_srcdir}/utility \ ${tr1_srcdir}/type_traits \ ${tr1_srcdir}/type_traits_fwd.h \ - ${tr1_srcdir}/hashtable \ ${tr1_srcdir}/unordered_set \ - ${tr1_srcdir}/unordered_map + ${tr1_srcdir}/unordered_map \ + ${tr1_srcdir}/utility # This is the common subset of files that all three "C" header models use. diff --git a/libstdc++-v3/include/tr1/complex b/libstdc++-v3/include/tr1/complex new file mode 100644 index 00000000000..5df17bb09b5 --- /dev/null +++ b/libstdc++-v3/include/tr1/complex @@ -0,0 +1,303 @@ +// TR1 complex -*- C++ -*- + +// Copyright (C) 2006 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 2, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING. If not, write to the Free +// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, +// USA. + +// As a special exception, you may use this file as part of a free software +// library without restriction. Specifically, if other files instantiate +// templates or use macros or inline functions from this file, or you compile +// this file and link it with other files to produce an executable, this +// file does not by itself cause the resulting executable to be covered by +// the GNU General Public License. This exception does not however +// invalidate any other reasons why the executable file might be covered by +// the GNU General Public License. + +/** @file + * This is a TR1 C++ Library header. + */ + +#ifndef _TR1_COMPLEX +#define _TR1_COMPLEX 1 + +#include "../complex" + +// namespace std::tr1 +namespace std +{ +_GLIBCXX_BEGIN_NAMESPACE(tr1) + + // Forward declarations. + template std::complex<_Tp> acos(const std::complex<_Tp>&); + template std::complex<_Tp> asin(const std::complex<_Tp>&); + template std::complex<_Tp> atan(const std::complex<_Tp>&); + + template std::complex<_Tp> acosh(const std::complex<_Tp>&); + template std::complex<_Tp> asinh(const std::complex<_Tp>&); + template std::complex<_Tp> atanh(const std::complex<_Tp>&); + template std::complex<_Tp> fabs(const std::complex<_Tp>&); + + /// @brief acos(__z) [8.1.2] + // Effects: Behaves the same as C99 function cacos, defined + // in subclause 7.3.5.1. + template + inline std::complex<_Tp> + __complex_acos(const std::complex<_Tp>& __z) + { + const std::complex<_Tp> __t = std::tr1::asin(__z); + const _Tp __pi_2 = 1.5707963267948966192313216916397514L; + return std::complex<_Tp>(__pi_2 - __t.real(), -__t.imag()); + } + +#if _GLIBCXX_USE_C99_COMPLEX + inline __complex__ float + __complex_acos(__complex__ float __z) + { return __builtin_cacosf(__z); } + + inline __complex__ double + __complex_acos(__complex__ double __z) + { return __builtin_cacos(__z); } + + inline __complex__ long double + __complex_acos(const __complex__ long double& __z) + { return __builtin_cacosl(__z); } + + template + inline std::complex<_Tp> + acos(const std::complex<_Tp>& __z) + { return __complex_acos(__z.__rep()); } +#else + template + inline std::complex<_Tp> + acos(const std::complex<_Tp>& __z) + { return __complex_acos(__z); } +#endif + + /// @brief asin(__z) [8.1.3] + // Effects: Behaves the same as C99 function casin, defined + // in subclause 7.3.5.2. + template + inline std::complex<_Tp> + __complex_asin(const std::complex<_Tp>& __z) + { + std::complex<_Tp> __t(-__z.imag(), __z.real()); + __t = std::tr1::asinh(__t); + return std::complex<_Tp>(__t.imag(), -__t.real()); + } + +#if _GLIBCXX_USE_C99_COMPLEX + inline __complex__ float + __complex_asin(__complex__ float __z) + { return __builtin_casinf(__z); } + + inline __complex__ double + __complex_asin(__complex__ double __z) + { return __builtin_casin(__z); } + + inline __complex__ long double + __complex_asin(const __complex__ long double& __z) + { return __builtin_casinl(__z); } + + template + inline std::complex<_Tp> + asin(const std::complex<_Tp>& __z) + { return __complex_asin(__z.__rep()); } +#else + template + inline std::complex<_Tp> + asin(const std::complex<_Tp>& __z) + { return __complex_asin(__z); } +#endif + + /// @brief atan(__z) [8.1.4] + // Effects: Behaves the same as C99 function catan, defined + // in subclause 7.3.5.3. + template + std::complex<_Tp> + __complex_atan(const std::complex<_Tp>& __z) + { + const _Tp __r2 = __z.real() * __z.real(); + const _Tp __x = _Tp(1.0) - __r2 - __z.imag() * __z.imag(); + + _Tp __num = __z.imag() + _Tp(1.0); + _Tp __den = __z.imag() - _Tp(1.0); + + __num = __r2 + __num * __num; + __den = __r2 + __den * __den; + + return std::complex<_Tp>(_Tp(0.5) * atan2(_Tp(2.0) * __z.real(), __x), + _Tp(0.25) * log(__num / __den)); + } + +#if _GLIBCXX_USE_C99_COMPLEX + inline __complex__ float + __complex_atan(__complex__ float __z) + { return __builtin_catanf(__z); } + + inline __complex__ double + __complex_atan(__complex__ double __z) + { return __builtin_catan(__z); } + + inline __complex__ long double + __complex_atan(const __complex__ long double& __z) + { return __builtin_catanl(__z); } + + template + inline std::complex<_Tp> + atan(const std::complex<_Tp>& __z) + { return __complex_atan(__z.__rep()); } +#else + template + inline std::complex<_Tp> + atan(const std::complex<_Tp>& __z) + { return __complex_atan(__z); } +#endif + + /// @brief acosh(__z) [8.1.5] + // Effects: Behaves the same as C99 function cacosh, defined + // in subclause 7.3.6.1. + template + std::complex<_Tp> + __complex_acosh(const std::complex<_Tp>& __z) + { + std::complex<_Tp> __t((__z.real() - __z.imag()) + * (__z.real() + __z.imag()) - _Tp(1.0), + _Tp(2.0) * __z.real() * __z.imag()); + __t = std::sqrt(__t); + + return std::log(__t + __z); + } + +#if _GLIBCXX_USE_C99_COMPLEX + inline __complex__ float + __complex_acosh(__complex__ float __z) + { return __builtin_cacoshf(__z); } + + inline __complex__ double + __complex_acosh(__complex__ double __z) + { return __builtin_cacosh(__z); } + + inline __complex__ long double + __complex_acosh(const __complex__ long double& __z) + { return __builtin_cacoshl(__z); } + + template + inline std::complex<_Tp> + acosh(const std::complex<_Tp>& __z) + { return __complex_acosh(__z.__rep()); } +#else + template + inline std::complex<_Tp> + acosh(const std::complex<_Tp>& __z) + { return __complex_acosh(__z); } +#endif + + /// @brief asinh(__z) [8.1.6] + // Effects: Behaves the same as C99 function casin, defined + // in subclause 7.3.6.2. + template + std::complex<_Tp> + __complex_asinh(const std::complex<_Tp>& __z) + { + std::complex<_Tp> __t((__z.real() - __z.imag()) + * (__z.real() + __z.imag()) + _Tp(1.0), + _Tp(2.0) * __z.real() * __z.imag()); + __t = std::sqrt(__t); + + return std::log(__t + __z); + } + +#if _GLIBCXX_USE_C99_COMPLEX + inline __complex__ float + __complex_asinh(__complex__ float __z) + { return __builtin_casinhf(__z); } + + inline __complex__ double + __complex_asinh(__complex__ double __z) + { return __builtin_casinh(__z); } + + inline __complex__ long double + __complex_asinh(const __complex__ long double& __z) + { return __builtin_casinhl(__z); } + + template + inline std::complex<_Tp> + asinh(const std::complex<_Tp>& __z) + { return __complex_asinh(__z.__rep()); } +#else + template + inline std::complex<_Tp> + asinh(const std::complex<_Tp>& __z) + { return __complex_asinh(__z); } +#endif + + /// @brief atanh(__z) [8.1.7] + // Effects: Behaves the same as C99 function catanh, defined + // in subclause 7.3.6.3. + template + std::complex<_Tp> + __complex_atanh(const std::complex<_Tp>& __z) + { + const _Tp __i2 = __z.imag() * __z.imag(); + const _Tp __x = _Tp(1.0) - __i2 - __z.real() * __z.real(); + + _Tp __num = _Tp(1.0) + __z.real(); + _Tp __den = _Tp(1.0) - __z.real(); + + __num = __i2 + __num * __num; + __den = __i2 + __den * __den; + + return std::complex<_Tp>(_Tp(0.25) * (log(__num) - log(__den)), + _Tp(0.5) * atan2(_Tp(2.0) * __z.imag(), __x)); + } + +#if _GLIBCXX_USE_C99_COMPLEX + inline __complex__ float + __complex_atanh(__complex__ float __z) + { return __builtin_catanhf(__z); } + + inline __complex__ double + __complex_atanh(__complex__ double __z) + { return __builtin_catanh(__z); } + + inline __complex__ long double + __complex_atanh(const __complex__ long double& __z) + { return __builtin_catanhl(__z); } + + template + inline std::complex<_Tp> + atanh(const std::complex<_Tp>& __z) + { return __complex_atanh(__z.__rep()); } +#else + template + inline std::complex<_Tp> + atanh(const std::complex<_Tp>& __z) + { return __complex_atanh(__z); } +#endif + + /// @brief fabs(__z) [8.1.8] + // Effects: Behaves the same as C99 function cabs, defined + // in subclause 7.3.8.1. + template + inline std::complex<_Tp> + fabs(const std::complex<_Tp>& __z) + { return std::abs(__z); } + +_GLIBCXX_END_NAMESPACE +} + +#endif diff --git a/libstdc++-v3/testsuite/tr1/8_c_compatibility/complex/functions.cc b/libstdc++-v3/testsuite/tr1/8_c_compatibility/complex/functions.cc new file mode 100644 index 00000000000..1fdd10848e3 --- /dev/null +++ b/libstdc++-v3/testsuite/tr1/8_c_compatibility/complex/functions.cc @@ -0,0 +1,54 @@ +// 2006-01-10 Paolo Carlini +// +// Copyright (C) 2006 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 2, or (at your option) +// any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING. If not, write to the Free +// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, +// USA. + +// 8.1 Additions to header + +#include + +template + void test01_do() + { + using namespace std::tr1; + typedef std::complex cmplx_type; + + cmplx_type ans; + + ans = acos(cmplx_type(1.0, 1.0)); + ans = asin(cmplx_type(1.0, 1.0)); + ans = atan(cmplx_type(1.0, 1.0)); + + ans = acosh(cmplx_type(1.0, 1.0)); + ans = asinh(cmplx_type(1.0, 1.0)); + ans = atanh(cmplx_type(1.0, 1.0)); + ans = fabs(cmplx_type(1.0, 1.0)); + } + +void test01() +{ + test01_do(); + test01_do(); + test01_do(); +} + +int main() +{ + test01(); + return 0; +}