Patchwork User-define literals for std::complex.

login
register
mail settings
Submitter Ed Smith-Rowland
Date Sept. 27, 2013, 4:17 a.m.
Message ID <524506EA.1040504@verizon.net>
Download mbox | patch
Permalink /patch/278469/
State New
Headers show

Comments

Ed Smith-Rowland - Sept. 27, 2013, 4:17 a.m.
Greetings,

The complex user-defined literals finally passed (n3779) with the 
resolution to DR1473 allowing the suffix id to touch the quotes (Can't 
find it but I put it in not too long ago).
(http://wiki.edg.com/twiki/pub/Wg21chicago2013/LibraryWorkingGroup/N3779-complex_literals.pdf)

Actually, I think allowing space between quotes and suffix ID was a mistake.

Also it looks like they are *removing* inline from the 'namespace 
literals' so that 'using std;' brings in the literals but that will be a 
later patch for all literals at once.

This has been bootstrapped and regtested on x86_64-linux.

As a general stylistic guide for the library I think I'll put
   operator""abc(...)
with no spaces.  Later.

OK?
2013-09-27  Ed Smith-Rowland  <3dw4rd@verizon.net>

	Implement N3779 - User-defined Literals for std::complex,
	part 2 of UDL for Standard Library Types
	* include/std/complex: Add complex literal operators.
	* testsuite/26_numerics/complex/literals/types.cc: New.
	* testsuite/26_numerics/complex/literals/values.cc: New.
Jonathan Wakely - Sept. 27, 2013, 9:39 a.m.
On 27 September 2013 05:17, Ed Smith-Rowland wrote:
>
> The complex user-defined literals finally passed (n3779) with the resolution
> to DR1473 allowing the suffix id to touch the quotes (Can't find it but I
> put it in not too long ago).

I think it's been approved by the LWG and looks like it will go to a
vote by the full committee, but let's wait for that to pass before
making any changes.
Ed Smith-Rowland - Oct. 20, 2013, 9:18 p.m.
On 09/27/2013 05:39 AM, Jonathan Wakely wrote:
> On 27 September 2013 05:17, Ed Smith-Rowland wrote:
>> The complex user-defined literals finally passed (n3779) with the resolution
>> to DR1473 allowing the suffix id to touch the quotes (Can't find it but I
>> put it in not too long ago).
> I think it's been approved by the LWG and looks like it will go to a
> vote by the full committee, but let's wait for that to pass before
> making any changes.
>

Now that this is in the working paper can we go ahead?
Jonathan Wakely - Oct. 22, 2013, 12:26 p.m.
On 20 October 2013 22:18, Ed Smith-Rowland wrote:
> On 09/27/2013 05:39 AM, Jonathan Wakely wrote:
>>
>> On 27 September 2013 05:17, Ed Smith-Rowland wrote:
>>>
>>> The complex user-defined literals finally passed (n3779) with the
>>> resolution
>>> to DR1473 allowing the suffix id to touch the quotes (Can't find it but I
>>> put it in not too long ago).
>>
>> I think it's been approved by the LWG and looks like it will go to a
>> vote by the full committee, but let's wait for that to pass before
>> making any changes.
>>
>
> Now that this is in the working paper can we go ahead?

Yes, thanks for waiting.  The patch you posted is OK, although I think
"inline constexpr" on the new operators is redundant, as constexpr
functions are implicitly inline.

Patch

Index: include/std/complex
===================================================================
--- include/std/complex	(revision 202928)
+++ include/std/complex	(working copy)
@@ -1924,6 +1924,40 @@ 
     conj(_Tp __x)
     { return __x; }
 
+#if __cplusplus > 201103L
+
+inline namespace literals {
+inline namespace complex_literals {
+
+  inline constexpr std::complex<float>
+  operator""if(long double __num)
+  { return std::complex<float>{0.0F, static_cast<float>(__num)}; }
+
+  inline constexpr std::complex<float>
+  operator""if(unsigned long long __num)
+  { return std::complex<float>{0.0F, static_cast<float>(__num)}; }
+
+  inline constexpr std::complex<double>
+  operator""i(long double __num)
+  { return std::complex<double>{0.0, static_cast<double>(__num)}; }
+
+  inline constexpr std::complex<double>
+  operator""i(unsigned long long __num)
+  { return std::complex<double>{0.0, static_cast<double>(__num)}; }
+
+  inline constexpr std::complex<long double>
+  operator""il(long double __num)
+  { return std::complex<long double>{0.0L, __num}; }
+
+  inline constexpr std::complex<long double>
+  operator""il(unsigned long long __num)
+  { return std::complex<long double>{0.0L, static_cast<long double>(__num)}; }
+
+} // inline namespace complex_literals
+} // inline namespace literals
+
+#endif // C++14
+
 _GLIBCXX_END_NAMESPACE_VERSION
 } // namespace
 
Index: testsuite/26_numerics/complex/literals/types.cc
===================================================================
--- testsuite/26_numerics/complex/literals/types.cc	(revision 0)
+++ testsuite/26_numerics/complex/literals/types.cc	(working copy)
@@ -0,0 +1,46 @@ 
+// { dg-options "-std=c++1y" }
+// { dg-do compile }
+
+// Copyright (C) 2013 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+#include <complex>
+#include <type_traits>
+
+void
+test02()
+{
+  using namespace std::literals::complex_literals;
+
+  static_assert(std::is_same<decltype(1.0if), std::complex<float>>::value,
+		"1.0if is std::complex<float>");
+
+  static_assert(std::is_same<decltype(1if), std::complex<float>>::value,
+		"1if is std::complex<float>");
+
+  static_assert(std::is_same<decltype(1.0i), std::complex<double>>::value,
+		"1.0i is std::complex<double>");
+
+  static_assert(std::is_same<decltype(1i), std::complex<double>>::value,
+		"1i is std::complex<double>");
+
+  static_assert(std::is_same<decltype(1.0il), std::complex<long double>>::value,
+		"1.0il is std::complex<long double>");
+
+  static_assert(std::is_same<decltype(1il), std::complex<long double>>::value,
+		"1il is std::complex<long double>");
+}
Index: testsuite/26_numerics/complex/literals/values.cc
===================================================================
--- testsuite/26_numerics/complex/literals/values.cc	(revision 0)
+++ testsuite/26_numerics/complex/literals/values.cc	(working copy)
@@ -0,0 +1,48 @@ 
+// { dg-options "-std=gnu++1y" }
+// { dg-do run }
+
+// Copyright (C) 2013 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+#include <complex>
+#include <testsuite_hooks.h>
+
+void
+test02()
+{
+  using namespace std::literals::complex_literals;
+
+  std::complex<float> j1 = 1.0if;
+  std::complex<float> k1 = 1if;
+  std::complex<double> j2 = 2.0i;
+  std::complex<double> k2 = 2i;
+  std::complex<long double> j4 = 4.0il;
+  std::complex<long double> k4 = 4il;
+
+  VERIFY( j1 == std::complex<float>(0.0F, 1.0F) );
+  VERIFY( k1 == std::complex<float>(0.0F, 1.0F) );
+  VERIFY( j2 == std::complex<double>(0.0, 2.0) );
+  VERIFY( k2 == std::complex<double>(0.0, 2.0) );
+  VERIFY( j4 == std::complex<long double>(0.0L, 4.0L) );
+  VERIFY( k4 == std::complex<long double>(0.0L, 4.0L) );
+}
+
+int
+main()
+{
+  test02();
+}