dim_testable.hpp

//=======================================================================
// Copyright (c) 2014-2023 Baptiste Wicht
// Distributed under the terms of the MIT License.
// (See accompanying file LICENSE or copy at
//  http://opensource.org/licenses/MIT)
//=======================================================================

/*
 * \file dim_testable.hpp
 * \brief Use CRTP technique to inject functions that test the dimensions.
 */

#pragma once

namespace etl {

template <typename E>
bool is_symmetric(E&& expr);

template <typename E>
bool is_triangular(E&& expr);

template <typename E>
bool is_lower_triangular(E&& expr);

template <typename E>
bool is_upper_triangular(E&& expr);

template <typename E>
bool is_strictly_lower_triangular(E&& expr);

template <typename E>
bool is_strictly_upper_triangular(E&& expr);

template <typename E>
bool is_uni_lower_triangular(E&& expr);

template <typename E>
bool is_uni_upper_triangular(E&& expr);

template <typename D>
struct dim_testable {
    using derived_t = D; 

    derived_t& as_derived() noexcept {
        return *static_cast<derived_t*>(this);
    }

    const derived_t& as_derived() const noexcept {
        return *static_cast<const derived_t*>(this);
    }

    bool is_square() const noexcept {
        return etl::is_square(as_derived());
    }

    bool is_rectangular() const noexcept {
        return etl::is_rectangular(as_derived());
    }

    bool is_sub_square() const noexcept {
        return etl::is_sub_square(as_derived());
    }

    bool is_sub_rectangular() const noexcept {
        return etl::is_sub_rectangular(as_derived());
    }

    bool is_symmetric() const noexcept {
        return etl::is_symmetric(as_derived());
    }

    bool is_lower_triangular() const noexcept {
        return etl::is_lower_triangular(as_derived());
    }

    bool is_uni_lower_triangular() const noexcept {
        return etl::is_uni_lower_triangular(as_derived());
    }

    bool is_strictly_lower_triangular() const noexcept {
        return etl::is_strictly_lower_triangular(as_derived());
    }

    bool is_upper_triangular() const noexcept {
        return etl::is_upper_triangular(as_derived());
    }

    bool is_uni_upper_triangular() const noexcept {
        return etl::is_uni_upper_triangular(as_derived());
    }

    bool is_strictly_upper_triangular() const noexcept {
        return etl::is_strictly_upper_triangular(as_derived());
    }

    bool is_triangular() const noexcept {
        return etl::is_triangular(as_derived());
    }
};

} //end of namespace etl