adc_ternary_vector.h

Go to the documentation of this file.

/*
 * Copyright 2021 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 <cstdint>
#include <functional>
#include <utility>
 
#include <Eigen/Core>
 
#include "num_collect/base/concepts/real_scalar_dense_vector.h"
#include "num_collect/base/exception.h"
#include "num_collect/base/index_type.h"
#include "num_collect/logging/logging_macros.h"
#include "num_collect/util/assert.h"
 
namespace num_collect::opt::impl {

template <base::concepts::real_scalar_dense_vector VariableType,
    index_type MaxDigits>
class adc_ternary_vector {
public:
    static_assert(MaxDigits > 0, "MaxDigits must be a positive integer.");

    using digit_type = std::int8_t;

    static constexpr index_type dimensions_at_compile_time =
        VariableType::RowsAtCompileTime;

    static constexpr index_type max_dimensions_at_compile_time =
        VariableType::MaxRowsAtCompileTime;

    static constexpr index_type max_digits_at_compile_time = MaxDigits;

    adc_ternary_vector() = default;

    explicit adc_ternary_vector(index_type dim)
        : data_(data_type::Zero(dim, MaxDigits)) {}

    [[nodiscard]] auto dim() const -> index_type { return data_.rows(); }

    [[nodiscard]] auto current_max_digits() const -> index_type {
        return current_max_digits_;
    }

    [[nodiscard]] auto next_divided_dimension_index() const -> index_type {
        return next_divided_dimension_index_;
    }

    [[nodiscard]] auto is_full() const -> bool {
        return current_max_digits_ >= max_digits_at_compile_time &&
            next_divided_dimension_index_ == 0;
    }

    [[nodiscard]] auto digits(index_type dim) const -> index_type {
        if (next_divided_dimension_index_ == 0 ||
            dim < next_divided_dimension_index_) {
            return current_max_digits_;
        }
        return current_max_digits_ - 1;
    }

    [[nodiscard]] auto operator()(index_type dim, index_type digit) const
        -> digit_type {
        NUM_COLLECT_DEBUG_ASSERT(dim < data_.rows());
        NUM_COLLECT_DEBUG_ASSERT(digit < max_digits_at_compile_time);
        return data_.coeff(dim, digit);
    }

    [[nodiscard]] auto operator()(index_type dim, index_type digit)
        -> digit_type& {
        NUM_COLLECT_DEBUG_ASSERT(dim < data_.rows());
        NUM_COLLECT_DEBUG_ASSERT(digit < max_digits_at_compile_time);
        return data_.coeffRef(dim, digit);
    }

    auto push_back(digit_type digit) -> std::pair<index_type, index_type> {
        if (next_divided_dimension_index_ == 0) {
            if (current_max_digits_ >= max_digits_at_compile_time) {
                NUM_COLLECT_LOG_AND_THROW(precondition_not_satisfied,
                    "Tried to add a digit to a full adc_ternary_vector.");
            }
            current_max_digits_ += 1;
        }
        NUM_COLLECT_DEBUG_ASSERT(current_max_digits_ - 1 >= 0);
        NUM_COLLECT_DEBUG_ASSERT(current_max_digits_ - 1 < data_.cols());
        NUM_COLLECT_DEBUG_ASSERT(next_divided_dimension_index_ < data_.rows());
        data_.coeffRef(next_divided_dimension_index_, current_max_digits_ - 1) =
            digit;
        const index_type divided_dimension_index =
            next_divided_dimension_index_;
        next_divided_dimension_index_ =
            (next_divided_dimension_index_ + 1) % data_.rows();
        return {divided_dimension_index, current_max_digits_ - 1};
    }

    [[nodiscard]] auto operator==(const adc_ternary_vector& right) const
        -> bool {
        return data_ == right.data_;
    }

    [[nodiscard]] auto operator!=(const adc_ternary_vector& right) const
        -> bool {
        return !operator==(right);
    }

    template <typename Scalar>
    [[nodiscard]] auto elem_as(index_type dim) const -> Scalar {
        NUM_COLLECT_DEBUG_ASSERT(dim < data_.rows());
        auto num = static_cast<Scalar>(0);
        auto coeff = static_cast<Scalar>(1);
        static const Scalar inv_base =
            static_cast<Scalar>(1) / static_cast<Scalar>(3);
        for (index_type i = 0; i < current_max_digits_; ++i) {
            num += coeff * static_cast<Scalar>(data_.coeff(dim, i));
            coeff *= inv_base;
        }
        return num;
    }

    [[nodiscard]] auto as_variable(const VariableType& lower_bound,
        const VariableType& width) const -> VariableType {
        VariableType res(dim());
        for (index_type i = 0; i < dim(); ++i) {
            res(i) = lower_bound(i) +
                width(i) * elem_as<typename VariableType::Scalar>(i);
        }
        return res;
    }

    [[nodiscard]] auto hash() const -> std::size_t {
        std::size_t res = 0;
        for (index_type i = 0; i < data_.rows(); ++i) {
            for (index_type j = 0; j < data_.cols(); ++j) {
                res += static_cast<std::size_t>(data_.coeff(i, j)) +
                    (res << 1U) + (res >> 2U);
            }
        }
        return res;
    }
 
private:
    using data_type = Eigen::Matrix<digit_type, dimensions_at_compile_time,
        MaxDigits, Eigen::RowMajor, max_dimensions_at_compile_time, MaxDigits>;

    data_type data_;

    index_type current_max_digits_{0};

    index_type next_divided_dimension_index_{0};
};
 
}  // namespace num_collect::opt::impl
 
namespace std {

template <num_collect::base::concepts::real_scalar_dense_vector VariableType,
    num_collect::index_type MaxDigits>
class hash<
    num_collect::opt::impl::adc_ternary_vector<VariableType, MaxDigits>> {
public:
    using argument_type =
        num_collect::opt::impl::adc_ternary_vector<VariableType, MaxDigits>;

    using result_type = std::size_t;

    [[nodiscard]] auto operator()(const argument_type& vec) const
        -> result_type {
        return vec.hash();
    }
};
 
}  // namespace std