1 /*
2  * Copyright (C) 2016 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 // Don't edit this file!  It is auto-generated by frameworks/rs/api/generate.sh.
18 
19 package android.renderscript.cts;
20 
21 import android.renderscript.Allocation;
22 import android.renderscript.RSRuntimeException;
23 import android.renderscript.Element;
24 import android.renderscript.cts.Target;
25 
26 import java.util.Arrays;
27 
28 public class TestLgamma extends RSBaseCompute {
29 
30     private ScriptC_TestLgamma script;
31     private ScriptC_TestLgammaRelaxed scriptRelaxed;
32 
33     @Override
setUp()34     protected void setUp() throws Exception {
35         super.setUp();
36         script = new ScriptC_TestLgamma(mRS);
37         scriptRelaxed = new ScriptC_TestLgammaRelaxed(mRS);
38     }
39 
40     @Override
tearDown()41     protected void tearDown() throws Exception {
42         script.destroy();
43         scriptRelaxed.destroy();
44         super.tearDown();
45     }
46 
47     public class ArgumentsFloatFloat {
48         public float inV;
49         public Target.Floaty out;
50     }
51 
checkLgammaFloatFloat()52     private void checkLgammaFloatFloat() {
53         Allocation inV = createRandomAllocation(mRS, Element.DataType.FLOAT_32, 1, 0xd9395583050bc4bel, false);
54         try {
55             Allocation out = Allocation.createSized(mRS, getElement(mRS, Element.DataType.FLOAT_32, 1), INPUTSIZE);
56             script.forEach_testLgammaFloatFloat(inV, out);
57             verifyResultsLgammaFloatFloat(inV, out, false);
58             out.destroy();
59         } catch (Exception e) {
60             throw new RSRuntimeException("RenderScript. Can't invoke forEach_testLgammaFloatFloat: " + e.toString());
61         }
62         try {
63             Allocation out = Allocation.createSized(mRS, getElement(mRS, Element.DataType.FLOAT_32, 1), INPUTSIZE);
64             scriptRelaxed.forEach_testLgammaFloatFloat(inV, out);
65             verifyResultsLgammaFloatFloat(inV, out, true);
66             out.destroy();
67         } catch (Exception e) {
68             throw new RSRuntimeException("RenderScript. Can't invoke forEach_testLgammaFloatFloat: " + e.toString());
69         }
70         inV.destroy();
71     }
72 
verifyResultsLgammaFloatFloat(Allocation inV, Allocation out, boolean relaxed)73     private void verifyResultsLgammaFloatFloat(Allocation inV, Allocation out, boolean relaxed) {
74         float[] arrayInV = new float[INPUTSIZE * 1];
75         Arrays.fill(arrayInV, (float) 42);
76         inV.copyTo(arrayInV);
77         float[] arrayOut = new float[INPUTSIZE * 1];
78         Arrays.fill(arrayOut, (float) 42);
79         out.copyTo(arrayOut);
80         StringBuilder message = new StringBuilder();
81         boolean errorFound = false;
82         for (int i = 0; i < INPUTSIZE; i++) {
83             for (int j = 0; j < 1 ; j++) {
84                 // Extract the inputs.
85                 ArgumentsFloatFloat args = new ArgumentsFloatFloat();
86                 args.inV = arrayInV[i];
87                 // Figure out what the outputs should have been.
88                 Target target = new Target(Target.FunctionType.NORMAL, Target.ReturnType.FLOAT, relaxed);
89                 CoreMathVerifier.computeLgamma(args, target);
90                 // Validate the outputs.
91                 boolean valid = true;
92                 if (!args.out.couldBe(arrayOut[i * 1 + j])) {
93                     valid = false;
94                 }
95                 if (!valid) {
96                     if (!errorFound) {
97                         errorFound = true;
98                         message.append("Input inV: ");
99                         appendVariableToMessage(message, args.inV);
100                         message.append("\n");
101                         message.append("Expected output out: ");
102                         appendVariableToMessage(message, args.out);
103                         message.append("\n");
104                         message.append("Actual   output out: ");
105                         appendVariableToMessage(message, arrayOut[i * 1 + j]);
106                         if (!args.out.couldBe(arrayOut[i * 1 + j])) {
107                             message.append(" FAIL");
108                         }
109                         message.append("\n");
110                         message.append("Errors at");
111                     }
112                     message.append(" [");
113                     message.append(Integer.toString(i));
114                     message.append(", ");
115                     message.append(Integer.toString(j));
116                     message.append("]");
117                 }
118             }
119         }
120         assertFalse("Incorrect output for checkLgammaFloatFloat" +
121                 (relaxed ? "_relaxed" : "") + ":\n" + message.toString(), errorFound);
122     }
123 
checkLgammaFloat2Float2()124     private void checkLgammaFloat2Float2() {
125         Allocation inV = createRandomAllocation(mRS, Element.DataType.FLOAT_32, 2, 0xeef55496367a4132l, false);
126         try {
127             Allocation out = Allocation.createSized(mRS, getElement(mRS, Element.DataType.FLOAT_32, 2), INPUTSIZE);
128             script.forEach_testLgammaFloat2Float2(inV, out);
129             verifyResultsLgammaFloat2Float2(inV, out, false);
130             out.destroy();
131         } catch (Exception e) {
132             throw new RSRuntimeException("RenderScript. Can't invoke forEach_testLgammaFloat2Float2: " + e.toString());
133         }
134         try {
135             Allocation out = Allocation.createSized(mRS, getElement(mRS, Element.DataType.FLOAT_32, 2), INPUTSIZE);
136             scriptRelaxed.forEach_testLgammaFloat2Float2(inV, out);
137             verifyResultsLgammaFloat2Float2(inV, out, true);
138             out.destroy();
139         } catch (Exception e) {
140             throw new RSRuntimeException("RenderScript. Can't invoke forEach_testLgammaFloat2Float2: " + e.toString());
141         }
142         inV.destroy();
143     }
144 
verifyResultsLgammaFloat2Float2(Allocation inV, Allocation out, boolean relaxed)145     private void verifyResultsLgammaFloat2Float2(Allocation inV, Allocation out, boolean relaxed) {
146         float[] arrayInV = new float[INPUTSIZE * 2];
147         Arrays.fill(arrayInV, (float) 42);
148         inV.copyTo(arrayInV);
149         float[] arrayOut = new float[INPUTSIZE * 2];
150         Arrays.fill(arrayOut, (float) 42);
151         out.copyTo(arrayOut);
152         StringBuilder message = new StringBuilder();
153         boolean errorFound = false;
154         for (int i = 0; i < INPUTSIZE; i++) {
155             for (int j = 0; j < 2 ; j++) {
156                 // Extract the inputs.
157                 ArgumentsFloatFloat args = new ArgumentsFloatFloat();
158                 args.inV = arrayInV[i * 2 + j];
159                 // Figure out what the outputs should have been.
160                 Target target = new Target(Target.FunctionType.NORMAL, Target.ReturnType.FLOAT, relaxed);
161                 CoreMathVerifier.computeLgamma(args, target);
162                 // Validate the outputs.
163                 boolean valid = true;
164                 if (!args.out.couldBe(arrayOut[i * 2 + j])) {
165                     valid = false;
166                 }
167                 if (!valid) {
168                     if (!errorFound) {
169                         errorFound = true;
170                         message.append("Input inV: ");
171                         appendVariableToMessage(message, args.inV);
172                         message.append("\n");
173                         message.append("Expected output out: ");
174                         appendVariableToMessage(message, args.out);
175                         message.append("\n");
176                         message.append("Actual   output out: ");
177                         appendVariableToMessage(message, arrayOut[i * 2 + j]);
178                         if (!args.out.couldBe(arrayOut[i * 2 + j])) {
179                             message.append(" FAIL");
180                         }
181                         message.append("\n");
182                         message.append("Errors at");
183                     }
184                     message.append(" [");
185                     message.append(Integer.toString(i));
186                     message.append(", ");
187                     message.append(Integer.toString(j));
188                     message.append("]");
189                 }
190             }
191         }
192         assertFalse("Incorrect output for checkLgammaFloat2Float2" +
193                 (relaxed ? "_relaxed" : "") + ":\n" + message.toString(), errorFound);
194     }
195 
checkLgammaFloat3Float3()196     private void checkLgammaFloat3Float3() {
197         Allocation inV = createRandomAllocation(mRS, Element.DataType.FLOAT_32, 3, 0xeef71db12c956210l, false);
198         try {
199             Allocation out = Allocation.createSized(mRS, getElement(mRS, Element.DataType.FLOAT_32, 3), INPUTSIZE);
200             script.forEach_testLgammaFloat3Float3(inV, out);
201             verifyResultsLgammaFloat3Float3(inV, out, false);
202             out.destroy();
203         } catch (Exception e) {
204             throw new RSRuntimeException("RenderScript. Can't invoke forEach_testLgammaFloat3Float3: " + e.toString());
205         }
206         try {
207             Allocation out = Allocation.createSized(mRS, getElement(mRS, Element.DataType.FLOAT_32, 3), INPUTSIZE);
208             scriptRelaxed.forEach_testLgammaFloat3Float3(inV, out);
209             verifyResultsLgammaFloat3Float3(inV, out, true);
210             out.destroy();
211         } catch (Exception e) {
212             throw new RSRuntimeException("RenderScript. Can't invoke forEach_testLgammaFloat3Float3: " + e.toString());
213         }
214         inV.destroy();
215     }
216 
verifyResultsLgammaFloat3Float3(Allocation inV, Allocation out, boolean relaxed)217     private void verifyResultsLgammaFloat3Float3(Allocation inV, Allocation out, boolean relaxed) {
218         float[] arrayInV = new float[INPUTSIZE * 4];
219         Arrays.fill(arrayInV, (float) 42);
220         inV.copyTo(arrayInV);
221         float[] arrayOut = new float[INPUTSIZE * 4];
222         Arrays.fill(arrayOut, (float) 42);
223         out.copyTo(arrayOut);
224         StringBuilder message = new StringBuilder();
225         boolean errorFound = false;
226         for (int i = 0; i < INPUTSIZE; i++) {
227             for (int j = 0; j < 3 ; j++) {
228                 // Extract the inputs.
229                 ArgumentsFloatFloat args = new ArgumentsFloatFloat();
230                 args.inV = arrayInV[i * 4 + j];
231                 // Figure out what the outputs should have been.
232                 Target target = new Target(Target.FunctionType.NORMAL, Target.ReturnType.FLOAT, relaxed);
233                 CoreMathVerifier.computeLgamma(args, target);
234                 // Validate the outputs.
235                 boolean valid = true;
236                 if (!args.out.couldBe(arrayOut[i * 4 + j])) {
237                     valid = false;
238                 }
239                 if (!valid) {
240                     if (!errorFound) {
241                         errorFound = true;
242                         message.append("Input inV: ");
243                         appendVariableToMessage(message, args.inV);
244                         message.append("\n");
245                         message.append("Expected output out: ");
246                         appendVariableToMessage(message, args.out);
247                         message.append("\n");
248                         message.append("Actual   output out: ");
249                         appendVariableToMessage(message, arrayOut[i * 4 + j]);
250                         if (!args.out.couldBe(arrayOut[i * 4 + j])) {
251                             message.append(" FAIL");
252                         }
253                         message.append("\n");
254                         message.append("Errors at");
255                     }
256                     message.append(" [");
257                     message.append(Integer.toString(i));
258                     message.append(", ");
259                     message.append(Integer.toString(j));
260                     message.append("]");
261                 }
262             }
263         }
264         assertFalse("Incorrect output for checkLgammaFloat3Float3" +
265                 (relaxed ? "_relaxed" : "") + ":\n" + message.toString(), errorFound);
266     }
267 
checkLgammaFloat4Float4()268     private void checkLgammaFloat4Float4() {
269         Allocation inV = createRandomAllocation(mRS, Element.DataType.FLOAT_32, 4, 0xeef8e6cc22b082eel, false);
270         try {
271             Allocation out = Allocation.createSized(mRS, getElement(mRS, Element.DataType.FLOAT_32, 4), INPUTSIZE);
272             script.forEach_testLgammaFloat4Float4(inV, out);
273             verifyResultsLgammaFloat4Float4(inV, out, false);
274             out.destroy();
275         } catch (Exception e) {
276             throw new RSRuntimeException("RenderScript. Can't invoke forEach_testLgammaFloat4Float4: " + e.toString());
277         }
278         try {
279             Allocation out = Allocation.createSized(mRS, getElement(mRS, Element.DataType.FLOAT_32, 4), INPUTSIZE);
280             scriptRelaxed.forEach_testLgammaFloat4Float4(inV, out);
281             verifyResultsLgammaFloat4Float4(inV, out, true);
282             out.destroy();
283         } catch (Exception e) {
284             throw new RSRuntimeException("RenderScript. Can't invoke forEach_testLgammaFloat4Float4: " + e.toString());
285         }
286         inV.destroy();
287     }
288 
verifyResultsLgammaFloat4Float4(Allocation inV, Allocation out, boolean relaxed)289     private void verifyResultsLgammaFloat4Float4(Allocation inV, Allocation out, boolean relaxed) {
290         float[] arrayInV = new float[INPUTSIZE * 4];
291         Arrays.fill(arrayInV, (float) 42);
292         inV.copyTo(arrayInV);
293         float[] arrayOut = new float[INPUTSIZE * 4];
294         Arrays.fill(arrayOut, (float) 42);
295         out.copyTo(arrayOut);
296         StringBuilder message = new StringBuilder();
297         boolean errorFound = false;
298         for (int i = 0; i < INPUTSIZE; i++) {
299             for (int j = 0; j < 4 ; j++) {
300                 // Extract the inputs.
301                 ArgumentsFloatFloat args = new ArgumentsFloatFloat();
302                 args.inV = arrayInV[i * 4 + j];
303                 // Figure out what the outputs should have been.
304                 Target target = new Target(Target.FunctionType.NORMAL, Target.ReturnType.FLOAT, relaxed);
305                 CoreMathVerifier.computeLgamma(args, target);
306                 // Validate the outputs.
307                 boolean valid = true;
308                 if (!args.out.couldBe(arrayOut[i * 4 + j])) {
309                     valid = false;
310                 }
311                 if (!valid) {
312                     if (!errorFound) {
313                         errorFound = true;
314                         message.append("Input inV: ");
315                         appendVariableToMessage(message, args.inV);
316                         message.append("\n");
317                         message.append("Expected output out: ");
318                         appendVariableToMessage(message, args.out);
319                         message.append("\n");
320                         message.append("Actual   output out: ");
321                         appendVariableToMessage(message, arrayOut[i * 4 + j]);
322                         if (!args.out.couldBe(arrayOut[i * 4 + j])) {
323                             message.append(" FAIL");
324                         }
325                         message.append("\n");
326                         message.append("Errors at");
327                     }
328                     message.append(" [");
329                     message.append(Integer.toString(i));
330                     message.append(", ");
331                     message.append(Integer.toString(j));
332                     message.append("]");
333                 }
334             }
335         }
336         assertFalse("Incorrect output for checkLgammaFloat4Float4" +
337                 (relaxed ? "_relaxed" : "") + ":\n" + message.toString(), errorFound);
338     }
339 
340     public class ArgumentsFloatIntFloat {
341         public float inV;
342         public int outSignOfGamma;
343         public float out;
344     }
345 
checkLgammaFloatIntFloat()346     private void checkLgammaFloatIntFloat() {
347         Allocation inV = createRandomAllocation(mRS, Element.DataType.FLOAT_32, 1, 0x2a62d992979c4bb7l, false);
348         try {
349             Allocation outSignOfGamma = Allocation.createSized(mRS, getElement(mRS, Element.DataType.SIGNED_32, 1), INPUTSIZE);
350             Allocation out = Allocation.createSized(mRS, getElement(mRS, Element.DataType.FLOAT_32, 1), INPUTSIZE);
351             script.set_gAllocOutSignOfGamma(outSignOfGamma);
352             script.forEach_testLgammaFloatIntFloat(inV, out);
353             verifyResultsLgammaFloatIntFloat(inV, outSignOfGamma, out, false);
354             outSignOfGamma.destroy();
355             out.destroy();
356         } catch (Exception e) {
357             throw new RSRuntimeException("RenderScript. Can't invoke forEach_testLgammaFloatIntFloat: " + e.toString());
358         }
359         try {
360             Allocation outSignOfGamma = Allocation.createSized(mRS, getElement(mRS, Element.DataType.SIGNED_32, 1), INPUTSIZE);
361             Allocation out = Allocation.createSized(mRS, getElement(mRS, Element.DataType.FLOAT_32, 1), INPUTSIZE);
362             scriptRelaxed.set_gAllocOutSignOfGamma(outSignOfGamma);
363             scriptRelaxed.forEach_testLgammaFloatIntFloat(inV, out);
364             verifyResultsLgammaFloatIntFloat(inV, outSignOfGamma, out, true);
365             outSignOfGamma.destroy();
366             out.destroy();
367         } catch (Exception e) {
368             throw new RSRuntimeException("RenderScript. Can't invoke forEach_testLgammaFloatIntFloat: " + e.toString());
369         }
370         inV.destroy();
371     }
372 
verifyResultsLgammaFloatIntFloat(Allocation inV, Allocation outSignOfGamma, Allocation out, boolean relaxed)373     private void verifyResultsLgammaFloatIntFloat(Allocation inV, Allocation outSignOfGamma, Allocation out, boolean relaxed) {
374         float[] arrayInV = new float[INPUTSIZE * 1];
375         Arrays.fill(arrayInV, (float) 42);
376         inV.copyTo(arrayInV);
377         int[] arrayOutSignOfGamma = new int[INPUTSIZE * 1];
378         Arrays.fill(arrayOutSignOfGamma, (int) 42);
379         outSignOfGamma.copyTo(arrayOutSignOfGamma);
380         float[] arrayOut = new float[INPUTSIZE * 1];
381         Arrays.fill(arrayOut, (float) 42);
382         out.copyTo(arrayOut);
383         StringBuilder message = new StringBuilder();
384         boolean errorFound = false;
385         for (int i = 0; i < INPUTSIZE; i++) {
386             for (int j = 0; j < 1 ; j++) {
387                 // Extract the inputs.
388                 ArgumentsFloatIntFloat args = new ArgumentsFloatIntFloat();
389                 args.inV = arrayInV[i];
390                 // Extract the outputs.
391                 args.outSignOfGamma = arrayOutSignOfGamma[i * 1 + j];
392                 args.out = arrayOut[i * 1 + j];
393                 // Ask the CoreMathVerifier to validate.
394                 Target target = new Target(Target.FunctionType.NORMAL, Target.ReturnType.FLOAT, relaxed);
395                 String errorMessage = CoreMathVerifier.verifyLgamma(args, target);
396                 boolean valid = errorMessage == null;
397                 if (!valid) {
398                     if (!errorFound) {
399                         errorFound = true;
400                         message.append("Input inV: ");
401                         appendVariableToMessage(message, args.inV);
402                         message.append("\n");
403                         message.append("Output outSignOfGamma: ");
404                         appendVariableToMessage(message, args.outSignOfGamma);
405                         message.append("\n");
406                         message.append("Output out: ");
407                         appendVariableToMessage(message, args.out);
408                         message.append("\n");
409                         message.append(errorMessage);
410                         message.append("Errors at");
411                     }
412                     message.append(" [");
413                     message.append(Integer.toString(i));
414                     message.append(", ");
415                     message.append(Integer.toString(j));
416                     message.append("]");
417                 }
418             }
419         }
420         assertFalse("Incorrect output for checkLgammaFloatIntFloat" +
421                 (relaxed ? "_relaxed" : "") + ":\n" + message.toString(), errorFound);
422     }
423 
checkLgammaFloat2Int2Float2()424     private void checkLgammaFloat2Int2Float2() {
425         Allocation inV = createRandomAllocation(mRS, Element.DataType.FLOAT_32, 2, 0x409fb9a5984bcf7fl, false);
426         try {
427             Allocation outSignOfGamma = Allocation.createSized(mRS, getElement(mRS, Element.DataType.SIGNED_32, 2), INPUTSIZE);
428             Allocation out = Allocation.createSized(mRS, getElement(mRS, Element.DataType.FLOAT_32, 2), INPUTSIZE);
429             script.set_gAllocOutSignOfGamma(outSignOfGamma);
430             script.forEach_testLgammaFloat2Int2Float2(inV, out);
431             verifyResultsLgammaFloat2Int2Float2(inV, outSignOfGamma, out, false);
432             outSignOfGamma.destroy();
433             out.destroy();
434         } catch (Exception e) {
435             throw new RSRuntimeException("RenderScript. Can't invoke forEach_testLgammaFloat2Int2Float2: " + e.toString());
436         }
437         try {
438             Allocation outSignOfGamma = Allocation.createSized(mRS, getElement(mRS, Element.DataType.SIGNED_32, 2), INPUTSIZE);
439             Allocation out = Allocation.createSized(mRS, getElement(mRS, Element.DataType.FLOAT_32, 2), INPUTSIZE);
440             scriptRelaxed.set_gAllocOutSignOfGamma(outSignOfGamma);
441             scriptRelaxed.forEach_testLgammaFloat2Int2Float2(inV, out);
442             verifyResultsLgammaFloat2Int2Float2(inV, outSignOfGamma, out, true);
443             outSignOfGamma.destroy();
444             out.destroy();
445         } catch (Exception e) {
446             throw new RSRuntimeException("RenderScript. Can't invoke forEach_testLgammaFloat2Int2Float2: " + e.toString());
447         }
448         inV.destroy();
449     }
450 
verifyResultsLgammaFloat2Int2Float2(Allocation inV, Allocation outSignOfGamma, Allocation out, boolean relaxed)451     private void verifyResultsLgammaFloat2Int2Float2(Allocation inV, Allocation outSignOfGamma, Allocation out, boolean relaxed) {
452         float[] arrayInV = new float[INPUTSIZE * 2];
453         Arrays.fill(arrayInV, (float) 42);
454         inV.copyTo(arrayInV);
455         int[] arrayOutSignOfGamma = new int[INPUTSIZE * 2];
456         Arrays.fill(arrayOutSignOfGamma, (int) 42);
457         outSignOfGamma.copyTo(arrayOutSignOfGamma);
458         float[] arrayOut = new float[INPUTSIZE * 2];
459         Arrays.fill(arrayOut, (float) 42);
460         out.copyTo(arrayOut);
461         StringBuilder message = new StringBuilder();
462         boolean errorFound = false;
463         for (int i = 0; i < INPUTSIZE; i++) {
464             for (int j = 0; j < 2 ; j++) {
465                 // Extract the inputs.
466                 ArgumentsFloatIntFloat args = new ArgumentsFloatIntFloat();
467                 args.inV = arrayInV[i * 2 + j];
468                 // Extract the outputs.
469                 args.outSignOfGamma = arrayOutSignOfGamma[i * 2 + j];
470                 args.out = arrayOut[i * 2 + j];
471                 // Ask the CoreMathVerifier to validate.
472                 Target target = new Target(Target.FunctionType.NORMAL, Target.ReturnType.FLOAT, relaxed);
473                 String errorMessage = CoreMathVerifier.verifyLgamma(args, target);
474                 boolean valid = errorMessage == null;
475                 if (!valid) {
476                     if (!errorFound) {
477                         errorFound = true;
478                         message.append("Input inV: ");
479                         appendVariableToMessage(message, args.inV);
480                         message.append("\n");
481                         message.append("Output outSignOfGamma: ");
482                         appendVariableToMessage(message, args.outSignOfGamma);
483                         message.append("\n");
484                         message.append("Output out: ");
485                         appendVariableToMessage(message, args.out);
486                         message.append("\n");
487                         message.append(errorMessage);
488                         message.append("Errors at");
489                     }
490                     message.append(" [");
491                     message.append(Integer.toString(i));
492                     message.append(", ");
493                     message.append(Integer.toString(j));
494                     message.append("]");
495                 }
496             }
497         }
498         assertFalse("Incorrect output for checkLgammaFloat2Int2Float2" +
499                 (relaxed ? "_relaxed" : "") + ":\n" + message.toString(), errorFound);
500     }
501 
checkLgammaFloat3Int3Float3()502     private void checkLgammaFloat3Int3Float3() {
503         Allocation inV = createRandomAllocation(mRS, Element.DataType.FLOAT_32, 3, 0x6655f8088dfe3c38l, false);
504         try {
505             Allocation outSignOfGamma = Allocation.createSized(mRS, getElement(mRS, Element.DataType.SIGNED_32, 3), INPUTSIZE);
506             Allocation out = Allocation.createSized(mRS, getElement(mRS, Element.DataType.FLOAT_32, 3), INPUTSIZE);
507             script.set_gAllocOutSignOfGamma(outSignOfGamma);
508             script.forEach_testLgammaFloat3Int3Float3(inV, out);
509             verifyResultsLgammaFloat3Int3Float3(inV, outSignOfGamma, out, false);
510             outSignOfGamma.destroy();
511             out.destroy();
512         } catch (Exception e) {
513             throw new RSRuntimeException("RenderScript. Can't invoke forEach_testLgammaFloat3Int3Float3: " + e.toString());
514         }
515         try {
516             Allocation outSignOfGamma = Allocation.createSized(mRS, getElement(mRS, Element.DataType.SIGNED_32, 3), INPUTSIZE);
517             Allocation out = Allocation.createSized(mRS, getElement(mRS, Element.DataType.FLOAT_32, 3), INPUTSIZE);
518             scriptRelaxed.set_gAllocOutSignOfGamma(outSignOfGamma);
519             scriptRelaxed.forEach_testLgammaFloat3Int3Float3(inV, out);
520             verifyResultsLgammaFloat3Int3Float3(inV, outSignOfGamma, out, true);
521             outSignOfGamma.destroy();
522             out.destroy();
523         } catch (Exception e) {
524             throw new RSRuntimeException("RenderScript. Can't invoke forEach_testLgammaFloat3Int3Float3: " + e.toString());
525         }
526         inV.destroy();
527     }
528 
verifyResultsLgammaFloat3Int3Float3(Allocation inV, Allocation outSignOfGamma, Allocation out, boolean relaxed)529     private void verifyResultsLgammaFloat3Int3Float3(Allocation inV, Allocation outSignOfGamma, Allocation out, boolean relaxed) {
530         float[] arrayInV = new float[INPUTSIZE * 4];
531         Arrays.fill(arrayInV, (float) 42);
532         inV.copyTo(arrayInV);
533         int[] arrayOutSignOfGamma = new int[INPUTSIZE * 4];
534         Arrays.fill(arrayOutSignOfGamma, (int) 42);
535         outSignOfGamma.copyTo(arrayOutSignOfGamma);
536         float[] arrayOut = new float[INPUTSIZE * 4];
537         Arrays.fill(arrayOut, (float) 42);
538         out.copyTo(arrayOut);
539         StringBuilder message = new StringBuilder();
540         boolean errorFound = false;
541         for (int i = 0; i < INPUTSIZE; i++) {
542             for (int j = 0; j < 3 ; j++) {
543                 // Extract the inputs.
544                 ArgumentsFloatIntFloat args = new ArgumentsFloatIntFloat();
545                 args.inV = arrayInV[i * 4 + j];
546                 // Extract the outputs.
547                 args.outSignOfGamma = arrayOutSignOfGamma[i * 4 + j];
548                 args.out = arrayOut[i * 4 + j];
549                 // Ask the CoreMathVerifier to validate.
550                 Target target = new Target(Target.FunctionType.NORMAL, Target.ReturnType.FLOAT, relaxed);
551                 String errorMessage = CoreMathVerifier.verifyLgamma(args, target);
552                 boolean valid = errorMessage == null;
553                 if (!valid) {
554                     if (!errorFound) {
555                         errorFound = true;
556                         message.append("Input inV: ");
557                         appendVariableToMessage(message, args.inV);
558                         message.append("\n");
559                         message.append("Output outSignOfGamma: ");
560                         appendVariableToMessage(message, args.outSignOfGamma);
561                         message.append("\n");
562                         message.append("Output out: ");
563                         appendVariableToMessage(message, args.out);
564                         message.append("\n");
565                         message.append(errorMessage);
566                         message.append("Errors at");
567                     }
568                     message.append(" [");
569                     message.append(Integer.toString(i));
570                     message.append(", ");
571                     message.append(Integer.toString(j));
572                     message.append("]");
573                 }
574             }
575         }
576         assertFalse("Incorrect output for checkLgammaFloat3Int3Float3" +
577                 (relaxed ? "_relaxed" : "") + ":\n" + message.toString(), errorFound);
578     }
579 
checkLgammaFloat4Int4Float4()580     private void checkLgammaFloat4Int4Float4() {
581         Allocation inV = createRandomAllocation(mRS, Element.DataType.FLOAT_32, 4, 0x8c0c366b83b0a8f1l, false);
582         try {
583             Allocation outSignOfGamma = Allocation.createSized(mRS, getElement(mRS, Element.DataType.SIGNED_32, 4), INPUTSIZE);
584             Allocation out = Allocation.createSized(mRS, getElement(mRS, Element.DataType.FLOAT_32, 4), INPUTSIZE);
585             script.set_gAllocOutSignOfGamma(outSignOfGamma);
586             script.forEach_testLgammaFloat4Int4Float4(inV, out);
587             verifyResultsLgammaFloat4Int4Float4(inV, outSignOfGamma, out, false);
588             outSignOfGamma.destroy();
589             out.destroy();
590         } catch (Exception e) {
591             throw new RSRuntimeException("RenderScript. Can't invoke forEach_testLgammaFloat4Int4Float4: " + e.toString());
592         }
593         try {
594             Allocation outSignOfGamma = Allocation.createSized(mRS, getElement(mRS, Element.DataType.SIGNED_32, 4), INPUTSIZE);
595             Allocation out = Allocation.createSized(mRS, getElement(mRS, Element.DataType.FLOAT_32, 4), INPUTSIZE);
596             scriptRelaxed.set_gAllocOutSignOfGamma(outSignOfGamma);
597             scriptRelaxed.forEach_testLgammaFloat4Int4Float4(inV, out);
598             verifyResultsLgammaFloat4Int4Float4(inV, outSignOfGamma, out, true);
599             outSignOfGamma.destroy();
600             out.destroy();
601         } catch (Exception e) {
602             throw new RSRuntimeException("RenderScript. Can't invoke forEach_testLgammaFloat4Int4Float4: " + e.toString());
603         }
604         inV.destroy();
605     }
606 
verifyResultsLgammaFloat4Int4Float4(Allocation inV, Allocation outSignOfGamma, Allocation out, boolean relaxed)607     private void verifyResultsLgammaFloat4Int4Float4(Allocation inV, Allocation outSignOfGamma, Allocation out, boolean relaxed) {
608         float[] arrayInV = new float[INPUTSIZE * 4];
609         Arrays.fill(arrayInV, (float) 42);
610         inV.copyTo(arrayInV);
611         int[] arrayOutSignOfGamma = new int[INPUTSIZE * 4];
612         Arrays.fill(arrayOutSignOfGamma, (int) 42);
613         outSignOfGamma.copyTo(arrayOutSignOfGamma);
614         float[] arrayOut = new float[INPUTSIZE * 4];
615         Arrays.fill(arrayOut, (float) 42);
616         out.copyTo(arrayOut);
617         StringBuilder message = new StringBuilder();
618         boolean errorFound = false;
619         for (int i = 0; i < INPUTSIZE; i++) {
620             for (int j = 0; j < 4 ; j++) {
621                 // Extract the inputs.
622                 ArgumentsFloatIntFloat args = new ArgumentsFloatIntFloat();
623                 args.inV = arrayInV[i * 4 + j];
624                 // Extract the outputs.
625                 args.outSignOfGamma = arrayOutSignOfGamma[i * 4 + j];
626                 args.out = arrayOut[i * 4 + j];
627                 // Ask the CoreMathVerifier to validate.
628                 Target target = new Target(Target.FunctionType.NORMAL, Target.ReturnType.FLOAT, relaxed);
629                 String errorMessage = CoreMathVerifier.verifyLgamma(args, target);
630                 boolean valid = errorMessage == null;
631                 if (!valid) {
632                     if (!errorFound) {
633                         errorFound = true;
634                         message.append("Input inV: ");
635                         appendVariableToMessage(message, args.inV);
636                         message.append("\n");
637                         message.append("Output outSignOfGamma: ");
638                         appendVariableToMessage(message, args.outSignOfGamma);
639                         message.append("\n");
640                         message.append("Output out: ");
641                         appendVariableToMessage(message, args.out);
642                         message.append("\n");
643                         message.append(errorMessage);
644                         message.append("Errors at");
645                     }
646                     message.append(" [");
647                     message.append(Integer.toString(i));
648                     message.append(", ");
649                     message.append(Integer.toString(j));
650                     message.append("]");
651                 }
652             }
653         }
654         assertFalse("Incorrect output for checkLgammaFloat4Int4Float4" +
655                 (relaxed ? "_relaxed" : "") + ":\n" + message.toString(), errorFound);
656     }
657 
testLgamma()658     public void testLgamma() {
659         checkLgammaFloatFloat();
660         checkLgammaFloat2Float2();
661         checkLgammaFloat3Float3();
662         checkLgammaFloat4Float4();
663         checkLgammaFloatIntFloat();
664         checkLgammaFloat2Int2Float2();
665         checkLgammaFloat3Int3Float3();
666         checkLgammaFloat4Int4Float4();
667     }
668 }
669