boost/qvm/gen/vec_operations2.hpp

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