share/Common.cxx

// Copyright (C) 2001-2012 Vivien Mallet
//
// This file is part of the linear-algebra library Seldon,
// http://seldon.sourceforge.net/.
//
// Seldon is free software; you can redistribute it and/or modify it under the
// terms of the GNU Lesser General Public License as published by the Free
// Software Foundation; either version 2.1 of the License, or (at your option)
// any later version.
//
// Seldon is distributed in the hope that it will be useful, but WITHOUT ANY
// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
// FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for
// more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with Seldon. If not, see http://www.gnu.org/licenses/.


#ifndef SELDON_FILE_COMMON_CXX

#include "Common.hxx"

template <class T>
void PrintArray(T* v, int lgth)
{
  for (int k = 0; k < lgth - 1; k++)
    std::cout << v[k] << " | ";
  std::cout << v[lgth - 1] << std::endl;
}

namespace Seldon
{


  Str::Str()
  {
  }



  Str::Str(const Str& s)
  {
    output_ << s;
  }


  Str::operator std::string() const
  {
    return output_.str();
  }



  template <class T>
  Str& Str::operator << (const T& input)
  {
    output_ << input;
    return *this;
  }



  template <class T>
  Str operator + (const Str& s, const T& input)
  {
    string s_input = s;
    Str output;
    output << s_input << input;
    return output;
  }


  ostream& operator << (ostream& out, Str& in)
  {
    string output = in;
    out << output;
    return out;
  }


  ostream& operator << (ostream& out, Str in)
  {
    string output = in;
    out << output;
    return out;
  }



  template<typename T>
  std::string to_str(const T& input)
  {
    std::ostringstream output;
    output << input;
    return output.str();
  }



  template <class T>
  void to_num(std::string s, T& num)
  {
    std::istringstream str(s);
    str >> num;
  }



  template <class T>
  T to_num(std::string s)
  {
    T num;
    std::istringstream str(s);
    str >> num;
    return num;
  }



  template <class T>
  inline void SetComplexZero(T& number)
  {
    number = T(0);
  }



  template <class T>
  inline void SetComplexZero(complex<T>& number)
  {
    number = complex<T>(T(0), T(0));
  }



  template <class T>
  inline void SetComplexOne(T& number)
  {
    number = T(1);
  }



  template <class T>
  inline void SetComplexOne(complex<T>& number)
  {
    number = complex<T>(T(1), T(0));
  }


#ifdef SELDON_WITH_HDF5


  template <class T>
  hid_t GetH5Type(T& input)
  {
    double d;
    float f;
    int i;
    long l;
    char c;
    unsigned char uc;
    long long ll;
    unsigned int ui;
    unsigned short us;
    unsigned long ul;
    unsigned long long ull;

    if (typeid(input) == typeid(d))
      return H5T_NATIVE_DOUBLE;
    if (typeid(input) == typeid(f))
      return H5T_NATIVE_FLOAT;
    if (typeid(input) == typeid(i))
      return H5T_NATIVE_INT;
    if (typeid(input) == typeid(l))
      return H5T_NATIVE_LONG;
    if (typeid(input) == typeid(c))
      return H5T_NATIVE_CHAR;
    if (typeid(input) == typeid(uc))
      return H5T_NATIVE_UCHAR;
    if (typeid(input) == typeid(ll))
      return H5T_NATIVE_LLONG;
    if (typeid(input) == typeid(ui))
      return H5T_NATIVE_UINT;
    if (typeid(input) == typeid(us))
      return H5T_NATIVE_USHORT;
    if (typeid(input) == typeid(ul))
      return H5T_NATIVE_ULONG;
    if (typeid(input) == typeid(ull))
      return H5T_NATIVE_ULLONG;
    else
      throw Error("hid_t GetH5Type(T& input)",
                  "Type has no corresponding native HDF5 datatype.");
  }
#endif


}  // namespace Seldon.

#define SELDON_FILE_COMMON_CXX
#endif