derivative_builder.hpp

Go to the documentation of this file.

#pragma once
 
#include <tuple>
#include <utility>
#include "nodes/binary.hpp"
 
namespace limes::expr {
 
// =============================================================================
// DerivativeBuilder: Fluent builder for derivatives
// =============================================================================
 
template<typename E>
struct DerivativeBuilder {
    using value_type = typename E::value_type;
    using expr_type = E;
 
    E expr;
 
    constexpr DerivativeBuilder(E e) noexcept : expr{e} {}
 
    // =========================================================================
    // wrt<Dim>(): Compute partial derivative with respect to dimension Dim
    // =========================================================================
 
    template<std::size_t Dim>
    [[nodiscard]] constexpr auto wrt() const {
        auto result = expr.template derivative<Dim>();
        return DerivativeBuilder<decltype(result)>{result};
    }
 
    template<std::size_t D1, std::size_t D2>
    [[nodiscard]] constexpr auto wrt() const {
        return wrt<D1>().template wrt<D2>();
    }
 
    template<std::size_t D1, std::size_t D2, std::size_t D3>
    [[nodiscard]] constexpr auto wrt() const {
        return wrt<D1>().template wrt<D2>().template wrt<D3>();
    }
 
    // =========================================================================
    // gradient(): Compute all partial derivatives as a tuple
    // =========================================================================
 
    [[nodiscard]] constexpr auto gradient() const {
        return gradient_impl(std::make_index_sequence<E::arity_v>{});
    }
 
    // =========================================================================
    // Implicit conversion to underlying expression
    // =========================================================================
 
    [[nodiscard]] constexpr E get() const noexcept { return expr; }
 
    [[nodiscard]] constexpr value_type eval(std::span<value_type const> args) const {
        return expr.eval(args);
    }
 
    [[nodiscard]] [[deprecated("use eval() instead")]]
    constexpr value_type evaluate(std::span<value_type const> args) const {
        return eval(args);
    }
 
    [[nodiscard]] std::string to_string() const {
        return expr.to_string();
    }
 
    static constexpr std::size_t arity_v = E::arity_v;
 
    template<std::size_t Dim>
    [[nodiscard]] constexpr auto derivative() const {
        return expr.template derivative<Dim>();
    }
 
private:
    template<std::size_t... Is>
    [[nodiscard]] constexpr auto gradient_impl(std::index_sequence<Is...>) const {
        return std::make_tuple(expr.template derivative<Is>()...);
    }
};
 
// Type trait for DerivativeBuilder detection
template<typename T>
struct is_derivative_builder : std::false_type {};
 
template<typename E>
struct is_derivative_builder<DerivativeBuilder<E>> : std::true_type {};
 
template<typename T>
inline constexpr bool is_derivative_builder_v = is_derivative_builder<T>::value;
 
// =============================================================================
// Builder entry point (new API, overloads existing derivative)
// =============================================================================
 
template<typename E>
    requires (is_expr_node_v<E> && !is_derivative_builder_v<E>)
[[nodiscard]] constexpr auto derivative(E expr) {
    return DerivativeBuilder<E>{expr};
}
 
// Note: The existing derivative<Dim>(expr) free function in derivative.hpp
// is still available for direct use without the builder pattern.
 
 
} // namespace limes::expr