Line data    Source code

       1           1 : // Distributed under the MIT License.
       2             : // See LICENSE.txt for details.
       3             : 
       4             : /// \file
       5             : /// `blaze::CompressedVector` is a general-purpose sparse vector type. This file
       6             : /// implements interoperability of `blaze::CompressedVector` with our data
       7             : /// structures.
       8             : 
       9             : #pragma once
      10             : 
      11             : #include <blaze/math/CompressedVector.h>
      12             : #include <cstddef>
      13             : #include <pup.h>
      14             : #include <vector>
      15             : 
      16             : #include "Utilities/Gsl.hpp"
      17             : 
      18             : /// \cond
      19             : namespace Options {
      20             : struct Option;
      21             : template <typename T>
      22             : struct create_from_yaml;
      23             : }  // namespace Options
      24             : /// \endcond
      25             : 
      26             : namespace PUP {
      27             : /// @{
      28             : /// Serialization of blaze::CompressedVector
      29             : template <typename T, bool TF, typename Tag>
      30             : void pup(er& p, blaze::CompressedVector<T, TF, Tag>& t) {
      31             :   size_t size = t.size();
      32             :   p | size;
      33             :   size_t num_non_zeros = t.nonZeros();
      34             :   p | num_non_zeros;
      35             :   // blaze::CompressedVector has no `.data()` access, so we use the low-level
      36             :   // `append` mechanism for serialization instead of `PUParray`. Maybe there's
      37             :   // an even faster way using PUPbytes.
      38             :   size_t index;
      39             :   if (p.isUnpacking()) {
      40             :     t.resize(size);
      41             :     t.reserve(num_non_zeros);
      42             :     T value;
      43             :     for (size_t i = 0; i < num_non_zeros; ++i) {
      44             :       p | index;
      45             :       p | value;
      46             :       t.append(index, value);
      47             :     }
      48             :   } else {
      49             :     for (auto it = t.begin(); it != t.end(); ++it) {
      50             :       index = it->index();
      51             :       p | index;
      52             :       p | it->value();
      53             :     }
      54             :   }
      55             : }
      56             : template <typename T, bool TF, typename Tag>
      57             : void operator|(er& p, blaze::CompressedVector<T, TF, Tag>& t) {
      58             :   pup(p, t);
      59             : }
      60             : /// @}
      61             : }  // namespace PUP
      62             : 
      63             : namespace CompressedVector_detail {
      64             : template <typename T>
      65             : std::vector<T> parse_to_vector(const Options::Option& options);
      66             : }  // namespace CompressedVector_detail
      67             : 
      68             : template <typename T, bool TF, typename Tag>
      69           0 : struct Options::create_from_yaml<blaze::CompressedVector<T, TF, Tag>> {
      70             :   template <typename Metavariables>
      71           0 :   static blaze::CompressedVector<T, TF, Tag> create(
      72             :       const Options::Option& options) {
      73             :     const auto data = CompressedVector_detail::parse_to_vector<T>(options);
      74             :     blaze::CompressedVector<T, TF, Tag> result(data.size());
      75             :     // Insert only non-zero elements. Can't use iterators and `std::copy`
      76             :     // because for sparse types the iterators only run over non-zero elements.
      77             :     // There's probably a faster way to do this construction using the low-level
      78             :     // `append` function, but it's probably not worth the effort for small
      79             :     // matrices created in input files.
      80             :     for (size_t i = 0; i < data.size(); ++i) {
      81             :       if (gsl::at(data, i) != 0.) {
      82             :         result[i] = gsl::at(data, i);
      83             :       }
      84             :     }
      85             :     return result;
      86             :   }
      87             : };