converter.h

Go to the documentation of this file.

//-----------------------------------------------------------------------bl-
//--------------------------------------------------------------------------
//
// Antioch - A Gas Dynamics Thermochemistry Library
//
// Copyright (C) 2014-2016 Paul T. Bauman, Benjamin S. Kirk,
//                         Sylvain Plessis, Roy H. Stonger
//
// Copyright (C) 2013 The PECOS Development Team
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the Version 2.1 GNU Lesser General
// Public License as published by the Free Software Foundation.
//
// This library 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 this library; if not, write to the Free Software
// Foundation, Inc. 51 Franklin Street, Fifth Floor,
// Boston, MA  02110-1301  USA
//
//-----------------------------------------------------------------------el-
#ifndef ANTIOCH_CONVERTER_H
#define ANTIOCH_CONVERTER_H

//Antioch
#include "antioch/metaprogramming.h"

//C++
#include <iostream>

namespace Antioch{

template <typename T = double>
class Converter{
      public:
        Converter();
        Converter(const T &coef, const T &trans);
        template <typename P>
        Converter(const Converter<P> &rhs){*this = rhs;}
        ~Converter(){}

        template <typename P = T>
        const P geta() const {return (P)a;} //only scalar type
        template <typename P = T>
        const P getb() const {return (P)b;} //only scalar type
        void clear()        {a = 1.L; Antioch::set_zero(b);}

        friend std::ostream &operator<< (std::ostream &out, const Converter<T> & rhs)
        {
          out << "(" << rhs.geta() << "," << rhs.getb() << ")";
          return out;
        }

        template <typename P>
        bool operator== (const Converter<P> &rhs) const;
        template <typename P>
        bool operator!=(const Converter<P> &rhs) const {return !(*this == rhs);}
        template <typename P>
        Converter & operator=  (const Converter<P> &rhs);
        template <typename P>
        Converter & operator*= (const Converter<P> &rhs);
        template <typename P>
        Converter & operator/= (const Converter<P> &rhs);
        template <typename P>
        Converter & operator+= (const Converter<P> &rhs);
        template <typename P>
        Converter operator/    (const Converter<P> &rhs) const;
        template <typename P>
        Converter operator*    (const Converter<P> &rhs) const;
        template <typename P>
        Converter & operator*= (const P &coef);
        template <typename P>
        Converter & operator/= (const P &coef);
        template <typename P>
        Converter operator*    (const P &coef)   const;
        template <typename P>
        Converter operator/    (const P &coef)   const;

      private:
        T a;
        T b;

};

template<typename T>
inline
Converter<T>::Converter()
{
  clear();
  return;
}

template<typename T>
inline
Converter<T>::Converter(const T &coef, const T &tran)
{
  a = Antioch::constant_clone(a,coef);
  b = Antioch::constant_clone(b,tran);
  return;
}


template<typename T>
template<typename P>
inline
Converter<T> & Converter<T>::operator= (const Converter<P> &rhs)
{
 // if(this == static_cast<Converter<T>*>(&rhs)){return *this;}
  a = Antioch::constant_clone(a,rhs.geta());
  b = Antioch::constant_clone(b,rhs.getb());
  return *this;
}

template<typename T>
template<typename P>
inline
Converter<T> & Converter<T>::operator*= (const P &coef)
{
  a *= coef;
  return *this;
}

template<typename T>
template<typename P>
inline
Converter<T> & Converter<T>::operator/= (const P &coef)
{
  a /= coef;
  return *this;
}

template<typename T>
template<typename P>
inline
Converter<T> & Converter<T>::operator*= (const Converter<P> &rhs)
{
  a *= rhs.geta();
  b  = (b + rhs.getb())/rhs.geta();
  return *this;
}

template<typename T>
template<typename P>
inline
Converter<T> & Converter<T>::operator/= (const Converter<P> &rhs)
{
  a /= rhs.geta();
  b  = (b - rhs.getb())/rhs.geta();
  return *this;
}

template<typename T>
template<typename P>
inline
Converter<T> & Converter<T>::operator+= (const Converter<P> &rhs)
{
  a *= rhs.geta();
  b += rhs.getb();
  return *this;
}

template<typename T>
template<typename P>
inline
Converter<T> Converter<T>::operator*  (const P &coef) const
{
  return Converter<T>(a*coef,b);
}

template<typename T>
template<typename P>
inline
Converter<T> Converter<T>::operator/  (const P &coef) const
{
  return Converter<T>(a/coef,b);
}

template<typename T>
template<typename P>
inline
Converter<T> Converter<T>::operator/  (const Converter<P> &rhs) const
{
  return Converter(a/rhs.geta(),(b-rhs.getb())/rhs.geta());
}

template<typename T>
template<typename P>
inline
Converter<T> Converter<T>::operator*  (const Converter<P> &rhs) const
{
  return Converter<T>(a * rhs.geta() , (b + rhs.getb())/rhs.geta());
}
}// end namespace

#endif