valarray.html

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

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

<P>The first template operator returns an object of class
<CODE><A HREF="#valarray">valarray</A>&lt;Ty&gt;</CODE>,
each of whose
elements <CODE>I</CODE> is <CODE>left[I] * right[I]</CODE>.
The second template operator stores in element <CODE>I</CODE>
<CODE>left[I] * right</CODE>.
The third template operator stores in element <CODE>I</CODE>
<CODE>left * right[I]</CODE>.</P>

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

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

<P>The first template operator returns an object of class
<CODE><A HREF="#valarray">valarray</A>&lt;Ty&gt;</CODE>,
each of whose
elements <CODE>I</CODE> is <CODE>left[I] + right[I]</CODE>.
The second template operator stores in element <CODE>I</CODE>
<CODE>left[I] + right</CODE>.
The third template operator stores in element <CODE>I</CODE>
<CODE>left + right[I]</CODE>.</P>

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

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

<P>The first template operator returns an object of class
<CODE><A HREF="#valarray">valarray</A>&lt;Ty&gt;</CODE>,
each of whose
elements <CODE>I</CODE> is <CODE>left[I] - right[I]</CODE>.
The second template operator stores in element <CODE>I</CODE>
<CODE>left[I] - right</CODE>.
The third template operator stores in element <CODE>I</CODE>
<CODE>left - right[I]</CODE>.</P>

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

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

<P>The first template operator returns an object of class
<CODE><A HREF="#valarray">valarray</A>&lt;Ty&gt;</CODE>,
each of whose
elements <CODE>I</CODE> is <CODE>left[I] / right[I]</CODE>.
The second template operator stores in element <CODE>I</CODE>
<CODE>left[I] / right</CODE>.
The third template operator stores in element <CODE>I</CODE>
<CODE>left / right[I]</CODE>.</P>

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

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

<P>The first template operator returns an object of class
<CODE><A HREF="#valarray&lt;bool&gt;">valarray&lt;bool&gt;</A></CODE>,
each of whose
elements <CODE>I</CODE> is <CODE>left[I] == right[I]</CODE>.
The second template operator stores in element <CODE>I</CODE>
<CODE>left[I] == right</CODE>.
The third template operator stores in element <CODE>I</CODE>
<CODE>left == right[I]</CODE>.</P>

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

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

<P>The first template operator returns an object of class
<CODE><A HREF="#valarray">valarray</A>&lt;Ty&gt;</CODE>,
each of whose
elements <CODE>I</CODE> is <CODE>left[I] ^ right[I]</CODE>.
The second template operator stores in element <CODE>I</CODE>
<CODE>left[I] ^ right</CODE>.
The third template operator stores in element <CODE>I</CODE>
<CODE>left ^ right[I]</CODE>.</P>

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

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

<P>The first template operator returns an object of class
<CODE><A HREF="#valarray">valarray</A>&lt;Ty&gt;</CODE>,
each of whose
elements <CODE>I</CODE> is <CODE>left[I] | right[I]</CODE>.
The second template operator stores in element <CODE>I</CODE>
<CODE>left[I] | right</CODE>.
The third template operator stores in element <CODE>I</CODE>
<CODE>left | right[I]</CODE>.</P>

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

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

<P>The first template operator returns an object of class
<CODE><A HREF="#valarray">valarray</A>&lt;bool&gt;</CODE>,
each of whose
elements <CODE>I</CODE> is <CODE>left[I] || right[I]</CODE>.
The second template operator stores in element <CODE>I</CODE>
<CODE>left[I] || right</CODE>.
The third template operator stores in element <CODE>I</CODE>
<CODE>left || right[I]</CODE>.</P>

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

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

<P>The first 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 <CODE>left[I]</CODE> raised to the
<CODE>right[I]</CODE> power.
The second template function stores in element <CODE>I</CODE>
<CODE>left[I]</CODE> raised to the <CODE>right</CODE> power.
The third template function stores in element <CODE>I</CODE>
<CODE>left</CODE> raised to the <CODE>right[I]</CODE> power.</P>

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

<PRE>template&lt;class Ty&gt;
    valarray&lt;Ty&gt; <B>sin</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 sine of <CODE>left[I]</CODE>.</P>

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

<PRE>template&lt;class Ty&gt;
    valarray&lt;Ty&gt; <B>sinh</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 sine of <CODE>left[I]</CODE>.</P>

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

<PRE>class <B>slice</B> {
public:
    <B><A HREF="#slice::slice">slice</A></B>();
    <B><A HREF="#slice::slice">slice</A></B>(size_t st, size_t len, size_t str);
    size_t <B><A HREF="#slice::start">start</A></B>() const;
    size_t <B><A HREF="#slice::size">size</A></B>() const;
    size_t <B><A HREF="#slice::stride">stride</A></B>() const;
    };</PRE>

<P>The class stores the parameters that characterize a
<CODE><A HREF="#slice_array">slice_array</A></CODE> when an
object of class <CODE>slice</CODE> appears as a subscript
for an object of class
<CODE><A HREF="#valarray::operator[]">valarray</A>&lt;Ty&gt;</CODE>.
The stored values include:</P>

<UL>
<LI>a <B>starting index</B></LI>

<LI>a <B>total length</B></LI>

<LI>a <B>stride</B>, or distance between subsequent indices</LI>
</UL>

<H3><A NAME="slice::slice"><CODE>slice::slice</CODE></A></H3>

<PRE><B>slice</B>();
<B>slice</B>(size_t st,
        const valarray&lt;size_t&gt; len, const valarray&lt;size_t&gt; str);</PRE>

<P>The default constructor stores zeros for the starting index,
total length, and stride. The second constructor stores <CODE>st</CODE>
for the starting index, <CODE>len</CODE> for the total length,
and <CODE>str</CODE> for the stride.</P>

<H3><A NAME="slice::size"><CODE>slice::size</CODE></A></H3>

<PRE>size_t <B>size</B>() const;</PRE>

<P>The member function returns the stored total length.</P>

<H3><A NAME="slice::start"><CODE>slice::start</CODE></A></H3>

<PRE>size_t <B>start</B>() const;</PRE>

<P>The member function returns the stored starting index.</P>

<H3><A NAME="slice::stride"><CODE>slice::stride</CODE></A></H3>

<PRE>size_t <B>stride</B>() const;</PRE>

<P>The member function returns the stored stride.</P>

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

<PRE>template&lt;class Ty&gt;
    class <B>slice_array</B> {
public:
    typedef Ty <B><A NAME="slice_array::value_type">value_type</A></B>;
    void <B><A NAME="slice_array::operator=">operator=</A></B>(const valarray&lt;Ty&gt; right) const;
    void <B><A NAME="#slice_array::operator=">operator=</A></B>(const Ty&amp; right) const;
    void <B><A NAME="slice_array::operator*=">operator*=</A></B>(const valarray&lt;Ty&gt; right) const;
    void <B><A NAME="slice_array::operator/=">operator/=</A></B>(const valarray&lt;Ty&gt; right) const;
    void <B><A NAME="slice_array::operator%=">operator%=</A></B>(const valarray&lt;Ty&gt; right) const;
    void <B><A NAME="slice_array::operator+=">operator+=</A></B>(const valarray&lt;Ty&gt; right) const;
    void <B><A NAME="slice_array::operator-=">operator-=</A></B>(const valarray&lt;Ty&gt; right) const;
    void <B><A NAME="slice_array::operator^=">operator^=</A></B>(const valarray&lt;Ty&gt; right) const;
    void <B><A NAME="slice_array::operator&amp;=">operator&amp;=</A></B>(const valarray&lt;Ty&gt; right) const;
    void <B><A NAME="slice_array::operator|=">operator|=</A></B>(const valarray&lt;Ty&gt; right) const;
    void <B><A NAME="slice_array::operator&lt;&lt;=">operator&lt;&lt;=</A></B>(const valarray&lt;Ty&gt; right) const;
    void <B><A NAME="slice_array::operator&gt;&gt;=">operator&gt;&gt;=</A></B>(const valarray&lt;Ty&gt; right) const;
private:
    void <B>slice_array</B>();  // not defined
    void <B>slice_array</B>(
        const slice_array&amp;);  // not defined
    slice_array&amp; <B>operator=</B>(
        const slice_array&amp;);  // not defined
    };</PRE>

<P>The class describes an object that