valarray.html

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

stores a reference to an object <CODE>va</CODE> of class
<CODE><A HREF="#valarray">valarray</A>&lt;Ty&gt;</CODE>,
along with an object <CODE>sl</CODE> of class
<CODE><A HREF="#slice">slice</A></CODE> which
describes the sequence of elements to select from the
<CODE>valarray&lt;Ty&gt;</CODE> object.</P>

<P>You construct a <CODE>slice_array&lt;Ty&gt;</CODE> object only
by writing an expression of the form
<CODE><A HREF="#valarray::operator[]">va[sl]</A></CODE>.
The member functions of class <CODE>slice_array</CODE> then
behave like the corresponding function signatures defined
for <CODE>valarray&lt;Ty&gt;</CODE>, except that only the sequence
of selected elements is affected.</P>

<P>The sequence consists of
<CODE>sl.<A HREF="#slice::size">size</A>()</CODE>
elements, where element <CODE>I</CODE> becomes the index
<CODE>sl.<A HREF="#slice::start">start</A>() + I *
sl.<A HREF="#slice::stride">stride</A>()</CODE> within <CODE>va</CODE>.
For example:</P>

<PRE>// va[slice(2, 5, 3)] selects elements with
//   indices 2, 5, 8, 11, 14</PRE>

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

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

<P>The template function returns an object of class
<CODE><A HREF="#valarray">valarray</A>&lt;Ty&gt;</CODE>, each of whose
elements <CODE>I</CODE> is the square root of <CODE>left[I]</CODE>.</P>

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

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

<P>The template function returns an object of class
<CODE><A HREF="#valarray">valarray</A>&lt;Ty&gt;</CODE>, each of whose
elements <CODE>I</CODE> is the tangent of <CODE>left[I]</CODE>.</P>

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

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

<P>The template function returns an object of class
<CODE><A HREF="#valarray">valarray</A>&lt;Ty&gt;</CODE>, each of whose
elements <CODE>I</CODE> is the hyperbolic tangent of <CODE>left[I]</CODE>.</P>

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

<HR>
<P><B><CODE><A HREF="#valarray::apply">apply</A>
&#183; <A HREF="#valarray::cshift">cshift</A>
&#183; <A HREF="#valarray::max">max</A>
&#183; <A HREF="#valarray::min">min</A>
&#183; <A HREF="#valarray::operator!">operator!</A>
&#183; <A HREF="#valarray::operator%=">operator%=</A>
&#183; <A HREF="#valarray::operator&amp;=">operator&amp;=</A>
&#183; <A HREF="#valarray::operator&gt;&gt;=">operator&gt;&gt;=</A>
&#183; <A HREF="#valarray::operator&lt;&lt;=">operator&lt;&lt;=</A>
&#183; <A HREF="#valarray::operator*=">operator*=</A>
&#183; <A HREF="#valarray::operator+">operator+</A>
&#183; <A HREF="#valarray::operator+=">operator+=</A>
&#183; <A HREF="#valarray::operator-">operator-</A>
&#183; <A HREF="#valarray::operator-=">operator-=</A>
&#183; <A HREF="#valarray::operator/=">operator/=</A>
&#183; <A HREF="#valarray::operator=">operator=</A>
&#183; <A HREF="#valarray::operator[]">operator[]</A>
&#183; <A HREF="#valarray::operator^=">operator^=</A>
&#183; <A HREF="#valarray::operator|=">operator|=</A>
&#183; <A HREF="#valarray::operator~">operator~</A>
&#183; <A HREF="#valarray::resize">resize</A>
&#183; <A HREF="#valarray::shift">shift</A>
&#183; <A HREF="#valarray::size">size</A>
&#183; <A HREF="#valarray::sum">sum</A>
&#183; <A HREF="#valarray::valarray">valarray</A>
&#183; <A HREF="#valarray::value_type">value_type</A>
</CODE></B></P>
<HR>

<PRE>template&lt;class Ty&gt;
    class <B>valarray</B> {
public:
    typedef Ty <B><A HREF="#valarray::value_type">value_type</A></B>;

    <B><A HREF="#valarray::valarray">valarray</A></B>();
    explicit <B><A HREF="#valarray::valarray">valarray</A></B>(size_t count);
    <B><A HREF="#valarray::valarray">valarray</A></B>(const Ty&amp; val, size_t count));
    <B><A HREF="#valarray::valarray">valarray</A></B>(const Ty *ptr, size_t count);
    <B><A HREF="#valarray::valarray">valarray</A></B>(const slice_array&lt;Ty&gt;&amp; slicearr);
    <B><A HREF="#valarray::valarray">valarray</A></B>(const gslice_array&lt;Ty&gt;&amp; gslicearr);
    <B><A HREF="#valarray::valarray">valarray</A></B>(const mask_array&lt;Ty&gt;&amp; maskarr);
    <B><A HREF="#valarray::valarray">valarray</A></B>(const indirect_array&lt;Ty&gt;&amp; indarr);

    valarray&lt;Ty&gt;&amp; <B><A HREF="#valarray::operator=">operator=</A></B>(const valarray&lt;Ty&gt;&amp; right);
    valarray&lt;Ty&gt;&amp; <B><A HREF="#valarray::operator=">operator=</A></B>(const Ty&amp; val);
    valarray&lt;Ty&gt;&amp; <B><A HREF="#valarray::operator=">operator=</A></B>(const slice_array&lt;Ty&gt;&amp; slicearr);
    valarray&lt;Ty&gt;&amp; <B><A HREF="#valarray::operator=">operator=</A></B>(const gslice_array&lt;Ty&gt;&amp; gslicearr);
    valarray&lt;Ty&gt;&amp; <B><A HREF="#valarray::operator=">operator=</A></B>(const mask_array&lt;Ty&gt;&amp; maskarr);
    valarray&lt;Ty&gt;&amp; <B><A HREF="#valarray::operator=">operator=</A></B>(const indirect_array&lt;Ty&gt;&amp; indarr);

    Ty&amp; <B><A HREF="#valarray::operator[]">operator[]</A></B>(size_t off);
    slice_array&lt;Ty&gt; <B><A HREF="#valarray::operator[]">operator[]</A></B>(slice slicearr);
    gslice_array&lt;Ty&gt; <B><A HREF="#valarray::operator[]">operator[]</A></B>(const gslice&amp; gslicearr);
    mask_array&lt;Ty&gt; <B><A HREF="#valarray::operator[]">operator[]</A></B>(const valarray&lt;bool&gt;&amp; boolarr);
    indirect_array&lt;Ty&gt;
        <B><A HREF="#valarray::operator[]">operator[]</A></B>(const valarray&lt;size_t&gt;&amp; indarr);

    Ty <B><A HREF="#valarray::operator[]">operator[]</A></B>(size_t off) const;
    valarray&lt;Ty&gt; <B><A HREF="#valarray::operator[]">operator[]</A></B>(slice slicearr) const;
    valarray&lt;Ty&gt; <B><A HREF="#valarray::operator[]">operator[]</A></B>(const gslice&amp; gslicearr) const;
    valarray&lt;Ty&gt;
        <B><A HREF="#valarray::operator[]">operator[]</A></B>(const valarray&lt;bool&gt;&amp; boolarr) const;
    valarray&lt;Ty&gt;
        <B><A HREF="#valarray::operator[]">operator[]</A></B>(const valarray&lt;size_t&gt;&amp; indarr) const;

    valarray&lt;Ty&gt; <B><A HREF="#valarray::operator+">operator+</A></B>() const;
    valarray&lt;Ty&gt; <B><A HREF="#valarray::operator-">operator-</A></B>() const;
    valarray&lt;Ty&gt; <B><A HREF="#valarray::operator~">operator~</A></B>() const;
    valarray&lt;bool&gt; <B><A HREF="#valarray::operator!">operator!</A></B>() const;
    valarray&lt;Ty&gt;&amp; <B><A HREF="#valarray::operator*=">operator*=</A></B>(const valarray&lt;Ty&gt;&amp; right);
    valarray&lt;Ty&gt;&amp; <B><A HREF="#valarray::operator*=">operator*=</A></B>(const Ty&amp; right);
    valarray&lt;Ty&gt;&amp; <B><A HREF="#valarray::operator/=">operator/=</A></B>(const valarray&lt;Ty&gt;&amp; right);
    valarray&lt;Ty&gt;&amp; <B><A HREF="#valarray::operator/=">operator/=</A></B>(const Ty&amp; right);
    valarray&lt;Ty&gt;&amp; <B><A HREF="#valarray::operator%=">operator%=</A></B>(const valarray&lt;Ty&gt;&amp; right);
    valarray&lt;Ty&gt;&amp; <B><A HREF="#valarray::operator%=">operator%=</A></B>(const Ty&amp; right);
    valarray&lt;Ty&gt;&amp; <B><A HREF="#valarray::operator+=">operator+=</A></B>(const valarray&lt;Ty&gt;&amp; right);
    valarray&lt;Ty&gt;&amp; <B><A HREF="#valarray::operator+=">operator+=</A></B>(const Ty&amp; right);
    valarray&lt;Ty&gt;&amp; <B><A HREF="#valarray::operator-=">operator-=</A></B>(const valarray&lt;Ty&gt;&amp; right);
    valarray&lt;Ty&gt;&amp; <B><A HREF="#valarray::operator-=">operator-=</A></B>(const Ty&amp; right);
    valarray&lt;Ty&gt;&amp; <B><A HREF="#valarray::operator^=">operator^=</A></B>(const valarray&lt;Ty&gt;&amp; right);
    valarray&lt;Ty&gt;&amp; <B><A HREF="#valarray::operator^=">operator^=</A></B>(const Ty&amp; right);
    valarray&lt;Ty&gt;&amp; <B><A HREF="#valarray::operator&amp;=">operator&amp;=</A></B>(const valarray&lt;Ty&gt;&amp; right);
    valarray&lt;Ty&gt;&amp; <B><A HREF="#valarray::operator&amp;=">operator&amp;=</A></B>(const Ty&amp; right);
    valarray&lt;Ty&gt;&amp; <B><A HREF="#valarray::operator|=">operator|=</A></B>(const valarray&lt;Ty&gt;&amp; right);
    valarray&lt;Ty&gt;&amp; <B><A HREF="#valarray::operator|=">operator|=</A></B>(const Ty&amp; right);
    valarray&lt;Ty&gt;&amp; <B><A HREF="#valarray::operator&lt;&lt;=">operator&lt;&lt;=</A></B>(const valarray&lt;Ty&gt;&amp; right);
    valarray&lt;Ty&gt;&amp; <B><A HREF="#valarray::operator&lt;&lt;=">operator&lt;&lt;=</A></B>(const Ty&amp; right);
    valarray&lt;Ty&gt;&amp; <B><A HREF="#valarray::operator&gt;&gt;=">operator&gt;&gt;=</A></B>(const valarray&lt;Ty&gt;&amp; right);
    valarray&lt;Ty&gt;&amp; <B><A HREF="#valarray::operator&gt;&gt;=">operator&gt;&gt;=</A></B>(const Ty&amp; right);

    size_t <B><A HREF="#valarray::size">size</A></B>() const;
    Ty <B><A HREF="#valarray::sum">sum</A></B>() const;
    Ty <B><A HREF="#valarray::max">max</A></B>() const;
    Ty <B><A HREF="#valarray::min">min</A></B>() const;
    valarray&lt;Ty&gt; <B><A HREF="#valarray::shift">shift</A></B>(int count) const;
    valarray&lt;Ty&gt; <B><A HREF="#valarray::cshift">cshift</A></B>(int count) const;
    valarray&lt;Ty&gt; <B><A HREF="#valarray::apply">apply</A></B>(Ty func(Ty)) const;
    valarray&lt;Ty&gt; <B><A HREF="#valarray::apply">apply</A></B>(Ty func(const Ty&amp;)) const;
    void <B><A HREF="#valarray::resize">resize</A></B>(size_t newsize);
    void <B><A HREF="#valarray::resize">resize</A></B>(size_t newsize, const Ty&amp; val);
   };</PRE>

<P>The template class describes an object that controls a
varying-length sequence of elements of type <CODE>Ty</CODE>.
The sequence is stored as an array of <CODE>Ty</CODE>.
It differs from template class
<CODE><A HREF="vector.html#vector">vector</A></CODE> in two important
ways:</P>

<UL>
<LI>It defines numerous arithmetic operations between corresponding
elements of <CODE>valarray&lt;Ty&gt;</CODE> objects of the same
type and length, such as <CODE>xarr = cos(yarr) + sin(zarr)</CODE>.</LI>

<LI>It defines a variety of interesting ways to subscript a
<CODE>valarray&lt;Ty&gt;</CODE> object, by overloading
<CODE><A HREF="#valarray::operator[]">operator[]</A></CODE>.</LI>
</UL>

<P>An object of class <CODE>Ty</CODE>:</P>

<UL>
<LI>has a public default constructor, destructor,
copy constructor, and assignment operator -- with
conventional behavior</LI>

<LI>defines the arithmetic operators and math functions, as needed,
that are defined for the floating-point
types -- with conventional behavior</LI>
</UL>

<P>In particular, no subtle differences may exist between copy construction
and default construction followed by assignment. And none of the operations
on objects of class <CODE>Ty</CODE> may throw exceptions.</P>

<H3><A NAME="valarray::apply"><CODE>valarray::apply</CODE></A></H3>

<PRE>valarray&lt;Ty&gt; <B>apply</B>(Ty func(Ty)) const;
valarray&lt;Ty&gt; <B>apply</B>(Ty func(const Ty&amp;)) const;</PRE>

<P>The member function returns an object of class
<CODE><A HREF="#valarray">valarray</A>&lt;Ty&gt;</CODE>, of length
<CODE><A HREF="#valarray::size">size</A>()</CODE>, each of whose
elements <CODE>I</CODE> is <CODE>func((*this)[I])</CODE>.</P>

<H3><A NAME="valarray::cshift"><CODE>valarray::cshift</CODE></A></H3>

<PRE>valarray&lt;Ty&gt; <B>cshift</B>(int count) const;</PRE>

<P>The member function returns an object of class
<CODE><A HREF="#valarray">valarray</A>&lt;Ty&gt;</CODE>, of length
<CODE><A HREF="#valarray::size">size</A>()</CODE>, each of whose
elements <CODE>I</CODE> is <CODE>(*this)[(I + count) % size()]</CODE>.
Thus, if element zero is taken as the leftmost element, a positive
value of <CODE>count</CODE> shifts the elements circularly left <CODE>count</CODE>
places.</P>

<H3><A NAME="valarray::max"><CODE>valarray::max</CODE></A></H3>

<PRE>Ty <B>max</B>() const;</PRE>

<P>The member function returns the value of the largest element
of <CODE>*this</CODE>, which must have nonzero length.
If the length is greater than one, it compares values
by applying <CODE>operator&lt;</CODE>
between pairs of corresponding elements of class <CODE>Ty</CODE>.</P>

<H3><A NAME="valarray::min"><CODE>valarray::min</CODE></A></H3>

<PRE>Ty <B>min</B>() const;</PRE>

<P>The member function returns the value of the smallest element
of <CODE>*this</CODE>, which must have nonzero length.
If the length is greater than one, it compares values
by applying <CODE>operator&lt;</CODE>
between pairs of elements of class <CODE>Ty</CODE>.</P>

<H3><A NAME="valarray::operator!"><CODE>valarray::operator!</CODE></A></H3>

<PRE>valarray&lt;bool&gt; <B>operator!</B>() const;</PRE>

<P>The member operator returns an object of class
<CODE><A HREF="#valarray">valarray</A>&lt;bool&gt;</CODE>, of length
<CODE><A HREF="#valarray::size">size</A>()</CODE>, each of whose
elements <CODE>I</CODE> is <CODE>!(*this)</CODE>.</P>

<H3><A NAME="valarray::operator%="><CODE>valarray::operator%=</CODE></A></H3>

<PRE>valarray&lt;Ty&gt;&amp; <B>operator%=</B>(const valarray&lt;Ty&gt;&amp; right);
valarray&lt;Ty&gt;&amp; <B>operator%=</B>(const Ty&amp; right);</PRE>

<P>The member operator replaces each element <CODE>I</CODE>
of <CODE>*this</CODE> with <CODE>(*this)[I] % right[I]</CODE>.
It returns <CODE>*this</CODE>.</P>

<H3><A NAME="valarray::operator&amp;="><CODE>valarray::operator&amp;=</CODE></A></H3>

<PRE>valarray&lt;Ty&gt;&amp; <B>operator&amp;=</B>(const valarray&lt;Ty&gt;&amp; right);
valarray&lt;Ty&gt;&amp; <B>operator&amp;=</B>(const Ty&amp; right);</PRE>

<P>The member operator replaces each element <CODE>I</CODE>
of <CODE>*this</CODE> with <CODE>(*this)[I] &amp; right[I]</CODE>.
It returns <CODE>*this</CODE>.</P>

<H3><A NAME="valarray::operator&gt;&gt;="><CODE>valarray::operator&gt;&gt;=</CODE></A></H3>

<PRE>valarray&lt;Ty&gt;&amp; <B>operator&gt;&gt;=</B>(const valarray&lt;Ty&gt;&amp; right);
valarray&lt;Ty&gt;&amp; <B>operator&gt;&gt;=</B>(const Ty&amp; right);</PRE>

<P>The member operator replaces each element <CODE>I</CODE>
of <CODE>*this</CODE> with <CODE>(*this)[I] &gt;&gt; right[I]</CODE>.
It returns <CODE>*this</CODE>.</P>

<H3><A NAME="valarray::operator&lt;&lt;="><CODE>valarray::operator&lt;&lt;=</CODE></A></H3>

<PRE>valarray&lt;Ty&gt;&amp; <B>operator&lt;&lt;=</B>(const valarray&lt;Ty&gt;&amp; right);
valarray&lt;Ty&gt;&amp; <B>operator&lt;&lt;=</B>(const Ty&amp; right);</PRE>

<P>The member operator replaces each element <CODE>I</CODE>
of <CODE>*this</CODE> with <CODE>(*this)[I] &lt;&lt; right[I]</CODE>.
It returns <CODE