math_helpers.hpp

Go to the documentation of this file.

#ifndef TATAMI_MATH_HELPERS_H
#define TATAMI_MATH_HELPERS_H
 
#include <cmath>
 
namespace tatami {
 
template<typename InputValue_ = double>
class DelayedUnaryIsometricAbs {
public:
    static constexpr bool is_basic = false;
 
    bool is_sparse() const {
        return true;
    }
 
private:
    template<typename Index_, typename OutputValue_>
    void core(const InputValue_* input, Index_ length, OutputValue_* output) const {
        for (Index_ i = 0; i < length; ++i) {
            if constexpr(std::is_same<InputValue_, OutputValue_>::value) {
                auto& val = output[i];
                val = std::abs(val);
            } else {
                output[i] = std::abs(input[i]);
            }
        }
    }
 
public:
    template<typename Index_, typename OutputValue_>
    void dense(bool, Index_, Index_, Index_ length, const InputValue_* input, OutputValue_* output) const {
        core(input, length, output);
    }
 
    template<typename Index_, typename OutputValue_>
    void dense(bool, Index_, const std::vector<Index_>& indices, const InputValue_* input, OutputValue_* output) const {
        core<Index_>(input, indices.size(), output);
    }
 
    template<typename Index_, typename OutputValue_>
    void sparse(bool, Index_, Index_ number, const InputValue_* input, const Index_*, OutputValue_* output) const {
        core(input, number, output);
    }
 
    template<typename OutputValue_, typename Index_>
    OutputValue_ fill(bool, Index_) const {
        return 0;
    }
};
 
template<typename InputValue_ = double>
class DelayedUnaryIsometricSign {
public:
    static constexpr bool is_basic = false;
 
    bool is_sparse() const {
        return true;
    }
private:
    template<typename Index_, typename OutputValue_>
    void core(const InputValue_* input, Index_ length, OutputValue_* output) const {
        for (Index_ i = 0; i < length; ++i) {
            if constexpr(std::is_same<InputValue_, OutputValue_>::value) {
                auto& val = output[i];
                if (!std::isnan(val)) {
                    val = (static_cast<InputValue_>(0) < val) - (val < static_cast<InputValue_>(0));
                }
            } else {
                auto val = input[i];
                if (!std::isnan(val)) {
                    output[i] = (static_cast<InputValue_>(0) < val) - (val < static_cast<InputValue_>(0));
                } else if constexpr(std::numeric_limits<OutputValue_>::has_quiet_NaN) {
                    output[i] = std::numeric_limits<OutputValue_>::quiet_NaN();
                } else {
                    output[i] = 0;
                }
            }
        }
    }
 
public:
    template<typename Index_, typename OutputValue_>
    void dense(bool, Index_, Index_, Index_ length, const InputValue_* input, OutputValue_* output) const {
        core(input, length, output);
    }
 
    template<typename Index_, typename OutputValue_>
    void dense(bool, Index_, const std::vector<Index_>& indices, const InputValue_* input, OutputValue_* output) const {
        core<Index_>(input, indices.size(), output);
    }
 
    template<typename Index_, typename OutputValue_>
    void sparse(bool, Index_, Index_ number, const InputValue_* input, const Index_*, OutputValue_* output) const {
        core(input, number, output);
    }
 
    template<typename OutputValue_, typename Index_>
    OutputValue_ fill(bool, Index_) const {
        return 0;
    }
};
 
template<typename InputValue_ = double, typename Base_ = InputValue_>
class DelayedUnaryIsometricLog {
public:
    DelayedUnaryIsometricLog() : my_base(1) {}
 
    DelayedUnaryIsometricLog(Base_ base) : my_base(std::log(base)) {}
 
public:
    static constexpr bool is_basic = false;
 
    bool is_sparse() const {
        return false;
    }
private:
    Base_ my_base;
 
    template<typename Index_, typename OutputValue_>
    void core(const InputValue_* input, Index_ length, OutputValue_* output) const {
        for (Index_ i = 0; i < length; ++i) {
            if constexpr(std::is_same<InputValue_, OutputValue_>::value) {
                auto& val = output[i];
                val = std::log(val) / my_base;
            } else {
                output[i] = std::log(input[i]) / my_base;
            }
        }
    }
 
public:
    template<typename Index_, typename OutputValue_>
    void dense(bool, Index_, Index_, Index_ length, const InputValue_* input, OutputValue_* output) const {
        core(input, length, output);
    }
 
    template<typename Index_, typename OutputValue_>
    void dense(bool, Index_, const std::vector<Index_>& indices, const InputValue_* input, OutputValue_* output) const {
        core<Index_>(input, indices.size(), output);
    }
 
    template<typename Index_, typename OutputValue_>
    void sparse(bool, Index_, Index_ number, const InputValue_* input, const Index_*, OutputValue_* output) const {
        core(input, number, output);
    }
 
    template<typename OutputValue_, typename Index_>
    OutputValue_ fill(bool, Index_) const {
        // Use the implementation-defined value.
        return std::log(static_cast<OutputValue_>(0));
    }
};
 
template<typename InputValue_ = double>
class DelayedUnaryIsometricSqrt {
public:
    static constexpr bool is_basic = false;
 
    bool is_sparse() const {
        return true;
    }
private:
    template<typename Index_, typename OutputValue_>
    void core(const InputValue_* input, Index_ length, OutputValue_* output) const {
        for (Index_ i = 0; i < length; ++i) {
            if constexpr(std::is_same<InputValue_, OutputValue_>::value) {
                auto& val = output[i];
                val = std::sqrt(val);
            } else {
                output[i] = std::sqrt(input[i]);
            }
        }
    }
 
public:
    template<typename Index_, typename OutputValue_>
    void dense(bool, Index_, Index_, Index_ length, const InputValue_* input, OutputValue_* output) const {
        core(input, length, output);
    }
 
    template<typename Index_, typename OutputValue_>
    void dense(bool, Index_, const std::vector<Index_>& indices, const InputValue_* input, OutputValue_* output) const {
        core(input, indices.size(), output);
    }
 
    template<typename Index_, typename OutputValue_>
    void sparse(bool, Index_, Index_ number, const InputValue_* input, const Index_*, OutputValue_* output) const {
        core(input, number, output);
    }
 
    template<typename OutputValue_, typename Index_>
    OutputValue_ fill(bool, Index_) const {
        return 0;
    }
};
 
template<typename InputValue_ = double>
class DelayedUnaryIsometricCeiling {
public:
    static constexpr bool is_basic = false;
 
    bool is_sparse() const {
        return true;
    }
private:
    template<typename Index_, typename OutputValue_>
    void core(const InputValue_* input, Index_ length, OutputValue_* output) const {
        for (Index_ i = 0; i < length; ++i) {
            if constexpr(std::is_same<InputValue_, OutputValue_>::value) {
                auto& val = output[i];
                val = std::ceil(val);
            } else {
                output[i] = std::ceil(input[i]);
            }
        }
    }
 
public:
    template<typename Index_, typename OutputValue_>
    void dense(bool, Index_, Index_, Index_ length, const InputValue_* input, OutputValue_* output) const {
        core(input, length, output);
    }
 
    template<typename Index_, typename OutputValue_>
    void dense(bool, Index_, const std::vector<Index_>& indices, const InputValue_* input, OutputValue_* output) const {
        core<Index_>(input, indices.size(), output);
    }
 
    template<typename Index_, typename OutputValue_>
    void sparse(bool, Index_, Index_ number, const InputValue_* input, const Index_*, OutputValue_* output) const {
        core(input, number, output);
    }
 
    template<typename OutputValue_, typename Index_>
    OutputValue_ fill(bool, Index_) const {
        return 0;
    }
};
 
template<typename InputValue_ = double>
class DelayedUnaryIsometricFloor {
public:
    static constexpr bool is_basic = false;
 
    bool is_sparse() const {
        return true;
    }
private:
    template<typename Index_, typename OutputValue_>
    void core(const InputValue_* input, Index_ length, OutputValue_* output) const {
        for (Index_ i = 0; i < length; ++i) {
            if constexpr(std::is_same<InputValue_, OutputValue_>::value) {
                auto& val = output[i];
                val = std::floor(val);
            } else {
                output[i] = std::floor(input[i]);
            }
        }
    }
 
public:
    template<typename Index_, typename OutputValue_>
    void dense(bool, Index_, Index_, Index_ length, const InputValue_* input, OutputValue_* output) const {
        core(input, length, output);
    }
 
    template<typename Index_, typename OutputValue_>
    void dense(bool, Index_, const std::vector<Index_>& indices, const InputValue_* input, OutputValue_* output) const {
        core(input, indices.size(), output);
    }
 
    template<typename Index_, typename OutputValue_>
    void sparse(bool, Index_, Index_ number, const InputValue_* input, const Index_*, OutputValue_* output) const {
        core(input, number, output);
    }
 
    template<typename OutputValue_, typename Index_>
    OutputValue_ fill(bool, Index_) const {
        return 0;
    }
};
 
template<typename InputValue_ = double>
class DelayedUnaryIsometricTrunc {
public:
    static constexpr bool is_basic = false;
 
    bool is_sparse() const {
        return true;
    }
private:
    template<typename Index_, typename OutputValue_>
    void core(const InputValue_* input, Index_ length, OutputValue_* output) const {
        for (Index_ i = 0; i < length; ++i) {
            if constexpr(std::is_same<InputValue_, OutputValue_>::value) {
                auto& val = output[i];
                val = std::trunc(val);
            } else {
                output[i] = std::trunc(input[i]);
            }
        }
    }
 
public:
    template<typename Index_, typename OutputValue_>
    void dense(bool, Index_, Index_, Index_ length, const InputValue_* input, OutputValue_* output) const {
        core(input, length, output);
    }
 
    template<typename Index_, typename OutputValue_>
    void dense(bool, Index_, const std::vector<Index_>& indices, const InputValue_* input, OutputValue_* output) const {
        core(input, indices.size(), output);
    }
 
    template<typename Index_, typename OutputValue_>
    void sparse(bool, Index_, Index_ number, const InputValue_* input, const Index_*, OutputValue_* output) const {
        core(input, number, output);
    }
 
    template<typename OutputValue_, typename Index_>
    OutputValue_ fill(bool, Index_) const {
        return 0;
    }
};
 
template<typename InputValue_ = double, typename Base_ = InputValue_>
class DelayedUnaryIsometricLog1p {
public:
    DelayedUnaryIsometricLog1p() : my_base(1) {}
 
    DelayedUnaryIsometricLog1p(Base_ base) : my_base(std::log(base)) {}
 
public:
    static constexpr bool is_basic = false;
 
    bool is_sparse() const {
        return true;
    }
private:
    template<typename Index_, typename OutputValue_>
    void core(const InputValue_* input, Index_ length, OutputValue_* output) const {
        for (Index_ i = 0; i < length; ++i) {
            if constexpr(std::is_same<InputValue_, OutputValue_>::value) {
                auto& val = output[i];
                val = std::log1p(val) / my_base;
            } else {
                output[i] = std::log1p(input[i]) / my_base;
            }
        }
    }
 
    Base_ my_base;
 
public:
    template<typename Index_, typename OutputValue_>
    void dense(bool, Index_, Index_, Index_ length, const InputValue_* input, OutputValue_* output) const {
        core(input, length, output);
    }
 
    template<typename Index_, typename OutputValue_>
    void dense(bool, Index_, const std::vector<Index_>& indices, const InputValue_* input, OutputValue_* output) const {
        core(input, indices.size(), output);
    }
 
    template<typename Index_, typename OutputValue_>
    void sparse(bool, Index_, Index_ number, const InputValue_* input, const Index_*, OutputValue_* output) const {
        core(input, number, output);
    }
 
    template<typename OutputValue_, typename Index_>
    OutputValue_ fill(bool, Index_) const {
        return 0;
    }
};
 
template<typename InputValue_ = double>
class DelayedUnaryIsometricRound {
public:
    static constexpr bool is_basic = false;
 
    bool is_sparse() const {
        return true;
    }
private:
    template<typename Index_, typename OutputValue_>
    void core(const InputValue_* input, Index_ length, OutputValue_* output) const {
        for (Index_ i = 0; i < length; ++i) {
            if constexpr(std::is_same<InputValue_, OutputValue_>::value) {
                auto& val = output[i];
                val = std::round(val);
            } else {
                output[i] = std::round(input[i]);
            }
        }
    }
 
public:
    template<typename Index_, typename OutputValue_>
    void dense(bool, Index_, Index_, Index_ length, const InputValue_* input, OutputValue_* output) const {
        core(input, length, output);
    }
 
    template<typename Index_, typename OutputValue_>
    void dense(bool, Index_, const std::vector<Index_>& indices, const InputValue_* input, OutputValue_* output) const {
        core(input, indices.size(), output);
    }
 
    template<typename Index_, typename OutputValue_>
    void sparse(bool, Index_, Index_ number, const InputValue_* input, const Index_*, OutputValue_* output) const {
        core(input, number, output);
    }
 
    template<typename OutputValue_, typename Index_>
    OutputValue_ fill(bool, Index_) const {
        return 0;
    }
};
 
template<typename InputValue_ = double>
class DelayedUnaryIsometricExp {
public:
    static constexpr bool is_basic = false;
 
    bool is_sparse() const {
        return false;
    }
private:
    template<typename Index_, typename OutputValue_>
    void core(const InputValue_* input, Index_ length, OutputValue_* output) const {
        for (Index_ i = 0; i < length; ++i) {
            if constexpr(std::is_same<InputValue_, OutputValue_>::value) {
                auto& val = output[i];
                val = std::exp(val);
            } else {
                output[i] = std::exp(input[i]);
            }
        }
    }
 
public:
    template<typename Index_, typename OutputValue_>
    void dense(bool, Index_, Index_, Index_ length, const InputValue_* input, OutputValue_* output) const {
        core(input, length, output);
    }
 
    template<typename Index_, typename OutputValue_>
    void dense(bool, Index_, const std::vector<Index_>& indices, const InputValue_* input, OutputValue_* output) const {
        core(input, indices.size(), output);
    }
 
    template<typename Index_, typename OutputValue_>
    void sparse(bool, Index_, Index_ number, const InputValue_* input, const Index_*, OutputValue_* output) const {
        core(input, number, output);
    }
 
    template<typename OutputValue_, typename Index_>
    OutputValue_ fill(bool, Index_) const {
        return 1;
    }
};
 
template<typename InputValue_ = double>
class DelayedUnaryIsometricExpm1 {
public:
    static constexpr bool is_basic = false;
 
    bool is_sparse() const {
        return true;
    }
private:
    template<typename Index_, typename OutputValue_>
    void core(const InputValue_* input, Index_ length, OutputValue_* output) const {
        for (Index_ i = 0; i < length; ++i) {
            if constexpr(std::is_same<InputValue_, OutputValue_>::value) {
                auto& val = output[i];
                val = std::expm1(val);
            } else {
                output[i] = std::expm1(input[i]);
            }
        }
    }
 
public:
    template<typename Index_, typename OutputValue_>
    void dense(bool, Index_, Index_, Index_ length, const InputValue_* input, OutputValue_* output) const {
        core(input, length, output);
    }
 
    template<typename Index_, typename OutputValue_>
    void dense(bool, Index_, const std::vector<Index_>& indices, const InputValue_* input, OutputValue_* output) const {
        core(input, indices.size(), output);
    }
 
    template<typename Index_, typename OutputValue_>
    void sparse(bool, Index_, Index_ number, const InputValue_* input, const Index_*, OutputValue_* output) const {
        core(input, number, output);
    }
 
    template<typename OutputValue_, typename Index_>
    OutputValue_ fill(bool, Index_) const {
        return 0;
    }
};
 
template<typename InputValue_ = double>
class DelayedUnaryIsometricAcos {
public:
    static constexpr bool is_basic = false;
 
    bool is_sparse() const {
        return false;
    }
private:
    template<typename Index_, typename OutputValue_>
    void core(const InputValue_* input, Index_ length, OutputValue_* output) const {
        for (Index_ i = 0; i < length; ++i) {
            if constexpr(std::is_same<InputValue_, OutputValue_>::value) {
                auto& val = output[i];
                val = std::acos(val);
            } else {
                output[i] = std::acos(input[i]);
            }
        }
    }
 
public:
    template<typename Index_, typename OutputValue_>
    void dense(bool, Index_, Index_, Index_ length, const InputValue_* input, OutputValue_* output) const {
        core(input, length, output);
    }
 
    template<typename Index_, typename OutputValue_>
    void dense(bool, Index_, const std::vector<Index_>& indices, const InputValue_* input, OutputValue_* output) const {
        core(input, indices.size(), output);
    }
 
    template<typename Index_, typename OutputValue_>
    void sparse(bool, Index_, Index_ number, const InputValue_* input, const Index_*, OutputValue_* output) const {
        core(input, number, output);
    }
 
    template<typename OutputValue_, typename Index_>
    OutputValue_ fill(bool, Index_) const {
        // Use the implementation-defined special value.
        return std::acos(0);
    }
};
 
template<typename InputValue_ = double>
class DelayedUnaryIsometricAcosh {
public:
    static constexpr bool is_basic = false;
 
    bool is_sparse() const {
        return false;
    }
private:
    template<typename Index_, typename OutputValue_>
    void core(const InputValue_* input, Index_ length, OutputValue_* output) const {
        for (Index_ i = 0; i < length; ++i) {
            if constexpr(std::is_same<InputValue_, OutputValue_>::value) {
                auto& val = output[i];
                val = std::acosh(val);
            } else {
                output[i] = std::acosh(input[i]);
            }
        }
    }
 
public:
    template<typename Index_, typename OutputValue_>
    void dense(bool, Index_, Index_, Index_ length, const InputValue_* input, OutputValue_* output) const {
        core(input, length, output);
    }
 
    template<typename Index_, typename OutputValue_>
    void dense(bool, Index_, const std::vector<Index_>& indices, const InputValue_* input, OutputValue_* output) const {
        core(input, indices.size(), output);
    }
 
    template<typename Index_, typename OutputValue_>
    void sparse(bool, Index_, Index_ number, const InputValue_* input, const Index_*, OutputValue_* output) const {
        core(input, number, output);
    }
 
    template<typename OutputValue_, typename Index_>
    OutputValue_ fill(bool, Index_) const {
        // Use the implementation-defined special value.
        return std::acosh(static_cast<InputValue_>(0));
    }
};
 
template<typename InputValue_ = double>
class DelayedUnaryIsometricAsin {
public:
    static constexpr bool is_basic = false;
 
    bool is_sparse() const {
        return true;
    }
private:
    template<typename Index_, typename OutputValue_>
    void core(const InputValue_* input, Index_ length, OutputValue_* output) const {
        for (Index_ i = 0; i < length; ++i) {
            if constexpr(std::is_same<InputValue_, OutputValue_>::value) {
                auto& val = output[i];
                val = std::asin(val);
            } else {
                output[i] = std::asin(input[i]);
            }
        }
    }
 
public:
    template<typename Index_, typename OutputValue_>
    void dense(bool, Index_, Index_, Index_ length, const InputValue_* input, OutputValue_* output) const {
        core(input, length, output);
    }
 
    template<typename Index_, typename OutputValue_>
    void dense(bool, Index_, const std::vector<Index_>& indices, const InputValue_* input, OutputValue_* output) const {
        core(input, indices.size(), output);
    }
 
    template<typename Index_, typename OutputValue_>
    void sparse(bool, Index_, Index_ number, const InputValue_* input, const Index_*, OutputValue_* output) const {
        core(input, number, output);
    }
 
    template<typename OutputValue_, typename Index_>
    OutputValue_ fill(bool, Index_) const {
        return 0;
    }
};
 
template<typename InputValue_ = double>
class DelayedUnaryIsometricAsinh {
public:
    static constexpr bool is_basic = false;
 
    bool is_sparse() const {
        return true;
    }
private:
    template<typename Index_, typename OutputValue_>
    void core(const InputValue_* input, Index_ length, OutputValue_* output) const {
        for (Index_ i = 0; i < length; ++i) {
            if constexpr(std::is_same<InputValue_, OutputValue_>::value) {
                auto& val = output[i];
                val = std::asinh(val);
            } else {
                output[i] = std::asinh(input[i]);
            }
        }
    }
 
public:
    template<typename Index_, typename OutputValue_>
    void dense(bool, Index_, Index_, Index_ length, const InputValue_* input, OutputValue_* output) const {
        core(input, length, output);
    }
 
    template<typename Index_, typename OutputValue_>
    void dense(bool, Index_, const std::vector<Index_>& indices, const InputValue_* input, OutputValue_* output) const {
        core(input, indices.size(), output);
    }
 
    template<typename Index_, typename OutputValue_>
    void sparse(bool, Index_, Index_ number, const InputValue_* input, const Index_*, OutputValue_* output) const {
        core(input, number, output);
    }
 
    template<typename OutputValue_, typename Index_>
    OutputValue_ fill(bool, Index_) const {
        return 0;
    }
};
 
template<typename InputValue_ = double>
class DelayedUnaryIsometricAtan {
public:
    static constexpr bool is_basic = false;
 
    bool is_sparse() const {
        return true;
    }
private:
    template<typename Index_, typename OutputValue_>
    void core(const InputValue_* input, Index_ length, OutputValue_* output) const {
        for (Index_ i = 0; i < length; ++i) {
            if constexpr(std::is_same<InputValue_, OutputValue_>::value) {
                auto& val = output[i];
                val = std::atan(val);
            } else {
                output[i] = std::atan(input[i]);
            }
        }
    }
 
public:
    template<typename Index_, typename OutputValue_>
    void dense(bool, Index_, Index_, Index_ length, const InputValue_* input, OutputValue_* output) const {
        core(input, length, output);
    }
 
    template<typename Index_, typename OutputValue_>
    void dense(bool, Index_, const std::vector<Index_>& indices, const InputValue_* input, OutputValue_* output) const {
        core(input, indices.size(), output);
    }
 
    template<typename Index_, typename OutputValue_>
    void sparse(bool, Index_, Index_ number, const InputValue_* input, const Index_*, OutputValue_* output) const {
        core(input, number, output);
    }
 
    template<typename OutputValue_, typename Index_>
    OutputValue_ fill(bool, Index_) const {
        return 0;
    }
};
 
template<typename InputValue_ = double>
class DelayedUnaryIsometricAtanh {
public:
    static constexpr bool is_basic = false;
 
    bool is_sparse() const {
        return true;
    }
private:
    template<typename Index_, typename OutputValue_>
    void core(const InputValue_* input, Index_ length, OutputValue_* output) const {
        for (Index_ i = 0; i < length; ++i) {
            if constexpr(std::is_same<InputValue_, OutputValue_>::value) {
                auto& val = output[i];
                val = std::atanh(val);
            } else {
                output[i] = std::atanh(input[i]);
            }
        }
    }
 
public:
    template<typename Index_, typename OutputValue_>
    void dense(bool, Index_, Index_, Index_ length, const InputValue_* input, OutputValue_* output) const {
        core(input, length, output);
    }
 
    template<typename Index_, typename OutputValue_>
    void dense(bool, Index_, const std::vector<Index_>& indices, const InputValue_* input, OutputValue_* output) const {
        core(input, indices.size(), output);
    }
 
    template<typename Index_, typename OutputValue_>
    void sparse(bool, Index_, Index_ number, const InputValue_* input, const Index_*, OutputValue_* output) const {
        core(input, number, output);
    }
 
    template<typename OutputValue_, typename Index_>
    OutputValue_ fill(bool, Index_) const {
        return 0;
    }
};
 
template<typename InputValue_ = double>
class DelayedUnaryIsometricCos {
public:
    static constexpr bool is_basic = false;
 
    bool is_sparse() const {
        return false;
    }
private:
    template<typename Index_, typename OutputValue_>
    void core(const InputValue_* input, Index_ length, OutputValue_* output) const {
        for (Index_ i = 0; i < length; ++i) {
            if constexpr(std::is_same<InputValue_, OutputValue_>::value) {
                auto& val = output[i];
                val = std::cos(val);
            } else {
                output[i] = std::cos(input[i]);
            }
        }
    }
 
public:
    template<typename Index_, typename OutputValue_>
    void dense(bool, Index_, Index_, Index_ length, const InputValue_* input, OutputValue_* output) const {
        core(input, length, output);
    }
 
    template<typename Index_, typename OutputValue_>
    void dense(bool, Index_, const std::vector<Index_>& indices, const InputValue_* input, OutputValue_* output) const {
        core(input, indices.size(), output);
    }
 
    template<typename Index_, typename OutputValue_>
    void sparse(bool, Index_, Index_ number, const InputValue_* input, const Index_*, OutputValue_* output) const {
        core(input, number, output);
    }
 
    template<typename OutputValue_, typename Index_>
    OutputValue_ fill(bool, Index_) const {
        return 1.0;
    }
};
 
template<typename InputValue_ = double>
class DelayedUnaryIsometricCosh {
public:
    static constexpr bool is_basic = false;
 
    bool is_sparse() const {
        return false;
    }
private:
    template<typename Index_, typename OutputValue_>
    void core(const InputValue_* input, Index_ length, OutputValue_* output) const {
        for (Index_ i = 0; i < length; ++i) {
            if constexpr(std::is_same<InputValue_, OutputValue_>::value) {
                auto& val = output[i];
                val = std::cosh(val);
            } else {
                output[i] = std::cosh(input[i]);
            }
        }
    }
 
public:
    template<typename Index_, typename OutputValue_>
    void dense(bool, Index_, Index_, Index_ length, const InputValue_* input, OutputValue_* output) const {
        core(input, length, output);
    }
 
    template<typename Index_, typename OutputValue_>
    void dense(bool, Index_, const std::vector<Index_>& indices, const InputValue_* input, OutputValue_* output) const {
        core(input, indices.size(), output);
    }
 
    template<typename Index_, typename OutputValue_>
    void sparse(bool, Index_, Index_ number, const InputValue_* input, const Index_*, OutputValue_* output) const {
        core(input, number, output);
    }
 
    template<typename OutputValue_, typename Index_>
    OutputValue_ fill(bool, Index_) const {
        return 1.0;
    }
};
 
template<typename InputValue_ = double>
class DelayedUnaryIsometricSin {
public:
    static constexpr bool is_basic = false;
 
    bool is_sparse() const {
        return true;
    }
private:
    template<typename Index_, typename OutputValue_>
    void core(const InputValue_* input, Index_ length, OutputValue_* output) const {
        for (Index_ i = 0; i < length; ++i) {
            if constexpr(std::is_same<InputValue_, OutputValue_>::value) {
                auto& val = output[i];
                val = std::sin(val);
            } else {
                output[i] = std::sin(input[i]);
            }
        }
    }
 
public:
    template<typename Index_, typename OutputValue_>
    void dense(bool, Index_, Index_, Index_ length, const InputValue_* input, OutputValue_* output) const {
        core(input, length, output);
    }
 
    template<typename Index_, typename OutputValue_>
    void dense(bool, Index_, const std::vector<Index_>& indices, const InputValue_* input, OutputValue_* output) const {
        core(input, indices.size(), output);
    }
 
    template<typename Index_, typename OutputValue_>
    void sparse(bool, Index_, Index_ number, const InputValue_* input, const Index_*, OutputValue_* output) const {
        core(input, number, output);
    }
 
    template<typename OutputValue_, typename Index_>
    OutputValue_ fill(bool, Index_) const {
        return 0;
    }
};
 
template<typename InputValue_ = double>
class DelayedUnaryIsometricSinh {
public:
    static constexpr bool is_basic = false;
 
    bool is_sparse() const {
        return true;
    }
private:
    template<typename Index_, typename OutputValue_>
    void core(const InputValue_* input, Index_ length, OutputValue_* output) const {
        for (Index_ i = 0; i < length; ++i) {
            if constexpr(std::is_same<InputValue_, OutputValue_>::value) {
                auto& val = output[i];
                val = std::sinh(val);
            } else {
                output[i] = std::sinh(input[i]);
            }
        }
    }
 
public:
    template<typename Index_, typename OutputValue_>
    void dense(bool, Index_, Index_, Index_ length, const InputValue_* input, OutputValue_* output) const {
        core(input, length, output);
    }
 
    template<typename Index_, typename OutputValue_>
    void dense(bool, Index_, const std::vector<Index_>& indices, const InputValue_* input, OutputValue_* output) const {
        core(input, indices.size(), output);
    }
 
    template<typename Index_, typename OutputValue_>
    void sparse(bool, Index_, Index_ number, const InputValue_* input, const Index_*, OutputValue_* output) const {
        core(input, number, output);
    }
 
    template<typename OutputValue_, typename Index_>
    OutputValue_ fill(bool, Index_) const {
        return 0;
    }
};
 
template<typename InputValue_ = double>
class DelayedUnaryIsometricTan {
public:
    static constexpr bool is_basic = false;
 
    bool is_sparse() const {
        return true;
    }
private:
    template<typename Index_, typename OutputValue_>
    void core(const InputValue_* input, Index_ length, OutputValue_* output) const {
        for (Index_ i = 0; i < length; ++i) {
            if constexpr(std::is_same<InputValue_, OutputValue_>::value) {
                auto& val = output[i];
                val = std::tan(val);
            } else {
                output[i] = std::tan(input[i]);
            }
        }
    }
 
public:
    template<typename Index_, typename OutputValue_>
    void dense(bool, Index_, Index_, Index_ length, const InputValue_* input, OutputValue_* output) const {
        core(input, length, output);
    }
 
    template<typename Index_, typename OutputValue_>
    void dense(bool, Index_, const std::vector<Index_>& indices, const InputValue_* input, OutputValue_* output) const {
        core(input, indices.size(), output);
    }
 
    template<typename Index_, typename OutputValue_>
    void sparse(bool, Index_, Index_ number, const InputValue_* input, const Index_*, OutputValue_* output) const {
        core(input, number, output);
    }
 
    template<typename OutputValue_, typename Index_>
    OutputValue_ fill(bool, Index_) const {
        return 0;
    }
};
 
template<typename InputValue_ = double>
class DelayedUnaryIsometricTanh {
public:
    static constexpr bool is_basic = false;
 
    bool is_sparse() const {
        return true;
    }
private:
    template<typename Index_, typename OutputValue_>
    void core(const InputValue_* input, Index_ length, OutputValue_* output) const {
        for (Index_ i = 0; i < length; ++i) {
            if constexpr(std::is_same<InputValue_, OutputValue_>::value) {
                auto& val = output[i];
                val = std::tanh(val);
            } else {
                output[i] = std::tanh(input[i]);
            }
        }
    }
 
public:
    template<typename Index_, typename OutputValue_>
    void dense(bool, Index_, Index_, Index_ length, const InputValue_* input, OutputValue_* output) const {
        core(input, length, output);
    }
 
    template<typename Index_, typename OutputValue_>
    void dense(bool, Index_, const std::vector<Index_>& indices, const InputValue_* input, OutputValue_* output) const {
        core(input, indices.size(), output);
    }
 
    template<typename Index_, typename OutputValue_>
    void sparse(bool, Index_, Index_ number, const InputValue_* input, const Index_*, OutputValue_* output) const {
        core(input, number, output);
    }
 
    template<typename OutputValue_, typename Index_>
    OutputValue_ fill(bool, Index_) const {
        return 0;
    }
};
 
template<typename InputValue_ = double>
class DelayedUnaryIsometricGamma {
public:
    static constexpr bool is_basic = false;
 
    bool is_sparse() const {
        return false;
    }
private:
    template<typename Index_, typename OutputValue_>
    void core(const InputValue_* input, Index_ length, OutputValue_* output) const {
        for (Index_ i = 0; i < length; ++i) {
            if constexpr(std::is_same<InputValue_, OutputValue_>::value) {
                auto& val = output[i];
                val = std::tgamma(val);
            } else {
                output[i] = std::tgamma(input[i]);
            }
        }
    }
 
public:
    template<typename Index_, typename OutputValue_>
    void dense(bool, Index_, Index_, Index_ length, const InputValue_* input, OutputValue_* output) const {
        core(input, length, output);
    }
 
    template<typename Index_, typename OutputValue_>
    void dense(bool, Index_, const std::vector<Index_>& indices, const InputValue_* input, OutputValue_* output) const {
        core(input, indices.size(), output);
    }
 
    template<typename Index_, typename OutputValue_>
    void sparse(bool, Index_, Index_ number, const InputValue_* input, const Index_*, OutputValue_* output) const {
        core(input, number, output);
    }
 
    template<typename OutputValue_, typename Index_>
    OutputValue_ fill(bool, Index_) const {
        // Use the implementation-defined special value.
        return std::tgamma(static_cast<InputValue_>(0));
    }
};
 
template<typename InputValue_ = double>
class DelayedUnaryIsometricLgamma {
public:
    static constexpr bool is_basic = false;
 
    bool is_sparse() const {
        return false;
    }
private:
    template<typename Index_, typename OutputValue_>
    void core(const InputValue_* input, Index_ length, OutputValue_* output) const {
        for (Index_ i = 0; i < length; ++i) {
            if constexpr(std::is_same<InputValue_, OutputValue_>::value) {
                auto& val = output[i];
                val = std::lgamma(val);
            } else {
                output[i] = std::lgamma(input[i]);
            }
        }
    }
 
public:
    template<typename Index_, typename OutputValue_>
    void dense(bool, Index_, Index_, Index_ length, const InputValue_* input, OutputValue_* output) const {
        core(input, length, output);
    }
 
    template<typename Index_, typename OutputValue_>
    void dense(bool, Index_, const std::vector<Index_>& indices, const InputValue_* input, OutputValue_* output) const {
        core(input, indices.size(), output);
    }
 
    template<typename Index_, typename OutputValue_>
    void sparse(bool, Index_, Index_ number, const InputValue_* input, const Index_*, OutputValue_* output) const {
        core(input, number, output);
    }
 
    template<typename OutputValue_, typename Index_>
    OutputValue_ fill(bool, Index_) const {
        // Use the implementation-defined special value.
        return std::lgamma(static_cast<InputValue_>(0));
    }
};
 
}
 
#endif