[Boost-commit] svn:boost r74539 - sandbox/variadic_templates/sandbox/stepper/boost/array_stepper

Subject: [Boost-commit] svn:boost r74539 - sandbox/variadic_templates/sandbox/stepper/boost/array_stepper
From: cppljevans_at_[hidden]
Date: 2011-09-23 14:43:26

Author: cppljevans
Date: 2011-09-23 14:43:24 EDT (Fri, 23 Sep 2011)
New Revision: 74539
URL: http://svn.boost.org/trac/boost/changeset/74539

Log:
index_stack*.hpp avoids need to manually code
nested for loops.
Other updates and mods are minor

Added:
   sandbox/variadic_templates/sandbox/stepper/boost/array_stepper/array_host.hpp   (contents, props changed)
   sandbox/variadic_templates/sandbox/stepper/boost/array_stepper/array_store_print.hpp   (contents, props changed)
   sandbox/variadic_templates/sandbox/stepper/boost/array_stepper/index_stack_length_stride_crtp.hpp   (contents, props changed)
   sandbox/variadic_templates/sandbox/stepper/boost/array_stepper/length_stride.hpp   (contents, props changed)
   sandbox/variadic_templates/sandbox/stepper/boost/array_stepper/length_stride_compose.hpp   (contents, props changed)
   sandbox/variadic_templates/sandbox/stepper/boost/array_stepper/length_strides_offset.hpp   (contents, props changed)
   sandbox/variadic_templates/sandbox/stepper/boost/array_stepper/scan_first_iter.hpp   (contents, props changed)
   sandbox/variadic_templates/sandbox/stepper/boost/array_stepper/vector_print.hpp   (contents, props changed)
Text files modified: 
   sandbox/variadic_templates/sandbox/stepper/boost/array_stepper/mk_iota.hpp        |    17 +++++                                   
   sandbox/variadic_templates/sandbox/stepper/boost/array_stepper/stepper_offset.hpp |   120 +++++++++++++++++++++++++++++++-------- 
   2 files changed, 111 insertions(+), 26 deletions(-)

Added: sandbox/variadic_templates/sandbox/stepper/boost/array_stepper/array_host.hpp
==============================================================================
--- (empty file)
+++ sandbox/variadic_templates/sandbox/stepper/boost/array_stepper/array_host.hpp	2011-09-23 14:43:24 EDT (Fri, 23 Sep 2011)
@@ -0,0 +1,131 @@
+#ifndef BOOST_ARRAY_STEPPER_ARRAY_HOST_HPP_INCLUDED
+#define BOOST_ARRAY_STEPPER_ARRAY_HOST_HPP_INCLUDED
+namespace boost
+{
+namespace array_stepper
+{
+  template
+  < typename Array
+  >
+  struct
+array_host
+{
+      Array&
+    my_array
+    ;
+        typedef typename
+      Array::domain_t
+    domain_t
+    ;
+        typedef typename
+      domain_t::index_t
+    index_t
+    ;
+        typedef typename
+      domain_t::offset_t
+    offset_t
+    ;
+        typedef typename
+      domain_t::length_stride_t
+    length_stride_t
+    ;
+        typedef typename
+      domain_t::length_strides_t::const_iterator
+    axis_iter_t
+    ;
+      axis_iter_t
+    my_axis_beg
+    ;
+      axis_iter_t const
+    my_axis_end
+    ;
+    array_host
+      ( Array& a_array
+      )
+    : my_array(a_array)
+    , my_axis_beg
+      ( my_array.length_strides().begin()
+      )
+    , my_axis_end
+      ( my_array.length_strides().end()
+      )
+    {
+    }
+    
+      template
+      < typename Visitor
+      >
+      void
+    accept
+      ( Visitor& a_viz
+      )
+    {
+        if(my_array.rank() == 0)
+        {
+            a_viz.null_array();
+        }
+        else
+        {
+            accept_off_ax
+            ( a_viz
+            , my_array.offset()
+            , my_axis_beg
+            );
+        }
+    }
+ private:
+      template
+      < typename Visitor
+      >
+      void
+    accept_off_ax
+      ( Visitor& a_viz
+      , index_t offset
+      , axis_iter_t axis_now
+      )
+    {
+        if(axis_now==my_axis_end)
+        {
+            a_viz.visit_child(my_array.data()[offset]);
+        }
+        else
+        {
+            axis_iter_t axis_nxt=axis_now+1;
+            length_stride_t const axis_length_stride=*axis_now;
+            typedef typename length_stride_t::stride_t stride_t;
+            typedef typename length_stride_t::length_t length_t;
+            stride_t const axis_stride=axis_length_stride.stride();
+            length_t const axis_length=axis_length_stride.length();
+          #if 0
+            std::cout
+              <<":axis="<<axis_now-my_axis_beg
+              <<":offset="<<offset
+              <<":length="<<axis_length
+              <<":stride="<<axis_stride
+              <<"\n";
+          #endif
+            a_viz.pre_children();
+            for(length_t i=0; i<axis_length; ++i)
+            {
+              #if 0
+                std::cout
+                  <<":i="<<i
+                  <<"\n";
+              #endif
+                a_viz.pre_child( i);
+                this->accept_off_ax
+                  ( a_viz
+                  , offset
+                  , axis_nxt
+                  );
+                a_viz.post_child();
+                offset+=axis_stride;
+            }
+            a_viz.post_children();
+        }
+    }
+};  
+
+}//exit array_stepper namespace
+}//exit boost namespace
+#endif

Added: sandbox/variadic_templates/sandbox/stepper/boost/array_stepper/array_store_print.hpp
==============================================================================
--- (empty file)
+++ sandbox/variadic_templates/sandbox/stepper/boost/array_stepper/array_store_print.hpp	2011-09-23 14:43:24 EDT (Fri, 23 Sep 2011)
@@ -0,0 +1,183 @@
+#ifndef BOOST_ARRAY_STEPPER_ARRAY_STORE_PRINT_HPP_INCLUDED
+#define BOOST_ARRAY_STEPPER_ARRAY_STORE_PRINT_HPP_INCLUDED
+
+#include <boost/array_stepper/array_store.hpp>
+#if 1
+#include <boost/array_stepper/array_host.hpp>
+#include <boost/iostreams/utility/indent_scoped_ostreambuf.hpp>
+#else
+#include <boost/array_stepper/length_stride_offset_iter_stack.hpp>
+#include <iostream>
+#include <iomanip>
+//#define BOOST_ARRAY_STEPPER_ARRAY_STORE_PRINT_TRACE          
+#ifdef  BOOST_ARRAY_STEPPER_ARRAY_STORE_PRINT_TRACE          
+#include <boost/assert.hpp>
+#endif
+#endif
+
+#ifndef BOOST_ARRAY_STEPPER_LENGTH_STRIDE_OFFSET_ITER_STACK_HPP_INCLUDED
+namespace boost
+{
+namespace array_stepper
+{
+  template
+  < typename T
+  >
+  struct
+array_store_print
+{
+      std::ostream&
+    my_sout
+    ;
+        typedef typename
+      array_store<T>::index_t
+    index_t
+    ;
+    array_store_print
+      ( std::ostream& a_sout
+      )
+    : my_sout(a_sout)
+    {}
+    
+    void null_array( )const
+    {
+        my_sout<<"(null_array)";
+    }
+    
+    void pre_children()
+    {
+        my_sout<<"{ ";
+    }
+    
+    void pre_child( index_t index)
+    {
+        if(0<index) my_sout<<", ";
+        my_sout<<indent_buf_in;
+    }
+    
+    void visit_child( T const& a_t)
+    {
+      #if 0
+        ::operator<<( my_sout, a_t);
+        //MAINTENANCE_NOTE:2011-06-29 with gcc4.6:
+        //  For some strange reason, have to use above with
+        //  gcc instead of what's in #else part because
+        //  otherwise compiler gives error saying:
+        //    no match for 'operator<<'
+        //  when T is std::vector<unsigned> even though
+        //  there is a:
+        //      std::ostream& 
+        //    operator<<
+        //      ( std::ostream&
+        //      , std::vector<unsigned>const&
+        //      );
+        //  defined.
+      #else
+        my_sout<<a_t;
+      #endif
+    }
+        
+    void post_child( )
+    {
+        my_sout<<indent_buf_out;
+    }
+    
+    void post_children()
+    {
+        my_sout<<"}\n";
+    }
+    
+};
+
+}//exit array_stepper namespace
+}//exit boost namespace
+#endif
+
+  template
+  < typename T
+  >
+  std::ostream&
+operator<<
+( std::ostream& sout
+, boost::array_stepper::array_store<T>const& a_arr
+)
+{
+  #ifdef BOOST_ARRAY_STEPPER_LENGTH_STRIDE_OFFSET_ITER_STACK_HPP_INCLUDED
+    typedef typename boost::array_stepper::array_store<T> arr_t;
+    typedef typename arr_t::domain_t domain_t;
+    typedef boost::array_stepper::length_stride_offset_iter_stack<> lsos_t;
+      lsos_t 
+    lsos_v
+      ( a_arr.length_strides().begin()
+      , a_arr.length_strides().end()
+      );
+    typedef typename arr_t::data_t data_t;
+    data_t const& data_v=a_arr.data();
+    int const n=data_v.size();
+    typename lsos_t::indices_t const& indices_v=lsos_v.indices();
+    int const axis_max=indices_v.size()-1;
+    int axis_now= axis_max;
+    int axis_pre=-1;
+    for(int l=axis_pre; l<axis_now; ++l) 
+    { //open 1st element for all axes.
+        sout<<"{ ";
+    }
+    for(int i=0; i<n; ++i,axis_pre=axis_now,axis_now=++lsos_v)
+    {
+        if(axis_now<axis_pre)
+        { //exiting one element and starting next.
+            for(int l=axis_pre; axis_now<l; --l) 
+            { //close axis_pre to axis_now elements.
+                if(l!=axis_pre) 
+                    sout<<std::setw(l*2)<<"";
+                sout<<"}\n";
+            }
+            sout<<std::setw(axis_now*2)<<""<<", ";//put delimiter between elements
+            for(int l=axis_pre; axis_now<l; --l)
+            { //open axis_now to axis_pre elements.
+                sout<<"{ ";
+            }
+          #ifdef BOOST_ARRAY_STEPPER_ARRAY_STORE_PRINT_TRACE
+            sout<<"(axis_now<axis_pre)";
+            BOOST_ASSERT(axis_pre == axis_max);
+          #endif
+        }
+        else if(-1<axis_pre)
+        {   sout<<", ";//put delimiter between elements
+          #ifdef BOOST_ARRAY_STEPPER_ARRAY_STORE_PRINT_TRACE
+            sout<<"(-1<axis_pre)";
+            BOOST_ASSERT( axis_now==axis_max && 0<indices_v[axis_now]);
+          #endif
+        }
+      #ifdef BOOST_ARRAY_STEPPER_ARRAY_STORE_PRINT_TRACE      
+        sout
+          <<":i="<<std::setw(2)<<i
+          <<":axis_pre="<<axis_pre
+          <<":axis_now="<<axis_now
+          <<":v="
+          ;
+      #endif
+        sout<<data_v[lsos_v.offset()];
+    }
+    for(int l=axis_pre; axis_now<l; --l)
+    {//close axis_pre to axis_now elements.
+        if(l!=axis_pre) 
+            sout<<std::setw(l*2)<<"";
+        sout<<"}\n";
+    }
+    #ifdef BOOST_ARRAY_STEPPER_ARRAY_STORE_PRINT_TRACE          
+    sout
+      <<":axis_pre="<<axis_pre
+      <<":axis_now="<<axis_now
+      <<"\n"
+      ;
+    #endif
+  #else
+    boost::array_stepper::array_store_print<T> a_viz(sout);
+    boost::array_stepper::array_host<boost::array_stepper::array_store<T> const> host_arr(a_arr);
+    host_arr.accept(a_viz);
+  #endif
+    return sout;
+}    
+
+#endif

Added: sandbox/variadic_templates/sandbox/stepper/boost/array_stepper/index_stack_length_stride_crtp.hpp
==============================================================================
--- (empty file)
+++ sandbox/variadic_templates/sandbox/stepper/boost/array_stepper/index_stack_length_stride_crtp.hpp	2011-09-23 14:43:24 EDT (Fri, 23 Sep 2011)
@@ -0,0 +1,718 @@
+//stack of loop indices and length_strides_for an array.
+#ifndef BOOST_ARRAY_STEPPER_INDEX_STACK_LENGTH_STRIDE_CRTP_HPP_INCLUDED
+#define BOOST_ARRAY_STEPPER_INDEX_STACK_LENGTH_STRIDE_CRTP_HPP_INCLUDED
+//  (C) Copyright Larry Evans 2011.
+//
+//  Permission to copy, use, modify, sell and distribute this software
+//  is granted provided this copyright notice appears in all copies.
+//  This software is provided "as is" without express or implied
+//  warranty, and with no claim as to its suitability for any purpose.
+//
+//====================================================================
+#include <boost/array_stepper/length_strides_offset.hpp>
+#include <boost/iterator/zip_iterator.hpp>
+#include <boost/iterator/transform_iterator.hpp>
+#include <boost/utility/enable_if.hpp>
+#include <boost/assert.hpp>
+namespace boost
+{
+namespace array_stepper
+{
+
+enum index_bounds_value_enum
+{ index_bound_lower
+, index_bound_upper
+, index_value
+};
+enum 
+{ index_bounds_value_size=index_value+1
+};
+enum mutable_enum
+{ mutable_not
+, mutable_yes
+};
+
+  template
+  < typename Stride=int
+  >
+  struct
+index_stack_length_stride_crtp_types
+{
+        typedef
+      Stride
+    stride_t
+    ;
+        typedef
+      length_strides_offset
+      < stride_t
+      >
+    length_strides_offset_t
+    ;
+        typedef
+      typename length_strides_offset_t::length_stride_t
+    length_stride_t
+    ;
+        typedef
+      typename length_strides_offset_t::length_strides_t
+    length_strides_t
+    ;
+        typedef
+      typename length_strides_t::const_iterator
+    length_stride_iter_t
+    ;
+        typedef
+      typename length_strides_offset_t::index_t
+    index_t
+    ;
+        typedef
+      typename length_strides_offset_t::axis_t
+    axis_t
+    ;
+        typedef
+      std::vector<index_t>
+    indices_t
+    ;
+      struct
+    offset_space
+      /**@brief
+       *  offset from beginning or the array's storage.
+       */
+    {
+        offset_space()
+        : my_offset(0)
+        {} 
+          stride_t
+        offset_space_val()const
+        {
+            return my_offset;
+        }
+          stride_t&
+        offset_space_ref()
+        {
+            return my_offset;
+        }
+     private:        
+          stride_t
+        my_offset
+        ;
+    };
+    
+      struct
+    offset_index_bounds
+      /**@brief
+       *  Offset from front and back of
+       *  an index range and current index.
+       */
+    : private array
+      < index_t
+      , std::size_t(index_bounds_value_size)
+      >
+    {
+            typedef
+          array
+          < index_t
+          , std::size_t(index_bounds_value_size)
+          >
+        super_t
+        ;
+        offset_index_bounds
+          (
+          )
+        : super_t
+          ({{ 0
+            , 0
+            , 0
+            }
+           }
+          )
+        {}
+          template
+          < index_bounds_value_enum IBV
+          >
+          index_t
+        val
+          (
+          )const
+        {
+            super_t const&me=*this;
+            return me[IBV];
+        }
+          template
+          < index_bounds_value_enum IBV
+          >
+          index_t&
+        ref
+          (
+          )
+        {
+            super_t&me=*this;
+            return me[IBV];
+        }
+          template
+          < index_bounds_value_enum IBV
+          >
+          index_t
+        get
+          (
+          )const
+        {
+            return val<IBV>();
+        }
+          template
+          < index_bounds_value_enum IBV
+          >
+          index_t&
+        get
+          (
+          )
+        {
+            return ref<IBV>();
+        }
+    };
+    
+      template
+      < mutable_enum MutEnum
+      >
+    struct index_bound_stride
+    {
+            typedef
+          typename ::boost::mpl::if_c
+          < MutEnum==mutable_yes
+          , offset_index_bounds
+          , offset_index_bounds const
+          >::type
+        offset_index_bounds_t
+        ;
+     private:
+          offset_index_bounds_t&
+        my_oib
+        ;
+          length_stride_t const&
+        my_ls
+        ;
+     public:
+        index_bound_stride
+        ( offset_index_bounds_t& a_oib
+        , length_stride_t const& a_ls
+        )
+        : my_oib(a_oib)
+        , my_ls(a_ls)
+        {}
+          template
+          < index_bounds_value_enum IBV
+          >
+          index_t
+        get
+          (
+          )const
+        {
+            return my_oib.template get<IBV>();
+        }
+          template
+          < index_bounds_value_enum IBV
+          >
+          typename ::boost::mpl::if_c
+          < MutEnum==mutable_yes
+          , index_t&
+          , index_t
+          >::type
+        get
+          (
+          )
+        {
+            return my_oib.template get<IBV>();
+        }
+        
+          template
+          < index_bounds_value_enum IBV
+          >
+          typename ::boost::enable_if_c
+          < IBV!=index_value
+          , index_t
+          >::type
+        bound()const
+        {
+            index_t offset=my_oib.template val<IBV>();
+            if(IBV==index_bound_lower) return offset;
+            return my_ls.length()-1-offset;
+        }
+          stride_t
+        stride_val()const
+        {
+            my_ls.stride();
+        }
+          stride_t
+        length_val()const
+        {
+            index_t index_upper=bound<index_bound_upper>();
+            index_t index_lower=bound<index_bound_lower>();
+            return index_upper-index_lower+1;
+        }
+    };
+    
+    struct indices_bounds_strides
+    {
+     private:
+            typedef
+          std::vector
+          < offset_index_bounds
+          >
+        offset_indices_bounds_t
+        ;
+          offset_indices_bounds_t
+        my_oib
+        ;
+          length_stride_iter_t
+        my_lsi
+        ;
+     public:
+        indices_bounds_strides
+          ( axis_t a_rank
+          , length_stride_iter_t const& a_lsi
+          )
+        : my_oib
+          ( a_rank
+          )
+        , my_lsi
+          ( a_lsi
+          )
+        {}
+        
+          axis_t
+        rank()const
+        {
+            return my_oib.size();
+        }
+
+          index_bound_stride<mutable_yes>
+        operator[](axis_t a_axis)
+        {
+            offset_index_bounds&oib=my_oib[a_axis];
+            length_stride_t const&ls=my_lsi[a_axis];
+            return index_bound_stride<mutable_yes>( oib, ls);
+        }
+          index_bound_stride<mutable_not>
+        operator[](axis_t a_axis)const
+        {
+            offset_index_bounds const&oib=my_oib[a_axis];
+            length_stride_t const&ls=my_lsi[a_axis];
+            return index_bound_stride<mutable_not>( oib, ls);
+        }
+    };
+};
+
+enum inc_dec_enum
+{ inc_ator
+, dec_ator
+};
+
+  template
+  < inc_dec_enum ID
+  >
+  struct
+inc_dec_concrete
+  /**@brief
+   *  Specializations provide operations & values
+   *  used by:
+   *      index_stack_length_stride_crtp_abstract::
+   *    inc_dec_ator<ID>
+   *  templated member function.
+   */
+;
+  template
+  <
+  >
+  struct
+inc_dec_concrete
+  < inc_ator
+  >
+{
+        static
+      index_bounds_value_enum const
+    bound_limit=index_bound_upper
+    ;
+        static
+      index_bounds_value_enum const
+    bound_reset=index_bound_lower
+    ;
+      template
+      < typename Index
+      , typename Offset
+      , typename Stride
+      >
+        static
+      void
+    change
+      ( Index& index
+      , Offset& offset
+      , Stride stride
+      )
+    {
+        ++index;
+        offset+=stride;
+    }
+};
+
+  template
+  <
+  >
+  struct
+inc_dec_concrete
+  < dec_ator
+  >
+{
+        static
+      index_bounds_value_enum const
+    bound_limit=index_bound_lower
+    ;
+        static
+      index_bounds_value_enum const
+    bound_reset=index_bound_upper
+    ;
+      template
+      < typename Index
+      , typename Offset
+      , typename Stride
+      >
+        static
+      void
+    change
+      ( Index& index
+      , Offset& offset
+      , Stride stride
+      )
+    {
+        --index;
+        offset-=stride;
+    }
+};
+
+  template
+  < typename IndexStackConcrete
+  >
+  struct
+index_stack_length_stride_crtp_abstract
+  /**@brief
+   *  An "abstract stack" of indices like those
+   *  for a N nested for loops, where N is the
+   *  value from rank() function of derived().
+   *  This class is abstract because the concrete
+   *  values are supplied by derived().
+   */
+{
+        typedef
+      IndexStackConcrete
+    index_stack_concrete_t
+    ;
+      index_stack_concrete_t&
+    derived()
+    {
+        *static_cast<index_stack_concrete_t*>(this);
+    }
+      index_stack_concrete_t const&
+    derived()const
+    {
+        *static_cast<index_stack_concrete_t const*>(this);
+    }
+      template
+      < inc_dec_enum ID
+      >
+      int
+    inc_dec_ator()
+      /**@brief
+       *  increment (if ID==inc_ator) or decrement(if ID==dec_ator) the indices
+       *  1 at a time, from rightmost to leftmost.
+       *  IOW, the rightmost index increments fastest, and 
+       *  the leftmost index increments slowest.
+       */
+    {
+        index_stack_concrete_t&der=derived();
+        typedef inc_dec_concrete<ID> conc_t;
+        auto& offset_space=der.offset_space_ref();
+        int const n=der.rank();
+        int axis=n-1;//increment 1st rightmost index.
+      //#define TRACE_INC_DEC_ATOR
+        while( 0<=axis)
+        {
+            auto ibs=der[axis];
+            auto& index_axis=ibs.template get<index_value>();
+            auto bound_limit_axis=ibs.template bound<conc_t::bound_limit>();
+            auto stride_axis=ibs.stride_val();
+          #ifdef TRACE_INC_DEC_ATOR
+            std::cout
+              <<"inc_dec_ator::before:axis="<<axis
+              <<":index_axis="<<index_axis
+              <<":bound_limit_axis="<<bound_limit_axis
+              <<"\n";
+          #endif
+            if( index_axis == bound_limit_axis)//if axis-th index at triggeer bound, then
+            {
+                { //reset index_axis to bound opposite to bound_limit_axis:
+                    auto bound_reset_axis=ibs.template bound<conc_t::bound_reset>();
+                      //First, change offset_space to reflect future
+                      //change in index_axis to bounds_reset_axis.
+                    offset_space-=(index_axis-bound_reset_axis)*stride_axis;
+                      //Next, change index_axis.
+                    index_axis=bound_reset_axis;
+                }
+                  //then proceed to increment/decrement next (in left direction) index in loop.
+                --axis;
+            }
+            else
+            { //just cnahge index_axis, offset_space, and exit loop.
+                conc_t::change( index_axis, offset_space, stride_axis);
+                break;
+            }
+          #ifdef TRACE_INC_DEC_ATOR
+            std::cout
+              <<"inc_dec_ator::after:axis="<<axis
+              <<":index_axis="<<index_axis
+              <<"\n";
+          #endif
+        }
+        return axis;
+    }
+      int
+    operator++()
+    {
+        return inc_dec_ator<inc_ator>();
+    }
+      int
+    operator--()
+    {
+        return inc_dec_ator<dec_ator>();
+    }
+
+};
+  
+  template
+  < typename IndexStackConcrete
+  >
+  struct
+indices_space
+;
+  template
+  < typename Stride
+  , template< typename>class Tmpl
+  >
+  struct
+indices_space
+  < Tmpl<Stride>
+  >
+{
+        typedef
+      Tmpl<Stride>
+    derived_t
+    ;
+        typedef
+      Stride
+    stride_t
+    ;
+        typedef
+      index_stack_length_stride_crtp_types<stride_t>
+    types_t
+    ;
+        typedef
+      typename types_t::axis_t
+    axis_t
+    ;
+        typedef
+      typename types_t::index_t
+    index_t
+    ;
+    indices_space()
+    : my_space(this->ctor_space())
+    {
+    }
+      stride_t
+    space()const
+    {
+        return my_space;
+    }
+
+      void
+    axis_index_put
+      ( axis_t a_axis
+      , index_t a_index
+      )
+    {
+        derived_t&der=derived();
+        auto ibs=der[a_axis];
+        auto&index_ref=ibs.get<index_value>();
+        auto&offset_space=der.offset_space_ref();
+        int index_diff=a_index-index_ref;
+        auto stride=ibs.stride_val();
+        int offset_diff=index_diff*stride;
+        offset_space+=offset_diff;
+        index_ref=a_index;
+    }
+
+      void
+    axis_offset_put
+      ( axis_t a_axis
+      , index_t a_offset_lower
+      , index_t a_offset_upper
+      )
+    {
+        derived_t&der=derived();
+        auto ibs=der[a_axis];
+        auto l_old=ibs.length_val();
+        ibs.get<index_bound_lower>()=a_offset_lower;
+        ibs.get<index_bound_upper>()=a_offset_upper;
+        auto l_new=ibs.length_val();
+        auto index_lower=ibs.template bound<index_bound_lower>();
+        axis_index_put(a_axis,index_lower);
+        if(l_old==l_new)return;
+        my_space/=l_old;
+        my_space*=l_new;
+    }
+
+      derived_t&
+    derived()
+    {
+        return *static_cast<derived_t*>(this);
+    }
+ private:
+      stride_t
+    ctor_space()
+      /**@brief
+       *  1) returns number of elements =
+       *       (bounds_upper[     0]+1-bounds_lower[     0])
+       *      *(bounds_upper[     1]+1-bounds_lower[     1])
+       *      ...
+       *      *(bounds_upper[rank-1]+1-bounds_lower[rank-1])
+       *  2) sets indices[*] to bounds_lower[*].
+       *  3) sets offset_space = 
+       *       bounds_lower[     0]*strides[     0]
+       *      +bounds_lower[     1]*strides[     1]
+       *      ...
+       *      +bounds_lower[rank-1]*strides[rank-1]
+       *
+       *  where:
+       *    rank = number of axes.
+       *    indices     [a_axis] is index                of axis, a_axis.
+       *    bounds_lower[a_axis] is lower bound of index of axis, a_axis.
+       *    bounds_upper[a_axis] is upper bound of index of axis, a_axis.
+       *    strides     [a_axis] is stride               of axis, a_axis.
+       */
+    {
+            typedef
+          typename derived_t::axis_t
+        axis_t;
+        derived_t&der=derived();
+        auto&offset_space=der.offset_space_ref();
+        stride_t s=1;
+        axis_t const rank=der.rank();
+        for
+          ( axis_t axis=0
+          ; axis<rank
+          ; ++axis
+          )
+        {
+            auto ibs=der[axis];
+            offset_space+=ibs.template get<index_value>()*std::abs(ibs.stride_val());
+            int l=ibs.length_val();
+            if(l<0)l=0;
+            s*=l;
+        }
+        return s;
+    }
+      stride_t
+    my_space
+    ;
+};
+
+  template
+  < typename Stride=int
+  >
+  struct
+index_stack_length_stride_crtp_indices
+: index_stack_length_stride_crtp_types<Stride>::indices_bounds_strides
+, index_stack_length_stride_crtp_types<Stride>::offset_space
+, index_stack_length_stride_crtp_abstract
+  < index_stack_length_stride_crtp_indices
+    < Stride
+    >
+  >
+, indices_space
+  < index_stack_length_stride_crtp_indices
+    < Stride
+    >
+  >
+{
+
+        typedef
+      index_stack_length_stride_crtp_types
+      < Stride
+      >
+    types_t
+    ;
+        typedef
+      typename types_t::stride_t
+    stride_t
+    ;
+        typedef
+      typename types_t::index_t
+    index_t
+    ;
+        typedef
+      typename types_t::axis_t
+    axis_t
+    ;
+        typedef
+      typename types_t::indices_bounds_strides
+    indices_bounds_strides_t
+    ;
+        typedef
+      indices_space
+      < index_stack_length_stride_crtp_indices
+        < Stride
+        >
+      >
+    indices_space_t
+    ;
+        typedef
+      typename types_t::length_stride_iter_t
+    length_stride_iter_t
+    ;
+    index_stack_length_stride_crtp_indices
+    ( length_stride_iter_t ls_iter_beg
+    , length_stride_iter_t ls_iter_end
+    )
+    : index_stack_length_stride_crtp_types<Stride>::indices_bounds_strides
+      ( axis_t(ls_iter_end-ls_iter_beg)
+      , ls_iter_beg
+      )
+    {
+    }
+};
+    
+}//exit array_stepper namespace
+}//exit boost namespace
+
+#include <iostream>
+#include <iomanip>
+
+  template< typename Stride>
+  std::ostream&
+operator<<
+  ( std::ostream& sout
+  , boost::array_stepper::index_stack_length_stride_crtp_indices<Stride>const& lsos_v
+  )
+  {
+      sout<<"{ offset="<<std::setw(2)<<lsos_v.offset_space_val();
+      sout<<", indices=";
+      sout<<"{ ";
+      for(unsigned axis=0; axis<lsos_v.rank(); ++axis)
+      {
+          if(0<axis)sout<<", ";
+          auto ibs=lsos_v[axis];
+          auto index=ibs.template get<boost::array_stepper::index_value>();
+          sout<<std::setw(2)<<index;
+      }
+      sout<<"} ";
+      sout<<"}";
+      return sout;
+  }
+
+#endif

Added: sandbox/variadic_templates/sandbox/stepper/boost/array_stepper/length_stride.hpp
==============================================================================
--- (empty file)
+++ sandbox/variadic_templates/sandbox/stepper/boost/array_stepper/length_stride.hpp	2011-09-23 14:43:24 EDT (Fri, 23 Sep 2011)
@@ -0,0 +1,132 @@
+#ifndef BOOST_ARRAY_STEPPER_LENGTH_STRIDE_HPP_INCLUDED
+#define BOOST_ARRAY_STEPPER_LENGTH_STRIDE_HPP_INCLUDED
+#include <limits>
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/make_unsigned.hpp>
+
+namespace boost
+{
+namespace array_stepper
+{
+  template
+  < typename StrideDir = int
+  >
+  struct
+length_stride
+  /**@brief
+   *  Length and Stride of an array axis.
+   **@reference:
+   *  _An APL Compiler_
+   *  Timothy Budd
+   *  Springer-Verlag, 1988
+   */
+{
+        typedef
+      StrideDir
+    stride_t
+      /**@brief
+       *  Stride of an axis.
+       */
+      ;
+ private:
+    BOOST_STATIC_ASSERT(std::numeric_limits<stride_t>::is_signed)
+      /**@brief
+       *  stride_t is be signed to allow for reverse ordering
+       *  of indices.  IOW, allow the (i+1)-th value 
+       *  to be located *before*  the     i-th value.
+       */
+      ;
+ public:
+        typedef
+      typename make_unsigned<stride_t>::type
+    length_t
+      ;
+ private:    
+      length_t
+    my_length
+      /**@brief
+       *  Length of the axis.
+       *  Corresponds to the s_i in equation (5.1)
+       *  of section:
+       *    5.1 Expansion Vectors
+       *  of @reference.
+       */
+      ;
+      stride_t
+    my_stride
+      /**@brief
+       *  Stride of the axis, i.e.
+       *  the distance between adjacent
+       *  elements on the axis.
+       *  If < 0, this indicates the
+       *  axis is reversed, IOW for
+       *  indices i,j such that i<j:
+       *       address of i-th element
+       *    >  address of j-th element.
+       *  See comments in:
+       *    length_stride_compose<>::operator()(...)
+       *    in length_stride_compose.hpp.
+       *
+       *  This corresponds to the e_i in equation (5.1)
+       *  of section:
+       *    5.1 Expansion Vectors
+       *  of @reference, *except* it may be negative
+       *  to account for axis reveral, as explained above.
+       */
+      ;
+ public:
+      length_t
+    length()const
+      {
+        return my_length;
+      }            
+      stride_t
+    stride()const
+      {
+        return my_stride;
+      }
+      length_t
+    space()const
+      {
+        return length()*abs(stride());
+      }
+    length_stride()
+      : my_length(1)
+      , my_stride(1)
+      {}
+    length_stride(length_t a_length)
+      : my_length(a_length)
+      , my_stride(1)
+      {}
+    length_stride(length_t a_length, stride_t a_stride)
+      : my_length(a_length)
+      , my_stride(a_stride)
+      {}
+    
+};
+
+  template
+  < typename LengthStride
+  >
+  typename LengthStride::space_t
+length
+  ( LengthStride const& ls
+  )
+  {
+    return ls.length();
+  }
+  
+  template
+  < typename LengthStride
+  >
+  typename LengthStride::stride_t
+stride
+  ( LengthStride const& ls
+  )
+  {
+    return ls.stride();
+  }
+  
+}//exit array_stepper namespace
+}//exit boost namespace
+#endif

Added: sandbox/variadic_templates/sandbox/stepper/boost/array_stepper/length_stride_compose.hpp
==============================================================================
--- (empty file)
+++ sandbox/variadic_templates/sandbox/stepper/boost/array_stepper/length_stride_compose.hpp	2011-09-23 14:43:24 EDT (Fri, 23 Sep 2011)
@@ -0,0 +1,152 @@
+#ifndef BOOST_ARRAY_STEPPER_LENGTH_STRIDE_COMPOSE_HPP_INCLUDED
+#define BOOST_ARRAY_STEPPER_LENGTH_STRIDE_COMPOSE_HPP_INCLUDED
+#include <boost/array_stepper/length_stride.hpp>
+#include <cstddef>
+#include <numeric>
+namespace boost
+{
+namespace array_stepper
+{
+  enum
+sign_val
+{ less0=-1
+, is0
+, more0
+};
+
+  template
+  < typename LengthStride //instance of length_stride.
+  , typename Offset=std::size_t
+  >
+  struct
+length_stride_compose
+  /**@brief
+   *  Used as 1st arg to scan_first_iter to
+   *  create LengthStride's from 
+   *  sequence of LengthStride::length_t's.
+   */
+{
+        typedef
+      LengthStride
+    length_stride_t
+    ;
+        typedef
+      typename length_stride_t::length_t
+    length_t
+    ;
+        typedef
+      typename length_stride_t::stride_t
+    stride_t
+    ;
+        typedef
+      stride_t
+    length_dir_t
+     /**@brief
+      *  axis length which is signed in order
+      *  to indicate forward (>0) or reverse(<0)
+      *  order of indices.
+      */
+    ;
+        typedef
+      Offset
+    offset_t
+    ;
+ private:    
+      offset_t
+    my_offset
+      /**@brief
+       *  Modified by negative length_t arguments.
+       *  A negative length_t indicates that the
+       *  elements are stored in reverse order.
+       *  In other words, the element stored
+       *  at index, i, is stored after the 
+       *  element stored at index, (i+1).
+       *  Here, index means the index argument
+       *  to the subscript operator.
+       *
+       **@reference:
+       *  _An APL Compiler_
+       *  Timothy Budd
+       *  Springer-Verlag, 1988
+       */
+    ;
+ public:    
+    length_stride_compose()
+    : my_offset(0)
+    {}
+      offset_t
+    offset()const
+    {
+        return my_offset;
+    }        
+    
+        static
+      sign_val
+    isign( length_dir_t a_length)
+      /**@brief
+       *  Returns one of {less0,is0,more0}
+       *  depending on sign of a_length.
+       */
+    {
+        sign_val r=(a_length<0)?less0:((a_length==0)?is0:more0);
+        return r;
+    }    
+
+      length_stride_t
+    operator()
+      ( length_dir_t a_length //The first length in the length sequence.
+      )
+    {
+        sign_val sv=isign(a_length);
+        length_t ex=abs(a_length);
+        /**
+         *  The comment preceding the similar statment
+         *  in binary operator() applies here also.
+         */
+        length_t sp=1;
+        if(sv==less0) my_offset =(ex-1)*sp;
+        stride_t st=sv*sp;
+        length_stride_t  result( ex, st);
+        return result;
+    }
+    
+      length_stride_t
+    operator()
+      ( length_stride_t a_length_stride //previous length stride
+      , length_dir_t a_length //current length (not first)
+      )
+      /**@brief
+       *  Returns current length_stride_t.
+       */
+    {
+        sign_val sv=isign(a_length);
+        length_t ex=abs(a_length);
+        /**
+         * The following 3 statements, when applied to all
+         * the axes, do, essentially, what's done by the:
+         * equations:
+         *   t_i' = s_i - t_i - 1
+         *   d_i' = -d_i
+         * in section:
+         *   6.1.4 Reversal
+         * and the alpha equation:
+         *   alpha = t_1*e_1 + ... t_n*e_n
+         * in section:
+         *   6.2 The Accessor
+         * of @reference (see comments to my_offset declaration).
+         *
+         * In summary, alpha in the above section 6.2 equation
+         * of @reference is my_offset here.
+         */
+        length_t sp=a_length_stride.space();
+        if(sv==less0) my_offset+=(ex-1)*sp;
+        stride_t st=sv*sp;
+        length_stride_t  result( ex, st);
+        return result;
+    }
+    
+};
+
+}//exit array_stepper namespace
+}//exit boost namespace
+#endif

Added: sandbox/variadic_templates/sandbox/stepper/boost/array_stepper/length_strides_offset.hpp
==============================================================================
--- (empty file)
+++ sandbox/variadic_templates/sandbox/stepper/boost/array_stepper/length_strides_offset.hpp	2011-09-23 14:43:24 EDT (Fri, 23 Sep 2011)
@@ -0,0 +1,522 @@
+#ifndef BOOST_ARRAY_STEPPER_LENGTH_STRIDES_OFFSET_HPP_INCLUDED
+#define BOOST_ARRAY_STEPPER_LENGTH_STRIDES_OFFSET_HPP_INCLUDED
+#if 0
+#include <boost/array_stepper/length_strides_axis_offset.hpp>
+#include <boost/array_stepper/length_strides_val.hpp>
+#endif
+#include <boost/array_stepper/length_stride_compose.hpp>
+#include <boost/array_stepper/scan_first_iter.hpp>
+#include <boost/array_stepper/permutation.hpp>
+#include <boost/array.hpp>
+#include <boost/iterator/permutation_iterator.hpp>
+#include <boost/iterator/transform_iterator.hpp>
+#include <boost/assert.hpp>
+#include <algorithm>
+
+namespace boost
+{
+namespace array_stepper
+{
+
+enum storage_order_predefined
+{ store_reverse //strides decrease as axis increases(as with c arrays).
+, store_forward //strides increase as axis increases(as with fortran arrays).
+};
+enum
+{ storage_order_predef_num=store_forward+1
+};
+enum struct_op_enum
+/**@brief
+ *  enumeration of the structural operations
+ */
+{ op_ax_permute //permute axes
+, op_ax_rotate //rotate axes(a specialized & faster permute)
+};
+  template
+  < struct_op_enum StrOp
+  >
+struct struct_op_tag
+{};   
+
+  template
+  < typename StrideDir=int
+  >
+  struct
+length_strides_offset
+  /**@brief
+   *  For each axis (or dimension) in a multi-dimentional array,
+   *  this structure stores a length_stride.  In addition,
+   *  to account for a negative stride for any of the axes, this
+   *  class stores an offset.
+   **@reference:
+   *  _An APL Compiler_
+   *  Timothy Budd
+   *  Springer-Verlag, 1988
+   */
+{
+        typedef
+      length_stride
+      < StrideDir
+      >
+    length_stride_t
+    ;
+        typedef
+      typename length_stride_t::stride_t
+    stride_t
+    ;
+        typedef
+      unsigned
+    axis_t
+    ;
+        typedef
+      int
+    rot_t
+      /**@brief
+       *  axis rotation amount.
+       */
+    ;
+        typedef
+      std::vector
+      < length_stride_t
+      >
+    length_strides_t
+    ;
+        typedef
+      length_stride_compose<length_stride_t> 
+    comp_t
+    ;
+        typedef
+      typename comp_t::length_dir_t
+    length_dir_t
+    ;
+        typedef
+      typename comp_t::offset_t
+    offset_t
+    ;
+        typedef
+      offset_t
+    index_t
+    ;
+        typedef
+      std::vector<index_t>
+    indexs_t
+    ;
+        typedef
+      std::vector<unsigned>
+    permute_t
+      /**@brief
+       *  Type of a permutaion of indices, 0...Rank-1
+       *  for some unsigned Rank.
+       */
+    ;
+        typedef typename
+      permute_t::value_type
+    permute_val_t
+    ;
+ public:
+        typedef
+      permute_t
+    (*permute_0to_t) //function returning a permutation of [0,a_last)
+      ( permute_val_t //a_last
+      )
+    ;
+        static
+      permute_t
+    identity_permutation
+      ( permute_val_t a_last
+      )
+    {
+      return mk_iota( permute_val_t(0), a_last);
+    }
+    
+        static
+      permute_t
+    reverse_permutation
+      ( permute_val_t a_last
+      )
+    {
+      return mk_iota( a_last, permute_val_t(0));
+    }
+    
+        static
+      storage_order_predefined const
+    storage_order_default
+    =store_reverse
+    ;
+      permute_0to_t
+    permute_select
+      ( storage_order_predefined a_so=storage_order_default
+      )
+    {
+        static permute_0to_t mk[storage_order_predef_num]=
+          { reverse_permutation
+          , identity_permutation
+          };
+        return mk[a_so];
+    }
+    
+ private:    
+      offset_t
+    my_offset
+    /**@brief
+     *  Offset from start of array where all 0 index
+     *  is located.  my_offset != 0 iff one or more
+     *  of the lengths passed to CTOR are < 0.
+     */
+    ;
+      length_strides_t
+    my_length_strides
+    /**@brief
+     *  The length & strides for each axis in a multidimensional array.
+     */
+    ;
+      template
+      < typename InpIter
+      , typename OutIter
+      >
+      OutIter
+    init_iter_strides
+      ( InpIter lengths_beg
+      , InpIter lengths_end
+      , OutIter strides_beg
+      )
+      /**@brief
+       *  1) Helper function for init_strides( Lengths...)
+       *  2) Initializes my_offset.
+       */
+    {
+        comp_t comp_v;
+        OutIter strides_end=
+          scan_first_iter
+            ( comp_v
+            , lengths_beg
+            , lengths_end
+            , strides_beg
+            );
+        my_offset=comp_v.offset();
+        return strides_end;
+    }
+    
+ protected:
+ 
+      template
+      < typename Lengths
+      >
+      stride_t
+    init_strides
+      ( Lengths const& a_lengths
+      , permute_t const& a_permute
+      )
+      /**@brief
+       *  1) Calculates strides of the array with shape, a_lengths,
+       *     permuted by a_permute.
+       *  2) Initializes my_offset.
+       *  3) returns number of elements in a multi-dimenstional
+       *     array with these Lengths (which is the
+       *     product of the absolute value of all a_length
+       *     elements).
+       */
+    {
+        BOOST_ASSERT
+        (  ( a_lengths.size() == my_length_strides.size())
+        && ( a_permute.size() == my_length_strides.size())
+        && permutation::is_permutation( a_permute)
+        );
+            typedef 
+          permutation_iterator
+          < typename Lengths::const_iterator
+          , permute_t::const_iterator
+          >
+        plenit_t;
+        plenit_t len_beg( a_lengths.begin(), a_permute.begin());
+        plenit_t len_end( a_lengths.begin(), a_permute.end());
+            typedef 
+          permutation_iterator
+          < typename length_strides_t::iterator
+          , permute_t::const_iterator
+          >
+        plss_t;
+        plss_t lss_beg( my_length_strides.begin(), a_permute.begin());
+        plss_t lss_end=
+          init_iter_strides
+            ( len_beg
+            , len_end
+            , lss_beg
+            );
+        return lss_end->space();
+    }
+    
+      template
+      < typename Lengths
+      >
+      stride_t
+    init_strides
+      ( Lengths const& a_lengths
+      , storage_order_predefined a_so=storage_order_default
+      )
+    {
+        return 
+        init_strides
+        ( a_lengths
+        , permute_select
+          ( a_so
+          )
+          ( a_lengths.size()
+          )
+        );
+    }
+      
+    length_strides_offset
+      ( std::size_t a_size
+      )
+    /**@brief
+     *  To be used by subclasses which should
+     *  call this->init_strides( a_lengths, ...)
+     *  where a_lengths.size() == a_size
+     */
+    : my_length_strides( a_size)
+    {
+    }
+ public:    
+    
+    template< typename Lengths>
+    length_strides_offset
+      ( Lengths const& a_lengths
+      , storage_order_predefined a_so=storage_order_default
+      )
+    : my_length_strides( a_lengths.size())
+    {
+        init_strides( a_lengths, a_so);
+    }
+    
+    template< typename Lengths>
+    length_strides_offset
+      ( Lengths const& a_lengths
+      , permute_t const& a_permute
+      )
+    : my_length_strides( a_lengths.size())
+    {
+        init_strides( a_lengths, a_permute);
+    }
+    
+    length_strides_offset
+      ( length_strides_offset const& a_iso
+      , index_t a_index
+      )
+      /**@brief
+       *  Let an array, A, be described by a_iso.
+       *  This CTOR produces a description of
+       *  A[a_index].
+       */
+      : my_offset
+        ( a_iso.offset()
+        + a_iso.length_strides().front().stride()
+        * a_index
+        )
+      , my_length_strides
+        ( a_iso.begin()+1
+        , a_iso.end()
+        )
+    {
+    }
+    
+    length_strides_offset
+      ( struct_op_tag<op_ax_rotate>
+      , length_strides_offset const& a_iso
+      , axis_t a_axis
+      )
+      /**@brief
+       *  Let an array, A, be described by a_iso.
+       *  This CTOR produces a description of an
+       *  array, B, with axes, a_axis..A.rank() 
+       *  rotated by 1.
+       */
+      : my_offset
+        ( a_iso.offset()
+        )
+      , my_length_strides
+        ( a_iso.rank()
+        )
+    {
+        std::copy //copy 1st part of a_iso
+        ( a_iso.begin()
+        , a_iso.begin()+a_axis-1
+        , my_length_strides.begin()
+        );
+        std::rotate_copy //copy 2nd part of a_iso rotated by 1.
+        ( a_iso.begin()+a_axis
+        , a_iso.begin()+a_axis+1
+        , a_iso.end()
+        , my_length_strides.begin()+a_axis
+        );
+    }
+    
+      axis_t
+    rank()const
+    {
+        return my_length_strides.size();
+    }
+      length_strides_t const&
+    length_strides()const
+    {
+        return my_length_strides;
+    }
+      typename length_strides_t::const_iterator
+    begin()const
+    {
+        return length_strides().begin();
+    }
+      offset_t
+    offset()const
+    {
+        return my_offset;
+    }
+      axis_t
+    normalize_rotation
+      ( int rotation
+      , axis_t a_axis
+      )
+    {
+        axis_t const rnk=rank()-a_axis;
+        int nrot=rotation%rnk;//-rnk < nrot && nrot < rnk
+        axis_t mrot=(nrot+rnk)%rnk;//0<=mrot && mrot < rnk
+        return mrot;
+    }
+      axis_t
+    normalize_axis
+      ( axis_t a_axis
+      )
+    {
+        return a_axis%rank();
+    }
+      void
+    axis_rot
+      ( int a_rot=1
+      , axis_t a_axis=0
+      )
+    {
+        a_axis=normalize_axis(a_axis);
+        unsigned const n_rot=normalize_rotation( a_rot, a_axis);
+        typedef typename length_strides_t::iterator iter_t;
+        iter_t beg=my_length_strides.begin()+a_axis;
+        iter_t mid=beg+n_rot;
+        iter_t end=my_length_strides.end();
+        std::rotate( beg, mid, end);
+    }
+        static
+      offset_t
+    offset_at_indexs_seq
+      ( indexs_t const& a_indexs_seq
+      , typename length_strides_t::const_iterator beg_ls
+      , offset_t a_offset
+      )
+      /**@brief
+       *  The offset of element in an array
+       *  corresponding to indices in index sequence, a_indices.
+       *
+       *  This corresponds to equation (5.2) of the @reference.
+       */
+    {
+        typename indexs_t::const_iterator beg_i=a_indexs_seq.begin();
+        typename indexs_t::const_iterator end_i=a_indexs_seq.end();
+        typedef stride_t(*get_stride_t)(length_stride_t const&);
+          transform_iterator
+          < get_stride_t
+          , typename length_strides_t::const_iterator
+          > 
+        beg_s
+          ( beg_ls
+          , stride< length_stride_t>
+          );
+        offset_t const r_offset
+          = std::inner_product
+            ( beg_i
+            , end_i
+            , beg_s
+            , a_offset
+            );
+        return r_offset;
+    }
+      offset_t
+    offset_at_indexs_seq
+      ( indexs_t const& a_indexs_seq
+      )const
+      /**@brief
+       *  The offset of element in an array
+       *  corresponding to indices in index sequence, a_indices.
+       *
+       *  This corresponds to equation (5.2) of the @reference.
+       */
+    {
+        typename length_strides_t::const_iterator beg_ls=my_length_strides.begin();
+        return offset_at_indexs_seq( a_indexs_seq, beg_ls, my_offset);
+    }
+    
+    struct index_at_offset
+    /**@brief
+     *  Functor used by indexs_at_offset.
+     */
+    {
+          offset_t 
+        my_offset
+          /**@brief
+           *  offset in multitimensional array.
+           *  from beginning of array.
+           */
+        ;
+        index_at_offset( offset_t a_offset)
+        : my_offset(a_offset)
+        {}
+            typedef 
+          index_t 
+        result_type
+          /**@brief
+           *  required by make_transform_iterator
+           *  used in indexs_at_offset.
+           */
+        ;
+          index_t
+        operator()( length_stride_t const& ls)const
+          /**@brief
+           *  this is equation (5.7) in @reference
+           *  for an axis described by ls.
+           */
+        { 
+            index_t div_v=my_offset/ls.stride();
+            index_t index_v=div_v%ls.length();
+            return index_v;
+        }
+    };
+      indexs_t
+    indexs_at_offset
+      ( offset_t a_offset
+      )const
+      /**@brief
+       *  The inverse of offset_at_indexs_seq.
+       *
+       *  This corresponds to equation (5.7) in @reference
+       *  for each axis.
+       */
+    {
+        typedef typename length_strides_t::const_iterator citer;
+        citer beg_ls=my_length_strides.begin();
+        citer end_ls=my_length_strides.end();
+        index_at_offset iao(a_offset);
+        typedef transform_iterator<index_at_offset,citer> xiter;
+        xiter beg_index( beg_ls, iao);
+        xiter end_index( end_ls, iao);
+        indexs_t a_indexs_seq(rank());
+        typename indexs_t::iterator beg_is=a_indexs_seq.begin();
+        std::copy
+          ( beg_index
+          , end_index
+          , beg_is
+          );
+        return a_indexs_seq;
+    }
+    
+};
+
+}//exit array_stepper namespace
+}//exit boost namespace
+#endif

Modified: sandbox/variadic_templates/sandbox/stepper/boost/array_stepper/mk_iota.hpp
==============================================================================
--- sandbox/variadic_templates/sandbox/stepper/boost/array_stepper/mk_iota.hpp	(original)
+++ sandbox/variadic_templates/sandbox/stepper/boost/array_stepper/mk_iota.hpp	2011-09-23 14:43:24 EDT (Fri, 23 Sep 2011)
@@ -1,7 +1,12 @@
 #ifndef BOOST_ARRAY_STEPPER_MK_IOTA_HPP_INCLUDED
 #define BOOST_ARRAY_STEPPER_MK_IOTA_HPP_INCLUDED
-#include <numeric>
+#include <cstdlib>
 #include <vector>
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+#include <numeric>
+#else
+#include <boost/iterator/counting_iterator.hpp>
+#endif
 namespace boost
 {
 namespace array_stepper
@@ -19,11 +24,21 @@
       std::vector<Value> result(abs(size));
       if(size>0)
       {
+        #ifdef __GXX_EXPERIMENTAL_CXX0X__
           std::iota( result.begin(), result.end(), first);
+        #else
+          unsigned const n=size;
+          for(unsigned i=0; i<n; ++i) result[i]=first+i;
+        #endif
       }
       else
       {
+        #ifdef __GXX_EXPERIMENTAL_CXX0X__
           std::iota( result.rbegin(), result.rend(), last);
+        #else
+          unsigned const n=-size;
+          for(unsigned i=0; i<n; ++i) result[n-1-i]=last+i;
+        #endif
       }
       return result;
   }

Added: sandbox/variadic_templates/sandbox/stepper/boost/array_stepper/scan_first_iter.hpp
==============================================================================
--- (empty file)
+++ sandbox/variadic_templates/sandbox/stepper/boost/array_stepper/scan_first_iter.hpp	2011-09-23 14:43:24 EDT (Fri, 23 Sep 2011)
@@ -0,0 +1,41 @@
+#ifndef BOOST_ARRAY_STEPPER_SCAN_FIRST_ITER_HPP_INCLUDED
+#define BOOST_ARRAY_STEPPER_SCAN_FIRST_ITER_HPP_INCLUDED
+namespace boost
+{
+namespace array_stepper
+{
+
+  template
+  < typename InputIter
+  , typename OutputIter
+  , typename Operations
+  >
+  OutputIter
+scan_first_iter
+  ( Operations& ops
+  , InputIter first
+  , InputIter last
+  , OutputIter result
+  )
+{
+    if(first!=last)
+    {
+        typedef typename OutputIter::value_type value_t;
+        *result=ops(*first);
+        for
+          ( ++first
+          ; first!=last
+          ; ++first
+          )
+        {
+            value_t next=ops(*result,*first);
+            ++result;
+            *result=next;
+        }
+    }
+    return result;
+}        
+        
+}//exit array_stepper namespace
+}//exit boost namespace
+#endif

Modified: sandbox/variadic_templates/sandbox/stepper/boost/array_stepper/stepper_offset.hpp
==============================================================================
--- sandbox/variadic_templates/sandbox/stepper/boost/array_stepper/stepper_offset.hpp	(original)
+++ sandbox/variadic_templates/sandbox/stepper/boost/array_stepper/stepper_offset.hpp	2011-09-23 14:43:24 EDT (Fri, 23 Sep 2011)
@@ -4,8 +4,9 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/make_signed.hpp>
 #include <boost/type_traits/make_unsigned.hpp>
-#include <limits>
 #include <boost/array_stepper/permutation0_last.hpp>
+#include <limits>
+
 namespace boost
 {
 namespace array_stepper
@@ -27,6 +28,7 @@
 enum
 { stepr_size=stepr_axis+1
 };
+  
   template
   < typename Value=int 
     //Value must include negative values(i.e. be signed) 
@@ -203,22 +205,47 @@
     {
         return my_offset;
     }
+      offset_t
+    offset(index_t a_index)const
+    {
+        axis_t const a_axis= my_stepper_ones[0][stepr_axis];
+        return offset()+my_stepper_ones[a_axis].offset(a_index);
+    }
       const_iterator
     begin()const
     {
         return my_stepper_ones.begin();
     }
       void
-    permute( axes_permutation_t a_permut)
+    permute_axes
+      ( axes_permutation_t a_permut
+      , axis_t a_from=0
+      )
     {
-        stepper_ones_t so_v(stepper_ones());
-        unsigned r=rank();
-        for( unsigned i=0; i<r; ++i)
+        unsigned r=rank()-a_from;
+        std::vector<value_t> axes(r);
+        for( unsigned i=a_from; i<r; ++i)
+        {
+            axes[i]=my_stepper_ones[i][stepr_axis];
+        }
+        for( unsigned i=a_from; i<r; ++i)
         {
             unsigned p=a_permut[i];
-            my_stepper_ones[i]=so_v[p];
-            //my_stepper_ones[i][stepr_axis]=a_permut[so_v[i][stepr_axis]];
+            my_stepper_ones[i][stepr_axis]=axes[p];
+        }
+    }
+      void
+    rotate_axes
+      ( axis_t a_from=0
+      )
+    {
+        unsigned r=rank();
+        axis_t a_axis=my_stepper_ones[a_from][stepr_axis];
+        for( unsigned i=a_from; i<r-1; ++i)
+        {
+            my_stepper_ones[i][stepr_axis]=my_stepper_ones[i+1][stepr_axis];
         }
+        my_stepper_ones[r-1][stepr_axis]=a_axis;
     }
  protected:
       offset_t
@@ -230,26 +257,69 @@
         unsigned size=a_lengths.size();
         if(0<size)
         {
-            unsigned i=0;
-            unsigned now_index =a_permut[i];
-            value_t  now_length=a_lengths[now_index];
-            int      now_sign  =isign(now_length);
-            my_stepper_ones[now_index][stepr_length]=abs(now_length);
-            my_stepper_ones[now_index][stepr_stride]=now_sign;
-            my_stepper_ones[now_index][stepr_axis  ]=size-1-i;
-            my_offset+=my_stepper_ones[now_index].offset();
-            for(++i; i<size; ++i)
+          #if 0
+            unsigned leng_indx=0;
+            unsigned perm_indx=a_permut[leng_indx];
+            value_t  leng_valu=a_lengths[perm_indx];
+            int      leng_sign=isign(leng_valu);
+            my_stepper_ones[perm_indx][stepr_length]=abs(leng_valu);
+            my_stepper_ones[perm_indx][stepr_stride]=leng_sign;
+            my_stepper_ones[perm_indx][stepr_axis  ]=size-1-leng_indx;
+            my_offset+=my_stepper_ones[perm_indx].offset();
+            for(++leng_indx; leng_indx<size; ++leng_indx)
+            {
+                value_t pre_space=my_stepper_ones[perm_indx].space();
+                perm_indx=a_permut[leng_indx];
+                leng_valu=a_lengths[perm_indx];
+                leng_sign=isign(leng_valu);
+                my_stepper_ones[perm_indx][stepr_length]=abs(leng_valu);
+                my_stepper_ones[perm_indx][stepr_stride]=leng_sign*pre_space;
+                my_stepper_ones[perm_indx][stepr_axis  ]=size-1-leng_indx;
+                my_offset+=my_stepper_ones[perm_indx].offset();
+            }
+            return my_stepper_ones[perm_indx].space();
+          #elif 0
+            unsigned leng_indx=0;
+            unsigned perm_indx=a_permut[leng_indx];
+            value_t  leng_valu=a_lengths[perm_indx];
+            int      leng_sign=isign(leng_valu);
+            my_stepper_ones[perm_indx][stepr_length]=abs(leng_valu);
+            my_stepper_ones[perm_indx][stepr_stride]=leng_sign;
+            my_stepper_ones[perm_indx][stepr_axis  ]=leng_indx;
+            my_offset+=my_stepper_ones[perm_indx].offset();
+            for(++leng_indx; leng_indx<size; ++leng_indx)
+            {
+                value_t pre_space=my_stepper_ones[perm_indx].space();
+                perm_indx=a_permut[leng_indx];
+                leng_valu=a_lengths[perm_indx];
+                leng_sign=isign(leng_valu);
+                my_stepper_ones[perm_indx][stepr_length]=abs(leng_valu);
+                my_stepper_ones[perm_indx][stepr_stride]=leng_sign*pre_space;
+                my_stepper_ones[perm_indx][stepr_axis  ]=leng_indx;
+                my_offset+=my_stepper_ones[perm_indx].offset();
+            }
+            return my_stepper_ones[perm_indx].space();
+          #else
+            unsigned maxm_indx=size-1;//MAXiMum index
+            for( unsigned leng_indx=0; leng_indx<size; ++leng_indx)
+            {
+                unsigned perm_indx=maxm_indx-a_permut[leng_indx];
+                value_t  leng_valu=a_lengths[leng_indx];
+                int      leng_sign=isign(leng_valu);
+                my_stepper_ones[perm_indx][stepr_length]=abs(leng_valu);
+                my_stepper_ones[perm_indx][stepr_stride]=leng_sign;
+                my_stepper_ones[leng_indx][stepr_axis  ]=perm_indx;
+            }
             {
-                value_t pre_space=my_stepper_ones[now_index].space();
-                now_index =a_permut[i];
-                now_length=a_lengths[now_index];
-                now_sign  =isign(now_length);
-                my_stepper_ones[now_index][stepr_length]=abs(now_length);
-                my_stepper_ones[now_index][stepr_stride]=now_sign*pre_space;
-                my_stepper_ones[now_index][stepr_axis  ]=size-1-i;
-                my_offset+=my_stepper_ones[now_index].offset();
+                my_offset=my_stepper_ones[maxm_indx].offset();
+                for( int axis_indx=maxm_indx-1; 0<=axis_indx; --axis_indx)
+                {
+                    my_stepper_ones[axis_indx][stepr_stride]*=my_stepper_ones[axis_indx+1].space();
+                    my_offset+=my_stepper_ones[axis_indx].offset();
+                }
             }
-            return my_stepper_ones[now_index].space();
+            return my_stepper_ones[maxm_indx].space();
+          #endif
         }
         else
         {

Added: sandbox/variadic_templates/sandbox/stepper/boost/array_stepper/vector_print.hpp
==============================================================================
--- (empty file)
+++ sandbox/variadic_templates/sandbox/stepper/boost/array_stepper/vector_print.hpp	2011-09-23 14:43:24 EDT (Fri, 23 Sep 2011)
@@ -0,0 +1,24 @@
+#ifndef BOOST_ARRAY_STEPPER_VECTOR_PRINT_HPP_INCLUDED
+#define BOOST_ARRAY_STEPPER_VECTOR_PRINT_HPP_INCLUDED
+#include <vector>
+#include <iostream>
+  template
+  < typename T
+  >
+  std::ostream&
+operator<<
+  ( std::ostream& sout
+  , std::vector<T> const& a_container
+  )
+{
+   sout<<"{ ";
+   unsigned const size=a_container.size();
+   for(unsigned i=0; i<size; ++i)
+   {
+      if(0<i) sout<<", ";
+      sout<<a_container[i];
+   }
+   sout<<"} ";
+   return sout;
+}
+#endif