callback_eval.hpp

// ops/callback_eval.hpp
//
// Thin Value<->double wrappers around a nk::FnHandle MATLAB-style callback,
// so the ops iterative solver kernels (root_solve: brent/findBracket/brentMin/
// nelderMead) can run in native double precision while the public objective
// stays a generic `void(Span<const Value>, Span<Value>)` handle. Core-free
// (value layer only); FnHandle is value/fn_handle.hpp (L0).
 
#pragma once
 
#include <cstddef>
#include <memory_resource>
#include <nk/value/error.hpp>
#include <nk/value/fn_handle.hpp>
#include <nk/value/span.hpp>
#include <nk/value/value.hpp>
#include <utility>
 
namespace nk::ops {

inline double evalScalar(FnHandle fn, double x, std::pmr::memory_resource *mr)
{
    Value             arg = Value::scalar(x, mr);
    Value             out;
    Span<const Value> args(&arg, 1);
    Span<Value>       outs(&out, 1);
    fn(args, outs, mr);
    if (!out.isScalar() && out.numel() != 1)
        throw Error("callback: handle must return a scalar value", 0, 0, "callback", "",
                    "nk:callback:nonScalar");
    return out.elemAsDouble(0);
}

inline double evalVecToScalar(FnHandle fn, const double *x, std::size_t n,
                              std::pmr::memory_resource *mr)
{
    Value v = Value::matrix(1, n, ValueType::DOUBLE, mr);
    if (n) {
        double *d = v.doubleDataMut();
        for (std::size_t i = 0; i < n; ++i) d[i] = x[i];
    }
    Value out;
    Value args[1] = {std::move(v)};
    fn(Span<const Value>(args, 1), Span<Value>(&out, 1), mr);
    return out.toScalar();
}
 
} // namespace nk::ops