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 double type.
21  * Provides three double fields packed.
22  */
23 public class Double3 {
24     public double x;
25     public double y;
26     public double z;
27 
Double3()28     public Double3() {
29     }
30     /** @hide */
Double3(Double3 data)31     public Double3(Double3 data) {
32         this.x = data.x;
33         this.y = data.y;
34         this.z = data.z;
35     }
36 
Double3(double x, double y, double z)37     public Double3(double x, double y, double z) {
38         this.x = x;
39         this.y = y;
40         this.z = z;
41     }
42 
43     /** @hide
44      * Vector add
45      *
46      * @param a
47      * @param b
48      * @return
49      */
add(Double3 a, Double3 b)50     public static Double3 add(Double3 a, Double3 b) {
51         Double3 res = new Double3();
52         res.x = a.x + b.x;
53         res.y = a.y + b.y;
54         res.z = a.z + b.z;
55 
56         return res;
57     }
58 
59     /** @hide
60      * Vector add
61      *
62      * @param value
63      */
add(Double3 value)64     public void add(Double3 value) {
65         x += value.x;
66         y += value.y;
67         z += value.z;
68     }
69 
70     /** @hide
71      * Vector add
72      *
73      * @param value
74      */
add(double value)75     public void add(double value) {
76         x += value;
77         y += value;
78         z += value;
79     }
80 
81     /** @hide
82      * Vector add
83      *
84      * @param a
85      * @param b
86      * @return
87      */
add(Double3 a, double b)88     public static Double3 add(Double3 a, double b) {
89         Double3 res = new Double3();
90         res.x = a.x + b;
91         res.y = a.y + b;
92         res.z = a.z + b;
93 
94         return res;
95     }
96 
97     /** @hide
98      * Vector subtraction
99      *
100      * @param value
101      */
sub(Double3 value)102     public void sub(Double3 value) {
103         x -= value.x;
104         y -= value.y;
105         z -= value.z;
106     }
107 
108     /** @hide
109      * Vector subtraction
110      *
111      * @param a
112      * @param b
113      * @return
114      */
sub(Double3 a, Double3 b)115     public static Double3 sub(Double3 a, Double3 b) {
116         Double3 res = new Double3();
117         res.x = a.x - b.x;
118         res.y = a.y - b.y;
119         res.z = a.z - b.z;
120 
121         return res;
122     }
123 
124     /** @hide
125      * Vector subtraction
126      *
127      * @param value
128      */
sub(double value)129     public void sub(double value) {
130         x -= value;
131         y -= value;
132         z -= value;
133     }
134 
135     /** @hide
136      * Vector subtraction
137      *
138      * @param a
139      * @param b
140      * @return
141      */
sub(Double3 a, double b)142     public static Double3 sub(Double3 a, double b) {
143         Double3 res = new Double3();
144         res.x = a.x - b;
145         res.y = a.y - b;
146         res.z = a.z - b;
147 
148         return res;
149     }
150 
151     /** @hide
152      * Vector multiplication
153      *
154      * @param value
155      */
mul(Double3 value)156     public void mul(Double3 value) {
157         x *= value.x;
158         y *= value.y;
159         z *= value.z;
160     }
161 
162     /** @hide
163      * Vector multiplication
164      *
165      * @param a
166      * @param b
167      * @return
168      */
mul(Double3 a, Double3 b)169     public static Double3 mul(Double3 a, Double3 b) {
170         Double3 res = new Double3();
171         res.x = a.x * b.x;
172         res.y = a.y * b.y;
173         res.z = a.z * b.z;
174 
175         return res;
176     }
177 
178     /** @hide
179      * Vector multiplication
180      *
181      * @param value
182      */
mul(double value)183     public void mul(double value) {
184         x *= value;
185         y *= value;
186         z *= value;
187     }
188 
189     /** @hide
190      * Vector multiplication
191      *
192      * @param a
193      * @param b
194      * @return
195      */
mul(Double3 a, double b)196     public static Double3 mul(Double3 a, double b) {
197         Double3 res = new Double3();
198         res.x = a.x * b;
199         res.y = a.y * b;
200         res.z = a.z * b;
201 
202         return res;
203     }
204 
205     /** @hide
206      * Vector division
207      *
208      * @param value
209      */
div(Double3 value)210     public void div(Double3 value) {
211         x /= value.x;
212         y /= value.y;
213         z /= value.z;
214     }
215 
216     /** @hide
217      * Vector division
218      *
219      * @param a
220      * @param b
221      * @return
222      */
div(Double3 a, Double3 b)223     public static Double3 div(Double3 a, Double3 b) {
224         Double3 res = new Double3();
225         res.x = a.x / b.x;
226         res.y = a.y / b.y;
227         res.z = a.z / b.z;
228 
229         return res;
230     }
231 
232     /** @hide
233      * Vector division
234      *
235      * @param value
236      */
div(double value)237     public void div(double value) {
238         x /= value;
239         y /= value;
240         z /= value;
241     }
242 
243     /** @hide
244      * Vector division
245      *
246      * @param a
247      * @param b
248      * @return
249      */
div(Double3 a, double b)250     public static Double3 div(Double3 a, double b) {
251         Double3 res = new Double3();
252         res.x = a.x / b;
253         res.y = a.y / b;
254         res.z = a.z / b;
255 
256         return res;
257     }
258 
259     /** @hide
260      * Vector dot Product
261      *
262      * @param a
263      * @return
264      */
dotProduct(Double3 a)265     public double dotProduct(Double3 a) {
266         return (x * a.x) + (y * a.y) + (z * a.z);
267     }
268 
269     /** @hide
270      * Vector dot Product
271      *
272      * @param a
273      * @param b
274      * @return
275      */
dotProduct(Double3 a, Double3 b)276     public static double dotProduct(Double3 a, Double3 b) {
277         return (b.x * a.x) + (b.y * a.y) + (b.z * a.z);
278     }
279 
280     /** @hide
281      * Vector add Multiple
282      *
283      * @param a
284      * @param factor
285      */
addMultiple(Double3 a, double factor)286     public void addMultiple(Double3 a, double factor) {
287         x += a.x * factor;
288         y += a.y * factor;
289         z += a.z * factor;
290     }
291 
292     /** @hide
293      * Set vector value by double3
294      *
295      * @param a
296      */
set(Double3 a)297     public void set(Double3 a) {
298         this.x = a.x;
299         this.y = a.y;
300         this.z = a.z;
301     }
302 
303     /** @hide
304      * Set vector negate
305      */
negate()306     public void negate() {
307         x = -x;
308         y = -y;
309         z = -z;
310     }
311 
312     /** @hide
313      * Get vector length
314      *
315      * @return
316      */
length()317     public int length() {
318         return 3;
319     }
320 
321     /** @hide
322      * Return the element sum of vector
323      *
324      * @return
325      */
elementSum()326     public double elementSum() {
327         return x + y + z;
328     }
329 
330     /** @hide
331      * Get the vector field value by index
332      *
333      * @param i
334      * @return
335      */
get(int i)336     public double get(int i) {
337         switch (i) {
338         case 0:
339             return x;
340         case 1:
341             return y;
342         case 2:
343             return z;
344         default:
345             throw new IndexOutOfBoundsException("Index: i");
346         }
347     }
348 
349     /** @hide
350      * Set the vector field value by index
351      *
352      * @param i
353      * @param value
354      */
setAt(int i, double value)355     public void setAt(int i, double value) {
356         switch (i) {
357         case 0:
358             x = value;
359             return;
360         case 1:
361             y = value;
362             return;
363         case 2:
364             z = value;
365             return;
366         default:
367             throw new IndexOutOfBoundsException("Index: i");
368         }
369     }
370 
371     /** @hide
372      * Add the vector field value by index
373      *
374      * @param i
375      * @param value
376      */
addAt(int i, double value)377     public void addAt(int i, double value) {
378         switch (i) {
379         case 0:
380             x += value;
381             return;
382         case 1:
383             y += value;
384             return;
385         case 2:
386             z += value;
387             return;
388         default:
389             throw new IndexOutOfBoundsException("Index: i");
390         }
391     }
392 
393     /** @hide
394      * Set the vector field value
395      *
396      * @param x
397      * @param y
398      * @param z
399      */
setValues(double x, double y, double z)400     public void setValues(double x, double y, double z) {
401         this.x = x;
402         this.y = y;
403         this.z = z;
404     }
405 
406     /** @hide
407      * Copy the vector to double array
408      *
409      * @param data
410      * @param offset
411      */
copyTo(double[] data, int offset)412     public void copyTo(double[] data, int offset) {
413         data[offset] = x;
414         data[offset + 1] = y;
415         data[offset + 2] = z;
416     }
417 }
418