size_checking.h

Go to the documentation of this file.

/* -*- C++ -*- ------------------------------------------------------------
 
Copyright (c) 2007 Jesse Anders and Demian Nave http://cmldev.net/

The Configurable Math Library (CML) is distributed under the terms of the
Boost Software License, v1.0 (see cml/LICENSE for details).

 *-----------------------------------------------------------------------*/
#ifndef size_checking_h
#define size_checking_h

#include <stdexcept>
#include <cml/core/cml_meta.h>
#include <cml/core/cml_assert.h>
#include <cml/core/fwd.h>
#include <cml/et/traits.h>

#if defined(_MSC_VER) && _MSC_VER < 1400
#pragma warning(push)
#pragma warning(disable:4348)
// XXX This is a terrible hack for VC7.1, and should really be fixed by
// separating out the "impl" templates from GetCheckedSize.
#endif

/* This is used below to create a more meaningful compile-time error when
 * fixed-size vector arguments don't match at compile time:
 */
struct incompatible_expression_size_error;

/* This is used below to create a more meaningful compile-time error when a
 * function is not provided with a square matrix or MatrixExpr argument:
 */
struct square_matrix_arg_expected_error;

namespace cml {
namespace et {
namespace detail {

} // namespace detail

/* Forward declare for specialization below: */
template<typename LeftT, typename RightT, typename SizeT>
    struct GetCheckedSize;

/* Checking for fixed-size expression: */
template<typename LeftT, typename RightT>
struct GetCheckedSize<LeftT,RightT,fixed_size_tag>
{
    /* Record argument traits: */
    typedef ExprTraits<LeftT> left_traits;
    typedef ExprTraits<RightT> right_traits;

    /* Result types: */
    typedef typename left_traits::result_tag left_result;
    typedef typename right_traits::result_tag right_result;


    /* For specialization below: */
    template<typename LR, typename RR, class X = void> struct impl;

    /* Check for two matrices (linear operators only): */
    template<class X> struct impl<matrix_result_tag,matrix_result_tag,X> {
        typedef matrix_size size_type;
        CML_STATIC_REQUIRE_M(
                (size_t)LeftT::array_rows == (size_t)RightT::array_rows
                && (size_t)LeftT::array_cols == (size_t)RightT::array_cols,
                incompatible_expression_size_error);

        /* Record the array size as a constant: */
        enum {
            array_rows = LeftT::array_rows,
            array_cols = LeftT::array_cols
        };

        /* Return the matrix size: */
        size_type size() const { return size_type(array_rows,array_cols); }
    };

    /* Check for a matrix and a vector: */
    template<class X> struct impl<matrix_result_tag,vector_result_tag,X> {
        typedef size_t size_type;
        CML_STATIC_REQUIRE_M(
                (size_t)LeftT::array_cols == (size_t)RightT::array_size,
                incompatible_expression_size_error);

        /* Record the array size as a constant: */
        enum { array_size = LeftT::array_rows };

        /* Return the vector size: */
        size_type size() const { return size_type(array_size); }
    };

    /* Check for a vector and a matrix: */
    template<class X> struct impl<vector_result_tag,matrix_result_tag,X> {
        typedef size_t size_type;
        CML_STATIC_REQUIRE_M(
                (size_t)LeftT::array_size == (size_t)RightT::array_rows,
                incompatible_expression_size_error);

        /* Record the array size as a constant: */
        enum { array_size = RightT::array_cols };

        /* Return the vector size: */
        size_type size() const { return size_type(array_size); }
    };

    /* Check for a matrix and a scalar: */
    template<class X> struct impl<matrix_result_tag,scalar_result_tag,X> {
        typedef matrix_size size_type;

        /* Record the array size as a constant: */
        enum {
            array_rows = LeftT::array_rows,
            array_cols = LeftT::array_cols
        };

        /* Return the matrix size: */
        size_type size() const { return size_type(array_rows,array_cols); }
    };

    /* Check for a scalar and a matrix: */
    template<class X> struct impl<scalar_result_tag,matrix_result_tag,X> {
        typedef matrix_size size_type;

        /* Record the array size as a constant: */
        enum {
            array_rows = RightT::array_rows,
            array_cols = RightT::array_cols
        };

        /* Return the matrix size: */
        size_type size() const { return size_type(array_rows,array_cols); }
    };


    /* Check for two vectors: */
    template<class X> struct impl<vector_result_tag,vector_result_tag,X> {
        typedef size_t size_type;
        CML_STATIC_REQUIRE_M(
                (size_t)LeftT::array_size == (size_t)RightT::array_size,
                incompatible_expression_size_error);

        /* Record the array size as a constant: */
        enum { array_size = LeftT::array_size };

        /* Return the vector size: */
        size_type size() const { return size_type(array_size); }
    };

    /* Check for a vector and a scalar: */
    template<class X> struct impl<vector_result_tag,scalar_result_tag,X> {
        typedef size_t size_type;

        /* Record the array size as a constant: */
        enum { array_size = LeftT::array_size };

        /* Return the vector size: */
        size_type size() const { return size_type(array_size); }
    };

    /* Check for a scalar and a vector: */
    template<class X> struct impl<scalar_result_tag,vector_result_tag,X> {
        typedef size_t size_type;

        /* Record the array size as a constant: */
        enum { array_size = RightT::array_size };

        /* Return the vector size: */
        size_type size() const { return size_type(array_size); }
    };


    /* Check for two quaternions: */
    template<class X>
    struct impl<quaternion_result_tag,quaternion_result_tag,X> {
        typedef size_t size_type;

        /* Record the quaternion size as a constant: */
        enum { array_size = 4 };

        /* Return the quaternion size: */
        size_type size() const { return size_type(array_size); }
    };

    /* Check for a quaternion and a vector: */
    template<class X> struct impl<quaternion_result_tag,vector_result_tag,X> {
        typedef size_t size_type;
        CML_STATIC_REQUIRE_M(
                RightT::array_size == 4,
                incompatible_expression_size_error);

        /* Record the quaternion size as a constant: */
        enum { array_size = 4 };

        /* Return the quaternion size: */
        size_type size() const { return size_type(array_size); }
    };

    /* Check for a vector and a quaternion: */
    template<class X> struct impl<vector_result_tag,quaternion_result_tag,X> {
        typedef size_t size_type;
        CML_STATIC_REQUIRE_M(
                LeftT::array_size == 4,
                incompatible_expression_size_error);

        /* Record the quaternion size as a constant: */
        enum { array_size = 4 };

        /* Return the quaternion size: */
        size_type size() const { return size_type(array_size); }
    };

    /* Check for a quaternion and a scalar: */
    template<class X> struct impl<quaternion_result_tag,scalar_result_tag,X> {
        typedef size_t size_type;

        /* Record the quaternion size as a constant: */
        enum { array_size = 4 };

        /* Return the quaternion size: */
        size_type size() const { return size_type(array_size); }
    };

    /* Check for a scalar and a quaternion: */
    template<class X> struct impl<scalar_result_tag,quaternion_result_tag,X> {
        typedef size_t size_type;

        /* Record the array size as a constant: */
        enum { array_size = 4 };

        /* Return the quaternion size: */
        size_type size() const { return size_type(array_size); }
    };

    /* Record the type of the checker: */
    typedef impl<left_result,right_result> check_type;
    typedef typename check_type::size_type size_type;

    /* The implementation: */
    size_type operator()(const LeftT&, const RightT&) const {
        return check_type().size();
    }
};

/* Checking for resizeable expression: */
template<typename LeftT, typename RightT>
struct GetCheckedSize<LeftT,RightT,dynamic_size_tag>
{
    /* Type of the size checker (for calling equal_or_fail): */
    typedef GetCheckedSize<LeftT,RightT,dynamic_size_tag> self;

    /* Record argument traits: */
    typedef ExprTraits<LeftT> left_traits;
    typedef ExprTraits<RightT> right_traits;

    /* Result types: */
    typedef typename left_traits::result_tag left_result;
    typedef typename right_traits::result_tag right_result;


    /* For specialization below: */
    template<typename LR, typename RR, class X = void> struct impl;

    /* Return the size if the same, or fail if different: */
    template<typename V> V equal_or_fail(V left, V right) const {
        if(left != right)
            throw std::invalid_argument(
                    "expressions have incompatible sizes.");
        return left;
    }

    /* Check for two matrices (linear operators only): */
    template<class X> struct impl<matrix_result_tag,matrix_result_tag,X> {
        typedef matrix_size size_type;

        /* Return the matrix size, or fail if incompatible: */
        size_type size(const LeftT& left, const RightT& right) const {
#if defined(CML_CHECK_MATRIX_EXPR_SIZES)
            return self().equal_or_fail(left.size(), right.size());
#else
            return left.size();
#endif
        }
    };

    /* Check for a matrix and a vector: */
    template<class X> struct impl<matrix_result_tag,vector_result_tag,X> {
        typedef size_t size_type;

        /* Return the vector size: */
        size_type size(const LeftT& left, const RightT& right) const {
#if defined(CML_CHECK_MATVEC_EXPR_SIZES)
            self().equal_or_fail(left.cols(), right.size());
#endif
            return left.rows();
        }
    };

    /* Check for a vector and a matrix: */
    template<class X> struct impl<vector_result_tag,matrix_result_tag,X> {
        typedef size_t size_type;

        /* Return the vector size: */
        size_type size(const LeftT& left, const RightT& right) const {
#if defined(CML_CHECK_MATVEC_EXPR_SIZES)
            self().equal_or_fail(left.size(), right.rows());
#endif
            return right.cols(right);
        }
    };

    /* Check for a matrix and a scalar: */
    template<class X> struct impl<matrix_result_tag,scalar_result_tag,X> {
        typedef matrix_size size_type;

        /* Return the matrix size: */
        size_type size(const LeftT& left, const RightT&) const {
            return left.size();
        }
    };

    /* Check for a scalar and a matrix: */
    template<class X> struct impl<scalar_result_tag,matrix_result_tag,X> {
        typedef matrix_size size_type;

        /* Return the matrix size: */
        size_type size(const LeftT&, const RightT& right) const {
            return right.size();
        }
    };

    /* Check for two vectors: */
    template<class X> struct impl<vector_result_tag,vector_result_tag,X> {
        typedef size_t size_type;

        /* Return the vector size: */
        size_type size(const LeftT& left, const RightT& right) const {
#if defined(CML_CHECK_VECTOR_EXPR_SIZES)
            return self().equal_or_fail(left.size(), right.size());
#else
            return left.size();
#endif
        }
    };

    /* Check for a vector and a scalar: */
    template<class X> struct impl<vector_result_tag,scalar_result_tag,X> {
        typedef size_t size_type;

        /* Return the vector size: */
        size_type size(const LeftT& left, const RightT&) const {
            return left.size();
        }
    };

    /* Check for a scalar and a vector: */
    template<class X> struct impl<scalar_result_tag,vector_result_tag,X> {
        typedef size_t size_type;

        /* Return the vector size: */
        size_type size(const LeftT&, const RightT& right) const {
            return right.size();
        }
    };

    /* Record the type of the checker: */
    typedef impl<left_result,right_result> check_type;
    typedef typename check_type::size_type size_type;

    /* The implementation: */
    size_type operator()(const LeftT& left, const RightT& right) const {
        return check_type().size(left,right);
    }
};

template<typename LeftT, typename RightT, typename SizeTag>
inline typename et::GetCheckedSize<LeftT,RightT,SizeTag>::size_type
CheckedSize(const LeftT& left, const RightT& right, SizeTag)
{
    return et::GetCheckedSize<LeftT,RightT,SizeTag>()(left,right);
}

template<typename MatT> inline size_t
CheckedSquare(const MatT&, fixed_size_tag)
{
    CML_STATIC_REQUIRE_M(
            ((size_t)MatT::array_rows == (size_t)MatT::array_cols),
            square_matrix_arg_expected_error);
    return (size_t)MatT::array_rows;
}

template<typename MatT> inline size_t
CheckedSquare(const MatT& m, dynamic_size_tag)
{
    matrix_size N = m.size();
    et::GetCheckedSize<MatT,MatT,dynamic_size_tag>()
        .equal_or_fail(N.first, N.second);
    return N.first;
}

} // namespace et
} // namespace cml

#if defined(_MSC_VER) && _MSC_VER < 1400
#pragma warning(pop)
#endif

#endif

// -------------------------------------------------------------------------
// vim:ft=cpp