home *** CD-ROM | disk | FTP | other *** search
/ PC Format (South-Africa) 2001 June / PCFJune.iso / Xenon / C++ / FreeCommandLineTools.exe / Include / valarray.h < prev    next >
Encoding:
C/C++ Source or Header  |  2000-01-31  |  21.8 KB  |  787 lines
  1. #ifndef __VALARRAY_H
  2. #define __VALARRAY_H
  3. #pragma option push -b -a8 -pc -Vx- -Ve- -w-inl -w-aus -w-sig
  4. // -*- C++ -*-
  5. #ifndef __RW_VALARRAY__
  6. #define __RW_VALARRAY__
  7.  
  8. /***************************************************************************
  9.  *
  10.  * valaray - Declarations for the Standard Library valarray
  11.  *
  12.  ***************************************************************************
  13.  *
  14.  * Copyright (c) 1994-1999 Rogue Wave Software, Inc.  All Rights Reserved.
  15.  *
  16.  * This computer software is owned by Rogue Wave Software, Inc. and is
  17.  * protected by U.S. copyright laws and other laws and by international
  18.  * treaties.  This computer software is furnished by Rogue Wave Software,
  19.  * Inc. pursuant to a written license agreement and may be used, copied,
  20.  * transmitted, and stored only in accordance with the terms of such
  21.  * license and with the inclusion of the above copyright notice.  This
  22.  * computer software or any other copies thereof may not be provided or
  23.  * otherwise made available to any other person.
  24.  *
  25.  * U.S. Government Restricted Rights.  This computer software is provided
  26.  * with Restricted Rights.  Use, duplication, or disclosure by the
  27.  * Government is subject to restrictions as set forth in subparagraph (c)
  28.  * (1) (ii) of The Rights in Technical Data and Computer Software clause
  29.  * at DFARS 252.227-7013 or subparagraphs (c) (1) and (2) of the
  30.  * Commercial Computer Software รป Restricted Rights at 48 CFR 52.227-19,
  31.  * as applicable.  Manufacturer is Rogue Wave Software, Inc., 5500
  32.  * Flatiron Parkway, Boulder, Colorado 80301 USA.
  33.  *
  34.  **************************************************************************/
  35. #include <rw/valimp>
  36.  
  37. #ifndef _RWSTD_NO_NAMESPACE
  38. namespace std {
  39. #endif
  40.  
  41. // forward declarations
  42.   class _RWSTDExport slice;
  43.   template <class T> class slice_array;
  44.   class _RWSTDExport gslice;
  45.   template <class T> class gslice_array;
  46.   template <class T> class mask_array;
  47.   template <class T> class indirect_array;
  48. /*************************************************************
  49.  *                     CLASS VALARRAY                        *
  50.  *************************************************************/
  51.  
  52.   template <class T>  class valarray {
  53.  
  54.   public:
  55.  
  56.     typedef T value_type;
  57.  
  58. // constructors
  59.  
  60.     valarray( ) {;}
  61.  
  62.     _EXPLICIT valarray(size_t size)
  63.     { memory_array._initial_size(size); }
  64.  
  65.     valarray(const T& value, size_t size)
  66.     { memory_array._initialize_with_value(value,size); }
  67.  
  68.     valarray(const T* pointer, size_t size)
  69.     { memory_array._initialize_with_array(pointer,size); }
  70.  
  71.     valarray(const valarray<T>& array)
  72.     { memory_array._copy_memory_array(array._RW_get_memory_array()); }
  73.  
  74.     valarray(const slice_array<T>&);
  75.     valarray(const gslice_array<T>&);
  76.     valarray(const mask_array<T>&);
  77.     valarray(const indirect_array<T>&);
  78.  
  79.     // operator =
  80.  
  81.     valarray<T>& operator= (const valarray<T>& array)
  82.     {
  83.       if ( this != &array )
  84.         memory_array._copy_memory_array(array._RW_get_memory_array());
  85.       return *this;
  86.     }
  87.  
  88.     valarray<T>& operator= (const T&);
  89.     valarray<T>& operator= (const slice_array<T>&);
  90.     valarray<T>& operator= (const gslice_array<T>&);
  91.     valarray<T>& operator= (const mask_array<T>&);
  92.     valarray<T>& operator= (const indirect_array<T>&);
  93.  
  94.     // operator[]
  95.  
  96.     T operator[] (size_t ind) const
  97.     { return memory_array[ind];  }
  98.  
  99.     T& operator[] (size_t ind)
  100.     { return memory_array[ind]; }
  101.  
  102.     valarray<T> operator[](slice) const;
  103.     inline slice_array<T> operator[](slice);
  104.     valarray<T> operator[](const gslice&) const;
  105.     inline gslice_array<T> operator[](const gslice&);
  106.     valarray<T> operator[](const valarray<bool>&) const;
  107.     inline mask_array<T> operator[](const valarray<bool>&);
  108.     valarray<T> operator[](const valarray<size_t>&) const;
  109.     inline indirect_array<T> operator[](const valarray<size_t>&);
  110.  
  111.     // unary operators
  112.  
  113.     valarray<T> operator+() const;
  114.     valarray<T> operator-() const;
  115. #ifndef _RWSTD_NO_ONLY_NEEDED_INSTANTIATION
  116.     valarray<T> operator~() const;
  117.     valarray<bool> operator!() const;
  118. #endif
  119.  
  120.     // computed assignment
  121.  
  122.     valarray<T>& operator*= (const valarray<T>& array);
  123.     valarray<T>& operator/= (const valarray<T>& array);
  124.     valarray<T>& operator+= (const valarray<T>& array);
  125.     valarray<T>& operator-= (const valarray<T>& array);
  126. #ifndef _RWSTD_NO_ONLY_NEEDED_INSTANTIATION
  127.     valarray<T>& operator%= (const valarray<T>& array);
  128.     valarray<T>& operator^= (const valarray<T>& array);
  129.     valarray<T>& operator&= (const valarray<T>& array);
  130.     valarray<T>& operator|= (const valarray<T>& array);
  131.     valarray<T>& operator<<= (const valarray<T>& array);
  132.     valarray<T>& operator>>= (const valarray<T>& array);
  133. #endif
  134.     valarray<T>& operator*= (const T& val);
  135.     valarray<T>& operator/= (const T& val);
  136.     valarray<T>& operator%= (const T& val);
  137.     valarray<T>& operator+= (const T& val);
  138.     valarray<T>& operator-= (const T& val);
  139.     valarray<T>& operator^= (const T& val);
  140.     valarray<T>& operator&= (const T& val);
  141.     valarray<T>& operator|= (const T& val);
  142.     valarray<T>& operator<<= (const T& val);
  143.     valarray<T>& operator>>= (const T& val);
  144.     // others
  145.  
  146.     size_t size() const { return memory_array._get_length(); }
  147.  
  148.     T sum() const;
  149. #ifndef _RWSTD_NO_ONLY_NEEDED_INSTANTIATION
  150.     T min() const;
  151.     T max() const;
  152. #endif
  153.  
  154.     valarray<T> shift(int sh) const;
  155.     valarray<T> cshift(int sh) const;
  156.  
  157.     valarray<T> apply(T func(T)) const;
  158.     valarray<T> apply(T func(const T&)) const;
  159.  
  160.     void free()
  161.     { memory_array._RW_resize_without_copy(0); }
  162.  
  163.     void resize(size_t sz, const T c= T() )
  164.     {
  165.       memory_array._RW_resize_without_copy(sz);
  166.       *this = c;
  167.     }
  168.  
  169.     // implementation specific
  170.  
  171.     const _RW_IMP_SPACE(_RW_array<T>)& _RW_get_memory_array( ) const
  172.     { return memory_array; }
  173.  
  174.     _RW_IMP_SPACE(_RW_array<T>)* _RW_get_memory_array_adr( )
  175.     { return &memory_array; }
  176.  
  177.     valarray(_RW_IMP_SPACE(_RW_temporary<T>)* tmp)
  178.     {
  179.       memory_array._replace(tmp->store_adr,tmp->length);
  180.       delete tmp;
  181.     }
  182.  
  183.   private:
  184.  
  185.     _RW_IMP_SPACE(_RW_array<T>)  memory_array;
  186.  
  187.   };
  188.  
  189. /*
  190.  *   VALARRAY INLINE MEMBER FUNCTIONS
  191.  */
  192.   template <class T>
  193.   inline valarray<T>& valarray<T>::operator=(const T& value)
  194.   {
  195.     memory_array._initialize_with_value(value, size());
  196.     return *this;
  197.   }
  198.  
  199. // operator[] for slice
  200.   
  201.   template <class T>
  202.   inline slice_array<T> valarray<T>::operator[](slice sl)
  203.   {
  204.     return slice_array<T>(&memory_array, sl);
  205.   }
  206.  
  207.   // operator[] for gslice
  208.  
  209.      
  210.   template <class T>
  211.   inline gslice_array<T> valarray<T>::operator[](const gslice& sl)
  212.   {
  213.     return gslice_array<T>(&memory_array, sl);
  214.   }
  215. // operator[] for valarray[valarray<bool>] used with mask_array
  216.  
  217.   
  218.   template <class T>
  219.   inline mask_array<T> valarray<T>::operator[](const valarray<bool>& array)
  220.   {
  221.     return mask_array<T>(&memory_array, array);
  222.   }
  223. // operator[] for valarray[valarray<size_t>] used with indirect_array
  224.   template <class T>
  225.   inline indirect_array<T> valarray<T>::operator[](const valarray<size_t>& array)
  226.   {
  227.     return indirect_array<T>(&memory_array, array);
  228.   }
  229.  
  230. /*
  231.  *
  232.  *   VALARRAY NON MEMBER FUNCTIONS
  233.  *
  234.  */
  235.  
  236.   // binary operators
  237.  
  238.   template<class T>
  239.   valarray<T> operator* (const valarray<T>& , const valarray<T>&  );
  240.  
  241.   template<class T>
  242.   valarray<T> operator/ (const valarray<T>& , const valarray<T>& );
  243.  
  244.   template<class T>
  245.   valarray<T> operator% (const valarray<T>&, const valarray<T>&);
  246.  
  247.   template<class T>
  248.   valarray<T> operator+ (const valarray<T>& , const valarray<T>& );
  249.  
  250.   template<class T>
  251.   valarray<T> operator- (const valarray<T>& , const valarray<T>& );
  252.   
  253.   template<class T>
  254.   valarray<T> operator^ (const valarray<T>&, const valarray<T>&);
  255.  
  256.   template<class T>
  257.   valarray<T> operator& (const valarray<T>&, const valarray<T>&);
  258.  
  259.   template<class T>
  260.   valarray<T> operator| (const valarray<T>&, const valarray<T>&);
  261.  
  262.   template<class T>
  263.   valarray<T> operator<< (const valarray<T>&, const valarray<T>&);
  264.  
  265.   template<class T>
  266.   valarray<T> operator>> (const valarray<T>&, const valarray<T>&);
  267.  
  268.   template<class T>
  269.   valarray<bool> operator&& (const valarray<T>&, const valarray<T>&);
  270.  
  271.   template<class T>
  272.   valarray<bool> operator|| (const valarray<T>&, const valarray<T>&);
  273.  
  274. // with non array second param
  275.  
  276.   template<class T>
  277.   valarray<T> operator* (const valarray<T>& , const T& );
  278.  
  279.   template<class T>
  280.   valarray<T> operator/ (const valarray<T>& , const T& );
  281.  
  282.   template<class T>
  283.   valarray<T> operator% (const valarray<T>&, const T&);
  284.  
  285.   template<class T>
  286.   valarray<T> operator+ (const valarray<T>& , const T& );
  287.  
  288.   template<class T>
  289.   valarray<T> operator- (const valarray<T>& , const T& );
  290.   
  291.   template<class T>
  292.   valarray<T> operator^ (const valarray<T>&, const T&);
  293.  
  294.   template<class T>
  295.   valarray<T> operator& (const valarray<T>&, const T&);
  296.  
  297.   template<class T>
  298.   valarray<T> operator| (const valarray<T>&, const T&);
  299.  
  300.   template<class T>
  301.   valarray<T> operator<< (const valarray<T>&, const T&);
  302.  
  303.   template<class T>
  304.   valarray<T> operator>> (const valarray<T>&, const T&);
  305.  
  306.   template<class T>
  307.   valarray<bool> operator&& (const valarray<T>&, const T&);
  308.  
  309.   template<class T>
  310.   valarray<bool> operator|| (const valarray<T>&, const T&);
  311. // with non array first param
  312.  
  313.   template<class T>
  314.   valarray<T> operator* (const T& , const valarray<T>& ); 
  315.  
  316.   template<class T>
  317.   valarray<T> operator/ (const T& , const valarray<T>& );
  318.  
  319.   template<class T>
  320.   valarray<T> operator% (const T&, const valarray<T>&);
  321.  
  322.   template<class T>
  323.   valarray<T> operator+ (const T& , const valarray<T>& );
  324.  
  325.   template<class T>
  326.   valarray<T> operator- (const T& , const valarray<T>& );
  327.  
  328.   template<class T>
  329.   valarray<T> operator^ (const T&, const valarray<T>&);
  330.  
  331.   template<class T>
  332.   valarray<T> operator& (const T&, const valarray<T>&);
  333.  
  334.   template<class T>
  335.   valarray<T> operator| (const T&, const valarray<T>&);
  336.  
  337.   template<class T>
  338.   valarray<T> operator<< (const T&, const valarray<T>&);
  339.  
  340.   template<class T>
  341.   valarray<T> operator>> (const T&, const valarray<T>&);
  342.  
  343.   template<class T>
  344.   valarray<bool> operator&& (const T&, const valarray<T>&);
  345.  
  346.   template<class T>
  347.   valarray<bool> operator|| (const T&, const valarray<T>&);
  348.  
  349. // comparison operators
  350.  
  351.   template<class T>
  352.   valarray<bool> operator== (const valarray<T>& , const valarray<T>& );
  353.   
  354.   template<class T>
  355.   valarray<bool> operator!= (const valarray<T>& , const valarray<T>& );
  356.    
  357.   template<class T>
  358.   valarray<bool> operator< (const valarray<T>& , const valarray<T>& );
  359.  
  360.   template<class T>
  361.   valarray<bool> operator> (const valarray<T>& , const valarray<T>& );
  362.    
  363.   template<class T>
  364.   valarray<bool> operator<= (const valarray<T>& , const valarray<T>& ); 
  365.  
  366.   template<class T>
  367.   valarray<bool> operator>= (const valarray<T>& , const valarray<T>& );
  368.  
  369. // comparison operators, non valarray second param
  370.  
  371.   template<class T>
  372.   valarray<bool> operator== (const valarray<T>& , const T& );
  373.  
  374.   template<class T>
  375.   valarray<bool> operator!= (const valarray<T>& , const T& );
  376.  
  377.   template<class T>
  378.   valarray<bool> operator< (const valarray<T>& , const T& );
  379.  
  380.   template<class T>
  381.   valarray<bool> operator> (const valarray<T>& , const T& );
  382.  
  383.   template<class T>
  384.   valarray<bool> operator<= (const valarray<T>& , const T& );
  385.   
  386.   template<class T>
  387.   valarray<bool> operator>= (const valarray<T>& , const T& );
  388.  
  389. // comparison operators, non valarray first param
  390.  
  391.   template<class T>
  392.   valarray<bool> operator== (const T& , const valarray<T>& );
  393.  
  394.   template<class T>
  395.   valarray<bool> operator!= (const T& , const valarray<T>& );
  396.  
  397.   template<class T>
  398.   valarray<bool> operator< (const T& , const valarray<T>& );
  399.  
  400.   template<class T>
  401.   valarray<bool> operator> (const T& , const valarray<T>& );
  402.  
  403.   template<class T>
  404.   valarray<bool> operator<= (const T& , const valarray<T>& ); 
  405.   
  406.   template<class T>
  407.   valarray<bool> operator>= (const T& , const valarray<T>& );
  408.  
  409.    
  410. // transcendentals
  411.  
  412.   template<class T>
  413.   valarray<T> abs(const valarray<T>& );
  414.  
  415.   template<class T>
  416.   valarray<T> acos(const valarray<T>& );
  417.  
  418.   template<class T>
  419.   valarray<T> asin(const valarray<T>& );
  420.  
  421.   template<class T>
  422.   valarray<T> atan(const valarray<T>& );
  423.  
  424.   template<class T>
  425.   valarray<T> cos(const valarray<T>& );
  426.  
  427.   template<class T>
  428.   valarray<T> cosh(const valarray<T>& );
  429.  
  430.   template<class T>
  431.   valarray<T> exp(const valarray<T>& );
  432.  
  433.   template<class T>
  434.   valarray<T> log(const valarray<T>& );
  435.  
  436.   template<class T>
  437.   valarray<T> log10(const valarray<T>& );
  438.  
  439.   template<class T>
  440.   valarray<T> sinh(const valarray<T>& );
  441.  
  442.   template<class T>
  443.   valarray<T> sin(const valarray<T>& );
  444.  
  445.   template<class T>
  446.   valarray<T> sqrt(const valarray<T>& );
  447.  
  448.   template<class T>
  449.   valarray<T> tan(const valarray<T>& );
  450.  
  451.   template<class T>
  452.   valarray<T> tanh(const valarray<T>& );
  453.  
  454.   template<class T>
  455.   valarray<T> atan2(const valarray<T>& , const valarray<T>& );
  456.  
  457.   template<class T>
  458.   valarray<T> atan2(const valarray<T>& , const T& );
  459.  
  460.   template<class T>
  461.   valarray<T> atan2(const T& , const valarray<T>& );
  462.  
  463.   template<class T>
  464.   valarray<T> pow(const valarray<T>& , const valarray<T>& );
  465.  
  466.   template<class T>
  467.   valarray<T> pow(const valarray<T>& , const T& );
  468.  
  469.   template<class T>
  470.   valarray<T> pow(const T& , const valarray<T>& );
  471.  
  472. // Global min and max template fonction
  473. // for compiler that try to instantiate all the member function
  474.  
  475. #ifdef _RWSTD_NO_ONLY_NEEDED_INSTANTIATION
  476.   template <class T> T max(const valarray<T>&);
  477.   template <class T> T min(const valarray<T>&);
  478. #endif
  479.  
  480. /****************************************************************
  481.  *                SLICE AND SLICE_ARRAY                         *
  482.  ****************************************************************/
  483.  
  484.   class _RWSTDExport slice {
  485.  
  486.   public:
  487.  
  488.     slice()
  489.       : start_(0), length_(0), stride_(0)
  490.     {;}
  491.     slice(size_t start, size_t length, size_t stride)
  492.       : start_(start)
  493.       , length_(length)
  494.       , stride_(stride)
  495.     {;}
  496.  
  497.     slice(const slice& sl)
  498.       :start_(sl.start())
  499.       ,length_(sl.size())
  500.       ,stride_(sl.stride())
  501.     {;}
  502.  
  503.     size_t start() const { return start_; }
  504.     size_t size() const { return length_; }
  505.     size_t stride() const { return stride_; }
  506.  
  507.   private:
  508.  
  509.     size_t start_;
  510.     size_t length_;
  511.     size_t stride_;
  512.  
  513.   };
  514.  
  515.   template <class T> class  slice_array {
  516.  
  517.   public:
  518.  
  519.     typedef T value_type;
  520.  
  521.     slice_array( _RW_IMP_SPACE(_RW_array<T>)* pt,const slice& a ) 
  522.       :ref_mem_array(pt)
  523.       ,slice_(a)
  524.     {;}
  525.  
  526.     slice_array(const slice_array<T>& sl)
  527.       :ref_mem_array(sl.get_ref_mem_array())
  528.       ,slice_(sl.get_slice())
  529.     {;}
  530.  
  531.     _RW_IMP_SPACE(_RW_array<T>)* get_ref_mem_array() const { return ref_mem_array; }
  532.     slice get_slice() const { return slice_; }
  533.  
  534.     // assignment
  535.  
  536.     void operator= (const valarray<T>& ) const;
  537.     void operator= (const T&) const;
  538.  
  539.     // computed assignment
  540.  
  541.     void operator*= (const valarray<T>& ) const;
  542.     void operator/= (const valarray<T>& ) const;
  543.     void operator+= (const valarray<T>& ) const;
  544.     void operator-= (const valarray<T>& ) const;
  545. #ifndef _RWSTD_NO_ONLY_NEEDED_INSTANTIATION
  546.     void operator%= (const valarray<T>& ) const;
  547.     void operator^= (const valarray<T>& ) const;
  548.     void operator&= (const valarray<T>& ) const;
  549.     void operator|= (const valarray<T>& ) const;
  550.     void operator<<= (const valarray<T>& ) const;
  551.     void operator>>= (const valarray<T>& ) const;
  552. #endif
  553.  
  554.   private:
  555.  
  556.     slice_array();
  557.     slice_array<T>& operator= (const slice_array<T>&);
  558.  
  559.     _RW_IMP_SPACE(_RW_array<T>)*  ref_mem_array;
  560.     slice slice_;
  561.     
  562.   };
  563. /****************************************************************
  564.  *                GSLICE AND GSLICE_ARRAY                       *
  565.  ****************************************************************/
  566.  
  567.   class _RWSTDExport gslice {
  568.  
  569.   public:
  570.  
  571.     gslice()
  572.       : start_(0)
  573.       , reset_(true)
  574.     {;}
  575.          
  576.  
  577.     gslice(size_t s, const valarray<size_t>& l, const valarray<size_t>& d)
  578.       : start_(s)
  579.       , length_(l)
  580.       , stride_(d)
  581.       , reset_(true)
  582.       , r_length_((size_t)0,l.size())
  583.     {;}
  584.  
  585.     gslice(const gslice& sl) 
  586.       : start_(sl.start())
  587.       , length_(sl.size())
  588.       , stride_(sl.stride())
  589.       , reset_(true)
  590.       , r_length_((size_t)0,sl.size().size())
  591.     {;}
  592.  
  593.     size_t start() const { return start_; }
  594.     valarray<size_t> size() const { return length_; }
  595.     valarray<size_t> stride() const { return stride_; }
  596.  
  597.     size_t next_ind();
  598.     inline size_t is_reseted() const { return reset_; }
  599.     size_t ind_max() const;
  600.     size_t ind_numb() const;
  601.  
  602.   private:
  603.  
  604.     size_t start_;
  605.     valarray<size_t> length_;
  606.     valarray<size_t> stride_;
  607.  
  608.     bool reset_;
  609.     valarray<size_t>  r_length_;
  610.  
  611.   };
  612. // class gslice_array
  613.  
  614.   template <class T> class gslice_array {
  615.   public:
  616.  
  617.     typedef T value_type;
  618.  
  619.     gslice_array( _RW_IMP_SPACE(_RW_array<T>)* pt,const gslice& a ) 
  620.       :ref_mem_array(pt)
  621.       ,slice_(a)
  622.     {;}
  623.  
  624.     gslice_array(const gslice_array<T>& sl)
  625.       :ref_mem_array(sl.get_ref_mem_array())
  626.       ,slice_(sl.get_slice())
  627.     {;}
  628.  
  629.     _RW_IMP_SPACE(_RW_array<T>)* get_ref_mem_array() const { return ref_mem_array; }
  630.     gslice get_slice() const { return slice_; }
  631.  
  632.     // assignment
  633.  
  634.     void operator= (const valarray<T>& ) const;
  635.     void operator= (const T&) const;
  636.  
  637.     // computed assignment
  638.  
  639.     void operator*= (const valarray<T>& ) const;
  640.     void operator/= (const valarray<T>& ) const;
  641.     void operator+= (const valarray<T>& ) const;
  642.     void operator-= (const valarray<T>& ) const;
  643. #ifndef _RWSTD_NO_ONLY_NEEDED_INSTANTIATION
  644.     void operator%= (const valarray<T>& ) const;
  645.     void operator^= (const valarray<T>& ) const;
  646.     void operator&= (const valarray<T>& ) const;         
  647.     void operator|= (const valarray<T>& ) const;         
  648.     void operator<<= (const valarray<T>& ) const;        
  649.     void operator>>= (const valarray<T>& ) const;
  650. #endif
  651.  
  652.   private:
  653.  
  654.     gslice_array();
  655.     gslice_array<T>& operator= (const gslice_array<T>&);
  656.  
  657.     _RW_IMP_SPACE(_RW_array<T>)*  ref_mem_array;
  658.     gslice slice_;
  659.     
  660.   };
  661.  
  662.  
  663. /****************************************************************
  664.  *                         MASK_ARRAY                           *
  665.  ****************************************************************/
  666. // class mask_array
  667.  
  668.   template <class T> class  mask_array {
  669.   public:
  670.  
  671.     typedef T value_type;
  672.  
  673.     mask_array( _RW_IMP_SPACE(_RW_array<T>)* pt,const valarray<bool>& a )
  674.       :ref_mem_array(pt)
  675.       ,array(a)
  676.     {;}
  677.  
  678.     mask_array(const mask_array<T>& sl)
  679.       :ref_mem_array(sl.get_ref_mem_array())
  680.       ,array(sl.get_array())
  681.     {;}
  682.  
  683.     _RW_IMP_SPACE(_RW_array<T>)* get_ref_mem_array() const { return ref_mem_array; }
  684.     valarray<bool> get_array() const { return array; }
  685.     valarray<bool>* get_array_pt() { return &array; }
  686.  
  687.     // assignment
  688.  
  689.     void operator= (const valarray<T>& ) const;
  690.     void operator= (const T&) const;
  691.  
  692.     // computed assignment
  693.  
  694.     void operator*= (const valarray<T>& ) const;
  695.     void operator/= (const valarray<T>& ) const;
  696.     void operator+= (const valarray<T>& ) const;
  697.     void operator-= (const valarray<T>& ) const;
  698. #ifndef _RWSTD_NO_ONLY_NEEDED_INSTANTIATION
  699.     void operator%= (const valarray<T>& ) const;
  700.     void operator^= (const valarray<T>& ) const;
  701.     void operator&= (const valarray<T>& ) const;
  702.     void operator|= (const valarray<T>& ) const;
  703.     void operator<<= (const valarray<T>& ) const;
  704.     void operator>>= (const valarray<T>& ) const;
  705. #endif
  706.  
  707.   private:
  708.  
  709.     mask_array();
  710.     mask_array<T>& operator= (const mask_array<T>&); 
  711.  
  712.     _RW_IMP_SPACE(_RW_array<T>)*  ref_mem_array;
  713.     valarray<bool> array;
  714.     
  715.   };
  716.  
  717.   
  718. /****************************************************************
  719.  *                       INDIRECT_ARRAY                         *
  720.  ****************************************************************/
  721. // class indirect_array
  722.  
  723.   template <class T> class  indirect_array {
  724.   public:
  725.  
  726.     typedef T value_type;
  727.  
  728.     indirect_array( _RW_IMP_SPACE(_RW_array<T>)* pt,const valarray<size_t>& a ) 
  729.       :ref_mem_array(pt)
  730.       ,array(a)
  731.     {;}
  732.  
  733.     indirect_array(const indirect_array<T>& sl)
  734.       :ref_mem_array(sl.get_ref_mem_array())
  735.       ,array(sl.get_array())
  736.     {;}
  737.  
  738.     _RW_IMP_SPACE(_RW_array<T>)* get_ref_mem_array() const { return ref_mem_array; }
  739.     valarray<size_t> get_array() const { return array; }
  740.     valarray<size_t>* get_array_pt() { return &array; }
  741.  
  742.     // assignment
  743.  
  744.     void operator= (const valarray<T>& ) const;
  745.     void operator= (const T& ) const;
  746.  
  747.     // computed assignment
  748.  
  749.     void operator*= (const valarray<T>& ) const;
  750.     void operator/= (const valarray<T>& ) const;
  751.     void operator+= (const valarray<T>& ) const;
  752.     void operator-= (const valarray<T>& ) const;
  753. #ifndef _RWSTD_NO_ONLY_NEEDED_INSTANTIATION
  754.     void operator%= (const valarray<T>& ) const;
  755.     void operator^= (const valarray<T>& ) const;
  756.     void operator&= (const valarray<T>& ) const;
  757.     void operator|= (const valarray<T>& ) const;
  758.     void operator<<= (const valarray<T>& ) const;
  759.     void operator>>= (const valarray<T>& ) const;
  760. #endif
  761.  
  762.   private:
  763.  
  764.     indirect_array();
  765.     indirect_array<T>& operator= (const indirect_array<T>&); 
  766.  
  767.     _RW_IMP_SPACE(_RW_array<T>)*  ref_mem_array;
  768.     valarray<size_t> array;
  769.  
  770.   };
  771.  
  772. #ifndef _RWSTD_NO_NAMESPACE
  773. }
  774. #endif
  775.  
  776. #ifdef _RWSTD_NO_TEMPLATE_REPOSITORY
  777. #include <valarray.cc>
  778. #endif
  779. #endif /* __VALARRAY__ */
  780.  
  781. #ifndef __USING_STD_NAMES__
  782.   using namespace std;
  783. #endif
  784.  
  785. #pragma option pop
  786. #endif /* __VALARRAY_H */
  787.