k_expr.hpp

Go to the documentation of this file.

// Copyright (c) 2023 Simons Foundation
// Copyright (c) 2023 Hugo U.R. Strand
//
// This program 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.
//
// This program 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 may obtain a copy of the License at
//     https://www.gnu.org/licenses/gpl-3.0.txt
//
// Authors: Olivier Parcollet, Hugo U. R. Strand, Nils Wentzell

 
#pragma once
 
#include <nda/nda.hpp>
 
#include <cstdint>
#include <utility>
 
namespace triqs::mesh {


  template <char OP, typename L>
    requires(OP == '-')
  struct k_expr_unary {
    // Operand to be negated.
    L l;

    [[nodiscard]] uint64_t mesh_hash() const { return l.mesh_hash(); };

    [[nodiscard]] auto value() const { return -l.value(); }

    [[nodiscard]] auto index() const { return -l.index(); }
  };

  template <char OP, typename L, typename R> struct k_expr {
    // Left hand side operand.
    L l;
 
    // Right hand side operand.
    R r;

    template <typename L1, typename R1> k_expr(L1 &&l1, R1 &&r1) : l{std::forward<L1>(l1)}, r{std::forward<R1>(r1)} {}

    [[nodiscard]] auto value() const {
      if constexpr (OP == '+') {
        return nda::make_regular(l.value() + r.value());
      } else if constexpr (OP == '-') {
        return nda::make_regular(l.value() - r.value());
      } else {
        return nda::make_regular(l * r.value());
      }
    }

    [[nodiscard]] auto index() const {
      // check that the mesh hashes are the same
      if constexpr (requires { l.mesh_hash(); }) { EXPECTS(l.mesh_hash() == r.mesh_hash()) };
      if constexpr (OP == '+') {
        return l.index() + r.index();
      } else if constexpr (OP == '-') {
        return l.index() - r.index();
      } else {
        return l * r.index();
      }
    }

    [[nodiscard]] uint64_t mesh_hash() const { return r.mesh_hash(); };
  };

  template <typename T> constexpr bool is_k_expr = false;
 
  // Specialization of triqs::mesh::is_k_expr for triqs::mesh::k_expr.
  template <char OP, typename L, typename R> constexpr bool is_k_expr<k_expr<OP, L, R>> = true;
 
  // Specialization of triqs::mesh::is_k_expr for triqs::mesh::k_expr_unary.
  template <char OP, typename L> constexpr bool is_k_expr<k_expr_unary<OP, L>> = true;

 
} // namespace triqs::mesh