stdcxx-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From vi...@apache.org
Subject svn commit: r663373 - in /stdcxx/branches/4.2.x: include/valarray tests/numerics/26.gslice.array.cassign.cpp
Date Wed, 04 Jun 2008 20:53:00 GMT
Author: vitek
Date: Wed Jun  4 13:53:00 2008
New Revision: 663373

URL: http://svn.apache.org/viewvc?rev=663373&view=rev
Log:
2008-06-04  Travis Vitek  <vitek@roguewave.com>

	STDCXX-901
	* include/valarray (gslice_array<>::operator=): Don't skip
	loop body if the slice is reset but has one element.
	(gslice_array<>::operator*=): Ditto.
	(gslice_array<>::operator/=): Ditto.
	(gslice_array<>::operator+=): Ditto.
	(gslice_array<>::operator-=): Ditto.
	(gslice_array<>::operator%=): Ditto.
	(gslice_array<>::operator^=): Ditto.
	(gslice_array<>::operator&=): Ditto.
	(gslice_array<>::operator|=): Ditto.
	(gslice_array<>::operator<<=): Ditto.
	(gslice_array<>::operator>>=): Ditto.
	(valarray<>::ctor): Ditto.
	(valarray<>::operator=): Ditto.
	* tests/numerics/26.gslice.array.cassign.cpp: New test
	for slice computed assignment operators.

Added:
    stdcxx/branches/4.2.x/tests/numerics/26.gslice.array.cassign.cpp   (with props)
Modified:
    stdcxx/branches/4.2.x/include/valarray

Modified: stdcxx/branches/4.2.x/include/valarray
URL: http://svn.apache.org/viewvc/stdcxx/branches/4.2.x/include/valarray?rev=663373&r1=663372&r2=663373&view=diff
==============================================================================
--- stdcxx/branches/4.2.x/include/valarray (original)
+++ stdcxx/branches/4.2.x/include/valarray Wed Jun  4 13:53:00 2008
@@ -1856,7 +1856,7 @@
     _RWSTD_SIZE_T __i = gsl->next_ind();
     _RWSTD_SIZE_T __cpt = 0;
 
-    while( (!gsl->is_reseted()) && (__cpt < __rhs.size()) )
+    while( (!gsl->is_reseted() || !__cpt && gsl->ind_numb()) && __cpt
< __rhs.size() )
     {
       (*_C_array)[__i] = __rhs[__cpt];
       __i= gsl->next_ind();
@@ -1869,11 +1869,13 @@
   { 
     gslice *gsl = _RWSTD_CONST_CAST (gslice*, &_C_slice);
     _RWSTD_SIZE_T __i = gsl->next_ind();
+    _RWSTD_SIZE_T __cpt = 0;
 
-    while( !gsl->is_reseted() )
+    while( !gsl->is_reseted() || !__cpt && gsl->ind_numb() )
     {
       (*_C_array)[__i] = value;
       __i= gsl->next_ind();
+      __cpt++;
     }
   }
 
@@ -1887,7 +1889,7 @@
     _RWSTD_SIZE_T __i = gsl->next_ind();
     _RWSTD_SIZE_T __cpt = 0;
 
-    while( (!gsl->is_reseted()) && (__cpt < __rhs.size()) )
+    while( (!gsl->is_reseted() || !__cpt && gsl->ind_numb()) && __cpt
< __rhs.size() )
     {
       (*_C_array)[__i] *= __rhs[__cpt];
       __i= gsl->next_ind();
@@ -1902,7 +1904,7 @@
     _RWSTD_SIZE_T __i = gsl->next_ind();
     _RWSTD_SIZE_T __cpt = 0;
 
-    while( (!gsl->is_reseted()) && (__cpt < __rhs.size()) )
+    while( (!gsl->is_reseted() || !__cpt && gsl->ind_numb()) && __cpt
< __rhs.size() )
     {
       (*_C_array)[__i] /= __rhs[__cpt];
       __i= gsl->next_ind();
@@ -1917,7 +1919,7 @@
     _RWSTD_SIZE_T __i = gsl->next_ind();
     _RWSTD_SIZE_T __cpt = 0;
 
-    while( (!gsl->is_reseted()) && (__cpt < __rhs.size()) )
+    while( (!gsl->is_reseted() || !__cpt && gsl->ind_numb()) && __cpt
< __rhs.size() )
     {
       (*_C_array)[__i] += __rhs[__cpt];
       __i= gsl->next_ind();
@@ -1932,7 +1934,7 @@
     _RWSTD_SIZE_T __i = gsl->next_ind();
     _RWSTD_SIZE_T __cpt = 0;
 
-    while( (!gsl->is_reseted()) && (__cpt < __rhs.size()) )
+    while( (!gsl->is_reseted() || !__cpt && gsl->ind_numb()) && __cpt
< __rhs.size() )
     {
       (*_C_array)[__i] -= __rhs[__cpt];
       __i= gsl->next_ind();
@@ -1948,7 +1950,7 @@
     _RWSTD_SIZE_T __i = gsl->next_ind();
     _RWSTD_SIZE_T __cpt = 0;
 
-    while( (!gsl->is_reseted()) && (__cpt < __rhs.size()) )
+    while( (!gsl->is_reseted() || !__cpt && gsl->ind_numb()) && __cpt
< __rhs.size() )
     {
       (*_C_array)[__i] %= __rhs[__cpt];
       __i= gsl->next_ind();
@@ -1963,7 +1965,7 @@
     _RWSTD_SIZE_T __i = gsl->next_ind();
     _RWSTD_SIZE_T __cpt = 0;
 
-    while( (!gsl->is_reseted()) && (__cpt < __rhs.size()) )
+    while( (!gsl->is_reseted() || !__cpt && gsl->ind_numb()) && __cpt
< __rhs.size() )
     {
       (*_C_array)[__i] ^= __rhs[__cpt];
       __i= gsl->next_ind();
@@ -1978,7 +1980,7 @@
     _RWSTD_SIZE_T __i = gsl->next_ind();
     _RWSTD_SIZE_T __cpt = 0;
 
-    while( (!gsl->is_reseted()) && (__cpt < __rhs.size()) )
+    while( (!gsl->is_reseted() || !__cpt && gsl->ind_numb()) && __cpt
< __rhs.size() )
     {
       (*_C_array)[__i] &= __rhs[__cpt];
       __i= gsl->next_ind();
@@ -1993,7 +1995,7 @@
     _RWSTD_SIZE_T __i = gsl->next_ind();
     _RWSTD_SIZE_T __cpt = 0;
 
-    while( (!gsl->is_reseted()) && (__cpt < __rhs.size()) )
+    while( (!gsl->is_reseted() || !__cpt && gsl->ind_numb()) && __cpt
< __rhs.size() )
     {
       (*_C_array)[__i] |= __rhs[__cpt];
       __i= gsl->next_ind();
@@ -2008,7 +2010,7 @@
     _RWSTD_SIZE_T __i = gsl->next_ind();
     _RWSTD_SIZE_T __cpt = 0;
 
-    while( (!gsl->is_reseted()) && (__cpt < __rhs.size()) )
+    while( (!gsl->is_reseted() || !__cpt && gsl->ind_numb()) && __cpt
< __rhs.size() )
     {
       (*_C_array)[__i] <<= __rhs[__cpt];
       __i= gsl->next_ind();
@@ -2023,7 +2025,7 @@
     _RWSTD_SIZE_T __i = gsl->next_ind();
     _RWSTD_SIZE_T __cpt = 0;
 
-    while( (!gsl->is_reseted()) && (__cpt < __rhs.size()) )
+    while( (!gsl->is_reseted() || !__cpt && gsl->ind_numb()) && __cpt
< __rhs.size() )
     {
       (*_C_array)[__i] >>= __rhs[__cpt];
       __i= gsl->next_ind();
@@ -2146,13 +2148,15 @@
 {
     gslice __sl(sl_ar._C_get_slice());
 
+    const _RWSTD_SIZE_T __maxinx = __sl.ind_numb ();
+
     _RW::__rw_array <_TypeT> __tmp =
-        _RW::__rw_array <_TypeT>(_TypeT (), __sl.ind_numb());
+        _RW::__rw_array <_TypeT>(_TypeT (), __maxinx);
 
     _RWSTD_SIZE_T __i = __sl.next_ind();
     _RWSTD_SIZE_T __cpt = 0;
 
-    while( !__sl.is_reseted() )
+    while( !__sl.is_reseted() || !__cpt && __maxinx )
     {
       __tmp[__cpt] = (*(sl_ar.get_ref_mem_array()))[__i];
       __i= __sl.next_ind();
@@ -2169,13 +2173,15 @@
 { 
     gslice __sl(sl_ar._C_get_slice());
 
+    const _RWSTD_SIZE_T __maxinx = __sl.ind_numb ();
+
     _RW::__rw_array <_TypeT> __tmp =
-        _RW::__rw_array <_TypeT>(_TypeT (), __sl.ind_numb());
+        _RW::__rw_array <_TypeT>(_TypeT (), __maxinx);
 
     _RWSTD_SIZE_T __i = __sl.next_ind();
     _RWSTD_SIZE_T __cpt = 0;
 
-    while( !__sl.is_reseted() )
+    while( !__sl.is_reseted() || !__cpt && __maxinx )
     {
       __tmp[__cpt] = (*(sl_ar.get_ref_mem_array()))[__i];
       __i= __sl.next_ind();

Added: stdcxx/branches/4.2.x/tests/numerics/26.gslice.array.cassign.cpp
URL: http://svn.apache.org/viewvc/stdcxx/branches/4.2.x/tests/numerics/26.gslice.array.cassign.cpp?rev=663373&view=auto
==============================================================================
--- stdcxx/branches/4.2.x/tests/numerics/26.gslice.array.cassign.cpp (added)
+++ stdcxx/branches/4.2.x/tests/numerics/26.gslice.array.cassign.cpp Wed Jun  4 13:53:00 2008
@@ -0,0 +1,558 @@
+/***************************************************************************
+ *
+ * 26.valarray.cassign.cpp - tests exercising valarray computed assignment
+ *
+ * $Id$
+ *
+ ***************************************************************************
+ *
+ * Licensed to the Apache Software  Foundation (ASF) under one or more
+ * contributor  license agreements.  See  the NOTICE  file distributed
+ * with  this  work  for  additional information  regarding  copyright
+ * ownership.   The ASF  licenses this  file to  you under  the Apache
+ * License, Version  2.0 (the  "License"); you may  not use  this file
+ * except in  compliance with the License.   You may obtain  a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the  License is distributed on an  "AS IS" BASIS,
+ * WITHOUT  WARRANTIES OR CONDITIONS  OF ANY  KIND, either  express or
+ * implied.   See  the License  for  the  specific language  governing
+ * permissions and limitations under the License.
+ *
+ * Copyright (C) 2007-2008 Rogue Wave Software, Inc.
+ *
+ **************************************************************************/
+
+#include <cstdlib>       // for free(), strtod(), size_t
+#include <valarray>      // for indirect_array, valarray
+
+//#include <rw_value.h>    // for UserClass
+#include <driver.h>      // for rw_test()
+#include <rw_printf.h>   // for rw_asnprintf()
+
+/**************************************************************************/
+
+// returns an array of size elements of type T constructed from a string
+// of comma-separated values
+static std::valarray<std::size_t>
+make_array (const char *s)
+{
+    std::size_t buf [256];
+    bool repeat = false;
+
+    std::size_t i = 0;
+    while (s && *s) {
+
+        char *end;
+        unsigned long val = std::strtoul (s, &end, 10);
+
+        RW_ASSERT ('\0' == *end || ',' == *end || '@' == *end);
+
+        if (!repeat)
+        {
+            buf [i++] = std::size_t (val);
+        }
+        else
+        {
+            const std::size_t n = buf [i-1];
+
+            for (std::size_t j = 0; j < (val - 1); ++j)
+                buf [i+j] = n;
+            i += (val - 1);
+        }
+
+        if ('\0' == *end)
+            break;
+
+        s = end + 1;
+        repeat = '@' == *end;
+    }
+
+    return std::valarray<std::size_t>(buf, i);
+}
+
+/**************************************************************************/
+
+void
+test_op_assign (void*,
+                void  (std::gslice_array<std::size_t>::*op_assign)(const std::valarray<std::size_t>&)
const,
+                const char *tname,     // T's type name
+                const char *opname,    // which assignment operator
+                int         line,      // test case line number
+                std::size_t start,     // start index of slice
+                const char *length_str,// number of strides
+                const char *stride_str,// length of stride
+                const char *lhs_str,   // original array
+                const char *rhs_str,   // right hand side of assignment
+                const char *res_str)   // result of assignment
+{
+    // create an array of values from the string length_str
+    // representing the length array of the slice
+    const std::valarray<std::size_t> lengths (make_array (length_str));
+
+    // create an array of values from the string stride_str
+    // representing the stride array of the slice
+    const std::valarray<std::size_t> strides (make_array (stride_str));
+
+    // valarray(s)[gslice(start, length, stride)] op= rhs
+
+    const std::gslice gsl (start, lengths, strides);
+
+    // create an array of values from the string lhs_str
+    // representing the left-hand side array before slicing
+    /* const */ std::valarray<std::size_t> lhs_va (make_array (lhs_str));
+
+    // create an array of values from the string rhs_str
+    // representing the right-hand side argument of the assignment
+    const std::valarray<std::size_t> rhs_va (make_array (rhs_str));
+
+    // create an array of values from the string res_str
+    // representing the result of the assignment
+    const std::valarray<std::size_t> res_va (make_array (res_str));
+
+    // verify sizes match
+    RW_ASSERT (lhs_va.size () == res_va.size ());
+
+    // take a gslice of lhs_va, this is the lhs of the assignment
+    std::gslice_array<std::size_t>& lhs_ga = lhs_va [gsl];
+
+    char*       fname = 0;
+    std::size_t size  = 0;
+
+    // format the name of the function call to be used in diagnostic
+    // messages below
+    rw_asnprintf (&fname, &size,
+                  "gslice_array<%s>(%s) %s std::valarray<%1$s>(%s)",
+                  tname, lhs_str, opname, rhs_str);
+
+    // invoke the assignment operator through the member pointer
+    (lhs_ga.*op_assign)(rhs_va);
+
+    // verify the element values
+    for (std::size_t i = 0; i != lhs_va.size (); ++i) {
+        if (!rw_assert (lhs_va [i] == res_va [i], 0, line,
+                        "line %d. %s: element at index %zu == %zu, got %zu",
+                        __LINE__, fname, i, res_va [i], lhs_va [i]))
+            break;
+
+    }
+
+    std::free (fname);
+}
+
+
+/**************************************************************************/
+
+#define OP(start, lengths, strides, lhs, rhs, res) \
+    test_op_assign ((T*)0, op, tname, opname, __LINE__, start, lengths, strides, lhs, rhs,
res)
+
+
+template <class T>
+void test_mul_assign (const T*, const char *tname, const char *opname)
+{
+    rw_info (0, 0, __LINE__,
+             "std::gslice_array<%s>::operator%s (const std::valarray<%1$s>&)",
+             tname, opname);
+
+    void (std::gslice_array<T>::*op)(const std::valarray<T>&) const =
+        &std::gslice_array<T>::operator*=;
+
+    //  +- start
+    //  |  +- lengths
+    //  |  |    +- strides      +- rhs
+    //  |  |    |    +- lhs     |    +- expect
+    //  v  v    v    v          v    v
+    OP (0, "",  "",  "1@4",     "2", "1@4");
+    OP (0, "0", "1", "1@4",     "2", "1@4");
+    OP (2, "0", "9", "1@4",     "2", "1@4");
+    OP (3, "0", "2", "1@4",     "7", "1@4");
+
+    OP (0, "1", "1", "1@4",     "5",   "5,1@3");
+    OP (2, "1", "1", "1@4",     "5", "1,1,5,1");
+
+    OP (1, "2", "1", "1@4",     "3,4", "1,3,4,1");
+    OP (1, "1", "2", "2@4",       "2", "2,4,2,2");
+
+    OP (0, "2,1", "2,3", "2@4", "3,7", "6,2,14,2");
+    OP (1, "1,0", "2,3", "3@4",   "3",  "3,9,3,3");
+}
+
+/**************************************************************************/
+
+template <class T>
+void test_div_assign (const T*, const char *tname, const char *opname)
+{
+    rw_info (0, 0, __LINE__,
+             "std::gslice_array<%s>::operator%s (const std::valarray<%1$s>&)",
+             tname, opname);
+
+    void (std::gslice_array<T>::*op)(const std::valarray<T>&) const =
+        &std::gslice_array<T>::operator/=;
+
+    OP (0, "",  "",  "1@4",     "2", "1@4");
+    OP (0, "0", "1", "1@4",     "2", "1@4");
+    OP (2, "0", "9", "1@4",     "2", "1@4");
+    OP (3, "0", "2", "1@4",     "7", "1@4");
+
+    OP (0, "1", "1", "10@4",    "5",     "2,10@3");
+    OP (2, "1", "1", "12@4",    "5", "12,12,2,12");
+
+    OP (1, "2", "1", "12@4",    "3,4", "12,4,3,12");
+    OP (1, "1", "2", "6@4",       "2",   "6,3,6,6");
+
+    OP (0, "2,1", "2,3", "42@4", "3,7", "14,42,6,42");
+    OP (1, "1,0", "2,3",  "3@4",   "3",    "3,1,3,3");
+}
+
+/**************************************************************************/
+
+template <class T>
+void test_mod_assign (const T*, const char *tname, const char *opname)
+{
+    rw_info (0, 0, __LINE__,
+             "std::gslice_array<%s>::operator%s (const std::valarray<%1$s>&)",
+             tname, opname);
+
+    void (std::gslice_array<T>::*op)(const std::valarray<T>&) const =
+        &std::gslice_array<T>::operator%=;
+
+    OP (0, "",  "",  "1@4",     "2", "1@4");
+    OP (0, "0", "1", "1@4",     "2", "1@4");
+    OP (2, "0", "9", "1@4",     "2", "1@4");
+    OP (3, "0", "2", "1@4",     "7", "1@4");
+
+    OP (0, "1", "1", "10@4",    "5",     "0,10@3");
+    OP (2, "1", "1", "12@4",    "5", "12,12,2,12");
+
+    OP (1, "2", "1", "12@4",    "3,4", "12,0,0,12");
+    OP (1, "1", "2", "7@4",       "2",   "7,1,7,7");
+
+    OP (0, "2,1", "2,3", "14@4", "3,7", "2,14,0,14");
+    OP (1, "1,0", "2,3",  "3@4",   "3",   "3,0,3,3");
+}
+
+/**************************************************************************/
+
+template <class T>
+void test_add_assign (const T*, const char *tname, const char *opname)
+{
+    rw_info (0, 0, __LINE__,
+             "std::valarray<%s>::operator%s (const std::valarray<%1$s>&)",
+             tname, opname);
+
+    void (std::gslice_array<T>::*op)(const std::valarray<T>&) const =
+        &std::gslice_array<T>::operator+=;
+
+    OP (0, "",  "",  "1@4",     "2", "1@4");
+    OP (0, "0", "1", "1@4",     "2", "1@4");
+    OP (2, "0", "9", "1@4",     "2", "1@4");
+    OP (3, "0", "2", "1@4",     "7", "1@4");
+
+    OP (0, "1", "1", "1@4",    "5",   "6,1@3");
+    OP (2, "1", "1", "2@4",    "5", "2,2,7,2");
+
+    OP (1, "2", "1", "3@4",    "3,4", "3,6,7,3");
+    OP (1, "1", "2", "7@4",      "2", "7,9,7,7");
+
+    OP (0, "2,1", "2,3", "1@4", "3,7", "4,1,8,1");
+    OP (1, "1,0", "2,3", "3@4",   "3", "3,6,3,3");
+}
+
+/**************************************************************************/
+
+template <class T>
+void test_sub_assign (const T*, const char *tname, const char *opname)
+{
+    rw_info (0, 0, __LINE__,
+             "std::gslice_array<%s>::operator%s (const std::valarray<%1$s>&)",
+             tname, opname);
+
+    void (std::gslice_array<T>::*op)(const std::valarray<T>&) const =
+        &std::gslice_array<T>::operator-=;
+
+    OP (0, "",  "",  "1@4",     "2", "1@4");
+    OP (0, "0", "1", "1@4",     "2", "1@4");
+    OP (2, "0", "9", "1@4",     "2", "1@4");
+    OP (3, "0", "2", "1@4",     "7", "1@4");
+
+    OP (0, "1", "1", "9@4",    "5",   "4,9@3");
+    OP (2, "1", "1", "7@4",    "5", "7,7,2,7");
+
+    OP (1, "2", "1", "3@4",    "3,2", "3,0,1,3");
+    OP (1, "1", "2", "7@4",      "2", "7,5,7,7");
+
+    OP (0, "2,1", "2,3", "7@4", "3,7", "4,7,0,7");
+    OP (1, "1,0", "2,3", "3@4",   "3", "3,0,3,3");
+}
+
+/**************************************************************************/
+
+template <class T>
+void test_xor_assign (const T*, const char *tname, const char *opname)
+{
+    rw_info (0, 0, __LINE__,
+             "std::gslice_array<%s>::operator%s (const std::valarray<%1$s>&)",
+             tname, opname);
+
+   void (std::gslice_array<T>::*op)(const std::valarray<T>&) const =
+        &std::gslice_array<T>::operator^=;
+
+    OP (0, "",  "",  "1@4",     "2", "1@4");
+    OP (0, "0", "1", "1@4",     "2", "1@4");
+    OP (2, "0", "9", "1@4",     "2", "1@4");
+    OP (3, "0", "2", "1@4",     "7", "1@4");
+
+    OP (0, "1", "1", "9@4",    "5",   "12,9@3");
+    OP (2, "1", "1", "7@4",    "5", "7,7,2,7");
+
+    OP (1, "2", "1", "3@4",    "3,4", "3,0,7,3");
+    OP (1, "1", "2", "7@4",      "2", "7,5,7,7");
+
+    OP (0, "2,1", "2,3", "7@4", "3,7", "4,7,0,7");
+    OP (1, "1,0", "2,3", "3@4",   "3", "3,0,3,3");
+}
+
+/**************************************************************************/
+
+template <class T>
+void test_and_assign (const T*, const char *tname, const char *opname)
+{
+    rw_info (0, 0, __LINE__,
+             "std::valarray<%s>::operator%s (const std::valarray<%1$s>&)",
+             tname, opname);
+
+    void (std::gslice_array<T>::*op)(const std::valarray<T>&) const =
+        &std::gslice_array<T>::operator&=;
+
+    OP (0, "",  "",  "1@4",     "2", "1@4");
+    OP (0, "0", "1", "1@4",     "2", "1@4");
+    OP (2, "0", "9", "1@4",     "2", "1@4");
+    OP (3, "0", "2", "1@4",     "7", "1@4");
+
+    OP (0, "1", "1", "9@4",    "5",   "1,9@3");
+    OP (2, "1", "1", "7@4",    "5", "7,7,5,7");
+
+    OP (1, "2", "1", "3@4",    "3,4", "3,3,0,3");
+    OP (1, "1", "2", "7@4",      "2", "7,2,7,7");
+
+    OP (0, "2,1", "2,3", "7@4", "3,2", "3,7,2,7");
+    OP (1, "1,0", "2,3", "3@4",   "1", "3,1,3,3");
+}
+
+/**************************************************************************/
+
+template <class T>
+void test_or_assign (const T*, const char *tname, const char *opname)
+{
+    rw_info (0, 0, __LINE__,
+             "std::gslice_array<%s>::operator%s (const std::valarray<%1$s>&)",
+             tname, opname);
+
+    void (std::gslice_array<T>::*op)(const std::valarray<T>&) const =
+        &std::gslice_array<T>::operator|=;
+
+    OP (0, "",  "",  "1@4",     "2", "1@4");
+    OP (0, "0", "1", "1@4",     "2", "1@4");
+    OP (2, "0", "9", "1@4",     "2", "1@4");
+    OP (3, "0", "2", "1@4",     "7", "1@4");
+
+    OP (0, "1", "1", "9@4",    "5",   "13,9@3");
+    OP (2, "1", "1", "7@4",    "5", "7,7,7,7");
+
+    OP (1, "2", "1", "3@4",    "3,4", "3,3,7,3");
+    OP (1, "1", "2", "7@4",      "2", "7,7,7,7");
+
+    OP (0, "2,1", "2,3", "4@4", "3,7", "7,4,7,4");
+    OP (1, "1,0", "2,3", "3@4",   "4", "3,7,3,3");
+}
+
+/**************************************************************************/
+
+template <class T>
+void test_shl_assign (const T*, const char *tname, const char *opname)
+{
+    rw_info (0, 0, __LINE__,
+             "std::gslice_array<%s>::operator%s (const std::valarray<%1$s>&)",
+             tname, opname);
+
+    void (std::gslice_array<T>::*op)(const std::valarray<T>&) =
+        &std::gslice_array<T>::operator<<=;
+
+    OP (0, "",  "",  "1@4",     "2", "1@4");
+    OP (0, "0", "1", "1@4",     "2", "1@4");
+    OP (2, "0", "9", "1@4",     "2", "1@4");
+    OP (3, "0", "2", "1@4",     "7", "1@4");
+
+    OP (0, "1", "1", "1@4",    "1",   "2,1@3");
+    OP (2, "1", "1", "2@4",    "1", "2,2,4,2");
+
+    OP (1, "2", "1", "1@4",    "3,4",  "1,4,8,1");
+    OP (1, "1", "2", "3@4",      "2", "3,12,3,3");
+
+    OP (0, "2,1", "2,3", "1@4", "3,2",  "8,1,4,1");
+    OP (1, "1,0", "2,3", "5@4",   "3", "5,20,5,5");
+}
+
+/**************************************************************************/
+
+template <class T>
+void test_shr_assign (const T*, const char *tname, const char *opname)
+{
+    rw_info (0, 0, __LINE__,
+             "std::gslice_array<%s>::operator%s (const std::valarray<%1$s>&)",
+             tname, opname);
+
+    void (std::gslice_array<T>::*op)(const std::valarray<T>&) const =
+        &std::gslice_array<T>::operator>>=;
+
+    OP (0, "",  "",  "1@4",     "2", "1@4");
+    OP (0, "0", "1", "1@4",     "2", "1@4");
+    OP (2, "0", "9", "1@4",     "2", "1@4");
+    OP (3, "0", "2", "1@4",     "7", "1@4");
+
+    OP (0, "1", "1", "1@4",    "1",   "0,1@3");
+    OP (2, "1", "1", "2@4",    "1", "2,2,1,2");
+
+    OP (1, "2", "1", "9@4",    "3,4", "9,1,0,9");
+    OP (1, "1", "2", "9@4",      "2", "9,2,9,9");
+
+    OP (0, "2,1", "2,3", "14@4", "3,2", "1,14,3,14");
+    OP (1, "1,0", "2,3", "5@4",    "3",   "5,0,5,5");
+}
+
+/**************************************************************************/
+
+enum {
+    inx_mul_assign,
+    inx_div_assign,
+    inx_mod_assign,
+    inx_add_assign,
+    inx_sub_assign,
+    inx_xor_assign,
+    inx_and_assign,
+    inx_or_assign,
+    inx_shl_assign,
+    inx_shr_assign,
+    n_assign_ops
+};
+
+static int opt_assign [n_assign_ops];
+
+
+template <class T>
+void test_op_assign (const T*, const char *tname)
+{
+    const std::size_t nassigns = sizeof opt_assign / sizeof *opt_assign;
+    for (std::size_t i = 0; i != nassigns; ++i) {
+        if (0 < opt_assign [i]) {
+            for (std::size_t j = 0; j != nassigns; ++j) {
+                if (0 == opt_assign [j])
+                    opt_assign [j] = -1;
+            }
+            break;
+        }
+    }
+
+    if (rw_note (0 <= opt_assign [inx_mul_assign], 0, __LINE__,
+                 "tests of operator*= disabled"))
+        test_mul_assign ((const T*)0, tname, "*=");
+
+    if (rw_note (0 <= opt_assign [inx_div_assign], 0, __LINE__,
+                 "tests of operator/= disabled"))
+        test_div_assign ((const T*)0, tname, "/=");
+
+    if (rw_note (0 <= opt_assign [inx_mod_assign], 0, __LINE__,
+                 "tests of operator%= disabled"))
+        test_mod_assign ((const T*)0, tname, "%=");
+
+    if (rw_note (0 <= opt_assign [inx_add_assign], 0, __LINE__,
+                 "tests of operator+= disabled"))
+        test_add_assign ((const T*)0, tname, "+=");
+
+    if (rw_note (0 <= opt_assign [inx_sub_assign], 0, __LINE__,
+                 "tests of operator-= disabled"))
+        test_sub_assign ((const T*)0, tname, "-=");
+
+    if (rw_note (0 <= opt_assign [inx_xor_assign], 0, __LINE__,
+                 "tests of operator^= disabled"))
+        test_xor_assign ((const T*)0, tname, "^=");
+
+    if (rw_note (0 <= opt_assign [inx_and_assign], 0, __LINE__,
+                 "tests of operator&= disabled"))
+        test_and_assign ((const T*)0, tname, "&=");
+
+    if (rw_note (0 <= opt_assign [inx_or_assign], 0, __LINE__,
+                 "tests of operator|= disabled"))
+        test_or_assign ((const T*)0, tname, "|=");
+
+    if (rw_note (0 <= opt_assign [inx_shl_assign], 0, __LINE__,
+                 "tests of operator<<= disabled"))
+        test_shr_assign ((const T*)0, tname, "<<=");
+
+    if (rw_note (0 <= opt_assign [inx_shr_assign], 0, __LINE__,
+                 "tests of operator>>= disabled"))
+        test_shr_assign ((const T*)0, tname, ">>=");
+}
+
+/**************************************************************************/
+
+static int
+run_test (int, char**)
+{
+#undef TEST
+#define TEST(T)   test_op_assign ((const T*)0, #T)
+
+    TEST (std::size_t);
+//    TEST (double);
+//
+//#if 0x04020100 >= _RWSTD_VER
+//
+//    // test fails to compile with stdcxx 4.2.1 and prior due to
+//    // STDCXX-512: http://issues.apache.org/jira/browse/STDCXX-512
+//    rw_warn (0, 0, __LINE__,
+//             "test of UserClass disabled in stdcxx 4.2.0 and prior "
+//             "due to STDCXX-512");
+//
+//#else   // stdcxx >= 4.2.1
+//
+//    //TEST (UserClass);
+//
+//#endif   // stdcxx version
+
+    return 0;
+}
+
+/**************************************************************************/
+
+int main (int argc, char *argv[])
+{
+    // FIXME: add command line options to enable/disable each operator
+    return rw_test (argc, argv, __FILE__,
+                    "gslice.array.comp.assign",
+                    0 /* no comment */,
+                    run_test,
+                    "|-times~ "
+                    "|-divide~ "
+                    "|-modulo~ "
+                    "|-plus~ "
+                    "|-minus~ "
+                    "|-xor~ "
+                    "|-and~ "
+                    "|-or~ "
+                    "|-shift_left~ "
+                    "|-shift_right~",
+                    opt_assign + inx_mul_assign,
+                    opt_assign + inx_div_assign,
+                    opt_assign + inx_mod_assign,
+                    opt_assign + inx_add_assign,
+                    opt_assign + inx_sub_assign,
+                    opt_assign + inx_xor_assign,
+                    opt_assign + inx_and_assign,
+                    opt_assign + inx_or_assign,
+                    opt_assign + inx_shl_assign,
+                    opt_assign + inx_shr_assign,
+                    (void*)0   /* sentinel */);
+}
\ No newline at end of file

Propchange: stdcxx/branches/4.2.x/tests/numerics/26.gslice.array.cassign.cpp
------------------------------------------------------------------------------
    svn:eol-style = native

Propchange: stdcxx/branches/4.2.x/tests/numerics/26.gslice.array.cassign.cpp
------------------------------------------------------------------------------
    svn:keywords = Id



Mime
View raw message