home *** CD-ROM | disk | FTP | other *** search
/ PC Plus SuperCD (UK) 2000 May / PCP163A.iso / Runimage / Cbuilder4 / Include / VALARRAY.CC < prev    next >
Encoding:
C/C++ Source or Header  |  1999-01-26  |  80.5 KB  |  2,950 lines
  1. #ifndef __VALARRAY_CC
  2. #define __VALARRAY_CC
  3. #pragma option push -b -a8 -pc -Vx- -Ve- -w-inl -w-aus -w-sig
  4.  
  5. /***************************************************************************
  6.  *
  7.  * valaray.cc - Declarations for the Standard Library valarray
  8.  *
  9.  ***************************************************************************
  10.  *
  11.  * (c) Copyright 1994, 1998 Rogue Wave Software, Inc.
  12.  * ALL RIGHTS RESERVED
  13.  *
  14.  * The software and information contained herein are proprietary to, and
  15.  * comprise valuable trade secrets of, Rogue Wave Software, Inc., which
  16.  * intends to preserve as trade secrets such software and information.
  17.  * This software is furnished pursuant to a written license agreement and
  18.  * may be used, copied, transmitted, and stored only in accordance with
  19.  * the terms of such license and with the inclusion of the above copyright
  20.  * notice.  This software and information or any other copies thereof may
  21.  * not be provided or otherwise made available to any other person.
  22.  *
  23.  * Notwithstanding any other lease or license that may pertain to, or
  24.  * accompany the delivery of, this computer software and information, the
  25.  * rights of the Government regarding its use, reproduction and disclosure
  26.  * are as set forth in Section 52.227-19 of the FARS Computer
  27.  * Software-Restricted Rights clause.
  28.  * 
  29.  * Use, duplication, or disclosure by the Government is subject to
  30.  * restrictions as set forth in subparagraph (c)(1)(ii) of the Rights in
  31.  * Technical Data and Computer Software clause at DFARS 252.227-7013.
  32.  * Contractor/Manufacturer is Rogue Wave Software, Inc.,
  33.  * P.O. Box 2328, Corvallis, Oregon 97339.
  34.  *
  35.  * This computer software and information is distributed with "restricted
  36.  * rights."  Use, duplication or disclosure is subject to restrictions as
  37.  * set forth in NASA FAR SUP 18-52.227-79 (April 1985) "Commercial
  38.  * Computer Software-Restricted Rights (April 1985)."  If the Clause at
  39.  * 18-52.227-74 "Rights in Data General" is specified in the contract,
  40.  * then the "Alternate III" clause applies.
  41.  *
  42.  **************************************************************************/
  43.  
  44. #ifndef _RWSTD_NO_NAMESPACE
  45. namespace std {
  46. #endif
  47. /*****************************************************************
  48.  *                                                                *
  49.  *                 VALARRAY MEMBER FUNCTIONS                      *
  50.  *                                                                *
  51.  ******************************************************************/
  52. // unary operators
  53.  
  54.   template<class T>
  55.   valarray<T> valarray<T>::operator+() const
  56.   {
  57.     valarray<T> tmp_array(size());
  58.       
  59.     for(size_t ind=0; ind< size(); ind++ )
  60.       tmp_array[ind] = +memory_array[ind];
  61.  
  62.     _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  63.  
  64.     _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  65.     _tmp_ret->length = size();
  66.  
  67.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  68.  
  69.     return _tmp_ret;
  70.   }
  71.  
  72.   template <class T>
  73.   valarray<T> valarray<T>::operator-() const
  74.   {
  75.     valarray<T> tmp_array(size());
  76.       
  77.     for(size_t ind=0; ind< size(); ind++ )
  78.       tmp_array[ind] = -memory_array[ind];
  79.  
  80.     _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  81.  
  82.     _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  83.     _tmp_ret->length = size();
  84.  
  85.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  86.  
  87.     return _tmp_ret;
  88.   }
  89. #ifndef _RWSTD_NO_ONLY_NEEDED_INSTANTIATION
  90.   template <class T>
  91.   valarray<T> valarray<T>::operator~() const
  92.   {
  93.     valarray<T> tmp_array(size());
  94.  
  95.     for(size_t ind=0; ind< size(); ind++ )
  96.       tmp_array[ind] = ~memory_array[ind];
  97.  
  98.     _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  99.  
  100.     _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  101.     _tmp_ret->length = size();
  102.  
  103.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  104.  
  105.     return _tmp_ret;
  106.   }
  107.  
  108.   template <class T>
  109.   valarray<bool> valarray<T>::operator!() const
  110.   {
  111.     valarray<bool> tmp_array(size());
  112.  
  113.     for(size_t ind=0; ind< size(); ind++ )
  114.       tmp_array[ind] = !memory_array[ind];
  115.  
  116.     _RW_IMP_SPACE(_RW_temporary<bool>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<bool>);
  117.  
  118.     _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  119.     _tmp_ret->length = size();
  120.  
  121.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  122.  
  123.     return _tmp_ret;
  124.   }
  125. #endif
  126.  
  127. // computed assignment
  128.  
  129.   template <class T>
  130.   valarray<T>& valarray<T>::operator*= (const valarray<T>& array)
  131.   {
  132.     size_t upper_l = ( size() < array.size() ) ? size() : array.size();
  133.  
  134.     for(size_t ind=0; ind < upper_l; ind++)
  135.       memory_array[ind]*= array[ind];
  136.  
  137.     return *this;
  138.   }
  139.  
  140.   template <class T>
  141.   valarray<T>& valarray<T>::operator/= (const valarray<T>& array)
  142.   {
  143.     size_t upper_l = ( size() < array.size() ) ? size() : array.size();
  144.  
  145.     for(size_t ind=0; ind < upper_l; ind++)
  146.       memory_array[ind]/= array[ind];
  147.  
  148.     return *this;
  149.   }
  150.  
  151.   template <class T>
  152.   valarray<T>& valarray<T>::operator+= (const valarray<T>& array)
  153.   {
  154.     size_t upper_l = ( size() < array.size() ) ? size() : array.size();
  155.  
  156.     for(size_t ind=0; ind < upper_l; ind++)
  157.       memory_array[ind]+= array[ind];
  158.  
  159.     return *this;
  160.   }
  161.  
  162.   template <class T>
  163.   valarray<T>& valarray<T>::operator-= (const valarray<T>& array)
  164.   {
  165.     size_t upper_l = ( size() < array.size() ) ? size() : array.size();
  166.  
  167.     for(size_t ind=0; ind < upper_l; ind++)
  168.       memory_array[ind]-= array[ind];
  169.  
  170.     return *this;
  171.   }
  172.  
  173. #ifndef _RWSTD_NO_ONLY_NEEDED_INSTANTIATION
  174.   template <class T>
  175.   valarray<T>& valarray<T>::operator%= (const valarray<T>& array)
  176.   {
  177.     size_t upper_l = ( size() < array.size() ) ? size() : array.size();
  178.  
  179.     for(size_t ind=0; ind < upper_l; ind++)
  180.       memory_array[ind]%= array[ind];
  181.  
  182.     return *this;
  183.   }
  184.  
  185.   template <class T>
  186.   valarray<T>& valarray<T>::operator^= (const valarray<T>& array)
  187.   {
  188.     size_t upper_l = ( size() < array.size() ) ? size() : array.size();
  189.  
  190.     for(size_t ind=0; ind < upper_l; ind++)
  191.       memory_array[ind]^= array[ind];
  192.  
  193.     return *this;
  194.   }
  195.  
  196.   template <class T>
  197.   valarray<T>& valarray<T>::operator&= (const valarray<T>& array)
  198.   {
  199.     size_t upper_l = ( size() < array.size() ) ? size() : array.size();
  200.  
  201.     for(size_t ind=0; ind < upper_l; ind++)
  202.       memory_array[ind]&= array[ind];
  203.  
  204.     return *this;
  205.   }
  206.  
  207.   template <class T>
  208.   valarray<T>& valarray<T>::operator|= (const valarray<T>& array)
  209.   {
  210.     size_t upper_l = ( size() < array.size() ) ? size() : array.size();
  211.  
  212.     for(size_t ind=0; ind < upper_l; ind++)
  213.       memory_array[ind]|= array[ind];
  214.  
  215.     return *this;
  216.   }
  217.  
  218.   template <class T>
  219.   valarray<T>& valarray<T>::operator<<= (const valarray<T>& array)
  220.   {
  221.     size_t upper_l = ( size() < array.size() ) ? size() : array.size();
  222.  
  223.     for(size_t ind=0; ind < upper_l; ind++)
  224.       memory_array[ind]<<= array[ind];
  225.  
  226.     return *this;
  227.   }
  228.  
  229.   template <class T>
  230.   valarray<T>& valarray<T>::operator>>= (const valarray<T>& array)
  231.   {
  232.     size_t upper_l = ( size() < array.size() ) ? size() : array.size();
  233.  
  234.     for(size_t ind=0; ind < upper_l; ind++)
  235.       memory_array[ind]>>= array[ind];
  236.  
  237.     return *this;
  238.   }
  239. #endif
  240.  
  241.   template <class T>
  242.   valarray<T>& valarray<T>::operator*= (const T& val)
  243.   {
  244.     for(size_t ind=0; ind < size(); ind++)
  245.       memory_array[ind]*= val;
  246.  
  247.     return *this;
  248.   }
  249.  
  250.   template <class T>
  251.   valarray<T>& valarray<T>::operator/= (const T& val)
  252.   {
  253.     for(size_t ind=0; ind < size(); ind++)
  254.       memory_array[ind]/= val;
  255.  
  256.     return *this;
  257.   }
  258.  
  259.   template <class T>
  260.   valarray<T>& valarray<T>::operator+= (const T& val)
  261.   {
  262.     for(size_t ind=0; ind < size(); ind++)
  263.       memory_array[ind]+= val;
  264.  
  265.     return *this;
  266.   }
  267.  
  268.   template <class T>
  269.   valarray<T>& valarray<T>::operator-= (const T& val)
  270.   {
  271.     for(size_t ind=0; ind < size(); ind++)
  272.       memory_array[ind]-= val;
  273.  
  274.     return *this;
  275.   }
  276.  
  277. #ifndef _RWSTD_NO_ONLY_NEEDED_INSTANTIATION
  278.   template <class T>
  279.   valarray<T>& valarray<T>::operator%= (const T& val)
  280.   {
  281.     for(size_t ind=0; ind < size(); ind++)
  282.       memory_array[ind]%= val;
  283.  
  284.     return *this;
  285.   }
  286.  
  287.   template <class T>
  288.   valarray<T>& valarray<T>::operator^= (const T& val)
  289.   {
  290.     for(size_t ind=0; ind < size(); ind++)
  291.       memory_array[ind]^= val;
  292.  
  293.     return *this;
  294.   }
  295.  
  296.   template <class T>
  297.   valarray<T>& valarray<T>::operator&= (const T& val)
  298.   {
  299.     for(size_t ind=0; ind < size(); ind++)
  300.       memory_array[ind]&= val;
  301.  
  302.     return *this;
  303.   }
  304.  
  305.   template <class T>
  306.   valarray<T>& valarray<T>::operator|= (const T& val)
  307.   {
  308.     for(size_t ind=0; ind < size(); ind++)
  309.       memory_array[ind]|= val;
  310.  
  311.     return *this;
  312.   }
  313.  
  314.   template <class T>
  315.   valarray<T>& valarray<T>::operator<<= (const T& val)
  316.   {
  317.     for(size_t ind=0; ind < size(); ind++)
  318.       memory_array[ind]<<= val;
  319.  
  320.     return *this;
  321.   }
  322.  
  323.   template <class T>
  324.   valarray<T>& valarray<T>::operator>>= (const T& val)
  325.   {
  326.     for(size_t ind=0; ind < size(); ind++)
  327.       memory_array[ind]>>= val;
  328.  
  329.     return *this;
  330.   }
  331. #endif
  332.  
  333. // other valarray member functions
  334.  
  335.   template <class T>
  336.   T valarray<T>::sum() const
  337.   {
  338.     T tmp;
  339.     if ( size() > 0 )
  340.     {
  341.       tmp = memory_array[0];
  342.       for(size_t ind=1; ind<size(); ind++)
  343.         tmp+= memory_array[ind];
  344.     }
  345.  
  346.     return tmp;
  347.   }
  348.  
  349.   template <class T>
  350.   valarray<T> valarray<T>::shift(int sh) const
  351.   {
  352.     valarray<T> tmp_array(T(),size());
  353.       
  354.     int right=0;
  355.     int left=0;
  356.  
  357.     if ( sh < 0 ) right = -sh;
  358.     else left = sh;
  359.  
  360.     for(size_t ind=left; ind< (size()-right); ind++ )
  361.       tmp_array[ind+right-left] = memory_array[ind];
  362.  
  363.     _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  364.  
  365.     _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  366.     _tmp_ret->length = size();
  367.  
  368.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  369.  
  370.     return _tmp_ret;
  371.   } 
  372.  
  373.   template <class T>
  374.   valarray<T> valarray<T>::cshift(int sh) const
  375.   {
  376.     valarray<T> tmp_array(T(),size());
  377.       
  378.     if ( sh >= 0 )
  379.     {
  380.       for(size_t ind=0; ind< size(); ind++ )
  381.         tmp_array[ind] = memory_array[(ind+sh)%size()];
  382.     }
  383.     else
  384.     {
  385.       for(size_t ind=size()+sh; ind< (2*size()+sh); ind++ )
  386.         tmp_array[ind-size()-sh] = memory_array[ind%size()];
  387.     }
  388.  
  389.     _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  390.  
  391.     _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  392.     _tmp_ret->length = size();
  393.  
  394.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  395.  
  396.     return _tmp_ret;
  397.   } 
  398.  
  399.   template <class T>
  400.   valarray<T> valarray<T>::apply(T func(T)) const
  401.   {
  402.     valarray<T> tmp_array(size());
  403.       
  404.     for(size_t ind=0; ind< size(); ind++ )
  405.       tmp_array[ind] = func(memory_array[ind]);
  406.  
  407.     _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  408.  
  409.     _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  410.     _tmp_ret->length = size();
  411.  
  412.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  413.  
  414.     return _tmp_ret;
  415.   } 
  416.  
  417.   template <class T>
  418.   valarray<T> valarray<T>::apply(T func(const T&)) const
  419.   {
  420.     valarray<T> tmp_array(size());
  421.       
  422.     for(size_t ind=0; ind< size(); ind++ )
  423.       tmp_array[ind] = func(memory_array[ind]);
  424.  
  425.     _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  426.  
  427.     _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  428.     _tmp_ret->length = size();
  429.  
  430.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  431.  
  432.     return _tmp_ret;
  433.   } 
  434.  
  435. // operator[] for slice
  436.  
  437.   template <class T> 
  438.   valarray<T> valarray<T>::operator[](slice sl) const
  439.   {
  440.     valarray<T> tmp_array(sl.size());
  441.       
  442.     size_t ind = sl.start();
  443.     size_t cpt = 0; 
  444.  
  445.     while( cpt < sl.size() )
  446.     {
  447.       tmp_array[cpt] = memory_array[ind];
  448.       ind+= sl.stride();
  449.       cpt++;
  450.     }
  451.  
  452.     _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  453.  
  454.     _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  455.     _tmp_ret->length = sl.size();
  456.  
  457.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  458.  
  459.     return _tmp_ret;
  460.   }
  461.  
  462. // copy ctor and assignment for slice
  463.  
  464.   template <class T>
  465.   valarray<T>::valarray(const slice_array<T>& sl_ar)
  466.   {
  467.     valarray<T> tmp_array(sl_ar.get_slice().size());
  468.       
  469.     size_t ind = sl_ar.get_slice().start();
  470.     size_t cpt = 0; 
  471.  
  472.     while( cpt < sl_ar.get_slice().size() )
  473.     {
  474.       tmp_array[cpt] = (*(sl_ar.get_ref_mem_array()))[ind];
  475.       ind+= sl_ar.get_slice().stride();
  476.       cpt++;
  477.     }
  478.     memory_array._replace(tmp_array._RW_get_memory_array()._RW_get_storage(),sl_ar.get_slice().size());
  479.  
  480.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();   
  481.   }
  482.    
  483.   template <class T>
  484.   valarray<T>& valarray<T>::operator= (const slice_array<T>& sl_ar)
  485.   { 
  486.     valarray<T> tmp_array(sl_ar.get_slice().size());
  487.       
  488.     size_t ind = sl_ar.get_slice().start();
  489.     size_t cpt = 0; 
  490.  
  491.     while( cpt < sl_ar.get_slice().size() )
  492.     {
  493.       tmp_array[cpt] = (*(sl_ar.get_ref_mem_array()))[ind];
  494.       ind+= sl_ar.get_slice().stride();
  495.       cpt++;
  496.     }
  497.  
  498.     if ( &memory_array == sl_ar.get_ref_mem_array() )
  499.       memory_array._RW_resize_without_copy(0); 
  500.  
  501.     memory_array._replace(tmp_array._RW_get_memory_array()._RW_get_storage(),sl_ar.get_slice().size());
  502.  
  503.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  504.  
  505.     return *this;
  506.   }
  507.  
  508.   // operator[] for gslice
  509.  
  510.   template <class T> 
  511.   valarray<T> valarray<T>::operator[](const gslice& sl) const
  512.   {
  513.     valarray<T> tmp_array(sl.ind_numb());
  514.       
  515.     gslice *gsl = (gslice *)&sl;
  516.  
  517.     size_t ind = gsl->next_ind();
  518.     size_t cpt = 0;
  519.  
  520.     while( !sl.is_reseted() )
  521.     {
  522.       tmp_array[cpt] = memory_array[ind];
  523.       ind= gsl->next_ind();
  524.       cpt++;
  525.     }
  526.  
  527.     _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  528.  
  529.     _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  530.     _tmp_ret->length = tmp_array.size();
  531.  
  532.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  533.  
  534.     return _tmp_ret;
  535.   }
  536.  
  537. // copy ctor and assignment for gslice
  538.  
  539.   template <class T>
  540.   valarray<T>::valarray(const gslice_array<T>& sl_ar)
  541.   {
  542.     gslice sl(sl_ar.get_slice());
  543.     valarray<T> tmp_array(sl.ind_numb());
  544.  
  545.     size_t ind = sl.next_ind();
  546.     size_t cpt = 0;
  547.  
  548.     while( !sl.is_reseted() )
  549.     {
  550.       tmp_array[cpt] = (*(sl_ar.get_ref_mem_array()))[ind];
  551.       ind= sl.next_ind();
  552.       cpt++;
  553.     }
  554.  
  555.     memory_array._replace(tmp_array._RW_get_memory_array()._RW_get_storage(),tmp_array.size());
  556.  
  557.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();   
  558.   }
  559.  
  560.   template <class T>
  561.   valarray<T>& valarray<T>::operator= (const gslice_array<T>& sl_ar)
  562.   { 
  563.     gslice sl(sl_ar.get_slice());
  564.     valarray<T> tmp_array(sl.ind_numb());
  565.  
  566.     size_t ind = sl.next_ind();
  567.     size_t cpt = 0;
  568.  
  569.     while( !sl.is_reseted() )
  570.     {
  571.       tmp_array[cpt] = (*(sl_ar.get_ref_mem_array()))[ind];
  572.       ind= sl.next_ind();
  573.       cpt++;
  574.     }
  575.  
  576.     if ( &memory_array == sl_ar.get_ref_mem_array() )
  577.       memory_array._RW_resize_without_copy(0); 
  578.  
  579.     memory_array._replace(tmp_array._RW_get_memory_array()._RW_get_storage(),tmp_array.size());
  580.  
  581.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  582.  
  583.     return *this;
  584.   }
  585. // operator[] for valarray[valarray<bool>] used with mask_array
  586.   template <class T> 
  587.   valarray<T> valarray<T>::operator[](const valarray<bool>& array) const
  588.   {
  589.     size_t iter,size =0;
  590.  
  591.     for(iter=0; iter < array.size(); iter++ )
  592.       if ( array[iter] ) size++;
  593.  
  594.     valarray<T> tmp_array(size);
  595.       
  596.     size_t cpt = 0; 
  597.  
  598.     for( iter=0; iter < array.size(); iter++ )
  599.       if ( array[iter] ) tmp_array[cpt++] = memory_array[iter];
  600.  
  601.     _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  602.  
  603.     _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  604.     _tmp_ret->length = size;
  605.  
  606.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  607.  
  608.     return _tmp_ret;
  609.   }
  610.  
  611. // copy ctor and assignment for mask_array
  612.  
  613.   template <class T>
  614.   valarray<T>::valarray(const mask_array<T>& mask)
  615.   {
  616.  
  617.     mask_array<T> *msk = (mask_array<T> *)&mask;
  618.     valarray<bool>* sec = msk->get_array_pt();
  619.  
  620.     size_t iter,size =0;
  621.  
  622.     for(iter=0; iter < sec->size(); iter++ )
  623.       if ( (*sec)[iter] ) size++;
  624.  
  625.     valarray<T> tmp_array(size);
  626.       
  627.     size_t cpt = 0; 
  628.  
  629.     for( iter=0; iter < sec->size(); iter++ )
  630.       if ( (*sec)[iter] ) tmp_array[cpt++] = (*(mask.get_ref_mem_array()))[iter];
  631.  
  632.     memory_array._replace(tmp_array._RW_get_memory_array()._RW_get_storage(),size);
  633.  
  634.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();   
  635.   }
  636.  
  637.   template <class T>
  638.   valarray<T>& valarray<T>::operator= (const mask_array<T>& mask)
  639.   { 
  640.     mask_array<T> *msk = (mask_array<T> *)&mask;
  641.     valarray<bool>* sec = msk->get_array_pt();
  642.  
  643.     size_t iter,size =0;
  644.  
  645.     for(iter=0; iter < sec->size(); iter++ )
  646.       if ( (*sec)[iter] ) size++;
  647.  
  648.     valarray<T> tmp_array(size);
  649.       
  650.     size_t cpt = 0; 
  651.  
  652.     for( iter=0; iter < sec->size(); iter++ )
  653.       if ( (*sec)[iter] ) tmp_array[cpt++] = (*(mask.get_ref_mem_array()))[iter];
  654.  
  655.     if ( &memory_array == mask.get_ref_mem_array() )
  656.       memory_array._RW_resize_without_copy(0); 
  657.  
  658.     memory_array._replace(tmp_array._RW_get_memory_array()._RW_get_storage(),size);
  659.  
  660.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  661.  
  662.     return *this;
  663.   }
  664.  
  665. // operator[] for valarray[valarray<size_t>] used with indirect_array
  666.  
  667.   template <class T> 
  668.   valarray<T> valarray<T>::operator[](const valarray<size_t>& array) const
  669.   {
  670.     valarray<T> tmp_array(array.size());
  671.  
  672.     for( size_t iter=0; iter < array.size(); iter++ )
  673.       tmp_array[iter] = memory_array[array[iter]];
  674.  
  675.     _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  676.  
  677.     _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  678.     _tmp_ret->length = array.size();
  679.  
  680.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  681.  
  682.     return _tmp_ret;
  683.   }
  684.  
  685. // copy ctor and assignment for indirect_array
  686.  
  687.   template <class T>
  688.   valarray<T>::valarray(const indirect_array<T>& indir)
  689.   {
  690.  
  691.     indirect_array<T> *indr= (indirect_array<T> *)&indir;
  692.     valarray<size_t>* sec = indr->get_array_pt();
  693.  
  694.     valarray<T> tmp_array(sec->size());
  695.       
  696.     size_t cpt = 0; 
  697.  
  698.     for(size_t iter=0; iter < sec->size(); iter++ )
  699.       tmp_array[cpt++] = (*(indir.get_ref_mem_array()))[(*sec)[iter]];
  700.  
  701.     memory_array._replace(tmp_array._RW_get_memory_array()._RW_get_storage(),sec->size());
  702.  
  703.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();   
  704.   }
  705.   template <class T>
  706.   valarray<T>& valarray<T>::operator= (const indirect_array<T>& indir)
  707.   { 
  708.     indirect_array<T> *indr= (indirect_array<T> *)&indir;
  709.     valarray<size_t>* sec = indr->get_array_pt();
  710.  
  711.     valarray<T> tmp_array(sec->size());
  712.       
  713.     size_t cpt = 0; 
  714.  
  715.     for(size_t iter=0; iter < sec->size(); iter++ )
  716.       tmp_array[cpt++] = (*(indir.get_ref_mem_array()))[(*sec)[iter]];
  717.  
  718.     if ( &memory_array == indir.get_ref_mem_array() )
  719.       memory_array._RW_resize_without_copy(0); 
  720.  
  721.     memory_array._replace(tmp_array._RW_get_memory_array()._RW_get_storage(),sec->size());
  722.  
  723.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  724.  
  725.     return *this;
  726.   }
  727. /*
  728.  *
  729.  *   VALARRAY NON MEMBER FUNCTIONS
  730.  *
  731.  */
  732.   template<class T>
  733.   valarray<T> operator* (const valarray<T>& a, const valarray<T>& b)
  734.   {
  735.     size_t length= ( a.size() > b.size() ) ? b.size() : a.size();
  736.     valarray<T> tmp_array(length);
  737.  
  738.     for(size_t ind=0; ind< length; ind++ )
  739.       tmp_array[ind] = a[ind]*b[ind];
  740.  
  741.     _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  742.  
  743.     _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  744.     _tmp_ret->length = length;
  745.  
  746.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  747.  
  748.     return _tmp_ret;
  749.   }
  750.  
  751.   template<class T>
  752.   valarray<T> operator/ (const valarray<T>& a, const valarray<T>& b)
  753.   {
  754.     size_t length= ( a.size() > b.size() ) ? b.size() : a.size();
  755.     valarray<T> tmp_array(length);
  756.  
  757.     for(size_t ind=0; ind< length; ind++ )
  758.       tmp_array[ind] = a[ind]/b[ind];
  759.  
  760.     _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  761.  
  762.     _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  763.     _tmp_ret->length = length;
  764.  
  765.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  766.  
  767.     return _tmp_ret;
  768.   }
  769.  
  770.   template<class T>
  771.   valarray<T> operator% (const valarray<T>& a, const valarray<T>& b)
  772.   {
  773.     size_t length= ( a.size() > b.size() ) ? b.size() : a.size();
  774.     valarray<T> tmp_array(length);
  775.  
  776.     for(size_t ind=0; ind< length; ind++ )
  777.       tmp_array[ind] = a[ind]%b[ind];
  778.  
  779.     _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  780.  
  781.     _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  782.     _tmp_ret->length = length;
  783.  
  784.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  785.  
  786.     return _tmp_ret;
  787.   }
  788.  
  789.   template<class T>
  790.   valarray<T> operator+ (const valarray<T>& a, const valarray<T>& b)
  791.   {
  792.     size_t length= ( a.size() > b.size() ) ? b.size() : a.size();
  793.     valarray<T> tmp_array(length);
  794.  
  795.     for(size_t ind=0; ind< length; ind++ )
  796.       tmp_array[ind] = a[ind]+b[ind];
  797.  
  798.     _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  799.  
  800.     _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  801.     _tmp_ret->length = length;
  802.  
  803.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  804.  
  805.     return _tmp_ret;
  806.   }
  807.  
  808.   template<class T>
  809.   valarray<T> operator- (const valarray<T>& a, const valarray<T>& b)
  810.   {
  811.     size_t length= ( a.size() > b.size() ) ? b.size() : a.size();
  812.     valarray<T> tmp_array(length);
  813.  
  814.     for(size_t ind=0; ind< length; ind++ )
  815.       tmp_array[ind] = a[ind]-b[ind];
  816.  
  817.     _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  818.  
  819.     _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  820.     _tmp_ret->length = length;
  821.  
  822.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  823.  
  824.     return _tmp_ret;
  825.   }
  826.   template<class T>
  827.   valarray<T> operator^ (const valarray<T>& a, const valarray<T>& b)
  828.   {
  829.     size_t length= ( a.size() > b.size() ) ? b.size() : a.size();
  830.     valarray<T> tmp_array(length);
  831.  
  832.     for(size_t ind=0; ind< length; ind++ )
  833.       tmp_array[ind] = a[ind]^b[ind];
  834.  
  835.     _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  836.  
  837.     _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  838.     _tmp_ret->length = length;
  839.  
  840.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  841.  
  842.     return _tmp_ret;
  843.   }
  844.  
  845.   template<class T>
  846.   valarray<T> operator& (const valarray<T>& a, const valarray<T>& b)
  847.   {
  848.     size_t length= ( a.size() > b.size() ) ? b.size() : a.size();
  849.     valarray<T> tmp_array(length);
  850.  
  851.     for(size_t ind=0; ind< length; ind++ )
  852.       tmp_array[ind] = a[ind]&b[ind];
  853.  
  854.     _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  855.  
  856.     _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  857.     _tmp_ret->length = length;
  858.  
  859.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  860.  
  861.     return _tmp_ret;
  862.   }
  863.  
  864.   template<class T>
  865.   valarray<T> operator| (const valarray<T>& a, const valarray<T>& b)
  866.   {
  867.     size_t length= ( a.size() > b.size() ) ? b.size() : a.size();
  868.     valarray<T> tmp_array(length);
  869.  
  870.     for(size_t ind=0; ind< length; ind++ )
  871.       tmp_array[ind] = a[ind]|b[ind];
  872.  
  873.     _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  874.  
  875.     _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  876.     _tmp_ret->length = length;
  877.  
  878.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  879.  
  880.     return _tmp_ret;
  881.   }
  882.  
  883.   template<class T>
  884.   valarray<T> operator<< (const valarray<T>& a, const valarray<T>& b)
  885.   {
  886.     size_t length= ( a.size() > b.size() ) ? b.size() : a.size();
  887.     valarray<T> tmp_array(length);
  888.  
  889.     for(size_t ind=0; ind< length; ind++ )
  890.       tmp_array[ind] = a[ind]<<b[ind];
  891.  
  892.     _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  893.  
  894.     _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  895.     _tmp_ret->length = length;
  896.  
  897.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  898.  
  899.     return _tmp_ret;
  900.   }
  901.  
  902.   template<class T>
  903.   valarray<T> operator>> (const valarray<T>& a, const valarray<T>& b)
  904.   {
  905.     size_t length= ( a.size() > b.size() ) ? b.size() : a.size();
  906.     valarray<T> tmp_array(length);
  907.  
  908.     for(size_t ind=0; ind< length; ind++ )
  909.       tmp_array[ind] = a[ind]>>b[ind];
  910.  
  911.     _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  912.  
  913.     _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  914.     _tmp_ret->length = length;
  915.  
  916.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  917.  
  918.     return _tmp_ret;
  919.   }
  920.  
  921.   template<class T>
  922.   valarray<bool> operator&& (const valarray<T>& a, const valarray<T>& b)
  923.   {
  924.     size_t length= ( a.size() > b.size() ) ? b.size() : a.size();
  925.     valarray<bool> tmp_array(length);
  926.  
  927.     for(size_t ind=0; ind< length; ind++ )
  928.       tmp_array[ind] = a[ind] && b[ind];
  929.  
  930.     _RW_IMP_SPACE(_RW_temporary<bool>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<bool>);
  931.  
  932.     _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  933.     _tmp_ret->length = length;
  934.  
  935.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  936.  
  937.     return _tmp_ret;
  938.   }
  939.  
  940.   template<class T>
  941.   valarray<bool> operator|| (const valarray<T>& a, const valarray<T>& b)
  942.   {
  943.     size_t length= ( a.size() > b.size() ) ? b.size() : a.size();
  944.     valarray<bool> tmp_array(length);
  945.  
  946.     for(size_t ind=0; ind< length; ind++ )
  947.       tmp_array[ind] = a[ind] || b[ind];
  948.  
  949.     _RW_IMP_SPACE(_RW_temporary<bool>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<bool>);
  950.  
  951.     _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  952.     _tmp_ret->length = length;
  953.  
  954.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  955.  
  956.     return _tmp_ret;
  957.   }
  958.  
  959. // with non array second parameter
  960.  
  961.   template<class T>
  962.   valarray<T> operator* (const valarray<T>& a, const T& b)
  963.   {
  964.     size_t length= a.size();
  965.     valarray<T> tmp_array(length);
  966.  
  967.     for(size_t ind=0; ind< length; ind++ )
  968.       tmp_array[ind] = a[ind]*b;
  969.  
  970.     _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  971.  
  972.     _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  973.     _tmp_ret->length = length;
  974.  
  975.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  976.  
  977.     return _tmp_ret;
  978.   }
  979.  
  980.   template<class T>
  981.   valarray<T> operator/ (const valarray<T>& a, const T& b)
  982.   {
  983.     size_t length= a.size();
  984.     valarray<T> tmp_array(length);
  985.  
  986.     for(size_t ind=0; ind< length; ind++ )
  987.       tmp_array[ind] = a[ind]/b;
  988.  
  989.     _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  990.  
  991.     _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  992.     _tmp_ret->length = length;
  993.  
  994.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  995.  
  996.     return _tmp_ret;
  997.   }
  998.  
  999.   template<class T>
  1000.   valarray<T> operator% (const valarray<T>& a,const T& b)
  1001.   {
  1002.     size_t length= a.size();
  1003.     valarray<T> tmp_array(length);
  1004.  
  1005.     for(size_t ind=0; ind< length; ind++ )
  1006.       tmp_array[ind] = a[ind]%b;
  1007.  
  1008.     _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  1009.  
  1010.     _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1011.     _tmp_ret->length = length;
  1012.  
  1013.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1014.  
  1015.     return _tmp_ret;
  1016.   }
  1017.  
  1018.   template<class T>
  1019.   valarray<T> operator+ (const valarray<T>& a, const T& b)
  1020.   {
  1021.     size_t length= a.size();
  1022.     valarray<T> tmp_array(length);
  1023.  
  1024.     for(size_t ind=0; ind< length; ind++ )
  1025.       tmp_array[ind] = a[ind]+b;
  1026.  
  1027.     _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  1028.  
  1029.     _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1030.     _tmp_ret->length = length;
  1031.  
  1032.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1033.  
  1034.     return _tmp_ret;
  1035.   }
  1036.  
  1037.   template<class T>
  1038.   valarray<T> operator- (const valarray<T>& a, const T& b)
  1039.   {
  1040.     size_t length= a.size();
  1041.     valarray<T> tmp_array(length);
  1042.  
  1043.     for(size_t ind=0; ind< length; ind++ )
  1044.       tmp_array[ind] = a[ind]-b;
  1045.  
  1046.     _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  1047.  
  1048.     _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1049.     _tmp_ret->length = length;
  1050.  
  1051.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1052.  
  1053.     return _tmp_ret;
  1054.   }
  1055.   template<class T>
  1056.   valarray<T> operator^ (const valarray<T>& a, const T& b)
  1057.   {
  1058.     size_t length= a.size();
  1059.     valarray<T> tmp_array(length);
  1060.  
  1061.     for(size_t ind=0; ind< length; ind++ )
  1062.       tmp_array[ind] = a[ind]^b;
  1063.  
  1064.     _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  1065.  
  1066.     _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1067.     _tmp_ret->length = length;
  1068.  
  1069.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1070.  
  1071.     return _tmp_ret;
  1072.   }
  1073.  
  1074.   template<class T>
  1075.   valarray<T> operator& (const valarray<T>& a, const T& b)
  1076.   {
  1077.     size_t length= a.size();
  1078.     valarray<T> tmp_array(length);
  1079.  
  1080.     for(size_t ind=0; ind< length; ind++ )
  1081.       tmp_array[ind] = a[ind]&b;
  1082.  
  1083.     _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  1084.  
  1085.     _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1086.     _tmp_ret->length = length;
  1087.  
  1088.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1089.  
  1090.     return _tmp_ret;
  1091.   }
  1092.  
  1093.   template<class T>
  1094.   valarray<T> operator| (const valarray<T>& a, const T& b)
  1095.   {
  1096.     size_t length= a.size();
  1097.     valarray<T> tmp_array(length);
  1098.  
  1099.     for(size_t ind=0; ind< length; ind++ )
  1100.       tmp_array[ind] = a[ind]|b;
  1101.  
  1102.     _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  1103.  
  1104.     _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1105.     _tmp_ret->length = length;
  1106.  
  1107.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1108.  
  1109.     return _tmp_ret;
  1110.   }
  1111.  
  1112.   template<class T>
  1113.   valarray<T> operator<< (const valarray<T>& a, const T& b)
  1114.   {
  1115.     size_t length= a.size();
  1116.     valarray<T> tmp_array(length);
  1117.  
  1118.     for(size_t ind=0; ind< length; ind++ )
  1119.       tmp_array[ind] = a[ind]<<b;
  1120.  
  1121.     _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  1122.  
  1123.     _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1124.     _tmp_ret->length = length;
  1125.  
  1126.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1127.  
  1128.     return _tmp_ret;
  1129.   }
  1130.  
  1131.   template<class T>
  1132.   valarray<T> operator>> (const valarray<T>& a, const T& b)
  1133.   {
  1134.     size_t length= a.size();
  1135.     valarray<T> tmp_array(length);
  1136.  
  1137.     for(size_t ind=0; ind< length; ind++ )
  1138.       tmp_array[ind] = a[ind]>>b;
  1139.  
  1140.     _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  1141.  
  1142.     _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1143.     _tmp_ret->length = length;
  1144.  
  1145.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1146.  
  1147.     return _tmp_ret;
  1148.   }
  1149.  
  1150.   template<class T>
  1151.   valarray<bool> operator&& (const valarray<T>& a, const T& b)
  1152.   {
  1153.     size_t length= a.size();
  1154.     valarray<bool> tmp_array(length);
  1155.  
  1156.     for(size_t ind=0; ind< length; ind++ )
  1157.       tmp_array[ind] = a[ind] && b;
  1158.  
  1159.     _RW_IMP_SPACE(_RW_temporary<bool>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<bool>);
  1160.  
  1161.     _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1162.     _tmp_ret->length = length;
  1163.  
  1164.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1165.  
  1166.     return _tmp_ret;
  1167.   }
  1168.  
  1169.   template<class T>
  1170.   valarray<bool> operator|| (const valarray<T>& a, const T& b)
  1171.   {
  1172.     size_t length= a.size();
  1173.     valarray<bool> tmp_array(length);
  1174.  
  1175.     for(size_t ind=0; ind< length; ind++ )
  1176.       tmp_array[ind] = a[ind] || b;
  1177.  
  1178.     _RW_IMP_SPACE(_RW_temporary<bool>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<bool>);
  1179.  
  1180.     _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1181.     _tmp_ret->length = length;
  1182.  
  1183.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1184.  
  1185.     return _tmp_ret;
  1186.   }
  1187.  
  1188. // with non array first parameter
  1189.  
  1190.   template<class T>
  1191.   valarray<T> operator* (const T& a, const valarray<T>& b)
  1192.   {
  1193.     size_t length= b.size();
  1194.     valarray<T> tmp_array(length);
  1195.  
  1196.     for(size_t ind=0; ind< length; ind++ )
  1197.       tmp_array[ind] = a*b[ind];
  1198.  
  1199.     _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  1200.  
  1201.     _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1202.     _tmp_ret->length = length;
  1203.  
  1204.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1205.  
  1206.     return _tmp_ret;
  1207.   }
  1208.  
  1209.   template<class T>
  1210.   valarray<T> operator/ (const T& a, const valarray<T>& b)
  1211.   {
  1212.     size_t length= b.size();
  1213.     valarray<T> tmp_array(length);
  1214.  
  1215.     for(size_t ind=0; ind< length; ind++ )
  1216.       tmp_array[ind] = a/b[ind];
  1217.  
  1218.     _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  1219.  
  1220.     _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1221.     _tmp_ret->length = length;
  1222.  
  1223.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1224.  
  1225.     return _tmp_ret;
  1226.   }
  1227.  
  1228.   template<class T>
  1229.   valarray<T> operator% (const T& a, const valarray<T>& b)
  1230.   {
  1231.     size_t length= b.size();
  1232.     valarray<T> tmp_array(length);
  1233.  
  1234.     for(size_t ind=0; ind< length; ind++ )
  1235.       tmp_array[ind] = a%b[ind];
  1236.  
  1237.     _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  1238.  
  1239.     _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1240.     _tmp_ret->length = length;
  1241.  
  1242.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1243.  
  1244.     return _tmp_ret;
  1245.   }
  1246.  
  1247.   template<class T>
  1248.   valarray<T> operator+ (const T& a, const valarray<T>& b)
  1249.   {
  1250.     size_t length= b.size();
  1251.     valarray<T> tmp_array(length);
  1252.  
  1253.     for(size_t ind=0; ind< length; ind++ )
  1254.       tmp_array[ind] = a+b[ind];
  1255.  
  1256.     _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  1257.  
  1258.     _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1259.     _tmp_ret->length = length;
  1260.  
  1261.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1262.  
  1263.     return _tmp_ret;
  1264.   }
  1265.  
  1266.   template<class T>
  1267.   valarray<T> operator- (const T& a, const valarray<T>& b)
  1268.   {
  1269.     size_t length= b.size();
  1270.     valarray<T> tmp_array(length);
  1271.  
  1272.     for(size_t ind=0; ind< length; ind++ )
  1273.       tmp_array[ind] = a-b[ind];
  1274.  
  1275.     _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  1276.  
  1277.     _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1278.     _tmp_ret->length = length;
  1279.  
  1280.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1281.  
  1282.     return _tmp_ret;
  1283.   }
  1284.   template<class T>
  1285.   valarray<T> operator^ (const T& a, const valarray<T>& b)
  1286.   {
  1287.     size_t length= b.size();
  1288.     valarray<T> tmp_array(length);
  1289.  
  1290.     for(size_t ind=0; ind< length; ind++ )
  1291.       tmp_array[ind] = a^b[ind];
  1292.  
  1293.     _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  1294.  
  1295.     _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1296.     _tmp_ret->length = length;
  1297.  
  1298.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1299.  
  1300.     return _tmp_ret;
  1301.   }
  1302.  
  1303.   template<class T>
  1304.   valarray<T> operator& (const T& a, const valarray<T>& b)
  1305.   {
  1306.     size_t length= b.size();
  1307.     valarray<T> tmp_array(length);
  1308.  
  1309.     for(size_t ind=0; ind< length; ind++ )
  1310.       tmp_array[ind] = a&b[ind];
  1311.  
  1312.     _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  1313.  
  1314.     _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1315.     _tmp_ret->length = length;
  1316.  
  1317.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1318.  
  1319.     return _tmp_ret;
  1320.   }
  1321.  
  1322.   template<class T>
  1323.   valarray<T> operator| (const T& a, const valarray<T>& b)
  1324.   {
  1325.     size_t length= b.size();
  1326.     valarray<T> tmp_array(length);
  1327.  
  1328.     for(size_t ind=0; ind< length; ind++ )
  1329.       tmp_array[ind] = a|b[ind];
  1330.  
  1331.     _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  1332.  
  1333.     _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1334.     _tmp_ret->length = length;
  1335.  
  1336.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1337.  
  1338.     return _tmp_ret;
  1339.   }
  1340.  
  1341.   template<class T>
  1342.   valarray<T> operator<< (const T& a, const valarray<T>& b)
  1343.   {
  1344.     size_t length= b.size();
  1345.     valarray<T> tmp_array(length);
  1346.  
  1347.     for(size_t ind=0; ind< length; ind++ )
  1348.       tmp_array[ind] = a<<b[ind];
  1349.  
  1350.     _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  1351.  
  1352.     _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1353.     _tmp_ret->length = length;
  1354.  
  1355.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1356.  
  1357.     return _tmp_ret;
  1358.   }
  1359.  
  1360.   template<class T>
  1361.   valarray<T> operator>> (const T& a, const valarray<T>& b)
  1362.   {
  1363.     size_t length= b.size();
  1364.     valarray<T> tmp_array(length);
  1365.  
  1366.     for(size_t ind=0; ind< length; ind++ )
  1367.       tmp_array[ind] = a>>b[ind];
  1368.  
  1369.     _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  1370.  
  1371.     _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1372.     _tmp_ret->length = length;
  1373.  
  1374.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1375.  
  1376.     return _tmp_ret;
  1377.   }
  1378.  
  1379.   template<class T>
  1380.   valarray<bool> operator&& (const T& a, const valarray<T>& b)
  1381.   {
  1382.     size_t length= b.size();
  1383.     valarray<bool> tmp_array(length);
  1384.  
  1385.     for(size_t ind=0; ind< length; ind++ )
  1386.       tmp_array[ind] = a && b[ind];
  1387.  
  1388.     _RW_IMP_SPACE(_RW_temporary<bool>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<bool>);
  1389.  
  1390.     _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1391.     _tmp_ret->length = length;
  1392.  
  1393.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1394.  
  1395.     return _tmp_ret;
  1396.   }
  1397.  
  1398.   template<class T>
  1399.   valarray<bool> operator|| (const T& a, const valarray<T>& b)
  1400.   {
  1401.     size_t length= b.size();
  1402.     valarray<bool> tmp_array(length);
  1403.  
  1404.     for(size_t ind=0; ind< length; ind++ )
  1405.       tmp_array[ind] = a || b[ind];
  1406.  
  1407.     _RW_IMP_SPACE(_RW_temporary<bool>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<bool>);
  1408.  
  1409.     _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1410.     _tmp_ret->length = length;
  1411.  
  1412.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1413.  
  1414.     return _tmp_ret;
  1415.   }
  1416.  
  1417. // comparison operators
  1418.  
  1419.   template<class T>
  1420.   valarray<bool> operator== (const valarray<T>& a, const valarray<T>& b)
  1421.   {
  1422.     size_t length= ( a.size() > b.size() ) ? b.size() : a.size();
  1423.     valarray<bool> tmp_array(length);
  1424.  
  1425.     for(size_t ind=0; ind< length; ind++ )
  1426.       tmp_array[ind] = (a[ind]==b[ind]);
  1427.  
  1428.     _RW_IMP_SPACE(_RW_temporary<bool>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<bool>);
  1429.  
  1430.     _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1431.     _tmp_ret->length = length;
  1432.  
  1433.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1434.  
  1435.     return _tmp_ret;
  1436.   }
  1437.  
  1438.   template<class T>
  1439.   valarray<bool> operator!= (const valarray<T>& a, const valarray<T>& b)
  1440.   {
  1441.     size_t length= ( a.size() > b.size() ) ? b.size() : a.size();
  1442.     valarray<bool> tmp_array(length);
  1443.  
  1444.     for(size_t ind=0; ind< length; ind++ )
  1445.       tmp_array[ind] = (a[ind]!=b[ind]);
  1446.  
  1447.     _RW_IMP_SPACE(_RW_temporary<bool>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<bool>);
  1448.  
  1449.     _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1450.     _tmp_ret->length = length;
  1451.  
  1452.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1453.  
  1454.     return _tmp_ret;
  1455.   }
  1456.  
  1457.   template<class T>
  1458.   valarray<bool> operator< (const valarray<T>& a, const valarray<T>& b)
  1459.   {
  1460.     size_t length= ( a.size() > b.size() ) ? b.size() : a.size();
  1461.     valarray<bool> tmp_array(length);
  1462.  
  1463.     for(size_t ind=0; ind< length; ind++ )
  1464.       tmp_array[ind] = (a[ind]<b[ind]);
  1465.  
  1466.     _RW_IMP_SPACE(_RW_temporary<bool>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<bool>);
  1467.  
  1468.     _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1469.     _tmp_ret->length = length;
  1470.  
  1471.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1472.  
  1473.     return _tmp_ret;
  1474.   }
  1475.  
  1476.   template<class T>
  1477.   valarray<bool> operator> (const valarray<T>& a, const valarray<T>& b)
  1478.   {
  1479.     size_t length= ( a.size() > b.size() ) ? b.size() : a.size();
  1480.     valarray<bool> tmp_array(length);
  1481.  
  1482.     for(size_t ind=0; ind< length; ind++ )
  1483.       tmp_array[ind] = (a[ind]>b[ind]);
  1484.  
  1485.     _RW_IMP_SPACE(_RW_temporary<bool>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<bool>);
  1486.  
  1487.     _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1488.     _tmp_ret->length = length;
  1489.  
  1490.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1491.  
  1492.     return _tmp_ret;
  1493.   }
  1494.  
  1495.   template<class T>
  1496.   valarray<bool> operator<= (const valarray<T>& a, const valarray<T>& b)
  1497.   {
  1498.     size_t length= ( a.size() > b.size() ) ? b.size() : a.size();
  1499.     valarray<bool> tmp_array(length);
  1500.  
  1501.     for(size_t ind=0; ind< length; ind++ )
  1502.       tmp_array[ind] = (a[ind]<=b[ind]);
  1503.  
  1504.     _RW_IMP_SPACE(_RW_temporary<bool>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<bool>);
  1505.  
  1506.     _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1507.     _tmp_ret->length = length;
  1508.  
  1509.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1510.  
  1511.     return _tmp_ret;
  1512.   }
  1513.  
  1514.   template<class T>
  1515.   valarray<bool> operator>= (const valarray<T>& a, const valarray<T>& b)
  1516.   {
  1517.     size_t length= ( a.size() > b.size() ) ? b.size() : a.size();
  1518.     valarray<bool> tmp_array(length);
  1519.  
  1520.     for(size_t ind=0; ind< length; ind++ )
  1521.       tmp_array[ind] = (a[ind]>=b[ind]);
  1522.  
  1523.     _RW_IMP_SPACE(_RW_temporary<bool>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<bool>);
  1524.  
  1525.     _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1526.     _tmp_ret->length = length;
  1527.  
  1528.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1529.  
  1530.     return _tmp_ret;
  1531.   }
  1532.  
  1533. // comparison operators, non valarray second param
  1534.  
  1535.   template<class T>
  1536.   valarray<bool> operator== (const valarray<T>& a, const T& b)
  1537.   {
  1538.     size_t length= a.size();
  1539.     valarray<bool> tmp_array(length);
  1540.  
  1541.     for(size_t ind=0; ind< length; ind++ )
  1542.       tmp_array[ind] = (a[ind]==b);
  1543.  
  1544.     _RW_IMP_SPACE(_RW_temporary<bool>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<bool>);
  1545.  
  1546.     _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1547.     _tmp_ret->length = length;
  1548.  
  1549.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1550.  
  1551.     return _tmp_ret;
  1552.   }
  1553.  
  1554.   template<class T>
  1555.   valarray<bool> operator!= (const valarray<T>& a, const T& b)
  1556.   {
  1557.     size_t length= a.size();
  1558.     valarray<bool> tmp_array(length);
  1559.  
  1560.     for(size_t ind=0; ind< length; ind++ )
  1561.       tmp_array[ind] = (a[ind]!=b);
  1562.  
  1563.     _RW_IMP_SPACE(_RW_temporary<bool>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<bool>);
  1564.  
  1565.     _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1566.     _tmp_ret->length = length;
  1567.  
  1568.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1569.  
  1570.     return _tmp_ret;
  1571.   }
  1572.  
  1573.   template<class T>
  1574.   valarray<bool> operator< (const valarray<T>& a, const T& b)
  1575.   {
  1576.     size_t length= a.size();
  1577.     valarray<bool> tmp_array(length);
  1578.  
  1579.     for(size_t ind=0; ind< length; ind++ )
  1580.       tmp_array[ind] = (a[ind]<b);
  1581.  
  1582.     _RW_IMP_SPACE(_RW_temporary<bool>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<bool>);
  1583.  
  1584.     _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1585.     _tmp_ret->length = length;
  1586.  
  1587.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1588.  
  1589.     return _tmp_ret;
  1590.   }
  1591.  
  1592.   template<class T>
  1593.   valarray<bool> operator> (const valarray<T>& a, const T& b)
  1594.   {
  1595.     size_t length= a.size();
  1596.     valarray<bool> tmp_array(length);
  1597.  
  1598.     for(size_t ind=0; ind< length; ind++ )
  1599.       tmp_array[ind] = (a[ind]>b);
  1600.  
  1601.     _RW_IMP_SPACE(_RW_temporary<bool>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<bool>);
  1602.  
  1603.     _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1604.     _tmp_ret->length = length;
  1605.  
  1606.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1607.  
  1608.     return _tmp_ret;
  1609.   }
  1610.  
  1611.   template<class T>
  1612.   valarray<bool> operator<= (const valarray<T>& a, const T& b)
  1613.   {
  1614.     size_t length= a.size();
  1615.     valarray<bool> tmp_array(length);
  1616.  
  1617.     for(size_t ind=0; ind< length; ind++ )
  1618.       tmp_array[ind] = (a[ind]<=b);
  1619.  
  1620.     _RW_IMP_SPACE(_RW_temporary<bool>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<bool>);
  1621.  
  1622.     _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1623.     _tmp_ret->length = length;
  1624.  
  1625.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1626.  
  1627.     return _tmp_ret;
  1628.   }
  1629.  
  1630.   template<class T>
  1631.   valarray<bool> operator>= (const valarray<T>& a, const T& b)
  1632.   {
  1633.     size_t length= a.size();
  1634.     valarray<bool> tmp_array(length);
  1635.  
  1636.     for(size_t ind=0; ind< length; ind++ )
  1637.       tmp_array[ind] = (a[ind]>=b);
  1638.  
  1639.     _RW_IMP_SPACE(_RW_temporary<bool>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<bool>);
  1640.  
  1641.     _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1642.     _tmp_ret->length = length;
  1643.  
  1644.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1645.  
  1646.     return _tmp_ret;
  1647.   }
  1648.  
  1649. // comparison operators, non valarray first param
  1650.  
  1651.   template<class T>
  1652.   valarray<bool> operator== (const T& a, const valarray<T>& b)
  1653.   {
  1654.     size_t length= b.size();
  1655.     valarray<bool> tmp_array(length);
  1656.  
  1657.     for(size_t ind=0; ind< length; ind++ )
  1658.       tmp_array[ind] = (a==b[ind]);
  1659.  
  1660.     _RW_IMP_SPACE(_RW_temporary<bool>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<bool>);
  1661.  
  1662.     _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1663.     _tmp_ret->length = length;
  1664.  
  1665.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1666.  
  1667.     return _tmp_ret;
  1668.   }
  1669.  
  1670.   template<class T>
  1671.   valarray<bool> operator!= (const T& a, const valarray<T>& b)
  1672.   {
  1673.     size_t length= b.size();
  1674.     valarray<bool> tmp_array(length);
  1675.  
  1676.     for(size_t ind=0; ind< length; ind++ )
  1677.       tmp_array[ind] = (a!=b[ind]);
  1678.  
  1679.     _RW_IMP_SPACE(_RW_temporary<bool>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<bool>);
  1680.  
  1681.     _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1682.     _tmp_ret->length = length;
  1683.  
  1684.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1685.  
  1686.     return _tmp_ret;
  1687.   }
  1688.  
  1689.   template<class T>
  1690.   valarray<bool> operator< (const T& a, const valarray<T>& b)
  1691.   {
  1692.     size_t length= b.size();
  1693.     valarray<bool> tmp_array(length);
  1694.  
  1695.     for(size_t ind=0; ind< length; ind++ )
  1696.       tmp_array[ind] = (a<b[ind]);
  1697.  
  1698.     _RW_IMP_SPACE(_RW_temporary<bool>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<bool>);
  1699.  
  1700.     _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1701.     _tmp_ret->length = length;
  1702.  
  1703.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1704.  
  1705.     return _tmp_ret;
  1706.   }
  1707.  
  1708.   template<class T>
  1709.   valarray<bool> operator> (const T& a, const valarray<T>& b)
  1710.   {
  1711.     size_t length= b.size();
  1712.     valarray<bool> tmp_array(length);
  1713.  
  1714.     for(size_t ind=0; ind< length; ind++ )
  1715.       tmp_array[ind] = (a>b[ind]);
  1716.  
  1717.     _RW_IMP_SPACE(_RW_temporary<bool>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<bool>);
  1718.  
  1719.     _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1720.     _tmp_ret->length = length;
  1721.  
  1722.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1723.  
  1724.     return _tmp_ret;
  1725.   }
  1726.  
  1727.   template<class T>
  1728.   valarray<bool> operator<= (const T& a, const valarray<T>& b)
  1729.   {
  1730.     size_t length= b.size();
  1731.     valarray<bool> tmp_array(length);
  1732.  
  1733.     for(size_t ind=0; ind< length; ind++ )
  1734.       tmp_array[ind] = (a<=b[ind]);
  1735.  
  1736.     _RW_IMP_SPACE(_RW_temporary<bool>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<bool>);
  1737.  
  1738.     _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1739.     _tmp_ret->length = length;
  1740.  
  1741.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1742.  
  1743.     return _tmp_ret;
  1744.   }
  1745.  
  1746.   template<class T>
  1747.   valarray<bool> operator>= (const T& a, const valarray<T>& b)
  1748.   {
  1749.     size_t length= b.size();
  1750.     valarray<bool> tmp_array(length);
  1751.  
  1752.     for(size_t ind=0; ind< length; ind++ )
  1753.       tmp_array[ind] = (a>=b[ind]);
  1754.  
  1755.     _RW_IMP_SPACE(_RW_temporary<bool>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<bool>);
  1756.  
  1757.     _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1758.     _tmp_ret->length = length;
  1759.  
  1760.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1761.  
  1762.     return _tmp_ret;
  1763.   }
  1764. #ifndef _RWSTD_NO_ONLY_NEEDED_INSTANTIATION
  1765.   // min and max functions
  1766.  
  1767.   template <class T>
  1768.   T valarray<T>::min()const
  1769.   {
  1770.     T tmp;
  1771.     if ( size() > 0 )
  1772.     {
  1773.       tmp = memory_array[0];
  1774.       for(size_t ind=1; ind< size(); ind++)
  1775.         if ( memory_array[ind] < tmp )
  1776.           tmp= memory_array[ind];
  1777.     }
  1778.  
  1779.     return tmp;
  1780.   }
  1781.  
  1782.   template <class T>
  1783.   T valarray<T>::max()const
  1784.   {
  1785.     T tmp;
  1786.     if ( size() > 0 )
  1787.     {
  1788.       tmp = memory_array[0];
  1789.       for(size_t ind=1; ind< size(); ind++)
  1790.         if ( memory_array[ind] > tmp )
  1791.           tmp= memory_array[ind];
  1792.     }
  1793.  
  1794.     return tmp;
  1795.   }
  1796. #else
  1797.   template <class T>
  1798.   T min(const valarray<T>& ar)
  1799.   {
  1800.     T tmp;
  1801.     if ( ar.size() > 0 )
  1802.     {
  1803.       tmp = ar[0];
  1804.       for(size_t ind=1; ind< ar.size(); ind++)
  1805.         if ( ar[ind] < tmp )
  1806.           tmp= ar[ind];
  1807.     }
  1808.  
  1809.     return tmp;
  1810.   }
  1811.  
  1812.   template <class T>
  1813.   T max(const valarray<T>& ar)
  1814.   {
  1815.     T tmp;
  1816.     if ( ar.size() > 0 )
  1817.     {
  1818.       tmp = ar[0];
  1819.       for(size_t ind=1; ind< ar.size(); ind++)
  1820.         if ( ar[ind] > tmp )
  1821.           tmp= ar[ind];
  1822.     }
  1823.  
  1824.     return tmp;
  1825.   }
  1826. #endif   
  1827. // transcendentals
  1828.   template<class T>
  1829.   valarray<T> abs(const valarray<T>& a)
  1830.   {
  1831.     valarray<T> tmp_array(a.size());
  1832.  
  1833.     for(size_t ind=0; ind< a.size(); ind++ )
  1834. #if !defined (_RWSTD_NO_NEW_HEADER) && !defined (_RWSTD_NO_NAMESPACE)
  1835.       tmp_array[ind] = std::abs(a[ind]);             
  1836. #else
  1837.       tmp_array[ind] = ::abs(a[ind]);             
  1838. #endif
  1839.  
  1840.     // note: abs need to be overloaded for 
  1841.     // float, long double and long see (17.3.1.1)
  1842.  
  1843.     _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  1844.  
  1845.     _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1846.     _tmp_ret->length = a.size();
  1847.  
  1848.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1849.  
  1850.     return _tmp_ret;
  1851.   }
  1852.  
  1853.   template<class T>
  1854.   valarray<T> acos(const valarray<T>& a)
  1855.   {
  1856.     valarray<T> tmp_array(a.size());
  1857.  
  1858.     for(size_t ind=0; ind< a.size(); ind++ )
  1859. #if !defined (_RWSTD_NO_NEW_HEADER) && !defined (_RWSTD_NO_NAMESPACE)
  1860.       tmp_array[ind] = std::acos(a[ind]);             
  1861. #else
  1862.       tmp_array[ind] = ::acos(a[ind]);             
  1863. #endif
  1864.  
  1865.     // note: acos need to be overloaded for 
  1866.     // float, long double see (17.3.1.1)
  1867.  
  1868.     _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  1869.  
  1870.     _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1871.     _tmp_ret->length = a.size();
  1872.  
  1873.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1874.  
  1875.     return _tmp_ret;
  1876.   }
  1877.  
  1878.   template<class T>
  1879.   valarray<T> asin(const valarray<T>& a)
  1880.   {
  1881.     valarray<T> tmp_array(a.size());
  1882.  
  1883.     for(size_t ind=0; ind< a.size(); ind++ )
  1884. #if !defined (_RWSTD_NO_NEW_HEADER) && !defined (_RWSTD_NO_NAMESPACE)
  1885.       tmp_array[ind] = std::asin(a[ind]);             
  1886. #else
  1887.       tmp_array[ind] = ::asin(a[ind]);             
  1888. #endif
  1889.  
  1890.     // note: asin need to be overloaded for 
  1891.     // float, long double see (17.3.1.1)
  1892.  
  1893.     _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  1894.  
  1895.     _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1896.     _tmp_ret->length = a.size();
  1897.  
  1898.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1899.  
  1900.     return _tmp_ret;
  1901.   }
  1902.  
  1903.   template<class T>
  1904.   valarray<T> atan(const valarray<T>& a)
  1905.   {
  1906.     valarray<T> tmp_array(a.size());
  1907.  
  1908.     for(size_t ind=0; ind< a.size(); ind++ )
  1909. #if !defined (_RWSTD_NO_NEW_HEADER) && !defined (_RWSTD_NO_NAMESPACE)
  1910.       tmp_array[ind] = std::atan(a[ind]);             
  1911. #else
  1912.       tmp_array[ind] = ::atan(a[ind]);             
  1913. #endif
  1914.  
  1915.     // note: atan need to be overloaded for 
  1916.     // float, long double see (17.3.1.1)
  1917.  
  1918.     _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  1919.  
  1920.     _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1921.     _tmp_ret->length = a.size();
  1922.  
  1923.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1924.  
  1925.     return _tmp_ret;
  1926.   }
  1927.  
  1928.   template<class T>
  1929.   valarray<T> cos(const valarray<T>& a)
  1930.   {
  1931.     valarray<T> tmp_array(a.size());
  1932.  
  1933.     for(size_t ind=0; ind< a.size(); ind++ )
  1934. #if !defined (_RWSTD_NO_NEW_HEADER) && !defined (_RWSTD_NO_NAMESPACE)
  1935.       tmp_array[ind] = std::cos(a[ind]);
  1936. #else
  1937.       tmp_array[ind] = ::cos(a[ind]);
  1938. #endif
  1939.  
  1940.     // note: cos need to be overloaded for 
  1941.     // float, long double see (17.3.1.1)
  1942.  
  1943.     _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  1944.  
  1945.     _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1946.     _tmp_ret->length = a.size();
  1947.  
  1948.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1949.  
  1950.     return _tmp_ret;
  1951.   }
  1952.  
  1953.   template<class T>
  1954.   valarray<T> cosh(const valarray<T>& a)
  1955.   {
  1956.     valarray<T> tmp_array(a.size());
  1957.  
  1958.     for(size_t ind=0; ind< a.size(); ind++ )
  1959. #if !defined (_RWSTD_NO_NEW_HEADER) && !defined (_RWSTD_NO_NAMESPACE)
  1960.       tmp_array[ind] = std::cosh(a[ind]);             
  1961. #else
  1962.       tmp_array[ind] = ::cosh(a[ind]);             
  1963. #endif
  1964.  
  1965.     // note: cosh need to be overloaded for 
  1966.     // float, long double see (17.3.1.1)
  1967.  
  1968.     _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  1969.  
  1970.     _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1971.     _tmp_ret->length = a.size();
  1972.  
  1973.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1974.  
  1975.     return _tmp_ret;
  1976.   }
  1977.  
  1978.   template<class T>
  1979.   valarray<T> exp(const valarray<T>& a)
  1980.   {
  1981.     valarray<T> tmp_array(a.size());
  1982.  
  1983.     for(size_t ind=0; ind< a.size(); ind++ )
  1984. #if !defined (_RWSTD_NO_NEW_HEADER) && !defined (_RWSTD_NO_NAMESPACE)
  1985.       tmp_array[ind] = std::exp(a[ind]);             
  1986. #else
  1987.       tmp_array[ind] = ::exp(a[ind]);             
  1988. #endif
  1989.  
  1990.     // note: exp need to be overloaded for 
  1991.     // float, long double see (17.3.1.1)
  1992.  
  1993.     _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  1994.  
  1995.     _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1996.     _tmp_ret->length = a.size();
  1997.  
  1998.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1999.  
  2000.     return _tmp_ret;
  2001.   }
  2002.  
  2003.   template<class T>
  2004.   valarray<T> log(const valarray<T>& a)
  2005.   {
  2006.     valarray<T> tmp_array(a.size());
  2007.  
  2008.     for(size_t ind=0; ind< a.size(); ind++ )
  2009. #if !defined (_RWSTD_NO_NEW_HEADER) && !defined (_RWSTD_NO_NAMESPACE)
  2010.       tmp_array[ind] = std::log(a[ind]);             
  2011. #else
  2012.       tmp_array[ind] = ::log(a[ind]);             
  2013. #endif
  2014.  
  2015.     // note: log need to be overloaded for 
  2016.     // float, long double see (17.3.1.1)
  2017.  
  2018.     _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  2019.  
  2020.     _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  2021.     _tmp_ret->length = a.size();
  2022.  
  2023.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  2024.  
  2025.     return _tmp_ret;
  2026.   }
  2027.  
  2028.   template<class T>
  2029.   valarray<T> log10(const valarray<T>& a)
  2030.   {
  2031.     valarray<T> tmp_array(a.size());
  2032.  
  2033.     for(size_t ind=0; ind< a.size(); ind++ )
  2034. #if !defined (_RWSTD_NO_NEW_HEADER) && !defined (_RWSTD_NO_NAMESPACE)
  2035.       tmp_array[ind] = std::log10(a[ind]);             
  2036. #else
  2037.       tmp_array[ind] = ::log10(a[ind]);             
  2038. #endif
  2039.  
  2040.     // note: log10 need to be overloaded for 
  2041.     // float, long double see (17.3.1.1)
  2042.  
  2043.     _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  2044.  
  2045.     _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  2046.     _tmp_ret->length = a.size();
  2047.  
  2048.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  2049.  
  2050.     return _tmp_ret;
  2051.   }
  2052.  
  2053.   template<class T>
  2054.   valarray<T> sinh(const valarray<T>& a)
  2055.   {
  2056.     valarray<T> tmp_array(a.size());
  2057.  
  2058.     for(size_t ind=0; ind< a.size(); ind++ )
  2059. #if !defined (_RWSTD_NO_NEW_HEADER) && !defined (_RWSTD_NO_NAMESPACE)
  2060.       tmp_array[ind] = std::sinh(a[ind]);             
  2061. #else
  2062.       tmp_array[ind] = ::sinh(a[ind]);             
  2063. #endif
  2064.  
  2065.     // note: sinh need to be overloaded for 
  2066.     // float, long double see (17.3.1.1)
  2067.  
  2068.     _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  2069.  
  2070.     _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  2071.     _tmp_ret->length = a.size();
  2072.  
  2073.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  2074.  
  2075.     return _tmp_ret;
  2076.   }
  2077.  
  2078.   template<class T>
  2079.   valarray<T> sin(const valarray<T>& a)
  2080.   {
  2081.     valarray<T> tmp_array(a.size());
  2082.  
  2083.     for(size_t ind=0; ind< a.size(); ind++ )
  2084. #if !defined (_RWSTD_NO_NEW_HEADER) && !defined (_RWSTD_NO_NAMESPACE)
  2085.       tmp_array[ind] = std::sin(a[ind]);             
  2086. #else
  2087.       tmp_array[ind] = ::sin(a[ind]);             
  2088. #endif
  2089.  
  2090.     // note: sin need to be overloaded for 
  2091.     // float, long double see (17.3.1.1)
  2092.  
  2093.     _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  2094.  
  2095.     _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  2096.     _tmp_ret->length = a.size();
  2097.  
  2098.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  2099.  
  2100.     return _tmp_ret;
  2101.   }
  2102.  
  2103.   template<class T>
  2104.   valarray<T> sqrt(const valarray<T>& a)
  2105.   {
  2106.     valarray<T> tmp_array(a.size());
  2107.  
  2108.     for(size_t ind=0; ind< a.size(); ind++ )
  2109. #if !defined (_RWSTD_NO_NEW_HEADER) && !defined (_RWSTD_NO_NAMESPACE)
  2110.       tmp_array[ind] = std::sqrt(a[ind]);             
  2111. #else
  2112.       tmp_array[ind] = ::sqrt(a[ind]);             
  2113. #endif
  2114.  
  2115.     _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  2116.  
  2117.     _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  2118.     _tmp_ret->length = a.size();
  2119.  
  2120.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  2121.  
  2122.     return _tmp_ret;
  2123.   }
  2124.  
  2125.   template<class T>
  2126.   valarray<T> tan(const valarray<T>& a)
  2127.   {
  2128.     valarray<T> tmp_array(a.size());
  2129.  
  2130.     for(size_t ind=0; ind< a.size(); ind++ )
  2131. #if !defined (_RWSTD_NO_NEW_HEADER) && !defined (_RWSTD_NO_NAMESPACE)
  2132.       tmp_array[ind] = std::tan(a[ind]);             
  2133. #else
  2134.       tmp_array[ind] = ::tan(a[ind]);             
  2135. #endif
  2136.  
  2137.     // note: tan need to be overloaded for 
  2138.     // float, long double see (17.3.1.1)
  2139.  
  2140.     _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  2141.  
  2142.     _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  2143.     _tmp_ret->length = a.size();
  2144.  
  2145.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  2146.  
  2147.     return _tmp_ret;
  2148.   }
  2149.   template<class T>
  2150.   valarray<T> tanh(const valarray<T>& a)
  2151.   {
  2152.     valarray<T> tmp_array(a.size());
  2153.  
  2154.     for(size_t ind=0; ind< a.size(); ind++ )
  2155. #if !defined (_RWSTD_NO_NEW_HEADER) && !defined (_RWSTD_NO_NAMESPACE)
  2156.       tmp_array[ind] = std::tanh(a[ind]);             
  2157. #else
  2158.       tmp_array[ind] = ::tanh(a[ind]);             
  2159. #endif
  2160.  
  2161.     // note: tanh need to be overloaded for 
  2162.     // float, long double see (17.3.1.1)
  2163.  
  2164.     _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  2165.  
  2166.     _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  2167.     _tmp_ret->length = a.size();
  2168.  
  2169.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  2170.  
  2171.     return _tmp_ret;
  2172.   }
  2173.  
  2174.   template<class T>
  2175.   valarray<T> atan2(const valarray<T>& a, const valarray<T>& b)
  2176.   {
  2177.     size_t length= ( a.size() > b.size() ) ? b.size() : a.size();
  2178.     valarray<T> tmp_array(length);
  2179.  
  2180.     for(size_t ind=0; ind< length; ind++ )
  2181. #if !defined (_RWSTD_NO_NEW_HEADER) && !defined (_RWSTD_NO_NAMESPACE)
  2182.       tmp_array[ind] = std::atan2(a[ind],b[ind]);             
  2183. #else
  2184.       tmp_array[ind] = ::atan2(a[ind],b[ind]);             
  2185. #endif
  2186.  
  2187.     // note: atan2 need to be overloaded for 
  2188.     // float, long double see (17.3.1.1)
  2189.  
  2190.     _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  2191.  
  2192.     _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  2193.     _tmp_ret->length = length;
  2194.  
  2195.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  2196.  
  2197.     return _tmp_ret;
  2198.   }
  2199.  
  2200.   template<class T>
  2201.   valarray<T> atan2(const valarray<T>& a, const T& b)
  2202.   {
  2203.     size_t length= a.size();
  2204.     valarray<T> tmp_array(length);
  2205.  
  2206.     for(size_t ind=0; ind< length; ind++ )
  2207. #if !defined (_RWSTD_NO_NEW_HEADER) && !defined (_RWSTD_NO_NAMESPACE)
  2208.       tmp_array[ind] = std::atan2(a[ind],b);             
  2209. #else
  2210.       tmp_array[ind] = ::atan2(a[ind],b);             
  2211. #endif
  2212.  
  2213.     // note: atan2 need to be overloaded for 
  2214.     // float, long double see (17.3.1.1)
  2215.  
  2216.     _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  2217.  
  2218.     _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  2219.     _tmp_ret->length = length;
  2220.  
  2221.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  2222.  
  2223.     return _tmp_ret;
  2224.   }
  2225.  
  2226.   template<class T>
  2227.   valarray<T> atan2(const T& a, const valarray<T>& b)
  2228.   {
  2229.     size_t length= b.size();
  2230.     valarray<T> tmp_array(length);
  2231.  
  2232.     for(size_t ind=0; ind< length; ind++ )
  2233. #if !defined (_RWSTD_NO_NEW_HEADER) && !defined (_RWSTD_NO_NAMESPACE)
  2234.       tmp_array[ind] = std::atan2(a,b[ind]);             
  2235. #else
  2236.       tmp_array[ind] = ::atan2(a,b[ind]);             
  2237. #endif
  2238.  
  2239.     // note: atan2 need to be overloaded for 
  2240.     // float, long double see (17.3.1.1)
  2241.  
  2242.     _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  2243.  
  2244.     _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  2245.     _tmp_ret->length = length;
  2246.  
  2247.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  2248.  
  2249.     return _tmp_ret;
  2250.   }
  2251.  
  2252.   template<class T>
  2253.   valarray<T> pow(const valarray<T>& a, const valarray<T>& b)
  2254.   {
  2255.     size_t length= ( a.size() > b.size() ) ? b.size() : a.size();
  2256.     valarray<T> tmp_array(length);
  2257.  
  2258.     for(size_t ind=0; ind< length; ind++ )
  2259. #if !defined (_RWSTD_NO_NEW_HEADER) && !defined (_RWSTD_NO_NAMESPACE)
  2260.       tmp_array[ind] = std::pow(a[ind],b[ind]);             
  2261. #else
  2262.       tmp_array[ind] = ::pow(a[ind],b[ind]);             
  2263. #endif
  2264.  
  2265.     // note: pow need to be overloaded for 
  2266.     // float, long double see (17.3.1.1)
  2267.  
  2268.     _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  2269.  
  2270.     _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  2271.     _tmp_ret->length = length;
  2272.  
  2273.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  2274.  
  2275.     return _tmp_ret;
  2276.   }
  2277.  
  2278.   template<class T>
  2279.   valarray<T> pow(const valarray<T>& a, const T& b)
  2280.   {
  2281.     size_t length= a.size();
  2282.     valarray<T> tmp_array(length);
  2283.  
  2284.     for(size_t ind=0; ind< length; ind++ )
  2285. #if !defined (_RWSTD_NO_NEW_HEADER) && !defined (_RWSTD_NO_NAMESPACE)
  2286.       tmp_array[ind] = std::pow(a[ind],b);             
  2287. #else
  2288.       tmp_array[ind] = ::pow(a[ind],b);             
  2289. #endif
  2290.  
  2291.     // note: pow need to be overloaded for 
  2292.     // float, long double see (17.3.1.1)
  2293.  
  2294.     _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  2295.  
  2296.     _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  2297.     _tmp_ret->length = length;
  2298.  
  2299.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  2300.  
  2301.     return _tmp_ret;
  2302.   }
  2303.  
  2304.   template<class T>
  2305.   valarray<T> pow(const T& a, const valarray<T>& b)
  2306.   {
  2307.     size_t length= b.size();
  2308.     valarray<T> tmp_array(length);
  2309.  
  2310.     for(size_t ind=0; ind< length; ind++ )
  2311. #if !defined (_RWSTD_NO_NEW_HEADER) && !defined (_RWSTD_NO_NAMESPACE)
  2312.       tmp_array[ind] = std::pow(a,b[ind]);             
  2313. #else
  2314.       tmp_array[ind] = ::pow(a,b[ind]);             
  2315. #endif
  2316.  
  2317.     // note: pow need to be overloaded for 
  2318.     // float, long double see (17.3.1.1)
  2319.  
  2320.     _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  2321.  
  2322.     _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  2323.     _tmp_ret->length = length;
  2324.  
  2325.     tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  2326.  
  2327.     return _tmp_ret;
  2328.   }
  2329. /*****************************************************************
  2330.  *                                                                *
  2331.  *                 SLICE_ARRAY MEMBER FUNCTIONS                   *
  2332.  *                                                                *
  2333.  ******************************************************************/
  2334.  
  2335. // slice_array inline member functions
  2336.  
  2337.   template <class T>
  2338.   void slice_array<T>::operator= (const valarray<T>& array) const
  2339.   { 
  2340.     size_t ind = slice_.start();
  2341.     size_t cpt = 0; 
  2342.  
  2343.     while( cpt < slice_.size() )
  2344.     {
  2345.       if ( (cpt<array.size()) && (ind<ref_mem_array->_get_length()) )
  2346.         (*ref_mem_array)[ind] = array[cpt];
  2347.       ind+= slice_.stride();
  2348.       cpt++;
  2349.     }
  2350.   }
  2351.  
  2352.   template <class T>
  2353.   void slice_array<T>::operator= (const T& value) const
  2354.   { 
  2355.     size_t ind = slice_.start();
  2356.     size_t cpt = 0; 
  2357.  
  2358.     while( cpt < slice_.size() )
  2359.     {
  2360.       if ( ind<ref_mem_array->_get_length() )
  2361.         (*ref_mem_array)[ind] = value;
  2362.       ind+= slice_.stride();
  2363.       cpt++;
  2364.     }
  2365.   }
  2366. // computed assignment
  2367.  
  2368.   template <class T>
  2369.   void slice_array<T>::operator*= (const valarray<T>& array) const
  2370.   { 
  2371.     size_t ind = slice_.start();
  2372.     size_t cpt = 0; 
  2373.  
  2374.     while( cpt < slice_.size() )
  2375.     {
  2376.       if ( (cpt<array.size()) && (ind<ref_mem_array->_get_length()) )
  2377.         (*ref_mem_array)[ind] *= array[cpt];
  2378.       ind+= slice_.stride();
  2379.       cpt++;
  2380.     }
  2381.   }
  2382.  
  2383.   template <class T>
  2384.   void slice_array<T>::operator/= (const valarray<T>& array) const
  2385.   { 
  2386.     size_t ind = slice_.start();
  2387.     size_t cpt = 0; 
  2388.  
  2389.     while( cpt < slice_.size() )
  2390.     {
  2391.       if ( (cpt<array.size()) && (ind<ref_mem_array->_get_length()) )
  2392.         (*ref_mem_array)[ind] /= array[cpt];
  2393.       ind+= slice_.stride();
  2394.       cpt++;
  2395.     }
  2396.   }
  2397.  
  2398.   template <class T>
  2399.   void slice_array<T>::operator+= (const valarray<T>& array) const
  2400.   {
  2401.     size_t ind = slice_.start();
  2402.     size_t cpt = 0;
  2403.  
  2404.     while( cpt < slice_.size() )
  2405.     {
  2406.       if ( (cpt<array.size()) && (ind<ref_mem_array->_get_length()) )
  2407.         (*ref_mem_array)[ind] += array[cpt];
  2408.       ind+= slice_.stride();
  2409.       cpt++;
  2410.     }
  2411.   }
  2412.  
  2413.   template <class T>
  2414.   void slice_array<T>::operator-= (const valarray<T>& array) const
  2415.   {
  2416.     size_t ind = slice_.start();
  2417.     size_t cpt = 0;
  2418.  
  2419.     while( cpt < slice_.size() )
  2420.     {
  2421.       if ( (cpt<array.size()) && (ind<ref_mem_array->_get_length()) )
  2422.         (*ref_mem_array)[ind] -= array[cpt];
  2423.       ind+= slice_.stride();
  2424.       cpt++;
  2425.     }
  2426.   }
  2427.  
  2428. #ifndef _RWSTD_NO_ONLY_NEEDED_INSTANTIATION
  2429.   template <class T>
  2430.   void slice_array<T>::operator%= (const valarray<T>& array) const
  2431.   {
  2432.     size_t ind = slice_.start();
  2433.     size_t cpt = 0;
  2434.  
  2435.     while( cpt < slice_.size() )
  2436.     {
  2437.       if ( (cpt<array.size()) && (ind<ref_mem_array->_get_length()) )
  2438.         (*ref_mem_array)[ind] %= array[cpt];
  2439.       ind+= slice_.stride();
  2440.       cpt++;
  2441.     }
  2442.   }
  2443.  
  2444.   template <class T>
  2445.   void slice_array<T>::operator^= (const valarray<T>& array) const
  2446.   {
  2447.     size_t ind = slice_.start();
  2448.     size_t cpt = 0; 
  2449.  
  2450.     while( cpt < slice_.size() )
  2451.     {
  2452.       if ( (cpt<array.size()) && (ind<ref_mem_array->_get_length()) )
  2453.         (*ref_mem_array)[ind] ^= array[cpt];
  2454.       ind+= slice_.stride();
  2455.       cpt++;
  2456.     }
  2457.   }
  2458.  
  2459.   template <class T>
  2460.   void slice_array<T>::operator&= (const valarray<T>& array) const
  2461.   { 
  2462.     size_t ind = slice_.start();
  2463.     size_t cpt = 0; 
  2464.  
  2465.     while( cpt < slice_.size() )
  2466.     {
  2467.       if ( (cpt<array.size()) && (ind<ref_mem_array->_get_length()) )
  2468.         (*ref_mem_array)[ind] &= array[cpt];
  2469.       ind+= slice_.stride();
  2470.       cpt++;
  2471.     }
  2472.   }
  2473.  
  2474.   template <class T>
  2475.   void slice_array<T>::operator|= (const valarray<T>& array) const
  2476.   { 
  2477.     size_t ind = slice_.start();
  2478.     size_t cpt = 0; 
  2479.  
  2480.     while( cpt < slice_.size() )
  2481.     {
  2482.       if ( (cpt<array.size()) && (ind<ref_mem_array->_get_length()) )
  2483.         (*ref_mem_array)[ind] |= array[cpt];
  2484.       ind+= slice_.stride();
  2485.       cpt++;
  2486.     }
  2487.   }
  2488.  
  2489.   template <class T>
  2490.   void slice_array<T>::operator<<= (const valarray<T>& array) const
  2491.   { 
  2492.     size_t ind = slice_.start();
  2493.     size_t cpt = 0; 
  2494.  
  2495.     while( cpt < slice_.size() )
  2496.     {
  2497.       if ( (cpt<array.size()) && (ind<ref_mem_array->_get_length()) )
  2498.         (*ref_mem_array)[ind] <<= array[cpt];
  2499.       ind+= slice_.stride();
  2500.       cpt++;
  2501.     }
  2502.   }
  2503.  
  2504.   template <class T>
  2505.   void slice_array<T>::operator>>= (const valarray<T>& array) const
  2506.   { 
  2507.     size_t ind = slice_.start();
  2508.     size_t cpt = 0; 
  2509.  
  2510.     while( cpt < slice_.size() )
  2511.     {
  2512.       if ( (cpt<array.size()) && (ind<ref_mem_array->_get_length()) )
  2513.         (*ref_mem_array)[ind] >>= array[cpt];
  2514.       ind+= slice_.stride();
  2515.       cpt++;
  2516.     }
  2517.   }
  2518. #endif
  2519. /*****************************************************************
  2520.  *                                                                *
  2521.  *                 GSLICE_ARRAY MEMBER FUNCTIONS                  *
  2522.  *                                                                *
  2523.  ******************************************************************/
  2524. // gslice_array inline member functions
  2525.  
  2526.   template <class T>
  2527.   void gslice_array<T>::operator= (const valarray<T>& array) const
  2528.   {
  2529.     gslice *gsl = (gslice *)&slice_;
  2530.     size_t ind = gsl->next_ind();
  2531.     size_t cpt = 0;
  2532.  
  2533.     while( (!gsl->is_reseted()) && (cpt < array.size()) )
  2534.     {
  2535.       (*ref_mem_array)[ind] = array[cpt];
  2536.       ind= gsl->next_ind();
  2537.       cpt++;
  2538.     }
  2539.   }
  2540.  
  2541.   template <class T>
  2542.   void gslice_array<T>::operator= (const T& value) const
  2543.   { 
  2544.     gslice *gsl = (gslice *)&slice_;
  2545.     size_t ind = gsl->next_ind();
  2546.  
  2547.     while( !gsl->is_reseted() )
  2548.     {
  2549.       (*ref_mem_array)[ind] = value;
  2550.       ind= gsl->next_ind();
  2551.     }
  2552.   }
  2553. // computed assignment
  2554.  
  2555.   template <class T>
  2556.   void gslice_array<T>::operator*= (const valarray<T>& array) const
  2557.   {
  2558.     gslice *gsl = (gslice *)&slice_;
  2559.     size_t ind = gsl->next_ind();
  2560.     size_t cpt = 0;
  2561.  
  2562.     while( (!gsl->is_reseted()) && (cpt < array.size()) )
  2563.     {
  2564.       (*ref_mem_array)[ind] *= array[cpt];
  2565.       ind= gsl->next_ind();
  2566.       cpt++;
  2567.     }
  2568.   }
  2569.  
  2570.   template <class T>
  2571.   void gslice_array<T>::operator/= (const valarray<T>& array) const
  2572.   { 
  2573.     gslice *gsl = (gslice *)&slice_;
  2574.     size_t ind = gsl->next_ind();
  2575.     size_t cpt = 0;
  2576.  
  2577.     while( (!gsl->is_reseted()) && (cpt < array.size()) )
  2578.     {
  2579.       (*ref_mem_array)[ind] /= array[cpt];
  2580.       ind= gsl->next_ind();
  2581.       cpt++;
  2582.     }
  2583.   }
  2584.  
  2585.   template <class T>
  2586.   void gslice_array<T>::operator+= (const valarray<T>& array) const
  2587.   { 
  2588.     gslice *gsl = (gslice *)&slice_;
  2589.     size_t ind = gsl->next_ind();
  2590.     size_t cpt = 0;
  2591.  
  2592.     while( (!gsl->is_reseted()) && (cpt < array.size()) )
  2593.     {
  2594.       (*ref_mem_array)[ind] += array[cpt];
  2595.       ind= gsl->next_ind();
  2596.       cpt++;
  2597.     }
  2598.   }
  2599.  
  2600.   template <class T>
  2601.   void gslice_array<T>::operator-= (const valarray<T>& array) const
  2602.   { 
  2603.     gslice *gsl = (gslice *)&slice_;
  2604.     size_t ind = gsl->next_ind();
  2605.     size_t cpt = 0;
  2606.  
  2607.     while( (!gsl->is_reseted()) && (cpt < array.size()) )
  2608.     {
  2609.       (*ref_mem_array)[ind] -= array[cpt];
  2610.       ind= gsl->next_ind();
  2611.       cpt++;
  2612.     }
  2613.   }
  2614.  
  2615. #ifndef _RWSTD_NO_ONLY_NEEDED_INSTANTIATION
  2616.   template <class T>
  2617.   void gslice_array<T>::operator%= (const valarray<T>& array) const
  2618.   { 
  2619.     gslice *gsl = (gslice *)&slice_;
  2620.     size_t ind = gsl->next_ind();
  2621.     size_t cpt = 0;
  2622.  
  2623.     while( (!gsl->is_reseted()) && (cpt < array.size()) )
  2624.     {
  2625.       (*ref_mem_array)[ind] %= array[cpt];
  2626.       ind= gsl->next_ind();
  2627.       cpt++;
  2628.     }
  2629.   }
  2630.  
  2631.   template <class T>
  2632.   void gslice_array<T>::operator^= (const valarray<T>& array) const
  2633.   { 
  2634.     gslice *gsl = (gslice *)&slice_;
  2635.     size_t ind = gsl->next_ind();
  2636.     size_t cpt = 0;
  2637.  
  2638.     while( (!gsl->is_reseted()) && (cpt < array.size()) )
  2639.     {
  2640.       (*ref_mem_array)[ind] ^= array[cpt];
  2641.       ind= gsl->next_ind();
  2642.       cpt++;
  2643.     }
  2644.   }
  2645.  
  2646.   template <class T>
  2647.   void gslice_array<T>::operator&= (const valarray<T>& array) const
  2648.   { 
  2649.     gslice *gsl = (gslice *)&slice_;
  2650.     size_t ind = gsl->next_ind();
  2651.     size_t cpt = 0;
  2652.  
  2653.     while( (!gsl->is_reseted()) && (cpt < array.size()) )
  2654.     {
  2655.       (*ref_mem_array)[ind] &= array[cpt];
  2656.       ind= gsl->next_ind();
  2657.       cpt++;
  2658.     }
  2659.   }
  2660.  
  2661.   template <class T>
  2662.   void gslice_array<T>::operator|= (const valarray<T>& array) const
  2663.   { 
  2664.     gslice *gsl = (gslice *)&slice_;
  2665.     size_t ind = gsl->next_ind();
  2666.     size_t cpt = 0;
  2667.  
  2668.     while( (!gsl->is_reseted()) && (cpt < array.size()) )
  2669.     {
  2670.       (*ref_mem_array)[ind] |= array[cpt];
  2671.       ind= gsl->next_ind();
  2672.       cpt++;
  2673.     }
  2674.   }
  2675.  
  2676.   template <class T>
  2677.   void gslice_array<T>::operator<<= (const valarray<T>& array) const
  2678.   { 
  2679.     gslice *gsl = (gslice *)&slice_;
  2680.     size_t ind = gsl->next_ind();
  2681.     size_t cpt = 0;
  2682.  
  2683.     while( (!gsl->is_reseted()) && (cpt < array.size()) )
  2684.     {
  2685.       (*ref_mem_array)[ind] <<= array[cpt];
  2686.       ind= gsl->next_ind();
  2687.       cpt++;
  2688.     }
  2689.   }
  2690.  
  2691.   template <class T>
  2692.   void gslice_array<T>::operator>>= (const valarray<T>& array) const
  2693.   { 
  2694.     gslice *gsl = (gslice *)&slice_;
  2695.     size_t ind = gsl->next_ind();
  2696.     size_t cpt = 0;
  2697.  
  2698.     while( (!gsl->is_reseted()) && (cpt < array.size()) )
  2699.     {
  2700.       (*ref_mem_array)[ind] >>= array[cpt];
  2701.       ind= gsl->next_ind();
  2702.       cpt++;
  2703.     }
  2704.   }
  2705. #endif
  2706. /*****************************************************************
  2707.  *                                                                *
  2708.  *                 MASK_ARRAY MEMBER FUNCTIONS                    *
  2709.  *                                                                *
  2710.  ******************************************************************/
  2711.  
  2712. // mask_array inline member functions
  2713.  
  2714.   template <class T>
  2715.   void mask_array<T>::operator= (const valarray<T>& ar) const
  2716.   {  
  2717.     size_t cpt = 0; 
  2718.  
  2719.     for(size_t iter=0; iter < array.size(); iter++ )
  2720.       if ( array[iter] ) 
  2721.         (*ref_mem_array)[iter]= ar[cpt++];
  2722.   }
  2723.  
  2724.   template <class T>
  2725.   void mask_array<T>::operator= (const T& value) const
  2726.   {
  2727.     for(size_t iter=0; iter < array.size(); iter++ )
  2728.       if ( array[iter] )
  2729.         (*ref_mem_array)[iter]= value;
  2730.   }
  2731.   template <class T>
  2732.   void mask_array<T>::operator*= (const valarray<T>& ar) const
  2733.   {  
  2734.     size_t cpt = 0; 
  2735.  
  2736.     for(size_t iter=0; iter < array.size(); iter++ )
  2737.       if ( array[iter] ) 
  2738.         (*ref_mem_array)[iter] *= ar[cpt++];
  2739.   }
  2740.  
  2741.   template <class T>
  2742.   void mask_array<T>::operator/= (const valarray<T>& ar) const
  2743.   {  
  2744.     size_t cpt = 0; 
  2745.  
  2746.     for(size_t iter=0; iter < array.size(); iter++ )
  2747.       if ( array[iter] ) 
  2748.         (*ref_mem_array)[iter]/= ar[cpt++];
  2749.   }
  2750.  
  2751.   template <class T>
  2752.   void mask_array<T>::operator+= (const valarray<T>& ar) const
  2753.   {  
  2754.     size_t cpt = 0; 
  2755.  
  2756.     for(size_t iter=0; iter < array.size(); iter++ )
  2757.       if ( array[iter] )
  2758.         (*ref_mem_array)[iter]+= ar[cpt++];
  2759.   }
  2760.  
  2761.   template <class T>
  2762.   void mask_array<T>::operator-= (const valarray<T>& ar) const
  2763.   {  
  2764.     size_t cpt = 0;
  2765.  
  2766.     for(size_t iter=0; iter < array.size(); iter++ )
  2767.       if ( array[iter] )
  2768.         (*ref_mem_array)[iter]-= ar[cpt++];
  2769.   }
  2770. #ifndef _RWSTD_NO_ONLY_NEEDED_INSTANTIATION
  2771.  
  2772.   template <class T>
  2773.   void mask_array<T>::operator%= (const valarray<T>& ar) const
  2774.   {
  2775.     size_t cpt = 0;
  2776.  
  2777.     for(size_t iter=0; iter < array.size(); iter++ )
  2778.       if ( array[iter] )
  2779.         (*ref_mem_array)[iter]%= ar[cpt++];
  2780.   }
  2781.  
  2782.   template <class T>
  2783.   void mask_array<T>::operator^= (const valarray<T>& ar) const
  2784.   {
  2785.     size_t cpt = 0;
  2786.  
  2787.     for(size_t iter=0; iter < array.size(); iter++ )
  2788.       if ( array[iter] )
  2789.         (*ref_mem_array)[iter]^= ar[cpt++];
  2790.   }
  2791.  
  2792.   template <class T>
  2793.   void mask_array<T>::operator&= (const valarray<T>& ar) const
  2794.   {
  2795.     size_t cpt = 0;
  2796.  
  2797.     for(size_t iter=0; iter < array.size(); iter++ )
  2798.       if ( array[iter] )
  2799.         (*ref_mem_array)[iter]&= ar[cpt++];
  2800.   }
  2801.  
  2802.   template <class T>
  2803.   void mask_array<T>::operator|= (const valarray<T>& ar) const
  2804.   {
  2805.     size_t cpt = 0;
  2806.  
  2807.     for(size_t iter=0; iter < array.size(); iter++ )
  2808.       if ( array[iter] )
  2809.         (*ref_mem_array)[iter]|= ar[cpt++];
  2810.   }
  2811.  
  2812.   template <class T>
  2813.   void mask_array<T>::operator<<= (const valarray<T>& ar) const
  2814.   {
  2815.     size_t cpt = 0;
  2816.  
  2817.     for(size_t iter=0; iter < array.size(); iter++ )
  2818.       if ( array[iter] )
  2819.         (*ref_mem_array)[iter]<<= ar[cpt++];
  2820.   }
  2821.  
  2822.   template <class T>
  2823.   void mask_array<T>::operator>>= (const valarray<T>& ar) const
  2824.   {
  2825.     size_t cpt = 0;
  2826.  
  2827.     for(size_t iter=0; iter < array.size(); iter++ )
  2828.       if ( array[iter] )
  2829.         (*ref_mem_array)[iter]>>= ar[cpt++];
  2830.   }
  2831. #endif
  2832.  
  2833. /*****************************************************************
  2834.  *                                                                *
  2835.  *                 INDIRECT_ARRAY MEMBER FUNCTIONS                *
  2836.  *                                                                *
  2837.  ******************************************************************/
  2838.  
  2839. // indirect_array inline member functions
  2840.  
  2841.   template <class T>
  2842.   void indirect_array<T>::operator= (const valarray<T>& ar) const
  2843.   {
  2844.     size_t cpt=0;
  2845.  
  2846.     for(size_t iter=0; iter < array.size(); iter++ )
  2847.       (*ref_mem_array)[array[iter]] = ar[cpt++];
  2848.   }
  2849.  
  2850.   template <class T>
  2851.   void indirect_array<T>::operator= (const T& value) const
  2852.   {
  2853.     for(size_t iter=0; iter < array.size(); iter++ )
  2854.       (*ref_mem_array)[array[iter]] = value;
  2855.   }
  2856.   template <class T>
  2857.   void indirect_array<T>::operator*= (const valarray<T>& ar) const
  2858.   {
  2859.     size_t cpt=0;
  2860.  
  2861.     for(size_t iter=0; iter < array.size(); iter++ )
  2862.       (*ref_mem_array)[array[iter]] *= ar[cpt++];
  2863.   }
  2864.  
  2865.   template <class T>
  2866.   void indirect_array<T>::operator/= (const valarray<T>& ar) const
  2867.   {
  2868.     size_t cpt=0;
  2869.  
  2870.     for(size_t iter=0; iter < array.size(); iter++ )
  2871.       (*ref_mem_array)[array[iter]] /= ar[cpt++];
  2872.   }
  2873.  
  2874.   template <class T>
  2875.   void indirect_array<T>::operator+= (const valarray<T>& ar) const
  2876.   {
  2877.     size_t cpt=0;
  2878.  
  2879.     for(size_t iter=0; iter < array.size(); iter++ )
  2880.       (*ref_mem_array)[array[iter]] += ar[cpt++];
  2881.   }
  2882.  
  2883.   template <class T>
  2884.   void indirect_array<T>::operator-= (const valarray<T>& ar) const
  2885.   {
  2886.     size_t cpt=0;
  2887.  
  2888.     for(size_t iter=0; iter < array.size(); iter++ )
  2889.       (*ref_mem_array)[array[iter]] -= ar[cpt++];
  2890.   }
  2891. #ifndef _RWSTD_NO_ONLY_NEEDED_INSTANTIATION
  2892.  
  2893.   template <class T>
  2894.   void indirect_array<T>::operator%= (const valarray<T>& ar) const
  2895.   {
  2896.     size_t cpt=0;
  2897.  
  2898.     for(size_t iter=0; iter < array.size(); iter++ )
  2899.       (*ref_mem_array)[array[iter]] %= ar[cpt++];
  2900.   }
  2901.  
  2902.   template <class T>
  2903.   void indirect_array<T>::operator^= (const valarray<T>& ar) const
  2904.   {
  2905.     size_t cpt=0;
  2906.  
  2907.     for(size_t iter=0; iter < array.size(); iter++ )
  2908.       (*ref_mem_array)[array[iter]] ^= ar[cpt++];
  2909.   }
  2910.  
  2911.   template <class T>
  2912.   void indirect_array<T>::operator&= (const valarray<T>& ar) const
  2913.   { 
  2914.     size_t cpt=0;
  2915.  
  2916.     for(size_t iter=0; iter < array.size(); iter++ )
  2917.       (*ref_mem_array)[array[iter]] &= ar[cpt++];
  2918.   }
  2919.  
  2920.   template <class T>
  2921.   void indirect_array<T>::operator|= (const valarray<T>& ar) const
  2922.   { 
  2923.     size_t cpt=0;
  2924.  
  2925.     for(size_t iter=0; iter < array.size(); iter++ )
  2926.       (*ref_mem_array)[array[iter]] |= ar[cpt++];
  2927.   }
  2928.   template <class T>
  2929.   void indirect_array<T>::operator<<= (const valarray<T>& ar) const
  2930.   { 
  2931.     size_t cpt=0;
  2932.  
  2933.     for(size_t iter=0; iter < array.size(); iter++ )
  2934.       (*ref_mem_array)[array[iter]] <<= ar[cpt++];
  2935.   }
  2936.   template <class T>
  2937.   void indirect_array<T>::operator>>= (const valarray<T>& ar) const
  2938.   { 
  2939.     size_t cpt=0;
  2940.  
  2941.     for(size_t iter=0; iter < array.size(); iter++ )
  2942.       (*ref_mem_array)[array[iter]] >>= ar[cpt++];
  2943.   }
  2944. #endif
  2945. #ifndef _RWSTD_NO_NAMESPACE
  2946. }
  2947. #endif
  2948. #pragma option pop
  2949. #endif /* __VALARRAY_CC */
  2950.