tpl_matgraph.H

Go to the documentation of this file.

 
/*
                          Aleph_w
 
  Data structures & Algorithms
  version 2.0.0b
  https://github.com/lrleon/Aleph-w
 
  This file is part of Aleph-w library
 
  Copyright (c) 2002-2026 Leandro Rabindranath Leon
 
  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:
 
  The above copyright notice and this permission notice shall be included in all
  copies or substantial portions of the Software.
 
  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  SOFTWARE.
*/
 
 
#ifndef TPL_MAT_GRAPH_H
#define TPL_MAT_GRAPH_H
 
#include <tpl_graph.H>
#include <tpl_sort_utils.H>
#include <ah-errors.H>
 
namespace Aleph
{
 
// =============================================================================
// Internal Helper Functions
// =============================================================================
 
namespace matgraph_detail
{
 
template <typename GT>
[[nodiscard]] inline typename GT::Node*
get_node(DynArray<typename GT::Node*>& nodes, long i)
{
  ah_out_of_range_error_if(i < 0 or static_cast<size_t>(i) >= nodes.size())
    << "Node index " << i << " out of range [0, " << nodes.size() << ")";
  return nodes.access(i);
}
 
template <typename GT>
[[nodiscard]] inline typename GT::Node*
get_node(const DynArray<typename GT::Node*>& nodes, long i)
{
  ah_out_of_range_error_if(i < 0 or static_cast<size_t>(i) >= nodes.size())
    << "Node index " << i << " out of range [0, " << nodes.size() << ")";
  return nodes.access(i);
}
 
template <typename GT>
[[nodiscard]] inline long
node_index(const DynArray<typename GT::Node*>& nodes, long n, typename GT::Node* p)
{
  return Aleph::binary_search(nodes, p, 0, n - 1);
}
 
[[nodiscard]] inline long
index_array(long i, long j, long n) noexcept
{
  return i + j * n;
}
 
[[nodiscard]] inline long
checked_index_array(long i, long j, long n)
{
  ah_out_of_range_error_if(i < 0 or i >= n or j < 0 or j >= n)
    << "Matrix index (" << i << ", " << j << ") out of range [0, " << n << ")";
  return index_array(i, j, n);
}
 
template <typename Entry>
[[nodiscard]] inline Entry*
read_matrix(const DynArray<Entry>& mat, long i, long j, long n)
{
  const long index = checked_index_array(i, j, n);
  if (not mat.exist(index))
    return nullptr;
  return &const_cast<Entry&>(mat.access(index));
}
 
template <typename Entry>
inline void
write_matrix(DynArray<Entry>& mat, long i, long j, long n, const Entry& entry)
{
  mat[checked_index_array(i, j, n)] = entry;
}
 
} // namespace matgraph_detail
 
 
// =============================================================================
// Map_Matrix_Graph - Mapped Adjacency Matrix
// =============================================================================
 
template <class GT, class SA = Dft_Show_Arc<GT>>
class Map_Matrix_Graph
{
public:
  using Graph_Type = GT;
 
  using Node_Type = typename GT::Node_Type;
 
  using Arc_Type = typename GT::Arc_Type;
 
  using Node = typename GT::Node;
 
  using Arc = typename GT::Arc;
 
private:
  struct Mat_Entry
  {
    Arc* arc = nullptr;
    Mat_Entry() = default;
    explicit Mat_Entry(Arc* a) : arc(a) {}
  };
 
  DynArray<Node*>    nodes;
  GT*                lgraph = nullptr;
  mutable size_t     num_nodes = 0;
  SA                 sa;
  DynArray<Mat_Entry> mat;
 
public:
  void copy_list_graph(GT& g);
 
  Map_Matrix_Graph(GT& g, SA&& __sa = SA())
    : lgraph(&g), num_nodes(g.get_num_nodes()), sa(std::move(__sa))
  {
    copy_list_graph(g);
  }
 
  Map_Matrix_Graph(GT& g, SA& __sa)
    : lgraph(&g), num_nodes(g.get_num_nodes()), sa(__sa)
  {
    copy_list_graph(g);
  }
 
  Map_Matrix_Graph(Map_Matrix_Graph& other)
    : lgraph(other.lgraph), num_nodes(other.num_nodes), sa(other.sa)
  {
    copy_list_graph(*other.lgraph);
  }
 
  Map_Matrix_Graph& operator=(Map_Matrix_Graph& other);
 
  Map_Matrix_Graph& operator=(GT& g);
 
  [[nodiscard]] Node* operator()(long i)
  {
    return matgraph_detail::get_node<GT>(nodes, i);
  }
 
  [[nodiscard]] long operator()(Node* node) const
  {
    return matgraph_detail::node_index<GT>(nodes, num_nodes, node);
  }
 
  [[nodiscard]] Arc* operator()(Node* src_node, Node* tgt_node) const
  {
    Mat_Entry* entry = matgraph_detail::read_matrix<Mat_Entry>(
      mat,
      matgraph_detail::node_index<GT>(nodes, num_nodes, src_node),
      matgraph_detail::node_index<GT>(nodes, num_nodes, tgt_node),
      num_nodes);
    return entry ? entry->arc : nullptr;
  }
 
  [[nodiscard]] Arc* operator()(long i, long j) const
  {
    Mat_Entry* entry = matgraph_detail::read_matrix<Mat_Entry>(mat, i, j, num_nodes);
    return entry ? entry->arc : nullptr;
  }
 
  [[nodiscard]] GT& get_list_graph() noexcept { return *lgraph; }
 
  [[nodiscard]] const GT& get_list_graph() const noexcept { return *lgraph; }
 
  [[nodiscard]] size_t get_num_nodes() const noexcept { return num_nodes; }
};
 
// Implementation
 
template <class GT, class SA>
Map_Matrix_Graph<GT, SA>&
Map_Matrix_Graph<GT, SA>::operator=(Map_Matrix_Graph& other)
{
  if (this != &other)
    copy_list_graph(*other.lgraph);
  return *this;
}
 
template <class GT, class SA>
Map_Matrix_Graph<GT, SA>&
Map_Matrix_Graph<GT, SA>::operator=(GT& g)
{
  copy_list_graph(g);
  return *this;
}
 
template <class GT, class SA>
void
Map_Matrix_Graph<GT, SA>::copy_list_graph(GT& g)
{
  lgraph = &g;
  num_nodes = g.get_num_nodes();
  nodes.cut();
  mat.cut();
 
  // Copy nodes to array
  long i = 0;
  for (typename GT::Node_Iterator it(g); it.has_curr(); it.next_ne(), ++i)
    nodes[i] = it.get_current_node_ne();
 
  // Sort for binary search
  quicksort(nodes);
 
  // Copy arcs to matrix
  for (typename GT::Node_Iterator nit(g); nit.has_curr(); nit.next_ne())
    {
      Node* src = nit.get_current_node_ne();
      const long src_idx = matgraph_detail::node_index<GT>(nodes, num_nodes, src);
 
      for (Node_Arc_Iterator<GT, SA> ait(src, sa); ait.has_curr(); ait.next_ne())
        {
          Arc* arc = ait.get_current_arc_ne();
          Node* tgt = g.get_connected_node(arc, src);
          const long tgt_idx = matgraph_detail::node_index<GT>(nodes, num_nodes, tgt);
          matgraph_detail::write_matrix<Mat_Entry>(mat, src_idx, tgt_idx, num_nodes, Mat_Entry(arc));
        }
    }
}
 
 
// =============================================================================
// Matrix_Graph - Attribute-Copying Adjacency Matrix
// =============================================================================
 
template <typename GT, class SA = Dft_Show_Arc<GT>>
class Matrix_Graph
{
public:
  using Graph_Type = GT;
 
  using Node_Type = typename GT::Node_Type;
 
  using Arc_Type = typename GT::Arc_Type;
 
  using Node = typename GT::Node;
 
  using Arc = typename GT::Arc;
 
private:
  DynArray<Node_Type> nodes;
  DynArray<Arc_Type>  arcs;
  mutable size_t      n = 0;
  mutable Arc_Type    Null_Value{};
  SA                  sa;
 
  void copy(Matrix_Graph& other)
  {
    if (this == &other)
      return;
 
    n = other.n;
    Null_Value = other.Null_Value;
    nodes.cut();
    arcs.cut();
    arcs.set_default_initial_value(Null_Value);
 
    for (size_t i = 0; i < n; ++i)
      {
        nodes[i] = other.nodes[i];
        for (size_t j = 0; j < n; ++j)
          {
            const long idx = matgraph_detail::index_array(i, j, n);
            if (other.arcs.exist(idx))
              arcs.touch(idx) = other.arcs.access(idx);
          }
      }
  }
 
  void copy(GT& g)
  {
    n = g.get_num_nodes();
    DynArray<typename GT::Node*> ptr;
 
    long i = 0;
    for (typename GT::Node_Iterator it(g); it.has_curr(); it.next_ne(), ++i)
      ptr[i] = it.get_current_node_ne();
 
    quicksort(ptr);
    arcs.set_default_initial_value(Null_Value);
 
    for (size_t idx = 0; idx < n; ++idx)
      {
        typename GT::Node* src = ptr[idx];
        nodes[idx] = src->get_info();
        for (Node_Arc_Iterator<GT, SA> it(src, sa); it.has_curr(); it.next_ne())
          {
            typename GT::Arc* arc = it.get_current_arc_ne();
            typename GT::Node* tgt = it.get_tgt_node();
            const long j = matgraph_detail::node_index<GT>(ptr, n, tgt);
            arcs[matgraph_detail::index_array(idx, j, n)] = arc->get_info();
          }
      }
  }
 
public:
  [[nodiscard]] size_t get_num_nodes() const noexcept { return n; }
 
  [[nodiscard]] const Arc_Type& null_value() const noexcept { return Null_Value; }
 
  Matrix_Graph(GT& g, const Arc_Type& null, SA&& __sa = SA())
    : Null_Value(null), sa(std::move(__sa))
  {
    copy(g);
  }
 
  Matrix_Graph(GT& g, const Arc_Type& null, SA& __sa)
    : Null_Value(null), sa(__sa)
  {
    copy(g);
  }
 
  Matrix_Graph(Matrix_Graph& other) { copy(other); }
 
  Matrix_Graph& operator=(Matrix_Graph& other)
  {
    copy(other);
    return *this;
  }
 
  Matrix_Graph& operator=(GT& g)
  {
    copy(g);
    return *this;
  }
 
  [[nodiscard]] const Arc_Type& operator()(long i, long j) const
  {
    const long idx = matgraph_detail::checked_index_array(i, j, n);
    return arcs.exist(idx) ? arcs.access(idx) : Null_Value;
  }
 
  [[nodiscard]] Node_Type& operator()(long i) const
  {
    ah_out_of_range_error_if(i < 0 or static_cast<size_t>(i) >= n)
      << "Node index " << i << " out of range";
    return const_cast<Node_Type&>(nodes.access(i));
  }
 
  [[nodiscard]] Arc_Type& operator()(long i, long j)
  {
    return arcs.touch(matgraph_detail::checked_index_array(i, j, n));
  }
};
 
 
// =============================================================================
// Ady_Mat - Auxiliary Adjacency Matrix
// =============================================================================
 
template <class GT, typename __Entry_Type, class SA = Dft_Show_Arc<GT>>
class Ady_Mat
{
public:
  using Graph_Type = GT;
 
  using Entry_Type = __Entry_Type;
 
  using Node_Type = typename GT::Node_Type;
 
  using Arc_Type = typename GT::Arc_Type;
 
  using Node = typename GT::Node;
 
  using Arc = typename GT::Arc;
 
private:
  GT*                  lgraph = nullptr;
  DynArray<Node*>      nodes;
  DynArray<Entry_Type> mat;
  mutable size_t       num_nodes = 0;
  mutable Entry_Type   Null_Value{};
 
  void test_same_graph(const Ady_Mat& other) const
  {
    ah_domain_error_if(lgraph != other.lgraph)
      << "Matrices refer to different graphs";
  }
 
  void copy_nodes(GT& g)
  {
    lgraph = &g;
    num_nodes = g.get_num_nodes();
    nodes.cut();
 
    long i = 0;
    for (typename GT::Node_Iterator it(g); it.has_curr(); it.next_ne(), ++i)
      nodes[i] = it.get_current_node_ne();
 
    quicksort(nodes);
  }
 
  Ady_Mat& copy(Ady_Mat& other)
  {
    if (this == &other)
      return *this;
 
    test_same_graph(other);
    Null_Value = other.Null_Value;
    copy_nodes(*other.lgraph);
    return *this;
  }
 
public:
  [[nodiscard]] Node* operator()(long i)
  {
    return matgraph_detail::get_node<GT>(nodes, i);
  }
 
  [[nodiscard]] Node* operator()(long i) const
  {
    return matgraph_detail::get_node<GT>(nodes, i);
  }
 
  [[nodiscard]] long operator()(Node* node) const
  {
    return matgraph_detail::node_index<GT>(nodes, num_nodes, node);
  }
 
  [[nodiscard]] Entry_Type& operator()(long i, long j)
  {
    return mat.touch(matgraph_detail::checked_index_array(i, j, num_nodes));
  }
 
  [[nodiscard]] const Entry_Type& operator()(long i, long j) const
  {
    const long index = matgraph_detail::checked_index_array(i, j, num_nodes);
    return mat.exist(index) ? mat.access(index) : Null_Value;
  }
 
  [[nodiscard]] Entry_Type& operator()(Node* src, Node* tgt)
  {
    return (*this)(matgraph_detail::node_index<GT>(nodes, num_nodes, src),
                   matgraph_detail::node_index<GT>(nodes, num_nodes, tgt));
  }
 
  [[nodiscard]] const Entry_Type& operator()(Node* src, Node* tgt) const
  {
    return (*this)(matgraph_detail::node_index<GT>(nodes, num_nodes, src),
                   matgraph_detail::node_index<GT>(nodes, num_nodes, tgt));
  }
 
  [[nodiscard]] GT& get_list_graph() noexcept { return *lgraph; }
 
  [[nodiscard]] const GT& get_list_graph() const noexcept { return *lgraph; }
 
  [[nodiscard]] const Entry_Type& null_value() const noexcept { return Null_Value; }
 
  [[nodiscard]] size_t get_num_nodes() const noexcept { return num_nodes; }
 
  explicit Ady_Mat(GT& g)
    : lgraph(&g), num_nodes(g.get_num_nodes())
  {
    copy_nodes(g);
  }
 
  Ady_Mat(GT& g, const Entry_Type& null)
    : lgraph(&g), num_nodes(g.get_num_nodes()), Null_Value(null)
  {
    copy_nodes(g);
  }
 
  void set_null_value(const Entry_Type& null) noexcept { Null_Value = null; }
 
  Ady_Mat(Ady_Mat& other) { copy(other); }
 
  Ady_Mat& operator=(Ady_Mat& other) { return copy(other); }
 
  template <class Operation>
  void operate_all_arcs_list_graph();
 
  template <class Operation>
  void operate_all_arcs_list_graph(void* ptr);
 
  template <class Operation>
  void operate_all_arcs_matrix();
 
  template <class Operation>
  void operate_all_arcs_matrix(void* ptr);
};
 
// Implementation of operate_* methods
 
template <class GT, typename __Entry_Type, class SA>
template <class Operation>
void
Ady_Mat<GT, __Entry_Type, SA>::operate_all_arcs_list_graph()
{
  for (typename GT::Node_Iterator nit(*lgraph); nit.has_curr(); nit.next_ne())
    {
      Node* src = nit.get_current_node_ne();
      const long src_idx = matgraph_detail::node_index<Graph_Type>(nodes, num_nodes, src);
 
      for (Node_Arc_Iterator<GT, SA> at(src); at.has_curr(); at.next_ne())
        {
          Arc* arc = at.get_current_arc_ne();
          Node* tgt = at.get_tgt_node();
          const long tgt_idx =
            matgraph_detail::node_index<Graph_Type>(nodes, num_nodes, tgt);
          Entry_Type& entry =
            mat.touch(matgraph_detail::index_array(src_idx, tgt_idx, num_nodes));
          Operation()(*this, arc, src_idx, tgt_idx, entry);
        }
    }
}
 
template <class GT, typename __Entry_Type, class SA>
template <class Operation>
void
Ady_Mat<GT, __Entry_Type, SA>::operate_all_arcs_list_graph(void* ptr)
{
  for (typename GT::Node_Iterator nit(*lgraph); nit.has_curr(); nit.next_ne())
    {
      Node* src = nit.get_current_node_ne();
      const long src_idx = matgraph_detail::node_index<Graph_Type>(nodes, num_nodes, src);
 
      for (Node_Arc_Iterator<GT, SA> at(src); at.has_curr(); at.next_ne())
        {
          Arc* arc = at.get_current_arc_ne();
          Node* tgt = lgraph->get_tgt_node(arc);
          const long tgt_idx = matgraph_detail::node_index<Graph_Type>(nodes, num_nodes, tgt);
          Entry_Type& entry =
            mat.touch(matgraph_detail::index_array(src_idx, tgt_idx, num_nodes));
          Operation()(*this, arc, src_idx, tgt_idx, entry, ptr);
        }
    }
}
 
template <class GT, typename __Entry_Type, class SA>
template <class Operation>
void
Ady_Mat<GT, __Entry_Type, SA>::operate_all_arcs_matrix()
{
  const long n = num_nodes;
  for (long s = 0; s < n; ++s)
    {
      Node* src_node = matgraph_detail::get_node<GT>(nodes, s);
      for (long t = 0; t < n; ++t)
        {
          Node* tgt_node = matgraph_detail::get_node<GT>(nodes, t);
          Entry_Type& entry = mat.touch(matgraph_detail::index_array(s, t, num_nodes));
          Operation()(*this, src_node, tgt_node, s, t, entry);
        }
    }
}
 
template <class GT, typename __Entry_Type, class SA>
template <class Operation>
void
Ady_Mat<GT, __Entry_Type, SA>::operate_all_arcs_matrix(void* ptr)
{
  const long n = num_nodes;
  for (long s = 0; s < n; ++s)
    {
      Node* src_node = matgraph_detail::get_node<GT>(nodes, s);
      for (long t = 0; t < n; ++t)
        {
          Node* tgt_node = matgraph_detail::get_node<GT>(nodes, t);
          Entry_Type& entry = mat.touch(matgraph_detail::index_array(s, t, num_nodes));
          Operation()(*this, src_node, tgt_node, s, t, entry, ptr);
        }
    }
}
 
 
// =============================================================================
// Bit_Mat_Graph - Bit Matrix for Connectivity
// =============================================================================
 
template <class GT, class SA = Dft_Show_Arc<GT>>
class Bit_Mat_Graph
{
public:
  using Graph_Type = GT;
 
  using Node = typename GT::Node;
 
  using Arc = typename GT::Arc;
 
private:
  BitArray                     bit_array;
  GT*                          lgraph = nullptr;
  DynArray<typename GT::Node*> nodes;
  mutable size_t               n = 0;
 
  void copy_list_graph(GT& g)
  {
    n = g.get_num_nodes();
    nodes.cut();
 
    long i = 0;
    for (typename GT::Node_Iterator it(g); it.has_curr(); it.next_ne())
      nodes[i++] = static_cast<typename GT::Node*>(it.get_current_node_ne());
 
    quicksort(nodes);
 
    for (typename GT::Node_Iterator it(g); it.has_curr(); it.next_ne())
      {
        typename GT::Node* src = it.get_current_node_ne();
        const size_t src_idx = matgraph_detail::node_index<Graph_Type>(nodes, n, src);
 
        for (Node_Arc_Iterator<GT, SA> jt(src); jt.has_curr(); jt.next_ne())
          {
            typename GT::Node* tgt = jt.get_tgt_node_ne();
            const size_t tgt_idx = matgraph_detail::node_index<Graph_Type>(nodes, n, tgt);
            bit_array[matgraph_detail::index_array(src_idx, tgt_idx, n)] = 1;
          }
      }
  }
 
  struct Proxy
  {
    BitArray&    bit_array;
    const size_t bit_index;
 
    Proxy(Bit_Mat_Graph& bitmat, long i, long j)
      : bit_array(bitmat.bit_array),
        bit_index(matgraph_detail::index_array(i, j, bitmat.n))
    {}
 
    Proxy& operator=(const Proxy& other)
    {
      bit_array[bit_index] = other.bit_array[other.bit_index];
      return *this;
    }
 
    Proxy& operator=(int value)
    {
      bit_array[bit_index] = value;
      return *this;
    }
 
    operator int() const { return bit_array[bit_index]; }
  };
 
public:
  [[nodiscard]] size_t get_num_nodes() const noexcept { return n; }
 
  Bit_Mat_Graph() = default;
 
  explicit Bit_Mat_Graph(GT& g)
    : bit_array(g.get_num_nodes() * g.get_num_nodes()), lgraph(&g)
  {
    copy_list_graph(g);
  }
 
  Bit_Mat_Graph(const Bit_Mat_Graph& other)
    : bit_array(other.bit_array), lgraph(other.lgraph),
      nodes(other.nodes), n(other.n)
  {}
 
  explicit Bit_Mat_Graph(size_t dim)
    : bit_array(dim * dim), nodes(dim), n(dim)
  {}
 
  void set_list_graph(GT& g)
  {
    const size_t new_n = g.get_num_nodes();
    bit_array.set_size(new_n * new_n);
    lgraph = &g;
    copy_list_graph(g);
  }
 
  [[nodiscard]] GT* get_list_graph() noexcept { return lgraph; }
 
  [[nodiscard]] const GT* get_list_graph() const noexcept { return lgraph; }
 
  Bit_Mat_Graph& operator=(const Bit_Mat_Graph& other)
  {
    if (this != &other)
      {
        lgraph = other.lgraph;
        bit_array = other.bit_array;
        nodes = other.nodes;
        n = other.n;
      }
    return *this;
  }
 
  Bit_Mat_Graph& operator=(GT& g)
  {
    if (&g != lgraph)
        set_list_graph(g);
    return *this;
  }
 
  [[nodiscard]] Node* operator()(long i)
  {
    ah_domain_error_if(lgraph == nullptr)
      << "No graph associated with bit matrix";
    return matgraph_detail::get_node<GT>(nodes, i);
  }
 
  [[nodiscard]] long operator()(Node* node) const
  {
    ah_domain_error_if(lgraph == nullptr)
      << "No graph associated with bit matrix";
    return matgraph_detail::node_index<GT>(nodes, n, node);
  }
 
  Proxy operator()(long i, long j)
  {
    return Proxy(*this, i, j);
  }
 
  Proxy operator()(long i, long j) const
  {
    return Proxy(const_cast<Bit_Mat_Graph&>(*this), i, j);
  }
 
  Proxy operator()(Node* src_node, Node* tgt_node)
  {
    ah_domain_error_if(lgraph == nullptr)
      << "No graph associated with bit matrix";
    return Proxy(*this,
                 matgraph_detail::node_index<GT>(nodes, n, src_node),
                 matgraph_detail::node_index<GT>(nodes, n, tgt_node));
  }
 
  Proxy operator()(Node* src_node, Node* tgt_node) const
  {
    ah_domain_error_if(lgraph == nullptr)
      << "No graph associated with bit matrix";
    return Proxy(const_cast<Bit_Mat_Graph&>(*this),
                 matgraph_detail::node_index<GT>(nodes, n, src_node),
                 matgraph_detail::node_index<GT>(nodes, n, tgt_node));
  }
};
 
 
// =============================================================================
// Legacy Helper Functions (for backward compatibility)
// =============================================================================
 
 
template <typename GT>
[[nodiscard]] inline typename GT::Node*
get_node(DynArray<typename GT::Node*>& nodes, long i)
{
  return matgraph_detail::get_node<GT>(nodes, i);
}
 
template <typename GT>
[[nodiscard]] inline long
node_index(const DynArray<typename GT::Node*>& nodes, long n, typename GT::Node* p)
{
  return matgraph_detail::node_index<GT>(nodes, n, p);
}
 
[[nodiscard]] inline long
index_array(long i, long j, long n)
{
  return matgraph_detail::index_array(i, j, n);
}
 
template <typename Entry>
[[nodiscard]] inline Entry*
read_matrix(const DynArray<Entry>& mat, long i, long j, long n)
{
  return matgraph_detail::read_matrix(mat, i, j, n);
}
 
template <typename Entry>
inline void
write_matrix(DynArray<Entry>& mat, long i, long j, long n, const Entry& entry)
{
  matgraph_detail::write_matrix(mat, i, j, n, entry);
}
 
 
} // end namespace Aleph
 
#endif // TPL_MAT_GRAPH_H