Home My Page Projects Code Snippets Project Openings diderot
Summary Activity Tracker Tasks SCM

SCM Repository

[diderot] Annotation of /tests/vec-tests/vec.h
ViewVC logotype

Annotation of /tests/vec-tests/vec.h

Parent Directory Parent Directory | Revision Log Revision Log


Revision 4640 - (view) (download) (as text)

1 : glk 4640 /*! \file vec.h
2 :     *
3 :     * \author John Reppy
4 :     */
5 :    
6 :     /*
7 :     * This code is part of the Diderot Project (http://diderot-language.cs.uchicago.edu)
8 :     *
9 :     * COPYRIGHT (c) 2016 The University of Chicago
10 :     * All rights reserved.
11 :     */
12 :    
13 :     #ifndef _VEC_H_
14 :     #define _VEC_H_
15 :    
16 :     #include <ostream>
17 :     #include "raw-vectors.h"
18 :    
19 :    
20 :     /***** Representations of vectors using raw vector types *****/
21 :    
22 :     struct rep2f {
23 :     raw2f v0;
24 :     rep2f (const raw2f &v) : v0(v) { }
25 :     rep2f (float a, float b) : v0((raw2f){a, b}) { }
26 :     rep2f (const float *m) : v0((raw2f){m[0], m[1]}) { }
27 :     float operator[] (unsigned int const &i) const { return this->v0[i]; }
28 :     };
29 :    
30 :     inline rep2f vec_add (rep2f const &a, rep2f const &b) { return rep2f(a.v0 + b.v0); }
31 :     inline rep2f vec_sub (rep2f const &a, rep2f const &b) { return rep2f(a.v0 - b.v0); }
32 :     inline rep2f vec_scale (float s, rep2f const &a) { return rep2f((raw2f){s, s} * a.v0); }
33 :     inline rep2f vec_mul (rep2f const &a, rep2f const &b) { return rep2f(a.v0 * b.v0); }
34 :     inline float vec_sum (rep2f const &a) { return a.v0[0] + a.v0[1]; }
35 :     inline void vec_store (float *m, rep2f const &a) { m[0] = a.v0[0]; m[1] = a.v0[1]; }
36 :    
37 :     struct rep3f {
38 :     #if (MAX_VEC_WID >= 16)
39 :     raw4f v0; // padded
40 :     rep3f (const raw4f &v) : v0(v) { }
41 :     rep3f (float a, float b, float c) : v0((raw4f){a, b, c, 0.0f}) { }
42 :     rep3f (const float *m) : v0((raw4f){m[0], m[1], m[2], 0.0f}) { }
43 :     float operator[] (unsigned int const &i) const { return this->v0[i]; }
44 :     #else // !(MAX_VEC_WID >= 16)
45 :     raw2f v0;
46 :     float v1;
47 :     rep3f (const raw2f &x01, float x2) : v0(x01), v1(x2) { }
48 :     rep3f (float a, float b, float c) : v0((raw2f){a, b}), v1(c) { }
49 :     rep3f (const float *m) : v0((raw2f){m[0], m[1]}), v1(m[2]) { }
50 :     float operator[] (unsigned int const &i) const
51 :     {
52 :     return (i < 2) ? this->v0[i] : this->v1;
53 :     }
54 :     #endif
55 :     };
56 :    
57 :     #if (MAX_VEC_WID >= 16)
58 :     inline rep3f vec_add (rep3f const &a, rep3f const &b) { return rep3f(a.v0 + b.v0); }
59 :     inline rep3f vec_sub (rep3f const &a, rep3f const &b) { return rep3f(a.v0 - b.v0); }
60 :     inline rep3f vec_scale (float s, rep3f const &a) { return rep3f((raw4f){s, s, s, s} * a.v0); }
61 :     inline rep3f vec_mul (rep3f const &a, rep3f const &b) { return rep3f(a.v0 * b.v0); }
62 :     inline float vec_sum (rep3f const &a) { return a.v0[0] + a.v0[1] + a.v0[2]; }
63 :     inline void vec_store (float *m, rep3f const &a) { m[0] = a.v0[0]; m[1] = a.v0[1]; m[2] = a.v0[2]; }
64 :     #else // !(MAX_VEC_WID >= 16)
65 :     inline rep3f vec_add (rep3f const &a, rep3f const &b) { return rep3f(a.v0 + b.v0, a.v1 + b.v1); }
66 :     inline rep3f vec_sub (rep3f const &a, rep3f const &b) { return rep3f(a.v0 - b.v0, a.v1 - b.v1); }
67 :     inline rep3f vec_scale (float s, rep3f const &a) { return rep3f((raw2f){s, s} * a.v0, s * a.v1); }
68 :     inline rep3f vec_mul (rep3f const &a, rep3f const &b) { return rep3f(a.v0 * b.v0, a.v1 * b.v1); }
69 :     inline float vec_sum (rep3f const &a) { return a.v0[0] + a.v0[1] + a.v1; }
70 :     inline void vec_store (float *m, rep3f const &a) { m[0] = a.v0[0]; m[1] = a.v0[1]; m[2] = a.v1; }
71 :     #endif
72 :    
73 :    
74 :     struct rep4f {
75 :     raw4f v0;
76 :     rep4f (const raw4f &v) : v0(v) { }
77 :     rep4f (float a, float b, float c, float d) : v0((raw4f){a, b, c, d}) { }
78 :     rep4f (const float *m) : v0((raw4f){m[0], m[1], m[2], m[3]}) { }
79 :     float operator[] (unsigned int const &i) const { return this->v0[i]; }
80 :     };
81 :    
82 :     inline rep4f vec_add (rep4f const &a, rep4f const &b) { return rep4f(a.v0 + b.v0); }
83 :     inline rep4f vec_sub (rep4f const &a, rep4f const &b) { return rep4f(a.v0 - b.v0); }
84 :     inline rep4f vec_scale (float s, rep4f const &a) { return rep4f((raw4f){s, s, s, s} * a.v0); }
85 :     inline rep4f vec_mul (rep4f const &a, rep4f const &b) { return rep4f(a.v0 * b.v0); }
86 :     inline float vec_sum (rep4f const &a) { return a.v0[0] + a.v0[1] + a.v0[1] + a.v0[2]; }
87 :     inline void vec_store (float *m, rep4f const &a) {
88 :     m[0] = a.v0[0]; m[1] = a.v0[1]; m[2] = a.v0[2]; m[3] = a.v0[3];
89 :     }
90 :    
91 :    
92 :     struct rep5f {
93 :     #if (MAX_VEC_WID >= 32)
94 :     raw8f v0; // padded
95 :     #else
96 :     raw4f v0;
97 :     float v1;
98 :     #endif
99 :     };
100 :    
101 :    
102 :     struct rep6f {
103 :     #if (MAX_VEC_WID >= 32)
104 :     raw8f v0; // padded
105 :     #else
106 :     raw4f v0;
107 :     raw2f v1;
108 :     #endif
109 :     };
110 :    
111 :    
112 :     struct rep7f {
113 :     raw8f v0; // padded
114 :     };
115 :    
116 :    
117 :     struct rep8f {
118 :     raw8f v0;
119 :     };
120 :    
121 :    
122 :     /***** Generic vector type *****/
123 :    
124 :     // T is element type, R is representation type, d is dimension
125 :     template <typename T, typename R, unsigned int d>
126 :     struct Vec
127 :     {
128 :     R _rep;
129 :    
130 :     Vec (R const &r) : _rep(r) { }
131 :     Vec (const T *mem) : _rep(mem) { };
132 :    
133 :     void store (T *mem) { vec_store(mem, this->_rep); }
134 :    
135 :     T operator[] (unsigned int const &i) const { return this->_rep[i]; }
136 :     T sum () const;
137 :    
138 :     union View {
139 :     T _arr[d];
140 :     R _raw;
141 :     View () { }
142 :     };
143 :    
144 :     };
145 :    
146 :    
147 :     /***** Specialized vector types *****/
148 :    
149 :     typedef Vec<float,rep2f,2> vec2f;
150 :     typedef Vec<float,rep3f,3> vec3f;
151 :     typedef Vec<float,rep4f,4> vec4f;
152 :    
153 :    
154 :     /***** Generic vector operations *****/
155 :    
156 :     template <typename T, typename R, unsigned int d>
157 :     inline T Vec<T,R,d>::sum () const
158 :     {
159 :     return Vec<T,R,d>(vec_sum (this->_rep));
160 :     }
161 :    
162 :     template <typename T, typename R, unsigned int d>
163 :     inline Vec<T,R,d> operator+ (Vec<T,R,d> const &a, Vec<T,R,d> const &b)
164 :     {
165 :     return Vec<T,R,d>(vec_add (a._rep, b._rep));
166 :     }
167 :    
168 :     template <typename T, typename R, unsigned int d>
169 :     inline Vec<T,R,d> operator- (Vec<T,R,d> const &a, Vec<T,R,d> const &b)
170 :     {
171 :     return Vec<T,R,d>(vec_sub (a._rep, b._rep));
172 :     }
173 :    
174 :     template <typename T, typename R, unsigned int d>
175 :     inline Vec<T,R,d> scale (T s, Vec<T,R,d> const &a)
176 :     {
177 :     return Vec<T,R,d>(vec_scale (s, a));
178 :     }
179 :    
180 :     template <typename T, typename R, unsigned int d>
181 :     inline Vec<T,R,d> operator* (Vec<T,R,d> const &a, Vec<T,R,d> const &b)
182 :     {
183 :     return Vec<T,R,d>(vec_mul (a._rep, b._rep));
184 :     }
185 :    
186 :     template <typename T, typename R, unsigned int d>
187 :     std::ostream& operator<< (std::ostream& s, Vec<T,R,d> const &v)
188 :     {
189 :     union Vec<T,R,d>::View view;
190 :     view._raw = v._rep;
191 :     s << "[" << view._arr[0];
192 :     for (int i = 1; i < d; i++) {
193 :     s << "," << view._arr[i];
194 :     }
195 :     s << "]";
196 :     return s;
197 :     }
198 :    
199 :     #endif // !_VEC_H_

root@smlnj-gforge.cs.uchicago.edu
ViewVC Help
Powered by ViewVC 1.0.0