variable.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 <utility>  // IWYU pragma: keep
 
#include <Eigen/Core>
 
#include "num_collect/auto_diff/backward/graph/node.h"
#include "num_collect/base/concepts/real_scalar.h"
 
namespace num_collect::auto_diff::backward {
 
struct constant_tag {};
 
struct variable_tag {};
 
template <base::concepts::real_scalar Scalar>
class variable {
public:
    using scalar_type = Scalar;
 
    variable(const scalar_type& value, graph::node_ptr<scalar_type> node)
        : value_(value), node_(std::move(node)) {}
 
    variable(const scalar_type& value, const constant_tag& /*tag*/)
        : variable(value, nullptr) {}
 
    variable(const scalar_type& value, const variable_tag& /*tag*/)
        : variable(value, graph::create_node<scalar_type>()) {}
 
    variable(const scalar_type& value)  // NOLINT: implicit conversion required
        : variable(value, constant_tag()) {}
 
    variable() : variable(static_cast<scalar_type>(0)) {}
 
    [[nodiscard]] auto value() const noexcept -> const scalar_type& {
        return value_;
    }
 
    [[nodiscard]] auto node() const noexcept
        -> const graph::node_ptr<scalar_type>& {
        return node_;
    }
 
    auto operator-() const -> variable {
        if (node_) {
            return variable(-value_,
                graph::create_node<scalar_type>(
                    node_, static_cast<scalar_type>(-1)));
        }
        return variable(-value_, nullptr);
    }
 
    auto operator+=(const variable& right) -> variable& {
        if (this == &right) {
            node_ = graph::create_node<scalar_type>(
                node_, static_cast<scalar_type>(2));
            value_ += right.value_;
            return *this;
        }
        if (node_) {
            if (right.node_) {
                node_ = graph::create_node<scalar_type>(node_,
                    static_cast<scalar_type>(1), right.node_,
                    static_cast<scalar_type>(1));
            }
        } else {
            node_ = right.node_;
        }
        value_ += right.value_;
        return *this;
    }
 
    auto operator-=(const variable& right) -> variable& {
        if (this == &right) {
            value_ -= right.value_;
            node_.reset();
            return *this;
        }
        if (node_) {
            if (right.node_) {
                node_ = graph::create_node<scalar_type>(node_,
                    static_cast<scalar_type>(1), right.node_,
                    static_cast<scalar_type>(-1));
            }
        } else {
            if (right.node_) {
                node_ = graph::create_node<scalar_type>(
                    right.node_, static_cast<scalar_type>(-1));
            }
        }
        value_ -= right.value_;
        return *this;
    }
 
    auto operator*=(const variable& right) -> variable& {
        if (this == &right) {
            node_ = graph::create_node<scalar_type>(
                node_, static_cast<scalar_type>(2) * value_);
            value_ *= right.value_;
            return *this;
        }
        if (node_) {
            if (right.node_) {
                node_ = graph::create_node<scalar_type>(
                    node_, right.value_, right.node_, value_);
            } else {
                node_ = graph::create_node<scalar_type>(node_, right.value_);
            }
        } else {
            if (right.node_) {
                node_ = graph::create_node<scalar_type>(right.node_, value_);
            }
        }
        value_ *= right.value_;
        return *this;
    }
 
    auto operator/=(const variable& right) -> variable& {
        if (this == &right) {
            value_ /= right.value_;
            node_.reset();
            return *this;
        }
        value_ /= right.value_;
        if (node_) {
            if (right.node_) {
                node_ = graph::create_node<scalar_type>(node_,
                    static_cast<scalar_type>(1) / right.value_, right.node_,
                    -value_ / right.value_);
            } else {
                node_ = graph::create_node<scalar_type>(
                    node_, static_cast<scalar_type>(1) / right.value_);
            }
        } else {
            if (right.node_) {
                node_ = graph::create_node<scalar_type>(
                    right.node_, -value_ / right.value_);
            }
        }
        return *this;
    }
 
private:
    scalar_type value_;
 
    graph::node_ptr<scalar_type> node_;
};
 
template <typename Scalar>
[[nodiscard]] inline auto operator+(const variable<Scalar>& left,
    const variable<Scalar>& right) -> variable<Scalar> {
    return variable<Scalar>(left) += right;
}
 
template <typename Scalar>
[[nodiscard]] inline auto operator+(
    const Scalar& left, const variable<Scalar>& right) -> variable<Scalar> {
    return variable<Scalar>(left) += right;
}
 
template <typename Scalar>
[[nodiscard]] inline auto operator+(
    const variable<Scalar>& left, const Scalar& right) -> variable<Scalar> {
    return variable<Scalar>(left) += right;
}
 
template <typename Scalar>
[[nodiscard]] inline auto operator-(const variable<Scalar>& left,
    const variable<Scalar>& right) -> variable<Scalar> {
    return variable<Scalar>(left) -= right;
}
 
template <typename Scalar>
[[nodiscard]] inline auto operator-(
    const Scalar& left, const variable<Scalar>& right) -> variable<Scalar> {
    return variable<Scalar>(left) -= right;
}
 
template <typename Scalar>
[[nodiscard]] inline auto operator-(
    const variable<Scalar>& left, const Scalar& right) -> variable<Scalar> {
    return variable<Scalar>(left) -= right;
}
 
template <typename Scalar>
[[nodiscard]] inline auto operator*(const variable<Scalar>& left,
    const variable<Scalar>& right) -> variable<Scalar> {
    return variable<Scalar>(left) *= right;
}
 
template <typename Scalar>
[[nodiscard]] inline auto operator*(
    const Scalar& left, const variable<Scalar>& right) -> variable<Scalar> {
    return variable<Scalar>(left) *= right;
}
 
template <typename Scalar>
[[nodiscard]] inline auto operator*(
    const variable<Scalar>& left, const Scalar& right) -> variable<Scalar> {
    return variable<Scalar>(left) *= right;
}
 
template <typename Scalar>
[[nodiscard]] inline auto operator/(const variable<Scalar>& left,
    const variable<Scalar>& right) -> variable<Scalar> {
    return variable<Scalar>(left) /= right;
}
 
template <typename Scalar>
[[nodiscard]] inline auto operator/(
    const Scalar& left, const variable<Scalar>& right) -> variable<Scalar> {
    return variable<Scalar>(left) /= right;
}
 
template <typename Scalar>
[[nodiscard]] inline auto operator/(
    const variable<Scalar>& left, const Scalar& right) -> variable<Scalar> {
    return variable<Scalar>(left) /= right;
}
 
}  // namespace num_collect::auto_diff::backward
 
namespace Eigen {
 
template <typename Scalar>
struct NumTraits<num_collect::auto_diff::backward::variable<Scalar>> {
    using Real = num_collect::auto_diff::backward::variable<Scalar>;
 
    using NonInteger = Real;
 
    using Literal = Real;
 
    using Nested = Real;
 
    enum {  // NOLINT(performance-enum-size): Preserve the same implementation as Eigen library.
        IsInteger = 0,  // NOLINT
 
        IsSigned = 1,  // NOLINT
 
        IsComplex = 0,  // NOLINT
 
        RequireInitialization = 1,  // NOLINT
 
        ReadCost = 1,  // NOLINT
 
        AddCost = 2,  // NOLINT
 
        MulCost = 4  // NOLINT
    };
 
    static constexpr auto epsilon() -> Real {
        return NumTraits<Scalar>::epsilon();
    }
 
    static constexpr auto dummy_precision() -> Real {
        return NumTraits<Scalar>::dummy_precision();
    }
 
    static constexpr auto highest() -> Real {
        return NumTraits<Scalar>::highest();
    }
 
    static constexpr auto lowest() -> Real {
        return NumTraits<Scalar>::lowest();
    }
 
    static constexpr auto digits10() -> int {
        return NumTraits<Scalar>::digits10();
    }
 
    static constexpr auto infinity() -> Real {
        return NumTraits<Scalar>::infinity();
    }
 
    static constexpr auto quiet_NaN() -> Real {  // NOLINT
        return NumTraits<Scalar>::quiet_NaN();
    }
};
 
}  // namespace Eigen