220 32091 <5fc8b8b9-c0f6-4620-b54a-62acde6cb7f0@isocpp.org> article
Path: news.gmane.org!.POSTED!not-for-mail
From: 3dw4rd@verizon.net
Newsgroups: gmane.comp.lang.c++.isocpp.proposals
Subject: Re: Decomposition of std::complex.
Date: Fri, 14 Apr 2017 13:01:17 -0700 (PDT)
Lines: 1011
Approved: news@gmane.org
Message-ID: <5fc8b8b9-c0f6-4620-b54a-62acde6cb7f0@isocpp.org>
References: <74a45396-2e35-4231-86b9-4caceb531239@isocpp.org>
 <4259d7dc-f060-dc27-5004-37bf4726e456@wanadoo.fr>
Reply-To: std-proposals@isocpp.org
NNTP-Posting-Host: blaine.gmane.org
Mime-Version: 1.0
Content-Type: multipart/mixed; 
	boundary="----=_Part_1227_1652640001.1492200077632"
X-Trace: blaine.gmane.org 1492200080 31992 195.159.176.226 (14 Apr 2017 20:01:20 GMT)
X-Complaints-To: usenet@blaine.gmane.org
NNTP-Posting-Date: Fri, 14 Apr 2017 20:01:20 +0000 (UTC)
To: ISO C++ Standard - Future Proposals <std-proposals@isocpp.org>
Original-X-From: std-proposals+bncBCS2FYFYXYEBBDWVYTDQKGQEDQLQH6Q@isocpp.org Fri Apr 14 22:01:14 2017
Return-path: <std-proposals+bncBCS2FYFYXYEBBDWVYTDQKGQEDQLQH6Q@isocpp.org>
Envelope-to: gclcip-std-proposals@m.gmane.org
Original-Received: from mail-pf0-f197.google.com ([209.85.192.197])
	by blaine.gmane.org with esmtp (Exim 4.84_2)
	(envelope-from <std-proposals+bncBCS2FYFYXYEBBDWVYTDQKGQEDQLQH6Q@isocpp.org>)
	id 1cz7P7-00089L-Rw
	for gclcip-std-proposals@m.gmane.org; Fri, 14 Apr 2017 22:01:14 +0200
Original-Received: by mail-pf0-f197.google.com with SMTP id j16sf51626073pfk.4
        for <gclcip-std-proposals@m.gmane.org>; Fri, 14 Apr 2017 13:01:19 -0700 (PDT)
DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed;
        d=isocpp-org.20150623.gappssmtp.com; s=20150623;
        h=date:from:to:message-id:in-reply-to:references:subject:mime-version
         :x-original-sender:reply-to:precedence:mailing-list:list-id
         :x-spam-checked-in-group:list-post:list-help:list-archive
         :list-subscribe:list-unsubscribe;
        bh=3eP2sRpxzVeXV7hpO6J1LTXgDInmSGvlX8UQ3t61yf8=;
        b=xUV22rhmx9HbC8Ja4m7kmcOYkY3TUUGo+Ewe0vPLED71i48bi7zl7coFvXzCJl5jXS
         U3SFvm7Z9WzEKa1sOLmS/33Ne0ckrdImi6Nh2LzFAH2PW8+TY1crmed5LpHyeBYlAYzV
         XeYIH6D3Vi6rZf4bqHt/JleDYGOyq4VqAcYNbGFJslBOrCHQ9/dNs7giZjBelYdUQWZg
         Rdw0oT8w2SsZc339Z2P+DK6nXe11mfZK4BKTIxm7mkaXzimsaGdItkTCAmIOBT11raES
         +mf9/ToP4sOif9UVEN3rpXcJRrPlhpQEpw0a7B9X4pXJZ5J4Vz+SYBDmLU6Ui5xsiskU
         eOsQ==
X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed;
        d=1e100.net; s=20161025;
        h=x-gm-message-state:date:from:to:message-id:in-reply-to:references
         :subject:mime-version:x-original-sender:reply-to:precedence
         :mailing-list:list-id:x-spam-checked-in-group:list-post:list-help
         :list-archive:list-subscribe:list-unsubscribe;
        bh=3eP2sRpxzVeXV7hpO6J1LTXgDInmSGvlX8UQ3t61yf8=;
        b=U42Y0urXC4r0C6So1tZ3KtRGKbVTtiEoCInCvJeDriFYUyECNUDMToAglONLwgaP2M
         4hOrTYFHnkb65VoSImfflRHojGxb80EHu5nS7OblPYLX5JExdkD4kBG676smlE4nd13q
         51PpqCikbYYYeWyxtoGyyMtAC4E4k3/IGGwWUd1CEY8dPnDtwfb/kHG0nMOtjhO9Ioxv
         RdYlnu9oQm06Ul5JC3Zs7f9kKKjKKW/olbPSVuB7FNcLk5pVHSP3PyMZFBEhadnj2dws
         EZBKcuPPs6jIMzvaqwdg81oRMdcY+906LtvQYWTpl5zwx4mvuHaiy4PpNFXZaxwlQQyO
         quag==
X-Gm-Message-State: AN3rC/5FRbhTupM4SdnQ44YtClNcsao3f9UO9fqCWH6AQq+fqnRnJ8T7
	F+z9lk2Frva6VA==
X-Received: by 10.99.63.139 with SMTP id m133mr1769248pga.42.1492200079034;
        Fri, 14 Apr 2017 13:01:19 -0700 (PDT)
X-BeenThere: std-proposals@isocpp.org
Original-Received: by 10.157.17.116 with SMTP id p49ls5385743otp.4.gmail; Fri, 14 Apr
 2017 13:01:18 -0700 (PDT)
X-Received: by 10.157.17.171 with SMTP id v40mr199354otf.11.1492200078127;
        Fri, 14 Apr 2017 13:01:18 -0700 (PDT)
In-Reply-To: <4259d7dc-f060-dc27-5004-37bf4726e456@wanadoo.fr>
X-Original-Sender: 3dw4rd@verizon.net
Precedence: list
Mailing-list: list std-proposals@isocpp.org; contact std-proposals+owners@isocpp.org
List-ID: <std-proposals.isocpp.org>
X-Google-Group-Id: 399137483710
List-Post: <https://groups.google.com/a/isocpp.org/group/std-proposals/post>, <mailto:std-proposals@isocpp.org>
List-Help: <https://support.google.com/a/isocpp.org/bin/topic.py?topic=25838>, <mailto:std-proposals+help@isocpp.org>
List-Archive: <https://groups.google.com/a/isocpp.org/group/std-proposals/>
List-Subscribe: <https://groups.google.com/a/isocpp.org/group/std-proposals/subscribe>,
 <mailto:std-proposals+subscribe@isocpp.org>
List-Unsubscribe: <mailto:googlegroups-manage+399137483710+unsubscribe@googlegroups.com>,
 <https://groups.google.com/a/isocpp.org/group/std-proposals/subscribe>
Xref: news.gmane.org gmane.comp.lang.c++.isocpp.proposals:32091
Archived-At: <http://permalink.gmane.org/gmane.comp.lang.c++.isocpp.proposals/32091>

------=_Part_1227_1652640001.1492200077632
Content-Type: multipart/alternative; 
	boundary="----=_Part_1228_1846414457.1492200077635"

------=_Part_1228_1846414457.1492200077635
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: quoted-printable



On Friday, April 14, 2017 at 1:02:02 PM UTC-4, Vicente J. Botet Escriba=20
wrote:
>
> Le 14/04/2017 =C3=A0 00:11, 3dw...@verizon.net <javascript:> a =C3=A9crit=
 :
>
> In many uses of std::complex
> one wants to capture the real and imaginary parts in separate variables=
=20
> either to use them in subsequent calculations or to modify them=20
> individually.
> There are many options:
>
> These options reflect an over-encapsulation of std::complex, which=20
> everyone agrees is a struct with two floating point numbers, real part an=
d=20
> imaginary part, in that order.
> Attempting to use a decomposition declaration for a complex number is an=
=20
> error because of the pretension (ostensibly for C compatibility) the=20
> complex numbers are opaque.
>
> Humm, it is not so opaque as you can get the representation as a c-array.
>
> This means that we should already be able to apply structured binding=20
> using the cast
>
>     auto& [p, q] =3D reinterpret_cast<Tp(&)[2]>(z);
>

This is certainly legal now.  That's how I implement this.  It's just fugly=
=20
and obscure for users.


> Nevertheles I agree with you that your proposal makes this cleaner and=20
> more explicit. Complex should be a ProductType.
>
>
> The rvalue and lvalue decomposition of std::complex can be accomplished=
=20
> with a simple pure-library extension:
> Provide a tuple interface to std::complex.
>
>   // Tuple interface to class template complex.
> #define __cxx_lib_tuple_complex 201705
>
>   // Declare tuple_size.
>   template<typename RealTp>
>     class tuple_size;
>
>   // Partial specialization for std::complex.
>   template<typename RealTp>
>     struct tuple_size<std::complex<RealTp>>
>     : public integral_constant<std::size_t, 2> { };
>
>   // Declare tuple_element.
>   template<std::size_t _Int, typename RealTp>
>     class tuple_element;
>
>   // Partial specialization for std::complex.
>   template<std::size_t _Int, typename RealTp>
>     struct tuple_element<_Int, std::complex<RealTp>>
>     {
>       static_assert(_Int < 2, "index is out of bounds");
>       typedef RealTp type;
>     };
>
>   // Decompose complex as rvalues.
>   template<std::size_t _Int, typename RealTp>
>     constexpr const RealTp
>     get(const std::complex<RealTp>& z)
>     {
>       static_assert(_Int < 2, "index is out of bounds");
>       return _Int =3D=3D 0 ? z.real() : z.imag();
>     }
>
>   // Decompose complex as lvalues.
>   template<std::size_t _Int, typename RealTp>
>     constexpr RealTp&
>     get(std::complex<RealTp>& z)
>     {
>       static_assert(_Int < 2, "index is out of bounds");
>       auto w =3D reinterpret_cast<RealTp(&)[2]>(z);
>       return _Int =3D=3D 0 ? w[0] : w[1];
>     }
>
>
> I believed that this reinterpret_cast was UB, but as you note below, it i=
s=20
> defined by the standard.
>
>
> Then we have the following behavior:
>
> template<typename Tp>
>   void
>   test_complex_decomp()
>   {
>     std::complex<Tp> z(1, 2);
>
>     auto [x, y] =3D z;
>     std::cout << "z =3D " << z << '\n';
>     std::cout << "z parts:" << ' ' << x << ' ' << y << '\n';
>
> I'm not sure if you believe this implies a call to get to decomponse as=
=20
> rvalues, but it isn't.
> It just copies the complex to a temporary, and then calls get on this=20
> temporary.
>

The z, x, y part is lvalue decomp.
..=20

>
>     z.real(3);
>     z.imag(4);
>     std::cout << "z =3D " << z << '\n';
>     std::cout << "z parts:" << ' ' << x << ' ' << y << '\n';
>
>     std::complex<Tp> w(1, 2);
>     std::cout << "w =3D " << w << '\n';
>     auto& [p, q] =3D w;
>
> I'm not sure if you believe this implies a call to get to decomponse as=
=20
> lvalues, but it isn't.
> It just takes store a reference to the complex in a temporary, and then=
=20
> calls get on this temporary reference.
>

The w, p, q part is rvalue decomp.
=20

>
>     w.real(3);
>     w.imag(4);
>     std::cout << "w =3D " << w << '\n';
>     std::cout << "w parts:" << ' ' << p << ' ' << q << '\n';
>
>     p =3D -5;
>     q =3D -6;
>     std::cout << "w =3D " << w << '\n';
>     std::cout << "w parts:" << ' ' << p << ' ' << q << '\n';
>
>     return;
>   }
>
> int
> main()
> {
>   test_complex_decomp<double>();
>   return 0;
> }
>
>
>
> -------------------
> z =3D (1,2)
> z parts: 1 2
> z =3D (3,4)
> z parts: 1 2
> w =3D (1,2)
> w =3D (3,4)
> w parts: 3 4
> w =3D (-5,-6)
> w parts: -5 -6
> -------------------
>
> The static cast, ugly as it is, is required to be valid by conforming=20
> implementations of complex.
>
> Are you talking of the reinterpret_cast?
>

Yes, reinterpret_cast. sorry.
=20

> 29.5 Complex numbers [complex.numbers] p4, specifically 4.1-4.3.
> This solution elegantly isolates user code from this wart.
>
> I believe that you need const/non const lvalue/rvalue decomposition, but=
=20
> maybe I'm wrong.
>
>   template<std::size_t _Int, typename RealTp>
>     constexpr const RealTp&&
>     get(const std::complex<RealTp>&& z)
>     {
>       static_assert(_Int < 2, "index is out of bounds");
>       return _Int =3D=3D 0 ? z.real() : z.imag();
>     }
>
> Not sure about this one.  I think it just might not be useful.=20

>
>   template<std::size_t _Int, typename RealTp>
>     constexpr RealTp&&
>     get(std::complex<RealTp>&& z)
>     {
>       static_assert(_Int < 2, "index is out of bounds");
>       return _Int =3D=3D 0 ? z.real() : z.imag();
>     }
>

I think you're right here.  std::array has at least this one.
=20

>   // Decompose complex as lvalues.
>
   // Decompose complex as rvalues.

>   template<std::size_t _Int, typename RealTp>
>     constexpr RealTp&
>     get(std::complex<RealTp>& z)
>     {
>       static_assert(_Int < 2, "index is out of bounds");
>       auto w =3D reinterpret_cast<RealTp(&)[2]>(z);
>       return _Int =3D=3D 0 ? w[0] : w[1];
>     }
>
>   // Decompose complex as lvalues.
>   template<std::size_t _Int, typename RealTp>
>     constexpr RealTp const&
>     get(const std::complex<RealTp>& z)
>     {
>       static_assert(_Int < 2, "index is out of bounds");
>       auto w =3D reinterpret_cast<RealTp const(&)[2]>(z);
>       return _Int =3D=3D 0 ? w[0] : w[1];
>     }
>
> =20
Thank you for looking this over.
Ed

=20

> Vicente
>
=20
=20

--=20
You received this message because you are subscribed to the Google Groups "=
ISO C++ Standard - Future Proposals" group.
To unsubscribe from this group and stop receiving emails from it, send an e=
mail to std-proposals+unsubscribe@isocpp.org.
To post to this group, send email to std-proposals@isocpp.org.
To view this discussion on the web visit https://groups.google.com/a/isocpp=
..org/d/msgid/std-proposals/5fc8b8b9-c0f6-4620-b54a-62acde6cb7f0%40isocpp.or=
g.

------=_Part_1228_1846414457.1492200077635
Content-Type: text/html; charset=UTF-8
Content-Transfer-Encoding: quoted-printable

<div dir=3D"ltr"><br><br>On Friday, April 14, 2017 at 1:02:02 PM UTC-4, Vic=
ente J. Botet Escriba wrote:<blockquote class=3D"gmail_quote" style=3D"marg=
in: 0;margin-left: 0.8ex;border-left: 1px #ccc solid;padding-left: 1ex;">
 =20
   =20
 =20
  <div bgcolor=3D"#FFFFFF" text=3D"#000000">
    <div>Le 14/04/2017 =C3=A0 00:11,
      <a href=3D"javascript:" target=3D"_blank" gdf-obfuscated-mailto=3D"AC=
xwaUT8DAAJ" rel=3D"nofollow" onmousedown=3D"this.href=3D&#39;javascript:&#3=
9;;return true;" onclick=3D"this.href=3D&#39;javascript:&#39;;return true;"=
>3dw...@verizon.net</a> a =C3=A9crit=C2=A0:<br>
    </div>
    <blockquote type=3D"cite">
      <div dir=3D"ltr">In many uses of std::complex<br>
        one wants to capture the real and imaginary parts in separate
        variables either to use them in subsequent calculations or to
        modify them individually.<br>
        There are many options:<br>
        <br>
        These options reflect an over-encapsulation of std::complex,
        which everyone agrees is a struct with two floating point
        numbers, real part and imaginary part, in that order.<br>
        Attempting to use a decomposition declaration for a complex
        number is an error because of the pretension (ostensibly for C
        compatibility) the complex numbers are opaque.<br>
      </div>
    </blockquote>
    Humm, it is not so opaque as you can get the representation as a
    c-array.<br>
    <br>
    This means that we should already be able to apply structured
    binding using the cast<br>
    <br>
    <code><span style=3D"color:#000">=C2=A0 =C2=A0 </span><span style=3D"co=
lor:#008">auto</span><span style=3D"color:#660">&amp;</span><span style=3D"=
color:#000"> </span><span style=3D"color:#660">[</span><span style=3D"color=
:#000">p</span><span style=3D"color:#660">,</span><span style=3D"color:#000=
"> q</span><span style=3D"color:#660">]</span><span style=3D"color:#000"> <=
/span><span style=3D"color:#660">=3D</span><span style=3D"color:#000"> </sp=
an></code><code><span style=3D"color:#000"><code><span style=3D"color:#000"=
></span><span style=3D"color:#008">reinterpret_cast</span><span style=3D"co=
lor:#660">&lt;</span><span style=3D"color:#606">Tp</span><span style=3D"col=
or:#660">(&amp;)[</span><span style=3D"color:#066">2</span><span style=3D"c=
olor:#660">]&gt;(</span><span style=3D"color:#000">z</span><span style=3D"c=
olor:#660">)</span></code></span><span style=3D"color:#660">;</span><span s=
tyle=3D"color:#000"><br></span></code></div></blockquote><div><br>This is c=
ertainly legal now.=C2=A0 That&#39;s how I implement this.=C2=A0 It&#39;s j=
ust fugly and obscure for users.<br><br></div><blockquote class=3D"gmail_qu=
ote" style=3D"margin: 0;margin-left: 0.8ex;border-left: 1px #ccc solid;padd=
ing-left: 1ex;"><div bgcolor=3D"#FFFFFF" text=3D"#000000"><code><span style=
=3D"color:#000">
      </span></code><br>
    Nevertheles I agree with you that your proposal makes this cleaner
    and more explicit. Complex should be a ProductType.<br>
    <blockquote type=3D"cite">
      <div dir=3D"ltr"><br>
        The rvalue and lvalue decomposition of std::complex can be
        accomplished with a simple pure-library extension:<br>
        Provide a tuple interface to std::complex.<br>
        <br>
        <div style=3D"background-color:rgb(250,250,250);border-color:rgb(18=
7,187,187);border-style:solid;border-width:1px"><code>
            <div><span style=3D"color:#000">=C2=A0 </span><span style=3D"co=
lor:#800">// Tuple interface to
                class template complex.</span><span style=3D"color:#000"><b=
r>
              </span><span style=3D"color:#800">#define</span><span style=
=3D"color:#000">
                __cxx_lib_tuple_complex </span><span style=3D"color:#066">2=
01705</span><span style=3D"color:#000"><br>
                <br>
                =C2=A0 </span><span style=3D"color:#800">// Declare tuple_s=
ize.</span><span style=3D"color:#000"><br>
                =C2=A0 </span><span style=3D"color:#008">template</span><sp=
an style=3D"color:#660">&lt;</span><span style=3D"color:#008">typename</spa=
n><span style=3D"color:#000"> </span><span style=3D"color:#606">RealTp</spa=
n><span style=3D"color:#660">&gt;</span><span style=3D"color:#000"><br>
                =C2=A0 =C2=A0 </span><span style=3D"color:#008">class</span=
><span style=3D"color:#000">
                tuple_size</span><span style=3D"color:#660">;</span><span s=
tyle=3D"color:#000"><br>
                <br>
                =C2=A0 </span><span style=3D"color:#800">// Partial special=
ization for
                std::complex.</span><span style=3D"color:#000"><br>
                =C2=A0 </span><span style=3D"color:#008">template</span><sp=
an style=3D"color:#660">&lt;</span><span style=3D"color:#008">typename</spa=
n><span style=3D"color:#000"> </span><span style=3D"color:#606">RealTp</spa=
n><span style=3D"color:#660">&gt;</span><span style=3D"color:#000"><br>
                =C2=A0 =C2=A0 </span><span style=3D"color:#008">struct</spa=
n><span style=3D"color:#000">
                tuple_size</span><span style=3D"color:#660">&lt;</span><spa=
n style=3D"color:#000">std</span><span style=3D"color:#660">::</span><span =
style=3D"color:#000">complex</span><span style=3D"color:#660">&lt;</span><s=
pan style=3D"color:#606">RealTp</span><span style=3D"color:#660"><wbr>&gt;&=
gt;</span><span style=3D"color:#000"><br>
                =C2=A0 =C2=A0 </span><span style=3D"color:#660">:</span><sp=
an style=3D"color:#000"> </span><span style=3D"color:#008">public</span><sp=
an style=3D"color:#000">
                integral_constant</span><span style=3D"color:#660">&lt;</sp=
an><span style=3D"color:#000">std</span><span style=3D"color:#660">::</span=
><span style=3D"color:#000">size_t</span><span style=3D"color:#660">,</span=
><span style=3D"color:#000"> </span><span style=3D"color:#066">2</span><spa=
n style=3D"color:#660">&gt;</span><span style=3D"color:#000"> </span><span =
style=3D"color:#660">{</span><span style=3D"color:#000"> </span><span style=
=3D"color:#660">};</span><span style=3D"color:#000"><br>
                <br>
                =C2=A0 </span><span style=3D"color:#800">// Declare tuple_e=
lement.</span><span style=3D"color:#000"><br>
                =C2=A0 </span><span style=3D"color:#008">template</span><sp=
an style=3D"color:#660">&lt;</span><span style=3D"color:#000">std</span><sp=
an style=3D"color:#660">::</span><span style=3D"color:#000">size_t
                _Int</span><span style=3D"color:#660">,</span><span style=
=3D"color:#000"> </span><span style=3D"color:#008">typename</span><span sty=
le=3D"color:#000"> </span><span style=3D"color:#606">RealTp</span><span sty=
le=3D"color:#660">&gt;</span><span style=3D"color:#000"><br>
                =C2=A0 =C2=A0 </span><span style=3D"color:#008">class</span=
><span style=3D"color:#000">
                tuple_element</span><span style=3D"color:#660">;</span><spa=
n style=3D"color:#000"><br>
                <br>
                =C2=A0 </span><span style=3D"color:#800">// Partial special=
ization for
                std::complex.</span><span style=3D"color:#000"><br>
                =C2=A0 </span><span style=3D"color:#008">template</span><sp=
an style=3D"color:#660">&lt;</span><span style=3D"color:#000">std</span><sp=
an style=3D"color:#660">::</span><span style=3D"color:#000">size_t
                _Int</span><span style=3D"color:#660">,</span><span style=
=3D"color:#000"> </span><span style=3D"color:#008">typename</span><span sty=
le=3D"color:#000"> </span><span style=3D"color:#606">RealTp</span><span sty=
le=3D"color:#660">&gt;</span><span style=3D"color:#000"><br>
                =C2=A0 =C2=A0 </span><span style=3D"color:#008">struct</spa=
n><span style=3D"color:#000">
                tuple_element</span><span style=3D"color:#660">&lt;</span><=
span style=3D"color:#000">_Int</span><span style=3D"color:#660">,</span><sp=
an style=3D"color:#000"> std</span><span style=3D"color:#660">::</span><spa=
n style=3D"color:#000">complex</span><span style=3D"color:#660">&lt;</span>=
<span style=3D"color:#606">RealTp</span><span style=3D"color:#660">&gt;&gt;=
</span><span style=3D"color:#000"><br>
                =C2=A0 =C2=A0 </span><span style=3D"color:#660">{</span><sp=
an style=3D"color:#000"><br>
                =C2=A0 =C2=A0 =C2=A0 </span><span style=3D"color:#008">stat=
ic_assert</span><span style=3D"color:#660">(</span><span style=3D"color:#00=
0">_Int </span><span style=3D"color:#660">&lt;</span><span style=3D"color:#=
000"> </span><span style=3D"color:#066">2</span><span style=3D"color:#660">=
,</span><span style=3D"color:#000"> </span><span style=3D"color:#080">&quot=
;index
                is out of bounds&quot;</span><span style=3D"color:#660">);<=
/span><span style=3D"color:#000"><br>
                =C2=A0 =C2=A0 =C2=A0 </span><span style=3D"color:#008">type=
def</span><span style=3D"color:#000"> </span><span style=3D"color:#606">Rea=
lTp</span><span style=3D"color:#000"> type</span><span style=3D"color:#660"=
>;</span><span style=3D"color:#000"><br>
                =C2=A0 =C2=A0 </span><span style=3D"color:#660">};</span><s=
pan style=3D"color:#000"><br>
                <br>
                =C2=A0 </span><span style=3D"color:#800">// Decompose compl=
ex as
                rvalues.</span><span style=3D"color:#000"><br>
                =C2=A0 </span><span style=3D"color:#008">template</span><sp=
an style=3D"color:#660">&lt;</span><span style=3D"color:#000">std</span><sp=
an style=3D"color:#660">::</span><span style=3D"color:#000">size_t
                _Int</span><span style=3D"color:#660">,</span><span style=
=3D"color:#000"> </span><span style=3D"color:#008">typename</span><span sty=
le=3D"color:#000"> </span><span style=3D"color:#606">RealTp</span><span sty=
le=3D"color:#660">&gt;</span><span style=3D"color:#000"><br>
                =C2=A0 =C2=A0 </span><span style=3D"color:#008">constexpr</=
span><span style=3D"color:#000"> </span><span style=3D"color:#008">const</s=
pan><span style=3D"color:#000"> </span><span style=3D"color:#606">RealTp</s=
pan><span style=3D"color:#000"><br>
                =C2=A0 =C2=A0 </span><span style=3D"color:#008">get</span><=
span style=3D"color:#660">(</span><span style=3D"color:#008">const</span><s=
pan style=3D"color:#000"> std</span><span style=3D"color:#660">::</span><sp=
an style=3D"color:#000">complex</span><span style=3D"color:#660">&lt;</span=
><span style=3D"color:#606">RealTp</span><span style=3D"color:#660">&gt;&am=
p;</span><span style=3D"color:#000"> z</span><span style=3D"color:#660">)</=
span><span style=3D"color:#000"><br>
                =C2=A0 =C2=A0 </span><span style=3D"color:#660">{</span><sp=
an style=3D"color:#000"><br>
                =C2=A0 =C2=A0 =C2=A0 </span><span style=3D"color:#008">stat=
ic_assert</span><span style=3D"color:#660">(</span><span style=3D"color:#00=
0">_Int </span><span style=3D"color:#660">&lt;</span><span style=3D"color:#=
000"> </span><span style=3D"color:#066">2</span><span style=3D"color:#660">=
,</span><span style=3D"color:#000"> </span><span style=3D"color:#080">&quot=
;index
                is out of bounds&quot;</span><span style=3D"color:#660">);<=
/span><span style=3D"color:#000"><br>
                =C2=A0 =C2=A0 =C2=A0 </span><span style=3D"color:#008">retu=
rn</span><span style=3D"color:#000"> _Int </span><span style=3D"color:#660"=
>=3D=3D</span><span style=3D"color:#000"> </span><span style=3D"color:#066"=
>0</span><span style=3D"color:#000"> </span><span style=3D"color:#660">?</s=
pan><span style=3D"color:#000"> z</span><span style=3D"color:#660">.</span>=
<span style=3D"color:#000">real</span><span style=3D"color:#660">()</span><=
span style=3D"color:#000"> </span><span style=3D"color:#660">:</span><span =
style=3D"color:#000"> z</span><span style=3D"color:#660">.</span><span styl=
e=3D"color:#000">imag</span><span style=3D"color:#660">();</span><span styl=
e=3D"color:#000"><br>
                =C2=A0 =C2=A0 </span><span style=3D"color:#660">}</span><sp=
an style=3D"color:#000"><br>
                <br>
                =C2=A0 </span><span style=3D"color:#800">// Decompose compl=
ex as
                lvalues.</span><span style=3D"color:#000"><br>
                =C2=A0 </span><span style=3D"color:#008">template</span><sp=
an style=3D"color:#660">&lt;</span><span style=3D"color:#000">std</span><sp=
an style=3D"color:#660">::</span><span style=3D"color:#000">size_t
                _Int</span><span style=3D"color:#660">,</span><span style=
=3D"color:#000"> </span><span style=3D"color:#008">typename</span><span sty=
le=3D"color:#000"> </span><span style=3D"color:#606">RealTp</span><span sty=
le=3D"color:#660">&gt;</span><span style=3D"color:#000"><br>
                =C2=A0 =C2=A0 </span><span style=3D"color:#008">constexpr</=
span><span style=3D"color:#000"> </span><span style=3D"color:#606">RealTp</=
span><span style=3D"color:#660">&amp;</span><span style=3D"color:#000"><br>
                =C2=A0 =C2=A0 </span><span style=3D"color:#008">get</span><=
span style=3D"color:#660">(</span><span style=3D"color:#000">std</span><spa=
n style=3D"color:#660">::</span><span style=3D"color:#000">complex</span><s=
pan style=3D"color:#660">&lt;</span><span style=3D"color:#606">RealTp</span=
><span style=3D"color:#660">&gt;&amp;</span><span style=3D"color:#000"> z</=
span><span style=3D"color:#660">)</span><span style=3D"color:#000"><br>
                =C2=A0 =C2=A0 </span><span style=3D"color:#660">{</span><sp=
an style=3D"color:#000"><br>
                =C2=A0 =C2=A0 =C2=A0 </span><span style=3D"color:#008">stat=
ic_assert</span><span style=3D"color:#660">(</span><span style=3D"color:#00=
0">_Int </span><span style=3D"color:#660">&lt;</span><span style=3D"color:#=
000"> </span><span style=3D"color:#066">2</span><span style=3D"color:#660">=
,</span><span style=3D"color:#000"> </span><span style=3D"color:#080">&quot=
;index
                is out of bounds&quot;</span><span style=3D"color:#660">);<=
/span><span style=3D"color:#000"><br>
                =C2=A0 =C2=A0 =C2=A0 </span><span style=3D"color:#008">auto=
</span><span style=3D"color:#000"> w </span><span style=3D"color:#660">=3D<=
/span><span style=3D"color:#000"> </span><span style=3D"color:#008">reinter=
pret_cast</span><span style=3D"color:#660">&lt;</span><span style=3D"color:=
#606">RealTp</span><span style=3D"color:#660">(&amp;)[</span><span style=3D=
"color:#066">2</span><span style=3D"color:#660">]&gt;<wbr>(</span><span sty=
le=3D"color:#000">z</span><span style=3D"color:#660">);</span><span style=
=3D"color:#000"><br>
                =C2=A0 =C2=A0 =C2=A0 </span><span style=3D"color:#008">retu=
rn</span><span style=3D"color:#000"> _Int </span><span style=3D"color:#660"=
>=3D=3D</span><span style=3D"color:#000"> </span><span style=3D"color:#066"=
>0</span><span style=3D"color:#000"> </span><span style=3D"color:#660">?</s=
pan><span style=3D"color:#000"> w</span><span style=3D"color:#660">[</span>=
<span style=3D"color:#066">0</span><span style=3D"color:#660">]</span><span=
 style=3D"color:#000"> </span><span style=3D"color:#660">:</span><span styl=
e=3D"color:#000"> w</span><span style=3D"color:#660">[</span><span style=3D=
"color:#066">1</span><span style=3D"color:#660">];</span><span style=3D"col=
or:#000"><br>
                =C2=A0 =C2=A0 </span><span style=3D"color:#660">}</span><sp=
an style=3D"color:#000"><br>
                <br>
              </span></div>
          </code></div>
        <br>
      </div>
    </blockquote>
    I believed that this reinterpret_cast was UB, but as you note below,
    it is defined by the standard.<br>
    <br>
    <blockquote type=3D"cite">
      <div dir=3D"ltr"><br>
        Then we have the following behavior:<br>
        <br>
        <div style=3D"background-color:rgb(250,250,250);border-color:rgb(18=
7,187,187);border-style:solid;border-width:1px"><code>
            <div><span style=3D"color:#008">template</span><span style=3D"c=
olor:#660">&lt;</span><span style=3D"color:#008">typename</span><span style=
=3D"color:#000"> </span><span style=3D"color:#606">Tp</span><span style=3D"=
color:#660">&gt;</span><span style=3D"color:#000"><br>
                =C2=A0 </span><span style=3D"color:#008">void</span><span s=
tyle=3D"color:#000"><br>
                =C2=A0 test_complex_decomp</span><span style=3D"color:#660"=
>()</span><span style=3D"color:#000"><br>
                =C2=A0 </span><span style=3D"color:#660">{</span><span styl=
e=3D"color:#000"><br>
                =C2=A0 =C2=A0 std</span><span style=3D"color:#660">::</span=
><span style=3D"color:#000">complex</span><span style=3D"color:#660">&lt;</=
span><span style=3D"color:#606">Tp</span><span style=3D"color:#660">&gt;</s=
pan><span style=3D"color:#000"> z</span><span style=3D"color:#660">(</span>=
<span style=3D"color:#066">1</span><span style=3D"color:#660">,</span><span=
 style=3D"color:#000"> </span><span style=3D"color:#066">2</span><span styl=
e=3D"color:#660">);</span><span style=3D"color:#000"><br>
                <br>
                =C2=A0 =C2=A0 </span><span style=3D"color:#008">auto</span>=
<span style=3D"color:#000"> </span><span style=3D"color:#660">[</span><span=
 style=3D"color:#000">x</span><span style=3D"color:#660">,</span><span styl=
e=3D"color:#000"> y</span><span style=3D"color:#660">]</span><span style=3D=
"color:#000"> </span><span style=3D"color:#660">=3D</span><span style=3D"co=
lor:#000"> z</span><span style=3D"color:#660">;</span><span style=3D"color:=
#000"><br>
                =C2=A0 =C2=A0 std</span><span style=3D"color:#660">::</span=
><span style=3D"color:#000">cout </span><span style=3D"color:#660">&lt;&lt;=
</span><span style=3D"color:#000"> </span><span style=3D"color:#080">&quot;=
z =3D &quot;</span><span style=3D"color:#000"> </span><span style=3D"color:=
#660">&lt;&lt;</span><span style=3D"color:#000"> z </span><span style=3D"co=
lor:#660">&lt;&lt;</span><span style=3D"color:#000"> </span><span style=3D"=
color:#080">&#39;\n&#39;</span><span style=3D"color:#660">;</span><span sty=
le=3D"color:#000"><br>
                =C2=A0 =C2=A0 std</span><span style=3D"color:#660">::</span=
><span style=3D"color:#000">cout </span><span style=3D"color:#660">&lt;&lt;=
</span><span style=3D"color:#000"> </span><span style=3D"color:#080">&quot;=
z
                parts:&quot;</span><span style=3D"color:#000"> </span><span=
 style=3D"color:#660">&lt;&lt;</span><span style=3D"color:#000"> </span><sp=
an style=3D"color:#080">&#39; &#39;</span><span style=3D"color:#000"> </spa=
n><span style=3D"color:#660">&lt;&lt;</span><span style=3D"color:#000"> x <=
/span><span style=3D"color:#660">&lt;&lt;</span><span style=3D"color:#000">=
 </span><span style=3D"color:#080">&#39; &#39;</span><span style=3D"color:#=
000"> </span><span style=3D"color:#660">&lt;&lt;</span><span style=3D"color=
:#000"> y </span><span style=3D"color:#660">&lt;&lt;</span><span style=3D"c=
olor:#000"> </span><span style=3D"color:#080">&#39;\n&#39;</span><span styl=
e=3D"color:#660">;</span><span style=3D"color:#000"><br>
                <br>
              </span></div>
          </code></div>
      </div>
    </blockquote>
    <code>I&#39;m not sure if you believe this implies a call to get to
      decomponse as rvalues, but it isn&#39;t.<br>
      It just copies the complex to a temporary, </code><code>and then
      calls get on this temporary.<br></code></div></blockquote><div><br>Th=
e z, x, y part is lvalue decomp.<br>. <br></div><blockquote class=3D"gmail_=
quote" style=3D"margin: 0;margin-left: 0.8ex;border-left: 1px #ccc solid;pa=
dding-left: 1ex;"><div bgcolor=3D"#FFFFFF" text=3D"#000000"><code>
      <br>
    </code>
    <blockquote type=3D"cite">
      <div dir=3D"ltr">
        <div style=3D"background-color:rgb(250,250,250);border-color:rgb(18=
7,187,187);border-style:solid;border-width:1px"><code>
            <div><span style=3D"color:#000">=C2=A0 =C2=A0 z</span><span sty=
le=3D"color:#660">.</span><span style=3D"color:#000">real</span><span style=
=3D"color:#660">(</span><span style=3D"color:#066">3</span><span style=3D"c=
olor:#660">);</span><span style=3D"color:#000"><br>
                =C2=A0 =C2=A0 z</span><span style=3D"color:#660">.</span><s=
pan style=3D"color:#000">imag</span><span style=3D"color:#660">(</span><spa=
n style=3D"color:#066">4</span><span style=3D"color:#660">);</span><span st=
yle=3D"color:#000"><br>
                =C2=A0 =C2=A0 std</span><span style=3D"color:#660">::</span=
><span style=3D"color:#000">cout </span><span style=3D"color:#660">&lt;&lt;=
</span><span style=3D"color:#000"> </span><span style=3D"color:#080">&quot;=
z =3D &quot;</span><span style=3D"color:#000"> </span><span style=3D"color:=
#660">&lt;&lt;</span><span style=3D"color:#000"> z </span><span style=3D"co=
lor:#660">&lt;&lt;</span><span style=3D"color:#000"> </span><span style=3D"=
color:#080">&#39;\n&#39;</span><span style=3D"color:#660">;</span><span sty=
le=3D"color:#000"><br>
                =C2=A0 =C2=A0 std</span><span style=3D"color:#660">::</span=
><span style=3D"color:#000">cout </span><span style=3D"color:#660">&lt;&lt;=
</span><span style=3D"color:#000"> </span><span style=3D"color:#080">&quot;=
z
                parts:&quot;</span><span style=3D"color:#000"> </span><span=
 style=3D"color:#660">&lt;&lt;</span><span style=3D"color:#000"> </span><sp=
an style=3D"color:#080">&#39; &#39;</span><span style=3D"color:#000"> </spa=
n><span style=3D"color:#660">&lt;&lt;</span><span style=3D"color:#000"> x <=
/span><span style=3D"color:#660">&lt;&lt;</span><span style=3D"color:#000">=
 </span><span style=3D"color:#080">&#39; &#39;</span><span style=3D"color:#=
000"> </span><span style=3D"color:#660">&lt;&lt;</span><span style=3D"color=
:#000"> y </span><span style=3D"color:#660">&lt;&lt;</span><span style=3D"c=
olor:#000"> </span><span style=3D"color:#080">&#39;\n&#39;</span><span styl=
e=3D"color:#660">;</span><span style=3D"color:#000"><br>
                <br>
                =C2=A0 =C2=A0 std</span><span style=3D"color:#660">::</span=
><span style=3D"color:#000">complex</span><span style=3D"color:#660">&lt;</=
span><span style=3D"color:#606">Tp</span><span style=3D"color:#660">&gt;</s=
pan><span style=3D"color:#000"> w</span><span style=3D"color:#660">(</span>=
<span style=3D"color:#066">1</span><span style=3D"color:#660">,</span><span=
 style=3D"color:#000"> </span><span style=3D"color:#066">2</span><span styl=
e=3D"color:#660">);</span><span style=3D"color:#000"><br>
                =C2=A0 =C2=A0 std</span><span style=3D"color:#660">::</span=
><span style=3D"color:#000">cout </span><span style=3D"color:#660">&lt;&lt;=
</span><span style=3D"color:#000"> </span><span style=3D"color:#080">&quot;=
w =3D &quot;</span><span style=3D"color:#000"> </span><span style=3D"color:=
#660">&lt;&lt;</span><span style=3D"color:#000"> w </span><span style=3D"co=
lor:#660">&lt;&lt;</span><span style=3D"color:#000"> </span><span style=3D"=
color:#080">&#39;\n&#39;</span><span style=3D"color:#660">;</span><span sty=
le=3D"color:#000"><br>
                =C2=A0 =C2=A0 </span><span style=3D"color:#008">auto</span>=
<span style=3D"color:#660">&amp;</span><span style=3D"color:#000"> </span><=
span style=3D"color:#660">[</span><span style=3D"color:#000">p</span><span =
style=3D"color:#660">,</span><span style=3D"color:#000"> q</span><span styl=
e=3D"color:#660">]</span><span style=3D"color:#000"> </span><span style=3D"=
color:#660">=3D</span><span style=3D"color:#000"> w</span><span style=3D"co=
lor:#660">;</span><span style=3D"color:#000"><br>
                <br>
              </span></div>
          </code></div>
      </div>
    </blockquote>
    <code>I&#39;m not sure if you believe this implies a call to get to
      decomponse as lvalues, but it isn&#39;t.<br>
    </code><code>It just takes store a reference to the complex in a
      temporary, and then calls get on this temporary reference.<br></code>=
</div></blockquote><div><br>The w, p, q part is rvalue decomp.<br>=C2=A0<br=
></div><blockquote class=3D"gmail_quote" style=3D"margin: 0;margin-left: 0.=
8ex;border-left: 1px #ccc solid;padding-left: 1ex;"><div bgcolor=3D"#FFFFFF=
" text=3D"#000000"><code>
    </code>
    <blockquote type=3D"cite">
      <div dir=3D"ltr">
        <div style=3D"background-color:rgb(250,250,250);border-color:rgb(18=
7,187,187);border-style:solid;border-width:1px"><code>
            <div><span style=3D"color:#000"></span></div>
          </code></div>
      </div>
    </blockquote>
    <br>
    <blockquote type=3D"cite">
      <div dir=3D"ltr">
        <div style=3D"background-color:rgb(250,250,250);border-color:rgb(18=
7,187,187);border-style:solid;border-width:1px"><code>
            <div><span style=3D"color:#000">=C2=A0 =C2=A0 w</span><span sty=
le=3D"color:#660">.</span><span style=3D"color:#000">real</span><span style=
=3D"color:#660">(</span><span style=3D"color:#066">3</span><span style=3D"c=
olor:#660">);</span><span style=3D"color:#000"><br>
                =C2=A0 =C2=A0 w</span><span style=3D"color:#660">.</span><s=
pan style=3D"color:#000">imag</span><span style=3D"color:#660">(</span><spa=
n style=3D"color:#066">4</span><span style=3D"color:#660">);</span><span st=
yle=3D"color:#000"><br>
                =C2=A0 =C2=A0 std</span><span style=3D"color:#660">::</span=
><span style=3D"color:#000">cout </span><span style=3D"color:#660">&lt;&lt;=
</span><span style=3D"color:#000"> </span><span style=3D"color:#080">&quot;=
w =3D &quot;</span><span style=3D"color:#000"> </span><span style=3D"color:=
#660">&lt;&lt;</span><span style=3D"color:#000"> w </span><span style=3D"co=
lor:#660">&lt;&lt;</span><span style=3D"color:#000"> </span><span style=3D"=
color:#080">&#39;\n&#39;</span><span style=3D"color:#660">;</span><span sty=
le=3D"color:#000"><br>
                =C2=A0 =C2=A0 std</span><span style=3D"color:#660">::</span=
><span style=3D"color:#000">cout </span><span style=3D"color:#660">&lt;&lt;=
</span><span style=3D"color:#000"> </span><span style=3D"color:#080">&quot;=
w
                parts:&quot;</span><span style=3D"color:#000"> </span><span=
 style=3D"color:#660">&lt;&lt;</span><span style=3D"color:#000"> </span><sp=
an style=3D"color:#080">&#39; &#39;</span><span style=3D"color:#000"> </spa=
n><span style=3D"color:#660">&lt;&lt;</span><span style=3D"color:#000"> p <=
/span><span style=3D"color:#660">&lt;&lt;</span><span style=3D"color:#000">=
 </span><span style=3D"color:#080">&#39; &#39;</span><span style=3D"color:#=
000"> </span><span style=3D"color:#660">&lt;&lt;</span><span style=3D"color=
:#000"> q </span><span style=3D"color:#660">&lt;&lt;</span><span style=3D"c=
olor:#000"> </span><span style=3D"color:#080">&#39;\n&#39;</span><span styl=
e=3D"color:#660">;</span><span style=3D"color:#000"><br>
                <br>
                =C2=A0 =C2=A0 p </span><span style=3D"color:#660">=3D</span=
><span style=3D"color:#000"> </span><span style=3D"color:#660">-</span><spa=
n style=3D"color:#066">5</span><span style=3D"color:#660">;</span><span sty=
le=3D"color:#000"><br>
                =C2=A0 =C2=A0 q </span><span style=3D"color:#660">=3D</span=
><span style=3D"color:#000"> </span><span style=3D"color:#660">-</span><spa=
n style=3D"color:#066">6</span><span style=3D"color:#660">;</span><span sty=
le=3D"color:#000"><br>
                =C2=A0 =C2=A0 std</span><span style=3D"color:#660">::</span=
><span style=3D"color:#000">cout </span><span style=3D"color:#660">&lt;&lt;=
</span><span style=3D"color:#000"> </span><span style=3D"color:#080">&quot;=
w =3D &quot;</span><span style=3D"color:#000"> </span><span style=3D"color:=
#660">&lt;&lt;</span><span style=3D"color:#000"> w </span><span style=3D"co=
lor:#660">&lt;&lt;</span><span style=3D"color:#000"> </span><span style=3D"=
color:#080">&#39;\n&#39;</span><span style=3D"color:#660">;</span><span sty=
le=3D"color:#000"><br>
                =C2=A0 =C2=A0 std</span><span style=3D"color:#660">::</span=
><span style=3D"color:#000">cout </span><span style=3D"color:#660">&lt;&lt;=
</span><span style=3D"color:#000"> </span><span style=3D"color:#080">&quot;=
w
                parts:&quot;</span><span style=3D"color:#000"> </span><span=
 style=3D"color:#660">&lt;&lt;</span><span style=3D"color:#000"> </span><sp=
an style=3D"color:#080">&#39; &#39;</span><span style=3D"color:#000"> </spa=
n><span style=3D"color:#660">&lt;&lt;</span><span style=3D"color:#000"> p <=
/span><span style=3D"color:#660">&lt;&lt;</span><span style=3D"color:#000">=
 </span><span style=3D"color:#080">&#39; &#39;</span><span style=3D"color:#=
000"> </span><span style=3D"color:#660">&lt;&lt;</span><span style=3D"color=
:#000"> q </span><span style=3D"color:#660">&lt;&lt;</span><span style=3D"c=
olor:#000"> </span><span style=3D"color:#080">&#39;\n&#39;</span><span styl=
e=3D"color:#660">;</span><span style=3D"color:#000"><br>
                <br>
                =C2=A0 =C2=A0 </span><span style=3D"color:#008">return</spa=
n><span style=3D"color:#660">;</span><span style=3D"color:#000"><br>
                =C2=A0 </span><span style=3D"color:#660">}</span><span styl=
e=3D"color:#000"><br>
                <br>
              </span><span style=3D"color:#008">int</span><span style=3D"co=
lor:#000"><br>
                main</span><span style=3D"color:#660">()</span><span style=
=3D"color:#000"><br>
              </span><span style=3D"color:#660">{</span><span style=3D"colo=
r:#000"><br>
                =C2=A0 test_complex_decomp</span><span style=3D"color:#080"=
>&lt;double&gt;</span><span style=3D"color:#660">();</span><span style=3D"c=
olor:#000"><br>
                =C2=A0 </span><span style=3D"color:#008">return</span><span=
 style=3D"color:#000"> </span><span style=3D"color:#066">0</span><span styl=
e=3D"color:#660">;</span><span style=3D"color:#000"><br>
              </span><span style=3D"color:#660">}</span><span style=3D"colo=
r:#000"><br>
                <br>
              </span></div>
          </code></div>
        <br>
        <br>
        -------------------<br>
        z =3D (1,2)<br>
        z parts: 1 2<br>
        z =3D (3,4)<br>
        z parts: 1 2<br>
        w =3D (1,2)<br>
        w =3D (3,4)<br>
        w parts: 3 4<br>
        w =3D (-5,-6)<br>
        w parts: -5 -6<br>
        -------------------<br>
        <br>
        The static cast, ugly as it is, is required to be valid by
        conforming implementations of complex.<br>
      </div>
    </blockquote>
    Are you talking of the reinterpret_cast?<br></div></blockquote><div><br=
>Yes, reinterpret_cast. sorry.<br>=C2=A0<br></div><blockquote class=3D"gmai=
l_quote" style=3D"margin: 0;margin-left: 0.8ex;border-left: 1px #ccc solid;=
padding-left: 1ex;"><div bgcolor=3D"#FFFFFF" text=3D"#000000">
    <blockquote type=3D"cite">
      <div dir=3D"ltr">29.5 Complex numbers [complex.numbers] p4,
        specifically 4.1-4.3.<br>
        This solution elegantly isolates user code from this wart.</div>
    </blockquote>
    I believe that you need const/non const lvalue/rvalue decomposition,
    but maybe I&#39;m wrong.<br>
    <br>
    <code><span style=3D"color:#000">=C2=A0 </span><span style=3D"color:#00=
8">template</span><span style=3D"color:#660">&lt;</span><span style=3D"colo=
r:#000">std</span><span style=3D"color:#660">::</span><span style=3D"color:=
#000">size_t _Int</span><span style=3D"color:#660">,</span><span style=3D"c=
olor:#000"> </span><span style=3D"color:#008">typename</span><span style=3D=
"color:#000"> </span><span style=3D"color:#606">RealTp</span><span style=3D=
"color:#660">&gt;</span><span style=3D"color:#000"><br>
        =C2=A0 =C2=A0 </span><span style=3D"color:#008">constexpr</span><sp=
an style=3D"color:#000"> </span><span style=3D"color:#008">const</span><spa=
n style=3D"color:#000"> </span><span style=3D"color:#606">RealTp</span><spa=
n style=3D"color:#000">&amp;&amp;<br>
        =C2=A0 =C2=A0 </span><span style=3D"color:#008">get</span><span sty=
le=3D"color:#660">(const </span><span style=3D"color:#000">std</span><span =
style=3D"color:#660">::</span><span style=3D"color:#000">complex</span><spa=
n style=3D"color:#660">&lt;</span><span style=3D"color:#606">RealTp</span><=
span style=3D"color:#660">&gt;&amp;</span><span style=3D"color:#000">&amp; =
z</span><span style=3D"color:#660">)</span><span style=3D"color:#000"><br>
        =C2=A0 =C2=A0 </span><span style=3D"color:#660">{</span><span style=
=3D"color:#000"><br>
        =C2=A0 =C2=A0 =C2=A0 </span><span style=3D"color:#008">static_asser=
t</span><span style=3D"color:#660">(</span><span style=3D"color:#000">_Int =
</span><span style=3D"color:#660">&lt;</span><span style=3D"color:#000"> </=
span><span style=3D"color:#066">2</span><span style=3D"color:#660">,</span>=
<span style=3D"color:#000"> </span><span style=3D"color:#080">&quot;index i=
s out of
        bounds&quot;</span><span style=3D"color:#660">);</span><span style=
=3D"color:#000"><br>
        =C2=A0 =C2=A0 =C2=A0 </span><span style=3D"color:#008">return</span=
><span style=3D"color:#000"> _Int </span><span style=3D"color:#660">=3D=3D<=
/span><span style=3D"color:#000"> </span><span style=3D"color:#066">0</span=
><span style=3D"color:#000"> </span><span style=3D"color:#660">?</span><spa=
n style=3D"color:#000"> z</span><span style=3D"color:#660">.</span><span st=
yle=3D"color:#000">real</span><span style=3D"color:#660">()</span><span sty=
le=3D"color:#000"> </span><span style=3D"color:#660">:</span><span style=3D=
"color:#000"> z</span><span style=3D"color:#660">.</span><span style=3D"col=
or:#000">imag</span><span style=3D"color:#660">();</span><span style=3D"col=
or:#000"><br>
        =C2=A0 =C2=A0 </span><span style=3D"color:#660">}</span><span style=
=3D"color:#000"><br>
        <br></span></code></div></blockquote><div>Not sure about this one.=
=C2=A0 I think it just might not be useful. <br></div><blockquote class=3D"=
gmail_quote" style=3D"margin: 0;margin-left: 0.8ex;border-left: 1px #ccc so=
lid;padding-left: 1ex;"><div bgcolor=3D"#FFFFFF" text=3D"#000000"><code><sp=
an style=3D"color:#000">
      </span></code><br>
    <code><span style=3D"color:#000"><code><span style=3D"color:#000">=C2=
=A0 </span><span style=3D"color:#008">template</span><span style=3D"color:#=
660">&lt;</span><span style=3D"color:#000">std</span><span style=3D"color:#=
660">::</span><span style=3D"color:#000">size_t _Int</span><span style=3D"c=
olor:#660">,</span><span style=3D"color:#000"> </span><span style=3D"color:=
#008">typename</span><span style=3D"color:#000"> </span><span style=3D"colo=
r:#606">RealTp</span><span style=3D"color:#660">&gt;</span><span style=3D"c=
olor:#000"><br>
            =C2=A0 =C2=A0 </span><span style=3D"color:#008">constexpr</span=
><span style=3D"color:#000"> </span><span style=3D"color:#000"></span><span=
 style=3D"color:#606">RealTp&amp;&amp;</span><span style=3D"color:#000"><br=
>
            =C2=A0 =C2=A0 </span><span style=3D"color:#008">get</span><span=
 style=3D"color:#660">(</span><span style=3D"color:#000">std</span><span st=
yle=3D"color:#660">::</span><span style=3D"color:#000">complex</span><span =
style=3D"color:#660">&lt;</span><span style=3D"color:#606">RealTp</span><sp=
an style=3D"color:#660">&gt;&amp;</span><span style=3D"color:#000">&amp; z<=
/span><span style=3D"color:#660">)</span><span style=3D"color:#000"><br>
            =C2=A0 =C2=A0 </span><span style=3D"color:#660">{</span><span s=
tyle=3D"color:#000"><br>
            =C2=A0 =C2=A0 =C2=A0 </span><span style=3D"color:#008">static_a=
ssert</span><span style=3D"color:#660">(</span><span style=3D"color:#000">_=
Int </span><span style=3D"color:#660">&lt;</span><span style=3D"color:#000"=
> </span><span style=3D"color:#066">2</span><span style=3D"color:#660">,</s=
pan><span style=3D"color:#000"> </span><span style=3D"color:#080">&quot;ind=
ex is
            out of bounds&quot;</span><span style=3D"color:#660">);</span><=
span style=3D"color:#000"><br>
            =C2=A0 =C2=A0 =C2=A0 </span><span style=3D"color:#008">return</=
span><span style=3D"color:#000"> _Int </span><span style=3D"color:#660">=3D=
=3D</span><span style=3D"color:#000"> </span><span style=3D"color:#066">0</=
span><span style=3D"color:#000"> </span><span style=3D"color:#660">?</span>=
<span style=3D"color:#000"> z</span><span style=3D"color:#660">.</span><spa=
n style=3D"color:#000">real</span><span style=3D"color:#660">()</span><span=
 style=3D"color:#000"> </span><span style=3D"color:#660">:</span><span styl=
e=3D"color:#000"> z</span><span style=3D"color:#660">.</span><span style=3D=
"color:#000">imag</span><span style=3D"color:#660">();</span><span style=3D=
"color:#000"><br>
            =C2=A0 =C2=A0 </span><span style=3D"color:#660">}</span><span s=
tyle=3D"color:#000"><br></span></code></span></code></div></blockquote><div=
><br>I think you&#39;re right here.=C2=A0 std::array has at least this one.=
<br>=C2=A0</div><blockquote class=3D"gmail_quote" style=3D"margin: 0;margin=
-left: 0.8ex;border-left: 1px #ccc solid;padding-left: 1ex;"><div bgcolor=
=3D"#FFFFFF" text=3D"#000000"><code><span style=3D"color:#000"><code><span =
style=3D"color:#000">
          </span></code>=C2=A0 </span><span style=3D"color:#800">// Decompo=
se complex as lvalues.</span><span style=3D"color:#000"><br></span></code><=
/div></blockquote><div>=C2=A0<code><span style=3D"color:#000">=C2=A0 </span=
><span style=3D"color:#800">// Decompose complex as rvalues.</span><span st=
yle=3D"color:#000"><br></span></code></div><blockquote class=3D"gmail_quote=
" style=3D"margin: 0;margin-left: 0.8ex;border-left: 1px #ccc solid;padding=
-left: 1ex;"><div bgcolor=3D"#FFFFFF" text=3D"#000000"><code><span style=3D=
"color:#000">
        =C2=A0 </span><span style=3D"color:#008">template</span><span style=
=3D"color:#660">&lt;</span><span style=3D"color:#000">std</span><span style=
=3D"color:#660">::</span><span style=3D"color:#000">size_t _Int</span><span=
 style=3D"color:#660">,</span><span style=3D"color:#000"> </span><span styl=
e=3D"color:#008">typename</span><span style=3D"color:#000"> </span><span st=
yle=3D"color:#606">RealTp</span><span style=3D"color:#660">&gt;</span><span=
 style=3D"color:#000"><br>
        =C2=A0 =C2=A0 </span><span style=3D"color:#008">constexpr</span><sp=
an style=3D"color:#000"> </span><span style=3D"color:#606">RealTp</span><sp=
an style=3D"color:#660">&amp;</span><span style=3D"color:#000"><br>
        =C2=A0 =C2=A0 </span><span style=3D"color:#008">get</span><span sty=
le=3D"color:#660">(</span><span style=3D"color:#000">std</span><span style=
=3D"color:#660">::</span><span style=3D"color:#000">complex</span><span sty=
le=3D"color:#660">&lt;</span><span style=3D"color:#606">RealTp</span><span =
style=3D"color:#660">&gt;&amp;</span><span style=3D"color:#000"> z</span><s=
pan style=3D"color:#660">)</span><span style=3D"color:#000"><br>
        =C2=A0 =C2=A0 </span><span style=3D"color:#660">{</span><span style=
=3D"color:#000"><br>
        =C2=A0 =C2=A0 =C2=A0 </span><span style=3D"color:#008">static_asser=
t</span><span style=3D"color:#660">(</span><span style=3D"color:#000">_Int =
</span><span style=3D"color:#660">&lt;</span><span style=3D"color:#000"> </=
span><span style=3D"color:#066">2</span><span style=3D"color:#660">,</span>=
<span style=3D"color:#000"> </span><span style=3D"color:#080">&quot;index i=
s out of
        bounds&quot;</span><span style=3D"color:#660">);</span><span style=
=3D"color:#000"><br>
        =C2=A0 =C2=A0 =C2=A0 </span><span style=3D"color:#008">auto</span><=
span style=3D"color:#000"> w </span><span style=3D"color:#660">=3D</span><s=
pan style=3D"color:#000"> </span><span style=3D"color:#008">reinterpret_cas=
t</span><span style=3D"color:#660">&lt;</span><span style=3D"color:#606">Re=
alTp</span><span style=3D"color:#660">(&amp;)[</span><span style=3D"color:#=
066">2</span><span style=3D"color:#660">]&gt;<wbr>(</span><span style=3D"co=
lor:#000">z</span><span style=3D"color:#660">);</span><span style=3D"color:=
#000"><br>
        =C2=A0 =C2=A0 =C2=A0 </span><span style=3D"color:#008">return</span=
><span style=3D"color:#000"> _Int </span><span style=3D"color:#660">=3D=3D<=
/span><span style=3D"color:#000"> </span><span style=3D"color:#066">0</span=
><span style=3D"color:#000"> </span><span style=3D"color:#660">?</span><spa=
n style=3D"color:#000"> w</span><span style=3D"color:#660">[</span><span st=
yle=3D"color:#066">0</span><span style=3D"color:#660">]</span><span style=
=3D"color:#000"> </span><span style=3D"color:#660">:</span><span style=3D"c=
olor:#000"> w</span><span style=3D"color:#660">[</span><span style=3D"color=
:#066">1</span><span style=3D"color:#660">];</span><span style=3D"color:#00=
0"><br>
        =C2=A0 =C2=A0 </span><span style=3D"color:#660">}</span><span style=
=3D"color:#000"><br>
      </span></code><br>
    <code><span style=3D"color:#000">=C2=A0 </span><span style=3D"color:#80=
0">// Decompose complex as lvalues.</span><span style=3D"color:#000"><br>
        =C2=A0 </span><span style=3D"color:#008">template</span><span style=
=3D"color:#660">&lt;</span><span style=3D"color:#000">std</span><span style=
=3D"color:#660">::</span><span style=3D"color:#000">size_t _Int</span><span=
 style=3D"color:#660">,</span><span style=3D"color:#000"> </span><span styl=
e=3D"color:#008">typename</span><span style=3D"color:#000"> </span><span st=
yle=3D"color:#606">RealTp</span><span style=3D"color:#660">&gt;</span><span=
 style=3D"color:#000"><br>
        =C2=A0 =C2=A0 </span><span style=3D"color:#008">constexpr</span><sp=
an style=3D"color:#000"> </span><span style=3D"color:#606">RealTp</span><sp=
an style=3D"color:#660"> const&amp;</span><span style=3D"color:#000"><br>
        =C2=A0 =C2=A0 </span><span style=3D"color:#008">get</span><span sty=
le=3D"color:#660">(const </span><span style=3D"color:#000">std</span><span =
style=3D"color:#660">::</span><span style=3D"color:#000">complex</span><spa=
n style=3D"color:#660">&lt;</span><span style=3D"color:#606">RealTp</span><=
span style=3D"color:#660">&gt;&amp;</span><span style=3D"color:#000"> z</sp=
an><span style=3D"color:#660">)</span><span style=3D"color:#000"><br>
        =C2=A0 =C2=A0 </span><span style=3D"color:#660">{</span><span style=
=3D"color:#000"><br>
        =C2=A0 =C2=A0 =C2=A0 </span><span style=3D"color:#008">static_asser=
t</span><span style=3D"color:#660">(</span><span style=3D"color:#000">_Int =
</span><span style=3D"color:#660">&lt;</span><span style=3D"color:#000"> </=
span><span style=3D"color:#066">2</span><span style=3D"color:#660">,</span>=
<span style=3D"color:#000"> </span><span style=3D"color:#080">&quot;index i=
s out of
        bounds&quot;</span><span style=3D"color:#660">);</span><span style=
=3D"color:#000"><br>
        =C2=A0 =C2=A0 =C2=A0 </span><span style=3D"color:#008">auto</span><=
span style=3D"color:#000"> w </span><span style=3D"color:#660">=3D</span><s=
pan style=3D"color:#000"> </span><span style=3D"color:#008">reinterpret_cas=
t</span><span style=3D"color:#660">&lt;</span><span style=3D"color:#606">Re=
alTp</span><span style=3D"color:#660"> const(&amp;)[</span><span style=3D"c=
olor:#066">2</span><span style=3D"color:#660">]&gt;(</span><span style=3D"c=
olor:#000">z</span><span style=3D"color:#660">);</span><span style=3D"color=
:#000"><br>
        =C2=A0 =C2=A0 =C2=A0 </span><span style=3D"color:#008">return</span=
><span style=3D"color:#000"> _Int </span><span style=3D"color:#660">=3D=3D<=
/span><span style=3D"color:#000"> </span><span style=3D"color:#066">0</span=
><span style=3D"color:#000"> </span><span style=3D"color:#660">?</span><spa=
n style=3D"color:#000"> w</span><span style=3D"color:#660">[</span><span st=
yle=3D"color:#066">0</span><span style=3D"color:#660">]</span><span style=
=3D"color:#000"> </span><span style=3D"color:#660">:</span><span style=3D"c=
olor:#000"> w</span><span style=3D"color:#660">[</span><span style=3D"color=
:#066">1</span><span style=3D"color:#660">];</span><span style=3D"color:#00=
0"><br>
        =C2=A0 =C2=A0 </span><span style=3D"color:#660">}</span><span style=
=3D"color:#000"><br>
      </span></code><br></div></blockquote><div>=C2=A0</div><div>Thank you =
for looking this over.<br>Ed<br><br>=C2=A0<br></div><blockquote class=3D"gm=
ail_quote" style=3D"margin: 0;margin-left: 0.8ex;border-left: 1px #ccc soli=
d;padding-left: 1ex;"><div bgcolor=3D"#FFFFFF" text=3D"#000000">
    Vicente<br></div></blockquote><div>=C2=A0</div><div>=C2=A0</div></div>

<p></p>

-- <br />
You received this message because you are subscribed to the Google Groups &=
quot;ISO C++ Standard - Future Proposals&quot; group.<br />
To unsubscribe from this group and stop receiving emails from it, send an e=
mail to <a href=3D"mailto:std-proposals+unsubscribe@isocpp.org">std-proposa=
ls+unsubscribe@isocpp.org</a>.<br />
To post to this group, send email to <a href=3D"mailto:std-proposals@isocpp=
..org">std-proposals@isocpp.org</a>.<br />
To view this discussion on the web visit <a href=3D"https://groups.google.c=
om/a/isocpp.org/d/msgid/std-proposals/5fc8b8b9-c0f6-4620-b54a-62acde6cb7f0%=
40isocpp.org?utm_medium=3Demail&utm_source=3Dfooter">https://groups.google.=
com/a/isocpp.org/d/msgid/std-proposals/5fc8b8b9-c0f6-4620-b54a-62acde6cb7f0=
%40isocpp.org</a>.<br />

------=_Part_1228_1846414457.1492200077635--

------=_Part_1227_1652640001.1492200077632--

.
