tau_t.hpp

// Copyright (c) 2022--present, The Simons Foundation
// Copyright (c) 2022--present, Max Planck Institute for Polymer Research, Mainz, Germany
// This file is part of TRIQS/ctseg and is licensed under the terms of GPLv3 or later.
// SPDX-License-Identifier: GPL-3.0-or-later
// See LICENSE in the root of this distribution for details.
 
#pragma once
#include <h5/h5.hpp>
#include <limits>
#include <iostream>
#include <cmath>
#include <assert.h>
 
#include <fmt/ostream.h>
 
namespace triqs_ctseg {

 
  class tau_t {

    inline static double _beta;

    uint64_t n = 0;
 
    public:
    static constexpr uint64_t n_max = std::numeric_limits<uint64_t>::max();

    static void set_beta(double beta) { _beta = beta; }

    tau_t() = default;

    tau_t(uint64_t n_) : n(n_) {}
    tau_t(double x) {
      if ((x > _beta || x < 0)) {
        throw std::invalid_argument("Time tau must be in the range [0, beta]");
      } else if (x == _beta)
        n = n_max;
      else
        n = uint64_t((x / _beta) * double(n_max));
    }

    auto operator<=>(tau_t const &tau) const { return n <=> tau.n; }
    bool operator==(tau_t const &tau) const { return n == tau.n; }

    explicit operator double() const { return _beta * (double(n) / double(n_max)); }

    static tau_t beta() { return {uint64_t{n_max}}; }

    static tau_t zero() { return {uint64_t{0}}; }

    static tau_t epsilon() { return {uint64_t{1}}; }
 
    // Get a random point in $]tau1, tau2[$
    static tau_t random(auto &rng, tau_t const &tau1, tau_t const &tau2) {
      auto n1 = tau1.n + 1;
      return {rng(tau2.n - n1) + n1};
    }

    static tau_t random(auto &rng, tau_t const &tau) { return {rng(tau.n - 1) + 1}; }
 
    // ----- Some basic op, with cyclicity --------
 
    friend tau_t operator+(tau_t const &a, tau_t const &b) { return {a.n + b.n}; }
 
    friend tau_t operator-(tau_t const &a, tau_t const &b) { return {a.n - b.n}; }
 
    friend tau_t operator-(tau_t const &a) { return {tau_t::n_max - a.n}; }
 
    // ----- IO --------

    friend std::ostream &operator<<(std::ostream &out, tau_t const &p) {
      return out << double(p) << " [tau_t : n = " << p.n << "]";
    }
  };
 
  // ----- arithmetic operations --------

  inline double operator*(tau_t const &a, tau_t const &b) { return double(a) * double(b); }
  inline double operator/(tau_t const &a, tau_t const &b) { return double(a) / double(b); }
 
  inline double operator+(tau_t const &x, double y) { return double(x) + y; }
  inline double operator+(double y, tau_t const &x) { return y + double(x); }
 
  inline double operator-(tau_t const &x, double y) { return double(x) - y; }
  inline double operator-(double y, tau_t const &x) { return y - double(x); }
 
  inline double operator*(tau_t const &x, double y) { return double(x) * y; }
  inline double operator*(double y, tau_t const &x) { return y * double(x); }
 
  inline double operator/(tau_t const &x, double y) { return double(x) / y; }
  inline double operator/(double y, tau_t const &x) { return y / double(x); }
 
} // namespace triqs_ctseg
 
template <> struct fmt::formatter<triqs_ctseg::tau_t> : ostream_formatter {};