ceph/src/boost/libs/qvm/include/boost/qvm/gen/vec_operations3.hpp

   1 //Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
   2
   3 //Distributed under the Boost Software License, Version 1.0. (See accompanying
   4 //file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
   5
   6 #ifndef BOOST_QVM_209A50EE407836FD124932F69E7D49DC
   7 #define BOOST_QVM_209A50EE407836FD124932F69E7D49DC
   8
   9 //This file was generated by a program. Do not edit manually.
  10
  11 #include <boost/qvm/deduce_scalar.hpp>
  12 #include <boost/qvm/deduce_vec.hpp>
  13 #include <boost/qvm/enable_if.hpp>
  14 #include <boost/qvm/error.hpp>
  15 #include <boost/qvm/inline.hpp>
  16 #include <boost/qvm/math.hpp>
  17 #include <boost/qvm/static_assert.hpp>
  18 #include <boost/qvm/throw_exception.hpp>
  19 #include <boost/qvm/vec_traits.hpp>
  20
  21 namespace
  22 boost
  23     {
  24     namespace
  25     qvm
  26         {
  27         template <class A,class B>
  28         BOOST_QVM_INLINE_OPERATIONS
  29         typename lazy_enable_if_c<
  30             vec_traits<A>::dim==3 && vec_traits<B>::dim==3,
  31             deduce_vec2<A,B,3> >::type
  32         operator+( A const & a, B const & b )
  33             {
  34             typedef typename deduce_vec2<A,B,3>::type R;
  35             BOOST_QVM_STATIC_ASSERT(vec_traits<R>::dim==3);
  36             R r;
  37             vec_traits<R>::template write_element<0>(r)=vec_traits<A>::template read_element<0>(a)+vec_traits<B>::template read_element<0>(b);
  38             vec_traits<R>::template write_element<1>(r)=vec_traits<A>::template read_element<1>(a)+vec_traits<B>::template read_element<1>(b);
  39             vec_traits<R>::template write_element<2>(r)=vec_traits<A>::template read_element<2>(a)+vec_traits<B>::template read_element<2>(b);
  40             return r;
  41             }
  42
  43         namespace
  44         sfinae
  45             {
  46             using ::boost::qvm::operator+;
  47             }
  48
  49         namespace
  50         qvm_detail
  51             {
  52             template <int D>
  53             struct plus_vv_defined;
  54
  55             template <>
  56             struct
  57             plus_vv_defined<3>
  58                 {
  59                 static bool const value=true;
  60                 };
  61             }
  62
  63         template <class A,class B>
  64         BOOST_QVM_INLINE_OPERATIONS
  65         typename lazy_enable_if_c<
  66             vec_traits<A>::dim==3 && vec_traits<B>::dim==3,
  67             deduce_vec2<A,B,3> >::type
  68         operator-( A const & a, B const & b )
  69             {
  70             typedef typename deduce_vec2<A,B,3>::type R;
  71             BOOST_QVM_STATIC_ASSERT(vec_traits<R>::dim==3);
  72             R r;
  73             vec_traits<R>::template write_element<0>(r)=vec_traits<A>::template read_element<0>(a)-vec_traits<B>::template read_element<0>(b);
  74             vec_traits<R>::template write_element<1>(r)=vec_traits<A>::template read_element<1>(a)-vec_traits<B>::template read_element<1>(b);
  75             vec_traits<R>::template write_element<2>(r)=vec_traits<A>::template read_element<2>(a)-vec_traits<B>::template read_element<2>(b);
  76             return r;
  77             }
  78
  79         namespace
  80         sfinae
  81             {
  82             using ::boost::qvm::operator-;
  83             }
  84
  85         namespace
  86         qvm_detail
  87             {
  88             template <int D>
  89             struct minus_vv_defined;
  90
  91             template <>
  92             struct
  93             minus_vv_defined<3>
  94                 {
  95                 static bool const value=true;
  96                 };
  97             }
  98
  99         template <class A,class B>
 100         BOOST_QVM_INLINE_OPERATIONS
 101         typename enable_if_c<
 102             vec_traits<A>::dim==3 && vec_traits<B>::dim==3,
 103             A &>::type
 104         operator+=( A & a, B const & b )
 105             {
 106             vec_traits<A>::template write_element<0>(a)+=vec_traits<B>::template read_element<0>(b);
 107             vec_traits<A>::template write_element<1>(a)+=vec_traits<B>::template read_element<1>(b);
 108             vec_traits<A>::template write_element<2>(a)+=vec_traits<B>::template read_element<2>(b);
 109             return a;
 110             }
 111
 112         namespace
 113         sfinae
 114             {
 115             using ::boost::qvm::operator+=;
 116             }
 117
 118         namespace
 119         qvm_detail
 120             {
 121             template <int D>
 122             struct plus_eq_vv_defined;
 123
 124             template <>
 125             struct
 126             plus_eq_vv_defined<3>
 127                 {
 128                 static bool const value=true;
 129                 };
 130             }
 131
 132         template <class A,class B>
 133         BOOST_QVM_INLINE_OPERATIONS
 134         typename enable_if_c<
 135             vec_traits<A>::dim==3 && vec_traits<B>::dim==3,
 136             A &>::type
 137         operator-=( A & a, B const & b )
 138             {
 139             vec_traits<A>::template write_element<0>(a)-=vec_traits<B>::template read_element<0>(b);
 140             vec_traits<A>::template write_element<1>(a)-=vec_traits<B>::template read_element<1>(b);
 141             vec_traits<A>::template write_element<2>(a)-=vec_traits<B>::template read_element<2>(b);
 142             return a;
 143             }
 144
 145         namespace
 146         sfinae
 147             {
 148             using ::boost::qvm::operator-=;
 149             }
 150
 151         namespace
 152         qvm_detail
 153             {
 154             template <int D>
 155             struct minus_eq_vv_defined;
 156
 157             template <>
 158             struct
 159             minus_eq_vv_defined<3>
 160                 {
 161                 static bool const value=true;
 162                 };
 163             }
 164
 165         template <class A,class B>
 166         BOOST_QVM_INLINE_OPERATIONS
 167         typename lazy_enable_if_c<
 168             vec_traits<A>::dim==3 && is_scalar<B>::value,
 169             deduce_vec<A> >::type
 170         operator*( A const & a, B b )
 171             {
 172             typedef typename deduce_vec<A>::type R;
 173             R r;
 174             vec_traits<R>::template write_element<0>(r)=vec_traits<A>::template read_element<0>(a)*b;
 175             vec_traits<R>::template write_element<1>(r)=vec_traits<A>::template read_element<1>(a)*b;
 176             vec_traits<R>::template write_element<2>(r)=vec_traits<A>::template read_element<2>(a)*b;
 177             return r;
 178             }
 179
 180         namespace
 181         sfinae
 182             {
 183             using ::boost::qvm::operator*;
 184             }
 185
 186         namespace
 187         qvm_detail
 188             {
 189             template <int D>
 190             struct mul_vs_defined;
 191
 192             template <>
 193             struct
 194             mul_vs_defined<3>
 195                 {
 196                 static bool const value=true;
 197                 };
 198             }
 199
 200         template <class A,class  B>
 201         BOOST_QVM_INLINE_OPERATIONS
 202         typename enable_if_c<
 203             vec_traits<A>::dim==3 && is_scalar<B>::value,
 204             A &>::type
 205         operator*=( A & a, B b )
 206             {
 207             vec_traits<A>::template write_element<0>(a)*=b;
 208             vec_traits<A>::template write_element<1>(a)*=b;
 209             vec_traits<A>::template write_element<2>(a)*=b;
 210             return a;
 211             }
 212
 213         namespace
 214         sfinae
 215             {
 216             using ::boost::qvm::operator*=;
 217             }
 218
 219         namespace
 220         qvm_detail
 221             {
 222             template <int D>
 223             struct mul_eq_vs_defined;
 224
 225             template <>
 226             struct
 227             mul_eq_vs_defined<3>
 228                 {
 229                 static bool const value=true;
 230                 };
 231             }
 232
 233         template <class A,class B>
 234         BOOST_QVM_INLINE_OPERATIONS
 235         typename lazy_enable_if_c<
 236             vec_traits<A>::dim==3 && is_scalar<B>::value,
 237             deduce_vec<A> >::type
 238         operator/( A const & a, B b )
 239             {
 240             typedef typename deduce_vec<A>::type R;
 241             R r;
 242             vec_traits<R>::template write_element<0>(r)=vec_traits<A>::template read_element<0>(a)/b;
 243             vec_traits<R>::template write_element<1>(r)=vec_traits<A>::template read_element<1>(a)/b;
 244             vec_traits<R>::template write_element<2>(r)=vec_traits<A>::template read_element<2>(a)/b;
 245             return r;
 246             }
 247
 248         namespace
 249         sfinae
 250             {
 251             using ::boost::qvm::operator/;
 252             }
 253
 254         namespace
 255         qvm_detail
 256             {
 257             template <int D>
 258             struct div_vs_defined;
 259
 260             template <>
 261             struct
 262             div_vs_defined<3>
 263                 {
 264                 static bool const value=true;
 265                 };
 266             }
 267
 268         template <class A,class  B>
 269         BOOST_QVM_INLINE_OPERATIONS
 270         typename enable_if_c<
 271             vec_traits<A>::dim==3 && is_scalar<B>::value,
 272             A &>::type
 273         operator/=( A & a, B b )
 274             {
 275             vec_traits<A>::template write_element<0>(a)/=b;
 276             vec_traits<A>::template write_element<1>(a)/=b;
 277             vec_traits<A>::template write_element<2>(a)/=b;
 278             return a;
 279             }
 280
 281         namespace
 282         sfinae
 283             {
 284             using ::boost::qvm::operator/=;
 285             }
 286
 287         namespace
 288         qvm_detail
 289             {
 290             template <int D>
 291             struct div_eq_vs_defined;
 292
 293             template <>
 294             struct
 295             div_eq_vs_defined<3>
 296                 {
 297                 static bool const value=true;
 298                 };
 299             }
 300
 301         template <class A,class B>
 302         BOOST_QVM_INLINE_OPERATIONS
 303         typename enable_if_c<
 304             vec_traits<A>::dim==3 && vec_traits<B>::dim==3,
 305             A &>::type
 306         assign( A & a, B const & b )
 307             {
 308             vec_traits<A>::template write_element<0>(a)=vec_traits<B>::template read_element<0>(b);
 309             vec_traits<A>::template write_element<1>(a)=vec_traits<B>::template read_element<1>(b);
 310             vec_traits<A>::template write_element<2>(a)=vec_traits<B>::template read_element<2>(b);
 311             return a;
 312             }
 313
 314         namespace
 315         sfinae
 316             {
 317             using ::boost::qvm::assign;
 318             }
 319
 320         namespace
 321         qvm_detail
 322             {
 323             template <int D>
 324             struct assign_vv_defined;
 325
 326             template <>
 327             struct
 328             assign_vv_defined<3>
 329                 {
 330                 static bool const value=true;
 331                 };
 332             }
 333
 334         template <class R,class A>
 335         BOOST_QVM_INLINE_OPERATIONS
 336         typename enable_if_c<
 337             is_vec<A>::value &&
 338             vec_traits<R>::dim==3 && vec_traits<A>::dim==3,
 339             R>::type
 340         convert_to( A const & a )
 341             {
 342             R r;
 343             vec_traits<R>::template write_element<0>(r)=vec_traits<A>::template read_element<0>(a);
 344             vec_traits<R>::template write_element<1>(r)=vec_traits<A>::template read_element<1>(a);
 345             vec_traits<R>::template write_element<2>(r)=vec_traits<A>::template read_element<2>(a);
 346             return r;
 347             }
 348
 349         namespace
 350         sfinae
 351             {
 352             using ::boost::qvm::convert_to;
 353             }
 354
 355         namespace
 356         qvm_detail
 357             {
 358             template <int D>
 359             struct convert_to_v_defined;
 360
 361             template <>
 362             struct
 363             convert_to_v_defined<3>
 364                 {
 365                 static bool const value=true;
 366                 };
 367             }
 368
 369         template <class A,class B>
 370         BOOST_QVM_INLINE_OPERATIONS
 371         typename enable_if_c<
 372             vec_traits<A>::dim==3 && vec_traits<B>::dim==3,
 373         bool>::type
 374         operator==( A const & a, B const & b )
 375             {
 376             return
 377                 vec_traits<A>::template read_element<0>(a)==vec_traits<B>::template read_element<0>(b) &&
 378                 vec_traits<A>::template read_element<1>(a)==vec_traits<B>::template read_element<1>(b) &&
 379                 vec_traits<A>::template read_element<2>(a)==vec_traits<B>::template read_element<2>(b);
 380             }
 381
 382         namespace
 383         sfinae
 384             {
 385             using ::boost::qvm::operator==;
 386             }
 387
 388         namespace
 389         qvm_detail
 390             {
 391             template <int D>
 392             struct eq_vv_defined;
 393
 394             template <>
 395             struct
 396             eq_vv_defined<3>
 397                 {
 398                 static bool const value=true;
 399                 };
 400             }
 401
 402         template <class A,class B>
 403         BOOST_QVM_INLINE_OPERATIONS
 404         typename enable_if_c<
 405             vec_traits<A>::dim==3 && vec_traits<B>::dim==3,
 406         bool>::type
 407         operator!=( A const & a, B const & b )
 408             {
 409             return
 410                 !(vec_traits<A>::template read_element<0>(a)==vec_traits<B>::template read_element<0>(b)) ||
 411                 !(vec_traits<A>::template read_element<1>(a)==vec_traits<B>::template read_element<1>(b)) ||
 412                 !(vec_traits<A>::template read_element<2>(a)==vec_traits<B>::template read_element<2>(b));
 413             }
 414
 415         namespace
 416         sfinae
 417             {
 418             using ::boost::qvm::operator!=;
 419             }
 420
 421         namespace
 422         qvm_detail
 423             {
 424             template <int D>
 425             struct neq_vv_defined;
 426
 427             template <>
 428             struct
 429             neq_vv_defined<3>
 430                 {
 431                 static bool const value=true;
 432                 };
 433             }
 434
 435         template <class A>
 436         BOOST_QVM_INLINE_OPERATIONS
 437         typename lazy_enable_if_c<
 438             vec_traits<A>::dim==3,
 439             deduce_vec<A> >::type
 440         operator-( A const & a )
 441             {
 442             typedef typename deduce_vec<A>::type R;
 443             R r;
 444             vec_traits<R>::template write_element<0>(r)=-vec_traits<A>::template read_element<0>(a);
 445             vec_traits<R>::template write_element<1>(r)=-vec_traits<A>::template read_element<1>(a);
 446             vec_traits<R>::template write_element<2>(r)=-vec_traits<A>::template read_element<2>(a);
 447             return r;
 448             }
 449
 450         namespace
 451         sfinae
 452             {
 453             using ::boost::qvm::operator-;
 454             }
 455
 456         namespace
 457         qvm_detail
 458             {
 459             template <int D>
 460             struct minus_v_defined;
 461
 462             template <>
 463             struct
 464             minus_v_defined<3>
 465                 {
 466                 static bool const value=true;
 467                 };
 468             }
 469
 470         template <class A>
 471         BOOST_QVM_INLINE_OPERATIONS
 472         typename enable_if_c<
 473             is_vec<A>::value && vec_traits<A>::dim==3,
 474             typename vec_traits<A>::scalar_type>::type
 475         mag( A const & a )
 476             {
 477             typedef typename vec_traits<A>::scalar_type T;
 478             T const a0=vec_traits<A>::template read_element<0>(a);
 479             T const a1=vec_traits<A>::template read_element<1>(a);
 480             T const a2=vec_traits<A>::template read_element<2>(a);
 481             T const m2=a0*a0+a1*a1+a2*a2;
 482             T const mag=sqrt<T>(m2);
 483             return mag;
 484             }
 485
 486         namespace
 487         sfinae
 488             {
 489             using ::boost::qvm::mag;
 490             }
 491
 492         namespace
 493         qvm_detail
 494             {
 495             template <int D>
 496             struct mag_v_defined;
 497
 498             template <>
 499             struct
 500             mag_v_defined<3>
 501                 {
 502                 static bool const value=true;
 503                 };
 504             }
 505
 506         template <class A>
 507         BOOST_QVM_INLINE_OPERATIONS
 508         typename enable_if_c<
 509             is_vec<A>::value && vec_traits<A>::dim==3,
 510             typename vec_traits<A>::scalar_type>::type
 511         mag_sqr( A const & a )
 512             {
 513             typedef typename vec_traits<A>::scalar_type T;
 514             T const a0=vec_traits<A>::template read_element<0>(a);
 515             T const a1=vec_traits<A>::template read_element<1>(a);
 516             T const a2=vec_traits<A>::template read_element<2>(a);
 517             T const m2=a0*a0+a1*a1+a2*a2;
 518             return m2;
 519             }
 520
 521         namespace
 522         sfinae
 523             {
 524             using ::boost::qvm::mag_sqr;
 525             }
 526
 527         namespace
 528         qvm_detail
 529             {
 530             template <int D>
 531             struct mag_sqr_v_defined;
 532
 533             template <>
 534             struct
 535             mag_sqr_v_defined<3>
 536                 {
 537                 static bool const value=true;
 538                 };
 539             }
 540
 541         template <class A>
 542         BOOST_QVM_INLINE_OPERATIONS
 543         typename lazy_enable_if_c<
 544             vec_traits<A>::dim==3,
 545             deduce_vec<A> >::type
 546         normalized( A const & a )
 547             {
 548             typedef typename vec_traits<A>::scalar_type T;
 549             T const a0=vec_traits<A>::template read_element<0>(a);
 550             T const a1=vec_traits<A>::template read_element<1>(a);
 551             T const a2=vec_traits<A>::template read_element<2>(a);
 552             T const m2=a0*a0+a1*a1+a2*a2;
 553             if( m2==scalar_traits<typename vec_traits<A>::scalar_type>::value(0) )
 554                 BOOST_QVM_THROW_EXCEPTION(zero_magnitude_error());
 555             T const rm=scalar_traits<T>::value(1)/sqrt<T>(m2);
 556             typedef typename deduce_vec<A>::type R;
 557             R r;
 558             vec_traits<R>::template write_element<0>(r)=a0*rm;
 559             vec_traits<R>::template write_element<1>(r)=a1*rm;
 560             vec_traits<R>::template write_element<2>(r)=a2*rm;
 561             return r;
 562             }
 563
 564         namespace
 565         sfinae
 566             {
 567             using ::boost::qvm::normalized;
 568             }
 569
 570         template <class A>
 571         BOOST_QVM_INLINE_OPERATIONS
 572         typename enable_if_c<
 573             vec_traits<A>::dim==3,
 574             void>::type
 575         normalize( A & a )
 576             {
 577             typedef typename vec_traits<A>::scalar_type T;
 578             T const a0=vec_traits<A>::template read_element<0>(a);
 579             T const a1=vec_traits<A>::template read_element<1>(a);
 580             T const a2=vec_traits<A>::template read_element<2>(a);
 581             T const m2=a0*a0+a1*a1+a2*a2;
 582             if( m2==scalar_traits<typename vec_traits<A>::scalar_type>::value(0) )
 583                 BOOST_QVM_THROW_EXCEPTION(zero_magnitude_error());
 584             T const rm=scalar_traits<T>::value(1)/sqrt<T>(m2);
 585             vec_traits<A>::template write_element<0>(a)*=rm;
 586             vec_traits<A>::template write_element<1>(a)*=rm;
 587             vec_traits<A>::template write_element<2>(a)*=rm;
 588             }
 589
 590         namespace
 591         sfinae
 592             {
 593             using ::boost::qvm::normalize;
 594             }
 595
 596         namespace
 597         qvm_detail
 598             {
 599             template <int D>
 600             struct normalize_v_defined;
 601
 602             template <>
 603             struct
 604             normalize_v_defined<3>
 605                 {
 606                 static bool const value=true;
 607                 };
 608             }
 609
 610         template <class A,class B>
 611         BOOST_QVM_INLINE_OPERATIONS
 612         typename lazy_enable_if_c<
 613             vec_traits<A>::dim==3 && vec_traits<B>::dim==3,
 614             deduce_scalar<typename vec_traits<A>::scalar_type,typename vec_traits<B>::scalar_type> >::type
 615         dot( A const & a, B const & b )
 616             {
 617             typedef typename vec_traits<A>::scalar_type Ta;
 618             typedef typename vec_traits<B>::scalar_type Tb;
 619             typedef typename deduce_scalar<Ta,Tb>::type Tr;
 620             Ta const a0=vec_traits<A>::template read_element<0>(a);
 621             Ta const a1=vec_traits<A>::template read_element<1>(a);
 622             Ta const a2=vec_traits<A>::template read_element<2>(a);
 623             Tb const b0=vec_traits<B>::template read_element<0>(b);
 624             Tb const b1=vec_traits<B>::template read_element<1>(b);
 625             Tb const b2=vec_traits<B>::template read_element<2>(b);
 626             Tr const dot=a0*b0+a1*b1+a2*b2;
 627             return dot;
 628             }
 629
 630         namespace
 631         sfinae
 632             {
 633             using ::boost::qvm::dot;
 634             }
 635
 636         namespace
 637         qvm_detail
 638             {
 639             template <int D>
 640             struct dot_vv_defined;
 641
 642             template <>
 643             struct
 644             dot_vv_defined<3>
 645                 {
 646                 static bool const value=true;
 647                 };
 648             }
 649
 650         }
 651     }
 652
 653 #endif