ceph/src/boost/boost/qvm/gen/vec_operations2.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_F622919DE18B1FDAB0CA992B9729D49
   7 #define BOOST_QVM_F622919DE18B1FDAB0CA992B9729D49
   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_assign2.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==2 && vec_traits<B>::dim==2,
  29             deduce_vec2<A,B,2> >::type
  30         operator+( A const & a, B const & b )
  31             {
  32             typedef typename deduce_vec2<A,B,2>::type R;
  33             BOOST_QVM_STATIC_ASSERT(vec_traits<R>::dim==2);
  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             return r;
  38             }
  39
  40         namespace
  41         sfinae
  42             {
  43             using ::boost::qvm::operator+;
  44             }
  45
  46         namespace
  47         qvm_detail
  48             {
  49             template <int D>
  50             struct plus_vv_defined;
  51
  52             template <>
  53             struct
  54             plus_vv_defined<2>
  55                 {
  56                 static bool const value=true;
  57                 };
  58             }
  59
  60         template <class A,class B>
  61         BOOST_QVM_INLINE_OPERATIONS
  62         typename lazy_enable_if_c<
  63             vec_traits<A>::dim==2 && vec_traits<B>::dim==2,
  64             deduce_vec2<A,B,2> >::type
  65         operator-( A const & a, B const & b )
  66             {
  67             typedef typename deduce_vec2<A,B,2>::type R;
  68             BOOST_QVM_STATIC_ASSERT(vec_traits<R>::dim==2);
  69             R r;
  70             vec_traits<R>::template write_element<0>(r)=vec_traits<A>::template read_element<0>(a)-vec_traits<B>::template read_element<0>(b);
  71             vec_traits<R>::template write_element<1>(r)=vec_traits<A>::template read_element<1>(a)-vec_traits<B>::template read_element<1>(b);
  72             return r;
  73             }
  74
  75         namespace
  76         sfinae
  77             {
  78             using ::boost::qvm::operator-;
  79             }
  80
  81         namespace
  82         qvm_detail
  83             {
  84             template <int D>
  85             struct minus_vv_defined;
  86
  87             template <>
  88             struct
  89             minus_vv_defined<2>
  90                 {
  91                 static bool const value=true;
  92                 };
  93             }
  94
  95         template <class A,class B>
  96         BOOST_QVM_INLINE_OPERATIONS
  97         typename enable_if_c<
  98             vec_traits<A>::dim==2 && vec_traits<B>::dim==2,
  99             A &>::type
 100         operator+=( A & a, B const & b )
 101             {
 102             vec_traits<A>::template write_element<0>(a)+=vec_traits<B>::template read_element<0>(b);
 103             vec_traits<A>::template write_element<1>(a)+=vec_traits<B>::template read_element<1>(b);
 104             return a;
 105             }
 106
 107         namespace
 108         sfinae
 109             {
 110             using ::boost::qvm::operator+=;
 111             }
 112
 113         namespace
 114         qvm_detail
 115             {
 116             template <int D>
 117             struct plus_eq_vv_defined;
 118
 119             template <>
 120             struct
 121             plus_eq_vv_defined<2>
 122                 {
 123                 static bool const value=true;
 124                 };
 125             }
 126
 127         template <class A,class B>
 128         BOOST_QVM_INLINE_OPERATIONS
 129         typename enable_if_c<
 130             vec_traits<A>::dim==2 && vec_traits<B>::dim==2,
 131             A &>::type
 132         operator-=( A & a, B const & b )
 133             {
 134             vec_traits<A>::template write_element<0>(a)-=vec_traits<B>::template read_element<0>(b);
 135             vec_traits<A>::template write_element<1>(a)-=vec_traits<B>::template read_element<1>(b);
 136             return a;
 137             }
 138
 139         namespace
 140         sfinae
 141             {
 142             using ::boost::qvm::operator-=;
 143             }
 144
 145         namespace
 146         qvm_detail
 147             {
 148             template <int D>
 149             struct minus_eq_vv_defined;
 150
 151             template <>
 152             struct
 153             minus_eq_vv_defined<2>
 154                 {
 155                 static bool const value=true;
 156                 };
 157             }
 158
 159         template <class A,class B>
 160         BOOST_QVM_INLINE_OPERATIONS
 161         typename lazy_enable_if_c<
 162             vec_traits<A>::dim==2 && is_scalar<B>::value,
 163             deduce_vec<A> >::type
 164         operator*( A const & a, B b )
 165             {
 166             typedef typename deduce_vec<A>::type R;
 167             R r;
 168             vec_traits<R>::template write_element<0>(r)=vec_traits<A>::template read_element<0>(a)*b;
 169             vec_traits<R>::template write_element<1>(r)=vec_traits<A>::template read_element<1>(a)*b;
 170             return r;
 171             }
 172
 173         namespace
 174         sfinae
 175             {
 176             using ::boost::qvm::operator*;
 177             }
 178
 179         namespace
 180         qvm_detail
 181             {
 182             template <int D>
 183             struct mul_vs_defined;
 184
 185             template <>
 186             struct
 187             mul_vs_defined<2>
 188                 {
 189                 static bool const value=true;
 190                 };
 191             }
 192
 193         template <class A,class B>
 194         BOOST_QVM_INLINE_OPERATIONS
 195         typename lazy_enable_if_c<
 196             is_scalar<A>::value && vec_traits<B>::dim==2,
 197             deduce_vec<B> >::type
 198         operator*( A a, B const & b )
 199             {
 200             typedef typename deduce_vec<B>::type R;
 201             R r;
 202             vec_traits<R>::template write_element<0>(r)=a*vec_traits<B>::template read_element<0>(b);
 203             vec_traits<R>::template write_element<1>(r)=a*vec_traits<B>::template read_element<1>(b);
 204             return r;
 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_sv_defined;
 218
 219             template <>
 220             struct
 221             mul_sv_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 enable_if_c<
 230             vec_traits<A>::dim==2 && is_scalar<B>::value,
 231             A &>::type
 232         operator*=( A & a, B b )
 233             {
 234             vec_traits<A>::template write_element<0>(a)*=b;
 235             vec_traits<A>::template write_element<1>(a)*=b;
 236             return a;
 237             }
 238
 239         namespace
 240         sfinae
 241             {
 242             using ::boost::qvm::operator*=;
 243             }
 244
 245         namespace
 246         qvm_detail
 247             {
 248             template <int D>
 249             struct mul_eq_vs_defined;
 250
 251             template <>
 252             struct
 253             mul_eq_vs_defined<2>
 254                 {
 255                 static bool const value=true;
 256                 };
 257             }
 258
 259         template <class A,class B>
 260         BOOST_QVM_INLINE_OPERATIONS
 261         typename lazy_enable_if_c<
 262             vec_traits<A>::dim==2 && is_scalar<B>::value,
 263             deduce_vec<A> >::type
 264         operator/( A const & a, B b )
 265             {
 266             typedef typename deduce_vec<A>::type R;
 267             R r;
 268             vec_traits<R>::template write_element<0>(r)=vec_traits<A>::template read_element<0>(a)/b;
 269             vec_traits<R>::template write_element<1>(r)=vec_traits<A>::template read_element<1>(a)/b;
 270             return r;
 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_vs_defined;
 284
 285             template <>
 286             struct
 287             div_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 && is_scalar<B>::value,
 297             A &>::type
 298         operator/=( A & a, B b )
 299             {
 300             vec_traits<A>::template write_element<0>(a)/=b;
 301             vec_traits<A>::template write_element<1>(a)/=b;
 302             return a;
 303             }
 304
 305         namespace
 306         sfinae
 307             {
 308             using ::boost::qvm::operator/=;
 309             }
 310
 311         namespace
 312         qvm_detail
 313             {
 314             template <int D>
 315             struct div_eq_vs_defined;
 316
 317             template <>
 318             struct
 319             div_eq_vs_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