From 865259da1f72582131ba7ad7f820feb9453c8ec9 Mon Sep 17 00:00:00 2001
From: hschreiber <hannah.schreiber.k@googlemail.com>
Date: Fri, 8 Nov 2024 17:00:00 +0100
Subject: [PATCH] add small vector column to matrix module

---
 src/Persistence_matrix/include/gudhi/Matrix.h |   9 +-
 .../columns/naive_vector_column.h             | 197 +++++++++---------
 .../gudhi/persistence_matrix_options.h        |   2 +
 .../test/pm_column_tests_boost_type_lists.h   |  16 +-
 .../test/pm_common_boost_type_lists.h         |   4 +
 .../test/pm_matrix_tests_boost_type_lists.h   |   6 +-
 6 files changed, 130 insertions(+), 104 deletions(-)

diff --git a/src/Persistence_matrix/include/gudhi/Matrix.h b/src/Persistence_matrix/include/gudhi/Matrix.h
index d917bddc80..2ff8b46d41 100644
--- a/src/Persistence_matrix/include/gudhi/Matrix.h
+++ b/src/Persistence_matrix/include/gudhi/Matrix.h
@@ -313,7 +313,8 @@ class Matrix {
   using Matrix_heap_column = Heap_column<Matrix<PersistenceMatrixOptions> >;
   using Matrix_list_column = List_column<Matrix<PersistenceMatrixOptions> >;
   using Matrix_vector_column = Vector_column<Matrix<PersistenceMatrixOptions> >;
-  using Matrix_naive_vector_column = Naive_vector_column<Matrix<PersistenceMatrixOptions> >;
+  using Matrix_naive_vector_column = STD_naive_vector_column<Matrix<PersistenceMatrixOptions> >;
+  using Matrix_small_vector_column = Small_naive_vector_column<Matrix<PersistenceMatrixOptions> >;
   using Matrix_set_column = Set_column<Matrix<PersistenceMatrixOptions> >;
   using Matrix_unordered_set_column = Unordered_set_column<Matrix<PersistenceMatrixOptions> >;
   using Matrix_intrusive_list_column = Intrusive_list_column<Matrix<PersistenceMatrixOptions> >;
@@ -345,7 +346,11 @@ class Matrix {
                             typename std::conditional<
                                 PersistenceMatrixOptions::column_type == Column_types::NAIVE_VECTOR,
                                 Matrix_naive_vector_column, 
-                                Matrix_intrusive_set_column
+                                typename std::conditional<
+                                    PersistenceMatrixOptions::column_type == Column_types::SMALL_VECTOR,
+                                    Matrix_small_vector_column, 
+                                    Matrix_intrusive_set_column
+                                    >::type
                                 >::type
                             >::type
                         >::type
diff --git a/src/Persistence_matrix/include/gudhi/Persistence_matrix/columns/naive_vector_column.h b/src/Persistence_matrix/include/gudhi/Persistence_matrix/columns/naive_vector_column.h
index 3626b9ae9d..710987a374 100644
--- a/src/Persistence_matrix/include/gudhi/Persistence_matrix/columns/naive_vector_column.h
+++ b/src/Persistence_matrix/include/gudhi/Persistence_matrix/columns/naive_vector_column.h
@@ -25,6 +25,7 @@
 #include <utility>    //std::swap, std::move & std::exchange
 
 #include <boost/iterator/indirect_iterator.hpp>
+#include <boost/container/small_vector.hpp>
 
 #include <gudhi/Persistence_matrix/allocators/entry_constructors.h>
 #include <gudhi/Persistence_matrix/columns/column_utilities.h>
@@ -43,7 +44,7 @@ namespace persistence_matrix {
  *
  * @tparam Master_matrix An instantiation of @ref Matrix from which all types and options are deduced.
  */
-template <class Master_matrix>
+template <class Master_matrix, class Support>
 class Naive_vector_column : public Master_matrix::Row_access_option,
                             public Master_matrix::Column_dimension_option,
                             public Master_matrix::Chain_column_option
@@ -59,7 +60,7 @@ class Naive_vector_column : public Master_matrix::Row_access_option,
 
  private:
   using Field_operators = typename Master_matrix::Field_operators;
-  using Column_support = std::vector<Entry*>;
+  using Column_support = Support;
   using Entry_constructor = typename Master_matrix::Entry_constructor;
 
  public:
@@ -223,7 +224,13 @@ class Naive_vector_column : public Master_matrix::Row_access_option,
 };
 
 template <class Master_matrix>
-inline Naive_vector_column<Master_matrix>::Naive_vector_column(Column_settings* colSettings)
+using STD_naive_vector_column = Naive_vector_column<Master_matrix, std::vector<typename Master_matrix::Matrix_entry*> >;
+template <class Master_matrix>
+using Small_naive_vector_column =
+    Naive_vector_column<Master_matrix, boost::container::small_vector<typename Master_matrix::Matrix_entry*, 8> >;
+
+template <class Master_matrix, class Support>
+inline Naive_vector_column<Master_matrix,Support>::Naive_vector_column(Column_settings* colSettings)
     : RA_opt(),
       Dim_opt(),
       Chain_opt(),
@@ -236,9 +243,9 @@ inline Naive_vector_column<Master_matrix>::Naive_vector_column(Column_settings*
   }
 }
 
-template <class Master_matrix>
+template <class Master_matrix, class Support>
 template <class Container>
-inline Naive_vector_column<Master_matrix>::Naive_vector_column(const Container& nonZeroRowIndices,
+inline Naive_vector_column<Master_matrix,Support>::Naive_vector_column(const Container& nonZeroRowIndices,
                                                                Column_settings* colSettings)
     : RA_opt(),
       Dim_opt(nonZeroRowIndices.size() == 0 ? 0 : nonZeroRowIndices.size() - 1),
@@ -263,9 +270,9 @@ inline Naive_vector_column<Master_matrix>::Naive_vector_column(const Container&
   }
 }
 
-template <class Master_matrix>
+template <class Master_matrix, class Support>
 template <class Container, class Row_container>
-inline Naive_vector_column<Master_matrix>::Naive_vector_column(Index columnIndex,
+inline Naive_vector_column<Master_matrix,Support>::Naive_vector_column(Index columnIndex,
                                                                const Container& nonZeroRowIndices,
                                                                Row_container* rowContainer,
                                                                Column_settings* colSettings)
@@ -298,9 +305,9 @@ inline Naive_vector_column<Master_matrix>::Naive_vector_column(Index columnIndex
   }
 }
 
-template <class Master_matrix>
+template <class Master_matrix, class Support>
 template <class Container>
-inline Naive_vector_column<Master_matrix>::Naive_vector_column(const Container& nonZeroRowIndices,
+inline Naive_vector_column<Master_matrix,Support>::Naive_vector_column(const Container& nonZeroRowIndices,
                                                                Dimension dimension,
                                                                Column_settings* colSettings)
     : RA_opt(),
@@ -329,9 +336,9 @@ inline Naive_vector_column<Master_matrix>::Naive_vector_column(const Container&
   }
 }
 
-template <class Master_matrix>
+template <class Master_matrix, class Support>
 template <class Container, class Row_container>
-inline Naive_vector_column<Master_matrix>::Naive_vector_column(Index columnIndex,
+inline Naive_vector_column<Master_matrix,Support>::Naive_vector_column(Index columnIndex,
                                                                const Container& nonZeroRowIndices,
                                                                Dimension dimension,
                                                                Row_container* rowContainer,
@@ -362,8 +369,8 @@ inline Naive_vector_column<Master_matrix>::Naive_vector_column(Index columnIndex
   }
 }
 
-template <class Master_matrix>
-inline Naive_vector_column<Master_matrix>::Naive_vector_column(const Naive_vector_column& column,
+template <class Master_matrix, class Support>
+inline Naive_vector_column<Master_matrix,Support>::Naive_vector_column(const Naive_vector_column& column,
                                                                Column_settings* colSettings)
     : RA_opt(),
       Dim_opt(static_cast<const Dim_opt&>(column)),
@@ -390,9 +397,9 @@ inline Naive_vector_column<Master_matrix>::Naive_vector_column(const Naive_vecto
   }
 }
 
-template <class Master_matrix>
+template <class Master_matrix, class Support>
 template <class Row_container>
-inline Naive_vector_column<Master_matrix>::Naive_vector_column(const Naive_vector_column& column,
+inline Naive_vector_column<Master_matrix,Support>::Naive_vector_column(const Naive_vector_column& column,
                                                                Index columnIndex,
                                                                Row_container* rowContainer,
                                                                Column_settings* colSettings)
@@ -417,8 +424,8 @@ inline Naive_vector_column<Master_matrix>::Naive_vector_column(const Naive_vecto
   }
 }
 
-template <class Master_matrix>
-inline Naive_vector_column<Master_matrix>::Naive_vector_column(Naive_vector_column&& column) noexcept
+template <class Master_matrix, class Support>
+inline Naive_vector_column<Master_matrix,Support>::Naive_vector_column(Naive_vector_column&& column) noexcept
     : RA_opt(std::move(static_cast<RA_opt&>(column))),
       Dim_opt(std::move(static_cast<Dim_opt&>(column))),
       Chain_opt(std::move(static_cast<Chain_opt&>(column))),
@@ -427,17 +434,17 @@ inline Naive_vector_column<Master_matrix>::Naive_vector_column(Naive_vector_colu
       entryPool_(std::exchange(column.entryPool_, nullptr))
 {}
 
-template <class Master_matrix>
-inline Naive_vector_column<Master_matrix>::~Naive_vector_column()
+template <class Master_matrix, class Support>
+inline Naive_vector_column<Master_matrix,Support>::~Naive_vector_column()
 {
   for (auto* entry : column_) {
     _delete_entry(entry);
   }
 }
 
-template <class Master_matrix>
-inline std::vector<typename Naive_vector_column<Master_matrix>::Field_element>
-Naive_vector_column<Master_matrix>::get_content(int columnLength) const
+template <class Master_matrix, class Support>
+inline std::vector<typename Naive_vector_column<Master_matrix,Support>::Field_element>
+Naive_vector_column<Master_matrix,Support>::get_content(int columnLength) const
 {
   if (columnLength < 0 && column_.size() > 0)
     columnLength = column_.back()->get_row_index() + 1;
@@ -456,29 +463,29 @@ Naive_vector_column<Master_matrix>::get_content(int columnLength) const
   return container;
 }
 
-template <class Master_matrix>
-inline bool Naive_vector_column<Master_matrix>::is_non_zero(ID_index rowIndex) const
+template <class Master_matrix, class Support>
+inline bool Naive_vector_column<Master_matrix,Support>::is_non_zero(ID_index rowIndex) const
 {
   Entry entry(rowIndex);
   return std::binary_search(column_.begin(), column_.end(), &entry,
                             [](const Entry* a, const Entry* b) { return a->get_row_index() < b->get_row_index(); });
 }
 
-template <class Master_matrix>
-inline bool Naive_vector_column<Master_matrix>::is_empty() const
+template <class Master_matrix, class Support>
+inline bool Naive_vector_column<Master_matrix,Support>::is_empty() const
 {
   return column_.empty();
 }
 
-template <class Master_matrix>
-inline std::size_t Naive_vector_column<Master_matrix>::size() const
+template <class Master_matrix, class Support>
+inline std::size_t Naive_vector_column<Master_matrix,Support>::size() const
 {
   return column_.size();
 }
 
-template <class Master_matrix>
+template <class Master_matrix, class Support>
 template <class Row_index_map>
-inline void Naive_vector_column<Master_matrix>::reorder(const Row_index_map& valueMap,
+inline void Naive_vector_column<Master_matrix,Support>::reorder(const Row_index_map& valueMap,
                                                         [[maybe_unused]] Index columnIndex)
 {
   static_assert(!Master_matrix::isNonBasic || Master_matrix::Option_list::is_of_boundary_type,
@@ -504,8 +511,8 @@ inline void Naive_vector_column<Master_matrix>::reorder(const Row_index_map& val
   std::sort(column_.begin(), column_.end(), [](const Entry* c1, const Entry* c2) { return *c1 < *c2; });
 }
 
-template <class Master_matrix>
-inline void Naive_vector_column<Master_matrix>::clear()
+template <class Master_matrix, class Support>
+inline void Naive_vector_column<Master_matrix,Support>::clear()
 {
   static_assert(!Master_matrix::isNonBasic || Master_matrix::Option_list::is_of_boundary_type,
                 "Method not available for chain columns as a base element should not be empty.");
@@ -518,8 +525,8 @@ inline void Naive_vector_column<Master_matrix>::clear()
   column_.clear();
 }
 
-template <class Master_matrix>
-inline void Naive_vector_column<Master_matrix>::clear(ID_index rowIndex)
+template <class Master_matrix, class Support>
+inline void Naive_vector_column<Master_matrix,Support>::clear(ID_index rowIndex)
 {
   static_assert(!Master_matrix::isNonBasic || Master_matrix::Option_list::is_of_boundary_type,
                 "Method not available for chain columns.");
@@ -532,8 +539,8 @@ inline void Naive_vector_column<Master_matrix>::clear(ID_index rowIndex)
   }
 }
 
-template <class Master_matrix>
-inline typename Naive_vector_column<Master_matrix>::ID_index Naive_vector_column<Master_matrix>::get_pivot() const
+template <class Master_matrix, class Support>
+inline typename Naive_vector_column<Master_matrix,Support>::ID_index Naive_vector_column<Master_matrix,Support>::get_pivot() const
 {
   static_assert(Master_matrix::isNonBasic,
                 "Method not available for base columns.");  // could technically be, but is the notion useful then?
@@ -545,8 +552,8 @@ inline typename Naive_vector_column<Master_matrix>::ID_index Naive_vector_column
   }
 }
 
-template <class Master_matrix>
-inline typename Naive_vector_column<Master_matrix>::Field_element Naive_vector_column<Master_matrix>::get_pivot_value()
+template <class Master_matrix, class Support>
+inline typename Naive_vector_column<Master_matrix,Support>::Field_element Naive_vector_column<Master_matrix,Support>::get_pivot_value()
     const
 {
   static_assert(Master_matrix::isNonBasic,
@@ -567,63 +574,63 @@ inline typename Naive_vector_column<Master_matrix>::Field_element Naive_vector_c
   }
 }
 
-template <class Master_matrix>
-inline typename Naive_vector_column<Master_matrix>::iterator Naive_vector_column<Master_matrix>::begin() noexcept
+template <class Master_matrix, class Support>
+inline typename Naive_vector_column<Master_matrix,Support>::iterator Naive_vector_column<Master_matrix,Support>::begin() noexcept
 {
   return column_.begin();
 }
 
-template <class Master_matrix>
-inline typename Naive_vector_column<Master_matrix>::const_iterator Naive_vector_column<Master_matrix>::begin()
+template <class Master_matrix, class Support>
+inline typename Naive_vector_column<Master_matrix,Support>::const_iterator Naive_vector_column<Master_matrix,Support>::begin()
     const noexcept
 {
   return column_.begin();
 }
 
-template <class Master_matrix>
-inline typename Naive_vector_column<Master_matrix>::iterator Naive_vector_column<Master_matrix>::end() noexcept
+template <class Master_matrix, class Support>
+inline typename Naive_vector_column<Master_matrix,Support>::iterator Naive_vector_column<Master_matrix,Support>::end() noexcept
 {
   return column_.end();
 }
 
-template <class Master_matrix>
-inline typename Naive_vector_column<Master_matrix>::const_iterator Naive_vector_column<Master_matrix>::end()
+template <class Master_matrix, class Support>
+inline typename Naive_vector_column<Master_matrix,Support>::const_iterator Naive_vector_column<Master_matrix,Support>::end()
     const noexcept
 {
   return column_.end();
 }
 
-template <class Master_matrix>
-inline typename Naive_vector_column<Master_matrix>::reverse_iterator
-Naive_vector_column<Master_matrix>::rbegin() noexcept
+template <class Master_matrix, class Support>
+inline typename Naive_vector_column<Master_matrix,Support>::reverse_iterator
+Naive_vector_column<Master_matrix,Support>::rbegin() noexcept
 {
   return column_.rbegin();
 }
 
-template <class Master_matrix>
-inline typename Naive_vector_column<Master_matrix>::const_reverse_iterator Naive_vector_column<Master_matrix>::rbegin()
+template <class Master_matrix, class Support>
+inline typename Naive_vector_column<Master_matrix,Support>::const_reverse_iterator Naive_vector_column<Master_matrix,Support>::rbegin()
     const noexcept
 {
   return column_.rbegin();
 }
 
-template <class Master_matrix>
-inline typename Naive_vector_column<Master_matrix>::reverse_iterator
-Naive_vector_column<Master_matrix>::rend() noexcept
+template <class Master_matrix, class Support>
+inline typename Naive_vector_column<Master_matrix,Support>::reverse_iterator
+Naive_vector_column<Master_matrix,Support>::rend() noexcept
 {
   return column_.rend();
 }
 
-template <class Master_matrix>
-inline typename Naive_vector_column<Master_matrix>::const_reverse_iterator Naive_vector_column<Master_matrix>::rend()
+template <class Master_matrix, class Support>
+inline typename Naive_vector_column<Master_matrix,Support>::const_reverse_iterator Naive_vector_column<Master_matrix,Support>::rend()
     const noexcept
 {
   return column_.rend();
 }
 
-template <class Master_matrix>
+template <class Master_matrix, class Support>
 template <class Entry_range>
-inline Naive_vector_column<Master_matrix>& Naive_vector_column<Master_matrix>::operator+=(const Entry_range& column)
+inline Naive_vector_column<Master_matrix,Support>& Naive_vector_column<Master_matrix,Support>::operator+=(const Entry_range& column)
 {
   static_assert((!Master_matrix::isNonBasic || std::is_same_v<Entry_range, Naive_vector_column>),
                 "For boundary columns, the range has to be a column of same type to help ensure the validity of the "
@@ -636,8 +643,8 @@ inline Naive_vector_column<Master_matrix>& Naive_vector_column<Master_matrix>::o
   return *this;
 }
 
-template <class Master_matrix>
-inline Naive_vector_column<Master_matrix>& Naive_vector_column<Master_matrix>::operator+=(Naive_vector_column& column)
+template <class Master_matrix, class Support>
+inline Naive_vector_column<Master_matrix,Support>& Naive_vector_column<Master_matrix,Support>::operator+=(Naive_vector_column& column)
 {
   if constexpr (Master_matrix::isNonBasic && !Master_matrix::Option_list::is_of_boundary_type) {
     // assumes that the addition never zeros out this column.
@@ -652,8 +659,8 @@ inline Naive_vector_column<Master_matrix>& Naive_vector_column<Master_matrix>::o
   return *this;
 }
 
-template <class Master_matrix>
-inline Naive_vector_column<Master_matrix>& Naive_vector_column<Master_matrix>::operator*=(unsigned int v)
+template <class Master_matrix, class Support>
+inline Naive_vector_column<Master_matrix,Support>& Naive_vector_column<Master_matrix,Support>::operator*=(unsigned int v)
 {
   if constexpr (Master_matrix::Option_list::is_z2) {
     if (v % 2 == 0) {
@@ -686,9 +693,9 @@ inline Naive_vector_column<Master_matrix>& Naive_vector_column<Master_matrix>::o
   return *this;
 }
 
-template <class Master_matrix>
+template <class Master_matrix, class Support>
 template <class Entry_range>
-inline Naive_vector_column<Master_matrix>& Naive_vector_column<Master_matrix>::multiply_target_and_add(
+inline Naive_vector_column<Master_matrix,Support>& Naive_vector_column<Master_matrix,Support>::multiply_target_and_add(
     const Field_element& val, const Entry_range& column)
 {
   static_assert((!Master_matrix::isNonBasic || std::is_same_v<Entry_range, Naive_vector_column>),
@@ -711,8 +718,8 @@ inline Naive_vector_column<Master_matrix>& Naive_vector_column<Master_matrix>::m
   return *this;
 }
 
-template <class Master_matrix>
-inline Naive_vector_column<Master_matrix>& Naive_vector_column<Master_matrix>::multiply_target_and_add(
+template <class Master_matrix, class Support>
+inline Naive_vector_column<Master_matrix,Support>& Naive_vector_column<Master_matrix,Support>::multiply_target_and_add(
     const Field_element& val, Naive_vector_column& column)
 {
   if constexpr (Master_matrix::isNonBasic && !Master_matrix::Option_list::is_of_boundary_type) {
@@ -748,9 +755,9 @@ inline Naive_vector_column<Master_matrix>& Naive_vector_column<Master_matrix>::m
   return *this;
 }
 
-template <class Master_matrix>
+template <class Master_matrix, class Support>
 template <class Entry_range>
-inline Naive_vector_column<Master_matrix>& Naive_vector_column<Master_matrix>::multiply_source_and_add(
+inline Naive_vector_column<Master_matrix,Support>& Naive_vector_column<Master_matrix,Support>::multiply_source_and_add(
     const Entry_range& column, const Field_element& val)
 {
   static_assert((!Master_matrix::isNonBasic || std::is_same_v<Entry_range, Naive_vector_column>),
@@ -770,8 +777,8 @@ inline Naive_vector_column<Master_matrix>& Naive_vector_column<Master_matrix>::m
   return *this;
 }
 
-template <class Master_matrix>
-inline Naive_vector_column<Master_matrix>& Naive_vector_column<Master_matrix>::multiply_source_and_add(
+template <class Master_matrix, class Support>
+inline Naive_vector_column<Master_matrix,Support>& Naive_vector_column<Master_matrix,Support>::multiply_source_and_add(
     Naive_vector_column& column, const Field_element& val)
 {
   if constexpr (Master_matrix::isNonBasic && !Master_matrix::Option_list::is_of_boundary_type) {
@@ -802,8 +809,8 @@ inline Naive_vector_column<Master_matrix>& Naive_vector_column<Master_matrix>::m
   return *this;
 }
 
-template <class Master_matrix>
-inline void Naive_vector_column<Master_matrix>::push_back(const Entry& entry)
+template <class Master_matrix, class Support>
+inline void Naive_vector_column<Master_matrix,Support>::push_back(const Entry& entry)
 {
   static_assert(Master_matrix::Option_list::is_of_boundary_type, "`push_back` is not available for Chain matrices.");
 
@@ -816,8 +823,8 @@ inline void Naive_vector_column<Master_matrix>::push_back(const Entry& entry)
   }
 }
 
-template <class Master_matrix>
-inline Naive_vector_column<Master_matrix>& Naive_vector_column<Master_matrix>::operator=(
+template <class Master_matrix, class Support>
+inline Naive_vector_column<Master_matrix,Support>& Naive_vector_column<Master_matrix,Support>::operator=(
     const Naive_vector_column& other)
 {
   static_assert(!Master_matrix::Option_list::has_row_access, "= assignment not enabled with row access option.");
@@ -855,22 +862,22 @@ inline Naive_vector_column<Master_matrix>& Naive_vector_column<Master_matrix>::o
   return *this;
 }
 
-template <class Master_matrix>
-inline void Naive_vector_column<Master_matrix>::_delete_entry(Entry* entry)
+template <class Master_matrix, class Support>
+inline void Naive_vector_column<Master_matrix,Support>::_delete_entry(Entry* entry)
 {
   if constexpr (Master_matrix::Option_list::has_row_access) RA_opt::unlink(entry);
   entryPool_->destroy(entry);
 }
 
-template <class Master_matrix>
-inline void Naive_vector_column<Master_matrix>::_delete_entry(typename Column_support::iterator& it)
+template <class Master_matrix, class Support>
+inline void Naive_vector_column<Master_matrix,Support>::_delete_entry(typename Column_support::iterator& it)
 {
   _delete_entry(*it);
   ++it;
 }
 
-template <class Master_matrix>
-inline typename Naive_vector_column<Master_matrix>::Entry* Naive_vector_column<Master_matrix>::_insert_entry(
+template <class Master_matrix, class Support>
+inline typename Naive_vector_column<Master_matrix,Support>::Entry* Naive_vector_column<Master_matrix,Support>::_insert_entry(
     const Field_element& value, ID_index rowIndex, Column_support& column)
 {
   if constexpr (Master_matrix::Option_list::has_row_access) {
@@ -887,8 +894,8 @@ inline typename Naive_vector_column<Master_matrix>::Entry* Naive_vector_column<M
   }
 }
 
-template <class Master_matrix>
-inline void Naive_vector_column<Master_matrix>::_insert_entry(ID_index rowIndex, Column_support& column)
+template <class Master_matrix, class Support>
+inline void Naive_vector_column<Master_matrix,Support>::_insert_entry(ID_index rowIndex, Column_support& column)
 {
   if constexpr (Master_matrix::Option_list::has_row_access) {
     Entry* newEntry = entryPool_->construct(RA_opt::columnIndex_, rowIndex);
@@ -899,8 +906,8 @@ inline void Naive_vector_column<Master_matrix>::_insert_entry(ID_index rowIndex,
   }
 }
 
-template <class Master_matrix>
-inline void Naive_vector_column<Master_matrix>::_update_entry(const Field_element& value,
+template <class Master_matrix, class Support>
+inline void Naive_vector_column<Master_matrix,Support>::_update_entry(const Field_element& value,
                                                              ID_index rowIndex,
                                                              Index position)
 {
@@ -915,8 +922,8 @@ inline void Naive_vector_column<Master_matrix>::_update_entry(const Field_elemen
   }
 }
 
-template <class Master_matrix>
-inline void Naive_vector_column<Master_matrix>::_update_entry(ID_index rowIndex, Index position)
+template <class Master_matrix, class Support>
+inline void Naive_vector_column<Master_matrix,Support>::_update_entry(ID_index rowIndex, Index position)
 {
   if constexpr (Master_matrix::Option_list::has_row_access) {
     Entry* newEntry = entryPool_->construct(RA_opt::columnIndex_, rowIndex);
@@ -927,9 +934,9 @@ inline void Naive_vector_column<Master_matrix>::_update_entry(ID_index rowIndex,
   }
 }
 
-template <class Master_matrix>
+template <class Master_matrix, class Support>
 template <class Entry_range>
-inline bool Naive_vector_column<Master_matrix>::_add(const Entry_range& column)
+inline bool Naive_vector_column<Master_matrix,Support>::_add(const Entry_range& column)
 {
   if (column.begin() == column.end()) return false;
   if (column_.empty()) {  // chain should never enter here.
@@ -977,9 +984,9 @@ inline bool Naive_vector_column<Master_matrix>::_add(const Entry_range& column)
   return pivotIsZeroed;
 }
 
-template <class Master_matrix>
+template <class Master_matrix, class Support>
 template <class Entry_range>
-inline bool Naive_vector_column<Master_matrix>::_multiply_target_and_add(const Field_element& val,
+inline bool Naive_vector_column<Master_matrix,Support>::_multiply_target_and_add(const Field_element& val,
                                                                          const Entry_range& column)
 {
   if (val == 0u) {
@@ -1035,9 +1042,9 @@ inline bool Naive_vector_column<Master_matrix>::_multiply_target_and_add(const F
   return pivotIsZeroed;
 }
 
-template <class Master_matrix>
+template <class Master_matrix, class Support>
 template <class Entry_range>
-inline bool Naive_vector_column<Master_matrix>::_multiply_source_and_add(const Entry_range& column,
+inline bool Naive_vector_column<Master_matrix,Support>::_multiply_source_and_add(const Entry_range& column,
                                                                          const Field_element& val)
 {
   if (val == 0u || column.begin() == column.end()) {
@@ -1083,9 +1090,9 @@ inline bool Naive_vector_column<Master_matrix>::_multiply_source_and_add(const E
  * @tparam Master_matrix Template parameter of @ref Gudhi::persistence_matrix::Naive_vector_column.
  * @tparam Entry_constructor Template parameter of @ref Gudhi::persistence_matrix::Naive_vector_column.
  */
-template <class Master_matrix>
-struct std::hash<Gudhi::persistence_matrix::Naive_vector_column<Master_matrix> > {
-  std::size_t operator()(const Gudhi::persistence_matrix::Naive_vector_column<Master_matrix>& column) const {
+template <class Master_matrix, class Support>
+struct std::hash<Gudhi::persistence_matrix::Naive_vector_column<Master_matrix,Support> > {
+  std::size_t operator()(const Gudhi::persistence_matrix::Naive_vector_column<Master_matrix,Support>& column) const {
     return Gudhi::persistence_matrix::hash_column(column);
   }
 };
diff --git a/src/Persistence_matrix/include/gudhi/persistence_matrix_options.h b/src/Persistence_matrix/include/gudhi/persistence_matrix_options.h
index 58f7bc117c..0d7c83785c 100644
--- a/src/Persistence_matrix/include/gudhi/persistence_matrix_options.h
+++ b/src/Persistence_matrix/include/gudhi/persistence_matrix_options.h
@@ -35,6 +35,8 @@ enum class Column_types {
   VECTOR,         /**< @ref Vector_column "": Underlying container is a std::vector<@ref Entry*>
                        with a lazy removal method. */
   NAIVE_VECTOR,   /**< @ref Naive_vector_column "": Underlying container is a std::vector<@ref Entry*>. */
+  SMALL_VECTOR,   /**< @ref Naive_vector_column "": Underlying container is a
+                       boost::container::small_vector<@ref Entry*, 8>. */
   UNORDERED_SET,  /**< @ref Unordered_set_column "": Underlying container is a std::unordered_set<@ref Entry*>. */
   INTRUSIVE_LIST, /**< @ref Intrusive_list_column "": Underlying container is a boost::intrusive::list<@ref Entry>. */
   INTRUSIVE_SET   /**< @ref Intrusive_set_column "": Underlying container is a boost::intrusive::set<@ref Entry>. */
diff --git a/src/Persistence_matrix/test/pm_column_tests_boost_type_lists.h b/src/Persistence_matrix/test/pm_column_tests_boost_type_lists.h
index 1f4b28b349..dbccb01e72 100644
--- a/src/Persistence_matrix/test/pm_column_tests_boost_type_lists.h
+++ b/src/Persistence_matrix/test/pm_column_tests_boost_type_lists.h
@@ -30,7 +30,8 @@ using Gudhi::persistence_matrix::Heap_column;
 using Gudhi::persistence_matrix::Intrusive_list_column;
 using Gudhi::persistence_matrix::Intrusive_set_column;
 using Gudhi::persistence_matrix::List_column;
-using Gudhi::persistence_matrix::Naive_vector_column;
+using Gudhi::persistence_matrix::STD_naive_vector_column;
+using Gudhi::persistence_matrix::Small_naive_vector_column;
 using Gudhi::persistence_matrix::Set_column;
 using Gudhi::persistence_matrix::Unordered_set_column;
 using Gudhi::persistence_matrix::Vector_column;
@@ -65,7 +66,9 @@ class column_non_validity {
     } else if constexpr (col_type::Master::Option_list::column_type == Column_types::UNORDERED_SET) {
       return !std::is_same_v<col_type, Unordered_set_column<typename col_type::Master> >;
     } else if constexpr (col_type::Master::Option_list::column_type == Column_types::NAIVE_VECTOR) {
-      return !std::is_same_v<col_type, Naive_vector_column<typename col_type::Master> >;
+      return !std::is_same_v<col_type, STD_naive_vector_column<typename col_type::Master> >;
+    } else if constexpr (col_type::Master::Option_list::column_type == Column_types::SMALL_VECTOR) {
+      return !std::is_same_v<col_type, Small_naive_vector_column<typename col_type::Master> >;
     } else if constexpr (col_type::Master::Option_list::column_type == Column_types::VECTOR) {
       return !std::is_same_v<col_type, Vector_column<typename col_type::Master> >;
     } else if constexpr (col_type::Master::Option_list::column_type == Column_types::HEAP) {
@@ -81,12 +84,13 @@ class column_non_validity {
 
 // if a new column type is implemented, create a `ct_*` structure for it and add it to this list...
 using col_type_list = boost::mp11::mp_list<ct_intrusive_list, ct_intrusive_set, ct_list, ct_set, ct_heap,
-                                           ct_unordered_set, ct_vector, ct_naive_vector>;
+                                           ct_unordered_set, ct_vector, ct_naive_vector, ct_small_vector>;
 using row_col_type_list = boost::mp11::mp_list<ct_intrusive_list, ct_intrusive_set, ct_list, ct_set, ct_unordered_set,
-                                               ct_vector, ct_naive_vector>;
+                                               ct_vector, ct_naive_vector, ct_small_vector>;
 //...and add the column name here.
-using column_list = mp_list_q<Intrusive_list_column, Intrusive_set_column, List_column, Set_column,
-                              Unordered_set_column, Naive_vector_column, Vector_column, Heap_column>;
+using column_list =
+    mp_list_q<Intrusive_list_column, Intrusive_set_column, List_column, Set_column, Unordered_set_column,
+              STD_naive_vector_column, Small_naive_vector_column, Vector_column, Heap_column>;
 using c_matrix_type_list = mp_list_q<Column_mini_matrix>;
 
 template <typename option_name_list, typename bool_is_z2, typename col_t, typename bool_has_row, typename bool_rem_row,
diff --git a/src/Persistence_matrix/test/pm_common_boost_type_lists.h b/src/Persistence_matrix/test/pm_common_boost_type_lists.h
index fe67522bd5..14993d0414 100644
--- a/src/Persistence_matrix/test/pm_common_boost_type_lists.h
+++ b/src/Persistence_matrix/test/pm_common_boost_type_lists.h
@@ -49,6 +49,10 @@ struct ct_naive_vector {
   static constexpr const Column_types t = Column_types::NAIVE_VECTOR;
 };
 
+struct ct_small_vector {
+  static constexpr const Column_types t = Column_types::SMALL_VECTOR;
+};
+
 struct true_value {
   static constexpr const bool t = true;
 };
diff --git a/src/Persistence_matrix/test/pm_matrix_tests_boost_type_lists.h b/src/Persistence_matrix/test/pm_matrix_tests_boost_type_lists.h
index 5307b62cff..776cbfedac 100644
--- a/src/Persistence_matrix/test/pm_matrix_tests_boost_type_lists.h
+++ b/src/Persistence_matrix/test/pm_matrix_tests_boost_type_lists.h
@@ -138,7 +138,7 @@ class matrix_non_validity {
 // users. But in case real changes were made to this module, it would be better to test at least once with all column
 // types as below:
 // using col_type_list = boost::mp11::mp_list<ct_intrusive_list, ct_intrusive_set, ct_list, ct_set, ct_heap,
-//                                            ct_unordered_set, ct_vector, ct_naive_vector>;
+//                                            ct_unordered_set, ct_vector, ct_naive_vector, ct_small_vector>;
 #ifdef PM_TEST_INTR_LIST
 using col_type_list = boost::mp11::mp_list<ct_intrusive_list>;
 #else
@@ -162,6 +162,9 @@ using col_type_list = boost::mp11::mp_list<ct_unordered_set>;
 #ifdef PM_TEST_NAIVE_VECTOR
 using col_type_list = boost::mp11::mp_list<ct_naive_vector>;
 #else
+#ifdef PM_TEST_SMALL_VECTOR
+using col_type_list = boost::mp11::mp_list<ct_small_vector>;
+#else
 using col_type_list = boost::mp11::mp_list<ct_vector>;
 #endif
 #endif
@@ -170,6 +173,7 @@ using col_type_list = boost::mp11::mp_list<ct_vector>;
 #endif
 #endif
 #endif
+#endif
 
 using matrix_type_list = mp_list_q<Matrix>;