• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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
operator +(A const & a,B const & b)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
operator -(A const & a,B const & b)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
operator +=(A & a,B const & b)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
operator -=(A & a,B const & b)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
operator *(A const & a,B b)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
operator *(A a,B const & b)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
operator *=(A & a,B b)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
operator /(A const & a,B b)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
operator /=(A & a,B b)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
convert_to(A const & a)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
operator ==(A const & a,B const & b)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
operator !=(A const & a,B const & b)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
operator -(A const & a)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
mag(A const & a)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
mag_sqr(A const & a)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
normalized(A const & a)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
normalize(A & a)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
dot(A const & a,B const & b)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
633