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