Home Browse Files 
       1
       2
       3
       4
       5
       6
       7
       8
       9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      24
      25
      26
      27
      28
      29
      30
      31
      32
      33
      34
      35
      36
      37
      38
      39
      40
      41
      42
      43
      44
      45
      46
      47
      48
      49
      50
      51
      52
      53
      54
      55
      56
      57
      58
      59
      60
      61
      62
      63
      64
      65
      66
      67
      68
      69
      70
      71
      72
      73
      74
      75
      76
      77
      78
      79
      80
      81
      82
      83
      84
      85
      86
      87
      88
      89
      90
      91
      92
      93
      94
      95
      96
      97
      98
      99
     100
     101
     102
     103
     104
     105
     106
     107
     108
     109
     110
     111
     112
     113
     114
     115
     116
     117

#ifndef HPC_MATVEC_PRINT_H
#define HPC_MATVEC_PRINT_H 1

#include <complex>
#include <type_traits>
#include <hpc/matvec/isgematrix.h>
#include <hpc/matvec/isdensevector.h>

namespace hpc { namespace matvec {

template <typename T>
struct Format
{
};

template <>
struct Format<long>
{
    static const char *
    value()
    {
        return " %10ld";
    }
};

template <>
struct Format<unsigned long>
{
    static const char *
    value()
    {
        return " %10lu";
    }
};

template <>
struct Format<float>
{
    static const char *
    value()
    {
        return " %10.3f";
    }
};

template <>
struct Format<double>
{
    static const char *
    value()
    {
        return " %10.3lf";
    }
};

template <>
struct Format<std::complex<double> >
{
    static const char *
    value()
    {
        return " (%10.3lf, %10.3lf)";
    }
};

//------------------------------------------------------------------------------

template <typename T>
void
print_value(T value) {
   std::printf(Format<T>::value(), value);
}

template <typename T>
void
print_value(const std::complex<T> &value) {
   std::printf(Format<std::complex<T> >::value(), value.real(), value.imag());
}

template <typename MA>
typename std::enable_if<IsGeMatrix<MA>::value,
         void>::type
print(const MA &A, const char *name = "")
{
    typedef typename MA::Index    Index;

    if (*name) {
        printf("%s = \n", name);
    }
    for (Index i=0; i<A.numRows; ++i) {
        for (Index j=0; j<A.numCols; ++j) {
            print_value(A(i,j));
        }
        printf("\n");
    }
    printf("\n");
}

template <typename VX>
typename std::enable_if<IsDenseVector<VX>::value,
         void>::type
print(const VX &x, const char *name = "")
{
    typedef typename VX::Index    Index;

    if (*name) {
        printf("%s = \n", name);
    }
    for (Index i=0; i<x.length; ++i) {
        print_value(x(i));
    }
    printf("\n");
}

} } // namespace matvec, hpc

#endif // HPC_MATVEC_PRINT_H





































































































Home