1/*
2 * Copyright (C) 2012 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
17package com.android.rs.test;
18
19import android.content.Context;
20import android.renderscript.Byte2;
21import android.renderscript.Byte3;
22import android.renderscript.Byte4;
23import android.renderscript.Float2;
24import android.renderscript.Float3;
25import android.renderscript.Float4;
26import android.renderscript.Int2;
27import android.renderscript.Int3;
28import android.renderscript.Int4;
29import android.renderscript.Long2;
30import android.renderscript.Long3;
31import android.renderscript.Long4;
32import android.renderscript.RenderScript;
33import android.renderscript.Short2;
34import android.renderscript.Short3;
35import android.renderscript.Short4;
36
37import java.util.Random;
38
39public class UT_math_agree extends UnitTest {
40    private Random rand;
41
42    protected UT_math_agree(RSTestCore rstc, Context ctx) {
43        super(rstc, "Math Agreement", ctx);
44        rand = new Random();
45    }
46
47    // packing functions
48    private Float2 pack_f2(float[] val) {
49        assert val.length == 2;
50        return new Float2(val[0], val[1]);
51    }
52
53    private Float3 pack_f3(float[] val) {
54        assert val.length == 3;
55        return new Float3(val[0], val[1], val[2]);
56    }
57
58    private Float4 pack_f4(float[] val) {
59        assert val.length == 4;
60        return new Float4(val[0], val[1], val[2], val[3]);
61    }
62
63    private Byte2 pack_b2(byte[] val) {
64        assert val.length == 2;
65        return new Byte2(val[0], val[1]);
66    }
67
68    private Byte3 pack_b3(byte[] val) {
69        assert val.length == 3;
70        return new Byte3(val[0], val[1], val[2]);
71    }
72
73    private Byte4 pack_b4(byte[] val) {
74        assert val.length == 4;
75        return new Byte4(val[0], val[1], val[2], val[3]);
76    }
77
78    private Short2 pack_s2(short[] val) {
79        assert val.length == 2;
80        return new Short2(val[0], val[1]);
81    }
82
83    private Short3 pack_s3(short[] val) {
84        assert val.length == 3;
85        return new Short3(val[0], val[1], val[2]);
86    }
87
88    private Short4 pack_s4(short[] val) {
89        assert val.length == 4;
90        return new Short4(val[0], val[1], val[2], val[3]);
91    }
92
93    private Int2 pack_i2(int[] val) {
94        assert val.length == 2;
95        return new Int2(val[0], val[1]);
96    }
97
98    private Int3 pack_i3(int[] val) {
99        assert val.length == 3;
100        return new Int3(val[0], val[1], val[2]);
101    }
102
103    private Int4 pack_i4(int[] val) {
104        assert val.length == 4;
105        return new Int4(val[0], val[1], val[2], val[3]);
106    }
107
108    private Long2 pack_l2(long[] val) {
109        assert val.length == 2;
110        return new Long2(val[0], val[1]);
111    }
112
113    private Long3 pack_l3(long[] val) {
114        assert val.length == 3;
115        return new Long3(val[0], val[1], val[2]);
116    }
117
118    private Long4 pack_l4(long[] val) {
119        assert val.length == 4;
120        return new Long4(val[0], val[1], val[2], val[3]);
121    }
122
123    // random vector generation functions
124    private float[] randvec_float(int dim) {
125        float[] fv = new float[dim];
126        for (int i = 0; i < dim; ++i)
127            fv[i] = rand.nextFloat();
128        return fv;
129    }
130
131    private byte[] randvec_char(int dim) {
132        byte[] cv = new byte[dim];
133        rand.nextBytes(cv);
134        return cv;
135    }
136
137    private short[] randvec_uchar(int dim) {
138        short[] ucv = new short[dim];
139        for (int i = 0; i < dim; ++i)
140            ucv[i] = (short) rand.nextInt(0x1 << 8);
141        return ucv;
142    }
143
144    private short[] randvec_short(int dim) {
145        short[] sv = new short[dim];
146        for (int i = 0; i < dim; ++i)
147            sv[i] = (short) rand.nextInt(0x1 << 16);
148        return sv;
149    }
150
151    private int[] randvec_ushort(int dim) {
152        int[] usv = new int[dim];
153        for (int i = 0; i < dim; ++i)
154            usv[i] = rand.nextInt(0x1 << 16);
155        return usv;
156    }
157
158    private int[] randvec_int(int dim) {
159        int[] iv = new int[dim];
160        for (int i = 0; i < dim; ++i)
161            iv[i] = rand.nextInt();
162        return iv;
163    }
164
165    private long[] randvec_uint(int dim) {
166        long[] uiv = new long[dim];
167        for (int i = 0; i < dim; ++i)
168            uiv[i] = (long) rand.nextInt() - (long) Integer.MIN_VALUE;
169        return uiv;
170    }
171
172    private long[] randvec_long(int dim) {
173        long[] lv = new long[dim];
174        for (int i = 0; i < dim; ++i)
175            lv[i] = rand.nextLong();
176        return lv;
177    }
178    // TODO:  unsigned long generator
179
180    // min reference functions
181    private float min(float v1, float v2) {
182        return v1 < v2 ? v1 : v2;
183    }
184
185    private float[] min(float[] v1, float[] v2) {
186        assert v1.length == v2.length;
187        float[] rv = new float[v1.length];
188        for (int i = 0; i < v1.length; ++i)
189            rv[i] = min(v1[i], v2[i]);
190        return rv;
191    }
192
193    private byte min(byte v1, byte v2) {
194        return v1 < v2 ? v1 : v2;
195    }
196
197    private byte[] min(byte[] v1, byte[] v2) {
198        assert v1.length == v2.length;
199        byte[] rv = new byte[v1.length];
200        for (int i = 0; i < v1.length; ++i)
201            rv[i] = min(v1[i], v2[i]);
202        return rv;
203    }
204
205    private short min(short v1, short v2) {
206        return v1 < v2 ? v1 : v2;
207    }
208
209    private short[] min(short[] v1, short[] v2) {
210        assert v1.length == v2.length;
211        short[] rv = new short[v1.length];
212        for (int i = 0; i < v1.length; ++i)
213            rv[i] = min(v1[i], v2[i]);
214        return rv;
215    }
216
217    private int min(int v1, int v2) {
218        return v1 < v2 ? v1 : v2;
219    }
220
221    private int[] min(int[] v1, int[] v2) {
222        assert v1.length == v2.length;
223        int[] rv = new int[v1.length];
224        for (int i = 0; i < v1.length; ++i)
225            rv[i] = min(v1[i], v2[i]);
226        return rv;
227    }
228
229    private long min(long v1, long v2) {
230        return v1 < v2 ? v1 : v2;
231    }
232
233    private long[] min(long[] v1, long[] v2) {
234        assert v1.length == v2.length;
235        long[] rv = new long[v1.length];
236        for (int i = 0; i < v1.length; ++i)
237            rv[i] = min(v1[i], v2[i]);
238        return rv;
239    }
240    // TODO:  unsigned long version of min
241
242    // max reference functions
243    private float max(float v1, float v2) {
244        return v1 > v2 ? v1 : v2;
245    }
246
247    private float[] max(float[] v1, float[] v2) {
248        assert v1.length == v2.length;
249        float[] rv = new float[v1.length];
250        for (int i = 0; i < v1.length; ++i)
251            rv[i] = max(v1[i], v2[i]);
252        return rv;
253    }
254
255    private byte max(byte v1, byte v2) {
256        return v1 > v2 ? v1 : v2;
257    }
258
259    private byte[] max(byte[] v1, byte[] v2) {
260        assert v1.length == v2.length;
261        byte[] rv = new byte[v1.length];
262        for (int i = 0; i < v1.length; ++i)
263            rv[i] = max(v1[i], v2[i]);
264        return rv;
265    }
266
267    private short max(short v1, short v2) {
268        return v1 > v2 ? v1 : v2;
269    }
270
271    private short[] max(short[] v1, short[] v2) {
272        assert v1.length == v2.length;
273        short[] rv = new short[v1.length];
274        for (int i = 0; i < v1.length; ++i)
275            rv[i] = max(v1[i], v2[i]);
276        return rv;
277    }
278
279    private int max(int v1, int v2) {
280        return v1 > v2 ? v1 : v2;
281    }
282
283    private int[] max(int[] v1, int[] v2) {
284        assert v1.length == v2.length;
285        int[] rv = new int[v1.length];
286        for (int i = 0; i < v1.length; ++i)
287            rv[i] = max(v1[i], v2[i]);
288        return rv;
289    }
290
291    private long max(long v1, long v2) {
292        return v1 > v2 ? v1 : v2;
293    }
294
295    private long[] max(long[] v1, long[] v2) {
296        assert v1.length == v2.length;
297        long[] rv = new long[v1.length];
298        for (int i = 0; i < v1.length; ++i)
299            rv[i] = max(v1[i], v2[i]);
300        return rv;
301    }
302    // TODO:  unsigned long version of max
303
304    // fmin reference functions
305    private float fmin(float v1, float v2) {
306        return min(v1, v2);
307    }
308
309    private float[] fmin(float[] v1, float[] v2) {
310        return min(v1, v2);
311    }
312
313    private float[] fmin(float[] v1, float v2) {
314        float[] rv = new float[v1.length];
315        for (int i = 0; i < v1.length; ++i)
316            rv[i] = min(v1[i], v2);
317        return rv;
318    }
319
320    // fmax reference functions
321    private float fmax(float v1, float v2) {
322        return max(v1, v2);
323    }
324
325    private float[] fmax(float[] v1, float[] v2) {
326        return max(v1, v2);
327    }
328
329    private float[] fmax(float[] v1, float v2) {
330        float[] rv = new float[v1.length];
331        for (int i = 0; i < v1.length; ++i)
332            rv[i] = max(v1[i], v2);
333        return rv;
334    }
335
336    private void initializeValues(ScriptC_math_agree s) {
337        float x = rand.nextFloat();
338        float y = rand.nextFloat();
339
340        s.set_x(x);
341        s.set_y(y);
342        s.set_result_add(x + y);
343        s.set_result_sub(x - y);
344        s.set_result_mul(x * y);
345        s.set_result_div(x / y);
346
347        // Generate random vectors of all types
348        float rand_f1_0 = rand.nextFloat();
349        float[] rand_f2_0 = randvec_float(2);
350        float[] rand_f3_0 = randvec_float(3);
351        float[] rand_f4_0 = randvec_float(4);
352        float rand_f1_1 = rand.nextFloat();
353        float[] rand_f2_1 = randvec_float(2);
354        float[] rand_f3_1 = randvec_float(3);
355        float[] rand_f4_1 = randvec_float(4);
356        short rand_uc1_0 = (short) rand.nextInt(0x1 << 8);
357        short[] rand_uc2_0 = randvec_uchar(2);
358        short[] rand_uc3_0 = randvec_uchar(3);
359        short[] rand_uc4_0 = randvec_uchar(4);
360        short rand_uc1_1 = (short) rand.nextInt(0x1 << 8);
361        short[] rand_uc2_1 = randvec_uchar(2);
362        short[] rand_uc3_1 = randvec_uchar(3);
363        short[] rand_uc4_1 = randvec_uchar(4);
364        short rand_ss1_0 = (short) rand.nextInt(0x1 << 16);
365        short[] rand_ss2_0 = randvec_short(2);
366        short[] rand_ss3_0 = randvec_short(3);
367        short[] rand_ss4_0 = randvec_short(4);
368        short rand_ss1_1 = (short) rand.nextInt(0x1 << 16);
369        short[] rand_ss2_1 = randvec_short(2);
370        short[] rand_ss3_1 = randvec_short(3);
371        short[] rand_ss4_1 = randvec_short(4);
372        int rand_us1_0 = rand.nextInt(0x1 << 16);
373        int[] rand_us2_0 = randvec_ushort(2);
374        int[] rand_us3_0 = randvec_ushort(3);
375        int[] rand_us4_0 = randvec_ushort(4);
376        int rand_us1_1 = rand.nextInt(0x1 << 16);
377        int[] rand_us2_1 = randvec_ushort(2);
378        int[] rand_us3_1 = randvec_ushort(3);
379        int[] rand_us4_1 = randvec_ushort(4);
380        int rand_si1_0 = rand.nextInt();
381        int[] rand_si2_0 = randvec_int(2);
382        int[] rand_si3_0 = randvec_int(3);
383        int[] rand_si4_0 = randvec_int(4);
384        int rand_si1_1 = rand.nextInt();
385        int[] rand_si2_1 = randvec_int(2);
386        int[] rand_si3_1 = randvec_int(3);
387        int[] rand_si4_1 = randvec_int(4);
388        long rand_ui1_0 = (long) rand.nextInt() - (long) Integer.MIN_VALUE;
389        long[] rand_ui2_0 = randvec_uint(2);
390        long[] rand_ui3_0 = randvec_uint(3);
391        long[] rand_ui4_0 = randvec_uint(4);
392        long rand_ui1_1 = (long) rand.nextInt() - (long) Integer.MIN_VALUE;
393        long[] rand_ui2_1 = randvec_uint(2);
394        long[] rand_ui3_1 = randvec_uint(3);
395        long[] rand_ui4_1 = randvec_uint(4);
396        long rand_sl1_0 = rand.nextLong();
397        long[] rand_sl2_0 = randvec_long(2);
398        long[] rand_sl3_0 = randvec_long(3);
399        long[] rand_sl4_0 = randvec_long(4);
400        long rand_sl1_1 = rand.nextLong();
401        long[] rand_sl2_1 = randvec_long(2);
402        long[] rand_sl3_1 = randvec_long(3);
403        long[] rand_sl4_1 = randvec_long(4);
404        byte rand_sc1_0 = (byte) rand.nextInt(0x1 << 8);
405        byte[] rand_sc2_0 = randvec_char(2);
406        byte[] rand_sc3_0 = randvec_char(3);
407        byte[] rand_sc4_0 = randvec_char(4);
408        byte rand_sc1_1 = (byte) rand.nextInt(0x1 << 8);
409        byte[] rand_sc2_1 = randvec_char(2);
410        byte[] rand_sc3_1 = randvec_char(3);
411        byte[] rand_sc4_1 = randvec_char(4);
412        // TODO:  generate unsigned long vectors
413
414        // Set random vectors in renderscript code
415        s.set_rand_f1_0(rand_f1_0);
416        s.set_rand_f2_0(pack_f2(rand_f2_0));
417        s.set_rand_f3_0(pack_f3(rand_f3_0));
418        s.set_rand_f4_0(pack_f4(rand_f4_0));
419        s.set_rand_f1_1(rand_f1_1);
420        s.set_rand_f2_1(pack_f2(rand_f2_1));
421        s.set_rand_f3_1(pack_f3(rand_f3_1));
422        s.set_rand_f4_1(pack_f4(rand_f4_1));
423        s.set_rand_uc1_1(rand_uc1_1);
424        s.set_rand_uc2_1(pack_s2(rand_uc2_1));
425        s.set_rand_uc3_1(pack_s3(rand_uc3_1));
426        s.set_rand_uc4_1(pack_s4(rand_uc4_1));
427        s.set_rand_ss1_0(rand_ss1_0);
428        s.set_rand_ss2_0(pack_s2(rand_ss2_0));
429        s.set_rand_ss3_0(pack_s3(rand_ss3_0));
430        s.set_rand_ss4_0(pack_s4(rand_ss4_0));
431        s.set_rand_ss1_1(rand_ss1_1);
432        s.set_rand_ss2_1(pack_s2(rand_ss2_1));
433        s.set_rand_ss3_1(pack_s3(rand_ss3_1));
434        s.set_rand_ss4_1(pack_s4(rand_ss4_1));
435        s.set_rand_us1_0(rand_us1_0);
436        s.set_rand_us2_0(pack_i2(rand_us2_0));
437        s.set_rand_us3_0(pack_i3(rand_us3_0));
438        s.set_rand_us4_0(pack_i4(rand_us4_0));
439        s.set_rand_us1_1(rand_us1_1);
440        s.set_rand_us2_1(pack_i2(rand_us2_1));
441        s.set_rand_us3_1(pack_i3(rand_us3_1));
442        s.set_rand_us4_1(pack_i4(rand_us4_1));
443        s.set_rand_si1_0(rand_si1_0);
444        s.set_rand_si2_0(pack_i2(rand_si2_0));
445        s.set_rand_si3_0(pack_i3(rand_si3_0));
446        s.set_rand_si4_0(pack_i4(rand_si4_0));
447        s.set_rand_si1_1(rand_si1_1);
448        s.set_rand_si2_1(pack_i2(rand_si2_1));
449        s.set_rand_si3_1(pack_i3(rand_si3_1));
450        s.set_rand_si4_1(pack_i4(rand_si4_1));
451        s.set_rand_ui1_0(rand_ui1_0);
452        s.set_rand_ui2_0(pack_l2(rand_ui2_0));
453        s.set_rand_ui3_0(pack_l3(rand_ui3_0));
454        s.set_rand_ui4_0(pack_l4(rand_ui4_0));
455        s.set_rand_ui1_1(rand_ui1_1);
456        s.set_rand_ui2_1(pack_l2(rand_ui2_1));
457        s.set_rand_ui3_1(pack_l3(rand_ui3_1));
458        s.set_rand_ui4_1(pack_l4(rand_ui4_1));
459        s.set_rand_sl1_0(rand_sl1_0);
460        s.set_rand_sl2_0(pack_l2(rand_sl2_0));
461        s.set_rand_sl3_0(pack_l3(rand_sl3_0));
462        s.set_rand_sl4_0(pack_l4(rand_sl4_0));
463        s.set_rand_sl1_1(rand_sl1_1);
464        s.set_rand_sl2_1(pack_l2(rand_sl2_1));
465        s.set_rand_sl3_1(pack_l3(rand_sl3_1));
466        s.set_rand_sl4_1(pack_l4(rand_sl4_1));
467        s.set_rand_uc1_0(rand_uc1_0);
468        s.set_rand_uc2_0(pack_s2(rand_uc2_0));
469        s.set_rand_uc3_0(pack_s3(rand_uc3_0));
470        s.set_rand_uc4_0(pack_s4(rand_uc4_0));
471        s.set_rand_sc1_0(rand_sc1_0);
472        s.set_rand_sc2_0(pack_b2(rand_sc2_0));
473        s.set_rand_sc3_0(pack_b3(rand_sc3_0));
474        s.set_rand_sc4_0(pack_b4(rand_sc4_0));
475        s.set_rand_sc1_1(rand_sc1_1);
476        s.set_rand_sc2_1(pack_b2(rand_sc2_1));
477        s.set_rand_sc3_1(pack_b3(rand_sc3_1));
478        s.set_rand_sc4_1(pack_b4(rand_sc4_1));
479        // TODO:  set unsigned long vectors
480
481        // Set results for min
482        s.set_min_rand_f1_f1(min(rand_f1_0, rand_f1_1));
483        s.set_min_rand_f2_f2(pack_f2(min(rand_f2_0, rand_f2_1)));
484        s.set_min_rand_f3_f3(pack_f3(min(rand_f3_0, rand_f3_1)));
485        s.set_min_rand_f4_f4(pack_f4(min(rand_f4_0, rand_f4_1)));
486        s.set_min_rand_uc1_uc1(min(rand_uc1_0, rand_uc1_1));
487        s.set_min_rand_uc2_uc2(pack_s2(min(rand_uc2_0, rand_uc2_1)));
488        s.set_min_rand_uc3_uc3(pack_s3(min(rand_uc3_0, rand_uc3_1)));
489        s.set_min_rand_uc4_uc4(pack_s4(min(rand_uc4_0, rand_uc4_1)));
490        s.set_min_rand_ss1_ss1(min(rand_ss1_0, rand_ss1_1));
491        s.set_min_rand_ss2_ss2(pack_s2(min(rand_ss2_0, rand_ss2_1)));
492        s.set_min_rand_ss3_ss3(pack_s3(min(rand_ss3_0, rand_ss3_1)));
493        s.set_min_rand_ss4_ss4(pack_s4(min(rand_ss4_0, rand_ss4_1)));
494        s.set_min_rand_us1_us1(min(rand_us1_0, rand_us1_1));
495        s.set_min_rand_us2_us2(pack_i2(min(rand_us2_0, rand_us2_1)));
496        s.set_min_rand_us3_us3(pack_i3(min(rand_us3_0, rand_us3_1)));
497        s.set_min_rand_us4_us4(pack_i4(min(rand_us4_0, rand_us4_1)));
498        s.set_min_rand_si1_si1(min(rand_si1_0, rand_si1_1));
499        s.set_min_rand_si2_si2(pack_i2(min(rand_si2_0, rand_si2_1)));
500        s.set_min_rand_si3_si3(pack_i3(min(rand_si3_0, rand_si3_1)));
501        s.set_min_rand_si4_si4(pack_i4(min(rand_si4_0, rand_si4_1)));
502        s.set_min_rand_ui1_ui1(min(rand_ui1_0, rand_ui1_1));
503        s.set_min_rand_ui2_ui2(pack_l2(min(rand_ui2_0, rand_ui2_1)));
504        s.set_min_rand_ui3_ui3(pack_l3(min(rand_ui3_0, rand_ui3_1)));
505        s.set_min_rand_ui4_ui4(pack_l4(min(rand_ui4_0, rand_ui4_1)));
506        s.set_min_rand_sl1_sl1(min(rand_sl1_0, rand_sl1_1));
507        s.set_min_rand_sl2_sl2(pack_l2(min(rand_sl2_0, rand_sl2_1)));
508        s.set_min_rand_sl3_sl3(pack_l3(min(rand_sl3_0, rand_sl3_1)));
509        s.set_min_rand_sl4_sl4(pack_l4(min(rand_sl4_0, rand_sl4_1)));
510        s.set_min_rand_sc1_sc1(min(rand_sc1_0, rand_sc1_1));
511        s.set_min_rand_sc2_sc2(pack_b2(min(rand_sc2_0, rand_sc2_1)));
512        s.set_min_rand_sc3_sc3(pack_b3(min(rand_sc3_0, rand_sc3_1)));
513        s.set_min_rand_sc4_sc4(pack_b4(min(rand_sc4_0, rand_sc4_1)));
514        // TODO:  set results for unsigned long min
515
516        // Set results for max
517        s.set_max_rand_f1_f1(max(rand_f1_0, rand_f1_1));
518        s.set_max_rand_f2_f2(pack_f2(max(rand_f2_0, rand_f2_1)));
519        s.set_max_rand_f3_f3(pack_f3(max(rand_f3_0, rand_f3_1)));
520        s.set_max_rand_f4_f4(pack_f4(max(rand_f4_0, rand_f4_1)));
521        s.set_max_rand_uc1_uc1(max(rand_uc1_0, rand_uc1_1));
522        s.set_max_rand_uc2_uc2(pack_s2(max(rand_uc2_0, rand_uc2_1)));
523        s.set_max_rand_uc3_uc3(pack_s3(max(rand_uc3_0, rand_uc3_1)));
524        s.set_max_rand_uc4_uc4(pack_s4(max(rand_uc4_0, rand_uc4_1)));
525        s.set_max_rand_ss1_ss1(max(rand_ss1_0, rand_ss1_1));
526        s.set_max_rand_ss2_ss2(pack_s2(max(rand_ss2_0, rand_ss2_1)));
527        s.set_max_rand_ss3_ss3(pack_s3(max(rand_ss3_0, rand_ss3_1)));
528        s.set_max_rand_ss4_ss4(pack_s4(max(rand_ss4_0, rand_ss4_1)));
529        s.set_max_rand_us1_us1(max(rand_us1_0, rand_us1_1));
530        s.set_max_rand_us2_us2(pack_i2(max(rand_us2_0, rand_us2_1)));
531        s.set_max_rand_us3_us3(pack_i3(max(rand_us3_0, rand_us3_1)));
532        s.set_max_rand_us4_us4(pack_i4(max(rand_us4_0, rand_us4_1)));
533        s.set_max_rand_si1_si1(max(rand_si1_0, rand_si1_1));
534        s.set_max_rand_si2_si2(pack_i2(max(rand_si2_0, rand_si2_1)));
535        s.set_max_rand_si3_si3(pack_i3(max(rand_si3_0, rand_si3_1)));
536        s.set_max_rand_si4_si4(pack_i4(max(rand_si4_0, rand_si4_1)));
537        s.set_max_rand_ui1_ui1(max(rand_ui1_0, rand_ui1_1));
538        s.set_max_rand_ui2_ui2(pack_l2(max(rand_ui2_0, rand_ui2_1)));
539        s.set_max_rand_ui3_ui3(pack_l3(max(rand_ui3_0, rand_ui3_1)));
540        s.set_max_rand_ui4_ui4(pack_l4(max(rand_ui4_0, rand_ui4_1)));
541        s.set_max_rand_sl1_sl1(max(rand_sl1_0, rand_sl1_1));
542        s.set_max_rand_sl2_sl2(pack_l2(max(rand_sl2_0, rand_sl2_1)));
543        s.set_max_rand_sl3_sl3(pack_l3(max(rand_sl3_0, rand_sl3_1)));
544        s.set_max_rand_sl4_sl4(pack_l4(max(rand_sl4_0, rand_sl4_1)));
545        s.set_max_rand_sc1_sc1(max(rand_sc1_0, rand_sc1_1));
546        s.set_max_rand_sc2_sc2(pack_b2(max(rand_sc2_0, rand_sc2_1)));
547        s.set_max_rand_sc3_sc3(pack_b3(max(rand_sc3_0, rand_sc3_1)));
548        s.set_max_rand_sc4_sc4(pack_b4(max(rand_sc4_0, rand_sc4_1)));
549
550        // TODO:  set results for unsigned long max
551
552        // Set results for fmin
553        s.set_fmin_rand_f1_f1(fmin(rand_f1_0, rand_f1_1));
554        s.set_fmin_rand_f2_f2(pack_f2(fmin(rand_f2_0, rand_f2_1)));
555        s.set_fmin_rand_f3_f3(pack_f3(fmin(rand_f3_0, rand_f3_1)));
556        s.set_fmin_rand_f4_f4(pack_f4(fmin(rand_f4_0, rand_f4_1)));
557        s.set_fmin_rand_f2_f1(pack_f2(fmin(rand_f2_0, rand_f1_1)));
558        s.set_fmin_rand_f3_f1(pack_f3(fmin(rand_f3_0, rand_f1_1)));
559        s.set_fmin_rand_f4_f1(pack_f4(fmin(rand_f4_0, rand_f1_1)));
560
561        // Set results for fmax
562        s.set_fmax_rand_f1_f1(fmax(rand_f1_0, rand_f1_1));
563        s.set_fmax_rand_f2_f2(pack_f2(fmax(rand_f2_0, rand_f2_1)));
564        s.set_fmax_rand_f3_f3(pack_f3(fmax(rand_f3_0, rand_f3_1)));
565        s.set_fmax_rand_f4_f4(pack_f4(fmax(rand_f4_0, rand_f4_1)));
566        s.set_fmax_rand_f2_f1(pack_f2(fmax(rand_f2_0, rand_f1_1)));
567        s.set_fmax_rand_f3_f1(pack_f3(fmax(rand_f3_0, rand_f1_1)));
568        s.set_fmax_rand_f4_f1(pack_f4(fmax(rand_f4_0, rand_f1_1)));
569    }
570
571    public void run() {
572        RenderScript pRS = RenderScript.create(mCtx);
573        ScriptC_math_agree s = new ScriptC_math_agree(pRS);
574        pRS.setMessageHandler(mRsMessage);
575        initializeValues(s);
576        s.invoke_math_agree_test();
577        pRS.finish();
578        waitForMessage();
579        s.destroy();
580        pRS.destroy();
581    }
582}
583