math_helpers.hpp

Go to the documentation of this file.

#ifndef TATAMI_MATH_HELPERS_H
#define TATAMI_MATH_HELPERS_H
 
#include "helper_interface.hpp"
#include <cmath>
 
namespace tatami {
 
template<typename OutputValue_, typename InputValue_, typename Index_>
class DelayedUnaryIsometricAbsHelper final : public DelayedUnaryIsometricOperationHelper<OutputValue_, InputValue_, Index_> {
public:
    std::optional<Index_> nrow() const {
        return std::nullopt;
    }
 
    std::optional<Index_> ncol() const {
        return std::nullopt;
    }
 
public:
    bool zero_depends_on_row() const {
        return false;
    }
 
    bool zero_depends_on_column() const {
        return false;
    }
 
    bool non_zero_depends_on_row() const {
        return false;
    }
 
    bool non_zero_depends_on_column() const {
        return false;
    }
 
private:
    void core(const InputValue_* input, const Index_ length, OutputValue_* const output) const {
        if constexpr(std::is_same<InputValue_, OutputValue_>::value) {
            input = output; // basically an assertion to the compiler to allow it to skip aliasing protection.
        }
        for (Index_ i = 0; i < length; ++i) {
            output[i] = std::abs(input[i]);
        }
    }
 
public:
    void dense(const bool, const Index_, const Index_, const Index_ length, const InputValue_* const input, OutputValue_* const output) const {
        core(input, length, output);
    }
 
    void dense(const bool, const Index_, const std::vector<Index_>& indices, const InputValue_* const input, OutputValue_* const output) const {
        core(input, indices.size(), output);
    }
 
public:
    bool is_sparse() const {
        return true;
    }
 
    void sparse(const bool, const Index_, const Index_ number, const InputValue_* const input, const Index_* const, OutputValue_* const output) const {
        core(input, number, output);
    }
 
    OutputValue_ fill(const bool, const Index_) const {
        return 0;
    }
};
 
template<typename OutputValue_, typename InputValue_, typename Index_>
class DelayedUnaryIsometricSignHelper final : public DelayedUnaryIsometricOperationHelper<OutputValue_, InputValue_, Index_> {
public:
    std::optional<Index_> nrow() const {
        return std::nullopt;
    }
 
    std::optional<Index_> ncol() const {
        return std::nullopt;
    }
 
public:
    bool zero_depends_on_row() const {
        return false;
    }
 
    bool zero_depends_on_column() const {
        return false;
    }
 
    bool non_zero_depends_on_row() const {
        return false;
    }
 
    bool non_zero_depends_on_column() const {
        return false;
    }
 
private:
    void core(const InputValue_* input, const Index_ length, OutputValue_* const output) const {
        if constexpr(std::is_same<InputValue_, OutputValue_>::value) {
            input = output; // basically an assertion to the compiler to allow it to skip aliasing protection.
        }
        for (Index_ i = 0; i < length; ++i) {
            auto val = input[i];
            if ([&]{
                if constexpr(std::numeric_limits<InputValue_>::has_quiet_NaN) {
                    return !std::isnan(val);
                } else {
                    return true;
                }
            }()) {
                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:
    void dense(const bool, const Index_, const Index_, const Index_ length, const InputValue_* const input, OutputValue_* const output) const {
        core(input, length, output);
    }
 
    void dense(const bool, const Index_, const std::vector<Index_>& indices, const InputValue_* const input, OutputValue_* const output) const {
        core(input, indices.size(), output);
    }
 
public:
    bool is_sparse() const {
        return true;
    }
 
    void sparse(const bool, const Index_, const Index_ number, const InputValue_* const input, const Index_* const, OutputValue_* const output) const {
        core(input, number, output);
    }
 
    OutputValue_ fill(const bool, const Index_) const {
        return 0;
    }
};
 
template<int base_, typename OutputValue_, typename InputValue_, typename Index_>
class DelayedUnaryIsometricFixedLogHelper final : public DelayedUnaryIsometricOperationHelper<OutputValue_, InputValue_, Index_> {
public:
    std::optional<Index_> nrow() const {
        return std::nullopt;
    }
 
    std::optional<Index_> ncol() const {
        return std::nullopt;
    }
 
public:
    bool zero_depends_on_row() const {
        return false;
    }
 
    bool zero_depends_on_column() const {
        return false;
    }
 
    bool non_zero_depends_on_row() const {
        return false;
    }
 
    bool non_zero_depends_on_column() const {
        return false;
    }
 
private:
    static auto logify(InputValue_ x) {
        if constexpr(base_ == 2) {
            return std::log2(x);
        } else if constexpr(base_ == 10) {
            return std::log10(x);
        } else {
            return std::log(x);
        }
    }
 
    void core(const InputValue_* input, const Index_ length, OutputValue_* const output) const {
        if constexpr(std::is_same<InputValue_, OutputValue_>::value) {
            input = output; // basically an assertion to the compiler to allow it to skip aliasing protection.
        }
        for (Index_ i = 0; i < length; ++i) {
            output[i] = logify(input[i]);
        }
    }
 
public:
    void dense(const bool, const Index_, const Index_, const Index_ length, const InputValue_* const input, OutputValue_* const output) const {
        core(input, length, output);
    }
 
    void dense(const bool, const Index_, const std::vector<Index_>& indices, const InputValue_* const input, OutputValue_* const output) const {
        core(input, indices.size(), output);
    }
 
public:
    bool is_sparse() const {
        return false;
    }
 
    void sparse(const bool, const Index_, const Index_ number, const InputValue_* const input, const Index_* const, OutputValue_* const output) const {
        core(input, number, output);
    }
 
    OutputValue_ fill(const bool, const Index_) const {
        // Use the implementation-defined value.
        return logify(0);
    }
};
template<typename OutputValue_, typename InputValue_, typename Index_>
using DelayedUnaryIsometricLogHelper = DelayedUnaryIsometricFixedLogHelper<-1, OutputValue_, InputValue_, Index_>;
 
template<typename OutputValue_, typename InputValue_, typename Index_>
using DelayedUnaryIsometricLog2Helper = DelayedUnaryIsometricFixedLogHelper<2, OutputValue_, InputValue_, Index_>;
 
template<typename OutputValue_, typename InputValue_, typename Index_>
using DelayedUnaryIsometricLog10Helper = DelayedUnaryIsometricFixedLogHelper<10, OutputValue_, InputValue_, Index_>;
 
template<typename OutputValue_, typename InputValue_, typename Index_, typename Base_>
class DelayedUnaryIsometricCustomLogHelper final : public DelayedUnaryIsometricOperationHelper<OutputValue_, InputValue_, Index_> {
public:
    DelayedUnaryIsometricCustomLogHelper(Base_ base) : my_base(std::log(base)) {}
 
public:
    std::optional<Index_> nrow() const {
        return std::nullopt;
    }
 
    std::optional<Index_> ncol() const {
        return std::nullopt;
    }
 
public:
    bool zero_depends_on_row() const {
        return false;
    }
 
    bool zero_depends_on_column() const {
        return false;
    }
 
    bool non_zero_depends_on_row() const {
        return false;
    }
 
    bool non_zero_depends_on_column() const {
        return false;
    }
 
private:
    Base_ my_base;
 
    void core(const InputValue_* input, const Index_ length, OutputValue_* const output) const {
        if constexpr(std::is_same<InputValue_, OutputValue_>::value) {
            input = output; // basically an assertion to the compiler to allow it to skip aliasing protection.
        }
        for (Index_ i = 0; i < length; ++i) {
            output[i] = std::log(input[i]) / my_base;
        }
    }
 
public:
    void dense(const bool, const Index_, const Index_, const Index_ length, const InputValue_* const input, OutputValue_* const output) const {
        core(input, length, output);
    }
 
    void dense(const bool, const Index_, const std::vector<Index_>& indices, const InputValue_* const input, OutputValue_* const output) const {
        core(input, indices.size(), output);
    }
 
public:
    bool is_sparse() const {
        return false;
    }
 
    void sparse(const bool, const Index_, const Index_ number, const InputValue_* const input, const Index_* const, OutputValue_* const output) const {
        core(input, number, output);
    }
 
    OutputValue_ fill(const bool, const Index_) const {
        // Use the implementation-defined value.
        return std::log(static_cast<InputValue_>(0)) / my_base;
    }
};
 
template<typename OutputValue_, typename InputValue_, typename Index_>
class DelayedUnaryIsometricSqrtHelper final : public DelayedUnaryIsometricOperationHelper<OutputValue_, InputValue_, Index_> {
public:
    std::optional<Index_> nrow() const {
        return std::nullopt;
    }
 
    std::optional<Index_> ncol() const {
        return std::nullopt;
    }
 
public:
    bool zero_depends_on_row() const {
        return false;
    }
 
    bool zero_depends_on_column() const {
        return false;
    }
 
    bool non_zero_depends_on_row() const {
        return false;
    }
 
    bool non_zero_depends_on_column() const {
        return false;
    }
 
private:
    void core(const InputValue_* input, const Index_ length, OutputValue_* const output) const {
        if constexpr(std::is_same<InputValue_, OutputValue_>::value) {
            input = output; // basically an assertion to the compiler to allow it to skip aliasing protection.
        }
        for (Index_ i = 0; i < length; ++i) {
            output[i] = std::sqrt(input[i]);
        }
    }
 
public:
    void dense(const bool, const Index_, const Index_, const Index_ length, const InputValue_* const input, OutputValue_* const output) const {
        core(input, length, output);
    }
 
    void dense(const bool, const Index_, const std::vector<Index_>& indices, const InputValue_* const input, OutputValue_* const output) const {
        core(input, indices.size(), output);
    }
 
public:
    bool is_sparse() const {
        return true;
    }
 
    void sparse(const bool, const Index_, const Index_ number, const InputValue_* const input, const Index_* const, OutputValue_* const output) const {
        core(input, number, output);
    }
 
    OutputValue_ fill(const bool, const Index_) const {
        return 0;
    }
};
 
template<typename OutputValue_, typename InputValue_, typename Index_>
class DelayedUnaryIsometricCeilingHelper final : public DelayedUnaryIsometricOperationHelper<OutputValue_, InputValue_, Index_> {
public:
    std::optional<Index_> nrow() const {
        return std::nullopt;
    }
 
    std::optional<Index_> ncol() const {
        return std::nullopt;
    }
 
public:
    bool zero_depends_on_row() const {
        return false;
    }
 
    bool zero_depends_on_column() const {
        return false;
    }
 
    bool non_zero_depends_on_row() const {
        return false;
    }
 
    bool non_zero_depends_on_column() const {
        return false;
    }
 
private:
    void core(const InputValue_* input, const Index_ length, OutputValue_* const output) const {
        if constexpr(std::is_same<InputValue_, OutputValue_>::value) {
            input = output; // basically an assertion to the compiler to allow it to skip aliasing protection.
        }
        for (Index_ i = 0; i < length; ++i) {
            output[i] = std::ceil(input[i]);
        }
    }
 
public:
    void dense(const bool, const Index_, const Index_, const Index_ length, const InputValue_* const input, OutputValue_* const output) const {
        core(input, length, output);
    }
 
    void dense(const bool, const Index_, const std::vector<Index_>& indices, const InputValue_* const input, OutputValue_* const output) const {
        core(input, indices.size(), output);
    }
 
public:
    bool is_sparse() const {
        return true;
    }
 
    void sparse(const bool, const Index_, const Index_ number, const InputValue_* const input, const Index_* const, OutputValue_* const output) const {
        core(input, number, output);
    }
 
    OutputValue_ fill(const bool, const Index_) const {
        return 0;
    }
};
 
template<typename OutputValue_, typename InputValue_, typename Index_>
class DelayedUnaryIsometricFloorHelper final : public DelayedUnaryIsometricOperationHelper<OutputValue_, InputValue_, Index_> {
public:
    std::optional<Index_> nrow() const {
        return std::nullopt;
    }
 
    std::optional<Index_> ncol() const {
        return std::nullopt;
    }
 
public:
    bool zero_depends_on_row() const {
        return false;
    }
 
    bool zero_depends_on_column() const {
        return false;
    }
 
    bool non_zero_depends_on_row() const {
        return false;
    }
 
    bool non_zero_depends_on_column() const {
        return false;
    }
 
private:
    void core(const InputValue_* input, const Index_ length, OutputValue_* const output) const {
        if constexpr(std::is_same<InputValue_, OutputValue_>::value) {
            input = output; // basically an assertion to the compiler to allow it to skip aliasing protection.
        }
        for (Index_ i = 0; i < length; ++i) {
            output[i] = std::floor(input[i]);
        }
    }
 
public:
    void dense(const bool, const Index_, const Index_, const Index_ length, const InputValue_* const input, OutputValue_* const output) const {
        core(input, length, output);
    }
 
    void dense(const bool, const Index_, const std::vector<Index_>& indices, const InputValue_* const input, OutputValue_* const output) const {
        core(input, indices.size(), output);
    }
 
public:
    bool is_sparse() const {
        return true;
    }
 
    void sparse(const bool, const Index_, const Index_ number, const InputValue_* const input, const Index_* const, OutputValue_* const output) const {
        core(input, number, output);
    }
 
    OutputValue_ fill(const bool, const Index_) const {
        return 0;
    }
};
 
template<typename OutputValue_, typename InputValue_, typename Index_>
class DelayedUnaryIsometricTruncHelper final : public DelayedUnaryIsometricOperationHelper<OutputValue_, InputValue_, Index_> {
public:
    std::optional<Index_> nrow() const {
        return std::nullopt;
    }
 
    std::optional<Index_> ncol() const {
        return std::nullopt;
    }
 
public:
    bool zero_depends_on_row() const {
        return false;
    }
 
    bool zero_depends_on_column() const {
        return false;
    }
 
    bool non_zero_depends_on_row() const {
        return false;
    }
 
    bool non_zero_depends_on_column() const {
        return false;
    }
 
private:
    void core(const InputValue_* input, const Index_ length, OutputValue_* const output) const {
        if constexpr(std::is_same<InputValue_, OutputValue_>::value) {
            input = output; // basically an assertion to the compiler to allow it to skip aliasing protection.
        }
        for (Index_ i = 0; i < length; ++i) {
            output[i] = std::trunc(input[i]);
        }
    }
 
public:
    void dense(const bool, const Index_, const Index_, const Index_ length, const InputValue_* const input, OutputValue_* const output) const {
        core(input, length, output);
    }
 
    void dense(const bool, const Index_, const std::vector<Index_>& indices, const InputValue_* const input, OutputValue_* const output) const {
        core(input, indices.size(), output);
    }
 
public:
    bool is_sparse() const {
        return true;
    }
 
    void sparse(const bool, const Index_, const Index_ number, const InputValue_* const input, const Index_* const, OutputValue_* const output) const {
        core(input, number, output);
    }
 
    OutputValue_ fill(const bool, const Index_) const {
        return 0;
    }
};
 
template<typename OutputValue_, typename InputValue_, typename Index_>
class DelayedUnaryIsometricLog1pHelper final : public DelayedUnaryIsometricOperationHelper<OutputValue_, InputValue_, Index_> {
public:
    std::optional<Index_> nrow() const {
        return std::nullopt;
    }
 
    std::optional<Index_> ncol() const {
        return std::nullopt;
    }
 
public:
    bool zero_depends_on_row() const {
        return false;
    }
 
    bool zero_depends_on_column() const {
        return false;
    }
 
    bool non_zero_depends_on_row() const {
        return false;
    }
 
    bool non_zero_depends_on_column() const {
        return false;
    }
 
private:
    void core(const InputValue_* input, const Index_ length, OutputValue_* const output) const {
        if constexpr(std::is_same<InputValue_, OutputValue_>::value) {
            input = output; // basically an assertion to the compiler to allow it to skip aliasing protection.
        }
        for (Index_ i = 0; i < length; ++i) {
            output[i] = std::log1p(input[i]); 
        }
    }
 
public:
    void dense(const bool, const Index_, const Index_, const Index_ length, const InputValue_* const input, OutputValue_* const output) const {
        core(input, length, output);
    }
 
    void dense(const bool, const Index_, const std::vector<Index_>& indices, const InputValue_* const input, OutputValue_* const output) const {
        core(input, indices.size(), output);
    }
 
public:
    bool is_sparse() const {
        return true;
    }
 
    void sparse(const bool, const Index_, const Index_ number, const InputValue_* const input, const Index_* const, OutputValue_* const output) const {
        core(input, number, output);
    }
 
    OutputValue_ fill(const bool, const Index_) const {
        return 0;
    }
};
 
template<typename OutputValue_, typename InputValue_, typename Index_>
class DelayedUnaryIsometricRoundHelper final : public DelayedUnaryIsometricOperationHelper<OutputValue_, InputValue_, Index_> {
public:
    std::optional<Index_> nrow() const {
        return std::nullopt;
    }
 
    std::optional<Index_> ncol() const {
        return std::nullopt;
    }
 
public:
    bool zero_depends_on_row() const {
        return false;
    }
 
    bool zero_depends_on_column() const {
        return false;
    }
 
    bool non_zero_depends_on_row() const {
        return false;
    }
 
    bool non_zero_depends_on_column() const {
        return false;
    }
 
private:
    void core(const InputValue_* input, const Index_ length, OutputValue_* const output) const {
        if constexpr(std::is_same<InputValue_, OutputValue_>::value) {
            input = output; // basically an assertion to the compiler to allow it to skip aliasing protection.
        }
        for (Index_ i = 0; i < length; ++i) {
            output[i] = std::round(input[i]);
        }
    }
 
public:
    void dense(const bool, const Index_, const Index_, const Index_ length, const InputValue_* const input, OutputValue_* const output) const {
        core(input, length, output);
    }
 
    void dense(const bool, const Index_, const std::vector<Index_>& indices, const InputValue_* const input, OutputValue_* const output) const {
        core(input, indices.size(), output);
    }
 
public:
    bool is_sparse() const {
        return true;
    }
 
    void sparse(const bool, const Index_, const Index_ number, const InputValue_* const input, const Index_* const, OutputValue_* const output) const {
        core(input, number, output);
    }
 
    OutputValue_ fill(const bool, const Index_) const {
        return 0;
    }
};
 
template<typename OutputValue_, typename InputValue_, typename Index_>
class DelayedUnaryIsometricExpHelper final : public DelayedUnaryIsometricOperationHelper<OutputValue_, InputValue_, Index_> {
public:
    std::optional<Index_> nrow() const {
        return std::nullopt;
    }
 
    std::optional<Index_> ncol() const {
        return std::nullopt;
    }
 
public:
    bool zero_depends_on_row() const {
        return false;
    }
 
    bool zero_depends_on_column() const {
        return false;
    }
 
    bool non_zero_depends_on_row() const {
        return false;
    }
 
    bool non_zero_depends_on_column() const {
        return false;
    }
 
private:
    void core(const InputValue_* input, const Index_ length, OutputValue_* const output) const {
        if constexpr(std::is_same<InputValue_, OutputValue_>::value) {
            input = output; // basically an assertion to the compiler to allow it to skip aliasing protection.
        }
        for (Index_ i = 0; i < length; ++i) {
            output[i] = std::exp(input[i]);
        }
    }
 
public:
    void dense(const bool, const Index_, const Index_, const Index_ length, const InputValue_* const input, OutputValue_* const output) const {
        core(input, length, output);
    }
 
    void dense(const bool, const Index_, const std::vector<Index_>& indices, const InputValue_* const input, OutputValue_* const output) const {
        core(input, indices.size(), output);
    }
 
public:
    bool is_sparse() const {
        return false;
    }
 
    void sparse(const bool, const Index_, const Index_ number, const InputValue_* const input, const Index_* const, OutputValue_* const output) const {
        core(input, number, output);
    }
 
    OutputValue_ fill(const bool, const Index_) const {
        return 1;
    }
};
 
template<typename OutputValue_, typename InputValue_, typename Index_>
class DelayedUnaryIsometricExpm1Helper final : public DelayedUnaryIsometricOperationHelper<OutputValue_, InputValue_, Index_> {
public:
    std::optional<Index_> nrow() const {
        return std::nullopt;
    }
 
    std::optional<Index_> ncol() const {
        return std::nullopt;
    }
 
public:
    bool zero_depends_on_row() const {
        return false;
    }
 
    bool zero_depends_on_column() const {
        return false;
    }
 
    bool non_zero_depends_on_row() const {
        return false;
    }
 
    bool non_zero_depends_on_column() const {
        return false;
    }
 
private:
    void core(const InputValue_* input, const Index_ length, OutputValue_* const output) const {
        if constexpr(std::is_same<InputValue_, OutputValue_>::value) {
            input = output; // basically an assertion to the compiler to allow it to skip aliasing protection.
        }
        for (Index_ i = 0; i < length; ++i) {
            output[i] = std::expm1(input[i]);
        }
    }
 
public:
    void dense(const bool, const Index_, const Index_, const Index_ length, const InputValue_* const input, OutputValue_* const output) const {
        core(input, length, output);
    }
 
    void dense(const bool, const Index_, const std::vector<Index_>& indices, const InputValue_* const input, OutputValue_* const output) const {
        core(input, indices.size(), output);
    }
 
public:
    bool is_sparse() const {
        return true;
    }
 
    void sparse(const bool, const Index_, const Index_ number, const InputValue_* const input, const Index_* const, OutputValue_* const output) const {
        core(input, number, output);
    }
 
    OutputValue_ fill(const bool, const Index_) const {
        return 0;
    }
};
 
template<typename OutputValue_, typename InputValue_, typename Index_>
class DelayedUnaryIsometricAcosHelper final : public DelayedUnaryIsometricOperationHelper<OutputValue_, InputValue_, Index_> {
public:
    std::optional<Index_> nrow() const {
        return std::nullopt;
    }
 
    std::optional<Index_> ncol() const {
        return std::nullopt;
    }
 
public:
    bool zero_depends_on_row() const {
        return false;
    }
 
    bool zero_depends_on_column() const {
        return false;
    }
 
    bool non_zero_depends_on_row() const {
        return false;
    }
 
    bool non_zero_depends_on_column() const {
        return false;
    }
 
private:
    void core(const InputValue_* input, const Index_ length, OutputValue_* const output) const {
        if constexpr(std::is_same<InputValue_, OutputValue_>::value) {
            input = output; // basically an assertion to the compiler to allow it to skip aliasing protection.
        }
        for (Index_ i = 0; i < length; ++i) {
            output[i] = std::acos(input[i]);
        }
    }
 
public:
    void dense(const bool, const Index_, const Index_, const Index_ length, const InputValue_* const input, OutputValue_* const output) const {
        core(input, length, output);
    }
 
    void dense(const bool, const Index_, const std::vector<Index_>& indices, const InputValue_* const input, OutputValue_* const output) const {
        core(input, indices.size(), output);
    }
 
public:
    bool is_sparse() const {
        return false;
    }
 
    void sparse(const bool, const Index_, const Index_ number, const InputValue_* const input, const Index_* const, OutputValue_* const output) const {
        core(input, number, output);
    }
 
    OutputValue_ fill(const bool, const Index_) const {
        // Use the implementation-defined special value.
        return std::acos(0);
    }
};
 
template<typename OutputValue_, typename InputValue_, typename Index_>
class DelayedUnaryIsometricAcoshHelper final : public DelayedUnaryIsometricOperationHelper<OutputValue_, InputValue_, Index_> {
public:
    std::optional<Index_> nrow() const {
        return std::nullopt;
    }
 
    std::optional<Index_> ncol() const {
        return std::nullopt;
    }
 
public:
    bool zero_depends_on_row() const {
        return false;
    }
 
    bool zero_depends_on_column() const {
        return false;
    }
 
    bool non_zero_depends_on_row() const {
        return false;
    }
 
    bool non_zero_depends_on_column() const {
        return false;
    }
 
private:
    void core(const InputValue_* input, const Index_ length, OutputValue_* const output) const {
        if constexpr(std::is_same<InputValue_, OutputValue_>::value) {
            input = output; // basically an assertion to the compiler to allow it to skip aliasing protection.
        }
        for (Index_ i = 0; i < length; ++i) {
            output[i] = std::acosh(input[i]);
        }
    }
 
public:
    void dense(const bool, const Index_, const Index_, const Index_ length, const InputValue_* const input, OutputValue_* const output) const {
        core(input, length, output);
    }
 
    void dense(const bool, const Index_, const std::vector<Index_>& indices, const InputValue_* const input, OutputValue_* const output) const {
        core(input, indices.size(), output);
    }
 
public:
    bool is_sparse() const {
        return false;
    }
 
    void sparse(const bool, const Index_, const Index_ number, const InputValue_* const input, const Index_* const, OutputValue_* const output) const {
        core(input, number, output);
    }
 
    OutputValue_ fill(const bool, const Index_) const {
        // Use the implementation-defined special value.
        return std::acosh(static_cast<InputValue_>(0));
    }
};
 
template<typename OutputValue_, typename InputValue_, typename Index_>
class DelayedUnaryIsometricAsinHelper final : public DelayedUnaryIsometricOperationHelper<OutputValue_, InputValue_, Index_>  {
public:
    std::optional<Index_> nrow() const {
        return std::nullopt;
    }
 
    std::optional<Index_> ncol() const {
        return std::nullopt;
    }
 
public:
    bool zero_depends_on_row() const {
        return false;
    }
 
    bool zero_depends_on_column() const {
        return false;
    }
 
    bool non_zero_depends_on_row() const {
        return false;
    }
 
    bool non_zero_depends_on_column() const {
        return false;
    }
 
private:
    void core(const InputValue_* input, const Index_ length, OutputValue_* const output) const {
        if constexpr(std::is_same<InputValue_, OutputValue_>::value) {
            input = output; // basically an assertion to the compiler to allow it to skip aliasing protection.
        }
        for (Index_ i = 0; i < length; ++i) {
            output[i] = std::asin(input[i]);
        }
    }
 
public:
    void dense(const bool, const Index_, const Index_, const Index_ length, const InputValue_* const input, OutputValue_* const output) const {
        core(input, length, output);
    }
 
    void dense(const bool, const Index_, const std::vector<Index_>& indices, const InputValue_* const input, OutputValue_* const output) const {
        core(input, indices.size(), output);
    }
 
public:
    bool is_sparse() const {
        return true;
    }
 
    void sparse(const bool, const Index_, const Index_ number, const InputValue_* const input, const Index_* const, OutputValue_* const output) const {
        core(input, number, output);
    }
 
    OutputValue_ fill(const bool, const Index_) const {
        return 0;
    }
};
 
template<typename OutputValue_, typename InputValue_, typename Index_>
class DelayedUnaryIsometricAsinhHelper final : public DelayedUnaryIsometricOperationHelper<OutputValue_, InputValue_, Index_> {
public:
    std::optional<Index_> nrow() const {
        return std::nullopt;
    }
 
    std::optional<Index_> ncol() const {
        return std::nullopt;
    }
 
public:
    bool zero_depends_on_row() const {
        return false;
    }
 
    bool zero_depends_on_column() const {
        return false;
    }
 
    bool non_zero_depends_on_row() const {
        return false;
    }
 
    bool non_zero_depends_on_column() const {
        return false;
    }
 
private:
    void core(const InputValue_* input, const Index_ length, OutputValue_* const output) const {
        if constexpr(std::is_same<InputValue_, OutputValue_>::value) {
            input = output; // basically an assertion to the compiler to allow it to skip aliasing protection.
        }
        for (Index_ i = 0; i < length; ++i) {
            output[i] = std::asinh(input[i]);
        }
    }
 
public:
    void dense(const bool, const Index_, const Index_, const Index_ length, const InputValue_* const input, OutputValue_* const output) const {
        core(input, length, output);
    }
 
    void dense(const bool, const Index_, const std::vector<Index_>& indices, const InputValue_* const input, OutputValue_* const output) const {
        core(input, indices.size(), output);
    }
 
public:
    bool is_sparse() const {
        return true;
    }
 
    void sparse(const bool, const Index_, const Index_ number, const InputValue_* const input, const Index_* const, OutputValue_* const output) const {
        core(input, number, output);
    }
 
    OutputValue_ fill(const bool, const Index_) const {
        return 0;
    }
};
 
template<typename OutputValue_, typename InputValue_, typename Index_>
class DelayedUnaryIsometricAtanHelper final : public DelayedUnaryIsometricOperationHelper<OutputValue_, InputValue_, Index_> {
public:
    std::optional<Index_> nrow() const {
        return std::nullopt;
    }
 
    std::optional<Index_> ncol() const {
        return std::nullopt;
    }
 
public:
    bool zero_depends_on_row() const {
        return false;
    }
 
    bool zero_depends_on_column() const {
        return false;
    }
 
    bool non_zero_depends_on_row() const {
        return false;
    }
 
    bool non_zero_depends_on_column() const {
        return false;
    }
 
private:
    void core(const InputValue_* input, const Index_ length, OutputValue_* const output) const {
        if constexpr(std::is_same<InputValue_, OutputValue_>::value) {
            input = output; // basically an assertion to the compiler to allow it to skip aliasing protection.
        }
        for (Index_ i = 0; i < length; ++i) {
            output[i] = std::atan(input[i]);
        }
    }
 
public:
    void dense(const bool, const Index_, const Index_, const Index_ length, const InputValue_* const input, OutputValue_* const output) const {
        core(input, length, output);
    }
 
    void dense(const bool, const Index_, const std::vector<Index_>& indices, const InputValue_* const input, OutputValue_* const output) const {
        core(input, indices.size(), output);
    }
 
public:
    bool is_sparse() const {
        return true;
    }
 
    void sparse(const bool, const Index_, const Index_ number, const InputValue_* const input, const Index_* const, OutputValue_* const output) const {
        core(input, number, output);
    }
 
    OutputValue_ fill(const bool, const Index_) const {
        return 0;
    }
};
 
template<typename OutputValue_, typename InputValue_, typename Index_>
class DelayedUnaryIsometricAtanhHelper final : public DelayedUnaryIsometricOperationHelper<OutputValue_, InputValue_, Index_> {
public:
    std::optional<Index_> nrow() const {
        return std::nullopt;
    }
 
    std::optional<Index_> ncol() const {
        return std::nullopt;
    }
 
public:
    bool zero_depends_on_row() const {
        return false;
    }
 
    bool zero_depends_on_column() const {
        return false;
    }
 
    bool non_zero_depends_on_row() const {
        return false;
    }
 
    bool non_zero_depends_on_column() const {
        return false;
    }
 
private:
    void core(const InputValue_* input, const Index_ length, OutputValue_* const output) const {
        if constexpr(std::is_same<InputValue_, OutputValue_>::value) {
            input = output; // basically an assertion to the compiler to allow it to skip aliasing protection.
        }
        for (Index_ i = 0; i < length; ++i) {
            output[i] = std::atanh(input[i]);
        }
    }
 
public:
    void dense(const bool, const Index_, const Index_, const Index_ length, const InputValue_* const input, OutputValue_* const output) const {
        core(input, length, output);
    }
 
    void dense(const bool, const Index_, const std::vector<Index_>& indices, const InputValue_* const input, OutputValue_* const output) const {
        core(input, indices.size(), output);
    }
 
public:
    bool is_sparse() const {
        return true;
    }
 
    void sparse(const bool, const Index_, const Index_ number, const InputValue_* const input, const Index_* const, OutputValue_* const output) const {
        core(input, number, output);
    }
 
    OutputValue_ fill(const bool, const Index_) const {
        return 0;
    }
};
 
template<typename OutputValue_, typename InputValue_, typename Index_>
class DelayedUnaryIsometricCosHelper final : public DelayedUnaryIsometricOperationHelper<OutputValue_, InputValue_, Index_> {
public:
    std::optional<Index_> nrow() const {
        return std::nullopt;
    }
 
    std::optional<Index_> ncol() const {
        return std::nullopt;
    }
 
public:
    bool zero_depends_on_row() const {
        return false;
    }
 
    bool zero_depends_on_column() const {
        return false;
    }
 
    bool non_zero_depends_on_row() const {
        return false;
    }
 
    bool non_zero_depends_on_column() const {
        return false;
    }
 
private:
    void core(const InputValue_* input, const Index_ length, OutputValue_* const output) const {
        if constexpr(std::is_same<InputValue_, OutputValue_>::value) {
            input = output; // basically an assertion to the compiler to allow it to skip aliasing protection.
        }
        for (Index_ i = 0; i < length; ++i) {
            output[i] = std::cos(input[i]);
        }
    }
 
public:
    void dense(const bool, const Index_, const Index_, const Index_ length, const InputValue_* const input, OutputValue_* const output) const {
        core(input, length, output);
    }
 
    void dense(const bool, const Index_, const std::vector<Index_>& indices, const InputValue_* const input, OutputValue_* const output) const {
        core(input, indices.size(), output);
    }
 
public:
    bool is_sparse() const {
        return false;
    }
 
    void sparse(const bool, const Index_, const Index_ number, const InputValue_* const input, const Index_* const, OutputValue_* const output) const {
        core(input, number, output);
    }
 
    OutputValue_ fill(const bool, const Index_) const {
        return 1;
    }
};
 
template<typename OutputValue_, typename InputValue_, typename Index_>
class DelayedUnaryIsometricCoshHelper final : public DelayedUnaryIsometricOperationHelper<OutputValue_, InputValue_, Index_> {
public:
    std::optional<Index_> nrow() const {
        return std::nullopt;
    }
 
    std::optional<Index_> ncol() const {
        return std::nullopt;
    }
 
public:
    bool zero_depends_on_row() const {
        return false;
    }
 
    bool zero_depends_on_column() const {
        return false;
    }
 
    bool non_zero_depends_on_row() const {
        return false;
    }
 
    bool non_zero_depends_on_column() const {
        return false;
    }
 
private:
    void core(const InputValue_* input, const Index_ length, OutputValue_* const output) const {
        if constexpr(std::is_same<InputValue_, OutputValue_>::value) {
            input = output; // basically an assertion to the compiler to allow it to skip aliasing protection.
        }
        for (Index_ i = 0; i < length; ++i) {
            output[i] = std::cosh(input[i]);
        }
    }
 
public:
    void dense(const bool, const Index_, const Index_, const Index_ length, const InputValue_* const input, OutputValue_* const output) const {
        core(input, length, output);
    }
 
    void dense(const bool, const Index_, const std::vector<Index_>& indices, const InputValue_* const input, OutputValue_* const output) const {
        core(input, indices.size(), output);
    }
 
public:
    bool is_sparse() const {
        return false;
    }
 
    void sparse(const bool, const Index_, const Index_ number, const InputValue_* const input, const Index_* const, OutputValue_* const output) const {
        core(input, number, output);
    }
 
    OutputValue_ fill(const bool, const Index_) const {
        return 1;
    }
};
 
template<typename OutputValue_, typename InputValue_, typename Index_>
class DelayedUnaryIsometricSinHelper final : public DelayedUnaryIsometricOperationHelper<OutputValue_, InputValue_, Index_> {
public:
    std::optional<Index_> nrow() const {
        return std::nullopt;
    }
 
    std::optional<Index_> ncol() const {
        return std::nullopt;
    }
 
public:
    bool zero_depends_on_row() const {
        return false;
    }
 
    bool zero_depends_on_column() const {
        return false;
    }
 
    bool non_zero_depends_on_row() const {
        return false;
    }
 
    bool non_zero_depends_on_column() const {
        return false;
    }
 
private:
    void core(const InputValue_* input, const Index_ length, OutputValue_* const output) const {
        if constexpr(std::is_same<InputValue_, OutputValue_>::value) {
            input = output; // basically an assertion to the compiler to allow it to skip aliasing protection.
        }
        for (Index_ i = 0; i < length; ++i) {
            output[i] = std::sin(input[i]);
        }
    }
 
public:
    void dense(const bool, const Index_, const Index_, const Index_ length, const InputValue_* const input, OutputValue_* const output) const {
        core(input, length, output);
    }
 
    void dense(const bool, const Index_, const std::vector<Index_>& indices, const InputValue_* const input, OutputValue_* const output) const {
        core(input, indices.size(), output);
    }
 
public:
    bool is_sparse() const {
        return true;
    }
 
    void sparse(const bool, const Index_, const Index_ number, const InputValue_* const input, const Index_* const, OutputValue_* const output) const {
        core(input, number, output);
    }
 
    OutputValue_ fill(const bool, const Index_) const {
        return 0;
    }
};
 
template<typename OutputValue_, typename InputValue_, typename Index_>
class DelayedUnaryIsometricSinhHelper final : public DelayedUnaryIsometricOperationHelper<OutputValue_, InputValue_, Index_> {
public:
    std::optional<Index_> nrow() const {
        return std::nullopt;
    }
 
    std::optional<Index_> ncol() const {
        return std::nullopt;
    }
 
public:
    bool zero_depends_on_row() const {
        return false;
    }
 
    bool zero_depends_on_column() const {
        return false;
    }
 
    bool non_zero_depends_on_row() const {
        return false;
    }
 
    bool non_zero_depends_on_column() const {
        return false;
    }
 
private:
    void core(const InputValue_* input, const Index_ length, OutputValue_* const output) const {
        if constexpr(std::is_same<InputValue_, OutputValue_>::value) {
            input = output; // basically an assertion to the compiler to allow it to skip aliasing protection.
        }
        for (Index_ i = 0; i < length; ++i) {
            output[i] = std::sinh(input[i]);
        }
    }
 
public:
    void dense(const bool, const Index_, const Index_, const Index_ length, const InputValue_* const input, OutputValue_* const output) const {
        core(input, length, output);
    }
 
    void dense(const bool, const Index_, const std::vector<Index_>& indices, const InputValue_* const input, OutputValue_* const output) const {
        core(input, indices.size(), output);
    }
 
public:
    bool is_sparse() const {
        return true;
    }
 
    void sparse(const bool, const Index_, const Index_ number, const InputValue_* const input, const Index_* const, OutputValue_* const output) const {
        core(input, number, output);
    }
 
    OutputValue_ fill(const bool, const Index_) const {
        return 0;
    }
};
 
template<typename OutputValue_, typename InputValue_, typename Index_>
class DelayedUnaryIsometricTanHelper final : public DelayedUnaryIsometricOperationHelper<OutputValue_, InputValue_, Index_> {
public:
    std::optional<Index_> nrow() const {
        return std::nullopt;
    }
 
    std::optional<Index_> ncol() const {
        return std::nullopt;
    }
 
public:
    bool zero_depends_on_row() const {
        return false;
    }
 
    bool zero_depends_on_column() const {
        return false;
    }
 
    bool non_zero_depends_on_row() const {
        return false;
    }
 
    bool non_zero_depends_on_column() const {
        return false;
    }
 
private:
    void core(const InputValue_* input, const Index_ length, OutputValue_* const output) const {
        if constexpr(std::is_same<InputValue_, OutputValue_>::value) {
            input = output; // basically an assertion to the compiler to allow it to skip aliasing protection.
        }
        for (Index_ i = 0; i < length; ++i) {
            output[i] = std::tan(input[i]);
        }
    }
 
public:
    void dense(const bool, const Index_, const Index_, const Index_ length, const InputValue_* const input, OutputValue_* const output) const {
        core(input, length, output);
    }
 
    void dense(const bool, const Index_, const std::vector<Index_>& indices, const InputValue_* const input, OutputValue_* const output) const {
        core(input, indices.size(), output);
    }
 
public:
    bool is_sparse() const {
        return true;
    }
 
    void sparse(const bool, const Index_, const Index_ number, const InputValue_* const input, const Index_* const, OutputValue_* const output) const {
        core(input, number, output);
    }
 
    OutputValue_ fill(const bool, const Index_) const {
        return 0;
    }
};
 
template<typename OutputValue_, typename InputValue_, typename Index_>
class DelayedUnaryIsometricTanhHelper final : public DelayedUnaryIsometricOperationHelper<OutputValue_, InputValue_, Index_> {
public:
    std::optional<Index_> nrow() const {
        return std::nullopt;
    }
 
    std::optional<Index_> ncol() const {
        return std::nullopt;
    }
 
public:
    bool zero_depends_on_row() const {
        return false;
    }
 
    bool zero_depends_on_column() const {
        return false;
    }
 
    bool non_zero_depends_on_row() const {
        return false;
    }
 
    bool non_zero_depends_on_column() const {
        return false;
    }
 
private:
    void core(const InputValue_* input, const Index_ length, OutputValue_* const output) const {
        if constexpr(std::is_same<InputValue_, OutputValue_>::value) {
            input = output; // basically an assertion to the compiler to allow it to skip aliasing protection.
        }
        for (Index_ i = 0; i < length; ++i) {
            output[i] = std::tanh(input[i]);
        }
    }
 
public:
    void dense(const bool, const Index_, const Index_, const Index_ length, const InputValue_* const input, OutputValue_* const output) const {
        core(input, length, output);
    }
 
    void dense(const bool, const Index_, const std::vector<Index_>& indices, const InputValue_* const input, OutputValue_* const output) const {
        core(input, indices.size(), output);
    }
 
public:
    bool is_sparse() const {
        return true;
    }
 
    void sparse(const bool, const Index_, const Index_ number, const InputValue_* const input, const Index_* const, OutputValue_* const output) const {
        core(input, number, output);
    }
 
    OutputValue_ fill(const bool, const Index_) const {
        return 0;
    }
};
 
template<typename OutputValue_, typename InputValue_, typename Index_>
class DelayedUnaryIsometricGammaHelper final : public DelayedUnaryIsometricOperationHelper<OutputValue_, InputValue_, Index_> {
public:
    std::optional<Index_> nrow() const {
        return std::nullopt;
    }
 
    std::optional<Index_> ncol() const {
        return std::nullopt;
    }
 
public:
    bool zero_depends_on_row() const {
        return false;
    }
 
    bool zero_depends_on_column() const {
        return false;
    }
 
    bool non_zero_depends_on_row() const {
        return false;
    }
 
    bool non_zero_depends_on_column() const {
        return false;
    }
 
private:
    void core(const InputValue_* input, const Index_ length, OutputValue_* const output) const {
        if constexpr(std::is_same<InputValue_, OutputValue_>::value) {
            input = output; // basically an assertion to the compiler to allow it to skip aliasing protection.
        }
        for (Index_ i = 0; i < length; ++i) {
            output[i] = std::tgamma(input[i]);
        }
    }
 
public:
    void dense(const bool, const Index_, const Index_, const Index_ length, const InputValue_* const input, OutputValue_* const output) const {
        core(input, length, output);
    }
 
    void dense(const bool, const Index_, const std::vector<Index_>& indices, const InputValue_* const input, OutputValue_* const output) const {
        core(input, indices.size(), output);
    }
 
public:
    bool is_sparse() const {
        return false;
    }
 
    void sparse(const bool, const Index_, const Index_ number, const InputValue_* const input, const Index_* const, OutputValue_* const output) const {
        core(input, number, output);
    }
 
    OutputValue_ fill(const bool, const Index_) const {
        // Use the implementation-defined special value.
        return std::tgamma(static_cast<InputValue_>(0));
    }
};
 
template<typename OutputValue_, typename InputValue_, typename Index_>
class DelayedUnaryIsometricLgammaHelper final : public DelayedUnaryIsometricOperationHelper<OutputValue_, InputValue_, Index_> {
public:
    std::optional<Index_> nrow() const {
        return std::nullopt;
    }
 
    std::optional<Index_> ncol() const {
        return std::nullopt;
    }
 
public:
    bool zero_depends_on_row() const {
        return false;
    }
 
    bool zero_depends_on_column() const {
        return false;
    }
 
    bool non_zero_depends_on_row() const {
        return false;
    }
 
    bool non_zero_depends_on_column() const {
        return false;
    }
 
private:
    void core(const InputValue_* input, const Index_ length, OutputValue_* const output) const {
        if constexpr(std::is_same<InputValue_, OutputValue_>::value) {
            input = output; // basically an assertion to the compiler to allow it to skip aliasing protection.
        }
        for (Index_ i = 0; i < length; ++i) {
            output[i] = std::lgamma(input[i]);
        }
    }
 
public:
    void dense(const bool, const Index_, const Index_, const Index_ length, const InputValue_* const input, OutputValue_* const output) const {
        core(input, length, output);
    }
 
    void dense(const bool, const Index_, const std::vector<Index_>& indices, const InputValue_* const input, OutputValue_* const output) const {
        core(input, indices.size(), output);
    }
 
public:
    bool is_sparse() const {
        return false;
    }
 
    void sparse(const bool, const Index_, const Index_ number, const InputValue_* const input, const Index_* const, OutputValue_* const output) const {
        core(input, number, output);
    }
 
    OutputValue_ fill(const bool, const Index_) const {
        // Use the implementation-defined special value.
        return std::lgamma(static_cast<InputValue_>(0));
    }
};
 
// Back-compatibility only.
template<typename OutputValue_ = double, typename InputValue_ = double, typename Index_ = int> 
using DelayedUnaryIsometricAbs = DelayedUnaryIsometricAbsHelper<OutputValue_, InputValue_, Index_>;
 
template<typename OutputValue_ = double, typename InputValue_ = double, typename Index_ = int> 
using DelayedUnaryIsometricSign = DelayedUnaryIsometricSignHelper<OutputValue_, InputValue_, Index_>;
 
template<typename OutputValue_ = double, typename InputValue_ = double, typename Index_ = int, typename Base_ = InputValue_> 
using DelayedUnaryIsometricLog = DelayedUnaryIsometricCustomLogHelper<OutputValue_, InputValue_, Index_, Base_>;
 
template<typename OutputValue_ = double, typename InputValue_ = double, typename Index_ = int> 
using DelayedUnaryIsometricSqrt = DelayedUnaryIsometricSqrtHelper<OutputValue_, InputValue_, Index_>;
 
template<typename OutputValue_ = double, typename InputValue_ = double, typename Index_ = int> 
using DelayedUnaryIsometricCeiling = DelayedUnaryIsometricCeilingHelper<OutputValue_, InputValue_, Index_>;
 
template<typename OutputValue_ = double, typename InputValue_ = double, typename Index_ = int> 
using DelayedUnaryIsometricFloor = DelayedUnaryIsometricFloorHelper<OutputValue_, InputValue_, Index_>;
 
template<typename OutputValue_ = double, typename InputValue_ = double, typename Index_ = int> 
using DelayedUnaryIsometricTrunc = DelayedUnaryIsometricTruncHelper<OutputValue_, InputValue_, Index_>;
 
template<typename OutputValue_ = double, typename InputValue_ = double, typename Index_ = int, typename Base_ = InputValue_> 
using DelayedUnaryIsometricLog1p = DelayedUnaryIsometricLog1pHelper<OutputValue_, InputValue_, Index_>;
 
template<typename OutputValue_ = double, typename InputValue_ = double, typename Index_ = int> 
using DelayedUnaryIsometricRound = DelayedUnaryIsometricRoundHelper<OutputValue_, InputValue_, Index_>;
 
template<typename OutputValue_ = double, typename InputValue_ = double, typename Index_ = int> 
using DelayedUnaryIsometricExp = DelayedUnaryIsometricExpHelper<OutputValue_, InputValue_, Index_>;
 
template<typename OutputValue_ = double, typename InputValue_ = double, typename Index_ = int> 
using DelayedUnaryIsometricExpm1 = DelayedUnaryIsometricExpm1Helper<OutputValue_, InputValue_, Index_>;
 
template<typename OutputValue_ = double, typename InputValue_ = double, typename Index_ = int> 
using DelayedUnaryIsometricAcos = DelayedUnaryIsometricAcosHelper<OutputValue_, InputValue_, Index_>;
 
template<typename OutputValue_ = double, typename InputValue_ = double, typename Index_ = int> 
using DelayedUnaryIsometricAcosh = DelayedUnaryIsometricAcoshHelper<OutputValue_, InputValue_, Index_>;
 
template<typename OutputValue_ = double, typename InputValue_ = double, typename Index_ = int> 
using DelayedUnaryIsometricAsin = DelayedUnaryIsometricAsinHelper<OutputValue_, InputValue_, Index_>;
 
template<typename OutputValue_ = double, typename InputValue_ = double, typename Index_ = int> 
using DelayedUnaryIsometricAsinh = DelayedUnaryIsometricAsinhHelper<OutputValue_, InputValue_, Index_>;
 
template<typename OutputValue_ = double, typename InputValue_ = double, typename Index_ = int> 
using DelayedUnaryIsometricAtan = DelayedUnaryIsometricAtanHelper<OutputValue_, InputValue_, Index_>;
 
template<typename OutputValue_ = double, typename InputValue_ = double, typename Index_ = int> 
using DelayedUnaryIsometricAtanh = DelayedUnaryIsometricAtanhHelper<OutputValue_, InputValue_, Index_>;
 
template<typename OutputValue_ = double, typename InputValue_ = double, typename Index_ = int> 
using DelayedUnaryIsometricCos = DelayedUnaryIsometricCosHelper<OutputValue_, InputValue_, Index_>;
 
template<typename OutputValue_ = double, typename InputValue_ = double, typename Index_ = int> 
using DelayedUnaryIsometricCosh = DelayedUnaryIsometricCoshHelper<OutputValue_, InputValue_, Index_>;
 
template<typename OutputValue_ = double, typename InputValue_ = double, typename Index_ = int> 
using DelayedUnaryIsometricSin = DelayedUnaryIsometricSinHelper<OutputValue_, InputValue_, Index_>;
 
template<typename OutputValue_ = double, typename InputValue_ = double, typename Index_ = int> 
using DelayedUnaryIsometricSinh = DelayedUnaryIsometricSinhHelper<OutputValue_, InputValue_, Index_>;
 
template<typename OutputValue_ = double, typename InputValue_ = double, typename Index_ = int> 
using DelayedUnaryIsometricTan = DelayedUnaryIsometricTanHelper<OutputValue_, InputValue_, Index_>;
 
template<typename OutputValue_ = double, typename InputValue_ = double, typename Index_ = int> 
using DelayedUnaryIsometricTanh = DelayedUnaryIsometricTanhHelper<OutputValue_, InputValue_, Index_>;
 
template<typename OutputValue_ = double, typename InputValue_ = double, typename Index_ = int> 
using DelayedUnaryIsometricGamma = DelayedUnaryIsometricGammaHelper<OutputValue_, InputValue_, Index_>;
 
template<typename OutputValue_ = double, typename InputValue_ = double, typename Index_ = int> 
using DelayedUnaryIsometricLgamma = DelayedUnaryIsometricLgammaHelper<OutputValue_, InputValue_, Index_>;
}
 
#endif