Branch data     Line data    Source code

       1                 :            : // *****************************************************************************
       2                 :            : /*!
       3                 :            :   \file      src/Main/RNGPrint.cpp
       4                 :            :   \copyright 2012-2015 J. Bakosi,
       5                 :            :              2016-2018 Los Alamos National Security, LLC.,
       6                 :            :              2019-2021 Triad National Security, LLC.
       7                 :            :              All rights reserved. See the LICENSE file for details.
       8                 :            :   \brief     Pretty printer base for pretty printers supporting RNGs
       9                 :            :   \details   Pretty printer base for pretty printers supporting RNGs.
      10                 :            : */
      11                 :            : // *****************************************************************************
      12                 :            : 
      13                 :            : #include <map>
      14                 :            : #include <utility>
      15                 :            : 
      16                 :            : #include "NoWarning/format.hpp"
      17                 :            : 
      18                 :            : #include "QuinoaConfig.hpp"
      19                 :            : #include "Tags.hpp"
      20                 :            : #include "Print.hpp"
      21                 :            : #include "RNGParam.hpp"
      22                 :            : #include "RNGPrint.hpp"
      23                 :            : #include "Options/RNG.hpp"
      24                 :            : #include "Options/RNGSSESeqLen.hpp"
      25                 :            : 
      26                 :            : #ifdef HAS_MKL
      27                 :            :   #include "Options/MKLGaussianMethod.hpp"
      28                 :            :   #include "Options/MKLGaussianMVMethod.hpp"
      29                 :            :   #include "Options/MKLUniformMethod.hpp"
      30                 :            : #endif
      31                 :            : 
      32                 :            : using tk::RNGPrint;
      33                 :            : 
      34                 :            : #ifdef HAS_MKL
      35                 :            : void
      36                 :            : RNGPrint::echoMKLParams( const ctr::RNGMKLParam& p ) const
      37                 :            : // *****************************************************************************
      38                 :            : //  Echo information on MKL random number generator
      39                 :            : //! \param[in] p MKL RNG parameters
      40                 :            : // *****************************************************************************
      41                 :            : {
      42                 :            :   ctr::MKLUniformMethod um;
      43                 :            :   ctr::MKLGaussianMethod gm;
      44                 :            :   ctr::MKLGaussianMVMethod gmvm;
      45                 :            : 
      46                 :            :   m_stream << m_item_name_value_fmt
      47                 :            :               % m_item_indent
      48                 :            :               % "seed"
      49                 :            :               % p.get< tag::seed >();
      50                 :            : 
      51                 :            :   m_stream << m_item_name_value_fmt
      52                 :            :               % m_item_indent
      53                 :            :               % um.group()
      54                 :            :               % um.name( p.get< tag::uniform_method >() );
      55                 :            : 
      56                 :            :   m_stream << m_item_name_value_fmt
      57                 :            :               % m_item_indent
      58                 :            :               % gm.group()
      59                 :            :               % gm.name( p.get< tag::gaussian_method >() );
      60                 :            : 
      61                 :            :   m_stream << m_item_name_value_fmt
      62                 :            :               % m_item_indent
      63                 :            :               % gmvm.group()
      64                 :            :               % gmvm.name( p.get< tag::gaussianmv_method >() );
      65                 :            : }
      66                 :            : #endif
      67                 :            : 
      68                 :            : void
      69                 :          4 : RNGPrint::echoRNGSSEParams( const ctr::RNGSSEParam& p,
      70                 :            :                             const ctr::RNG& rng,
      71                 :            :                             const ctr::RNGType& r ) const
      72                 :            : // *****************************************************************************
      73                 :            : //  Echo information on RNGSSE random number generator
      74                 :            : //! \param[in] p RNGSSE RNG parameters
      75                 :            : //! \param[in] rng RNG options object
      76                 :            : //! \param[in] r RNG type enum
      77                 :            : // *****************************************************************************
      78                 :            : {
      79                 :          4 :   m_stream << m_item_name_value_fmt
      80                 :          4 :               % m_item_indent
      81                 :            :               % "seed"
      82                 :          4 :               % p.get< tag::seed >();
      83                 :            : 
      84         [ +  + ]:          8 :   if ( rng.supportsSeq(r) ) {
      85                 :          3 :     ctr::RNGSSESeqLen seq;
      86                 :          3 :     m_stream << m_item_name_value_fmt
      87                 :            :                 % m_item_indent
      88                 :            :                 % seq.group()
      89         [ +  - ]:          6 :                 % seq.name( p.get< tag::seqlen >() );
      90                 :            :   }
      91                 :          4 : }
      92                 :            : 
      93                 :            : void
      94                 :          4 : RNGPrint::echoRandom123Params( const ctr::RNGRandom123Param& p ) const
      95                 :            : // *****************************************************************************
      96                 :            : //  Echo information on Random123 random number generator
      97                 :            : //! \param[in] p Random123 RNG parameters
      98                 :            : // *****************************************************************************
      99                 :            : {
     100                 :          4 :   m_stream << m_item_name_value_fmt
     101                 :          4 :               % m_item_indent
     102                 :            :               % "seed"
     103                 :          4 :               % p.get< tag::seed >();
     104                 :          4 : }
     105                 :            : 
     106                 :            : #ifdef HAS_MKL
     107                 :            : void
     108                 :            : RNGPrint::MKLParams( const std::vector< ctr::RNGType >& vec,
     109                 :            :                      const ctr::RNGMKLParameters& map ) const
     110                 :            : // *****************************************************************************
     111                 :            : //  Print all fields of MKL RNG parameters
     112                 :            : //! \param[in] vec Vector of RNG type enums to print
     113                 :            : //! \param[in] map MKL RNG parameters map
     114                 :            : // *****************************************************************************
     115                 :            : {
     116                 :            :   ctr::RNG rng;
     117                 :            : 
     118                 :            :   for (auto& r : vec) {
     119                 :            :     if (rng.lib(r) == ctr::RNGLibType::MKL) {
     120                 :            :       subsection( rng.name(r) );
     121                 :            :       const auto& m = map.find(r);
     122                 :            :       if (m == map.end()) {   // no parameter map entry, print defaults
     123                 :            :         echoMKLParams( ctr::RNGMKLParam() );
     124                 :            :       } else {
     125                 :            :         echoMKLParams( m->second );
     126                 :            :       }
     127                 :            :     }
     128                 :            :   }
     129                 :            : }
     130                 :            : #endif
     131                 :            : 
     132                 :            : void
     133                 :          4 : RNGPrint::RNGSSEParams( const std::vector< ctr::RNGType >& vec,
     134                 :            :                         const ctr::RNGSSEParameters& map ) const
     135                 :            : // *****************************************************************************
     136                 :            : //  Print all fields of RNGSSE RNG parameters
     137                 :            : //! \param[in] vec Vector of RNG type enums to print
     138                 :            : //! \param[in] map RNGSSE RNG parameters map
     139                 :            : // *****************************************************************************
     140                 :            : {
     141                 :          8 :   ctr::RNG rng;
     142                 :            : 
     143         [ +  + ]:         12 :   for (auto& r : vec) {
     144 [ +  - ][ +  + ]:          8 :     if (rng.lib(r) == ctr::RNGLibType::RNGSSE) {
     145         [ +  - ]:          8 :       subsection( rng.name(r) );
     146                 :            :       const auto& m = map.find(r);
     147         [ +  - ]:          4 :       if (m == map.end()) {   // no parameter map entry, print defaults
     148         [ +  - ]:          4 :         echoRNGSSEParams( ctr::RNGSSEParam(), rng, r );
     149                 :            :       } else {
     150         [ -  - ]:          0 :         echoRNGSSEParams( m->second, rng, r );
     151                 :            :       }
     152                 :            :     }
     153                 :            :   }
     154                 :          4 : }
     155                 :            : 
     156                 :            : void
     157                 :          4 : RNGPrint::Random123Params( const std::vector< ctr::RNGType >& vec,
     158                 :            :                            const ctr::RNGRandom123Parameters& map ) const
     159                 :            : // *****************************************************************************
     160                 :            : //  Print all fields of Random123 RNG parameters
     161                 :            : //! \param[in] vec Vector of RNG type enums to print
     162                 :            : //! \param[in] map Random123 RNG parameters map
     163                 :            : // *****************************************************************************
     164                 :            : {
     165                 :          8 :   ctr::RNG rng;
     166                 :            : 
     167         [ +  + ]:         12 :   for (auto& r : vec) {
     168 [ +  - ][ +  + ]:          8 :     if (rng.lib(r) == ctr::RNGLibType::R123) {
     169         [ +  - ]:          8 :       subsection( rng.name(r) );
     170                 :            :       const auto& m = map.find(r);
     171         [ +  - ]:          4 :       if (m == map.end()) {   // no parameter map entry, print defaults
     172         [ +  - ]:          4 :         echoRandom123Params( ctr::RNGRandom123Param() );
     173                 :            :       } else {
     174         [ -  - ]:          0 :         echoRandom123Params( m->second );
     175                 :            :       }
     176                 :            :     }
     177                 :            :   }
     178                 :          4 : }