ceph/src/boost/boost/qvm/gen/vec_operations4.hpp

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