X-Git-Url: https://git.dogcows.com/gitweb?a=blobdiff_plain;f=src%2Fmoof%2Fcml%2Fvector%2Fvector_comparison.h;fp=src%2Fmoof%2Fcml%2Fvector%2Fvector_comparison.h;h=0000000000000000000000000000000000000000;hb=6b0a0d0efafe34d48ab344fca3b479553bd4e62c;hp=c30a07f1179127c8e56764dc3f4b8a81c6c2ae1d;hpb=85783316365181491a3e3c0c63659972477cebba;p=chaz%2Fyoink diff --git a/src/moof/cml/vector/vector_comparison.h b/src/moof/cml/vector/vector_comparison.h deleted file mode 100644 index c30a07f..0000000 --- a/src/moof/cml/vector/vector_comparison.h +++ /dev/null @@ -1,236 +0,0 @@ -/* -*- 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). - - *-----------------------------------------------------------------------*/ -/** @file - * @brief - */ - -#ifndef vector_comparison_h -#define vector_comparison_h - -#include -#include -#include - -/* This is used below to create a more meaningful compile-time error when - * vector_comparison is not provided with vector or VectorExpr arguments: - */ -struct vector_comparison_expects_vector_args_error; - -#define CML_VEC_VEC_ORDER(_order_, _op_, _OpT_) \ -template \ -inline bool \ -_op_ ( \ - const vector& left, \ - const vector& right) \ -{ \ - return detail::vector_##_order_ (left, right, _OpT_ ()); \ -} - -#define CML_VEC_VECXPR_ORDER(_order_, _op_, _OpT_) \ -template \ -inline bool \ -_op_ ( \ - const vector& left, \ - VECXPR_ARG_TYPE right) \ -{ \ - return detail::vector_##_order_ (left, right, \ - _OpT_ ()); \ -} - -#define CML_VECXPR_VEC_ORDER(_order_, _op_, _OpT_) \ -template \ -inline bool \ -_op_ ( \ - VECXPR_ARG_TYPE left, \ - const vector& right) \ -{ \ - return detail::vector_##_order_ (left, right, \ - _OpT_ ()); \ -} - -#define CML_VECXPR_VECXPR_ORDER(_order_, _op_, _OpT_) \ -template \ -inline bool \ -_op_ ( \ - VECXPR_ARG_TYPE_N(1) left, \ - VECXPR_ARG_TYPE_N(2) right) \ -{ \ - return detail::vector_##_order_ (left, right, \ - _OpT_ < \ - typename XprT1::value_type, \ - typename XprT2::value_type>()); \ -} - - -namespace cml { -namespace detail { - -/** Vector strict weak ordering relationship. - * - * OpT must implement a strict weak order on the vector element type. - * operator< and operator> on integer and floating-point types are - * examples. - */ -template -inline bool -vector_weak_order(const LeftT& left, const RightT& right, OpT) -{ - /* Shorthand: */ - typedef et::ExprTraits left_traits; - typedef et::ExprTraits right_traits; - - /* vector_comparison() requires vector expressions: */ - CML_STATIC_REQUIRE_M( - (et::VectorExpressions::is_true), - vector_comparison_expects_vector_args_error); - /* Note: parens are required here so that the preprocessor ignores the - * commas: - */ - - typedef typename et::VectorPromote< - typename left_traits::result_type, - typename right_traits::result_type - >::type result_type; - typedef typename result_type::size_tag size_tag; - - /* Verify expression size: */ - ssize_t N = (ssize_t) et::CheckedSize(left,right,size_tag()); - for(ssize_t i = 0; i < N; ++ i) { - if(OpT().apply( - left_traits().get(left,i), - right_traits().get(right,i) - )) - { - /* If weak order (a < b) is satisfied, return true: */ - return true; - } else if(OpT().apply( - right_traits().get(right,i), - left_traits().get(left,i) - )) - { - /* If !(b < a), then return false: */ - return false; - } else { - - /* Have !(a < b) && !(b < a) <=> (a >= b && b >= a) <=> (a == b). - * so need to test next element: - */ - continue; - } - } - /* XXX Can this be unrolled in any reasonable way? */ - - /* If we get here, then left == right: */ - return false; -} - -/** Vector total order relationship. - * - * OpT must implement a total order on the vector element type. operator<= - * and operator>= on integer and floating-point types are examples. - */ -template -inline bool -vector_total_order(const LeftT& left, const RightT& right, OpT) -{ - /* Shorthand: */ - typedef et::ExprTraits left_traits; - typedef et::ExprTraits right_traits; - - /* vector_comparison() requires vector expressions: */ - CML_STATIC_REQUIRE_M( - (et::VectorExpressions::is_true), - vector_comparison_expects_vector_args_error); - /* Note: parens are required here so that the preprocessor ignores the - * commas: - */ - - typedef typename et::VectorPromote< - typename left_traits::result_type, - typename right_traits::result_type - >::type result_type; - typedef typename result_type::size_tag size_tag; - - /* Verify expression size: */ - ssize_t N = (ssize_t) et::CheckedSize(left,right,size_tag()); - for(ssize_t i = 0; i < N; ++ i) { - - /* Test total order: */ - if(OpT().apply( - left_traits().get(left,i), - right_traits().get(right,i) - )) - { - /* Automatically true if weak order (a <= b) && !(b <= a) <=> - * (a <= b) && (b > a) <=> (a < b) is satisfied: - */ - if(!OpT().apply( - right_traits().get(right,i), - left_traits().get(left,i) - )) - return true; - - /* Otherwise, have equality (a <= b) && (b <= a), so continue - * to next element: - */ - else - continue; - - } else { - - /* Total order isn't satisfied (a > b), so return false: */ - return false; - } - } - /* XXX Can this be unrolled in any reasonable way? */ - - /* Total (==) or weak (<) order was satisfied, so return true: */ - return true; -} - -} - -/* XXX There is a better way to handle these with operator traits... */ - -CML_VEC_VEC_ORDER( total_order, operator==, et::OpEqual) -CML_VECXPR_VEC_ORDER( total_order, operator==, et::OpEqual) -CML_VEC_VECXPR_ORDER( total_order, operator==, et::OpEqual) -CML_VECXPR_VECXPR_ORDER( total_order, operator==, et::OpEqual) - -CML_VEC_VEC_ORDER( weak_order, operator!=, et::OpNotEqual) -CML_VECXPR_VEC_ORDER( weak_order, operator!=, et::OpNotEqual) -CML_VEC_VECXPR_ORDER( weak_order, operator!=, et::OpNotEqual) -CML_VECXPR_VECXPR_ORDER( weak_order, operator!=, et::OpNotEqual) - -CML_VEC_VEC_ORDER( weak_order, operator<, et::OpLess) -CML_VECXPR_VEC_ORDER( weak_order, operator<, et::OpLess) -CML_VEC_VECXPR_ORDER( weak_order, operator<, et::OpLess) -CML_VECXPR_VECXPR_ORDER( weak_order, operator<, et::OpLess) - -CML_VEC_VEC_ORDER( weak_order, operator>, et::OpGreater) -CML_VECXPR_VEC_ORDER( weak_order, operator>, et::OpGreater) -CML_VEC_VECXPR_ORDER( weak_order, operator>, et::OpGreater) -CML_VECXPR_VECXPR_ORDER( weak_order, operator>, et::OpGreater) - -CML_VEC_VEC_ORDER( total_order, operator<=, et::OpLessEqual) -CML_VECXPR_VEC_ORDER( total_order, operator<=, et::OpLessEqual) -CML_VEC_VECXPR_ORDER( total_order, operator<=, et::OpLessEqual) -CML_VECXPR_VECXPR_ORDER( total_order, operator<=, et::OpLessEqual) - -CML_VEC_VEC_ORDER( total_order, operator>=, et::OpGreaterEqual) -CML_VECXPR_VEC_ORDER( total_order, operator>=, et::OpGreaterEqual) -CML_VEC_VECXPR_ORDER( total_order, operator>=, et::OpGreaterEqual) -CML_VECXPR_VECXPR_ORDER( total_order, operator>=, et::OpGreaterEqual) - -} // namespace cml - -#endif - -// ------------------------------------------------------------------------- -// vim:ft=cpp