fixing tesor-vector multiplication for subtensor.

Author: Cem Bassoy

IDEs/qtcreator/test/test_tensor.pro

@@ -5,13 +5,11 @@ CONFIG += staticlib depend_includepath console
 CONFIG -= qt
 CONFIG += c++20
 
-CONFIG += c++17
-
 #QMAKE_CXXFLAGS += -fno-inline
 QMAKE_CXXFLAGS  =-std=c++20
 QMAKE_CXXFLAGS +=-Wall -Wpedantic -Wextra
 QMAKE_CXXFLAGS +=-Wno-unknown-pragmas
-QMAKE_CXXFLAGS +=-Wno-unused-but-set-variable
+#QMAKE_CXXFLAGS +=-Wno-unused-but-set-variable
 
 
 gcc:QMAKE_CXXFLAGS_RELEASE =-O3 -march=native -fopenmp

include/boost/numeric/ublas/tensor/access.hpp

@@ -1,5 +1,5 @@
 //
-//  Copyright (c) 2018-2020, Cem Bassoy, [email protected]
+//  Copyright (c) 2020, Cem Bassoy, [email protected]
 //
 //  Distributed under the Boost Software License, Version 1.0. (See
 //  accompanying file LICENSE_1_0.txt or copy at
@@ -10,8 +10,8 @@
 //
 
 
-#ifndef _BOOST_UBLAS_TENSOR_ACCESS_HPP
-#define _BOOST_UBLAS_TENSOR_ACCESS_HPP
+#ifndef BOOST_UBLAS_TENSOR_ACCESS_HPP
+#define BOOST_UBLAS_TENSOR_ACCESS_HPP
 
 
 #include <algorithm>
@@ -26,7 +26,7 @@ namespace boost::numeric::ublas {
 using first_order = column_major;
 using last_order = row_major;
 
-}
+} // namespace boost::numeric::ublas
 
 namespace boost::numeric::ublas::detail{
 
@@ -68,11 +68,21 @@ constexpr inline auto compute_single_index(InputIt1 i, InputIt1 /*ip*/, InputIt2
  * @param i begin output iterator to a container with tensor or subtensor indices length std::distance(begin,end) or greater
 */
 template<typename InputIt1, typename OutputIt, typename LayoutType>
-constexpr inline void compute_multi_index(std::size_t j, InputIt1 w, InputIt1 wp, OutputIt i, LayoutType l);
+constexpr inline void compute_multi_index(std::size_t j, InputIt1 w, InputIt1 wp, OutputIt i, LayoutType /*unused*/);
+//{
+//  if(w == wp)
+//    return;
+
+//  auto wr  = std::make_reverse_iterator( w );
+//  auto wrp = std::make_reverse_iterator( wp );
+//  auto ir  = std::make_reverse_iterator( i+std::distance(w,wp) );
+
+//  std::transform(wrp,wr,ir, [&j](auto v) { auto k=j/v; j-=v*k; return k; } );
+//}
 
 
 template<typename InputIt1, typename OutputIt>
-constexpr inline void compute_multi_index(std::size_t j, InputIt1 w, InputIt1 wp, OutputIt i, first_order )
+constexpr inline void compute_multi_index(std::size_t j, InputIt1 w, InputIt1 wp, OutputIt i, first_order /*unused*/)
 {
     if(w == wp)
         return;
@@ -85,7 +95,7 @@ constexpr inline void compute_multi_index(std::size_t j, InputIt1 w, InputIt1 wp
 }
 
 template<typename InputIt1, typename OutputIt>
-constexpr inline void compute_multi_index(std::size_t j, InputIt1 w, InputIt1 wp, OutputIt i, last_order )
+constexpr inline void compute_multi_index(std::size_t j, InputIt1 w, InputIt1 wp, OutputIt i, last_order /*unused*/)
 {
     if(w == wp)
         return;
@@ -182,6 +192,6 @@ constexpr inline auto compute_single_index(std::size_t jv, InputIt1 w, InputIt1
   );
 }
 
-} // namespace
+} // namespace boost::numeric::ublas::detail
 
 #endif

include/boost/numeric/ublas/tensor/concepts.hpp

@@ -15,6 +15,7 @@
 
 #include <type_traits>
 
+
 namespace boost::numeric::ublas{
 
 template<typename T>

include/boost/numeric/ublas/tensor/extents/extents_functions.hpp

@@ -153,9 +153,12 @@ template<integral T, class L>
 {
   auto s = typename extents_core<T>::base_type(e.size(),1ul);
 
-  if(empty(e) || is_vector(e) || is_scalar(e)){
+  if(empty(e) || is_scalar(e)){
     return s;
   }
+
+  // || is_vector(e)
+
   if constexpr(std::is_same_v<L,layout::first_order>){
     std::transform(begin (e), end (e) - 1,  s.begin (),  s.begin ()+1, std::multiplies<>{});
   } else {
@@ -170,9 +173,13 @@ template<integral T, T n, class L>
   auto s = typename extents_core<T,n>::base_type{};
   std::fill(s.begin(),s.end(),1ul);
 
-  if(empty(e) || is_vector(e) || is_scalar(e)){
+  if(empty(e) || is_scalar(e)){
     return s;
   }
+
+
+  // || is_vector(e)
+
   if constexpr(std::is_same_v<L,layout::first_order>){
     std::transform(begin (e), end (e) - 1,  s.begin (),  s.begin ()+1, std::multiplies<>{});
   } else {

include/boost/numeric/ublas/tensor/function/tensor_times_vector.hpp

@@ -94,9 +94,8 @@ inline decltype(auto) prod( tensor_core< TE > const &a, vector<T, A> const &b, c
       nc_base[j++] = na.at(i);
 
   auto nc = shape(nc_base);
-
-
   auto c = tensor( nc, value{} );
+
   auto const* bb = &(b(0));
   ttv(m, p,
       c.data(), c.extents().data(), c.strides().data(),

include/boost/numeric/ublas/tensor/span.hpp

@@ -10,26 +10,23 @@
 //
 
 
-#ifndef _BOOST_UBLAS_TENSOR_SPAN_
-#define _BOOST_UBLAS_TENSOR_SPAN_
+#ifndef BOOST_UBLAS_TENSOR_SPAN
+#define BOOST_UBLAS_TENSOR_SPAN
 
 #include <typeinfo>
 #include <limits>
 #include <stdexcept>
 #include <ostream>
 
-namespace boost   {
-namespace numeric {
-namespace ublas   {
-namespace tag     {
+
+#include "concepts.hpp"
+
+namespace boost::numeric::ublas::tag{
 
 struct sliced  {};
 struct strided {};
 
-}
-}
-}
-}
+} // namespace boost::numeric::ublas::tag
 
 
 namespace boost::numeric::ublas {
@@ -53,7 +50,7 @@ template<class span_tag, class unsigned_type>
 class span;
 
 
-static constexpr inline std::size_t end = std::numeric_limits<std::size_t>::max();
+static constexpr inline std::size_t max = std::numeric_limits<std::size_t>::max();
 
 template<>
 class span<tag::strided, std::size_t>
@@ -210,14 +207,14 @@ class span<tag::sliced, std::size_t> :
 using sliced_span = span<tag::sliced, std::size_t>;
 
 
-template<class unsigned_type>
-inline auto ran(unsigned_type f, unsigned_type l)
+template<integral unsigned_type_left, integral unsigned_type_right>
+inline auto ran(unsigned_type_left f, unsigned_type_right l)
 {
 	return sliced_span(f,l);
 }
 
-template<class unsigned_type>
-inline auto ran(unsigned_type f, unsigned_type s, unsigned_type l)
+template<integral unsigned_type_left, integral unsigned_type_middle, integral unsigned_type_right>
+inline auto ran(unsigned_type_left f, unsigned_type_middle s, unsigned_type_right l)
 {
 	return strided_span(f,s,l);
 }