node.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 <memory>
#include <utility>
#include <vector>
 
#include "num_collect/base/concepts/real_scalar.h"
#include "num_collect/util/assert.h"
 
namespace num_collect::auto_diff::backward::graph {
 
template <base::concepts::real_scalar Scalar>
class node;
 
template <base::concepts::real_scalar Scalar>
using node_ptr = std::shared_ptr<const node<Scalar>>;
 
template <base::concepts::real_scalar Scalar>
class child_node {
public:
    using scalar_type = Scalar;
 
    child_node(node_ptr<scalar_type> node, const scalar_type& sensitivity)
        : node_(std::move(node)), sensitivity_(sensitivity) {
        NUM_COLLECT_ASSERT(node_);
    }
 
    [[nodiscard]] auto node() const noexcept -> const node_ptr<scalar_type>& {
        return node_;
    }
 
    [[nodiscard]] auto sensitivity() const noexcept -> const scalar_type& {
        return sensitivity_;
    }
 
private:
    node_ptr<scalar_type> node_;
 
    scalar_type sensitivity_;
};
 
template <base::concepts::real_scalar Scalar>
class node {
public:
    using scalar_type = Scalar;
 
    explicit node(std::vector<child_node<scalar_type>> children =
                      std::vector<child_node<scalar_type>>())
        : children_(std::move(children)) {}
 
    [[nodiscard]] auto children() const noexcept
        -> const std::vector<child_node<scalar_type>>& {
        return children_;
    }
 
private:
    std::vector<child_node<scalar_type>> children_;
};
 
namespace impl {
 
template <base::concepts::real_scalar Scalar>
[[nodiscard]] inline auto create_node_impl(
    std::vector<child_node<Scalar>>& children) -> node_ptr<Scalar> {
    return std::make_shared<node<Scalar>>(std::move(children));
}
 
template <base::concepts::real_scalar Scalar, typename... Args>
[[nodiscard]] inline auto create_node_impl(
    std::vector<child_node<Scalar>>& children, node_ptr<Scalar> node,
    const Scalar& sensitivity, Args&&... args) -> node_ptr<Scalar> {
    children.emplace_back(std::move(node), sensitivity);
    return create_node_impl(children, std::forward<Args>(args)...);
}
 
}  // namespace impl
 
template <base::concepts::real_scalar Scalar, typename... Args>
[[nodiscard]] inline auto create_node(Args&&... args) -> node_ptr<Scalar> {
    std::vector<child_node<Scalar>> children;
    return impl::create_node_impl(children, std::forward<Args>(args)...);
}
 
}  // namespace num_collect::auto_diff::backward::graph