adc_sample_dict.h

Go to the documentation of this file.

/*
 * Copyright 2025 MusicScience37 (Kenta Kabashima)
 *
 * 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
 *
 * 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.
 */
#pragma once
 
#include <cstddef>
#include <string_view>
 
#include <hash_tables/maps/open_address_map_st.h>
 
#include "num_collect/base/index_type.h"
#include "num_collect/base/precondition.h"
#include "num_collect/opt/concepts/multi_variate_objective_function.h"
#include "num_collect/opt/concepts/objective_function.h"
#include "num_collect/opt/impl/adc_ternary_vector.h"
#include "num_collect/util/assert.h"
 
namespace num_collect::opt::impl {

template <concepts::objective_function ObjectiveFunction, index_type MaxDigits>
class adc_sample_dict;

template <concepts::multi_variate_objective_function ObjectiveFunction,
    index_type MaxDigits>
class adc_sample_dict<ObjectiveFunction, MaxDigits> {
public:
    using objective_function_type = ObjectiveFunction;

    using variable_type = typename objective_function_type::variable_type;

    using value_type = typename objective_function_type::value_type;

    using ternary_vector_type = adc_ternary_vector<variable_type, MaxDigits>;

    explicit adc_sample_dict(
        const objective_function_type& obj_fun = objective_function_type())
        : obj_fun_(obj_fun) {}

    void change_objective_function(const objective_function_type& obj_fun) {
        obj_fun_ = obj_fun;
    }

    void init(const variable_type& lower, const variable_type& upper) {
        NUM_COLLECT_PRECONDITION(lower.size() == upper.size(),
            "Element-wise limits must have the same size.");
        NUM_COLLECT_PRECONDITION((lower.array() < upper.array()).all(),
            "Element-wise limits must satisfy lower < upper for each element.");
 
        lower_ = lower;
        width_ = upper - lower;
        dim_ = lower.size();
        value_dict_.clear();
    }

    void reserve(index_type size) {
        value_dict_.reserve(static_cast<std::size_t>(size));
    }

    [[nodiscard]] auto operator()(const ternary_vector_type& point)
        -> value_type {
        return value_dict_.get_or_create_with_factory(
            point, [this, &point] { return evaluate_on(point); });
    }

    [[nodiscard]] auto dim() const -> index_type { return dim_; }

    [[nodiscard]] auto opt_variable() const -> const variable_type& {
        return opt_variable_;
    }

    [[nodiscard]] auto opt_point() const -> const ternary_vector_type& {
        return opt_point_;
    }

    [[nodiscard]] auto opt_value() const -> const value_type& {
        return opt_value_;
    }

    [[nodiscard]] auto evaluations() const noexcept -> index_type {
        return static_cast<index_type>(value_dict_.size());
    }
 
private:
    [[nodiscard]] auto evaluate_on(const ternary_vector_type& point)
        -> value_type {
        NUM_COLLECT_DEBUG_ASSERT(point.dim() == dim_);
        const auto var = point.as_variable(lower_, width_);
        obj_fun_.evaluate_on(var);
 
        if (value_dict_.empty() || obj_fun_.value() < opt_value_) {
            opt_point_ = point;
            opt_variable_ = var;
            opt_value_ = obj_fun_.value();
        }
 
        return obj_fun_.value();
    }

    objective_function_type obj_fun_;

    variable_type lower_{};

    variable_type width_{};

    index_type dim_{0};

    hash_tables::maps::open_address_map_st<ternary_vector_type, value_type>
        value_dict_{};

    ternary_vector_type opt_point_{};

    variable_type opt_variable_{};

    value_type opt_value_{};
};
 
}  // namespace num_collect::opt::impl