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