valarray.html

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

<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 natural logarithm of <CODE>left[I]</CODE>.</P>

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

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

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

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

<P>The class describes an object that
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>ba</CODE> of class
<CODE><A HREF="#valarray&lt;bool&gt;">valarray&lt;bool&gt;</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>mask_array&lt;Ty&gt;</CODE> object only
by writing an expression of the form
<CODE><A HREF="#valarray::operator[]">va[ba]</A></CODE>.
The member functions of class <CODE>mask_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 at most
<CODE>ba.<A HREF="#valarray::size">size</A>()</CODE>
elements. An element <CODE>J</CODE> is included only if <CODE>ba[J]</CODE>
is true. Thus, there are as many elements in the sequence as there are
true elements in <CODE>ba</CODE>.
If <CODE>I</CODE> is the index of the lowest true element
in <CODE>ba</CODE>, then <CODE>va[I]</CODE> is element zero in the
selected sequence. For example:</P>

<PRE>const bool vb[] = {false, false, true, true, false, true};
// va[valarray&lt;bool&gt;(vb, 56] selects elements with
//   indices 2, 3, 5</PRE>

<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&amp;"><CODE>operator&amp;</CODE></A></H2>

<PRE>template&lt;class Ty&gt;
    valarray&lt;Ty&gt; <B>operator&amp;</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&amp;</B>(const valarray&lt;Ty&gt; left,
        const Ty&amp; right);
template&lt;class Ty&gt;
    valarray&lt;Ty&gt; <B>operator&amp;</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] &amp; right[I]</CODE>.
The second template operator stores in element <CODE>I</CODE>
<CODE>left[I] &amp; right</CODE>.
The third template operator stores in element <CODE>I</CODE>
<CODE>left &amp; right[I]</CODE>.</P>

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

<PRE>template&lt;class Ty&gt;
    valarray&lt;bool&gt; <B>operator&amp;&amp;</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&amp;&amp;</B>(const valarray&lt;Ty&gt; left,
        const Ty&amp; right);
template&lt;class Ty&gt;
    valarray&lt;bool&gt; <B>operator&amp;&amp;</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] &amp;&amp; right[I]</CODE>.
The second template operator stores in element <CODE>I</CODE>
<CODE>left[I] &amp;&amp; right</CODE>.
The third template operator stores in element <CODE>I</CODE>
<CODE>left &amp;&amp; right[I]</CODE>.</P>

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

<PRE>template&lt;class Ty&gt;
    valarray&lt;bool&gt; <B>operator&gt;</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&gt;</B>(const valarray&lt;Ty&gt; left,
        const Ty&amp; right);
template&lt;class Ty&gt;
    valarray&lt;bool&gt; <B>operator&gt;</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] &gt; right[I]</CODE>.
The second template operator stores in element <CODE>I</CODE>
<CODE>left[I] &gt; right</CODE>.
The third template operator stores in element <CODE>I</CODE>
<CODE>left &gt; right[I]</CODE>.</P>

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

<PRE>template&lt;class Ty&gt;
    valarray&lt;Ty&gt; <B>operator&gt;&gt;</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&gt;&gt;</B>(const valarray&lt;Ty&gt; left,
        const Ty&amp; right);
template&lt;class Ty&gt;
    valarray&lt;Ty&gt; <B>operator&gt;&gt;</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] &gt;&gt; right[I]</CODE>.
The second template operator stores in element <CODE>I</CODE>
<CODE>left[I] &gt;&gt; right</CODE>.
The third template operator stores in element <CODE>I</CODE>
<CODE>left &gt;&gt; right[I]</CODE>.</P>

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

<PRE>template&lt;class Ty&gt;
    valarray&lt;bool&gt; <B>operator&gt;=</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&gt;=</B>(const valarray&lt;Ty&gt; left, const Ty&amp; right);
template&lt;class Ty&gt;
    valarray&lt;bool&gt; <B>operator&gt;=</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] &gt;= right[I]</CODE>.
The second template operator stores in element <CODE>I</CODE>
<CODE>left[I] &gt;= right</CODE>.
The third template operator stores in element <CODE>I</CODE>
<CODE>left &gt;= right[I]</CODE>.</P>

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

<PRE>template&lt;class Ty&gt;
    valarray&lt;bool&gt; <B>operator&lt;</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&lt;</B>(const valarray&lt;Ty&gt; left, const Ty&amp; right);
template&lt;class Ty&gt;
    valarray&lt;bool&gt; <B>operator&lt;</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] &lt; right[I]</CODE>.
The second template operator stores in element <CODE>I</CODE>
<CODE>left[I] &lt; right</CODE>.
The third template operator stores in element <CODE>I</CODE>
<CODE>left &lt; right[I]</CODE>.</P>

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

<PRE>template&lt;class Ty&gt;
    valarray&lt;Ty&gt; <B>operator&lt;&lt;</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&lt;&lt;</B>(const valarray&lt;Ty&gt; left,
        const Ty&amp; right);
template&lt;class Ty&gt;
    valarray&lt;Ty&gt; <B>operator&lt;&lt;</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] &lt;&lt; right[I]</CODE>.
The second template operator stores in element <CODE>I</CODE>
<CODE>left[I] &lt;&lt; right</CODE>.
The third template operator stores in element <CODE>I</CODE>
<CODE>left &lt;&lt; right[I]</CODE>.</P>

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

<PRE>template&lt;class Ty&gt;
    valarray&lt;bool&gt; <B>operator&lt;=</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&lt;=</B>(const valarray&lt;Ty&gt; left, const Ty&amp; right);
template&lt;class Ty&gt;
    valarray&lt;bool&gt; <B>operator&lt;=</B>(const Ty&amp; left, const valarray&lt;Ty&gt;&amp; right);</PRE>

<P>The first template operator retrrns 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] &lt;= right[I]</CODE>.
The second template operator stores in element <CODE>I</CODE>
<CODE>left[I] &lt;= right</CODE>.
The third template operator stores in element <CODE>I</CODE>
<CODE>left &lt;= 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;