1 /*
2  * Copyright (C) 2013 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 package android.renderscript;
18 
19 /**
20  * Vector version of the basic short type.
21  * Provides four short fields packed.
22  */
23 public class Short4 {
24     public short x;
25     public short y;
26     public short z;
27     public short w;
28 
Short4()29     public Short4() {
30     }
31 
32     /** @hide */
Short4(short i)33     public Short4(short i) {
34         this.x = this.y = this.z = this.w = i;
35     }
36 
Short4(short x, short y, short z, short w)37     public Short4(short x, short y, short z, short w) {
38         this.x = x;
39         this.y = y;
40         this.z = z;
41         this.w = w;
42     }
43 
44     /** @hide */
Short4(Short4 source)45     public Short4(Short4 source) {
46         this.x = source.x;
47         this.y = source.y;
48         this.z = source.z;
49         this.w = source.w;
50     }
51 
52     /** @hide
53      * Vector add
54      *
55      * @param a
56      */
add(Short4 a)57     public void add(Short4 a) {
58         this.x += a.x;
59         this.y += a.y;
60         this.z += a.z;
61         this.w += a.w;
62     }
63 
64     /** @hide
65      * Vector add
66      *
67      * @param a
68      * @param b
69      * @return
70      */
add(Short4 a, Short4 b)71     public static Short4 add(Short4 a, Short4 b) {
72         Short4 result = new Short4();
73         result.x = (short)(a.x + b.x);
74         result.y = (short)(a.y + b.y);
75         result.z = (short)(a.z + b.z);
76         result.w = (short)(a.w + b.w);
77 
78         return result;
79     }
80 
81     /** @hide
82      * Vector add
83      *
84      * @param value
85      */
add(short value)86     public void add(short value) {
87         x += value;
88         y += value;
89         z += value;
90         w += value;
91     }
92 
93     /** @hide
94      * Vector add
95      *
96      * @param a
97      * @param b
98      * @return
99      */
add(Short4 a, short b)100     public static Short4 add(Short4 a, short b) {
101         Short4 result = new Short4();
102         result.x = (short)(a.x + b);
103         result.y = (short)(a.y + b);
104         result.z = (short)(a.z + b);
105         result.w = (short)(a.w + b);
106 
107         return result;
108     }
109 
110     /** @hide
111      * Vector subtraction
112      *
113      * @param a
114      */
sub(Short4 a)115     public void sub(Short4 a) {
116         this.x -= a.x;
117         this.y -= a.y;
118         this.z -= a.z;
119         this.w -= a.w;
120     }
121 
122     /** @hide
123      * Vector subtraction
124      *
125      * @param a
126      * @param b
127      * @return
128      */
sub(Short4 a, Short4 b)129     public static Short4 sub(Short4 a, Short4 b) {
130         Short4 result = new Short4();
131         result.x = (short)(a.x - b.x);
132         result.y = (short)(a.y - b.y);
133         result.z = (short)(a.z - b.z);
134         result.w = (short)(a.w - b.w);
135 
136         return result;
137     }
138 
139     /** @hide
140      * Vector subtraction
141      *
142      * @param value
143      */
sub(short value)144     public void sub(short value) {
145         x -= value;
146         y -= value;
147         z -= value;
148         w -= value;
149     }
150 
151     /** @hide
152      * Vector subtraction
153      *
154      * @param a
155      * @param b
156      * @return
157      */
sub(Short4 a, short b)158     public static Short4 sub(Short4 a, short b) {
159         Short4 result = new Short4();
160         result.x = (short)(a.x - b);
161         result.y = (short)(a.y - b);
162         result.z = (short)(a.z - b);
163         result.w = (short)(a.w - b);
164 
165         return result;
166     }
167 
168     /** @hide
169      * Vector multiplication
170      *
171      * @param a
172      */
mul(Short4 a)173     public void mul(Short4 a) {
174         this.x *= a.x;
175         this.y *= a.y;
176         this.z *= a.z;
177         this.w *= a.w;
178     }
179 
180     /** @hide
181      * Vector multiplication
182      *
183      * @param a
184      * @param b
185      * @return
186      */
mul(Short4 a, Short4 b)187     public static Short4 mul(Short4 a, Short4 b) {
188         Short4 result = new Short4();
189         result.x = (short)(a.x * b.x);
190         result.y = (short)(a.y * b.y);
191         result.z = (short)(a.z * b.z);
192         result.w = (short)(a.w * b.w);
193 
194         return result;
195     }
196 
197     /** @hide
198      * Vector multiplication
199      *
200      * @param value
201      */
mul(short value)202     public void mul(short value) {
203         x *= value;
204         y *= value;
205         z *= value;
206         w *= value;
207     }
208 
209     /** @hide
210      * Vector multiplication
211      *
212      * @param a
213      * @param b
214      * @return
215      */
mul(Short4 a, short b)216     public static Short4 mul(Short4 a, short b) {
217         Short4 result = new Short4();
218         result.x = (short)(a.x * b);
219         result.y = (short)(a.y * b);
220         result.z = (short)(a.z * b);
221         result.w = (short)(a.w * b);
222 
223         return result;
224     }
225 
226     /** @hide
227      * Vector division
228      *
229      * @param a
230      */
div(Short4 a)231     public void div(Short4 a) {
232         this.x /= a.x;
233         this.y /= a.y;
234         this.z /= a.z;
235         this.w /= a.w;
236     }
237 
238     /** @hide
239      * Vector division
240      *
241      * @param a
242      * @param b
243      * @return
244      */
div(Short4 a, Short4 b)245     public static Short4 div(Short4 a, Short4 b) {
246         Short4 result = new Short4();
247         result.x = (short)(a.x / b.x);
248         result.y = (short)(a.y / b.y);
249         result.z = (short)(a.z / b.z);
250         result.w = (short)(a.w / b.w);
251 
252         return result;
253     }
254 
255     /** @hide
256      * Vector division
257      *
258      * @param value
259      */
div(short value)260     public void div(short value) {
261         x /= value;
262         y /= value;
263         z /= value;
264         w /= value;
265     }
266 
267     /** @hide
268      * Vector division
269      *
270      * @param a
271      * @param b
272      * @return
273      */
div(Short4 a, short b)274     public static Short4 div(Short4 a, short b) {
275         Short4 result = new Short4();
276         result.x = (short)(a.x / b);
277         result.y = (short)(a.y / b);
278         result.z = (short)(a.z / b);
279         result.w = (short)(a.w / b);
280 
281         return result;
282     }
283 
284     /** @hide
285      * Vector Modulo
286      *
287      * @param a
288      */
mod(Short4 a)289     public void mod(Short4 a) {
290         this.x %= a.x;
291         this.y %= a.y;
292         this.z %= a.z;
293         this.w %= a.w;
294     }
295 
296     /** @hide
297      * Vector Modulo
298      *
299      * @param a
300      * @param b
301      * @return
302      */
mod(Short4 a, Short4 b)303     public static Short4 mod(Short4 a, Short4 b) {
304         Short4 result = new Short4();
305         result.x = (short)(a.x % b.x);
306         result.y = (short)(a.y % b.y);
307         result.z = (short)(a.z % b.z);
308         result.w = (short)(a.w % b.w);
309 
310         return result;
311     }
312 
313     /** @hide
314      * Vector Modulo
315      *
316      * @param value
317      */
mod(short value)318     public void mod(short value) {
319         x %= value;
320         y %= value;
321         z %= value;
322         w %= value;
323     }
324 
325     /** @hide
326      * Vector Modulo
327      *
328      * @param a
329      * @param b
330      * @return
331      */
mod(Short4 a, short b)332     public static Short4 mod(Short4 a, short b) {
333         Short4 result = new Short4();
334         result.x = (short)(a.x % b);
335         result.y = (short)(a.y % b);
336         result.z = (short)(a.z % b);
337         result.w = (short)(a.w % b);
338 
339         return result;
340     }
341 
342     /** @hide
343      * get vector length
344      *
345      * @return
346      */
length()347     public short length() {
348         return 4;
349     }
350 
351     /** @hide
352      * set vector negate
353      */
negate()354     public void negate() {
355         this.x = (short)(-x);
356         this.y = (short)(-y);
357         this.z = (short)(-z);
358         this.w = (short)(-w);
359     }
360 
361     /** @hide
362      * Vector dot Product
363      *
364      * @param a
365      * @return
366      */
dotProduct(Short4 a)367     public short dotProduct(Short4 a) {
368         return (short)((x * a.x) + (y * a.y) + (z * a.z) + (w * a.w));
369     }
370 
371     /** @hide
372      * Vector dot Product
373      *
374      * @param a
375      * @param b
376      * @return
377      */
dotProduct(Short4 a, Short4 b)378     public static short dotProduct(Short4 a, Short4 b) {
379         return (short)((b.x * a.x) + (b.y * a.y) + (b.z * a.z) + (b.w * a.w));
380     }
381 
382     /** @hide
383      * Vector add Multiple
384      *
385      * @param a
386      * @param factor
387      */
addMultiple(Short4 a, short factor)388     public void addMultiple(Short4 a, short factor) {
389         x += a.x * factor;
390         y += a.y * factor;
391         z += a.z * factor;
392         w += a.w * factor;
393     }
394 
395     /** @hide
396      * set vector value by Short4
397      *
398      * @param a
399      */
set(Short4 a)400     public void set(Short4 a) {
401         this.x = a.x;
402         this.y = a.y;
403         this.z = a.z;
404         this.w = a.w;
405     }
406 
407     /** @hide
408      * set the vector field value by Short
409      *
410      * @param a
411      * @param b
412      * @param c
413      * @param d
414      */
setValues(short a, short b, short c, short d)415     public void setValues(short a, short b, short c, short d) {
416         this.x = a;
417         this.y = b;
418         this.z = c;
419         this.w = d;
420     }
421 
422     /** @hide
423      * return the element sum of vector
424      *
425      * @return
426      */
elementSum()427     public short elementSum() {
428         return (short)(x + y + z + w);
429     }
430 
431     /** @hide
432      * get the vector field value by index
433      *
434      * @param i
435      * @return
436      */
get(int i)437     public short get(int i) {
438         switch (i) {
439         case 0:
440             return (short)(x);
441         case 1:
442             return (short)(y);
443         case 2:
444             return (short)(z);
445         case 3:
446             return (short)(w);
447         default:
448             throw new IndexOutOfBoundsException("Index: i");
449         }
450     }
451 
452     /** @hide
453      * set the vector field value by index
454      *
455      * @param i
456      * @param value
457      */
setAt(int i, short value)458     public void setAt(int i, short value) {
459         switch (i) {
460         case 0:
461             x = value;
462             return;
463         case 1:
464             y = value;
465             return;
466         case 2:
467             z = value;
468             return;
469         case 3:
470             w = value;
471             return;
472         default:
473             throw new IndexOutOfBoundsException("Index: i");
474         }
475     }
476 
477     /** @hide
478      * add the vector field value by index
479      *
480      * @param i
481      * @param value
482      */
addAt(int i, short value)483     public void addAt(int i, short value) {
484         switch (i) {
485         case 0:
486             x += value;
487             return;
488         case 1:
489             y += value;
490             return;
491         case 2:
492             z += value;
493             return;
494         case 3:
495             w += value;
496             return;
497         default:
498             throw new IndexOutOfBoundsException("Index: i");
499         }
500     }
501 
502     /** @hide
503      * copy the vector to short array
504      *
505      * @param data
506      * @param offset
507      */
copyTo(short[] data, int offset)508     public void copyTo(short[] data, int offset) {
509         data[offset] = (short)(x);
510         data[offset + 1] = (short)(y);
511         data[offset + 2] = (short)(z);
512         data[offset + 3] = (short)(w);
513     }
514 }
515