entity.h

/*
 *  Copyright (C) 2004-2021 Edward F. Valeev
 *
 *  This file is part of Libint.
 *
 *  Libint is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  Libint 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 General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with Libint.  If not, see <http://www.gnu.org/licenses/>.
 *
 */
 
#ifndef _libint2_src_bin_libint_entity_h_
#define _libint2_src_bin_libint_entity_h_
 
#include <iomanip>
#include <limits>
#include <string>
#include <sstream>
#include <dgvertex.h>
#include <class_registry.h>
 
namespace libint2 {
 
  namespace EntityTypes {
    typedef enum {fp, integer} EntityTypeEnum;
 
    template <unsigned int TypeIndex>
    struct EntityType {
      static unsigned int type2int() {
        return TypeIndex;
      }
    };
 
    typedef EntityType<fp> FP;
    typedef EntityType<integer> Int;
 
    static const unsigned int ntypes = 2;
  };
 
  template <typename T, typename U>
    struct ProductType;
  template <> struct ProductType<int,int>         { typedef int result; };
  template <> struct ProductType<int,double>      { typedef double result; };
  template <> struct ProductType<double,int>      { typedef double result; };
  template <> struct ProductType<double,double>   { typedef double result; };
  template <> struct ProductType<EntityTypes::Int,int>     { typedef EntityTypes::Int result; };
  template <> struct ProductType<EntityTypes::Int,double>  { typedef EntityTypes::FP result; };
  template <> struct ProductType<EntityTypes::FP,int>      { typedef EntityTypes::FP result; };
  template <> struct ProductType<EntityTypes::FP,double>   { typedef EntityTypes::FP result; };
  template <> struct ProductType<int,EntityTypes::Int>     { typedef EntityTypes::Int result; };
  template <> struct ProductType<double,EntityTypes::Int>  { typedef EntityTypes::FP result; };
  template <> struct ProductType<int,EntityTypes::FP>      { typedef EntityTypes::FP result; };
  template <> struct ProductType<double,EntityTypes::FP>   { typedef EntityTypes::FP result; };
  template <> struct ProductType<EntityTypes::Int,EntityTypes::Int>     { typedef EntityTypes::Int result; };
  template <> struct ProductType<EntityTypes::Int,EntityTypes::FP>      { typedef EntityTypes::FP result; };
  template <> struct ProductType<EntityTypes::FP,EntityTypes::Int>      { typedef EntityTypes::FP result; };
  template <> struct ProductType<EntityTypes::FP,EntityTypes::FP>       { typedef EntityTypes::FP result; };
 
  template <typename T>
    std::string to_string(const T& x) {
    std::ostringstream oss;  oss << std::scientific << std::setprecision(std::numeric_limits<T>::digits10 + 1) << x;  return oss.str();
  }
 
  class Entity
  {
    public:
    virtual ~Entity() {}
    const std::string& id() const { return id_; }
 
    protected:
    Entity(const std::string& id) : id_(id) {}
 
    private:
    std::string id_;
 
  };
 
  template <class T>
  class RTimeEntity :
  public Entity,
  public DGVertex
  {
    public:
    typedef typename DGVertex::KeyType key_type;
 
    RTimeEntity(const std::string& id, bool p = true) :
      Entity(id), DGVertex(ClassInfo<RTimeEntity>::Instance().id()), precomputed_(p)
    {
      FNVStringHash SH;
      key_ = KeyTypes::cast(SH.hash(id));
#if DEBUG
std::cout << "Allocated RTimeEntity id = " << this->id() << std::endl;
#endif
    }
 
    virtual ~RTimeEntity()
    {
#if DEBUG
      std::cout << "Deallocated RTimeEntity id = " << this->id() << std::endl;
#endif
    }
 
    unsigned int size() const override { return 1; }
 
    bool equiv(const SafePtr<DGVertex>& a) const override
    {
      if (a->typeid_ == typeid_) {
#if USE_INT_KEY_TO_COMPARE
        return key() == a->key() && label() == a->label();
#else
        SafePtr<RTimeEntity> a_cast = static_pointer_cast<RTimeEntity,DGVertex>(a);
        return id() == a_cast->id();
#endif
      }
      else
        return false;
    }
 
    const std::string& label() const override
    {
      return Entity::id();
    }
    const std::string& id() const override
    {
      return label();
    }
    std::string description() const override
    {
      std::ostringstream os;
      os << "RTimeEntity: " << id();
      const std::string descr = os.str();
      return descr;
    }
    typename DGVertex::KeyReturnType key() const override {
      return key_;
    }
 
    private:
    bool this_precomputed() const override
    {
      return precomputed_;
    }
 
    key_type key_;
    bool precomputed_;
  };
 
  template <class T>
    class CTimeEntity :
    public Entity,
    public DGVertex
    {
      public:
      CTimeEntity(const T& val) :
        Entity(to_string(val)), DGVertex(ClassInfo<CTimeEntity>::Instance().id()), value_(val)
        {
#if DEBUG
          std::cout << "Allocated CTimeEntity id = " << this->id() << " value = " << value() << std::endl;
#endif
        }
 
      virtual ~CTimeEntity()
        {
#if DEBUG
          std::cout << "Deallocated CTimeEntity id = " << this->id() << " value = " << value() << std::endl;
#endif
        }
 
      unsigned int size() const override { return 1; }
 
      bool equiv(const SafePtr<DGVertex>& a) const override
      {
        if (a->typeid_ == typeid_) {
#if USE_INT_KEY_TO_COMPARE
          return key() == a->key();
#else
          SafePtr<CTimeEntity> a_cast = static_pointer_cast<CTimeEntity,DGVertex>(a);
          return id() == a_cast->id();
#endif
        }
        else
          return false;
      }
 
      const std::string& label() const override
      {
        return Entity::id();
      }
      const std::string& id() const override
      {
        return label();
      }
      std::string description() const override
      {
        std::ostringstream os;
        os << "CTimeEntity: " << id();
        const std::string descr = os.str();
        return descr;
      }
 
      typename KeyTraits<T>::ReturnType value() const { return value_; }
 
      typename DGVertex::KeyReturnType key() const override {
        if (std::is_floating_point<T>::value) {
          if (not std::is_same<T,double>::value)
            throw std::runtime_error("CTimeEntity<Real> only supported when Real==double");
          return static_cast<typename DGVertex::KeyReturnType>(*reinterpret_cast<const unsigned long*>(&value_));
        }
        else
          return static_cast<typename DGVertex::KeyReturnType>(value());
      }
 
    private:
      T value_;
 
      bool this_precomputed() const override
      {
        return true;
      }
 
    };
 
 
//  template <typename T>
//    SafePtr<Entity>
//    operator*(const SafePtr<Entity>& A, const SafePtr< CTimeEntity<T> >& B);
 
  template <typename T, typename U>
    SafePtr< CTimeEntity< typename ProductType<T,U>::result > >
    operator*(const SafePtr< CTimeEntity<T> >& A, const SafePtr< CTimeEntity<U> >& B)
    {
      typedef CTimeEntity< typename ProductType<T,U>::result > prodtype;
      return SafePtr<prodtype>(new prodtype(A->value()*B->value()));
    }
 
  template <typename T, typename U>
    SafePtr< RTimeEntity< typename ProductType<T,U>::result > >
    operator*(const SafePtr< RTimeEntity<T> >& A, const SafePtr< CTimeEntity<U> >& B)
    {
      typedef RTimeEntity< typename ProductType<T,U>::result > prodtype;
      std::ostringstream oss;
      oss << A->id() << "*" << B->id();
      // TODO this should be false, but the logic of DirectedGraph construction depends on this being true
      const bool not_precomputed = true;
      return SafePtr<prodtype>(new prodtype(oss.str(), not_precomputed));
    }
  // TODO should be possible to enable this, but this creates RTimeEntities that should not be precomputed, see the comment above
#if 0
  template <typename T, typename U>
    SafePtr< RTimeEntity< typename ProductType<T,U>::result > >
    operator*(const SafePtr< CTimeEntity<U> >& B, const SafePtr< RTimeEntity<T> >& A)
    {
      return A * B;
    }
#endif
 
};
 
#endif