complex.html

ST20 Embedded Toolset R2.0.5用于开发基于ST20芯片机顶盒软件的开发平台,2.0.5版本,国内找不到的.在国外论坛上花了N天才找到!

<PRE>template&lt;class Ty&gt;
    complex&lt;Ty&gt; <B>log10</B>(const complex&lt;Ty&gt;&amp; left);</PRE>

<P>The function returns the base 10
logarithm of <CODE>left</CODE>.
The branch cuts are along the negative real axis.</P>

<H2><A NAME="norm"><CODE>norm</CODE></A></H2>

<PRE>template&lt;class Ty&gt;
    Ty <B>norm</B>(const complex&lt;Ty&gt;&amp; left);</PRE>

<P>The function returns the squared magnitude of <CODE>left</CODE>.</P>

<H2><A NAME="operator!="><CODE>operator!=</CODE></A></H2>

<PRE>template&lt;class Ty&gt;
    bool <B>operator!=</B>(const complex&lt;Ty&gt;&amp; left,
        const complex&lt;Ty&gt;&amp; right);
template&lt;class Ty&gt;
    bool <B>operator!=</B>(const complex&lt;Ty&gt;&amp; left,
        const Ty&amp; right);
template&lt;class Ty&gt;
    bool <B>operator!=</B>(const Ty&amp; left,
        const complex&lt;Ty&gt;&amp; right);</PRE>

<P>The operators each return true only if
<CODE><A HREF="#real">real</A>(left) != real(right) ||
<A HREF="#imag">imag</A>(left) != imag(right)</CODE>.</P>

<H2><A NAME="operator*"><CODE>operator*</CODE></A></H2>

<PRE>template&lt;class Ty&gt;
    complex&lt;Ty&gt; <B>operator*</B>(const complex&lt;Ty&gt;&amp; left,
        const complex&lt;Ty&gt;&amp; right);
template&lt;class Ty&gt;
    complex&lt;Ty&gt; <B>operator*</B>(const complex&lt;Ty&gt;&amp; left,
        const Ty&amp; right);
template&lt;class Ty&gt;
    complex&lt;Ty&gt; <B>operator*</B>(const Ty&amp; left,
        const complex&lt;Ty&gt;&amp; right);</PRE>

<P>The operators each convert both operands to the return type,
then return the complex product
of the converted <CODE>left</CODE> and <CODE>right</CODE>.</P>

<H2><A NAME="operator+"><CODE>operator+</CODE></A></H2>

<PRE>template&lt;class Ty&gt;
    complex&lt;Ty&gt; <B>operator+</B>(const complex&lt;Ty&gt;&amp; left,
        const complex&lt;Ty&gt;&amp; right);
template&lt;class Ty&gt;
    complex&lt;Ty&gt; <B>operator+</B>(const complex&lt;Ty&gt;&amp; left,
        const Ty&amp; right);
template&lt;class Ty&gt;
    complex&lt;Ty&gt; <B>operator+</B>(const Ty&amp; left,
        const complex&lt;Ty&gt;&amp; right);
template&lt;class Ty&gt;
    complex&lt;Ty&gt; <B>operator+</B>(const complex&lt;Ty&gt;&amp; left);</PRE>

<P>The binary operators each convert both operands to the return type,
then return the complex sum
of the converted <CODE>left</CODE> and <CODE>right</CODE>.</P>

<P>The unary operator returns <CODE>left</CODE>.</P>

<H2><A NAME="operator-"><CODE>operator-</CODE></A></H2>

<PRE>template&lt;class Ty&gt;
    complex&lt;Ty&gt; <B>operator-</B>(const complex&lt;Ty&gt;&amp; left,
        const complex&lt;Ty&gt;&amp; right);
template&lt;class Ty&gt;
    complex&lt;Ty&gt; <B>operator-</B>(const complex&lt;Ty&gt;&amp; left,
        const Ty&amp; right);
template&lt;class Ty&gt;
    complex&lt;Ty&gt; <B>operator-</B>(const Ty&amp; left,
        const complex&lt;Ty&gt;&amp; right);
template&lt;class Ty&gt;
    complex&lt;Ty&gt; <B>operator-</B>(const complex&lt;Ty&gt;&amp; left);</PRE>

<P>The binary operators each convert both operands to the return type,
then return the complex difference
of the converted <CODE>left</CODE> and <CODE>right</CODE>.</P>

<P>The unary operator returns a value whose real part is
<CODE>-<A HREF="#real">real</A>(left)</CODE> and whose imaginary part is
<CODE>-<A HREF="#imag">imag</A>(left)</CODE>.</P>

<H2><A NAME="operator/"><CODE>operator/</CODE></A></H2>

<PRE>template&lt;class Ty&gt;
    complex&lt;Ty&gt; <B>operator/</B>(const complex&lt;Ty&gt;&amp; left,
        const complex&lt;Ty&gt;&amp; right);
template&lt;class Ty&gt;
    complex&lt;Ty&gt; <B>operator/</B>(const complex&lt;Ty&gt;&amp; left,
        const Ty&amp; right);
template&lt;class Ty&gt;
    complex&lt;Ty&gt; <B>operator/</B>(const Ty&amp; left,
        const complex&lt;Ty&gt;&amp; right);</PRE>

<P>The operators each convert both operands to the return type,
then return the complex quotient
of the converted <CODE>left</CODE> and <CODE>right</CODE>.</P>

<H2><A NAME="operator&lt;&lt;"><CODE>operator&lt;&lt;</CODE></A></H2>

<PRE>template&lt;class Ty, class Elem, class Tr&gt;
    basic_ostream&lt;Elem, Tr&gt;&amp;
        <B><A HREF="#operator&lt;&lt;">operator&lt;&lt;</A></B>(basic_ostream&lt;Elem, Tr&gt;&amp; ostr,
            const complex&lt;Ty&gt;&amp; right);</PRE>

<P>The template function inserts the complex value <CODE>right</CODE>
in the output stream <CODE>os</CODE>, effectively by executing:</P>

<PRE>basic_ostringstream&lt;Elem, Tr&gt; osstr;
osstr.flags(ostr.flags());
osstr.imbue(ostr.imbue());
osstr.precision(ostr.precision());
osstr &lt;&lt; '(' &lt;&lt; real(right) &lt;&lt; ','
    &lt;&lt; imag(right) &lt;&lt; ')';
ostr &lt;&lt; osstr.str().c_str();</PRE>

<P>Thus, if
<CODE>ostr.<A HREF="ios.html#ios_base::width">width</A>()</CODE> is
greater than zero, any padding occurs either before or after the
parenthesized pair of values, which itself contains no padding.
The function returns <CODE>ostr</CODE>.</P>

<H2><A NAME="operator=="><CODE>operator==</CODE></A></H2>

<PRE>template&lt;class Ty&gt;
    bool <B>operator==</B>(const complex&lt;Ty&gt;&amp; left,
        const complex&lt;Ty&gt;&amp; right);
template&lt;class Ty&gt;
    bool <B>operator==</B>(const complex&lt;Ty&gt;&amp; left,
        const Ty&amp; right);
template&lt;class Ty&gt;
    bool <B>operator==</B>(const Ty&amp; left,
        const complex&lt;Ty&gt;&amp; right);</PRE>

<P>The operators each return true only if
<CODE><A HREF="#real">real</A>(left) == real(right) &amp;&amp;
<A HREF="#imag">imag</A>(left) == imag(right)</CODE>.</P>

<H2><A NAME="operator&gt;&gt;"><CODE>operator&gt;&gt;</CODE></A></H2>

<PRE>template&lt;class Ty, class Elem, class Tr&gt;
    basic_istream&lt;Elem, Tr&gt;&amp;
        <B>operator&gt;&gt;</B>(basic_istream&lt;Elem, Tr&gt;&amp; istr,
            complex&lt;Ty&gt;&amp; right);</PRE>

<P>The template function attempts to extract a complex value
from the input stream <CODE>istr</CODE>, effectively by executing:</P>

<PRE>istr &gt;&gt; ch &amp;&amp; ch == '('
    &amp;&amp; istr &gt;&gt; re &gt;&gt; ch &amp;&amp; ch == ','
    &amp;&amp; istr &gt;&gt; im &gt;&gt; ch &amp;&amp; ch == ')'</PRE>

<P>Here, <CODE>ch</CODE> is an object of type <CODE>Elem</CODE>,
and <CODE>re</CODE> and <CODE>im</CODE> are objects of type <CODE>Ty</CODE>.</P>

<P>If the result of this expression is true, the function stores
<CODE>re</CODE> in the real part and <CODE>im</CODE> in the
imaginary part of <CODE>right</CODE>. In any event, the function
returns <CODE>istr</CODE>.</P>

<H2><A NAME="polar"><CODE>polar</CODE></A></H2>

<PRE>template&lt;class Ty&gt;
    complex&lt;Ty&gt; <B>polar</B>(const Ty&amp; rho,
        const Ty&amp; theta = 0);</PRE>

<P>The function returns the complex value whose magnitude
is <CODE>rho</CODE> and whose phase angle is <CODE>theta</CODE>.</P>

<H2><A NAME="pow"><CODE>pow</CODE></A></H2>

<PRE>template&lt;class Ty&gt;
    complex&lt;Ty&gt; <B>pow</B>(const complex&lt;Ty&gt;&amp; left, int right);
template&lt;class Ty&gt;
    complex&lt;Ty&gt; <B>pow</B>(const complex&lt;Ty&gt;&amp; left,
        const Ty&amp; right);
template&lt;class Ty&gt;
    complex&lt;Ty&gt; <B>pow</B>(const complex&lt;Ty&gt;&amp; left,
        const complex&lt;Ty&gt;&amp; right);
template&lt;class Ty&gt;
    complex&lt;Ty&gt; <B>pow</B>(const Ty&amp; left,
        const complex&lt;Ty&gt;&amp; right);</PRE>

<P>The functions each effectively convert both operands to
the return type, then return the converted
<CODE>left</CODE> to the power <CODE>right</CODE>.
The branch cut for <CODE>left</CODE> is along the negative real axis.</P>

<H2><A NAME="real"><CODE>real</CODE></A></H2>

<PRE>template&lt;class Ty&gt;
    Ty <B>real</B>(const complex&lt;Ty&gt;&amp; left);</PRE>

<P>The function returns the real part of <CODE>left</CODE>.</P>

<H2><A NAME="sin"><CODE>sin</CODE></A></H2>

<PRE>template&lt;class Ty&gt;
    complex&lt;Ty&gt; <B>sin</B>(const complex&lt;Ty&gt;&amp; left);</PRE>

<P>The function returns the sine of <CODE>left</CODE>.</P>

<H2><A NAME="sinh"><CODE>sinh</CODE></A></H2>

<PRE>template&lt;class Ty&gt;
    complex&lt;Ty&gt; <B>sinh</B>(const complex&lt;Ty&gt;&amp; left);</PRE>

<P>The function returns the hyperbolic sine of <CODE>left</CODE>.</P>

<H2><A NAME="sqrt"><CODE>sqrt</CODE></A></H2>

<PRE>template&lt;class Ty&gt;
    complex&lt;Ty&gt; <B>sqrt</B>(const complex&lt;Ty&gt;&amp; left);</PRE>

<P>The function returns the square root of <CODE>left</CODE>,
with phase angle in the half-open interval <CODE>(-pi/2, pi/2]</CODE>.
The branch cuts are along the negative real axis.</P>

<H2><A NAME="__STD_COMPLEX"><CODE>__STD_COMPLEX</CODE></A></H2>

<PRE>#define <B>__STD_COMPLEX</B></PRE>

<P>The macro is defined, with an unspecified expansion, to indicate
compliance with the specifications of this header.</P>

<H2><A NAME="tan"><CODE>tan</CODE></A></H2>

<PRE>template&lt;class Ty&gt;
    complex&lt;Ty&gt; <B>tan</B>(const complex&lt;Ty&gt;&amp; left);</PRE>

<P>The function returns the tangent of <CODE>left</CODE>.</P>

<H2><A NAME="tanh"><CODE>tanh</CODE></A></H2>

<PRE>template&lt;class Ty&gt;
    complex&lt;Ty&gt; <B>tanh</B>(const complex&lt;Ty&gt;&amp; left);</PRE>

<P>The function returns the hyperbolic tangent of <CODE>left</CODE>.</P>

<HR>
<P>See also the
<B><A HREF="index.html#Table of Contents">Table of Contents</A></B> and the
<B><A HREF="_index.html">Index</A></B>.</P>

<P><I>
<A HREF="crit_pjp.html">Copyright</A> &#169; 1992-2002
by P.J. Plauger. All rights reserved.</I></P>

<!--V4.01:1125--></BODY></HTML>