Line data    Source code

       1           1 : // Distributed under the MIT License.
       2             : // See LICENSE.txt for details.
       3             : 
       4             : /// \file
       5             : /// `blaze::StaticMatrix` is a general-purpose fixed size matrix type. This file
       6             : /// implements interoperability of `blaze::StaticMatrix` with our data
       7             : /// structures.
       8             : 
       9             : #pragma once
      10             : 
      11             : #include <array>
      12             : #include <blaze/math/StaticMatrix.h>
      13             : #include <cstddef>
      14             : #include <pup.h>
      15             : #include <type_traits>
      16             : 
      17             : #include "Options/ParseOptions.hpp"
      18             : 
      19             : namespace PUP {
      20             : /// @{
      21             : /// Serialization of blaze::StaticMatrix
      22             : template <typename Type, size_t M, size_t N, bool SO, blaze::AlignmentFlag AF,
      23             :           blaze::PaddingFlag PF, typename Tag>
      24             : void pup(er& p, blaze::StaticMatrix<Type, M, N, SO, AF, PF, Tag>& t) {
      25             :   const size_t spacing = t.spacing();
      26             :   const size_t data_size = spacing * (SO == blaze::rowMajor ? M : N);
      27             :   if (std::is_fundamental_v<Type>) {
      28             :     PUParray(p, t.data(), data_size);
      29             :   } else {
      30             :     for (size_t i = 0; i < data_size; ++i) {
      31             :       p | t.data()[i];
      32             :     }
      33             :   }
      34             : }
      35             : template <typename Type, size_t M, size_t N, bool SO, blaze::AlignmentFlag AF,
      36             :           blaze::PaddingFlag PF, typename Tag>
      37             : void operator|(er& p, blaze::StaticMatrix<Type, M, N, SO, AF, PF, Tag>& t) {
      38             :   pup(p, t);
      39             : }
      40             : /// @}
      41             : }  // namespace PUP
      42             : 
      43             : template <typename Type, size_t M, size_t N, bool SO, blaze::AlignmentFlag AF,
      44             :           blaze::PaddingFlag PF, typename Tag>
      45           0 : struct Options::create_from_yaml<
      46             :     blaze::StaticMatrix<Type, M, N, SO, AF, PF, Tag>> {
      47             :   template <typename Metavariables>
      48           0 :   static blaze::StaticMatrix<Type, M, N, SO, AF, PF, Tag> create(
      49             :       const Options::Option& options) {
      50             :     return {options.parse_as<std::array<std::array<Type, N>, M>>()};
      51             :   }
      52             : };