sum.hpp

Go to the documentation of this file.

// Copyright (c) 2019-2024 Simons Foundation
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0.txt
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// Authors: Thomas Hahn, Olivier Parcollet, Nils Wentzell
 
#pragma once
 
#include "./clef.hpp"
#include "../basic_functions.hpp"
#include "../exceptions.hpp"
 
namespace nda::clef {
 
  namespace detail {
 
    // Helper function to sum a callable object over a domain using a simple for loop.
    template <typename F, typename D>
    auto sum_f_domain_impl(F const &f, D const &d)
      requires(not is_clef_expression<F, D>)
    {
      auto it  = d.begin();
      auto ite = d.end();
      if (it == ite) NDA_RUNTIME_ERROR << "Error in nda::clef::sum_f_domain_impl: Sum over an empty domain";
      auto res = make_regular(f(*it));
      ++it;
      for (; it != ite; ++it) res = res + f(*it);
      return res;
    }
 
    // Make sum_f_domain_impl lazy.
    CLEF_MAKE_FNT_LAZY(sum_f_domain_impl);
 
  } // namespace detail
 
  template <typename Expr, int N, typename D>
  decltype(auto) sum(Expr const &ex, clef::pair<N, D> d) {
    if constexpr (std::is_lvalue_reference_v<D>) {
      return detail::sum_f_domain_impl(make_function(ex, clef::placeholder<N>()), d.rhs);
    } else {
      return detail::sum_f_domain_impl(make_function(ex, clef::placeholder<N>()), std::move(d.rhs));
    }
  }
 
  template <typename Expr, typename D0, typename D1, typename... Ds>
  auto sum(Expr const &ex, D0 &&d0, D1 &&d1, Ds &&...ds) {
    return sum(sum(ex, std::forward<D0>(d0)), std::forward<D1>(d1), std::forward<Ds>(ds)...);
  }
 
} // namespace nda::clef