<HTML>
<HEAD>
<TITLE>gslice_array</TITLE>
<LINK REL=StyleSheet HREF="../rw.css" TYPE="text/css" TITLE="Apache stdcxx Stylesheet"></HEAD>
<BODY BGCOLOR=#FFFFFF>
<A HREF="gslice.html"><IMG SRC="images/bprev.gif" WIDTH=20 HEIGHT=21 ALT="Previous file" BORDER=O></A><A HREF="noframes.html"><IMG SRC="images/btop.gif" WIDTH=56 HEIGHT=21 ALT="Top of Document" BORDER=O></A><A HREF="booktoc.html"><IMG SRC="images/btoc.gif" WIDTH=56 HEIGHT=21 ALT="Contents" BORDER=O></A><A HREF="tindex.html"><IMG SRC="images/bindex.gif" WIDTH=56 HEIGHT=21 ALT="Index page" BORDER=O></A><A HREF="has-facet.html"><IMG SRC="images/bnext.gif" WIDTH=25 HEIGHT=21 ALT="Next file" BORDER=O></A><DIV CLASS="DOCUMENTNAME"><B>Apache C++ Standard Library Reference Guide</B></DIV>
<H2>gslice_array</H2>
<P><B>Library:</B>&nbsp;&nbsp;<A HREF="2-10.html">Numerics</A></P>

<PRE><HR><B><I>Does not inherit</I></B><HR></PRE>

<UL>
<LI><A HREF="#sec1">Local Index</A></LI>
<LI><A HREF="#sec2">Summary</A></LI>
<LI><A HREF="#sec3">Synopsis</A></LI>
<LI><A HREF="#sec4">Description</A></LI>
<LI><A HREF="#sec5">Interface</A></LI>
<LI><A HREF="#sec6">Constructors</A></LI>
<LI><A HREF="#sec7">Assignment Operators</A></LI>
<LI><A HREF="#sec8">Computed Assignment Operators</A></LI>
<LI><A HREF="#sec9">Example</A></LI>
<LI><A HREF="#sec10">See Also</A></LI>
<LI><A HREF="#sec11">Standards Conformance</A></LI>
</UL>
<A NAME="sec1"><H3>Local Index</H3></A>
<H4>Members</H4>
<UL><TABLE CELLPADDING=3>
<TR><TD VALIGN=top>
<A HREF="#idx653">gslice_array()</A><BR>
<A HREF="#idx657">operator%=()</A><BR>
<A HREF="#idx657">operator&amp;=()</A><BR>
</TD>
<TD VALIGN=top><A HREF="#idx657">operator&gt;&gt;=()</A><BR>
<A HREF="#idx657">operator&lt;&lt;=()</A><BR>
<A HREF="#idx657">operator*=()</A><BR>
</TD>
<TD VALIGN=top><A HREF="#idx657">operator+=()</A><BR>
<A HREF="#idx657">operator-=()</A><BR>
<A HREF="#idx657">operator/=()</A><BR>
</TD>
<TD VALIGN=top><A HREF="#idx654">operator=()</A><BR>
<A HREF="#idx657">operator^=()</A><BR>
<A HREF="#idx657">operator|=()</A><BR>
</TD></TR>
</TABLE></UL>

<A NAME="sec2"><H3>Summary</H3></A>
<P>A numeric array class used to represent a BLAS-like slice from a <B><I><A HREF="valarray.html">valarray</A></I></B></P>
<A NAME="sec3"><H3>Synopsis</H3></A>

<PRE>#include &lt;valarray&gt;

namespace std {
  template &lt;class T&gt;
  class gslice_array;
}
</PRE>
<A NAME="sec4"><H3>Description</H3></A>
<P><B><I>gslice_array</I></B> creates a <B><I><A HREF="gslice.html">gslice</A></I></B> view into a <B><I><A HREF="valarray.html">valarray</A></I></B>.  A <B><I>gslice_array</I></B> can only be produced by applying the <B><I>gslice</I></B> subscript operator to a <B><I>valarray</I></B>. The elements in a <B><I>gslice_array</I></B> are references to selected elements in the <B><I>valarray</I></B> (so changing an element in the <B><I>gslice_array</I></B> really changes the corresponding element in the <B><I>valarray</I></B>). A <B><I>gslice_array</I></B> does not itself hold any distinct elements. The template cannot be instantiated directly since all its constructors are private. However, you can copy a <B><I>gslice_array</I></B> to a <B><I>valarray</I></B> using either the <B><I>valarray</I></B> copy constructor or the assignment operator. Reference semantics are lost at that point. </P>
<A NAME="sec5"><H3>Interface</H3></A>

<UL><PRE>namespace std{ 

  template &lt;class T&gt; class gslice_array {
  public:

    // types
    typedef T value_type;

    // destructor
    ~gslice_array();

    // public assignment
    void operator=(const valarray&lt;T&gt;&amp; array) const;
    
    // computed assignment
    void operator*=(const valarray&lt;T&gt;&amp; array) const;
    void operator/=(const valarray&lt;T&gt;&amp; array) const;
    void operator%=(const valarray&lt;T&gt;&amp; array) const;
    void operator+=(const valarray&lt;T&gt;&amp; array) const;
    void operator-=(const valarray&lt;T&gt;&amp; array) const;
    void operator^=(const valarray&lt;T&gt;&amp; array) const;
    void operator&amp;=(const valarray&lt;T&gt;&amp; array) const;
    void operator|=(const valarray&lt;T&gt;&amp; array) const;
    void operator&lt;&lt;=(const valarray&lt;T&gt;&amp; array) const;
    void operator&gt;&gt;=(const valarray&lt;T&gt;&amp; array) const;
 
    // fill function
    void operator=(const T&amp;);  

  private:
    
    // constructors
    gslice_array();
    gslice_array(const gslice_array&lt;T&gt;&amp;);
    
    // operator =
    gslice_array&lt;T&gt;&amp; operator= (const gslice_array&lt;T&gt;&amp; array);
  };
}
</PRE></UL>
<A NAME="sec6"><H3>Constructors</H3></A>

<A NAME="idx653"></A><PRE><B>gslice_array</B>();
<B>gslice_array</B>(const gslice_array&amp;);</PRE>
<UL>
<P>All <B><I>gslice_array</I></B> constructors are private and cannot be called directly. This prevents copy construction of <B><I>gslice_arrays</I></B>.</P>
</UL>

<A NAME="sec7"><H3>Assignment Operators</H3></A>

<A NAME="idx654"></A><PRE>void <B>operator=</B>(const valarray&lt;T&gt;&amp; x) const;</PRE>
<UL>
<P>Assigns values from <SAMP>x</SAMP> to the selected elements of the <B><I><A HREF="valarray.html">valarray</A></I></B> that self refers to. Remember that a <B><I>gslice_array</I></B> never holds any elements itself; it simply refers to selected elements in the <B><I>valarray</I></B> used to generate it.</P>
</UL>


<A NAME="idx655"></A><PRE>gslice_array&lt;T&gt;&amp; 
<B>operator=</B>(const gslice_array&lt;T&gt;&amp; x);</PRE>
<UL>
<P>Private assignment operator. Cannot be called directly, thus preventing assignment between <B><I>gslice_array</I></B>s.</P>
</UL>


<A NAME="idx656"></A><PRE>void <B>operator=</B>(const T&amp; x) const;</PRE>
<UL>
<P>Assigns <SAMP>x</SAMP> to the selected elements of the <B><I><A HREF="valarray.html">valarray</A></I></B> that self refers to. </P>
</UL>

<A NAME="sec8"><H3>Computed Assignment Operators</H3></A>

<A NAME="idx657"></A><PRE>void <B>operator*=</B>(const valarray&lt;T&gt;&amp; val) const;
void <B>operator/=</B>(const valarray&lt;T&gt;&amp; val) const;
void <B>operator%=</B>(const valarray&lt;T&gt;&amp; val) const;
void <B>operator+=</B>(const valarray&lt;T&gt;&amp; val) const;
void <B>operator-=</B>(const valarray&lt;T&gt;&amp; val) const;
void <B>operator^=</B>(const valarray&lt;T&gt;&amp; val) const;
void <B>operator&amp;=</B>(const valarray&lt;T&gt;&amp; val) const;
void <B>operator|=</B>(const valarray&lt;T&gt;&amp; val) const;
void <B>operator&lt;&lt;=</B>(const valarray&lt;T&gt;&amp; val) const;
void <B>operator&gt;&gt;=</B>(const valarray&lt;T&gt;&amp; val) const;</PRE>
<UL>
<P>Applies the indicated operation using elements from <SAMP>val</SAMP> to the selected elements of the <B><I><A HREF="valarray.html">valarray</A></I></B> that self refers to. Remember that a <B><I>gslice_array</I></B> never holds any elements itself; it simply refers to selected elements in the <B><I>valarray</I></B> used to generate it.</P>
</UL>

<A NAME="sec9"><H3>Example</H3></A>

<UL><PRE>//
//  gslice_array.cpp
//

#include &lt;valarray.h&gt;  // Includes valarray and 
                       // provides stream inserter.

typedef std::valarray&lt;int&gt; valarray_t;

int main(void) {

  valarray_t::value_type
      ibuf[22] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10,
                   11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21 };

  // Create a valarray of ints
  valarray_t  vi (ibuf,(sizeof ibuf / sizeof *ibuf));

  // Print out the valarray
  std::cout &lt;&lt; "original valarray vi:\n\n" &lt;&lt; vi &lt;&lt; "\n\n";

  // Get a two dimensional diagonal slice out of the middle
  size_t length_ary[] = {4, 2};
  size_t stride_ary[] = {4, 6};

  std::valarray&lt;size_t&gt; length_val(length_ary, 2);
  std::valarray&lt;size_t&gt; stride_val(stride_ary, 2);


  // Print out the slices starting at positions 0 and 2
  // respectively.
  std::cout &lt;&lt; "vi[gslice(0,[4,2],[4,6])]\n\n"
            &lt;&lt; vi[std::gslice(0,length_val,stride_val)] 
            &lt;&lt; "\n\n";

  std::cout &lt;&lt; "vi[gslice(2,[4,2],[4,6])]\n\n"
            &lt;&lt; vi[std::gslice(2,length_val,stride_val)] 
            &lt;&lt; "\n\n";

  // Multiply the first slice by the second.
  vi[std::gslice(0,length_val,stride_val)]
      *= static_cast&lt;valarray_t &gt; (vi[std::gslice(2,length_val,
                                                  stride_val)]);

  std::cout &lt;&lt; "vi[gslice(0,[4,2],[4,8])] *= " 
            &lt;&lt; "vi[gslice(2,[4,2],[4,6])]\n\n"
            &lt;&lt; vi &lt;&lt; std::endl;
  
  return 0;
  
}


Program Output:
</PRE></UL>
<UL><PRE>original valarray vi:

[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21]

vi[gslice(0,[4,2],[4,6])]

[0,6,4,10,8,14,12,18]

vi[gslice(2,[4,2],[4,6])]

[2,8,6,12,10,16,14,20]

vi[gslice(0,[4,2],[4,8])] *= vi[gslice(2,[4,2],[4,6])]

[0,1,2,3,24,5,48,7,80,9,120,11,168,13,224,15,16,17,360,19,20,21]
</PRE></UL>
<A NAME="sec10"><H3>See Also</H3></A>
<P><B><I><A HREF="slice.html">slice</A></I></B>, <B><I><A HREF="valarray.html">valarray</A></I></B>, <B><I><A HREF="gslice.html">gslice</A></I></B>, <B><I><A HREF="slice-array.html">slice_array</A></I></B>, <B><I><A HREF="mask-array.html">mask_array</A></I></B>, <B><I><A HREF="indirect-array.html">indirect_array</A></I></B></P>
<A NAME="sec11"><H3>Standards Conformance</H3></A>
<P><I>ISO/IEC 14882:1998 -- International Standard for Information Systems -- Programming Language C++, Section 26.3.7</I></P>

<BR>
<HR>
<A HREF="gslice.html"><IMG SRC="images/bprev.gif" WIDTH=20 HEIGHT=21 ALT="Previous file" BORDER=O></A><A HREF="noframes.html"><IMG SRC="images/btop.gif" WIDTH=56 HEIGHT=21 ALT="Top of Document" BORDER=O></A><A HREF="booktoc.html"><IMG SRC="images/btoc.gif" WIDTH=56 HEIGHT=21 ALT="Contents" BORDER=O></A><A HREF="tindex.html"><IMG SRC="images/bindex.gif" WIDTH=56 HEIGHT=21 ALT="Index page" BORDER=O></A><A HREF="has-facet.html"><IMG SRC="images/bnext.gif" WIDTH=20 HEIGHT=21 ALT="Next file" BORDER=O></A>

<!-- Google Analytics tracking code -->
<script src="http://www.google-analytics.com/urchin.js" type="text/javascript">
</script>
<script type="text/javascript">
    _uacct = "UA-1775151-1";
    urchinTracker();
</script>
<!-- end of Google Analytics tracking code -->

</BODY>
</HTML>