ceph/src/boost/boost/qvm/map_mat_vec.hpp

   1 #ifndef BOOST_QVM_MAP_MAT_VEC_HPP_INCLUDED
   2 #define BOOST_QVM_MAP_MAT_VEC_HPP_INCLUDED
   3
   4 // Copyright 2008-2022 Emil Dotchevski and Reverge Studios, Inc.
   5
   6 // Distributed under the Boost Software License, Version 1.0. (See accompanying
   7 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
   8
   9 #include <boost/qvm/inline.hpp>
  10 #include <boost/qvm/mat_traits.hpp>
  11 #include <boost/qvm/deduce_vec.hpp>
  12 #include <boost/qvm/assert.hpp>
  13 #include <boost/qvm/enable_if.hpp>
  14
  15 namespace boost { namespace qvm {
  16
  17 namespace
  18 qvm_detail
  19     {
  20     template <int Col,class OriginalMatrix>
  21     class
  22     col_
  23         {
  24         col_( col_ const & );
  25         col_ & operator=( col_ const & );
  26         ~col_();
  27
  28         public:
  29
  30         template <class T>
  31         BOOST_QVM_CONSTEXPR BOOST_QVM_INLINE_TRIVIAL
  32         col_ &
  33         operator=( T const & x )
  34             {
  35             assign(*this,x);
  36             return *this;
  37             }
  38
  39         template <class R>
  40         BOOST_QVM_CONSTEXPR BOOST_QVM_INLINE_TRIVIAL
  41         operator R() const
  42             {
  43             R r;
  44             assign(r,*this);
  45             return r;
  46             }
  47         };
  48     }
  49
  50 template <int Col,class OriginalMatrix>
  51 struct
  52 vec_traits< qvm_detail::col_<Col,OriginalMatrix> >
  53     {
  54     typedef qvm_detail::col_<Col,OriginalMatrix> this_vector;
  55     typedef typename mat_traits<OriginalMatrix>::scalar_type scalar_type;
  56     static int const dim=mat_traits<OriginalMatrix>::rows;
  57     BOOST_QVM_STATIC_ASSERT(Col>=0);
  58     BOOST_QVM_STATIC_ASSERT(Col<mat_traits<OriginalMatrix>::cols);
  59
  60     template <int I>
  61     static
  62     BOOST_QVM_CONSTEXPR BOOST_QVM_INLINE_CRITICAL
  63     scalar_type
  64     read_element( this_vector const & x )
  65         {
  66         BOOST_QVM_STATIC_ASSERT(I>=0);
  67         BOOST_QVM_STATIC_ASSERT(I<dim);
  68         return mat_traits<OriginalMatrix>::template read_element<I,Col>(reinterpret_cast<OriginalMatrix const &>(x));
  69         }
  70
  71     template <int I>
  72     static
  73     BOOST_QVM_CONSTEXPR BOOST_QVM_INLINE_CRITICAL
  74     scalar_type &
  75     write_element( this_vector & x )
  76         {
  77         BOOST_QVM_STATIC_ASSERT(I>=0);
  78         BOOST_QVM_STATIC_ASSERT(I<dim);
  79         return mat_traits<OriginalMatrix>::template write_element<I,Col>(reinterpret_cast<OriginalMatrix &>(x));
  80         }
  81
  82     static
  83     BOOST_QVM_CONSTEXPR BOOST_QVM_INLINE_CRITICAL
  84     scalar_type
  85     read_element_idx( int i, this_vector const & x )
  86         {
  87         BOOST_QVM_ASSERT(i>=0);
  88         BOOST_QVM_ASSERT(i<dim);
  89         return mat_traits<OriginalMatrix>::read_element_idx(i,Col,reinterpret_cast<OriginalMatrix const &>(x));
  90         }
  91
  92     static
  93     BOOST_QVM_CONSTEXPR BOOST_QVM_INLINE_CRITICAL
  94     scalar_type &
  95     write_element_idx( int i, this_vector & x )
  96         {
  97         BOOST_QVM_ASSERT(i>=0);
  98         BOOST_QVM_ASSERT(i<dim);
  99         return mat_traits<OriginalMatrix>::write_element_idx(i,Col,reinterpret_cast<OriginalMatrix &>(x));
 100         }
 101     };
 102
 103 template <int Col,class OriginalMatrix,int D>
 104 struct
 105 deduce_vec<qvm_detail::col_<Col,OriginalMatrix>,D>
 106     {
 107     typedef vec<typename mat_traits<OriginalMatrix>::scalar_type,D> type;
 108     };
 109
 110 template <int Col,class OriginalMatrix,int D>
 111 struct
 112 deduce_vec2<qvm_detail::col_<Col,OriginalMatrix>,qvm_detail::col_<Col,OriginalMatrix>,D>
 113     {
 114     typedef vec<typename mat_traits<OriginalMatrix>::scalar_type,D> type;
 115     };
 116
 117 template <int Col,class A>
 118 typename enable_if_c<
 119     is_mat<A>::value,
 120     qvm_detail::col_<Col,A> const &>::type
 121 BOOST_QVM_CONSTEXPR BOOST_QVM_INLINE_TRIVIAL
 122 col( A const & a )
 123     {
 124     return reinterpret_cast<typename qvm_detail::col_<Col,A> const &>(a);
 125     }
 126
 127 template <int Col,class A>
 128 typename enable_if_c<
 129     is_mat<A>::value,
 130     qvm_detail::col_<Col,A> &>::type
 131 BOOST_QVM_CONSTEXPR BOOST_QVM_INLINE_TRIVIAL
 132 col( A & a )
 133     {
 134     return reinterpret_cast<typename qvm_detail::col_<Col,A> &>(a);
 135     }
 136
 137 ////////////////////////////////////////////////
 138
 139 namespace
 140 qvm_detail
 141     {
 142     template <int Row,class OriginalMatrix>
 143     class
 144     row_
 145         {
 146         row_( row_ const & );
 147         row_ & operator=( row_ const & );
 148         ~row_();
 149
 150         public:
 151
 152         template <class T>
 153         BOOST_QVM_CONSTEXPR BOOST_QVM_INLINE_TRIVIAL
 154         row_ &
 155         operator=( T const & x )
 156             {
 157             assign(*this,x);
 158             return *this;
 159             }
 160
 161         template <class R>
 162         BOOST_QVM_CONSTEXPR BOOST_QVM_INLINE_TRIVIAL
 163         operator R() const
 164             {
 165             R r;
 166             assign(r,*this);
 167             return r;
 168             }
 169         };
 170     }
 171
 172 template <int Row,class OriginalMatrix>
 173 struct
 174 vec_traits< qvm_detail::row_<Row,OriginalMatrix> >
 175     {
 176     typedef qvm_detail::row_<Row,OriginalMatrix> this_vector;
 177     typedef typename mat_traits<OriginalMatrix>::scalar_type scalar_type;
 178     static int const dim=mat_traits<OriginalMatrix>::cols;
 179     BOOST_QVM_STATIC_ASSERT(Row>=0);
 180     BOOST_QVM_STATIC_ASSERT(Row<mat_traits<OriginalMatrix>::rows);
 181
 182     template <int I>
 183     static
 184     BOOST_QVM_CONSTEXPR BOOST_QVM_INLINE_CRITICAL
 185     scalar_type
 186     read_element( this_vector const & x )
 187         {
 188         BOOST_QVM_STATIC_ASSERT(I>=0);
 189         BOOST_QVM_STATIC_ASSERT(I<dim);
 190         return mat_traits<OriginalMatrix>::template read_element<Row,I>(reinterpret_cast<OriginalMatrix const &>(x));
 191         }
 192
 193     template <int I>
 194     static
 195     BOOST_QVM_CONSTEXPR BOOST_QVM_INLINE_CRITICAL
 196     scalar_type &
 197     write_element( this_vector & x )
 198         {
 199         BOOST_QVM_STATIC_ASSERT(I>=0);
 200         BOOST_QVM_STATIC_ASSERT(I<dim);
 201         return mat_traits<OriginalMatrix>::template write_element<Row,I>(reinterpret_cast<OriginalMatrix &>(x));
 202         }
 203
 204     static
 205     BOOST_QVM_CONSTEXPR BOOST_QVM_INLINE_CRITICAL
 206     scalar_type
 207     read_element_idx( int i, this_vector const & x )
 208         {
 209         BOOST_QVM_ASSERT(i>=0);
 210         BOOST_QVM_ASSERT(i<dim);
 211         return mat_traits<OriginalMatrix>::read_element_idx(Row,i,reinterpret_cast<OriginalMatrix const &>(x));
 212         }
 213
 214     static
 215     BOOST_QVM_CONSTEXPR BOOST_QVM_INLINE_CRITICAL
 216     scalar_type &
 217     write_element_idx( int i, this_vector & x )
 218         {
 219         BOOST_QVM_ASSERT(i>=0);
 220         BOOST_QVM_ASSERT(i<dim);
 221         return mat_traits<OriginalMatrix>::write_element_idx(Row,i,reinterpret_cast<OriginalMatrix &>(x));
 222         }
 223     };
 224
 225 template <int Row,class OriginalMatrix,int D>
 226 struct
 227 deduce_vec<qvm_detail::row_<Row,OriginalMatrix>,D>
 228     {
 229     typedef vec<typename mat_traits<OriginalMatrix>::scalar_type,D> type;
 230     };
 231
 232 template <int Row,class OriginalMatrix,int D>
 233 struct
 234 deduce_vec2<qvm_detail::row_<Row,OriginalMatrix>,qvm_detail::row_<Row,OriginalMatrix>,D>
 235     {
 236     typedef vec<typename mat_traits<OriginalMatrix>::scalar_type,D> type;
 237     };
 238
 239 template <int Row,class A>
 240 typename enable_if_c<
 241     is_mat<A>::value,
 242     qvm_detail::row_<Row,A> const &>::type
 243 BOOST_QVM_CONSTEXPR BOOST_QVM_INLINE_TRIVIAL
 244 row( A const & a )
 245     {
 246     return reinterpret_cast<typename qvm_detail::row_<Row,A> const &>(a);
 247     }
 248
 249 template <int Row,class A>
 250 typename enable_if_c<
 251     is_mat<A>::value,
 252     qvm_detail::row_<Row,A> &>::type
 253 BOOST_QVM_CONSTEXPR BOOST_QVM_INLINE_TRIVIAL
 254 row( A & a )
 255     {
 256     return reinterpret_cast<typename qvm_detail::row_<Row,A> &>(a);
 257     }
 258
 259 ////////////////////////////////////////////////
 260
 261 namespace
 262 qvm_detail
 263     {
 264     template <class OriginalMatrix>
 265     class
 266     diag_
 267         {
 268         diag_( diag_ const & );
 269         diag_ & operator=( diag_ const & );
 270         ~diag_();
 271
 272         public:
 273
 274         template <class T>
 275         BOOST_QVM_CONSTEXPR BOOST_QVM_INLINE_TRIVIAL
 276         diag_ &
 277         operator=( T const & x )
 278             {
 279             assign(*this,x);
 280             return *this;
 281             }
 282
 283         template <class R>
 284         BOOST_QVM_CONSTEXPR BOOST_QVM_INLINE_TRIVIAL
 285         operator R() const
 286             {
 287             R r;
 288             assign(r,*this);
 289             return r;
 290             }
 291         };
 292
 293     template <int X,int Y,bool Which>
 294     struct diag_bool_dispatch;
 295
 296     template <int X,int Y>
 297     struct
 298     diag_bool_dispatch<X,Y,true>
 299         {
 300         static int const value=X;
 301         };
 302
 303     template <int X,int Y>
 304     struct
 305     diag_bool_dispatch<X,Y,false>
 306         {
 307         static int const value=Y;
 308         };
 309     }
 310
 311 template <class OriginalMatrix>
 312 struct
 313 vec_traits< qvm_detail::diag_<OriginalMatrix> >
 314     {
 315     typedef qvm_detail::diag_<OriginalMatrix> this_vector;
 316     typedef typename mat_traits<OriginalMatrix>::scalar_type scalar_type;
 317     static int const dim=qvm_detail::diag_bool_dispatch<
 318             mat_traits<OriginalMatrix>::rows,
 319             mat_traits<OriginalMatrix>::cols,
 320             mat_traits<OriginalMatrix>::rows<=mat_traits<OriginalMatrix>::cols>::value;
 321
 322     template <int I>
 323     static
 324     BOOST_QVM_CONSTEXPR BOOST_QVM_INLINE_CRITICAL
 325     scalar_type
 326     read_element( this_vector const & x )
 327         {
 328         BOOST_QVM_STATIC_ASSERT(I>=0);
 329         BOOST_QVM_STATIC_ASSERT(I<dim);
 330         return mat_traits<OriginalMatrix>::template read_element<I,I>(reinterpret_cast<OriginalMatrix const &>(x));
 331         }
 332
 333     template <int I>
 334     static
 335     BOOST_QVM_CONSTEXPR BOOST_QVM_INLINE_CRITICAL
 336     scalar_type &
 337     write_element( this_vector & x )
 338         {
 339         BOOST_QVM_STATIC_ASSERT(I>=0);
 340         BOOST_QVM_STATIC_ASSERT(I<dim);
 341         return mat_traits<OriginalMatrix>::template write_element<I,I>(reinterpret_cast<OriginalMatrix &>(x));
 342         }
 343
 344     static
 345     BOOST_QVM_CONSTEXPR BOOST_QVM_INLINE_CRITICAL
 346     scalar_type
 347     read_element_idx( int i, this_vector const & x )
 348         {
 349         BOOST_QVM_ASSERT(i>=0);
 350         BOOST_QVM_ASSERT(i<dim);
 351         return mat_traits<OriginalMatrix>::read_element_idx(i,i,reinterpret_cast<OriginalMatrix const &>(x));
 352         }
 353
 354     static
 355     BOOST_QVM_CONSTEXPR BOOST_QVM_INLINE_CRITICAL
 356     scalar_type &
 357     write_element_idx( int i, this_vector & x )
 358         {
 359         BOOST_QVM_ASSERT(i>=0);
 360         BOOST_QVM_ASSERT(i<dim);
 361         return mat_traits<OriginalMatrix>::write_element_idx(i,i,reinterpret_cast<OriginalMatrix &>(x));
 362         }
 363     };
 364
 365 template <class OriginalMatrix,int D>
 366 struct
 367 deduce_vec<qvm_detail::diag_<OriginalMatrix>,D>
 368     {
 369     typedef vec<typename mat_traits<OriginalMatrix>::scalar_type,D> type;
 370     };
 371
 372 template <class OriginalMatrix,int D>
 373 struct
 374 deduce_vec2<qvm_detail::diag_<OriginalMatrix>,qvm_detail::diag_<OriginalMatrix>,D>
 375     {
 376     typedef vec<typename mat_traits<OriginalMatrix>::scalar_type,D> type;
 377     };
 378
 379 template <class A>
 380 typename enable_if_c<
 381     is_mat<A>::value,
 382     qvm_detail::diag_<A> const &>::type
 383 BOOST_QVM_CONSTEXPR BOOST_QVM_INLINE_TRIVIAL
 384 diag( A const & a )
 385     {
 386     return reinterpret_cast<typename qvm_detail::diag_<A> const &>(a);
 387     }
 388
 389 template <class A>
 390 typename enable_if_c<
 391     is_mat<A>::value,
 392     qvm_detail::diag_<A> &>::type
 393 BOOST_QVM_CONSTEXPR BOOST_QVM_INLINE_TRIVIAL
 394 diag( A & a )
 395     {
 396     return reinterpret_cast<typename qvm_detail::diag_<A> &>(a);
 397     }
 398
 399 ////////////////////////////////////////////////
 400
 401 namespace
 402 qvm_detail
 403     {
 404     template <class OriginalMatrix>
 405     class
 406     translation_
 407         {
 408         translation_( translation_ const & );
 409         ~translation_();
 410
 411         public:
 412
 413         translation_ &
 414         operator=( translation_ const & x )
 415             {
 416             assign(*this,x);
 417             return *this;
 418             }
 419
 420         template <class T>
 421         BOOST_QVM_CONSTEXPR BOOST_QVM_INLINE_TRIVIAL
 422         translation_ &
 423         operator=( T const & x )
 424             {
 425             assign(*this,x);
 426             return *this;
 427             }
 428
 429         template <class R>
 430         BOOST_QVM_CONSTEXPR BOOST_QVM_INLINE_TRIVIAL
 431         operator R() const
 432             {
 433             R r;
 434             assign(r,*this);
 435             return r;
 436             }
 437         };
 438     }
 439
 440 template <class OriginalMatrix>
 441 struct
 442 vec_traits< qvm_detail::translation_<OriginalMatrix> >
 443     {
 444     typedef qvm_detail::translation_<OriginalMatrix> this_vector;
 445     typedef typename mat_traits<OriginalMatrix>::scalar_type scalar_type;
 446     static int const dim=mat_traits<OriginalMatrix>::rows-1;
 447     BOOST_QVM_STATIC_ASSERT(mat_traits<OriginalMatrix>::rows==mat_traits<OriginalMatrix>::cols);
 448     BOOST_QVM_STATIC_ASSERT(mat_traits<OriginalMatrix>::rows>=3);
 449
 450     template <int I>
 451     static
 452     BOOST_QVM_CONSTEXPR BOOST_QVM_INLINE_CRITICAL
 453     scalar_type
 454     read_element( this_vector const & x )
 455         {
 456         BOOST_QVM_STATIC_ASSERT(I>=0);
 457         BOOST_QVM_STATIC_ASSERT(I<dim);
 458         return mat_traits<OriginalMatrix>::template read_element<I,dim>(reinterpret_cast<OriginalMatrix const &>(x));
 459         }
 460
 461     template <int I>
 462     static
 463     BOOST_QVM_CONSTEXPR BOOST_QVM_INLINE_CRITICAL
 464     scalar_type &
 465     write_element( this_vector & x )
 466         {
 467         BOOST_QVM_STATIC_ASSERT(I>=0);
 468         BOOST_QVM_STATIC_ASSERT(I<dim);
 469         return mat_traits<OriginalMatrix>::template write_element<I,dim>(reinterpret_cast<OriginalMatrix &>(x));
 470         }
 471
 472     static
 473     BOOST_QVM_CONSTEXPR BOOST_QVM_INLINE_CRITICAL
 474     scalar_type
 475     read_element_idx( int i, this_vector const & x )
 476         {
 477         BOOST_QVM_ASSERT(i>=0);
 478         BOOST_QVM_ASSERT(i<dim);
 479         return mat_traits<OriginalMatrix>::read_element_idx(i,dim,reinterpret_cast<OriginalMatrix const &>(x));
 480         }
 481
 482     static
 483     BOOST_QVM_CONSTEXPR BOOST_QVM_INLINE_CRITICAL
 484     scalar_type &
 485     write_element_idx( int i, this_vector & x )
 486         {
 487         BOOST_QVM_ASSERT(i>=0);
 488         BOOST_QVM_ASSERT(i<dim);
 489         return mat_traits<OriginalMatrix>::write_element_idx(i,dim,reinterpret_cast<OriginalMatrix &>(x));
 490         }
 491     };
 492
 493 template <class OriginalMatrix,int D>
 494 struct
 495 deduce_vec<qvm_detail::translation_<OriginalMatrix>,D>
 496     {
 497     typedef vec<typename mat_traits<OriginalMatrix>::scalar_type,D> type;
 498     };
 499
 500 template <class OriginalMatrix,int D>
 501 struct
 502 deduce_vec2<qvm_detail::translation_<OriginalMatrix>,qvm_detail::translation_<OriginalMatrix>,D>
 503     {
 504     typedef vec<typename mat_traits<OriginalMatrix>::scalar_type,D> type;
 505     };
 506
 507 template <class A>
 508 typename enable_if_c<
 509     is_mat<A>::value && mat_traits<A>::rows==mat_traits<A>::cols && mat_traits<A>::rows>=3,
 510     qvm_detail::translation_<A> const &>::type
 511 BOOST_QVM_CONSTEXPR BOOST_QVM_INLINE_TRIVIAL
 512 translation( A const & a )
 513     {
 514     return reinterpret_cast<typename qvm_detail::translation_<A> const &>(a);
 515     }
 516
 517 template <class A>
 518 typename enable_if_c<
 519     is_mat<A>::value && mat_traits<A>::rows==mat_traits<A>::cols && mat_traits<A>::rows>=3,
 520     qvm_detail::translation_<A> &>::type
 521 BOOST_QVM_CONSTEXPR BOOST_QVM_INLINE_TRIVIAL
 522 translation( A & a )
 523     {
 524     return reinterpret_cast<typename qvm_detail::translation_<A> &>(a);
 525     }
 526
 527 } }
 528
 529 #endif