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 <optional>
#include <utility>
 
#include <Eigen/Core>
 
#include "num_collect/base/concepts/real_scalar.h"
#include "num_collect/base/exception.h"
#include "num_collect/base/precondition.h"
#include "num_collect/logging/logging_macros.h"
 
namespace num_collect::auto_diff::forward {
 
template <base::concepts::real_scalar Value, typename Diff = Value>
class variable {
public:
    using value_type = Value;
 
    using diff_type = Diff;
 
    template <typename DiffArg>
    variable(const value_type& value, DiffArg&& diff)
        : value_(value), diff_(std::forward<DiffArg>(diff)) {}
 
    variable(const value_type& value)  // NOLINT: implicit conversion required
        : value_(value) {}
 
    variable() : variable(static_cast<value_type>(0)) {}
 
    [[nodiscard]] auto value() const noexcept -> const value_type& {
        return value_;
    }
 
    [[nodiscard]] auto has_diff() const noexcept -> bool {
        return diff_.has_value();
    }
 
    [[nodiscard]] auto diff() const -> const diff_type& {
        NUM_COLLECT_PRECONDITION(has_diff(),
            "diff function called for a variable without differential "
            "coefficients.");
        return *diff_;
    }
 
    auto operator-() const -> variable {
        if (diff_) {
            return variable(-value_, -*diff_);
        }
        return variable(-value_);
    }
 
    auto operator+=(const variable& right) -> variable& {
        value_ += right.value_;
        if (right.diff_) {
            if (diff_) {
                *diff_ += *right.diff_;
            } else {
                diff_ = *right.diff_;
            }
        }
        return *this;
    }
 
    auto operator-=(const variable& right) -> variable& {
        value_ -= right.value_;
        if (right.diff_) {
            if (diff_) {
                *diff_ -= *right.diff_;
            } else {
                diff_ = -*right.diff_;
            }
        }
        return *this;
    }
 
    auto operator*=(const variable& right) -> variable& {
        if (right.diff_) {
            if (diff_) {
                *diff_ *= right.value_;
                *diff_ += value_ * (*right.diff_);
            } else {
                diff_ = value_ * (*right.diff_);
            }
        } else {
            if (diff_) {
                *diff_ *= right.value_;
            }
        }
        value_ *= right.value_;
        return *this;
    }
 
    auto operator/=(const variable& right) -> variable& {
        value_ /= right.value_;
        if (right.diff_) {
            if (diff_) {
                *diff_ = ((*diff_) - (*right.diff_) * value_) / right.value_;
            } else {
                diff_ = -(*right.diff_) * value_ / right.value_;
            }
        } else {
            if (diff_) {
                *diff_ = (*diff_) / right.value_;
            }
        }
        return *this;
    }
 
private:
    value_type value_;
 
    std::optional<diff_type> diff_{};
};
 
template <typename Value, typename Diff>
[[nodiscard]] inline auto operator+(const variable<Value, Diff>& left,
    const variable<Value, Diff>& right) -> variable<Value, Diff> {
    return variable<Value, Diff>(left) += right;
}
 
template <typename Value, typename Diff>
[[nodiscard]] inline auto operator+(const Value& left,
    const variable<Value, Diff>& right) -> variable<Value, Diff> {
    return variable<Value, Diff>(left) += right;
}
 
template <typename Value, typename Diff>
[[nodiscard]] inline auto operator+(const variable<Value, Diff>& left,
    const Value& right) -> variable<Value, Diff> {
    return variable<Value, Diff>(left) += right;
}
 
template <typename Value, typename Diff>
[[nodiscard]] inline auto operator-(const variable<Value, Diff>& left,
    const variable<Value, Diff>& right) -> variable<Value, Diff> {
    return variable<Value, Diff>(left) -= right;
}
 
template <typename Value, typename Diff>
[[nodiscard]] inline auto operator-(const Value& left,
    const variable<Value, Diff>& right) -> variable<Value, Diff> {
    return variable<Value, Diff>(left) -= right;
}
 
template <typename Value, typename Diff>
[[nodiscard]] inline auto operator-(const variable<Value, Diff>& left,
    const Value& right) -> variable<Value, Diff> {
    return variable<Value, Diff>(left) -= right;
}
 
template <typename Value, typename Diff>
[[nodiscard]] inline auto operator*(const variable<Value, Diff>& left,
    const variable<Value, Diff>& right) -> variable<Value, Diff> {
    return variable<Value, Diff>(left) *= right;
}
 
template <typename Value, typename Diff>
[[nodiscard]] inline auto operator*(const Value& left,
    const variable<Value, Diff>& right) -> variable<Value, Diff> {
    return variable<Value, Diff>(left) *= right;
}
 
template <typename Value, typename Diff>
[[nodiscard]] inline auto operator*(const variable<Value, Diff>& left,
    const Value& right) -> variable<Value, Diff> {
    return variable<Value, Diff>(left) *= right;
}
 
template <typename Value, typename Diff>
[[nodiscard]] inline auto operator/(const variable<Value, Diff>& left,
    const variable<Value, Diff>& right) -> variable<Value, Diff> {
    return variable<Value, Diff>(left) /= right;
}
 
template <typename Value, typename Diff>
[[nodiscard]] inline auto operator/(const Value& left,
    const variable<Value, Diff>& right) -> variable<Value, Diff> {
    return variable<Value, Diff>(left) /= right;
}
 
template <typename Value, typename Diff>
[[nodiscard]] inline auto operator/(const variable<Value, Diff>& left,
    const Value& right) -> variable<Value, Diff> {
    return variable<Value, Diff>(left) /= right;
}
 
}  // namespace num_collect::auto_diff::forward
 
namespace Eigen {
 
template <typename Value, typename Diff>
struct NumTraits<num_collect::auto_diff::forward::variable<Value, Diff>> {
    using Real = num_collect::auto_diff::forward::variable<Value, Diff>;
 
    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<Value>::epsilon();
    }
 
    static constexpr auto dummy_precision() -> Real {
        return NumTraits<Value>::dummy_precision();
    }
 
    static constexpr auto highest() -> Real {
        return NumTraits<Value>::highest();
    }
 
    static constexpr auto lowest() -> Real {
        return NumTraits<Value>::lowest();
    }
 
    static constexpr auto digits10() -> int {
        return NumTraits<Value>::digits10();
    }
 
    static constexpr auto infinity() -> Real {
        return NumTraits<Value>::infinity();
    }
 
    static constexpr auto quiet_NaN() -> Real {  // NOLINT
        return NumTraits<Value>::quiet_NaN();
    }
};
 
}  // namespace Eigen