Author: sebor
Date: Mon Dec 18 13:38:49 2006
New Revision: 488430
URL: http://svn.apache.org/viewvc?view=rev&rev=488430
Log:
2006-12-18 Martin Sebor <[EMAIL PROTECTED]>
STDCXX-4
* 26.class.gslice.cpp: New test exercising lib.class.gslice.
Added:
incubator/stdcxx/trunk/tests/numerics/26.class.gslice.cpp (with props)
Added: incubator/stdcxx/trunk/tests/numerics/26.class.gslice.cpp
URL:
http://svn.apache.org/viewvc/incubator/stdcxx/trunk/tests/numerics/26.class.gslice.cpp?view=auto&rev=488430
==============================================================================
--- incubator/stdcxx/trunk/tests/numerics/26.class.gslice.cpp (added)
+++ incubator/stdcxx/trunk/tests/numerics/26.class.gslice.cpp Mon Dec 18
13:38:49 2006
@@ -0,0 +1,239 @@
+/***************************************************************************
+ *
+ * 26.class.gslice.cpp - tests exercising class std::gslice
+ *
+ * $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.
+ *
+ **************************************************************************/
+
+#include <cstdlib> // for strtoul(), size_t
+#include <valarray> // for gslice, valarray
+
+#include <driver.h>
+
+/**************************************************************************/
+
+// returns a valarray constructed from a string of comma-separated values
+static std::valarray<std::size_t>
+make_array (const char *s)
+{
+ if (0 == s)
+ return std::valarray<std::size_t>();
+
+ std::size_t buf [256];
+
+ for (std::size_t i = 0; ; ++i) {
+
+ char *end;
+ unsigned long val = std::strtoul (s, &end, 10);
+
+ RW_ASSERT ('\0' == *end || ',' == *end);
+
+ buf [i] = std::size_t (val);
+
+ if ('\0' == *end)
+ return std::valarray<std::size_t>(buf, i);
+
+ s = end + 1;
+ }
+}
+
+/**************************************************************************/
+
+// returns the size of the index array represented by the genreralized slice
+static std::size_t
+get_array_size (const std::gslice &gsl)
+{
+ const std::valarray<std::size_t> sizes = gsl.size ();
+
+ std::size_t asize = sizes.size () ? 1 : 0;
+
+ for (std::size_t i = 0; i != sizes.size (); ++i) {
+ asize *= sizes [i];
+ }
+
+ return asize;
+}
+
+/**************************************************************************/
+
+static std::size_t
+next_index (const std::gslice &gsl, std::valarray<std::size_t> &factors)
+{
+ const std::size_t start = gsl.start ();
+ const std::valarray<std::size_t> asizes = gsl.size ();
+ const std::valarray<std::size_t> astrides = gsl.stride ();
+
+ const std::size_t ndims = asizes.size ();
+
+ std::size_t inx = asizes.size ();
+
+ if (0 == factors.size ()) {
+ factors.resize (ndims);
+
+ return start;
+ }
+
+ while (inx && factors [inx - 1] == asizes [inx - 1] - 1)
+ --inx;
+
+ if (0 == inx) {
+ factors = 0;
+
+ return start;
+ }
+
+ ++factors [inx - 1];
+
+ if (inx < factors.size ()) {
+ for (std::size_t i = inx; i != ndims; ++i)
+ factors [i] = 0;
+ }
+ else
+ inx = factors.size ();
+
+ std::size_t index = start;
+
+ for (std::size_t i = 0; i != inx; ++i)
+ index += factors [i] * astrides [i];
+
+ return index;
+}
+
+/**************************************************************************/
+
+// returns a valarray of indices reprsented by the generalized slice
+static std::valarray<std::size_t>
+get_index_array (const std::gslice &gsl)
+{
+ const std::size_t size = get_array_size (gsl);
+
+ std::valarray<std::size_t> indices (size);
+
+ std::valarray<std::size_t> tmpstore;
+
+ for (std::size_t i = 0; i != size; ++i)
+ indices [i] = next_index (gsl, tmpstore);
+
+ return indices;
+}
+
+/**************************************************************************/
+
+static void
+test_gslice (std::size_t start,
+ const char *sizes,
+ const char *strides)
+{
+ const std::valarray<std::size_t> asizes (make_array (sizes));
+ const std::valarray<std::size_t> astrides (make_array (strides));
+
+ const std::gslice gsl (start, asizes, astrides);
+
+ const std::valarray<std::size_t> indices = get_index_array (gsl);
+
+ std::size_t maxinx = 0;
+
+ for (std::size_t i = 0; i != indices.size (); ++i)
+ if (maxinx < indices [i])
+ maxinx = indices [i];
+
+ std::valarray<std::size_t> va (maxinx + 1);
+ for (std::size_t i = 0; i != va.size (); ++i)
+ va [i] = i;
+
+ for (int i = 0; i != 2; ++i) {
+ // repeat each test twice to verify that operator[](gslice)
+ // doesn't change the observable state of its argument
+
+ const std::valarray<std::size_t> array_slice = va [gsl];
+
+ bool equal = array_slice.size () == indices.size ();
+
+ rw_assert (equal, 0, __LINE__,
+ "size() == %zu, got %zu\n",
+ indices.size (), array_slice.size ());
+
+ if (equal) {
+ for (std::size_t j = 0; j != array_slice.size (); ++j) {
+
+ equal = array_slice [j] == va [indices [j]];
+
+ rw_assert (equal, 0, __LINE__,
+ "mismatch at %u, index %u: expected %u, got %u\n",
+ j, indices [j], va [indices [j]],
+ array_slice [j]);
+ }
+ }
+ }
+}
+
+/**************************************************************************/
+
+static void
+test_gslice (const char *sizes, const char *strides)
+{
+ for (std::size_t i = 0; i != 10; ++i)
+ test_gslice (i, sizes, strides);
+}
+
+/**************************************************************************/
+
+static int
+run_test (int, char**)
+{
+ test_gslice ("1", "1");
+ test_gslice ("1", "2");
+ test_gslice ("2", "1");
+ test_gslice ("2", "3");
+ test_gslice ("3", "2");
+
+ test_gslice ("1,1", "1,1");
+ test_gslice ("1,1", "1,2");
+ test_gslice ("1,1", "2,1");
+ test_gslice ("1,9", "2,1");
+ test_gslice ("9,1", "2,1");
+
+ test_gslice ("1,1,1", "1,1,1");
+ test_gslice ("1,2,3", "4,5,6");
+ test_gslice ("6,5,4", "3,2,1");
+ test_gslice ("10,11,12", "13,14,15");
+
+ // includes example from class.gslice, p3
+ test_gslice ("2,4,3", "19,4,1");
+
+ // includes example of a degenerate gslice from p5
+ test_gslice ("2,4,3", "19,4,1");
+
+ return 0;
+}
+
+/**************************************************************************/
+
+int main (int argc, char *argv[])
+{
+ return rw_test (argc, argv, __FILE__,
+ "lib.class.gslice",
+ 0 /* no comment */,
+ run_test,
+ "",
+ (void*)0 /* sentinel */);
+}
Propchange: incubator/stdcxx/trunk/tests/numerics/26.class.gslice.cpp
------------------------------------------------------------------------------
svn:eol-style = native
Propchange: incubator/stdcxx/trunk/tests/numerics/26.class.gslice.cpp
------------------------------------------------------------------------------
svn:keywords = Id
