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