valarray-inst.cc (gslice::_Indexer::_Indexer): Don't flip lengths and strides.

        * src/valarray-inst.cc (gslice::_Indexer::_Indexer): Don't flip
        lengths and strides.
        (__gslice_to_index): Document.

From-SVN: r39583

libstdc++-v3/ChangeLog

 2001-02-11  Gabriel Dos Reis  <gdr@codesourcery.com>
 
+	* src/valarray-inst.cc (gslice::_Indexer::_Indexer): Don't flip 
+	lengths and strides.
+	(__gslice_to_index): Document.
+
+2001-02-11  Gabriel Dos Reis  <gdr@codesourcery.com>
+
 	* include/bits/char_traits.h char_traits<char>::int_type: Change
 	to `int' to match 21.1.3.1/2.
 

libstdc++-v3/src/valarray-inst.cc

@@ -28,22 +28,46 @@ namespace std
     return __valarray_product(&__t[0], &__t[0] + __n);
   }
   
-    void __gslice_to_index(size_t __o, const valarray<size_t>& __l,
-                           const valarray<size_t>& __s,
-                           valarray<size_t>& __i)
+  // Map a gslice, described by its multidimensional LENGTHS
+  // and corresponding STRIDES, to a linear array of INDEXES
+  // for the purpose of indexing a flat, one-dimensional array
+  // representation of a gslice_array.
+  void
+  __gslice_to_index(size_t __o, const valarray<size_t>& __l,
+                    const valarray<size_t>& __s, valarray<size_t>& __i)
   {
+    // There are as much as dimensions as there are strides.
     size_t __n = __l.size();
+
+    // Get a buffer to hold current multi-index as we go through
+    // the gslice for the purpose of computing its linear-image.
     size_t* const __t = static_cast<size_t*>
-            (__builtin_alloca(__n*sizeof(size_t)));
+      (__builtin_alloca(__n * sizeof (size_t)));
     __valarray_fill(__t, __n, size_t(0));
+
+    // Note that this should match the product of all numbers appearing
+    // in __l which describes the multidimensional sizes of the
+    // the generalized slice.
     const size_t __z = __i.size();
-        __valarray_fill(&__i[0], __z, __o);
-        for (size_t __j=0; __j<__z; ++__j) {
-            for (size_t __k=0; __k<__n; ++__k)
-                __i[__j] += __s[__k]*__t[__k];
+    
+    for (size_t __j = 0; __j < __z; ++__j)
+      {
+        // Compute the linear-index image of (t_0, ... t_{n-1}).
+        // Normaly, we should use inner_product<>(), but we do it the
+        // the hard way here to avoid link-time can of worms.
+        size_t __a = __o;
+        for (size_t __k = 0; __k < __n; ++__k)
+          __a += __s[__k] * __t[__k];
+
+        __i[__j] = __a;
+
+        // Process the next multi-index.  The loop ought to be
+        // backward since we're making a lexicagraphical visit.
         ++__t[__n-1];
-            for (size_t __k=__n-1; __k; --__k) {
-                if (__t[__k] >= __l[__k]) {
+        for (size_t __k=__n-1; __k; --__k)
+          {
+            if (__t[__k] >= __l[__k])
+              {
                 __t[__k] = 0;
                 ++__t[__k-1];
               }
@@ -51,10 +75,10 @@ namespace std
       }
   }
   
-    gslice::_Indexer::_Indexer(size_t __o, const valarray<size_t>& __s,
-                               const valarray<size_t>& __l)
-            : _M_count(1), _M_start(__o), _M_size(__s), _M_stride(__l),
-              _M_index(__l.size() ? __valarray_product(__l) : 0)
+  gslice::_Indexer::_Indexer(size_t __o, const valarray<size_t>& __l,
+                             const valarray<size_t>& __s)
+      : _M_count(1), _M_start(__o), _M_size(__l), _M_stride(__s),
+        _M_index(__l.size() == 0 ? 0 : __valarray_product(__l))
   { __gslice_to_index(__o, __l, __s, _M_index); }
   
 }