Mapping Transpose Feature

.bazelrc

@@ -1 +1 @@
-build --cxxopt=-std=c++14
+build --cxxopt=-std=c++14

.gitignore

@@ -1,15 +1,17 @@
 .DS_Store
 .vscode
-build
 tmp
 docs/*
 !docs/Doxyfile
 !docs/DoxygenLayout.xml
 !docs/index.html
+build/
+bazel-*/
 venv
 .venv
 __pycache__
 .eggs
 .pytest_cache
 lin.cpp
-bazel-*
+bazel-*
+compile_commands.json

.travis.yml

@@ -27,3 +27,20 @@ matrix:
         - pip install -vvv .
       script:
         - pytest -v test_lin.py
+    - sudo: false
+      branches:
+          only:
+              - master
+      addons:
+          apt:
+              packages:
+                  - doxygen
+      script:
+          - cd docs && doxygen && cd ..
+      deploy:
+          provider: pages
+          skip_cleanup: true
+          local_dir: docs/html
+          github_token: $GH_REPO_TOKEN
+          on:
+              branch: master

LICENSE

@@ -1,6 +1,7 @@
 MIT License
 
-Copyright (c) 2020 kkrol27
+Copyright (c) 2020 kylekrol
+Copyright (c) 2020 Pathfinder for Autonomous Navigation (PAN)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 

README.md

@@ -1,7 +1,7 @@
 
 # lin
 
-[![Build Status](https://travis-ci.com/kkrol27/lin.svg?branch=master)](https://travis-ci.com/kkrol27/lin)
+[![Build Status](https://travis-ci.com/pathfinder-for-autonomous-navigation/lin.svg?branch=master)](https://travis-ci.com/pathfinder-for-autonomous-navigation/lin)
 
 Linear algebra library solely using static memory alocation. It's been developed primarily for the [PAN](https://github.com/pathfinder-for-autonomous-navigation) mission.
 
@@ -32,6 +32,8 @@ Documentation can be built with doxygen by running:
 
 and then opening `docs/html/index.html`. Starting at the modules page will be most helpful.
 
+The documentation is also hosted online at https://pathfinder-for-autonomous-navigation.github.io/lin/modules.html
+
 ## Python Bindings
 
 There is a small python module wrapping a few basic types from `lin` that have `double` elements. All of the core module is implemented with a handful of helpful additions. The source code for the it is generated at install time by the `setup.py` file.
@@ -47,3 +49,4 @@ For running tests locally using a virtual environment may be useful:
     pip install -r requirements.txt
     pip install . -vvv
     pytest -v test_lin.py
+

docs/Doxyfile

@@ -852,6 +852,18 @@ INPUT                  = \
   ../include/lin/views/tensor_view.hpp \
   ../include/lin/views/matrix_view.hpp \
   ../include/lin/views/vector_view.hpp \
+  ../include/lin/views/const_tensor_view.hpp \
+  ../include/lin/views/const_matrix_view.hpp \
+  ../include/lin/views/const_vector_view.hpp \
+  ../include/lin/references.hpp \
+  ../include/lin/references/tensor_mapping_reference.hpp \
+  ../include/lin/references/matrix_mapping_reference.hpp \
+  ../include/lin/references/vector_mapping_reference.hpp \
+  ../include/lin/references/diagonal_mapping_reference.hpp \
+  ../include/lin/references/tensor_stream_reference.hpp \
+  ../include/lin/references/matrix_stream_reference.hpp \
+  ../include/lin/references/vector_stream_reference.hpp \
+  ../include/lin/references/diagonal_stream_reference.hpp \
   ../include
 
 # This tag can be used to specify the character encoding of the source files

include/lin/core/operations/mapping_transpose.hpp

@@ -0,0 +1,107 @@
+// vim: set tabstop=2:softtabstop=2:shiftwidth=2:expandtab
+
+/** @file lin/core/operations/mapping_transpose.hpp
+ *  @author Kyle Krol
+ */
+
+#ifndef LIN_CORE_OPERATIONS_MAPPING_TRANSPOSE_HPP_
+#define LIN_CORE_OPERATIONS_MAPPING_TRANSPOSE_HPP_
+
+namespace lin {
+namespace internal {
+
+/** @brief Proxy to a lazily evalutated transpose operation.
+ * 
+ *  @tparam Cs %Tensor type.
+ * 
+ *  Details to come...
+ * 
+ *  @ingroup COREOPERATIONS
+ */
+template <class C>
+class MappingTranspose : public Mapping<MappingTranspose<C>> {
+ private:
+  /** @brief Mapping reference.
+   */
+  Mapping<C> &c;
+
+ public:
+  /** @brief Traits information for this type.
+   * 
+   *  @sa internal::traits
+   */
+  typedef traits<MappingTranspose<C>> Traits;
+
+ protected:
+  using Mapping<MappingTranspose<C>>::derived;
+
+ public:
+  using Mapping<MappingTranspose<C>>::size;
+  using Mapping<MappingTranspose<C>>::eval;
+  using Mapping<MappingTranspose<C>>::operator();
+  using Mapping<MappingTranspose<C>>::operator=;
+
+  constexpr MappingTranspose() = delete;
+  constexpr MappingTranspose(MappingTranspose<C> const &) = default;
+  constexpr MappingTranspose(MappingTranspose<C> &&) = default;
+  constexpr MappingTranspose<C> &operator=(MappingTranspose<C> const &) = default;
+  constexpr MappingTranspose<C> &operator=(MappingTranspose<C> &&) = default;
+
+  /** @brief Constructs a proxy to a tensor transpose operation.
+   * 
+   *  @param c %Tensor mapping.
+   */
+  constexpr MappingTranspose(Mapping<C> &c)
+  : c(c) { }
+
+  /** @return Number of rows in the tensor.
+   */
+  constexpr size_t rows() const {
+    return c.cols();
+  }
+
+  /** @return Number of columns in the tensor.
+   */
+  constexpr size_t cols() const {
+    return c.rows();
+  }
+
+  /** @brief Read write access to the requested tensor element.
+   * 
+   *  @param i Row index.
+   *  @param j Column index.
+   * 
+   *  @return Reference to the tensor element.
+   */
+  constexpr typename Traits::elem_t &operator()(size_t i, size_t j) {
+    return c(j, i);
+  }
+
+  /** @brief Read write access to the requested tensor element.
+   * 
+   *  @param i Index.
+   * 
+   *  @return Reference to the tensor element.
+   * 
+   *  Element access proceeds as if all the elements of the tensor stream were
+   *  flattened into an array in row major order.
+   */
+  constexpr typename Traits::elem_t &operator()(size_t i) {
+    return (*this)(i / cols(), i % cols());
+  }
+};
+
+template <class C>
+struct _elem<MappingTranspose<C>> : _elem<C> { };
+
+template <class C>
+struct _dims<MappingTranspose<C>> {
+  static constexpr size_t rows = _dims<C>::cols;
+  static constexpr size_t cols = _dims<C>::rows;
+  static constexpr size_t max_rows = _dims<C>::max_cols;
+  static constexpr size_t max_cols = _dims<C>::max_rows;
+};
+}  // namespace internal
+}  // namespace lin
+
+#endif

include/lin/core/operations/tensor_operations.hpp

@@ -11,6 +11,7 @@
 #include "../traits.hpp"
 #include "../types.hpp"
 #include "functors.hpp"
+#include "mapping_transpose.hpp"
 #include "stream_element_wise_operator.hpp"
 #include "stream_transpose.hpp"
 
@@ -316,6 +317,12 @@ constexpr auto sum(internal::Stream<C> const &c) {
   return x;
 }
 
+template <class C, std::enable_if_t<
+    internal::matches_tensor<C>::value, size_t> = 0>
+constexpr auto transpose(internal::Mapping<C> &c) {
+  return internal::MappingTranspose<C>(c);
+}
+
 template <class C, std::enable_if_t<
     internal::matches_tensor<C>::value, size_t> = 0>
 constexpr auto transpose(internal::Stream<C> const &c) {

include/lin/core/types.hpp

@@ -16,6 +16,7 @@
 #define LIN_CORE_TYPES_HPP_
 
 #include "types/base.hpp"
+#include "types/const_base.hpp"
 #include "types/dimensions.hpp"
 #include "types/mapping.hpp"
 #include "types/matrix.hpp"

include/lin/core/types/base.hpp

@@ -15,7 +15,7 @@
 namespace lin {
 namespace internal {
 
-/** @brief %Value backed tensor interface with resizing support.
+/** @brief Value backed tensor interface with resizing support.
  * 
  *  @tparam D Derived type.
  * 
@@ -26,8 +26,8 @@ namespace internal {
  *  added. A getter to retrive a pointer to the element backing array is also
  *  included.
  * 
- *  The main purpose is to provide an interface that supports value backed types -
- *  i.e. those directly storing tensor elements in a member array or and a
+ *  The main purpose is to provide an interface that supports value backed types
+ *  - i.e. those directly storing tensor elements in a member array or and a
  *  pointer.
  * 
  *  @sa internal::Stream
@@ -72,7 +72,7 @@ class Base : public Mapping<D>, public Dimensions<D> {
    *  @returns Pointer to the backing array.
    * 
    *  The elements of the tensor are layed out in row major order in the backing
-   *  array. They are stored continguously in memory.
+   *  array. They are stored contiguously in memory.
    */
   inline constexpr typename Traits::elem_t *data() {
     return derived().data();
@@ -83,7 +83,7 @@ class Base : public Mapping<D>, public Dimensions<D> {
    *  @returns Constant pointer to the backing array.
    * 
    *  The elements of the tensor are layed out in row major order in the backing
-   *  array. They are stored continguously in memory.
+   *  array. They are stored contiguously in memory.
    */
   inline constexpr typename Traits::elem_t const *data() const {
     return const_cast<D &>(derived()).data();

include/lin/core/types/const_base.hpp

@@ -0,0 +1,118 @@
+// vim: set tabstop=2:softtabstop=2:shiftwidth=2:expandtab
+
+/** @file lin/core/types/const_base.hpp
+ *  @author Kyle Krol
+ */
+
+#ifndef LIN_CORE_TYPES_CONST_BASE_HPP_
+#define LIN_CORE_TYPES_CONST_BASE_HPP_
+
+#include "../config.hpp"
+#include "../traits.hpp"
+#include "dimensions.hpp"
+#include "stream.hpp"
+
+namespace lin {
+namespace internal {
+
+/** @brief Value backed, read only tensor interface.
+ * 
+ *  @tparam D Derived type.
+ * 
+ *  This is the third of the three main entry points on the lin inheritance tree
+ *  after internal::Mapping.
+ * 
+ *  Here, direct tracking of runtime dimensions and the ability to resize is
+ *  added. A getter to retrive a pointer to the element backing array is also
+ *  included.
+ * 
+ *  The main purpose is to provide an interface that supports value backed types -
+ *  i.e. those directly storing tensor elements in a member array or and a
+ *  pointer.
+ * 
+ *  @sa internal::Stream
+ *  @sa internal::Mapping
+ *  @sa internal::Tensor
+ * 
+ *  @ingroup CORETYPES
+ */
+template <class D>
+class ConstBase : public Stream<D>, public Dimensions<D> {
+  static_assert(has_valid_traits<D>::value,
+      "Derived types to ConstBase<...> must have valid traits");
+
+ public:
+  /** @brief Traits information for this type.
+   * 
+   *  @sa internal::traits
+   */
+  typedef traits<D> Traits;
+
+ protected:
+  using Stream<D>::derived;
+
+ public:
+  using Stream<D>::size;
+  using Stream<D>::eval;
+  using Stream<D>::operator();
+
+  using Dimensions<D>::rows;
+  using Dimensions<D>::cols;
+  using Dimensions<D>::resize;
+
+  constexpr ConstBase() = default;
+  constexpr ConstBase(ConstBase<D> const &) = default;
+  constexpr ConstBase(ConstBase<D> &&) = default;
+  constexpr ConstBase<D> &operator=(ConstBase<D> const &) = default;
+  constexpr ConstBase<D> &operator=(ConstBase<D> &&) = default;
+
+  /** @brief Retrives a constant pointer to the element backing array.
+   * 
+   *  @returns Constant pointer to the backing array.
+   * 
+   *  The elements of the tensor are layed out in row major order in the backing
+   *  array. They are stored contiguously in memory.
+   */
+  inline constexpr typename Traits::elem_t const *data() const {
+    return derived().data();
+  }
+
+  /** @brief Provides read only access to tensor elements.
+   * 
+   *  @param i Row index.
+   *  @param j Column index.
+   * 
+   *  @return Value of the tensor element.
+   * 
+   *  If the indices are out of bounds as defined by the tensor's current
+   *  dimensions, lin assertion errors will be triggered.
+   */
+  constexpr typename Traits::elem_t const &operator()(size_t i, size_t j) const {
+    LIN_ASSERT(0 <= i && i < rows());
+    LIN_ASSERT(0 <= j && j < cols());
+
+    return data()[i * cols() + j];
+  }
+
+  /** @brief Provides read only access to tensor elements.
+   * 
+   *  @param i Index
+   * 
+   *  @return Value of the tensor element.
+   * 
+   *  Element access proceeds as if all the elements of the tensor stream were
+   *  flattened into an array in row major order.
+   * 
+   *  If the index is out of bounds as defined by the tensor's current size, lin
+   *  lin assertion errors will be triggered.
+   */
+  constexpr typename Traits::elem_t const &operator()(size_t i) {
+    LIN_ASSERT(0 <= i && i < size());
+
+    return data()[i];
+  }
+};
+}  // namespace internal
+}  // namespace lin
+
+#endif