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