complex.html

来自「ST20 Embedded Toolset R2.0.5用于开发基于ST20芯片」· HTML 代码 · 共 668 行 · 第 1/2 页

of type <I>double,</I> one that represents the real part
of a complex number and one that represents the imaginary part.
The class differs from its fictitious base class
<CODE><A HREF="#complex">complex</A>&lt;double&gt;</CODE>
only in the constructors it defines.
The first constructor initializes the stored real part to
<CODE>realval</CODE> and the stored imaginary part to <CODE>imagval</CODE>.
The second constructor initializes the stored real part to
<CODE>right.real()</CODE> and the stored imaginary part to
<CODE>right.imag()</CODE>.
The assignment operator stores <CODE>right</CODE> in the stored real part
and zero in the stored imaginary part.</P>

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

<PRE>double_complex <B>exp</B>(const double_complex&amp; left);
float_complex <B>exp</B>(const float_complex&amp; left);</PRE>

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

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

<PRE>class <B>float_complex</B> : public complex&lt;float&gt; {
public:
    <B>float_complex</B>(float realval = 0, float imagval = 0);
    explicit <B>float_complex</B>(const double_complex&amp; right);
    float_complex&amp; <B>operator=</B>(const float right);
    };</PRE>

<P>The class describes an object that stores two objects
of type <I>float,</I> one that represents the real part
of a complex number and one that represents the imaginary part.
The class differs from its fictitious base class
<CODE><A HREF="#complex">complex</A>&lt;float&gt;</CODE>
only in the constructors it defines.
The first constructor initializes the stored real part to
<CODE>realval</CODE> and the stored imaginary part to <CODE>imagval</CODE>.
The second constructor initializes the stored real part to
<CODE>right.real()</CODE> and the stored imaginary part to
<CODE>right.imag()</CODE>.
The assignment operator stores <CODE>right</CODE> in the stored real part
and zero in the stored imaginary part.</P>

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

<PRE>double <B>imag</B>(const double_complex&amp; left);
float <B>imag</B>(const float_complex&amp; left);</PRE>

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

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

<PRE>double_complex <B>log</B>(const double_complex&amp; left);
float_complex <B>log</B>(const float_complex&amp; left);</PRE>

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

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

<PRE>double_complex <B>log10</B>(const double_complex&amp; left);
float_complex <B>log10</B>(const float_complex&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>double <B>norm</B>(const double_complex&amp; left);
float <B>norm</B>(const float_complex&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>bool <B>operator!=</B>(const double_complex&amp; left,
    const double_complex&amp; right);
bool <B>operator!=</B>(const double_complex&amp; left,
    const double&amp; right);
bool <B>operator!=</B>(const double&amp; left,
    const double_complex&amp; right);
bool <B>operator!=</B>(const float_complex&amp; left,
    const float_complex&amp; right);
bool <B>operator!=</B>(const float_complex&amp; left,
    const float&amp; right);
bool <B>operator!=</B>(const float&amp; left,
    const float_complex&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>double_complex <B>operator*</B>(const double_complex&amp; left,
    const double_complex;&amp; right);
double_complex <B>operator*</B>(const double_complex&amp; left,
    const double&amp; right);
double_complex <B>operator*</B>(const double&amp; left,
    const double_complex&amp; right);
float_complex <B>operator*</B>(const float_complex&amp; left,
    const float_complex;&amp; right);
float_complex <B>operator*</B>(const float_complex&amp; left,
    const float&amp; right);
float_complex <B>operator*</B>(const float&amp; left,
    const float_complex&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>double_complex <B>operator+</B>(const double_complex&amp; left,
    const double_complex;&amp; right);
double_complex <B>operator+</B>(const double_complex&amp; left,
    const double&amp; right);
double_complex <B>operator+</B>(const double&amp; left,
    const double_complex&amp; right);
double_complex <B>operator+</B>(const double_complex&amp; left);
float_complex <B>operator+</B>(const float_complex&amp; left,
    const float_complex;&amp; right);
float_complex <B>operator+</B>(const float_complex&amp; left,
    const float&amp; right);
float_complex <B>operator+</B>(const float&amp; left,
    const float_complex&amp; right);
float_complex <B>operator+</B>(const float_complex&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>double_complex <B>operator-</B>(const double_complex&amp; left,
    const double_complex;&amp; right);
double_complex <B>operator-</B>(const double_complex&amp; left,
    const double&amp; right);
double_complex <B>operator-</B>(const double&amp; left,
    const double_complex&amp; right);
double_complex <B>operator-</B>(const double_complex&amp; left);
float_complex <B>operator-</B>(const float_complex&amp; left,
    const float_complex;&amp; right);
float_complex <B>operator-</B>(const float_complex&amp; left,
    const float&amp; right);
float_complex <B>operator-</B>(const float&amp; left,
    const float_complex&amp; right);
float_complex <B>operator-</B>(const float_complex&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>double_complex <B>operator/</B>(const double_complex&amp; left,
    const double_complex;&amp; right);
double_complex <B>operator/</B>(const double_complex&amp; left,
    const double&amp; right);
double_complex <B>operator/</B>(const double&amp; left,
    const double_complex&amp; right);
float_complex <B>operator/</B>(const float_complex&amp; left,
    const float_complex;&amp; right);
float_complex <B>operator/</B>(const float_complex&amp; left,
    const float&amp; right);
float_complex <B>operator/</B>(const float&amp; left,
    const float_complex&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>ostream&amp; <B><A HREF="#operator&lt;&lt;">operator&lt;&lt;</A></B>(ostream&amp; ostr,
    const double_complex&amp; right);
ostream&amp; <B><A HREF="#operator&lt;&lt;">operator&lt;&lt;</A></B>(ostream&amp; ostr,
    const float_complex&amp; right);</PRE>

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

<PRE>ostringstream osstr;
osstr.flags(ostr.flags());
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>bool <B>operator==</B>(const double_complex&amp; left,
    const double_complex&amp; right);
bool <B>operator==</B>(const double_complex&amp; left,
    const double&amp; right);
bool <B>operator==</B>(const double&amp; left,
    const double_complex&amp; right);
bool <B>operator==</B>(const float_complex&amp; left,
    const float_complex&amp; right);
bool <B>operator==</B>(const float_complex&amp; left,
    const float&amp; right);
bool <B>operator==</B>(const float&amp; left,
    const float_complex&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>istream&amp; <B>operator&gt;&gt;</B>(istream&amp; istr,
    double_complex&amp; right);
istream&amp; <B>operator&gt;&gt;</B>(istream&amp; istr,
    float_complex&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 <I>char,</I>
and <CODE>re</CODE> and <CODE>im</CODE> are objects of the same type
as <CODE>right.real()</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>double_complex <B>polar</B>(const double&amp; rho,
    const double&amp; theta = 0);
float_complex <B>polar</B>(const float&amp; rho,
    const float&amp; theta);</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>double_complex <B>pow</B>(const double_complex&amp; left, int right);
double_complex <B>pow</B>(const double_complex&amp; left, const Ty&amp; right);
double_complex <B>pow</B>(const double_complex&amp; left,
    const double_complex&amp; right);
double_complex <B>pow</B>(const Ty&amp; left, const double_complex&amp; right);
float_complex <B>pow</B>(const float_complex&amp; left, int right);
float_complex <B>pow</B>(const float_complex&amp; left, const Ty&amp; right);
float_complex <B>pow</B>(const float_complex&amp; left,
    const float_complex&amp; right);
float_complex <B>pow</B>(const Ty&amp; left, const float_complex&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>double <B>real</B>(const double_complex&amp; left);
float <B>real</B>(const float_complex&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>double_complex <B>sin</B>(const double_complex&amp; left);
float_complex <B>sin</B>(const float_complex&amp; left);</PRE>

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

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

<PRE>double_complex <B>sinh</B>(const double_complex&amp; left);
float_complex <B>sinh</B>(const float_complex&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>double_complex <B>sqrt</B>(const double_complex&amp; left);
float_complex <B>sqrt</B>(const float_complex&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>double_complex <B>tan</B>(const double_complex&amp; left);
float_complex <B>tan</B>(const float_complex&amp; left);</PRE>

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

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

<PRE>double_complex <B>tanh</B>(const double_complex&amp; left);
float_complex <B>tanh</B>(const float_complex&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>