1/* 2 * Copyright (C) 2011-2014 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/* 18 * This file is auto-generated. DO NOT MODIFY! 19 * The source Renderscript file: reduce_general_result.rs 20 */ 21 22package result; 23 24import android.renderscript.*; 25import result.reduce_general_resultBitCode; 26 27/** 28 * @hide 29 */ 30public class ScriptC_reduce_general_result extends ScriptC { 31 private static final String __rs_resource_name = "reduce_general_result"; 32 // Constructor 33 public ScriptC_reduce_general_result(RenderScript rs) { 34 super(rs, 35 __rs_resource_name, 36 reduce_general_resultBitCode.getBitCode32(), 37 reduce_general_resultBitCode.getBitCode64()); 38 mRSLocal = rs; 39 __F16 = Element.F16(rs); 40 __F16_2 = Element.F16_2(rs); 41 __F16_4 = Element.F16_4(rs); 42 __F32 = Element.F32(rs); 43 __F32_2 = Element.F32_2(rs); 44 __F32_4 = Element.F32_4(rs); 45 __F64 = Element.F64(rs); 46 __F64_2 = Element.F64_2(rs); 47 __F64_4 = Element.F64_4(rs); 48 __I8 = Element.I8(rs); 49 __I8_2 = Element.I8_2(rs); 50 __I8_4 = Element.I8_4(rs); 51 __I16 = Element.I16(rs); 52 __I16_2 = Element.I16_2(rs); 53 __I16_4 = Element.I16_4(rs); 54 __I32 = Element.I32(rs); 55 __I32_2 = Element.I32_2(rs); 56 __I32_4 = Element.I32_4(rs); 57 __I64 = Element.I64(rs); 58 __I64_2 = Element.I64_2(rs); 59 __I64_4 = Element.I64_4(rs); 60 __U8 = Element.U8(rs); 61 __U8_2 = Element.U8_2(rs); 62 __U8_4 = Element.U8_4(rs); 63 __U16 = Element.U16(rs); 64 __U16_2 = Element.U16_2(rs); 65 __U16_4 = Element.U16_4(rs); 66 __U32 = Element.U32(rs); 67 __U32_2 = Element.U32_2(rs); 68 __U32_4 = Element.U32_4(rs); 69 __U64 = Element.U64(rs); 70 __U64_2 = Element.U64_2(rs); 71 __U64_4 = Element.U64_4(rs); 72 __BOOLEAN = Element.BOOLEAN(rs); 73 } 74 75 private Element __BOOLEAN; 76 private Element __F16; 77 private Element __F16_2; 78 private Element __F16_4; 79 private Element __F32; 80 private Element __F32_2; 81 private Element __F32_4; 82 private Element __F64; 83 private Element __F64_2; 84 private Element __F64_4; 85 private Element __I16; 86 private Element __I16_2; 87 private Element __I16_4; 88 private Element __I32; 89 private Element __I32_2; 90 private Element __I32_4; 91 private Element __I64; 92 private Element __I64_2; 93 private Element __I64_4; 94 private Element __I8; 95 private Element __I8_2; 96 private Element __I8_4; 97 private Element __U16; 98 private Element __U16_2; 99 private Element __U16_4; 100 private Element __U32; 101 private Element __U32_2; 102 private Element __U32_4; 103 private Element __U64; 104 private Element __U64_2; 105 private Element __U64_4; 106 private Element __U8; 107 private Element __U8_2; 108 private Element __U8_4; 109 private RenderScript mRSLocal; 110 // To obtain the result, invoke get(), which blocks 111 // until the asynchronously-launched operation has completed. 112 public static class resultArray7_bool { 113 public boolean[] get() { 114 if (!mGotResult) { 115 byte[] outArray = new byte[7]; 116 mOut.copyTo(outArray); 117 boolean[] result = new boolean[7]; 118 for (int Idx = 0; Idx < 7; ++Idx) { 119 result[Idx] = outArray[Idx] != 0; 120 } 121 122 mResult = result; 123 mOut.destroy(); 124 mOut = null; // make Java object eligible for garbage collection 125 if (mTempIns != null) { 126 for (Allocation tempIn : mTempIns) { 127 tempIn.destroy(); 128 } 129 130 mTempIns = null; // make Java objects eligible for garbage collection 131 } 132 133 mGotResult = true; 134 } 135 136 return mResult; 137 } 138 139 private resultArray7_bool(Allocation out) { 140 mTempIns = null; 141 mOut = out; 142 mGotResult = false; 143 } 144 145 private Allocation[] mTempIns; 146 private Allocation mOut; 147 private boolean mGotResult; 148 private boolean[] mResult; 149 } 150 151 // To obtain the result, invoke get(), which blocks 152 // until the asynchronously-launched operation has completed. 153 public static class resultArray7_char { 154 public byte[] get() { 155 if (!mGotResult) { 156 byte[] outArray = new byte[7]; 157 mOut.copyTo(outArray); 158 mResult = outArray; 159 mOut.destroy(); 160 mOut = null; // make Java object eligible for garbage collection 161 if (mTempIns != null) { 162 for (Allocation tempIn : mTempIns) { 163 tempIn.destroy(); 164 } 165 166 mTempIns = null; // make Java objects eligible for garbage collection 167 } 168 169 mGotResult = true; 170 } 171 172 return mResult; 173 } 174 175 private resultArray7_char(Allocation out) { 176 mTempIns = null; 177 mOut = out; 178 mGotResult = false; 179 } 180 181 private Allocation[] mTempIns; 182 private Allocation mOut; 183 private boolean mGotResult; 184 private byte[] mResult; 185 } 186 187 // To obtain the result, invoke get(), which blocks 188 // until the asynchronously-launched operation has completed. 189 public static class resultArray7_char2 { 190 public Byte2[] get() { 191 if (!mGotResult) { 192 byte[] outArray = new byte[14]; 193 mOut.copyTo(outArray); 194 Byte2[] result = new Byte2[7]; 195 for (int Idx = 0; Idx < 7; ++Idx) { 196 result[Idx] = new Byte2(outArray[2*Idx+0], outArray[2*Idx+1]); 197 } 198 199 mResult = result; 200 mOut.destroy(); 201 mOut = null; // make Java object eligible for garbage collection 202 if (mTempIns != null) { 203 for (Allocation tempIn : mTempIns) { 204 tempIn.destroy(); 205 } 206 207 mTempIns = null; // make Java objects eligible for garbage collection 208 } 209 210 mGotResult = true; 211 } 212 213 return mResult; 214 } 215 216 private resultArray7_char2(Allocation out) { 217 mTempIns = null; 218 mOut = out; 219 mGotResult = false; 220 } 221 222 private Allocation[] mTempIns; 223 private Allocation mOut; 224 private boolean mGotResult; 225 private Byte2[] mResult; 226 } 227 228 // To obtain the result, invoke get(), which blocks 229 // until the asynchronously-launched operation has completed. 230 public static class resultArray7_char4 { 231 public Byte4[] get() { 232 if (!mGotResult) { 233 byte[] outArray = new byte[28]; 234 mOut.copyTo(outArray); 235 Byte4[] result = new Byte4[7]; 236 for (int Idx = 0; Idx < 7; ++Idx) { 237 result[Idx] = new Byte4(outArray[4*Idx+0], outArray[4*Idx+1], outArray[4*Idx+2], outArray[4*Idx+3]); 238 } 239 240 mResult = result; 241 mOut.destroy(); 242 mOut = null; // make Java object eligible for garbage collection 243 if (mTempIns != null) { 244 for (Allocation tempIn : mTempIns) { 245 tempIn.destroy(); 246 } 247 248 mTempIns = null; // make Java objects eligible for garbage collection 249 } 250 251 mGotResult = true; 252 } 253 254 return mResult; 255 } 256 257 private resultArray7_char4(Allocation out) { 258 mTempIns = null; 259 mOut = out; 260 mGotResult = false; 261 } 262 263 private Allocation[] mTempIns; 264 private Allocation mOut; 265 private boolean mGotResult; 266 private Byte4[] mResult; 267 } 268 269 // To obtain the result, invoke get(), which blocks 270 // until the asynchronously-launched operation has completed. 271 public static class resultArray7_double { 272 public double[] get() { 273 if (!mGotResult) { 274 double[] outArray = new double[7]; 275 mOut.copyTo(outArray); 276 mResult = outArray; 277 mOut.destroy(); 278 mOut = null; // make Java object eligible for garbage collection 279 if (mTempIns != null) { 280 for (Allocation tempIn : mTempIns) { 281 tempIn.destroy(); 282 } 283 284 mTempIns = null; // make Java objects eligible for garbage collection 285 } 286 287 mGotResult = true; 288 } 289 290 return mResult; 291 } 292 293 private resultArray7_double(Allocation out) { 294 mTempIns = null; 295 mOut = out; 296 mGotResult = false; 297 } 298 299 private Allocation[] mTempIns; 300 private Allocation mOut; 301 private boolean mGotResult; 302 private double[] mResult; 303 } 304 305 // To obtain the result, invoke get(), which blocks 306 // until the asynchronously-launched operation has completed. 307 public static class resultArray7_double2 { 308 public Double2[] get() { 309 if (!mGotResult) { 310 double[] outArray = new double[14]; 311 mOut.copyTo(outArray); 312 Double2[] result = new Double2[7]; 313 for (int Idx = 0; Idx < 7; ++Idx) { 314 result[Idx] = new Double2(outArray[2*Idx+0], outArray[2*Idx+1]); 315 } 316 317 mResult = result; 318 mOut.destroy(); 319 mOut = null; // make Java object eligible for garbage collection 320 if (mTempIns != null) { 321 for (Allocation tempIn : mTempIns) { 322 tempIn.destroy(); 323 } 324 325 mTempIns = null; // make Java objects eligible for garbage collection 326 } 327 328 mGotResult = true; 329 } 330 331 return mResult; 332 } 333 334 private resultArray7_double2(Allocation out) { 335 mTempIns = null; 336 mOut = out; 337 mGotResult = false; 338 } 339 340 private Allocation[] mTempIns; 341 private Allocation mOut; 342 private boolean mGotResult; 343 private Double2[] mResult; 344 } 345 346 // To obtain the result, invoke get(), which blocks 347 // until the asynchronously-launched operation has completed. 348 public static class resultArray7_double4 { 349 public Double4[] get() { 350 if (!mGotResult) { 351 double[] outArray = new double[28]; 352 mOut.copyTo(outArray); 353 Double4[] result = new Double4[7]; 354 for (int Idx = 0; Idx < 7; ++Idx) { 355 result[Idx] = new Double4(outArray[4*Idx+0], outArray[4*Idx+1], outArray[4*Idx+2], outArray[4*Idx+3]); 356 } 357 358 mResult = result; 359 mOut.destroy(); 360 mOut = null; // make Java object eligible for garbage collection 361 if (mTempIns != null) { 362 for (Allocation tempIn : mTempIns) { 363 tempIn.destroy(); 364 } 365 366 mTempIns = null; // make Java objects eligible for garbage collection 367 } 368 369 mGotResult = true; 370 } 371 372 return mResult; 373 } 374 375 private resultArray7_double4(Allocation out) { 376 mTempIns = null; 377 mOut = out; 378 mGotResult = false; 379 } 380 381 private Allocation[] mTempIns; 382 private Allocation mOut; 383 private boolean mGotResult; 384 private Double4[] mResult; 385 } 386 387 // To obtain the result, invoke get(), which blocks 388 // until the asynchronously-launched operation has completed. 389 public static class resultArray7_float { 390 public float[] get() { 391 if (!mGotResult) { 392 float[] outArray = new float[7]; 393 mOut.copyTo(outArray); 394 mResult = outArray; 395 mOut.destroy(); 396 mOut = null; // make Java object eligible for garbage collection 397 if (mTempIns != null) { 398 for (Allocation tempIn : mTempIns) { 399 tempIn.destroy(); 400 } 401 402 mTempIns = null; // make Java objects eligible for garbage collection 403 } 404 405 mGotResult = true; 406 } 407 408 return mResult; 409 } 410 411 private resultArray7_float(Allocation out) { 412 mTempIns = null; 413 mOut = out; 414 mGotResult = false; 415 } 416 417 private Allocation[] mTempIns; 418 private Allocation mOut; 419 private boolean mGotResult; 420 private float[] mResult; 421 } 422 423 // To obtain the result, invoke get(), which blocks 424 // until the asynchronously-launched operation has completed. 425 public static class resultArray7_float2 { 426 public Float2[] get() { 427 if (!mGotResult) { 428 float[] outArray = new float[14]; 429 mOut.copyTo(outArray); 430 Float2[] result = new Float2[7]; 431 for (int Idx = 0; Idx < 7; ++Idx) { 432 result[Idx] = new Float2(outArray[2*Idx+0], outArray[2*Idx+1]); 433 } 434 435 mResult = result; 436 mOut.destroy(); 437 mOut = null; // make Java object eligible for garbage collection 438 if (mTempIns != null) { 439 for (Allocation tempIn : mTempIns) { 440 tempIn.destroy(); 441 } 442 443 mTempIns = null; // make Java objects eligible for garbage collection 444 } 445 446 mGotResult = true; 447 } 448 449 return mResult; 450 } 451 452 private resultArray7_float2(Allocation out) { 453 mTempIns = null; 454 mOut = out; 455 mGotResult = false; 456 } 457 458 private Allocation[] mTempIns; 459 private Allocation mOut; 460 private boolean mGotResult; 461 private Float2[] mResult; 462 } 463 464 // To obtain the result, invoke get(), which blocks 465 // until the asynchronously-launched operation has completed. 466 public static class resultArray7_float4 { 467 public Float4[] get() { 468 if (!mGotResult) { 469 float[] outArray = new float[28]; 470 mOut.copyTo(outArray); 471 Float4[] result = new Float4[7]; 472 for (int Idx = 0; Idx < 7; ++Idx) { 473 result[Idx] = new Float4(outArray[4*Idx+0], outArray[4*Idx+1], outArray[4*Idx+2], outArray[4*Idx+3]); 474 } 475 476 mResult = result; 477 mOut.destroy(); 478 mOut = null; // make Java object eligible for garbage collection 479 if (mTempIns != null) { 480 for (Allocation tempIn : mTempIns) { 481 tempIn.destroy(); 482 } 483 484 mTempIns = null; // make Java objects eligible for garbage collection 485 } 486 487 mGotResult = true; 488 } 489 490 return mResult; 491 } 492 493 private resultArray7_float4(Allocation out) { 494 mTempIns = null; 495 mOut = out; 496 mGotResult = false; 497 } 498 499 private Allocation[] mTempIns; 500 private Allocation mOut; 501 private boolean mGotResult; 502 private Float4[] mResult; 503 } 504 505 // To obtain the result, invoke get(), which blocks 506 // until the asynchronously-launched operation has completed. 507 public static class resultArray7_half { 508 public short[] get() { 509 if (!mGotResult) { 510 short[] outArray = new short[7]; 511 mOut.copyTo(outArray); 512 mResult = outArray; 513 mOut.destroy(); 514 mOut = null; // make Java object eligible for garbage collection 515 if (mTempIns != null) { 516 for (Allocation tempIn : mTempIns) { 517 tempIn.destroy(); 518 } 519 520 mTempIns = null; // make Java objects eligible for garbage collection 521 } 522 523 mGotResult = true; 524 } 525 526 return mResult; 527 } 528 529 private resultArray7_half(Allocation out) { 530 mTempIns = null; 531 mOut = out; 532 mGotResult = false; 533 } 534 535 private Allocation[] mTempIns; 536 private Allocation mOut; 537 private boolean mGotResult; 538 private short[] mResult; 539 } 540 541 // To obtain the result, invoke get(), which blocks 542 // until the asynchronously-launched operation has completed. 543 public static class resultArray7_half2 { 544 public Short2[] get() { 545 if (!mGotResult) { 546 short[] outArray = new short[14]; 547 mOut.copyTo(outArray); 548 Short2[] result = new Short2[7]; 549 for (int Idx = 0; Idx < 7; ++Idx) { 550 result[Idx] = new Short2(outArray[2*Idx+0], outArray[2*Idx+1]); 551 } 552 553 mResult = result; 554 mOut.destroy(); 555 mOut = null; // make Java object eligible for garbage collection 556 if (mTempIns != null) { 557 for (Allocation tempIn : mTempIns) { 558 tempIn.destroy(); 559 } 560 561 mTempIns = null; // make Java objects eligible for garbage collection 562 } 563 564 mGotResult = true; 565 } 566 567 return mResult; 568 } 569 570 private resultArray7_half2(Allocation out) { 571 mTempIns = null; 572 mOut = out; 573 mGotResult = false; 574 } 575 576 private Allocation[] mTempIns; 577 private Allocation mOut; 578 private boolean mGotResult; 579 private Short2[] mResult; 580 } 581 582 // To obtain the result, invoke get(), which blocks 583 // until the asynchronously-launched operation has completed. 584 public static class resultArray7_half4 { 585 public Short4[] get() { 586 if (!mGotResult) { 587 short[] outArray = new short[28]; 588 mOut.copyTo(outArray); 589 Short4[] result = new Short4[7]; 590 for (int Idx = 0; Idx < 7; ++Idx) { 591 result[Idx] = new Short4(outArray[4*Idx+0], outArray[4*Idx+1], outArray[4*Idx+2], outArray[4*Idx+3]); 592 } 593 594 mResult = result; 595 mOut.destroy(); 596 mOut = null; // make Java object eligible for garbage collection 597 if (mTempIns != null) { 598 for (Allocation tempIn : mTempIns) { 599 tempIn.destroy(); 600 } 601 602 mTempIns = null; // make Java objects eligible for garbage collection 603 } 604 605 mGotResult = true; 606 } 607 608 return mResult; 609 } 610 611 private resultArray7_half4(Allocation out) { 612 mTempIns = null; 613 mOut = out; 614 mGotResult = false; 615 } 616 617 private Allocation[] mTempIns; 618 private Allocation mOut; 619 private boolean mGotResult; 620 private Short4[] mResult; 621 } 622 623 // To obtain the result, invoke get(), which blocks 624 // until the asynchronously-launched operation has completed. 625 public static class resultArray7_int { 626 public int[] get() { 627 if (!mGotResult) { 628 int[] outArray = new int[7]; 629 mOut.copyTo(outArray); 630 mResult = outArray; 631 mOut.destroy(); 632 mOut = null; // make Java object eligible for garbage collection 633 if (mTempIns != null) { 634 for (Allocation tempIn : mTempIns) { 635 tempIn.destroy(); 636 } 637 638 mTempIns = null; // make Java objects eligible for garbage collection 639 } 640 641 mGotResult = true; 642 } 643 644 return mResult; 645 } 646 647 private resultArray7_int(Allocation out) { 648 mTempIns = null; 649 mOut = out; 650 mGotResult = false; 651 } 652 653 private Allocation[] mTempIns; 654 private Allocation mOut; 655 private boolean mGotResult; 656 private int[] mResult; 657 } 658 659 // To obtain the result, invoke get(), which blocks 660 // until the asynchronously-launched operation has completed. 661 public static class resultArray7_int2 { 662 public Int2[] get() { 663 if (!mGotResult) { 664 int[] outArray = new int[14]; 665 mOut.copyTo(outArray); 666 Int2[] result = new Int2[7]; 667 for (int Idx = 0; Idx < 7; ++Idx) { 668 result[Idx] = new Int2(outArray[2*Idx+0], outArray[2*Idx+1]); 669 } 670 671 mResult = result; 672 mOut.destroy(); 673 mOut = null; // make Java object eligible for garbage collection 674 if (mTempIns != null) { 675 for (Allocation tempIn : mTempIns) { 676 tempIn.destroy(); 677 } 678 679 mTempIns = null; // make Java objects eligible for garbage collection 680 } 681 682 mGotResult = true; 683 } 684 685 return mResult; 686 } 687 688 private resultArray7_int2(Allocation out) { 689 mTempIns = null; 690 mOut = out; 691 mGotResult = false; 692 } 693 694 private Allocation[] mTempIns; 695 private Allocation mOut; 696 private boolean mGotResult; 697 private Int2[] mResult; 698 } 699 700 // To obtain the result, invoke get(), which blocks 701 // until the asynchronously-launched operation has completed. 702 public static class resultArray7_int4 { 703 public Int4[] get() { 704 if (!mGotResult) { 705 int[] outArray = new int[28]; 706 mOut.copyTo(outArray); 707 Int4[] result = new Int4[7]; 708 for (int Idx = 0; Idx < 7; ++Idx) { 709 result[Idx] = new Int4(outArray[4*Idx+0], outArray[4*Idx+1], outArray[4*Idx+2], outArray[4*Idx+3]); 710 } 711 712 mResult = result; 713 mOut.destroy(); 714 mOut = null; // make Java object eligible for garbage collection 715 if (mTempIns != null) { 716 for (Allocation tempIn : mTempIns) { 717 tempIn.destroy(); 718 } 719 720 mTempIns = null; // make Java objects eligible for garbage collection 721 } 722 723 mGotResult = true; 724 } 725 726 return mResult; 727 } 728 729 private resultArray7_int4(Allocation out) { 730 mTempIns = null; 731 mOut = out; 732 mGotResult = false; 733 } 734 735 private Allocation[] mTempIns; 736 private Allocation mOut; 737 private boolean mGotResult; 738 private Int4[] mResult; 739 } 740 741 // To obtain the result, invoke get(), which blocks 742 // until the asynchronously-launched operation has completed. 743 public static class resultArray7_long { 744 public long[] get() { 745 if (!mGotResult) { 746 long[] outArray = new long[7]; 747 mOut.copyTo(outArray); 748 mResult = outArray; 749 mOut.destroy(); 750 mOut = null; // make Java object eligible for garbage collection 751 if (mTempIns != null) { 752 for (Allocation tempIn : mTempIns) { 753 tempIn.destroy(); 754 } 755 756 mTempIns = null; // make Java objects eligible for garbage collection 757 } 758 759 mGotResult = true; 760 } 761 762 return mResult; 763 } 764 765 private resultArray7_long(Allocation out) { 766 mTempIns = null; 767 mOut = out; 768 mGotResult = false; 769 } 770 771 private Allocation[] mTempIns; 772 private Allocation mOut; 773 private boolean mGotResult; 774 private long[] mResult; 775 } 776 777 // To obtain the result, invoke get(), which blocks 778 // until the asynchronously-launched operation has completed. 779 public static class resultArray7_long2 { 780 public Long2[] get() { 781 if (!mGotResult) { 782 long[] outArray = new long[14]; 783 mOut.copyTo(outArray); 784 Long2[] result = new Long2[7]; 785 for (int Idx = 0; Idx < 7; ++Idx) { 786 result[Idx] = new Long2(outArray[2*Idx+0], outArray[2*Idx+1]); 787 } 788 789 mResult = result; 790 mOut.destroy(); 791 mOut = null; // make Java object eligible for garbage collection 792 if (mTempIns != null) { 793 for (Allocation tempIn : mTempIns) { 794 tempIn.destroy(); 795 } 796 797 mTempIns = null; // make Java objects eligible for garbage collection 798 } 799 800 mGotResult = true; 801 } 802 803 return mResult; 804 } 805 806 private resultArray7_long2(Allocation out) { 807 mTempIns = null; 808 mOut = out; 809 mGotResult = false; 810 } 811 812 private Allocation[] mTempIns; 813 private Allocation mOut; 814 private boolean mGotResult; 815 private Long2[] mResult; 816 } 817 818 // To obtain the result, invoke get(), which blocks 819 // until the asynchronously-launched operation has completed. 820 public static class resultArray7_long4 { 821 public Long4[] get() { 822 if (!mGotResult) { 823 long[] outArray = new long[28]; 824 mOut.copyTo(outArray); 825 Long4[] result = new Long4[7]; 826 for (int Idx = 0; Idx < 7; ++Idx) { 827 result[Idx] = new Long4(outArray[4*Idx+0], outArray[4*Idx+1], outArray[4*Idx+2], outArray[4*Idx+3]); 828 } 829 830 mResult = result; 831 mOut.destroy(); 832 mOut = null; // make Java object eligible for garbage collection 833 if (mTempIns != null) { 834 for (Allocation tempIn : mTempIns) { 835 tempIn.destroy(); 836 } 837 838 mTempIns = null; // make Java objects eligible for garbage collection 839 } 840 841 mGotResult = true; 842 } 843 844 return mResult; 845 } 846 847 private resultArray7_long4(Allocation out) { 848 mTempIns = null; 849 mOut = out; 850 mGotResult = false; 851 } 852 853 private Allocation[] mTempIns; 854 private Allocation mOut; 855 private boolean mGotResult; 856 private Long4[] mResult; 857 } 858 859 // To obtain the result, invoke get(), which blocks 860 // until the asynchronously-launched operation has completed. 861 public static class resultArray7_short { 862 public short[] get() { 863 if (!mGotResult) { 864 short[] outArray = new short[7]; 865 mOut.copyTo(outArray); 866 mResult = outArray; 867 mOut.destroy(); 868 mOut = null; // make Java object eligible for garbage collection 869 if (mTempIns != null) { 870 for (Allocation tempIn : mTempIns) { 871 tempIn.destroy(); 872 } 873 874 mTempIns = null; // make Java objects eligible for garbage collection 875 } 876 877 mGotResult = true; 878 } 879 880 return mResult; 881 } 882 883 private resultArray7_short(Allocation out) { 884 mTempIns = null; 885 mOut = out; 886 mGotResult = false; 887 } 888 889 private Allocation[] mTempIns; 890 private Allocation mOut; 891 private boolean mGotResult; 892 private short[] mResult; 893 } 894 895 // To obtain the result, invoke get(), which blocks 896 // until the asynchronously-launched operation has completed. 897 public static class resultArray7_short2 { 898 public Short2[] get() { 899 if (!mGotResult) { 900 short[] outArray = new short[14]; 901 mOut.copyTo(outArray); 902 Short2[] result = new Short2[7]; 903 for (int Idx = 0; Idx < 7; ++Idx) { 904 result[Idx] = new Short2(outArray[2*Idx+0], outArray[2*Idx+1]); 905 } 906 907 mResult = result; 908 mOut.destroy(); 909 mOut = null; // make Java object eligible for garbage collection 910 if (mTempIns != null) { 911 for (Allocation tempIn : mTempIns) { 912 tempIn.destroy(); 913 } 914 915 mTempIns = null; // make Java objects eligible for garbage collection 916 } 917 918 mGotResult = true; 919 } 920 921 return mResult; 922 } 923 924 private resultArray7_short2(Allocation out) { 925 mTempIns = null; 926 mOut = out; 927 mGotResult = false; 928 } 929 930 private Allocation[] mTempIns; 931 private Allocation mOut; 932 private boolean mGotResult; 933 private Short2[] mResult; 934 } 935 936 // To obtain the result, invoke get(), which blocks 937 // until the asynchronously-launched operation has completed. 938 public static class resultArray7_short4 { 939 public Short4[] get() { 940 if (!mGotResult) { 941 short[] outArray = new short[28]; 942 mOut.copyTo(outArray); 943 Short4[] result = new Short4[7]; 944 for (int Idx = 0; Idx < 7; ++Idx) { 945 result[Idx] = new Short4(outArray[4*Idx+0], outArray[4*Idx+1], outArray[4*Idx+2], outArray[4*Idx+3]); 946 } 947 948 mResult = result; 949 mOut.destroy(); 950 mOut = null; // make Java object eligible for garbage collection 951 if (mTempIns != null) { 952 for (Allocation tempIn : mTempIns) { 953 tempIn.destroy(); 954 } 955 956 mTempIns = null; // make Java objects eligible for garbage collection 957 } 958 959 mGotResult = true; 960 } 961 962 return mResult; 963 } 964 965 private resultArray7_short4(Allocation out) { 966 mTempIns = null; 967 mOut = out; 968 mGotResult = false; 969 } 970 971 private Allocation[] mTempIns; 972 private Allocation mOut; 973 private boolean mGotResult; 974 private Short4[] mResult; 975 } 976 977 // To obtain the result, invoke get(), which blocks 978 // until the asynchronously-launched operation has completed. 979 public static class resultArray7_uchar { 980 public short[] get() { 981 if (!mGotResult) { 982 byte[] outArray = new byte[7]; 983 mOut.copyTo(outArray); 984 short[] result = new short[7]; 985 for (int Idx = 0; Idx < 7; ++Idx) { 986 result[Idx] = ((short) ((outArray[Idx]) & (short) 0xff)); 987 } 988 989 mResult = result; 990 mOut.destroy(); 991 mOut = null; // make Java object eligible for garbage collection 992 if (mTempIns != null) { 993 for (Allocation tempIn : mTempIns) { 994 tempIn.destroy(); 995 } 996 997 mTempIns = null; // make Java objects eligible for garbage collection 998 } 999 1000 mGotResult = true; 1001 } 1002 1003 return mResult; 1004 } 1005 1006 private resultArray7_uchar(Allocation out) { 1007 mTempIns = null; 1008 mOut = out; 1009 mGotResult = false; 1010 } 1011 1012 private Allocation[] mTempIns; 1013 private Allocation mOut; 1014 private boolean mGotResult; 1015 private short[] mResult; 1016 } 1017 1018 // To obtain the result, invoke get(), which blocks 1019 // until the asynchronously-launched operation has completed. 1020 public static class resultArray7_uchar2 { 1021 public Short2[] get() { 1022 if (!mGotResult) { 1023 byte[] outArray = new byte[14]; 1024 mOut.copyTo(outArray); 1025 Short2[] result = new Short2[7]; 1026 for (int Idx = 0; Idx < 7; ++Idx) { 1027 result[Idx] = new Short2(((short) ((outArray[2*Idx+0]) & (short) 0xff)), ((short) ((outArray[2*Idx+1]) & (short) 0xff))); 1028 } 1029 1030 mResult = result; 1031 mOut.destroy(); 1032 mOut = null; // make Java object eligible for garbage collection 1033 if (mTempIns != null) { 1034 for (Allocation tempIn : mTempIns) { 1035 tempIn.destroy(); 1036 } 1037 1038 mTempIns = null; // make Java objects eligible for garbage collection 1039 } 1040 1041 mGotResult = true; 1042 } 1043 1044 return mResult; 1045 } 1046 1047 private resultArray7_uchar2(Allocation out) { 1048 mTempIns = null; 1049 mOut = out; 1050 mGotResult = false; 1051 } 1052 1053 private Allocation[] mTempIns; 1054 private Allocation mOut; 1055 private boolean mGotResult; 1056 private Short2[] mResult; 1057 } 1058 1059 // To obtain the result, invoke get(), which blocks 1060 // until the asynchronously-launched operation has completed. 1061 public static class resultArray7_uchar4 { 1062 public Short4[] get() { 1063 if (!mGotResult) { 1064 byte[] outArray = new byte[28]; 1065 mOut.copyTo(outArray); 1066 Short4[] result = new Short4[7]; 1067 for (int Idx = 0; Idx < 7; ++Idx) { 1068 result[Idx] = new Short4(((short) ((outArray[4*Idx+0]) & (short) 0xff)), ((short) ((outArray[4*Idx+1]) & (short) 0xff)), ((short) ((outArray[4*Idx+2]) & (short) 0xff)), ((short) ((outArray[4*Idx+3]) & (short) 0xff))); 1069 } 1070 1071 mResult = result; 1072 mOut.destroy(); 1073 mOut = null; // make Java object eligible for garbage collection 1074 if (mTempIns != null) { 1075 for (Allocation tempIn : mTempIns) { 1076 tempIn.destroy(); 1077 } 1078 1079 mTempIns = null; // make Java objects eligible for garbage collection 1080 } 1081 1082 mGotResult = true; 1083 } 1084 1085 return mResult; 1086 } 1087 1088 private resultArray7_uchar4(Allocation out) { 1089 mTempIns = null; 1090 mOut = out; 1091 mGotResult = false; 1092 } 1093 1094 private Allocation[] mTempIns; 1095 private Allocation mOut; 1096 private boolean mGotResult; 1097 private Short4[] mResult; 1098 } 1099 1100 // To obtain the result, invoke get(), which blocks 1101 // until the asynchronously-launched operation has completed. 1102 public static class resultArray7_uint { 1103 public long[] get() { 1104 if (!mGotResult) { 1105 int[] outArray = new int[7]; 1106 mOut.copyTo(outArray); 1107 long[] result = new long[7]; 1108 for (int Idx = 0; Idx < 7; ++Idx) { 1109 result[Idx] = ((long) ((outArray[Idx]) & 0xffffffffL)); 1110 } 1111 1112 mResult = result; 1113 mOut.destroy(); 1114 mOut = null; // make Java object eligible for garbage collection 1115 if (mTempIns != null) { 1116 for (Allocation tempIn : mTempIns) { 1117 tempIn.destroy(); 1118 } 1119 1120 mTempIns = null; // make Java objects eligible for garbage collection 1121 } 1122 1123 mGotResult = true; 1124 } 1125 1126 return mResult; 1127 } 1128 1129 private resultArray7_uint(Allocation out) { 1130 mTempIns = null; 1131 mOut = out; 1132 mGotResult = false; 1133 } 1134 1135 private Allocation[] mTempIns; 1136 private Allocation mOut; 1137 private boolean mGotResult; 1138 private long[] mResult; 1139 } 1140 1141 // To obtain the result, invoke get(), which blocks 1142 // until the asynchronously-launched operation has completed. 1143 public static class resultArray7_uint2 { 1144 public Long2[] get() { 1145 if (!mGotResult) { 1146 int[] outArray = new int[14]; 1147 mOut.copyTo(outArray); 1148 Long2[] result = new Long2[7]; 1149 for (int Idx = 0; Idx < 7; ++Idx) { 1150 result[Idx] = new Long2(((long) ((outArray[2*Idx+0]) & 0xffffffffL)), ((long) ((outArray[2*Idx+1]) & 0xffffffffL))); 1151 } 1152 1153 mResult = result; 1154 mOut.destroy(); 1155 mOut = null; // make Java object eligible for garbage collection 1156 if (mTempIns != null) { 1157 for (Allocation tempIn : mTempIns) { 1158 tempIn.destroy(); 1159 } 1160 1161 mTempIns = null; // make Java objects eligible for garbage collection 1162 } 1163 1164 mGotResult = true; 1165 } 1166 1167 return mResult; 1168 } 1169 1170 private resultArray7_uint2(Allocation out) { 1171 mTempIns = null; 1172 mOut = out; 1173 mGotResult = false; 1174 } 1175 1176 private Allocation[] mTempIns; 1177 private Allocation mOut; 1178 private boolean mGotResult; 1179 private Long2[] mResult; 1180 } 1181 1182 // To obtain the result, invoke get(), which blocks 1183 // until the asynchronously-launched operation has completed. 1184 public static class resultArray7_uint4 { 1185 public Long4[] get() { 1186 if (!mGotResult) { 1187 int[] outArray = new int[28]; 1188 mOut.copyTo(outArray); 1189 Long4[] result = new Long4[7]; 1190 for (int Idx = 0; Idx < 7; ++Idx) { 1191 result[Idx] = new Long4(((long) ((outArray[4*Idx+0]) & 0xffffffffL)), ((long) ((outArray[4*Idx+1]) & 0xffffffffL)), ((long) ((outArray[4*Idx+2]) & 0xffffffffL)), ((long) ((outArray[4*Idx+3]) & 0xffffffffL))); 1192 } 1193 1194 mResult = result; 1195 mOut.destroy(); 1196 mOut = null; // make Java object eligible for garbage collection 1197 if (mTempIns != null) { 1198 for (Allocation tempIn : mTempIns) { 1199 tempIn.destroy(); 1200 } 1201 1202 mTempIns = null; // make Java objects eligible for garbage collection 1203 } 1204 1205 mGotResult = true; 1206 } 1207 1208 return mResult; 1209 } 1210 1211 private resultArray7_uint4(Allocation out) { 1212 mTempIns = null; 1213 mOut = out; 1214 mGotResult = false; 1215 } 1216 1217 private Allocation[] mTempIns; 1218 private Allocation mOut; 1219 private boolean mGotResult; 1220 private Long4[] mResult; 1221 } 1222 1223 // To obtain the result, invoke get(), which blocks 1224 // until the asynchronously-launched operation has completed. 1225 public static class resultArray7_ulong { 1226 public long[] get() { 1227 if (!mGotResult) { 1228 long[] outArray = new long[7]; 1229 mOut.copyTo(outArray); 1230 for (int Idx = 0; Idx < 7; ++Idx) { 1231 if (outArray[Idx] < 0) 1232 throw new RSRuntimeException("Result is not representible in Java"); 1233 } 1234 1235 mResult = outArray; 1236 mOut.destroy(); 1237 mOut = null; // make Java object eligible for garbage collection 1238 if (mTempIns != null) { 1239 for (Allocation tempIn : mTempIns) { 1240 tempIn.destroy(); 1241 } 1242 1243 mTempIns = null; // make Java objects eligible for garbage collection 1244 } 1245 1246 mGotResult = true; 1247 } 1248 1249 return mResult; 1250 } 1251 1252 private resultArray7_ulong(Allocation out) { 1253 mTempIns = null; 1254 mOut = out; 1255 mGotResult = false; 1256 } 1257 1258 private Allocation[] mTempIns; 1259 private Allocation mOut; 1260 private boolean mGotResult; 1261 private long[] mResult; 1262 } 1263 1264 // To obtain the result, invoke get(), which blocks 1265 // until the asynchronously-launched operation has completed. 1266 public static class resultArray7_ulong2 { 1267 public Long2[] get() { 1268 if (!mGotResult) { 1269 long[] outArray = new long[14]; 1270 mOut.copyTo(outArray); 1271 for (int Idx = 0; Idx < 14; ++Idx) { 1272 if (outArray[Idx] < 0) 1273 throw new RSRuntimeException("Result is not representible in Java"); 1274 } 1275 1276 Long2[] result = new Long2[7]; 1277 for (int Idx = 0; Idx < 7; ++Idx) { 1278 result[Idx] = new Long2(outArray[2*Idx+0], outArray[2*Idx+1]); 1279 } 1280 1281 mResult = result; 1282 mOut.destroy(); 1283 mOut = null; // make Java object eligible for garbage collection 1284 if (mTempIns != null) { 1285 for (Allocation tempIn : mTempIns) { 1286 tempIn.destroy(); 1287 } 1288 1289 mTempIns = null; // make Java objects eligible for garbage collection 1290 } 1291 1292 mGotResult = true; 1293 } 1294 1295 return mResult; 1296 } 1297 1298 private resultArray7_ulong2(Allocation out) { 1299 mTempIns = null; 1300 mOut = out; 1301 mGotResult = false; 1302 } 1303 1304 private Allocation[] mTempIns; 1305 private Allocation mOut; 1306 private boolean mGotResult; 1307 private Long2[] mResult; 1308 } 1309 1310 // To obtain the result, invoke get(), which blocks 1311 // until the asynchronously-launched operation has completed. 1312 public static class resultArray7_ulong4 { 1313 public Long4[] get() { 1314 if (!mGotResult) { 1315 long[] outArray = new long[28]; 1316 mOut.copyTo(outArray); 1317 for (int Idx = 0; Idx < 28; ++Idx) { 1318 if (outArray[Idx] < 0) 1319 throw new RSRuntimeException("Result is not representible in Java"); 1320 } 1321 1322 Long4[] result = new Long4[7]; 1323 for (int Idx = 0; Idx < 7; ++Idx) { 1324 result[Idx] = new Long4(outArray[4*Idx+0], outArray[4*Idx+1], outArray[4*Idx+2], outArray[4*Idx+3]); 1325 } 1326 1327 mResult = result; 1328 mOut.destroy(); 1329 mOut = null; // make Java object eligible for garbage collection 1330 if (mTempIns != null) { 1331 for (Allocation tempIn : mTempIns) { 1332 tempIn.destroy(); 1333 } 1334 1335 mTempIns = null; // make Java objects eligible for garbage collection 1336 } 1337 1338 mGotResult = true; 1339 } 1340 1341 return mResult; 1342 } 1343 1344 private resultArray7_ulong4(Allocation out) { 1345 mTempIns = null; 1346 mOut = out; 1347 mGotResult = false; 1348 } 1349 1350 private Allocation[] mTempIns; 1351 private Allocation mOut; 1352 private boolean mGotResult; 1353 private Long4[] mResult; 1354 } 1355 1356 // To obtain the result, invoke get(), which blocks 1357 // until the asynchronously-launched operation has completed. 1358 public static class resultArray7_ushort { 1359 public int[] get() { 1360 if (!mGotResult) { 1361 short[] outArray = new short[7]; 1362 mOut.copyTo(outArray); 1363 int[] result = new int[7]; 1364 for (int Idx = 0; Idx < 7; ++Idx) { 1365 result[Idx] = ((int) ((outArray[Idx]) & 0xffff)); 1366 } 1367 1368 mResult = result; 1369 mOut.destroy(); 1370 mOut = null; // make Java object eligible for garbage collection 1371 if (mTempIns != null) { 1372 for (Allocation tempIn : mTempIns) { 1373 tempIn.destroy(); 1374 } 1375 1376 mTempIns = null; // make Java objects eligible for garbage collection 1377 } 1378 1379 mGotResult = true; 1380 } 1381 1382 return mResult; 1383 } 1384 1385 private resultArray7_ushort(Allocation out) { 1386 mTempIns = null; 1387 mOut = out; 1388 mGotResult = false; 1389 } 1390 1391 private Allocation[] mTempIns; 1392 private Allocation mOut; 1393 private boolean mGotResult; 1394 private int[] mResult; 1395 } 1396 1397 // To obtain the result, invoke get(), which blocks 1398 // until the asynchronously-launched operation has completed. 1399 public static class resultArray7_ushort2 { 1400 public Int2[] get() { 1401 if (!mGotResult) { 1402 short[] outArray = new short[14]; 1403 mOut.copyTo(outArray); 1404 Int2[] result = new Int2[7]; 1405 for (int Idx = 0; Idx < 7; ++Idx) { 1406 result[Idx] = new Int2(((int) ((outArray[2*Idx+0]) & 0xffff)), ((int) ((outArray[2*Idx+1]) & 0xffff))); 1407 } 1408 1409 mResult = result; 1410 mOut.destroy(); 1411 mOut = null; // make Java object eligible for garbage collection 1412 if (mTempIns != null) { 1413 for (Allocation tempIn : mTempIns) { 1414 tempIn.destroy(); 1415 } 1416 1417 mTempIns = null; // make Java objects eligible for garbage collection 1418 } 1419 1420 mGotResult = true; 1421 } 1422 1423 return mResult; 1424 } 1425 1426 private resultArray7_ushort2(Allocation out) { 1427 mTempIns = null; 1428 mOut = out; 1429 mGotResult = false; 1430 } 1431 1432 private Allocation[] mTempIns; 1433 private Allocation mOut; 1434 private boolean mGotResult; 1435 private Int2[] mResult; 1436 } 1437 1438 // To obtain the result, invoke get(), which blocks 1439 // until the asynchronously-launched operation has completed. 1440 public static class resultArray7_ushort4 { 1441 public Int4[] get() { 1442 if (!mGotResult) { 1443 short[] outArray = new short[28]; 1444 mOut.copyTo(outArray); 1445 Int4[] result = new Int4[7]; 1446 for (int Idx = 0; Idx < 7; ++Idx) { 1447 result[Idx] = new Int4(((int) ((outArray[4*Idx+0]) & 0xffff)), ((int) ((outArray[4*Idx+1]) & 0xffff)), ((int) ((outArray[4*Idx+2]) & 0xffff)), ((int) ((outArray[4*Idx+3]) & 0xffff))); 1448 } 1449 1450 mResult = result; 1451 mOut.destroy(); 1452 mOut = null; // make Java object eligible for garbage collection 1453 if (mTempIns != null) { 1454 for (Allocation tempIn : mTempIns) { 1455 tempIn.destroy(); 1456 } 1457 1458 mTempIns = null; // make Java objects eligible for garbage collection 1459 } 1460 1461 mGotResult = true; 1462 } 1463 1464 return mResult; 1465 } 1466 1467 private resultArray7_ushort4(Allocation out) { 1468 mTempIns = null; 1469 mOut = out; 1470 mGotResult = false; 1471 } 1472 1473 private Allocation[] mTempIns; 1474 private Allocation mOut; 1475 private boolean mGotResult; 1476 private Int4[] mResult; 1477 } 1478 1479 // To obtain the result, invoke get(), which blocks 1480 // until the asynchronously-launched operation has completed. 1481 public static class result_bool { 1482 public boolean get() { 1483 if (!mGotResult) { 1484 byte[] outArray = new byte[1]; 1485 mOut.copyTo(outArray); 1486 mResult = outArray[0] != 0; 1487 mOut.destroy(); 1488 mOut = null; // make Java object eligible for garbage collection 1489 if (mTempIns != null) { 1490 for (Allocation tempIn : mTempIns) { 1491 tempIn.destroy(); 1492 } 1493 1494 mTempIns = null; // make Java objects eligible for garbage collection 1495 } 1496 1497 mGotResult = true; 1498 } 1499 1500 return mResult; 1501 } 1502 1503 private result_bool(Allocation out) { 1504 mTempIns = null; 1505 mOut = out; 1506 mGotResult = false; 1507 } 1508 1509 private Allocation[] mTempIns; 1510 private Allocation mOut; 1511 private boolean mGotResult; 1512 private boolean mResult; 1513 } 1514 1515 // To obtain the result, invoke get(), which blocks 1516 // until the asynchronously-launched operation has completed. 1517 public static class result_char { 1518 public byte get() { 1519 if (!mGotResult) { 1520 byte[] outArray = new byte[1]; 1521 mOut.copyTo(outArray); 1522 mResult = outArray[0]; 1523 mOut.destroy(); 1524 mOut = null; // make Java object eligible for garbage collection 1525 if (mTempIns != null) { 1526 for (Allocation tempIn : mTempIns) { 1527 tempIn.destroy(); 1528 } 1529 1530 mTempIns = null; // make Java objects eligible for garbage collection 1531 } 1532 1533 mGotResult = true; 1534 } 1535 1536 return mResult; 1537 } 1538 1539 private result_char(Allocation out) { 1540 mTempIns = null; 1541 mOut = out; 1542 mGotResult = false; 1543 } 1544 1545 private Allocation[] mTempIns; 1546 private Allocation mOut; 1547 private boolean mGotResult; 1548 private byte mResult; 1549 } 1550 1551 // To obtain the result, invoke get(), which blocks 1552 // until the asynchronously-launched operation has completed. 1553 public static class result_char2 { 1554 public Byte2 get() { 1555 if (!mGotResult) { 1556 byte[] outArray = new byte[2]; 1557 mOut.copyTo(outArray); 1558 mResult = new Byte2(outArray[0], outArray[1]); 1559 mOut.destroy(); 1560 mOut = null; // make Java object eligible for garbage collection 1561 if (mTempIns != null) { 1562 for (Allocation tempIn : mTempIns) { 1563 tempIn.destroy(); 1564 } 1565 1566 mTempIns = null; // make Java objects eligible for garbage collection 1567 } 1568 1569 mGotResult = true; 1570 } 1571 1572 return mResult; 1573 } 1574 1575 private result_char2(Allocation out) { 1576 mTempIns = null; 1577 mOut = out; 1578 mGotResult = false; 1579 } 1580 1581 private Allocation[] mTempIns; 1582 private Allocation mOut; 1583 private boolean mGotResult; 1584 private Byte2 mResult; 1585 } 1586 1587 // To obtain the result, invoke get(), which blocks 1588 // until the asynchronously-launched operation has completed. 1589 public static class result_char4 { 1590 public Byte4 get() { 1591 if (!mGotResult) { 1592 byte[] outArray = new byte[4]; 1593 mOut.copyTo(outArray); 1594 mResult = new Byte4(outArray[0], outArray[1], outArray[2], outArray[3]); 1595 mOut.destroy(); 1596 mOut = null; // make Java object eligible for garbage collection 1597 if (mTempIns != null) { 1598 for (Allocation tempIn : mTempIns) { 1599 tempIn.destroy(); 1600 } 1601 1602 mTempIns = null; // make Java objects eligible for garbage collection 1603 } 1604 1605 mGotResult = true; 1606 } 1607 1608 return mResult; 1609 } 1610 1611 private result_char4(Allocation out) { 1612 mTempIns = null; 1613 mOut = out; 1614 mGotResult = false; 1615 } 1616 1617 private Allocation[] mTempIns; 1618 private Allocation mOut; 1619 private boolean mGotResult; 1620 private Byte4 mResult; 1621 } 1622 1623 // To obtain the result, invoke get(), which blocks 1624 // until the asynchronously-launched operation has completed. 1625 public static class result_double { 1626 public double get() { 1627 if (!mGotResult) { 1628 double[] outArray = new double[1]; 1629 mOut.copyTo(outArray); 1630 mResult = outArray[0]; 1631 mOut.destroy(); 1632 mOut = null; // make Java object eligible for garbage collection 1633 if (mTempIns != null) { 1634 for (Allocation tempIn : mTempIns) { 1635 tempIn.destroy(); 1636 } 1637 1638 mTempIns = null; // make Java objects eligible for garbage collection 1639 } 1640 1641 mGotResult = true; 1642 } 1643 1644 return mResult; 1645 } 1646 1647 private result_double(Allocation out) { 1648 mTempIns = null; 1649 mOut = out; 1650 mGotResult = false; 1651 } 1652 1653 private Allocation[] mTempIns; 1654 private Allocation mOut; 1655 private boolean mGotResult; 1656 private double mResult; 1657 } 1658 1659 // To obtain the result, invoke get(), which blocks 1660 // until the asynchronously-launched operation has completed. 1661 public static class result_double2 { 1662 public Double2 get() { 1663 if (!mGotResult) { 1664 double[] outArray = new double[2]; 1665 mOut.copyTo(outArray); 1666 mResult = new Double2(outArray[0], outArray[1]); 1667 mOut.destroy(); 1668 mOut = null; // make Java object eligible for garbage collection 1669 if (mTempIns != null) { 1670 for (Allocation tempIn : mTempIns) { 1671 tempIn.destroy(); 1672 } 1673 1674 mTempIns = null; // make Java objects eligible for garbage collection 1675 } 1676 1677 mGotResult = true; 1678 } 1679 1680 return mResult; 1681 } 1682 1683 private result_double2(Allocation out) { 1684 mTempIns = null; 1685 mOut = out; 1686 mGotResult = false; 1687 } 1688 1689 private Allocation[] mTempIns; 1690 private Allocation mOut; 1691 private boolean mGotResult; 1692 private Double2 mResult; 1693 } 1694 1695 // To obtain the result, invoke get(), which blocks 1696 // until the asynchronously-launched operation has completed. 1697 public static class result_double4 { 1698 public Double4 get() { 1699 if (!mGotResult) { 1700 double[] outArray = new double[4]; 1701 mOut.copyTo(outArray); 1702 mResult = new Double4(outArray[0], outArray[1], outArray[2], outArray[3]); 1703 mOut.destroy(); 1704 mOut = null; // make Java object eligible for garbage collection 1705 if (mTempIns != null) { 1706 for (Allocation tempIn : mTempIns) { 1707 tempIn.destroy(); 1708 } 1709 1710 mTempIns = null; // make Java objects eligible for garbage collection 1711 } 1712 1713 mGotResult = true; 1714 } 1715 1716 return mResult; 1717 } 1718 1719 private result_double4(Allocation out) { 1720 mTempIns = null; 1721 mOut = out; 1722 mGotResult = false; 1723 } 1724 1725 private Allocation[] mTempIns; 1726 private Allocation mOut; 1727 private boolean mGotResult; 1728 private Double4 mResult; 1729 } 1730 1731 // To obtain the result, invoke get(), which blocks 1732 // until the asynchronously-launched operation has completed. 1733 public static class result_float { 1734 public float get() { 1735 if (!mGotResult) { 1736 float[] outArray = new float[1]; 1737 mOut.copyTo(outArray); 1738 mResult = outArray[0]; 1739 mOut.destroy(); 1740 mOut = null; // make Java object eligible for garbage collection 1741 if (mTempIns != null) { 1742 for (Allocation tempIn : mTempIns) { 1743 tempIn.destroy(); 1744 } 1745 1746 mTempIns = null; // make Java objects eligible for garbage collection 1747 } 1748 1749 mGotResult = true; 1750 } 1751 1752 return mResult; 1753 } 1754 1755 private result_float(Allocation out) { 1756 mTempIns = null; 1757 mOut = out; 1758 mGotResult = false; 1759 } 1760 1761 private Allocation[] mTempIns; 1762 private Allocation mOut; 1763 private boolean mGotResult; 1764 private float mResult; 1765 } 1766 1767 // To obtain the result, invoke get(), which blocks 1768 // until the asynchronously-launched operation has completed. 1769 public static class result_float2 { 1770 public Float2 get() { 1771 if (!mGotResult) { 1772 float[] outArray = new float[2]; 1773 mOut.copyTo(outArray); 1774 mResult = new Float2(outArray[0], outArray[1]); 1775 mOut.destroy(); 1776 mOut = null; // make Java object eligible for garbage collection 1777 if (mTempIns != null) { 1778 for (Allocation tempIn : mTempIns) { 1779 tempIn.destroy(); 1780 } 1781 1782 mTempIns = null; // make Java objects eligible for garbage collection 1783 } 1784 1785 mGotResult = true; 1786 } 1787 1788 return mResult; 1789 } 1790 1791 private result_float2(Allocation out) { 1792 mTempIns = null; 1793 mOut = out; 1794 mGotResult = false; 1795 } 1796 1797 private Allocation[] mTempIns; 1798 private Allocation mOut; 1799 private boolean mGotResult; 1800 private Float2 mResult; 1801 } 1802 1803 // To obtain the result, invoke get(), which blocks 1804 // until the asynchronously-launched operation has completed. 1805 public static class result_float4 { 1806 public Float4 get() { 1807 if (!mGotResult) { 1808 float[] outArray = new float[4]; 1809 mOut.copyTo(outArray); 1810 mResult = new Float4(outArray[0], outArray[1], outArray[2], outArray[3]); 1811 mOut.destroy(); 1812 mOut = null; // make Java object eligible for garbage collection 1813 if (mTempIns != null) { 1814 for (Allocation tempIn : mTempIns) { 1815 tempIn.destroy(); 1816 } 1817 1818 mTempIns = null; // make Java objects eligible for garbage collection 1819 } 1820 1821 mGotResult = true; 1822 } 1823 1824 return mResult; 1825 } 1826 1827 private result_float4(Allocation out) { 1828 mTempIns = null; 1829 mOut = out; 1830 mGotResult = false; 1831 } 1832 1833 private Allocation[] mTempIns; 1834 private Allocation mOut; 1835 private boolean mGotResult; 1836 private Float4 mResult; 1837 } 1838 1839 // To obtain the result, invoke get(), which blocks 1840 // until the asynchronously-launched operation has completed. 1841 public static class result_half { 1842 public short get() { 1843 if (!mGotResult) { 1844 short[] outArray = new short[1]; 1845 mOut.copyTo(outArray); 1846 mResult = outArray[0]; 1847 mOut.destroy(); 1848 mOut = null; // make Java object eligible for garbage collection 1849 if (mTempIns != null) { 1850 for (Allocation tempIn : mTempIns) { 1851 tempIn.destroy(); 1852 } 1853 1854 mTempIns = null; // make Java objects eligible for garbage collection 1855 } 1856 1857 mGotResult = true; 1858 } 1859 1860 return mResult; 1861 } 1862 1863 private result_half(Allocation out) { 1864 mTempIns = null; 1865 mOut = out; 1866 mGotResult = false; 1867 } 1868 1869 private Allocation[] mTempIns; 1870 private Allocation mOut; 1871 private boolean mGotResult; 1872 private short mResult; 1873 } 1874 1875 // To obtain the result, invoke get(), which blocks 1876 // until the asynchronously-launched operation has completed. 1877 public static class result_half2 { 1878 public Short2 get() { 1879 if (!mGotResult) { 1880 short[] outArray = new short[2]; 1881 mOut.copyTo(outArray); 1882 mResult = new Short2(outArray[0], outArray[1]); 1883 mOut.destroy(); 1884 mOut = null; // make Java object eligible for garbage collection 1885 if (mTempIns != null) { 1886 for (Allocation tempIn : mTempIns) { 1887 tempIn.destroy(); 1888 } 1889 1890 mTempIns = null; // make Java objects eligible for garbage collection 1891 } 1892 1893 mGotResult = true; 1894 } 1895 1896 return mResult; 1897 } 1898 1899 private result_half2(Allocation out) { 1900 mTempIns = null; 1901 mOut = out; 1902 mGotResult = false; 1903 } 1904 1905 private Allocation[] mTempIns; 1906 private Allocation mOut; 1907 private boolean mGotResult; 1908 private Short2 mResult; 1909 } 1910 1911 // To obtain the result, invoke get(), which blocks 1912 // until the asynchronously-launched operation has completed. 1913 public static class result_half4 { 1914 public Short4 get() { 1915 if (!mGotResult) { 1916 short[] outArray = new short[4]; 1917 mOut.copyTo(outArray); 1918 mResult = new Short4(outArray[0], outArray[1], outArray[2], outArray[3]); 1919 mOut.destroy(); 1920 mOut = null; // make Java object eligible for garbage collection 1921 if (mTempIns != null) { 1922 for (Allocation tempIn : mTempIns) { 1923 tempIn.destroy(); 1924 } 1925 1926 mTempIns = null; // make Java objects eligible for garbage collection 1927 } 1928 1929 mGotResult = true; 1930 } 1931 1932 return mResult; 1933 } 1934 1935 private result_half4(Allocation out) { 1936 mTempIns = null; 1937 mOut = out; 1938 mGotResult = false; 1939 } 1940 1941 private Allocation[] mTempIns; 1942 private Allocation mOut; 1943 private boolean mGotResult; 1944 private Short4 mResult; 1945 } 1946 1947 // To obtain the result, invoke get(), which blocks 1948 // until the asynchronously-launched operation has completed. 1949 public static class result_int { 1950 public int get() { 1951 if (!mGotResult) { 1952 int[] outArray = new int[1]; 1953 mOut.copyTo(outArray); 1954 mResult = outArray[0]; 1955 mOut.destroy(); 1956 mOut = null; // make Java object eligible for garbage collection 1957 if (mTempIns != null) { 1958 for (Allocation tempIn : mTempIns) { 1959 tempIn.destroy(); 1960 } 1961 1962 mTempIns = null; // make Java objects eligible for garbage collection 1963 } 1964 1965 mGotResult = true; 1966 } 1967 1968 return mResult; 1969 } 1970 1971 private result_int(Allocation out) { 1972 mTempIns = null; 1973 mOut = out; 1974 mGotResult = false; 1975 } 1976 1977 private Allocation[] mTempIns; 1978 private Allocation mOut; 1979 private boolean mGotResult; 1980 private int mResult; 1981 } 1982 1983 // To obtain the result, invoke get(), which blocks 1984 // until the asynchronously-launched operation has completed. 1985 public static class result_int2 { 1986 public Int2 get() { 1987 if (!mGotResult) { 1988 int[] outArray = new int[2]; 1989 mOut.copyTo(outArray); 1990 mResult = new Int2(outArray[0], outArray[1]); 1991 mOut.destroy(); 1992 mOut = null; // make Java object eligible for garbage collection 1993 if (mTempIns != null) { 1994 for (Allocation tempIn : mTempIns) { 1995 tempIn.destroy(); 1996 } 1997 1998 mTempIns = null; // make Java objects eligible for garbage collection 1999 } 2000 2001 mGotResult = true; 2002 } 2003 2004 return mResult; 2005 } 2006 2007 private result_int2(Allocation out) { 2008 mTempIns = null; 2009 mOut = out; 2010 mGotResult = false; 2011 } 2012 2013 private Allocation[] mTempIns; 2014 private Allocation mOut; 2015 private boolean mGotResult; 2016 private Int2 mResult; 2017 } 2018 2019 // To obtain the result, invoke get(), which blocks 2020 // until the asynchronously-launched operation has completed. 2021 public static class result_int4 { 2022 public Int4 get() { 2023 if (!mGotResult) { 2024 int[] outArray = new int[4]; 2025 mOut.copyTo(outArray); 2026 mResult = new Int4(outArray[0], outArray[1], outArray[2], outArray[3]); 2027 mOut.destroy(); 2028 mOut = null; // make Java object eligible for garbage collection 2029 if (mTempIns != null) { 2030 for (Allocation tempIn : mTempIns) { 2031 tempIn.destroy(); 2032 } 2033 2034 mTempIns = null; // make Java objects eligible for garbage collection 2035 } 2036 2037 mGotResult = true; 2038 } 2039 2040 return mResult; 2041 } 2042 2043 private result_int4(Allocation out) { 2044 mTempIns = null; 2045 mOut = out; 2046 mGotResult = false; 2047 } 2048 2049 private Allocation[] mTempIns; 2050 private Allocation mOut; 2051 private boolean mGotResult; 2052 private Int4 mResult; 2053 } 2054 2055 // To obtain the result, invoke get(), which blocks 2056 // until the asynchronously-launched operation has completed. 2057 public static class result_long { 2058 public long get() { 2059 if (!mGotResult) { 2060 long[] outArray = new long[1]; 2061 mOut.copyTo(outArray); 2062 mResult = outArray[0]; 2063 mOut.destroy(); 2064 mOut = null; // make Java object eligible for garbage collection 2065 if (mTempIns != null) { 2066 for (Allocation tempIn : mTempIns) { 2067 tempIn.destroy(); 2068 } 2069 2070 mTempIns = null; // make Java objects eligible for garbage collection 2071 } 2072 2073 mGotResult = true; 2074 } 2075 2076 return mResult; 2077 } 2078 2079 private result_long(Allocation out) { 2080 mTempIns = null; 2081 mOut = out; 2082 mGotResult = false; 2083 } 2084 2085 private Allocation[] mTempIns; 2086 private Allocation mOut; 2087 private boolean mGotResult; 2088 private long mResult; 2089 } 2090 2091 // To obtain the result, invoke get(), which blocks 2092 // until the asynchronously-launched operation has completed. 2093 public static class result_long2 { 2094 public Long2 get() { 2095 if (!mGotResult) { 2096 long[] outArray = new long[2]; 2097 mOut.copyTo(outArray); 2098 mResult = new Long2(outArray[0], outArray[1]); 2099 mOut.destroy(); 2100 mOut = null; // make Java object eligible for garbage collection 2101 if (mTempIns != null) { 2102 for (Allocation tempIn : mTempIns) { 2103 tempIn.destroy(); 2104 } 2105 2106 mTempIns = null; // make Java objects eligible for garbage collection 2107 } 2108 2109 mGotResult = true; 2110 } 2111 2112 return mResult; 2113 } 2114 2115 private result_long2(Allocation out) { 2116 mTempIns = null; 2117 mOut = out; 2118 mGotResult = false; 2119 } 2120 2121 private Allocation[] mTempIns; 2122 private Allocation mOut; 2123 private boolean mGotResult; 2124 private Long2 mResult; 2125 } 2126 2127 // To obtain the result, invoke get(), which blocks 2128 // until the asynchronously-launched operation has completed. 2129 public static class result_long4 { 2130 public Long4 get() { 2131 if (!mGotResult) { 2132 long[] outArray = new long[4]; 2133 mOut.copyTo(outArray); 2134 mResult = new Long4(outArray[0], outArray[1], outArray[2], outArray[3]); 2135 mOut.destroy(); 2136 mOut = null; // make Java object eligible for garbage collection 2137 if (mTempIns != null) { 2138 for (Allocation tempIn : mTempIns) { 2139 tempIn.destroy(); 2140 } 2141 2142 mTempIns = null; // make Java objects eligible for garbage collection 2143 } 2144 2145 mGotResult = true; 2146 } 2147 2148 return mResult; 2149 } 2150 2151 private result_long4(Allocation out) { 2152 mTempIns = null; 2153 mOut = out; 2154 mGotResult = false; 2155 } 2156 2157 private Allocation[] mTempIns; 2158 private Allocation mOut; 2159 private boolean mGotResult; 2160 private Long4 mResult; 2161 } 2162 2163 // To obtain the result, invoke get(), which blocks 2164 // until the asynchronously-launched operation has completed. 2165 public static class result_short { 2166 public short get() { 2167 if (!mGotResult) { 2168 short[] outArray = new short[1]; 2169 mOut.copyTo(outArray); 2170 mResult = outArray[0]; 2171 mOut.destroy(); 2172 mOut = null; // make Java object eligible for garbage collection 2173 if (mTempIns != null) { 2174 for (Allocation tempIn : mTempIns) { 2175 tempIn.destroy(); 2176 } 2177 2178 mTempIns = null; // make Java objects eligible for garbage collection 2179 } 2180 2181 mGotResult = true; 2182 } 2183 2184 return mResult; 2185 } 2186 2187 private result_short(Allocation out) { 2188 mTempIns = null; 2189 mOut = out; 2190 mGotResult = false; 2191 } 2192 2193 private Allocation[] mTempIns; 2194 private Allocation mOut; 2195 private boolean mGotResult; 2196 private short mResult; 2197 } 2198 2199 // To obtain the result, invoke get(), which blocks 2200 // until the asynchronously-launched operation has completed. 2201 public static class result_short2 { 2202 public Short2 get() { 2203 if (!mGotResult) { 2204 short[] outArray = new short[2]; 2205 mOut.copyTo(outArray); 2206 mResult = new Short2(outArray[0], outArray[1]); 2207 mOut.destroy(); 2208 mOut = null; // make Java object eligible for garbage collection 2209 if (mTempIns != null) { 2210 for (Allocation tempIn : mTempIns) { 2211 tempIn.destroy(); 2212 } 2213 2214 mTempIns = null; // make Java objects eligible for garbage collection 2215 } 2216 2217 mGotResult = true; 2218 } 2219 2220 return mResult; 2221 } 2222 2223 private result_short2(Allocation out) { 2224 mTempIns = null; 2225 mOut = out; 2226 mGotResult = false; 2227 } 2228 2229 private Allocation[] mTempIns; 2230 private Allocation mOut; 2231 private boolean mGotResult; 2232 private Short2 mResult; 2233 } 2234 2235 // To obtain the result, invoke get(), which blocks 2236 // until the asynchronously-launched operation has completed. 2237 public static class result_short4 { 2238 public Short4 get() { 2239 if (!mGotResult) { 2240 short[] outArray = new short[4]; 2241 mOut.copyTo(outArray); 2242 mResult = new Short4(outArray[0], outArray[1], outArray[2], outArray[3]); 2243 mOut.destroy(); 2244 mOut = null; // make Java object eligible for garbage collection 2245 if (mTempIns != null) { 2246 for (Allocation tempIn : mTempIns) { 2247 tempIn.destroy(); 2248 } 2249 2250 mTempIns = null; // make Java objects eligible for garbage collection 2251 } 2252 2253 mGotResult = true; 2254 } 2255 2256 return mResult; 2257 } 2258 2259 private result_short4(Allocation out) { 2260 mTempIns = null; 2261 mOut = out; 2262 mGotResult = false; 2263 } 2264 2265 private Allocation[] mTempIns; 2266 private Allocation mOut; 2267 private boolean mGotResult; 2268 private Short4 mResult; 2269 } 2270 2271 // To obtain the result, invoke get(), which blocks 2272 // until the asynchronously-launched operation has completed. 2273 public static class result_uchar { 2274 public short get() { 2275 if (!mGotResult) { 2276 byte[] outArray = new byte[1]; 2277 mOut.copyTo(outArray); 2278 mResult = ((short) ((outArray[0]) & (short) 0xff)); 2279 mOut.destroy(); 2280 mOut = null; // make Java object eligible for garbage collection 2281 if (mTempIns != null) { 2282 for (Allocation tempIn : mTempIns) { 2283 tempIn.destroy(); 2284 } 2285 2286 mTempIns = null; // make Java objects eligible for garbage collection 2287 } 2288 2289 mGotResult = true; 2290 } 2291 2292 return mResult; 2293 } 2294 2295 private result_uchar(Allocation out) { 2296 mTempIns = null; 2297 mOut = out; 2298 mGotResult = false; 2299 } 2300 2301 private Allocation[] mTempIns; 2302 private Allocation mOut; 2303 private boolean mGotResult; 2304 private short mResult; 2305 } 2306 2307 // To obtain the result, invoke get(), which blocks 2308 // until the asynchronously-launched operation has completed. 2309 public static class result_uchar2 { 2310 public Short2 get() { 2311 if (!mGotResult) { 2312 byte[] outArray = new byte[2]; 2313 mOut.copyTo(outArray); 2314 mResult = new Short2(((short) ((outArray[0]) & (short) 0xff)), ((short) ((outArray[1]) & (short) 0xff))); 2315 mOut.destroy(); 2316 mOut = null; // make Java object eligible for garbage collection 2317 if (mTempIns != null) { 2318 for (Allocation tempIn : mTempIns) { 2319 tempIn.destroy(); 2320 } 2321 2322 mTempIns = null; // make Java objects eligible for garbage collection 2323 } 2324 2325 mGotResult = true; 2326 } 2327 2328 return mResult; 2329 } 2330 2331 private result_uchar2(Allocation out) { 2332 mTempIns = null; 2333 mOut = out; 2334 mGotResult = false; 2335 } 2336 2337 private Allocation[] mTempIns; 2338 private Allocation mOut; 2339 private boolean mGotResult; 2340 private Short2 mResult; 2341 } 2342 2343 // To obtain the result, invoke get(), which blocks 2344 // until the asynchronously-launched operation has completed. 2345 public static class result_uchar4 { 2346 public Short4 get() { 2347 if (!mGotResult) { 2348 byte[] outArray = new byte[4]; 2349 mOut.copyTo(outArray); 2350 mResult = new Short4(((short) ((outArray[0]) & (short) 0xff)), ((short) ((outArray[1]) & (short) 0xff)), ((short) ((outArray[2]) & (short) 0xff)), ((short) ((outArray[3]) & (short) 0xff))); 2351 mOut.destroy(); 2352 mOut = null; // make Java object eligible for garbage collection 2353 if (mTempIns != null) { 2354 for (Allocation tempIn : mTempIns) { 2355 tempIn.destroy(); 2356 } 2357 2358 mTempIns = null; // make Java objects eligible for garbage collection 2359 } 2360 2361 mGotResult = true; 2362 } 2363 2364 return mResult; 2365 } 2366 2367 private result_uchar4(Allocation out) { 2368 mTempIns = null; 2369 mOut = out; 2370 mGotResult = false; 2371 } 2372 2373 private Allocation[] mTempIns; 2374 private Allocation mOut; 2375 private boolean mGotResult; 2376 private Short4 mResult; 2377 } 2378 2379 // To obtain the result, invoke get(), which blocks 2380 // until the asynchronously-launched operation has completed. 2381 public static class result_uint { 2382 public long get() { 2383 if (!mGotResult) { 2384 int[] outArray = new int[1]; 2385 mOut.copyTo(outArray); 2386 mResult = ((long) ((outArray[0]) & 0xffffffffL)); 2387 mOut.destroy(); 2388 mOut = null; // make Java object eligible for garbage collection 2389 if (mTempIns != null) { 2390 for (Allocation tempIn : mTempIns) { 2391 tempIn.destroy(); 2392 } 2393 2394 mTempIns = null; // make Java objects eligible for garbage collection 2395 } 2396 2397 mGotResult = true; 2398 } 2399 2400 return mResult; 2401 } 2402 2403 private result_uint(Allocation out) { 2404 mTempIns = null; 2405 mOut = out; 2406 mGotResult = false; 2407 } 2408 2409 private Allocation[] mTempIns; 2410 private Allocation mOut; 2411 private boolean mGotResult; 2412 private long mResult; 2413 } 2414 2415 // To obtain the result, invoke get(), which blocks 2416 // until the asynchronously-launched operation has completed. 2417 public static class result_uint2 { 2418 public Long2 get() { 2419 if (!mGotResult) { 2420 int[] outArray = new int[2]; 2421 mOut.copyTo(outArray); 2422 mResult = new Long2(((long) ((outArray[0]) & 0xffffffffL)), ((long) ((outArray[1]) & 0xffffffffL))); 2423 mOut.destroy(); 2424 mOut = null; // make Java object eligible for garbage collection 2425 if (mTempIns != null) { 2426 for (Allocation tempIn : mTempIns) { 2427 tempIn.destroy(); 2428 } 2429 2430 mTempIns = null; // make Java objects eligible for garbage collection 2431 } 2432 2433 mGotResult = true; 2434 } 2435 2436 return mResult; 2437 } 2438 2439 private result_uint2(Allocation out) { 2440 mTempIns = null; 2441 mOut = out; 2442 mGotResult = false; 2443 } 2444 2445 private Allocation[] mTempIns; 2446 private Allocation mOut; 2447 private boolean mGotResult; 2448 private Long2 mResult; 2449 } 2450 2451 // To obtain the result, invoke get(), which blocks 2452 // until the asynchronously-launched operation has completed. 2453 public static class result_uint4 { 2454 public Long4 get() { 2455 if (!mGotResult) { 2456 int[] outArray = new int[4]; 2457 mOut.copyTo(outArray); 2458 mResult = new Long4(((long) ((outArray[0]) & 0xffffffffL)), ((long) ((outArray[1]) & 0xffffffffL)), ((long) ((outArray[2]) & 0xffffffffL)), ((long) ((outArray[3]) & 0xffffffffL))); 2459 mOut.destroy(); 2460 mOut = null; // make Java object eligible for garbage collection 2461 if (mTempIns != null) { 2462 for (Allocation tempIn : mTempIns) { 2463 tempIn.destroy(); 2464 } 2465 2466 mTempIns = null; // make Java objects eligible for garbage collection 2467 } 2468 2469 mGotResult = true; 2470 } 2471 2472 return mResult; 2473 } 2474 2475 private result_uint4(Allocation out) { 2476 mTempIns = null; 2477 mOut = out; 2478 mGotResult = false; 2479 } 2480 2481 private Allocation[] mTempIns; 2482 private Allocation mOut; 2483 private boolean mGotResult; 2484 private Long4 mResult; 2485 } 2486 2487 // To obtain the result, invoke get(), which blocks 2488 // until the asynchronously-launched operation has completed. 2489 public static class result_ulong { 2490 public long get() { 2491 if (!mGotResult) { 2492 long[] outArray = new long[1]; 2493 mOut.copyTo(outArray); 2494 if (outArray[0] < 0) 2495 throw new RSRuntimeException("Result is not representible in Java"); 2496 mResult = outArray[0]; 2497 mOut.destroy(); 2498 mOut = null; // make Java object eligible for garbage collection 2499 if (mTempIns != null) { 2500 for (Allocation tempIn : mTempIns) { 2501 tempIn.destroy(); 2502 } 2503 2504 mTempIns = null; // make Java objects eligible for garbage collection 2505 } 2506 2507 mGotResult = true; 2508 } 2509 2510 return mResult; 2511 } 2512 2513 private result_ulong(Allocation out) { 2514 mTempIns = null; 2515 mOut = out; 2516 mGotResult = false; 2517 } 2518 2519 private Allocation[] mTempIns; 2520 private Allocation mOut; 2521 private boolean mGotResult; 2522 private long mResult; 2523 } 2524 2525 // To obtain the result, invoke get(), which blocks 2526 // until the asynchronously-launched operation has completed. 2527 public static class result_ulong2 { 2528 public Long2 get() { 2529 if (!mGotResult) { 2530 long[] outArray = new long[2]; 2531 mOut.copyTo(outArray); 2532 for (int Idx = 0; Idx < 2; ++Idx) { 2533 if (outArray[Idx] < 0) 2534 throw new RSRuntimeException("Result is not representible in Java"); 2535 } 2536 2537 mResult = new Long2(outArray[0], outArray[1]); 2538 mOut.destroy(); 2539 mOut = null; // make Java object eligible for garbage collection 2540 if (mTempIns != null) { 2541 for (Allocation tempIn : mTempIns) { 2542 tempIn.destroy(); 2543 } 2544 2545 mTempIns = null; // make Java objects eligible for garbage collection 2546 } 2547 2548 mGotResult = true; 2549 } 2550 2551 return mResult; 2552 } 2553 2554 private result_ulong2(Allocation out) { 2555 mTempIns = null; 2556 mOut = out; 2557 mGotResult = false; 2558 } 2559 2560 private Allocation[] mTempIns; 2561 private Allocation mOut; 2562 private boolean mGotResult; 2563 private Long2 mResult; 2564 } 2565 2566 // To obtain the result, invoke get(), which blocks 2567 // until the asynchronously-launched operation has completed. 2568 public static class result_ulong4 { 2569 public Long4 get() { 2570 if (!mGotResult) { 2571 long[] outArray = new long[4]; 2572 mOut.copyTo(outArray); 2573 for (int Idx = 0; Idx < 4; ++Idx) { 2574 if (outArray[Idx] < 0) 2575 throw new RSRuntimeException("Result is not representible in Java"); 2576 } 2577 2578 mResult = new Long4(outArray[0], outArray[1], outArray[2], outArray[3]); 2579 mOut.destroy(); 2580 mOut = null; // make Java object eligible for garbage collection 2581 if (mTempIns != null) { 2582 for (Allocation tempIn : mTempIns) { 2583 tempIn.destroy(); 2584 } 2585 2586 mTempIns = null; // make Java objects eligible for garbage collection 2587 } 2588 2589 mGotResult = true; 2590 } 2591 2592 return mResult; 2593 } 2594 2595 private result_ulong4(Allocation out) { 2596 mTempIns = null; 2597 mOut = out; 2598 mGotResult = false; 2599 } 2600 2601 private Allocation[] mTempIns; 2602 private Allocation mOut; 2603 private boolean mGotResult; 2604 private Long4 mResult; 2605 } 2606 2607 // To obtain the result, invoke get(), which blocks 2608 // until the asynchronously-launched operation has completed. 2609 public static class result_ushort { 2610 public int get() { 2611 if (!mGotResult) { 2612 short[] outArray = new short[1]; 2613 mOut.copyTo(outArray); 2614 mResult = ((int) ((outArray[0]) & 0xffff)); 2615 mOut.destroy(); 2616 mOut = null; // make Java object eligible for garbage collection 2617 if (mTempIns != null) { 2618 for (Allocation tempIn : mTempIns) { 2619 tempIn.destroy(); 2620 } 2621 2622 mTempIns = null; // make Java objects eligible for garbage collection 2623 } 2624 2625 mGotResult = true; 2626 } 2627 2628 return mResult; 2629 } 2630 2631 private result_ushort(Allocation out) { 2632 mTempIns = null; 2633 mOut = out; 2634 mGotResult = false; 2635 } 2636 2637 private Allocation[] mTempIns; 2638 private Allocation mOut; 2639 private boolean mGotResult; 2640 private int mResult; 2641 } 2642 2643 // To obtain the result, invoke get(), which blocks 2644 // until the asynchronously-launched operation has completed. 2645 public static class result_ushort2 { 2646 public Int2 get() { 2647 if (!mGotResult) { 2648 short[] outArray = new short[2]; 2649 mOut.copyTo(outArray); 2650 mResult = new Int2(((int) ((outArray[0]) & 0xffff)), ((int) ((outArray[1]) & 0xffff))); 2651 mOut.destroy(); 2652 mOut = null; // make Java object eligible for garbage collection 2653 if (mTempIns != null) { 2654 for (Allocation tempIn : mTempIns) { 2655 tempIn.destroy(); 2656 } 2657 2658 mTempIns = null; // make Java objects eligible for garbage collection 2659 } 2660 2661 mGotResult = true; 2662 } 2663 2664 return mResult; 2665 } 2666 2667 private result_ushort2(Allocation out) { 2668 mTempIns = null; 2669 mOut = out; 2670 mGotResult = false; 2671 } 2672 2673 private Allocation[] mTempIns; 2674 private Allocation mOut; 2675 private boolean mGotResult; 2676 private Int2 mResult; 2677 } 2678 2679 // To obtain the result, invoke get(), which blocks 2680 // until the asynchronously-launched operation has completed. 2681 public static class result_ushort4 { 2682 public Int4 get() { 2683 if (!mGotResult) { 2684 short[] outArray = new short[4]; 2685 mOut.copyTo(outArray); 2686 mResult = new Int4(((int) ((outArray[0]) & 0xffff)), ((int) ((outArray[1]) & 0xffff)), ((int) ((outArray[2]) & 0xffff)), ((int) ((outArray[3]) & 0xffff))); 2687 mOut.destroy(); 2688 mOut = null; // make Java object eligible for garbage collection 2689 if (mTempIns != null) { 2690 for (Allocation tempIn : mTempIns) { 2691 tempIn.destroy(); 2692 } 2693 2694 mTempIns = null; // make Java objects eligible for garbage collection 2695 } 2696 2697 mGotResult = true; 2698 } 2699 2700 return mResult; 2701 } 2702 2703 private result_ushort4(Allocation out) { 2704 mTempIns = null; 2705 mOut = out; 2706 mGotResult = false; 2707 } 2708 2709 private Allocation[] mTempIns; 2710 private Allocation mOut; 2711 private boolean mGotResult; 2712 private Int4 mResult; 2713 } 2714 2715 private final static int mExportReduceIdx_my_half = 0; 2716 // in1 = "val" 2717 public result_half reduce_my_half(short[] in1) { 2718 // Verify that "in1" is non-null. 2719 if (in1 == null) { 2720 throw new RSIllegalArgumentException("Array \"in1\" is null!"); 2721 } 2722 Allocation ain1 = Allocation.createSized(mRSLocal, __F16, in1.length); 2723 ain1.setAutoPadding(true); 2724 ain1.copyFrom(in1); 2725 2726 result_half result = reduce_my_half(ain1, null); 2727 result.mTempIns = new Allocation[]{ain1}; 2728 return result; 2729 } 2730 2731 // ain1 = "half val" 2732 public result_half reduce_my_half(Allocation ain1) { 2733 return reduce_my_half(ain1, null); 2734 } 2735 2736 // ain1 = "half val" 2737 public result_half reduce_my_half(Allocation ain1, Script.LaunchOptions sc) { 2738 // check ain1 2739 if (!ain1.getType().getElement().isCompatible(__F16)) { 2740 throw new RSRuntimeException("Type mismatch with F16!"); 2741 } 2742 Allocation aout = Allocation.createSized(mRSLocal, __F16, 1); 2743 aout.setAutoPadding(true); 2744 reduce(mExportReduceIdx_my_half, new Allocation[]{ain1}, aout, sc); 2745 return new result_half(aout); 2746 } 2747 2748 private final static int mExportReduceIdx_my_half2 = 1; 2749 // in1 = "val", flattened 2-vectors 2750 public result_half2 reduce_my_half2(short[] in1) { 2751 // Verify that "in1" is non-null. 2752 if (in1 == null) { 2753 throw new RSIllegalArgumentException("Array \"in1\" is null!"); 2754 } 2755 // Verify that the array length is a multiple of the vector size. 2756 if (in1.length % 2 != 0) { 2757 throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!"); 2758 } 2759 Allocation ain1 = Allocation.createSized(mRSLocal, __F16_2, in1.length / 2); 2760 ain1.setAutoPadding(true); 2761 ain1.copyFrom(in1); 2762 2763 result_half2 result = reduce_my_half2(ain1, null); 2764 result.mTempIns = new Allocation[]{ain1}; 2765 return result; 2766 } 2767 2768 // ain1 = "half2 val" 2769 public result_half2 reduce_my_half2(Allocation ain1) { 2770 return reduce_my_half2(ain1, null); 2771 } 2772 2773 // ain1 = "half2 val" 2774 public result_half2 reduce_my_half2(Allocation ain1, Script.LaunchOptions sc) { 2775 // check ain1 2776 if (!ain1.getType().getElement().isCompatible(__F16_2)) { 2777 throw new RSRuntimeException("Type mismatch with F16_2!"); 2778 } 2779 Allocation aout = Allocation.createSized(mRSLocal, __F16_2, 1); 2780 aout.setAutoPadding(true); 2781 reduce(mExportReduceIdx_my_half2, new Allocation[]{ain1}, aout, sc); 2782 return new result_half2(aout); 2783 } 2784 2785 private final static int mExportReduceIdx_my_half4 = 2; 2786 // in1 = "val", flattened 4-vectors 2787 public result_half4 reduce_my_half4(short[] in1) { 2788 // Verify that "in1" is non-null. 2789 if (in1 == null) { 2790 throw new RSIllegalArgumentException("Array \"in1\" is null!"); 2791 } 2792 // Verify that the array length is a multiple of the vector size. 2793 if (in1.length % 4 != 0) { 2794 throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!"); 2795 } 2796 Allocation ain1 = Allocation.createSized(mRSLocal, __F16_4, in1.length / 4); 2797 ain1.setAutoPadding(true); 2798 ain1.copyFrom(in1); 2799 2800 result_half4 result = reduce_my_half4(ain1, null); 2801 result.mTempIns = new Allocation[]{ain1}; 2802 return result; 2803 } 2804 2805 // ain1 = "half4 val" 2806 public result_half4 reduce_my_half4(Allocation ain1) { 2807 return reduce_my_half4(ain1, null); 2808 } 2809 2810 // ain1 = "half4 val" 2811 public result_half4 reduce_my_half4(Allocation ain1, Script.LaunchOptions sc) { 2812 // check ain1 2813 if (!ain1.getType().getElement().isCompatible(__F16_4)) { 2814 throw new RSRuntimeException("Type mismatch with F16_4!"); 2815 } 2816 Allocation aout = Allocation.createSized(mRSLocal, __F16_4, 1); 2817 aout.setAutoPadding(true); 2818 reduce(mExportReduceIdx_my_half4, new Allocation[]{ain1}, aout, sc); 2819 return new result_half4(aout); 2820 } 2821 2822 private final static int mExportReduceIdx_my_array_half = 3; 2823 // in1 = "val" 2824 public resultArray7_half reduce_my_array_half(short[] in1) { 2825 // Verify that "in1" is non-null. 2826 if (in1 == null) { 2827 throw new RSIllegalArgumentException("Array \"in1\" is null!"); 2828 } 2829 Allocation ain1 = Allocation.createSized(mRSLocal, __F16, in1.length); 2830 ain1.setAutoPadding(true); 2831 ain1.copyFrom(in1); 2832 2833 resultArray7_half result = reduce_my_array_half(ain1, null); 2834 result.mTempIns = new Allocation[]{ain1}; 2835 return result; 2836 } 2837 2838 // ain1 = "half val" 2839 public resultArray7_half reduce_my_array_half(Allocation ain1) { 2840 return reduce_my_array_half(ain1, null); 2841 } 2842 2843 // ain1 = "half val" 2844 public resultArray7_half reduce_my_array_half(Allocation ain1, Script.LaunchOptions sc) { 2845 // check ain1 2846 if (!ain1.getType().getElement().isCompatible(__F16)) { 2847 throw new RSRuntimeException("Type mismatch with F16!"); 2848 } 2849 Allocation aout = Allocation.createSized(mRSLocal, __F16, 7); 2850 aout.setAutoPadding(true); 2851 reduce(mExportReduceIdx_my_array_half, new Allocation[]{ain1}, aout, sc); 2852 return new resultArray7_half(aout); 2853 } 2854 2855 private final static int mExportReduceIdx_my_array_half2 = 4; 2856 // in1 = "val", flattened 2-vectors 2857 public resultArray7_half2 reduce_my_array_half2(short[] in1) { 2858 // Verify that "in1" is non-null. 2859 if (in1 == null) { 2860 throw new RSIllegalArgumentException("Array \"in1\" is null!"); 2861 } 2862 // Verify that the array length is a multiple of the vector size. 2863 if (in1.length % 2 != 0) { 2864 throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!"); 2865 } 2866 Allocation ain1 = Allocation.createSized(mRSLocal, __F16_2, in1.length / 2); 2867 ain1.setAutoPadding(true); 2868 ain1.copyFrom(in1); 2869 2870 resultArray7_half2 result = reduce_my_array_half2(ain1, null); 2871 result.mTempIns = new Allocation[]{ain1}; 2872 return result; 2873 } 2874 2875 // ain1 = "half2 val" 2876 public resultArray7_half2 reduce_my_array_half2(Allocation ain1) { 2877 return reduce_my_array_half2(ain1, null); 2878 } 2879 2880 // ain1 = "half2 val" 2881 public resultArray7_half2 reduce_my_array_half2(Allocation ain1, Script.LaunchOptions sc) { 2882 // check ain1 2883 if (!ain1.getType().getElement().isCompatible(__F16_2)) { 2884 throw new RSRuntimeException("Type mismatch with F16_2!"); 2885 } 2886 Allocation aout = Allocation.createSized(mRSLocal, __F16_2, 7); 2887 aout.setAutoPadding(true); 2888 reduce(mExportReduceIdx_my_array_half2, new Allocation[]{ain1}, aout, sc); 2889 return new resultArray7_half2(aout); 2890 } 2891 2892 private final static int mExportReduceIdx_my_array_half4 = 5; 2893 // in1 = "val", flattened 4-vectors 2894 public resultArray7_half4 reduce_my_array_half4(short[] in1) { 2895 // Verify that "in1" is non-null. 2896 if (in1 == null) { 2897 throw new RSIllegalArgumentException("Array \"in1\" is null!"); 2898 } 2899 // Verify that the array length is a multiple of the vector size. 2900 if (in1.length % 4 != 0) { 2901 throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!"); 2902 } 2903 Allocation ain1 = Allocation.createSized(mRSLocal, __F16_4, in1.length / 4); 2904 ain1.setAutoPadding(true); 2905 ain1.copyFrom(in1); 2906 2907 resultArray7_half4 result = reduce_my_array_half4(ain1, null); 2908 result.mTempIns = new Allocation[]{ain1}; 2909 return result; 2910 } 2911 2912 // ain1 = "half4 val" 2913 public resultArray7_half4 reduce_my_array_half4(Allocation ain1) { 2914 return reduce_my_array_half4(ain1, null); 2915 } 2916 2917 // ain1 = "half4 val" 2918 public resultArray7_half4 reduce_my_array_half4(Allocation ain1, Script.LaunchOptions sc) { 2919 // check ain1 2920 if (!ain1.getType().getElement().isCompatible(__F16_4)) { 2921 throw new RSRuntimeException("Type mismatch with F16_4!"); 2922 } 2923 Allocation aout = Allocation.createSized(mRSLocal, __F16_4, 7); 2924 aout.setAutoPadding(true); 2925 reduce(mExportReduceIdx_my_array_half4, new Allocation[]{ain1}, aout, sc); 2926 return new resultArray7_half4(aout); 2927 } 2928 2929 private final static int mExportReduceIdx_my_float = 6; 2930 // in1 = "val" 2931 public result_float reduce_my_float(float[] in1) { 2932 // Verify that "in1" is non-null. 2933 if (in1 == null) { 2934 throw new RSIllegalArgumentException("Array \"in1\" is null!"); 2935 } 2936 Allocation ain1 = Allocation.createSized(mRSLocal, __F32, in1.length); 2937 ain1.setAutoPadding(true); 2938 ain1.copyFrom(in1); 2939 2940 result_float result = reduce_my_float(ain1, null); 2941 result.mTempIns = new Allocation[]{ain1}; 2942 return result; 2943 } 2944 2945 // ain1 = "float val" 2946 public result_float reduce_my_float(Allocation ain1) { 2947 return reduce_my_float(ain1, null); 2948 } 2949 2950 // ain1 = "float val" 2951 public result_float reduce_my_float(Allocation ain1, Script.LaunchOptions sc) { 2952 // check ain1 2953 if (!ain1.getType().getElement().isCompatible(__F32)) { 2954 throw new RSRuntimeException("Type mismatch with F32!"); 2955 } 2956 Allocation aout = Allocation.createSized(mRSLocal, __F32, 1); 2957 aout.setAutoPadding(true); 2958 reduce(mExportReduceIdx_my_float, new Allocation[]{ain1}, aout, sc); 2959 return new result_float(aout); 2960 } 2961 2962 private final static int mExportReduceIdx_my_float2 = 7; 2963 // in1 = "val", flattened 2-vectors 2964 public result_float2 reduce_my_float2(float[] in1) { 2965 // Verify that "in1" is non-null. 2966 if (in1 == null) { 2967 throw new RSIllegalArgumentException("Array \"in1\" is null!"); 2968 } 2969 // Verify that the array length is a multiple of the vector size. 2970 if (in1.length % 2 != 0) { 2971 throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!"); 2972 } 2973 Allocation ain1 = Allocation.createSized(mRSLocal, __F32_2, in1.length / 2); 2974 ain1.setAutoPadding(true); 2975 ain1.copyFrom(in1); 2976 2977 result_float2 result = reduce_my_float2(ain1, null); 2978 result.mTempIns = new Allocation[]{ain1}; 2979 return result; 2980 } 2981 2982 // ain1 = "float2 val" 2983 public result_float2 reduce_my_float2(Allocation ain1) { 2984 return reduce_my_float2(ain1, null); 2985 } 2986 2987 // ain1 = "float2 val" 2988 public result_float2 reduce_my_float2(Allocation ain1, Script.LaunchOptions sc) { 2989 // check ain1 2990 if (!ain1.getType().getElement().isCompatible(__F32_2)) { 2991 throw new RSRuntimeException("Type mismatch with F32_2!"); 2992 } 2993 Allocation aout = Allocation.createSized(mRSLocal, __F32_2, 1); 2994 aout.setAutoPadding(true); 2995 reduce(mExportReduceIdx_my_float2, new Allocation[]{ain1}, aout, sc); 2996 return new result_float2(aout); 2997 } 2998 2999 private final static int mExportReduceIdx_my_float4 = 8; 3000 // in1 = "val", flattened 4-vectors 3001 public result_float4 reduce_my_float4(float[] in1) { 3002 // Verify that "in1" is non-null. 3003 if (in1 == null) { 3004 throw new RSIllegalArgumentException("Array \"in1\" is null!"); 3005 } 3006 // Verify that the array length is a multiple of the vector size. 3007 if (in1.length % 4 != 0) { 3008 throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!"); 3009 } 3010 Allocation ain1 = Allocation.createSized(mRSLocal, __F32_4, in1.length / 4); 3011 ain1.setAutoPadding(true); 3012 ain1.copyFrom(in1); 3013 3014 result_float4 result = reduce_my_float4(ain1, null); 3015 result.mTempIns = new Allocation[]{ain1}; 3016 return result; 3017 } 3018 3019 // ain1 = "float4 val" 3020 public result_float4 reduce_my_float4(Allocation ain1) { 3021 return reduce_my_float4(ain1, null); 3022 } 3023 3024 // ain1 = "float4 val" 3025 public result_float4 reduce_my_float4(Allocation ain1, Script.LaunchOptions sc) { 3026 // check ain1 3027 if (!ain1.getType().getElement().isCompatible(__F32_4)) { 3028 throw new RSRuntimeException("Type mismatch with F32_4!"); 3029 } 3030 Allocation aout = Allocation.createSized(mRSLocal, __F32_4, 1); 3031 aout.setAutoPadding(true); 3032 reduce(mExportReduceIdx_my_float4, new Allocation[]{ain1}, aout, sc); 3033 return new result_float4(aout); 3034 } 3035 3036 private final static int mExportReduceIdx_my_array_float = 9; 3037 // in1 = "val" 3038 public resultArray7_float reduce_my_array_float(float[] in1) { 3039 // Verify that "in1" is non-null. 3040 if (in1 == null) { 3041 throw new RSIllegalArgumentException("Array \"in1\" is null!"); 3042 } 3043 Allocation ain1 = Allocation.createSized(mRSLocal, __F32, in1.length); 3044 ain1.setAutoPadding(true); 3045 ain1.copyFrom(in1); 3046 3047 resultArray7_float result = reduce_my_array_float(ain1, null); 3048 result.mTempIns = new Allocation[]{ain1}; 3049 return result; 3050 } 3051 3052 // ain1 = "float val" 3053 public resultArray7_float reduce_my_array_float(Allocation ain1) { 3054 return reduce_my_array_float(ain1, null); 3055 } 3056 3057 // ain1 = "float val" 3058 public resultArray7_float reduce_my_array_float(Allocation ain1, Script.LaunchOptions sc) { 3059 // check ain1 3060 if (!ain1.getType().getElement().isCompatible(__F32)) { 3061 throw new RSRuntimeException("Type mismatch with F32!"); 3062 } 3063 Allocation aout = Allocation.createSized(mRSLocal, __F32, 7); 3064 aout.setAutoPadding(true); 3065 reduce(mExportReduceIdx_my_array_float, new Allocation[]{ain1}, aout, sc); 3066 return new resultArray7_float(aout); 3067 } 3068 3069 private final static int mExportReduceIdx_my_array_float2 = 10; 3070 // in1 = "val", flattened 2-vectors 3071 public resultArray7_float2 reduce_my_array_float2(float[] in1) { 3072 // Verify that "in1" is non-null. 3073 if (in1 == null) { 3074 throw new RSIllegalArgumentException("Array \"in1\" is null!"); 3075 } 3076 // Verify that the array length is a multiple of the vector size. 3077 if (in1.length % 2 != 0) { 3078 throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!"); 3079 } 3080 Allocation ain1 = Allocation.createSized(mRSLocal, __F32_2, in1.length / 2); 3081 ain1.setAutoPadding(true); 3082 ain1.copyFrom(in1); 3083 3084 resultArray7_float2 result = reduce_my_array_float2(ain1, null); 3085 result.mTempIns = new Allocation[]{ain1}; 3086 return result; 3087 } 3088 3089 // ain1 = "float2 val" 3090 public resultArray7_float2 reduce_my_array_float2(Allocation ain1) { 3091 return reduce_my_array_float2(ain1, null); 3092 } 3093 3094 // ain1 = "float2 val" 3095 public resultArray7_float2 reduce_my_array_float2(Allocation ain1, Script.LaunchOptions sc) { 3096 // check ain1 3097 if (!ain1.getType().getElement().isCompatible(__F32_2)) { 3098 throw new RSRuntimeException("Type mismatch with F32_2!"); 3099 } 3100 Allocation aout = Allocation.createSized(mRSLocal, __F32_2, 7); 3101 aout.setAutoPadding(true); 3102 reduce(mExportReduceIdx_my_array_float2, new Allocation[]{ain1}, aout, sc); 3103 return new resultArray7_float2(aout); 3104 } 3105 3106 private final static int mExportReduceIdx_my_array_float4 = 11; 3107 // in1 = "val", flattened 4-vectors 3108 public resultArray7_float4 reduce_my_array_float4(float[] in1) { 3109 // Verify that "in1" is non-null. 3110 if (in1 == null) { 3111 throw new RSIllegalArgumentException("Array \"in1\" is null!"); 3112 } 3113 // Verify that the array length is a multiple of the vector size. 3114 if (in1.length % 4 != 0) { 3115 throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!"); 3116 } 3117 Allocation ain1 = Allocation.createSized(mRSLocal, __F32_4, in1.length / 4); 3118 ain1.setAutoPadding(true); 3119 ain1.copyFrom(in1); 3120 3121 resultArray7_float4 result = reduce_my_array_float4(ain1, null); 3122 result.mTempIns = new Allocation[]{ain1}; 3123 return result; 3124 } 3125 3126 // ain1 = "float4 val" 3127 public resultArray7_float4 reduce_my_array_float4(Allocation ain1) { 3128 return reduce_my_array_float4(ain1, null); 3129 } 3130 3131 // ain1 = "float4 val" 3132 public resultArray7_float4 reduce_my_array_float4(Allocation ain1, Script.LaunchOptions sc) { 3133 // check ain1 3134 if (!ain1.getType().getElement().isCompatible(__F32_4)) { 3135 throw new RSRuntimeException("Type mismatch with F32_4!"); 3136 } 3137 Allocation aout = Allocation.createSized(mRSLocal, __F32_4, 7); 3138 aout.setAutoPadding(true); 3139 reduce(mExportReduceIdx_my_array_float4, new Allocation[]{ain1}, aout, sc); 3140 return new resultArray7_float4(aout); 3141 } 3142 3143 private final static int mExportReduceIdx_my_double = 12; 3144 // in1 = "val" 3145 public result_double reduce_my_double(double[] in1) { 3146 // Verify that "in1" is non-null. 3147 if (in1 == null) { 3148 throw new RSIllegalArgumentException("Array \"in1\" is null!"); 3149 } 3150 Allocation ain1 = Allocation.createSized(mRSLocal, __F64, in1.length); 3151 ain1.setAutoPadding(true); 3152 ain1.copyFrom(in1); 3153 3154 result_double result = reduce_my_double(ain1, null); 3155 result.mTempIns = new Allocation[]{ain1}; 3156 return result; 3157 } 3158 3159 // ain1 = "double val" 3160 public result_double reduce_my_double(Allocation ain1) { 3161 return reduce_my_double(ain1, null); 3162 } 3163 3164 // ain1 = "double val" 3165 public result_double reduce_my_double(Allocation ain1, Script.LaunchOptions sc) { 3166 // check ain1 3167 if (!ain1.getType().getElement().isCompatible(__F64)) { 3168 throw new RSRuntimeException("Type mismatch with F64!"); 3169 } 3170 Allocation aout = Allocation.createSized(mRSLocal, __F64, 1); 3171 aout.setAutoPadding(true); 3172 reduce(mExportReduceIdx_my_double, new Allocation[]{ain1}, aout, sc); 3173 return new result_double(aout); 3174 } 3175 3176 private final static int mExportReduceIdx_my_double2 = 13; 3177 // in1 = "val", flattened 2-vectors 3178 public result_double2 reduce_my_double2(double[] in1) { 3179 // Verify that "in1" is non-null. 3180 if (in1 == null) { 3181 throw new RSIllegalArgumentException("Array \"in1\" is null!"); 3182 } 3183 // Verify that the array length is a multiple of the vector size. 3184 if (in1.length % 2 != 0) { 3185 throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!"); 3186 } 3187 Allocation ain1 = Allocation.createSized(mRSLocal, __F64_2, in1.length / 2); 3188 ain1.setAutoPadding(true); 3189 ain1.copyFrom(in1); 3190 3191 result_double2 result = reduce_my_double2(ain1, null); 3192 result.mTempIns = new Allocation[]{ain1}; 3193 return result; 3194 } 3195 3196 // ain1 = "double2 val" 3197 public result_double2 reduce_my_double2(Allocation ain1) { 3198 return reduce_my_double2(ain1, null); 3199 } 3200 3201 // ain1 = "double2 val" 3202 public result_double2 reduce_my_double2(Allocation ain1, Script.LaunchOptions sc) { 3203 // check ain1 3204 if (!ain1.getType().getElement().isCompatible(__F64_2)) { 3205 throw new RSRuntimeException("Type mismatch with F64_2!"); 3206 } 3207 Allocation aout = Allocation.createSized(mRSLocal, __F64_2, 1); 3208 aout.setAutoPadding(true); 3209 reduce(mExportReduceIdx_my_double2, new Allocation[]{ain1}, aout, sc); 3210 return new result_double2(aout); 3211 } 3212 3213 private final static int mExportReduceIdx_my_double4 = 14; 3214 // in1 = "val", flattened 4-vectors 3215 public result_double4 reduce_my_double4(double[] in1) { 3216 // Verify that "in1" is non-null. 3217 if (in1 == null) { 3218 throw new RSIllegalArgumentException("Array \"in1\" is null!"); 3219 } 3220 // Verify that the array length is a multiple of the vector size. 3221 if (in1.length % 4 != 0) { 3222 throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!"); 3223 } 3224 Allocation ain1 = Allocation.createSized(mRSLocal, __F64_4, in1.length / 4); 3225 ain1.setAutoPadding(true); 3226 ain1.copyFrom(in1); 3227 3228 result_double4 result = reduce_my_double4(ain1, null); 3229 result.mTempIns = new Allocation[]{ain1}; 3230 return result; 3231 } 3232 3233 // ain1 = "double4 val" 3234 public result_double4 reduce_my_double4(Allocation ain1) { 3235 return reduce_my_double4(ain1, null); 3236 } 3237 3238 // ain1 = "double4 val" 3239 public result_double4 reduce_my_double4(Allocation ain1, Script.LaunchOptions sc) { 3240 // check ain1 3241 if (!ain1.getType().getElement().isCompatible(__F64_4)) { 3242 throw new RSRuntimeException("Type mismatch with F64_4!"); 3243 } 3244 Allocation aout = Allocation.createSized(mRSLocal, __F64_4, 1); 3245 aout.setAutoPadding(true); 3246 reduce(mExportReduceIdx_my_double4, new Allocation[]{ain1}, aout, sc); 3247 return new result_double4(aout); 3248 } 3249 3250 private final static int mExportReduceIdx_my_array_double = 15; 3251 // in1 = "val" 3252 public resultArray7_double reduce_my_array_double(double[] in1) { 3253 // Verify that "in1" is non-null. 3254 if (in1 == null) { 3255 throw new RSIllegalArgumentException("Array \"in1\" is null!"); 3256 } 3257 Allocation ain1 = Allocation.createSized(mRSLocal, __F64, in1.length); 3258 ain1.setAutoPadding(true); 3259 ain1.copyFrom(in1); 3260 3261 resultArray7_double result = reduce_my_array_double(ain1, null); 3262 result.mTempIns = new Allocation[]{ain1}; 3263 return result; 3264 } 3265 3266 // ain1 = "double val" 3267 public resultArray7_double reduce_my_array_double(Allocation ain1) { 3268 return reduce_my_array_double(ain1, null); 3269 } 3270 3271 // ain1 = "double val" 3272 public resultArray7_double reduce_my_array_double(Allocation ain1, Script.LaunchOptions sc) { 3273 // check ain1 3274 if (!ain1.getType().getElement().isCompatible(__F64)) { 3275 throw new RSRuntimeException("Type mismatch with F64!"); 3276 } 3277 Allocation aout = Allocation.createSized(mRSLocal, __F64, 7); 3278 aout.setAutoPadding(true); 3279 reduce(mExportReduceIdx_my_array_double, new Allocation[]{ain1}, aout, sc); 3280 return new resultArray7_double(aout); 3281 } 3282 3283 private final static int mExportReduceIdx_my_array_double2 = 16; 3284 // in1 = "val", flattened 2-vectors 3285 public resultArray7_double2 reduce_my_array_double2(double[] in1) { 3286 // Verify that "in1" is non-null. 3287 if (in1 == null) { 3288 throw new RSIllegalArgumentException("Array \"in1\" is null!"); 3289 } 3290 // Verify that the array length is a multiple of the vector size. 3291 if (in1.length % 2 != 0) { 3292 throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!"); 3293 } 3294 Allocation ain1 = Allocation.createSized(mRSLocal, __F64_2, in1.length / 2); 3295 ain1.setAutoPadding(true); 3296 ain1.copyFrom(in1); 3297 3298 resultArray7_double2 result = reduce_my_array_double2(ain1, null); 3299 result.mTempIns = new Allocation[]{ain1}; 3300 return result; 3301 } 3302 3303 // ain1 = "double2 val" 3304 public resultArray7_double2 reduce_my_array_double2(Allocation ain1) { 3305 return reduce_my_array_double2(ain1, null); 3306 } 3307 3308 // ain1 = "double2 val" 3309 public resultArray7_double2 reduce_my_array_double2(Allocation ain1, Script.LaunchOptions sc) { 3310 // check ain1 3311 if (!ain1.getType().getElement().isCompatible(__F64_2)) { 3312 throw new RSRuntimeException("Type mismatch with F64_2!"); 3313 } 3314 Allocation aout = Allocation.createSized(mRSLocal, __F64_2, 7); 3315 aout.setAutoPadding(true); 3316 reduce(mExportReduceIdx_my_array_double2, new Allocation[]{ain1}, aout, sc); 3317 return new resultArray7_double2(aout); 3318 } 3319 3320 private final static int mExportReduceIdx_my_array_double4 = 17; 3321 // in1 = "val", flattened 4-vectors 3322 public resultArray7_double4 reduce_my_array_double4(double[] in1) { 3323 // Verify that "in1" is non-null. 3324 if (in1 == null) { 3325 throw new RSIllegalArgumentException("Array \"in1\" is null!"); 3326 } 3327 // Verify that the array length is a multiple of the vector size. 3328 if (in1.length % 4 != 0) { 3329 throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!"); 3330 } 3331 Allocation ain1 = Allocation.createSized(mRSLocal, __F64_4, in1.length / 4); 3332 ain1.setAutoPadding(true); 3333 ain1.copyFrom(in1); 3334 3335 resultArray7_double4 result = reduce_my_array_double4(ain1, null); 3336 result.mTempIns = new Allocation[]{ain1}; 3337 return result; 3338 } 3339 3340 // ain1 = "double4 val" 3341 public resultArray7_double4 reduce_my_array_double4(Allocation ain1) { 3342 return reduce_my_array_double4(ain1, null); 3343 } 3344 3345 // ain1 = "double4 val" 3346 public resultArray7_double4 reduce_my_array_double4(Allocation ain1, Script.LaunchOptions sc) { 3347 // check ain1 3348 if (!ain1.getType().getElement().isCompatible(__F64_4)) { 3349 throw new RSRuntimeException("Type mismatch with F64_4!"); 3350 } 3351 Allocation aout = Allocation.createSized(mRSLocal, __F64_4, 7); 3352 aout.setAutoPadding(true); 3353 reduce(mExportReduceIdx_my_array_double4, new Allocation[]{ain1}, aout, sc); 3354 return new resultArray7_double4(aout); 3355 } 3356 3357 private final static int mExportReduceIdx_my_char = 18; 3358 // in1 = "val" 3359 public result_char reduce_my_char(byte[] in1) { 3360 // Verify that "in1" is non-null. 3361 if (in1 == null) { 3362 throw new RSIllegalArgumentException("Array \"in1\" is null!"); 3363 } 3364 Allocation ain1 = Allocation.createSized(mRSLocal, __I8, in1.length); 3365 ain1.setAutoPadding(true); 3366 ain1.copyFrom(in1); 3367 3368 result_char result = reduce_my_char(ain1, null); 3369 result.mTempIns = new Allocation[]{ain1}; 3370 return result; 3371 } 3372 3373 // ain1 = "char val" 3374 public result_char reduce_my_char(Allocation ain1) { 3375 return reduce_my_char(ain1, null); 3376 } 3377 3378 // ain1 = "char val" 3379 public result_char reduce_my_char(Allocation ain1, Script.LaunchOptions sc) { 3380 // check ain1 3381 if (!ain1.getType().getElement().isCompatible(__I8)) { 3382 throw new RSRuntimeException("Type mismatch with I8!"); 3383 } 3384 Allocation aout = Allocation.createSized(mRSLocal, __I8, 1); 3385 aout.setAutoPadding(true); 3386 reduce(mExportReduceIdx_my_char, new Allocation[]{ain1}, aout, sc); 3387 return new result_char(aout); 3388 } 3389 3390 private final static int mExportReduceIdx_my_char2 = 19; 3391 // in1 = "val", flattened 2-vectors 3392 public result_char2 reduce_my_char2(byte[] in1) { 3393 // Verify that "in1" is non-null. 3394 if (in1 == null) { 3395 throw new RSIllegalArgumentException("Array \"in1\" is null!"); 3396 } 3397 // Verify that the array length is a multiple of the vector size. 3398 if (in1.length % 2 != 0) { 3399 throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!"); 3400 } 3401 Allocation ain1 = Allocation.createSized(mRSLocal, __I8_2, in1.length / 2); 3402 ain1.setAutoPadding(true); 3403 ain1.copyFrom(in1); 3404 3405 result_char2 result = reduce_my_char2(ain1, null); 3406 result.mTempIns = new Allocation[]{ain1}; 3407 return result; 3408 } 3409 3410 // ain1 = "char2 val" 3411 public result_char2 reduce_my_char2(Allocation ain1) { 3412 return reduce_my_char2(ain1, null); 3413 } 3414 3415 // ain1 = "char2 val" 3416 public result_char2 reduce_my_char2(Allocation ain1, Script.LaunchOptions sc) { 3417 // check ain1 3418 if (!ain1.getType().getElement().isCompatible(__I8_2)) { 3419 throw new RSRuntimeException("Type mismatch with I8_2!"); 3420 } 3421 Allocation aout = Allocation.createSized(mRSLocal, __I8_2, 1); 3422 aout.setAutoPadding(true); 3423 reduce(mExportReduceIdx_my_char2, new Allocation[]{ain1}, aout, sc); 3424 return new result_char2(aout); 3425 } 3426 3427 private final static int mExportReduceIdx_my_char4 = 20; 3428 // in1 = "val", flattened 4-vectors 3429 public result_char4 reduce_my_char4(byte[] in1) { 3430 // Verify that "in1" is non-null. 3431 if (in1 == null) { 3432 throw new RSIllegalArgumentException("Array \"in1\" is null!"); 3433 } 3434 // Verify that the array length is a multiple of the vector size. 3435 if (in1.length % 4 != 0) { 3436 throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!"); 3437 } 3438 Allocation ain1 = Allocation.createSized(mRSLocal, __I8_4, in1.length / 4); 3439 ain1.setAutoPadding(true); 3440 ain1.copyFrom(in1); 3441 3442 result_char4 result = reduce_my_char4(ain1, null); 3443 result.mTempIns = new Allocation[]{ain1}; 3444 return result; 3445 } 3446 3447 // ain1 = "char4 val" 3448 public result_char4 reduce_my_char4(Allocation ain1) { 3449 return reduce_my_char4(ain1, null); 3450 } 3451 3452 // ain1 = "char4 val" 3453 public result_char4 reduce_my_char4(Allocation ain1, Script.LaunchOptions sc) { 3454 // check ain1 3455 if (!ain1.getType().getElement().isCompatible(__I8_4)) { 3456 throw new RSRuntimeException("Type mismatch with I8_4!"); 3457 } 3458 Allocation aout = Allocation.createSized(mRSLocal, __I8_4, 1); 3459 aout.setAutoPadding(true); 3460 reduce(mExportReduceIdx_my_char4, new Allocation[]{ain1}, aout, sc); 3461 return new result_char4(aout); 3462 } 3463 3464 private final static int mExportReduceIdx_my_array_char = 21; 3465 // in1 = "val" 3466 public resultArray7_char reduce_my_array_char(byte[] in1) { 3467 // Verify that "in1" is non-null. 3468 if (in1 == null) { 3469 throw new RSIllegalArgumentException("Array \"in1\" is null!"); 3470 } 3471 Allocation ain1 = Allocation.createSized(mRSLocal, __I8, in1.length); 3472 ain1.setAutoPadding(true); 3473 ain1.copyFrom(in1); 3474 3475 resultArray7_char result = reduce_my_array_char(ain1, null); 3476 result.mTempIns = new Allocation[]{ain1}; 3477 return result; 3478 } 3479 3480 // ain1 = "char val" 3481 public resultArray7_char reduce_my_array_char(Allocation ain1) { 3482 return reduce_my_array_char(ain1, null); 3483 } 3484 3485 // ain1 = "char val" 3486 public resultArray7_char reduce_my_array_char(Allocation ain1, Script.LaunchOptions sc) { 3487 // check ain1 3488 if (!ain1.getType().getElement().isCompatible(__I8)) { 3489 throw new RSRuntimeException("Type mismatch with I8!"); 3490 } 3491 Allocation aout = Allocation.createSized(mRSLocal, __I8, 7); 3492 aout.setAutoPadding(true); 3493 reduce(mExportReduceIdx_my_array_char, new Allocation[]{ain1}, aout, sc); 3494 return new resultArray7_char(aout); 3495 } 3496 3497 private final static int mExportReduceIdx_my_array_char2 = 22; 3498 // in1 = "val", flattened 2-vectors 3499 public resultArray7_char2 reduce_my_array_char2(byte[] in1) { 3500 // Verify that "in1" is non-null. 3501 if (in1 == null) { 3502 throw new RSIllegalArgumentException("Array \"in1\" is null!"); 3503 } 3504 // Verify that the array length is a multiple of the vector size. 3505 if (in1.length % 2 != 0) { 3506 throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!"); 3507 } 3508 Allocation ain1 = Allocation.createSized(mRSLocal, __I8_2, in1.length / 2); 3509 ain1.setAutoPadding(true); 3510 ain1.copyFrom(in1); 3511 3512 resultArray7_char2 result = reduce_my_array_char2(ain1, null); 3513 result.mTempIns = new Allocation[]{ain1}; 3514 return result; 3515 } 3516 3517 // ain1 = "char2 val" 3518 public resultArray7_char2 reduce_my_array_char2(Allocation ain1) { 3519 return reduce_my_array_char2(ain1, null); 3520 } 3521 3522 // ain1 = "char2 val" 3523 public resultArray7_char2 reduce_my_array_char2(Allocation ain1, Script.LaunchOptions sc) { 3524 // check ain1 3525 if (!ain1.getType().getElement().isCompatible(__I8_2)) { 3526 throw new RSRuntimeException("Type mismatch with I8_2!"); 3527 } 3528 Allocation aout = Allocation.createSized(mRSLocal, __I8_2, 7); 3529 aout.setAutoPadding(true); 3530 reduce(mExportReduceIdx_my_array_char2, new Allocation[]{ain1}, aout, sc); 3531 return new resultArray7_char2(aout); 3532 } 3533 3534 private final static int mExportReduceIdx_my_array_char4 = 23; 3535 // in1 = "val", flattened 4-vectors 3536 public resultArray7_char4 reduce_my_array_char4(byte[] in1) { 3537 // Verify that "in1" is non-null. 3538 if (in1 == null) { 3539 throw new RSIllegalArgumentException("Array \"in1\" is null!"); 3540 } 3541 // Verify that the array length is a multiple of the vector size. 3542 if (in1.length % 4 != 0) { 3543 throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!"); 3544 } 3545 Allocation ain1 = Allocation.createSized(mRSLocal, __I8_4, in1.length / 4); 3546 ain1.setAutoPadding(true); 3547 ain1.copyFrom(in1); 3548 3549 resultArray7_char4 result = reduce_my_array_char4(ain1, null); 3550 result.mTempIns = new Allocation[]{ain1}; 3551 return result; 3552 } 3553 3554 // ain1 = "char4 val" 3555 public resultArray7_char4 reduce_my_array_char4(Allocation ain1) { 3556 return reduce_my_array_char4(ain1, null); 3557 } 3558 3559 // ain1 = "char4 val" 3560 public resultArray7_char4 reduce_my_array_char4(Allocation ain1, Script.LaunchOptions sc) { 3561 // check ain1 3562 if (!ain1.getType().getElement().isCompatible(__I8_4)) { 3563 throw new RSRuntimeException("Type mismatch with I8_4!"); 3564 } 3565 Allocation aout = Allocation.createSized(mRSLocal, __I8_4, 7); 3566 aout.setAutoPadding(true); 3567 reduce(mExportReduceIdx_my_array_char4, new Allocation[]{ain1}, aout, sc); 3568 return new resultArray7_char4(aout); 3569 } 3570 3571 private final static int mExportReduceIdx_my_short = 24; 3572 // in1 = "val" 3573 public result_short reduce_my_short(short[] in1) { 3574 // Verify that "in1" is non-null. 3575 if (in1 == null) { 3576 throw new RSIllegalArgumentException("Array \"in1\" is null!"); 3577 } 3578 Allocation ain1 = Allocation.createSized(mRSLocal, __I16, in1.length); 3579 ain1.setAutoPadding(true); 3580 ain1.copyFrom(in1); 3581 3582 result_short result = reduce_my_short(ain1, null); 3583 result.mTempIns = new Allocation[]{ain1}; 3584 return result; 3585 } 3586 3587 // ain1 = "short val" 3588 public result_short reduce_my_short(Allocation ain1) { 3589 return reduce_my_short(ain1, null); 3590 } 3591 3592 // ain1 = "short val" 3593 public result_short reduce_my_short(Allocation ain1, Script.LaunchOptions sc) { 3594 // check ain1 3595 if (!ain1.getType().getElement().isCompatible(__I16)) { 3596 throw new RSRuntimeException("Type mismatch with I16!"); 3597 } 3598 Allocation aout = Allocation.createSized(mRSLocal, __I16, 1); 3599 aout.setAutoPadding(true); 3600 reduce(mExportReduceIdx_my_short, new Allocation[]{ain1}, aout, sc); 3601 return new result_short(aout); 3602 } 3603 3604 private final static int mExportReduceIdx_my_short2 = 25; 3605 // in1 = "val", flattened 2-vectors 3606 public result_short2 reduce_my_short2(short[] in1) { 3607 // Verify that "in1" is non-null. 3608 if (in1 == null) { 3609 throw new RSIllegalArgumentException("Array \"in1\" is null!"); 3610 } 3611 // Verify that the array length is a multiple of the vector size. 3612 if (in1.length % 2 != 0) { 3613 throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!"); 3614 } 3615 Allocation ain1 = Allocation.createSized(mRSLocal, __I16_2, in1.length / 2); 3616 ain1.setAutoPadding(true); 3617 ain1.copyFrom(in1); 3618 3619 result_short2 result = reduce_my_short2(ain1, null); 3620 result.mTempIns = new Allocation[]{ain1}; 3621 return result; 3622 } 3623 3624 // ain1 = "short2 val" 3625 public result_short2 reduce_my_short2(Allocation ain1) { 3626 return reduce_my_short2(ain1, null); 3627 } 3628 3629 // ain1 = "short2 val" 3630 public result_short2 reduce_my_short2(Allocation ain1, Script.LaunchOptions sc) { 3631 // check ain1 3632 if (!ain1.getType().getElement().isCompatible(__I16_2)) { 3633 throw new RSRuntimeException("Type mismatch with I16_2!"); 3634 } 3635 Allocation aout = Allocation.createSized(mRSLocal, __I16_2, 1); 3636 aout.setAutoPadding(true); 3637 reduce(mExportReduceIdx_my_short2, new Allocation[]{ain1}, aout, sc); 3638 return new result_short2(aout); 3639 } 3640 3641 private final static int mExportReduceIdx_my_short4 = 26; 3642 // in1 = "val", flattened 4-vectors 3643 public result_short4 reduce_my_short4(short[] in1) { 3644 // Verify that "in1" is non-null. 3645 if (in1 == null) { 3646 throw new RSIllegalArgumentException("Array \"in1\" is null!"); 3647 } 3648 // Verify that the array length is a multiple of the vector size. 3649 if (in1.length % 4 != 0) { 3650 throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!"); 3651 } 3652 Allocation ain1 = Allocation.createSized(mRSLocal, __I16_4, in1.length / 4); 3653 ain1.setAutoPadding(true); 3654 ain1.copyFrom(in1); 3655 3656 result_short4 result = reduce_my_short4(ain1, null); 3657 result.mTempIns = new Allocation[]{ain1}; 3658 return result; 3659 } 3660 3661 // ain1 = "short4 val" 3662 public result_short4 reduce_my_short4(Allocation ain1) { 3663 return reduce_my_short4(ain1, null); 3664 } 3665 3666 // ain1 = "short4 val" 3667 public result_short4 reduce_my_short4(Allocation ain1, Script.LaunchOptions sc) { 3668 // check ain1 3669 if (!ain1.getType().getElement().isCompatible(__I16_4)) { 3670 throw new RSRuntimeException("Type mismatch with I16_4!"); 3671 } 3672 Allocation aout = Allocation.createSized(mRSLocal, __I16_4, 1); 3673 aout.setAutoPadding(true); 3674 reduce(mExportReduceIdx_my_short4, new Allocation[]{ain1}, aout, sc); 3675 return new result_short4(aout); 3676 } 3677 3678 private final static int mExportReduceIdx_my_array_short = 27; 3679 // in1 = "val" 3680 public resultArray7_short reduce_my_array_short(short[] in1) { 3681 // Verify that "in1" is non-null. 3682 if (in1 == null) { 3683 throw new RSIllegalArgumentException("Array \"in1\" is null!"); 3684 } 3685 Allocation ain1 = Allocation.createSized(mRSLocal, __I16, in1.length); 3686 ain1.setAutoPadding(true); 3687 ain1.copyFrom(in1); 3688 3689 resultArray7_short result = reduce_my_array_short(ain1, null); 3690 result.mTempIns = new Allocation[]{ain1}; 3691 return result; 3692 } 3693 3694 // ain1 = "short val" 3695 public resultArray7_short reduce_my_array_short(Allocation ain1) { 3696 return reduce_my_array_short(ain1, null); 3697 } 3698 3699 // ain1 = "short val" 3700 public resultArray7_short reduce_my_array_short(Allocation ain1, Script.LaunchOptions sc) { 3701 // check ain1 3702 if (!ain1.getType().getElement().isCompatible(__I16)) { 3703 throw new RSRuntimeException("Type mismatch with I16!"); 3704 } 3705 Allocation aout = Allocation.createSized(mRSLocal, __I16, 7); 3706 aout.setAutoPadding(true); 3707 reduce(mExportReduceIdx_my_array_short, new Allocation[]{ain1}, aout, sc); 3708 return new resultArray7_short(aout); 3709 } 3710 3711 private final static int mExportReduceIdx_my_array_short2 = 28; 3712 // in1 = "val", flattened 2-vectors 3713 public resultArray7_short2 reduce_my_array_short2(short[] in1) { 3714 // Verify that "in1" is non-null. 3715 if (in1 == null) { 3716 throw new RSIllegalArgumentException("Array \"in1\" is null!"); 3717 } 3718 // Verify that the array length is a multiple of the vector size. 3719 if (in1.length % 2 != 0) { 3720 throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!"); 3721 } 3722 Allocation ain1 = Allocation.createSized(mRSLocal, __I16_2, in1.length / 2); 3723 ain1.setAutoPadding(true); 3724 ain1.copyFrom(in1); 3725 3726 resultArray7_short2 result = reduce_my_array_short2(ain1, null); 3727 result.mTempIns = new Allocation[]{ain1}; 3728 return result; 3729 } 3730 3731 // ain1 = "short2 val" 3732 public resultArray7_short2 reduce_my_array_short2(Allocation ain1) { 3733 return reduce_my_array_short2(ain1, null); 3734 } 3735 3736 // ain1 = "short2 val" 3737 public resultArray7_short2 reduce_my_array_short2(Allocation ain1, Script.LaunchOptions sc) { 3738 // check ain1 3739 if (!ain1.getType().getElement().isCompatible(__I16_2)) { 3740 throw new RSRuntimeException("Type mismatch with I16_2!"); 3741 } 3742 Allocation aout = Allocation.createSized(mRSLocal, __I16_2, 7); 3743 aout.setAutoPadding(true); 3744 reduce(mExportReduceIdx_my_array_short2, new Allocation[]{ain1}, aout, sc); 3745 return new resultArray7_short2(aout); 3746 } 3747 3748 private final static int mExportReduceIdx_my_array_short4 = 29; 3749 // in1 = "val", flattened 4-vectors 3750 public resultArray7_short4 reduce_my_array_short4(short[] in1) { 3751 // Verify that "in1" is non-null. 3752 if (in1 == null) { 3753 throw new RSIllegalArgumentException("Array \"in1\" is null!"); 3754 } 3755 // Verify that the array length is a multiple of the vector size. 3756 if (in1.length % 4 != 0) { 3757 throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!"); 3758 } 3759 Allocation ain1 = Allocation.createSized(mRSLocal, __I16_4, in1.length / 4); 3760 ain1.setAutoPadding(true); 3761 ain1.copyFrom(in1); 3762 3763 resultArray7_short4 result = reduce_my_array_short4(ain1, null); 3764 result.mTempIns = new Allocation[]{ain1}; 3765 return result; 3766 } 3767 3768 // ain1 = "short4 val" 3769 public resultArray7_short4 reduce_my_array_short4(Allocation ain1) { 3770 return reduce_my_array_short4(ain1, null); 3771 } 3772 3773 // ain1 = "short4 val" 3774 public resultArray7_short4 reduce_my_array_short4(Allocation ain1, Script.LaunchOptions sc) { 3775 // check ain1 3776 if (!ain1.getType().getElement().isCompatible(__I16_4)) { 3777 throw new RSRuntimeException("Type mismatch with I16_4!"); 3778 } 3779 Allocation aout = Allocation.createSized(mRSLocal, __I16_4, 7); 3780 aout.setAutoPadding(true); 3781 reduce(mExportReduceIdx_my_array_short4, new Allocation[]{ain1}, aout, sc); 3782 return new resultArray7_short4(aout); 3783 } 3784 3785 private final static int mExportReduceIdx_my_int = 30; 3786 // in1 = "val" 3787 public result_int reduce_my_int(int[] in1) { 3788 // Verify that "in1" is non-null. 3789 if (in1 == null) { 3790 throw new RSIllegalArgumentException("Array \"in1\" is null!"); 3791 } 3792 Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length); 3793 ain1.setAutoPadding(true); 3794 ain1.copyFrom(in1); 3795 3796 result_int result = reduce_my_int(ain1, null); 3797 result.mTempIns = new Allocation[]{ain1}; 3798 return result; 3799 } 3800 3801 // ain1 = "int val" 3802 public result_int reduce_my_int(Allocation ain1) { 3803 return reduce_my_int(ain1, null); 3804 } 3805 3806 // ain1 = "int val" 3807 public result_int reduce_my_int(Allocation ain1, Script.LaunchOptions sc) { 3808 // check ain1 3809 if (!ain1.getType().getElement().isCompatible(__I32)) { 3810 throw new RSRuntimeException("Type mismatch with I32!"); 3811 } 3812 Allocation aout = Allocation.createSized(mRSLocal, __I32, 1); 3813 aout.setAutoPadding(true); 3814 reduce(mExportReduceIdx_my_int, new Allocation[]{ain1}, aout, sc); 3815 return new result_int(aout); 3816 } 3817 3818 private final static int mExportReduceIdx_my_int2 = 31; 3819 // in1 = "val", flattened 2-vectors 3820 public result_int2 reduce_my_int2(int[] in1) { 3821 // Verify that "in1" is non-null. 3822 if (in1 == null) { 3823 throw new RSIllegalArgumentException("Array \"in1\" is null!"); 3824 } 3825 // Verify that the array length is a multiple of the vector size. 3826 if (in1.length % 2 != 0) { 3827 throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!"); 3828 } 3829 Allocation ain1 = Allocation.createSized(mRSLocal, __I32_2, in1.length / 2); 3830 ain1.setAutoPadding(true); 3831 ain1.copyFrom(in1); 3832 3833 result_int2 result = reduce_my_int2(ain1, null); 3834 result.mTempIns = new Allocation[]{ain1}; 3835 return result; 3836 } 3837 3838 // ain1 = "int2 val" 3839 public result_int2 reduce_my_int2(Allocation ain1) { 3840 return reduce_my_int2(ain1, null); 3841 } 3842 3843 // ain1 = "int2 val" 3844 public result_int2 reduce_my_int2(Allocation ain1, Script.LaunchOptions sc) { 3845 // check ain1 3846 if (!ain1.getType().getElement().isCompatible(__I32_2)) { 3847 throw new RSRuntimeException("Type mismatch with I32_2!"); 3848 } 3849 Allocation aout = Allocation.createSized(mRSLocal, __I32_2, 1); 3850 aout.setAutoPadding(true); 3851 reduce(mExportReduceIdx_my_int2, new Allocation[]{ain1}, aout, sc); 3852 return new result_int2(aout); 3853 } 3854 3855 private final static int mExportReduceIdx_my_int4 = 32; 3856 // in1 = "val", flattened 4-vectors 3857 public result_int4 reduce_my_int4(int[] in1) { 3858 // Verify that "in1" is non-null. 3859 if (in1 == null) { 3860 throw new RSIllegalArgumentException("Array \"in1\" is null!"); 3861 } 3862 // Verify that the array length is a multiple of the vector size. 3863 if (in1.length % 4 != 0) { 3864 throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!"); 3865 } 3866 Allocation ain1 = Allocation.createSized(mRSLocal, __I32_4, in1.length / 4); 3867 ain1.setAutoPadding(true); 3868 ain1.copyFrom(in1); 3869 3870 result_int4 result = reduce_my_int4(ain1, null); 3871 result.mTempIns = new Allocation[]{ain1}; 3872 return result; 3873 } 3874 3875 // ain1 = "int4 val" 3876 public result_int4 reduce_my_int4(Allocation ain1) { 3877 return reduce_my_int4(ain1, null); 3878 } 3879 3880 // ain1 = "int4 val" 3881 public result_int4 reduce_my_int4(Allocation ain1, Script.LaunchOptions sc) { 3882 // check ain1 3883 if (!ain1.getType().getElement().isCompatible(__I32_4)) { 3884 throw new RSRuntimeException("Type mismatch with I32_4!"); 3885 } 3886 Allocation aout = Allocation.createSized(mRSLocal, __I32_4, 1); 3887 aout.setAutoPadding(true); 3888 reduce(mExportReduceIdx_my_int4, new Allocation[]{ain1}, aout, sc); 3889 return new result_int4(aout); 3890 } 3891 3892 private final static int mExportReduceIdx_my_array_int = 33; 3893 // in1 = "val" 3894 public resultArray7_int reduce_my_array_int(int[] in1) { 3895 // Verify that "in1" is non-null. 3896 if (in1 == null) { 3897 throw new RSIllegalArgumentException("Array \"in1\" is null!"); 3898 } 3899 Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length); 3900 ain1.setAutoPadding(true); 3901 ain1.copyFrom(in1); 3902 3903 resultArray7_int result = reduce_my_array_int(ain1, null); 3904 result.mTempIns = new Allocation[]{ain1}; 3905 return result; 3906 } 3907 3908 // ain1 = "int val" 3909 public resultArray7_int reduce_my_array_int(Allocation ain1) { 3910 return reduce_my_array_int(ain1, null); 3911 } 3912 3913 // ain1 = "int val" 3914 public resultArray7_int reduce_my_array_int(Allocation ain1, Script.LaunchOptions sc) { 3915 // check ain1 3916 if (!ain1.getType().getElement().isCompatible(__I32)) { 3917 throw new RSRuntimeException("Type mismatch with I32!"); 3918 } 3919 Allocation aout = Allocation.createSized(mRSLocal, __I32, 7); 3920 aout.setAutoPadding(true); 3921 reduce(mExportReduceIdx_my_array_int, new Allocation[]{ain1}, aout, sc); 3922 return new resultArray7_int(aout); 3923 } 3924 3925 private final static int mExportReduceIdx_my_array_int2 = 34; 3926 // in1 = "val", flattened 2-vectors 3927 public resultArray7_int2 reduce_my_array_int2(int[] in1) { 3928 // Verify that "in1" is non-null. 3929 if (in1 == null) { 3930 throw new RSIllegalArgumentException("Array \"in1\" is null!"); 3931 } 3932 // Verify that the array length is a multiple of the vector size. 3933 if (in1.length % 2 != 0) { 3934 throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!"); 3935 } 3936 Allocation ain1 = Allocation.createSized(mRSLocal, __I32_2, in1.length / 2); 3937 ain1.setAutoPadding(true); 3938 ain1.copyFrom(in1); 3939 3940 resultArray7_int2 result = reduce_my_array_int2(ain1, null); 3941 result.mTempIns = new Allocation[]{ain1}; 3942 return result; 3943 } 3944 3945 // ain1 = "int2 val" 3946 public resultArray7_int2 reduce_my_array_int2(Allocation ain1) { 3947 return reduce_my_array_int2(ain1, null); 3948 } 3949 3950 // ain1 = "int2 val" 3951 public resultArray7_int2 reduce_my_array_int2(Allocation ain1, Script.LaunchOptions sc) { 3952 // check ain1 3953 if (!ain1.getType().getElement().isCompatible(__I32_2)) { 3954 throw new RSRuntimeException("Type mismatch with I32_2!"); 3955 } 3956 Allocation aout = Allocation.createSized(mRSLocal, __I32_2, 7); 3957 aout.setAutoPadding(true); 3958 reduce(mExportReduceIdx_my_array_int2, new Allocation[]{ain1}, aout, sc); 3959 return new resultArray7_int2(aout); 3960 } 3961 3962 private final static int mExportReduceIdx_my_array_int4 = 35; 3963 // in1 = "val", flattened 4-vectors 3964 public resultArray7_int4 reduce_my_array_int4(int[] in1) { 3965 // Verify that "in1" is non-null. 3966 if (in1 == null) { 3967 throw new RSIllegalArgumentException("Array \"in1\" is null!"); 3968 } 3969 // Verify that the array length is a multiple of the vector size. 3970 if (in1.length % 4 != 0) { 3971 throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!"); 3972 } 3973 Allocation ain1 = Allocation.createSized(mRSLocal, __I32_4, in1.length / 4); 3974 ain1.setAutoPadding(true); 3975 ain1.copyFrom(in1); 3976 3977 resultArray7_int4 result = reduce_my_array_int4(ain1, null); 3978 result.mTempIns = new Allocation[]{ain1}; 3979 return result; 3980 } 3981 3982 // ain1 = "int4 val" 3983 public resultArray7_int4 reduce_my_array_int4(Allocation ain1) { 3984 return reduce_my_array_int4(ain1, null); 3985 } 3986 3987 // ain1 = "int4 val" 3988 public resultArray7_int4 reduce_my_array_int4(Allocation ain1, Script.LaunchOptions sc) { 3989 // check ain1 3990 if (!ain1.getType().getElement().isCompatible(__I32_4)) { 3991 throw new RSRuntimeException("Type mismatch with I32_4!"); 3992 } 3993 Allocation aout = Allocation.createSized(mRSLocal, __I32_4, 7); 3994 aout.setAutoPadding(true); 3995 reduce(mExportReduceIdx_my_array_int4, new Allocation[]{ain1}, aout, sc); 3996 return new resultArray7_int4(aout); 3997 } 3998 3999 private final static int mExportReduceIdx_my_long = 36; 4000 // in1 = "val" 4001 public result_long reduce_my_long(long[] in1) { 4002 // Verify that "in1" is non-null. 4003 if (in1 == null) { 4004 throw new RSIllegalArgumentException("Array \"in1\" is null!"); 4005 } 4006 Allocation ain1 = Allocation.createSized(mRSLocal, __I64, in1.length); 4007 ain1.setAutoPadding(true); 4008 ain1.copyFrom(in1); 4009 4010 result_long result = reduce_my_long(ain1, null); 4011 result.mTempIns = new Allocation[]{ain1}; 4012 return result; 4013 } 4014 4015 // ain1 = "long val" 4016 public result_long reduce_my_long(Allocation ain1) { 4017 return reduce_my_long(ain1, null); 4018 } 4019 4020 // ain1 = "long val" 4021 public result_long reduce_my_long(Allocation ain1, Script.LaunchOptions sc) { 4022 // check ain1 4023 if (!ain1.getType().getElement().isCompatible(__I64)) { 4024 throw new RSRuntimeException("Type mismatch with I64!"); 4025 } 4026 Allocation aout = Allocation.createSized(mRSLocal, __I64, 1); 4027 aout.setAutoPadding(true); 4028 reduce(mExportReduceIdx_my_long, new Allocation[]{ain1}, aout, sc); 4029 return new result_long(aout); 4030 } 4031 4032 private final static int mExportReduceIdx_my_long2 = 37; 4033 // in1 = "val", flattened 2-vectors 4034 public result_long2 reduce_my_long2(long[] in1) { 4035 // Verify that "in1" is non-null. 4036 if (in1 == null) { 4037 throw new RSIllegalArgumentException("Array \"in1\" is null!"); 4038 } 4039 // Verify that the array length is a multiple of the vector size. 4040 if (in1.length % 2 != 0) { 4041 throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!"); 4042 } 4043 Allocation ain1 = Allocation.createSized(mRSLocal, __I64_2, in1.length / 2); 4044 ain1.setAutoPadding(true); 4045 ain1.copyFrom(in1); 4046 4047 result_long2 result = reduce_my_long2(ain1, null); 4048 result.mTempIns = new Allocation[]{ain1}; 4049 return result; 4050 } 4051 4052 // ain1 = "long2 val" 4053 public result_long2 reduce_my_long2(Allocation ain1) { 4054 return reduce_my_long2(ain1, null); 4055 } 4056 4057 // ain1 = "long2 val" 4058 public result_long2 reduce_my_long2(Allocation ain1, Script.LaunchOptions sc) { 4059 // check ain1 4060 if (!ain1.getType().getElement().isCompatible(__I64_2)) { 4061 throw new RSRuntimeException("Type mismatch with I64_2!"); 4062 } 4063 Allocation aout = Allocation.createSized(mRSLocal, __I64_2, 1); 4064 aout.setAutoPadding(true); 4065 reduce(mExportReduceIdx_my_long2, new Allocation[]{ain1}, aout, sc); 4066 return new result_long2(aout); 4067 } 4068 4069 private final static int mExportReduceIdx_my_long4 = 38; 4070 // in1 = "val", flattened 4-vectors 4071 public result_long4 reduce_my_long4(long[] in1) { 4072 // Verify that "in1" is non-null. 4073 if (in1 == null) { 4074 throw new RSIllegalArgumentException("Array \"in1\" is null!"); 4075 } 4076 // Verify that the array length is a multiple of the vector size. 4077 if (in1.length % 4 != 0) { 4078 throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!"); 4079 } 4080 Allocation ain1 = Allocation.createSized(mRSLocal, __I64_4, in1.length / 4); 4081 ain1.setAutoPadding(true); 4082 ain1.copyFrom(in1); 4083 4084 result_long4 result = reduce_my_long4(ain1, null); 4085 result.mTempIns = new Allocation[]{ain1}; 4086 return result; 4087 } 4088 4089 // ain1 = "long4 val" 4090 public result_long4 reduce_my_long4(Allocation ain1) { 4091 return reduce_my_long4(ain1, null); 4092 } 4093 4094 // ain1 = "long4 val" 4095 public result_long4 reduce_my_long4(Allocation ain1, Script.LaunchOptions sc) { 4096 // check ain1 4097 if (!ain1.getType().getElement().isCompatible(__I64_4)) { 4098 throw new RSRuntimeException("Type mismatch with I64_4!"); 4099 } 4100 Allocation aout = Allocation.createSized(mRSLocal, __I64_4, 1); 4101 aout.setAutoPadding(true); 4102 reduce(mExportReduceIdx_my_long4, new Allocation[]{ain1}, aout, sc); 4103 return new result_long4(aout); 4104 } 4105 4106 private final static int mExportReduceIdx_my_array_long = 39; 4107 // in1 = "val" 4108 public resultArray7_long reduce_my_array_long(long[] in1) { 4109 // Verify that "in1" is non-null. 4110 if (in1 == null) { 4111 throw new RSIllegalArgumentException("Array \"in1\" is null!"); 4112 } 4113 Allocation ain1 = Allocation.createSized(mRSLocal, __I64, in1.length); 4114 ain1.setAutoPadding(true); 4115 ain1.copyFrom(in1); 4116 4117 resultArray7_long result = reduce_my_array_long(ain1, null); 4118 result.mTempIns = new Allocation[]{ain1}; 4119 return result; 4120 } 4121 4122 // ain1 = "long val" 4123 public resultArray7_long reduce_my_array_long(Allocation ain1) { 4124 return reduce_my_array_long(ain1, null); 4125 } 4126 4127 // ain1 = "long val" 4128 public resultArray7_long reduce_my_array_long(Allocation ain1, Script.LaunchOptions sc) { 4129 // check ain1 4130 if (!ain1.getType().getElement().isCompatible(__I64)) { 4131 throw new RSRuntimeException("Type mismatch with I64!"); 4132 } 4133 Allocation aout = Allocation.createSized(mRSLocal, __I64, 7); 4134 aout.setAutoPadding(true); 4135 reduce(mExportReduceIdx_my_array_long, new Allocation[]{ain1}, aout, sc); 4136 return new resultArray7_long(aout); 4137 } 4138 4139 private final static int mExportReduceIdx_my_array_long2 = 40; 4140 // in1 = "val", flattened 2-vectors 4141 public resultArray7_long2 reduce_my_array_long2(long[] in1) { 4142 // Verify that "in1" is non-null. 4143 if (in1 == null) { 4144 throw new RSIllegalArgumentException("Array \"in1\" is null!"); 4145 } 4146 // Verify that the array length is a multiple of the vector size. 4147 if (in1.length % 2 != 0) { 4148 throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!"); 4149 } 4150 Allocation ain1 = Allocation.createSized(mRSLocal, __I64_2, in1.length / 2); 4151 ain1.setAutoPadding(true); 4152 ain1.copyFrom(in1); 4153 4154 resultArray7_long2 result = reduce_my_array_long2(ain1, null); 4155 result.mTempIns = new Allocation[]{ain1}; 4156 return result; 4157 } 4158 4159 // ain1 = "long2 val" 4160 public resultArray7_long2 reduce_my_array_long2(Allocation ain1) { 4161 return reduce_my_array_long2(ain1, null); 4162 } 4163 4164 // ain1 = "long2 val" 4165 public resultArray7_long2 reduce_my_array_long2(Allocation ain1, Script.LaunchOptions sc) { 4166 // check ain1 4167 if (!ain1.getType().getElement().isCompatible(__I64_2)) { 4168 throw new RSRuntimeException("Type mismatch with I64_2!"); 4169 } 4170 Allocation aout = Allocation.createSized(mRSLocal, __I64_2, 7); 4171 aout.setAutoPadding(true); 4172 reduce(mExportReduceIdx_my_array_long2, new Allocation[]{ain1}, aout, sc); 4173 return new resultArray7_long2(aout); 4174 } 4175 4176 private final static int mExportReduceIdx_my_array_long4 = 41; 4177 // in1 = "val", flattened 4-vectors 4178 public resultArray7_long4 reduce_my_array_long4(long[] in1) { 4179 // Verify that "in1" is non-null. 4180 if (in1 == null) { 4181 throw new RSIllegalArgumentException("Array \"in1\" is null!"); 4182 } 4183 // Verify that the array length is a multiple of the vector size. 4184 if (in1.length % 4 != 0) { 4185 throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!"); 4186 } 4187 Allocation ain1 = Allocation.createSized(mRSLocal, __I64_4, in1.length / 4); 4188 ain1.setAutoPadding(true); 4189 ain1.copyFrom(in1); 4190 4191 resultArray7_long4 result = reduce_my_array_long4(ain1, null); 4192 result.mTempIns = new Allocation[]{ain1}; 4193 return result; 4194 } 4195 4196 // ain1 = "long4 val" 4197 public resultArray7_long4 reduce_my_array_long4(Allocation ain1) { 4198 return reduce_my_array_long4(ain1, null); 4199 } 4200 4201 // ain1 = "long4 val" 4202 public resultArray7_long4 reduce_my_array_long4(Allocation ain1, Script.LaunchOptions sc) { 4203 // check ain1 4204 if (!ain1.getType().getElement().isCompatible(__I64_4)) { 4205 throw new RSRuntimeException("Type mismatch with I64_4!"); 4206 } 4207 Allocation aout = Allocation.createSized(mRSLocal, __I64_4, 7); 4208 aout.setAutoPadding(true); 4209 reduce(mExportReduceIdx_my_array_long4, new Allocation[]{ain1}, aout, sc); 4210 return new resultArray7_long4(aout); 4211 } 4212 4213 private final static int mExportReduceIdx_my_uchar = 42; 4214 // in1 = "val" 4215 public result_uchar reduce_my_uchar(byte[] in1) { 4216 // Verify that "in1" is non-null. 4217 if (in1 == null) { 4218 throw new RSIllegalArgumentException("Array \"in1\" is null!"); 4219 } 4220 Allocation ain1 = Allocation.createSized(mRSLocal, __U8, in1.length); 4221 ain1.setAutoPadding(true); 4222 ain1.copyFrom(in1); 4223 4224 result_uchar result = reduce_my_uchar(ain1, null); 4225 result.mTempIns = new Allocation[]{ain1}; 4226 return result; 4227 } 4228 4229 // ain1 = "uchar val" 4230 public result_uchar reduce_my_uchar(Allocation ain1) { 4231 return reduce_my_uchar(ain1, null); 4232 } 4233 4234 // ain1 = "uchar val" 4235 public result_uchar reduce_my_uchar(Allocation ain1, Script.LaunchOptions sc) { 4236 // check ain1 4237 if (!ain1.getType().getElement().isCompatible(__U8)) { 4238 throw new RSRuntimeException("Type mismatch with U8!"); 4239 } 4240 Allocation aout = Allocation.createSized(mRSLocal, __U8, 1); 4241 aout.setAutoPadding(true); 4242 reduce(mExportReduceIdx_my_uchar, new Allocation[]{ain1}, aout, sc); 4243 return new result_uchar(aout); 4244 } 4245 4246 private final static int mExportReduceIdx_my_uchar2 = 43; 4247 // in1 = "val", flattened 2-vectors 4248 public result_uchar2 reduce_my_uchar2(byte[] in1) { 4249 // Verify that "in1" is non-null. 4250 if (in1 == null) { 4251 throw new RSIllegalArgumentException("Array \"in1\" is null!"); 4252 } 4253 // Verify that the array length is a multiple of the vector size. 4254 if (in1.length % 2 != 0) { 4255 throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!"); 4256 } 4257 Allocation ain1 = Allocation.createSized(mRSLocal, __U8_2, in1.length / 2); 4258 ain1.setAutoPadding(true); 4259 ain1.copyFrom(in1); 4260 4261 result_uchar2 result = reduce_my_uchar2(ain1, null); 4262 result.mTempIns = new Allocation[]{ain1}; 4263 return result; 4264 } 4265 4266 // ain1 = "uchar2 val" 4267 public result_uchar2 reduce_my_uchar2(Allocation ain1) { 4268 return reduce_my_uchar2(ain1, null); 4269 } 4270 4271 // ain1 = "uchar2 val" 4272 public result_uchar2 reduce_my_uchar2(Allocation ain1, Script.LaunchOptions sc) { 4273 // check ain1 4274 if (!ain1.getType().getElement().isCompatible(__U8_2)) { 4275 throw new RSRuntimeException("Type mismatch with U8_2!"); 4276 } 4277 Allocation aout = Allocation.createSized(mRSLocal, __U8_2, 1); 4278 aout.setAutoPadding(true); 4279 reduce(mExportReduceIdx_my_uchar2, new Allocation[]{ain1}, aout, sc); 4280 return new result_uchar2(aout); 4281 } 4282 4283 private final static int mExportReduceIdx_my_uchar4 = 44; 4284 // in1 = "val", flattened 4-vectors 4285 public result_uchar4 reduce_my_uchar4(byte[] in1) { 4286 // Verify that "in1" is non-null. 4287 if (in1 == null) { 4288 throw new RSIllegalArgumentException("Array \"in1\" is null!"); 4289 } 4290 // Verify that the array length is a multiple of the vector size. 4291 if (in1.length % 4 != 0) { 4292 throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!"); 4293 } 4294 Allocation ain1 = Allocation.createSized(mRSLocal, __U8_4, in1.length / 4); 4295 ain1.setAutoPadding(true); 4296 ain1.copyFrom(in1); 4297 4298 result_uchar4 result = reduce_my_uchar4(ain1, null); 4299 result.mTempIns = new Allocation[]{ain1}; 4300 return result; 4301 } 4302 4303 // ain1 = "uchar4 val" 4304 public result_uchar4 reduce_my_uchar4(Allocation ain1) { 4305 return reduce_my_uchar4(ain1, null); 4306 } 4307 4308 // ain1 = "uchar4 val" 4309 public result_uchar4 reduce_my_uchar4(Allocation ain1, Script.LaunchOptions sc) { 4310 // check ain1 4311 if (!ain1.getType().getElement().isCompatible(__U8_4)) { 4312 throw new RSRuntimeException("Type mismatch with U8_4!"); 4313 } 4314 Allocation aout = Allocation.createSized(mRSLocal, __U8_4, 1); 4315 aout.setAutoPadding(true); 4316 reduce(mExportReduceIdx_my_uchar4, new Allocation[]{ain1}, aout, sc); 4317 return new result_uchar4(aout); 4318 } 4319 4320 private final static int mExportReduceIdx_my_array_uchar = 45; 4321 // in1 = "val" 4322 public resultArray7_uchar reduce_my_array_uchar(byte[] in1) { 4323 // Verify that "in1" is non-null. 4324 if (in1 == null) { 4325 throw new RSIllegalArgumentException("Array \"in1\" is null!"); 4326 } 4327 Allocation ain1 = Allocation.createSized(mRSLocal, __U8, in1.length); 4328 ain1.setAutoPadding(true); 4329 ain1.copyFrom(in1); 4330 4331 resultArray7_uchar result = reduce_my_array_uchar(ain1, null); 4332 result.mTempIns = new Allocation[]{ain1}; 4333 return result; 4334 } 4335 4336 // ain1 = "uchar val" 4337 public resultArray7_uchar reduce_my_array_uchar(Allocation ain1) { 4338 return reduce_my_array_uchar(ain1, null); 4339 } 4340 4341 // ain1 = "uchar val" 4342 public resultArray7_uchar reduce_my_array_uchar(Allocation ain1, Script.LaunchOptions sc) { 4343 // check ain1 4344 if (!ain1.getType().getElement().isCompatible(__U8)) { 4345 throw new RSRuntimeException("Type mismatch with U8!"); 4346 } 4347 Allocation aout = Allocation.createSized(mRSLocal, __U8, 7); 4348 aout.setAutoPadding(true); 4349 reduce(mExportReduceIdx_my_array_uchar, new Allocation[]{ain1}, aout, sc); 4350 return new resultArray7_uchar(aout); 4351 } 4352 4353 private final static int mExportReduceIdx_my_array_uchar2 = 46; 4354 // in1 = "val", flattened 2-vectors 4355 public resultArray7_uchar2 reduce_my_array_uchar2(byte[] in1) { 4356 // Verify that "in1" is non-null. 4357 if (in1 == null) { 4358 throw new RSIllegalArgumentException("Array \"in1\" is null!"); 4359 } 4360 // Verify that the array length is a multiple of the vector size. 4361 if (in1.length % 2 != 0) { 4362 throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!"); 4363 } 4364 Allocation ain1 = Allocation.createSized(mRSLocal, __U8_2, in1.length / 2); 4365 ain1.setAutoPadding(true); 4366 ain1.copyFrom(in1); 4367 4368 resultArray7_uchar2 result = reduce_my_array_uchar2(ain1, null); 4369 result.mTempIns = new Allocation[]{ain1}; 4370 return result; 4371 } 4372 4373 // ain1 = "uchar2 val" 4374 public resultArray7_uchar2 reduce_my_array_uchar2(Allocation ain1) { 4375 return reduce_my_array_uchar2(ain1, null); 4376 } 4377 4378 // ain1 = "uchar2 val" 4379 public resultArray7_uchar2 reduce_my_array_uchar2(Allocation ain1, Script.LaunchOptions sc) { 4380 // check ain1 4381 if (!ain1.getType().getElement().isCompatible(__U8_2)) { 4382 throw new RSRuntimeException("Type mismatch with U8_2!"); 4383 } 4384 Allocation aout = Allocation.createSized(mRSLocal, __U8_2, 7); 4385 aout.setAutoPadding(true); 4386 reduce(mExportReduceIdx_my_array_uchar2, new Allocation[]{ain1}, aout, sc); 4387 return new resultArray7_uchar2(aout); 4388 } 4389 4390 private final static int mExportReduceIdx_my_array_uchar4 = 47; 4391 // in1 = "val", flattened 4-vectors 4392 public resultArray7_uchar4 reduce_my_array_uchar4(byte[] in1) { 4393 // Verify that "in1" is non-null. 4394 if (in1 == null) { 4395 throw new RSIllegalArgumentException("Array \"in1\" is null!"); 4396 } 4397 // Verify that the array length is a multiple of the vector size. 4398 if (in1.length % 4 != 0) { 4399 throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!"); 4400 } 4401 Allocation ain1 = Allocation.createSized(mRSLocal, __U8_4, in1.length / 4); 4402 ain1.setAutoPadding(true); 4403 ain1.copyFrom(in1); 4404 4405 resultArray7_uchar4 result = reduce_my_array_uchar4(ain1, null); 4406 result.mTempIns = new Allocation[]{ain1}; 4407 return result; 4408 } 4409 4410 // ain1 = "uchar4 val" 4411 public resultArray7_uchar4 reduce_my_array_uchar4(Allocation ain1) { 4412 return reduce_my_array_uchar4(ain1, null); 4413 } 4414 4415 // ain1 = "uchar4 val" 4416 public resultArray7_uchar4 reduce_my_array_uchar4(Allocation ain1, Script.LaunchOptions sc) { 4417 // check ain1 4418 if (!ain1.getType().getElement().isCompatible(__U8_4)) { 4419 throw new RSRuntimeException("Type mismatch with U8_4!"); 4420 } 4421 Allocation aout = Allocation.createSized(mRSLocal, __U8_4, 7); 4422 aout.setAutoPadding(true); 4423 reduce(mExportReduceIdx_my_array_uchar4, new Allocation[]{ain1}, aout, sc); 4424 return new resultArray7_uchar4(aout); 4425 } 4426 4427 private final static int mExportReduceIdx_my_ushort = 48; 4428 // in1 = "val" 4429 public result_ushort reduce_my_ushort(short[] in1) { 4430 // Verify that "in1" is non-null. 4431 if (in1 == null) { 4432 throw new RSIllegalArgumentException("Array \"in1\" is null!"); 4433 } 4434 Allocation ain1 = Allocation.createSized(mRSLocal, __U16, in1.length); 4435 ain1.setAutoPadding(true); 4436 ain1.copyFrom(in1); 4437 4438 result_ushort result = reduce_my_ushort(ain1, null); 4439 result.mTempIns = new Allocation[]{ain1}; 4440 return result; 4441 } 4442 4443 // ain1 = "ushort val" 4444 public result_ushort reduce_my_ushort(Allocation ain1) { 4445 return reduce_my_ushort(ain1, null); 4446 } 4447 4448 // ain1 = "ushort val" 4449 public result_ushort reduce_my_ushort(Allocation ain1, Script.LaunchOptions sc) { 4450 // check ain1 4451 if (!ain1.getType().getElement().isCompatible(__U16)) { 4452 throw new RSRuntimeException("Type mismatch with U16!"); 4453 } 4454 Allocation aout = Allocation.createSized(mRSLocal, __U16, 1); 4455 aout.setAutoPadding(true); 4456 reduce(mExportReduceIdx_my_ushort, new Allocation[]{ain1}, aout, sc); 4457 return new result_ushort(aout); 4458 } 4459 4460 private final static int mExportReduceIdx_my_ushort2 = 49; 4461 // in1 = "val", flattened 2-vectors 4462 public result_ushort2 reduce_my_ushort2(short[] in1) { 4463 // Verify that "in1" is non-null. 4464 if (in1 == null) { 4465 throw new RSIllegalArgumentException("Array \"in1\" is null!"); 4466 } 4467 // Verify that the array length is a multiple of the vector size. 4468 if (in1.length % 2 != 0) { 4469 throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!"); 4470 } 4471 Allocation ain1 = Allocation.createSized(mRSLocal, __U16_2, in1.length / 2); 4472 ain1.setAutoPadding(true); 4473 ain1.copyFrom(in1); 4474 4475 result_ushort2 result = reduce_my_ushort2(ain1, null); 4476 result.mTempIns = new Allocation[]{ain1}; 4477 return result; 4478 } 4479 4480 // ain1 = "ushort2 val" 4481 public result_ushort2 reduce_my_ushort2(Allocation ain1) { 4482 return reduce_my_ushort2(ain1, null); 4483 } 4484 4485 // ain1 = "ushort2 val" 4486 public result_ushort2 reduce_my_ushort2(Allocation ain1, Script.LaunchOptions sc) { 4487 // check ain1 4488 if (!ain1.getType().getElement().isCompatible(__U16_2)) { 4489 throw new RSRuntimeException("Type mismatch with U16_2!"); 4490 } 4491 Allocation aout = Allocation.createSized(mRSLocal, __U16_2, 1); 4492 aout.setAutoPadding(true); 4493 reduce(mExportReduceIdx_my_ushort2, new Allocation[]{ain1}, aout, sc); 4494 return new result_ushort2(aout); 4495 } 4496 4497 private final static int mExportReduceIdx_my_ushort4 = 50; 4498 // in1 = "val", flattened 4-vectors 4499 public result_ushort4 reduce_my_ushort4(short[] in1) { 4500 // Verify that "in1" is non-null. 4501 if (in1 == null) { 4502 throw new RSIllegalArgumentException("Array \"in1\" is null!"); 4503 } 4504 // Verify that the array length is a multiple of the vector size. 4505 if (in1.length % 4 != 0) { 4506 throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!"); 4507 } 4508 Allocation ain1 = Allocation.createSized(mRSLocal, __U16_4, in1.length / 4); 4509 ain1.setAutoPadding(true); 4510 ain1.copyFrom(in1); 4511 4512 result_ushort4 result = reduce_my_ushort4(ain1, null); 4513 result.mTempIns = new Allocation[]{ain1}; 4514 return result; 4515 } 4516 4517 // ain1 = "ushort4 val" 4518 public result_ushort4 reduce_my_ushort4(Allocation ain1) { 4519 return reduce_my_ushort4(ain1, null); 4520 } 4521 4522 // ain1 = "ushort4 val" 4523 public result_ushort4 reduce_my_ushort4(Allocation ain1, Script.LaunchOptions sc) { 4524 // check ain1 4525 if (!ain1.getType().getElement().isCompatible(__U16_4)) { 4526 throw new RSRuntimeException("Type mismatch with U16_4!"); 4527 } 4528 Allocation aout = Allocation.createSized(mRSLocal, __U16_4, 1); 4529 aout.setAutoPadding(true); 4530 reduce(mExportReduceIdx_my_ushort4, new Allocation[]{ain1}, aout, sc); 4531 return new result_ushort4(aout); 4532 } 4533 4534 private final static int mExportReduceIdx_my_array_ushort = 51; 4535 // in1 = "val" 4536 public resultArray7_ushort reduce_my_array_ushort(short[] in1) { 4537 // Verify that "in1" is non-null. 4538 if (in1 == null) { 4539 throw new RSIllegalArgumentException("Array \"in1\" is null!"); 4540 } 4541 Allocation ain1 = Allocation.createSized(mRSLocal, __U16, in1.length); 4542 ain1.setAutoPadding(true); 4543 ain1.copyFrom(in1); 4544 4545 resultArray7_ushort result = reduce_my_array_ushort(ain1, null); 4546 result.mTempIns = new Allocation[]{ain1}; 4547 return result; 4548 } 4549 4550 // ain1 = "ushort val" 4551 public resultArray7_ushort reduce_my_array_ushort(Allocation ain1) { 4552 return reduce_my_array_ushort(ain1, null); 4553 } 4554 4555 // ain1 = "ushort val" 4556 public resultArray7_ushort reduce_my_array_ushort(Allocation ain1, Script.LaunchOptions sc) { 4557 // check ain1 4558 if (!ain1.getType().getElement().isCompatible(__U16)) { 4559 throw new RSRuntimeException("Type mismatch with U16!"); 4560 } 4561 Allocation aout = Allocation.createSized(mRSLocal, __U16, 7); 4562 aout.setAutoPadding(true); 4563 reduce(mExportReduceIdx_my_array_ushort, new Allocation[]{ain1}, aout, sc); 4564 return new resultArray7_ushort(aout); 4565 } 4566 4567 private final static int mExportReduceIdx_my_array_ushort2 = 52; 4568 // in1 = "val", flattened 2-vectors 4569 public resultArray7_ushort2 reduce_my_array_ushort2(short[] in1) { 4570 // Verify that "in1" is non-null. 4571 if (in1 == null) { 4572 throw new RSIllegalArgumentException("Array \"in1\" is null!"); 4573 } 4574 // Verify that the array length is a multiple of the vector size. 4575 if (in1.length % 2 != 0) { 4576 throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!"); 4577 } 4578 Allocation ain1 = Allocation.createSized(mRSLocal, __U16_2, in1.length / 2); 4579 ain1.setAutoPadding(true); 4580 ain1.copyFrom(in1); 4581 4582 resultArray7_ushort2 result = reduce_my_array_ushort2(ain1, null); 4583 result.mTempIns = new Allocation[]{ain1}; 4584 return result; 4585 } 4586 4587 // ain1 = "ushort2 val" 4588 public resultArray7_ushort2 reduce_my_array_ushort2(Allocation ain1) { 4589 return reduce_my_array_ushort2(ain1, null); 4590 } 4591 4592 // ain1 = "ushort2 val" 4593 public resultArray7_ushort2 reduce_my_array_ushort2(Allocation ain1, Script.LaunchOptions sc) { 4594 // check ain1 4595 if (!ain1.getType().getElement().isCompatible(__U16_2)) { 4596 throw new RSRuntimeException("Type mismatch with U16_2!"); 4597 } 4598 Allocation aout = Allocation.createSized(mRSLocal, __U16_2, 7); 4599 aout.setAutoPadding(true); 4600 reduce(mExportReduceIdx_my_array_ushort2, new Allocation[]{ain1}, aout, sc); 4601 return new resultArray7_ushort2(aout); 4602 } 4603 4604 private final static int mExportReduceIdx_my_array_ushort4 = 53; 4605 // in1 = "val", flattened 4-vectors 4606 public resultArray7_ushort4 reduce_my_array_ushort4(short[] in1) { 4607 // Verify that "in1" is non-null. 4608 if (in1 == null) { 4609 throw new RSIllegalArgumentException("Array \"in1\" is null!"); 4610 } 4611 // Verify that the array length is a multiple of the vector size. 4612 if (in1.length % 4 != 0) { 4613 throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!"); 4614 } 4615 Allocation ain1 = Allocation.createSized(mRSLocal, __U16_4, in1.length / 4); 4616 ain1.setAutoPadding(true); 4617 ain1.copyFrom(in1); 4618 4619 resultArray7_ushort4 result = reduce_my_array_ushort4(ain1, null); 4620 result.mTempIns = new Allocation[]{ain1}; 4621 return result; 4622 } 4623 4624 // ain1 = "ushort4 val" 4625 public resultArray7_ushort4 reduce_my_array_ushort4(Allocation ain1) { 4626 return reduce_my_array_ushort4(ain1, null); 4627 } 4628 4629 // ain1 = "ushort4 val" 4630 public resultArray7_ushort4 reduce_my_array_ushort4(Allocation ain1, Script.LaunchOptions sc) { 4631 // check ain1 4632 if (!ain1.getType().getElement().isCompatible(__U16_4)) { 4633 throw new RSRuntimeException("Type mismatch with U16_4!"); 4634 } 4635 Allocation aout = Allocation.createSized(mRSLocal, __U16_4, 7); 4636 aout.setAutoPadding(true); 4637 reduce(mExportReduceIdx_my_array_ushort4, new Allocation[]{ain1}, aout, sc); 4638 return new resultArray7_ushort4(aout); 4639 } 4640 4641 private final static int mExportReduceIdx_my_uint = 54; 4642 // in1 = "val" 4643 public result_uint reduce_my_uint(int[] in1) { 4644 // Verify that "in1" is non-null. 4645 if (in1 == null) { 4646 throw new RSIllegalArgumentException("Array \"in1\" is null!"); 4647 } 4648 Allocation ain1 = Allocation.createSized(mRSLocal, __U32, in1.length); 4649 ain1.setAutoPadding(true); 4650 ain1.copyFrom(in1); 4651 4652 result_uint result = reduce_my_uint(ain1, null); 4653 result.mTempIns = new Allocation[]{ain1}; 4654 return result; 4655 } 4656 4657 // ain1 = "uint val" 4658 public result_uint reduce_my_uint(Allocation ain1) { 4659 return reduce_my_uint(ain1, null); 4660 } 4661 4662 // ain1 = "uint val" 4663 public result_uint reduce_my_uint(Allocation ain1, Script.LaunchOptions sc) { 4664 // check ain1 4665 if (!ain1.getType().getElement().isCompatible(__U32)) { 4666 throw new RSRuntimeException("Type mismatch with U32!"); 4667 } 4668 Allocation aout = Allocation.createSized(mRSLocal, __U32, 1); 4669 aout.setAutoPadding(true); 4670 reduce(mExportReduceIdx_my_uint, new Allocation[]{ain1}, aout, sc); 4671 return new result_uint(aout); 4672 } 4673 4674 private final static int mExportReduceIdx_my_uint2 = 55; 4675 // in1 = "val", flattened 2-vectors 4676 public result_uint2 reduce_my_uint2(int[] in1) { 4677 // Verify that "in1" is non-null. 4678 if (in1 == null) { 4679 throw new RSIllegalArgumentException("Array \"in1\" is null!"); 4680 } 4681 // Verify that the array length is a multiple of the vector size. 4682 if (in1.length % 2 != 0) { 4683 throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!"); 4684 } 4685 Allocation ain1 = Allocation.createSized(mRSLocal, __U32_2, in1.length / 2); 4686 ain1.setAutoPadding(true); 4687 ain1.copyFrom(in1); 4688 4689 result_uint2 result = reduce_my_uint2(ain1, null); 4690 result.mTempIns = new Allocation[]{ain1}; 4691 return result; 4692 } 4693 4694 // ain1 = "uint2 val" 4695 public result_uint2 reduce_my_uint2(Allocation ain1) { 4696 return reduce_my_uint2(ain1, null); 4697 } 4698 4699 // ain1 = "uint2 val" 4700 public result_uint2 reduce_my_uint2(Allocation ain1, Script.LaunchOptions sc) { 4701 // check ain1 4702 if (!ain1.getType().getElement().isCompatible(__U32_2)) { 4703 throw new RSRuntimeException("Type mismatch with U32_2!"); 4704 } 4705 Allocation aout = Allocation.createSized(mRSLocal, __U32_2, 1); 4706 aout.setAutoPadding(true); 4707 reduce(mExportReduceIdx_my_uint2, new Allocation[]{ain1}, aout, sc); 4708 return new result_uint2(aout); 4709 } 4710 4711 private final static int mExportReduceIdx_my_uint4 = 56; 4712 // in1 = "val", flattened 4-vectors 4713 public result_uint4 reduce_my_uint4(int[] in1) { 4714 // Verify that "in1" is non-null. 4715 if (in1 == null) { 4716 throw new RSIllegalArgumentException("Array \"in1\" is null!"); 4717 } 4718 // Verify that the array length is a multiple of the vector size. 4719 if (in1.length % 4 != 0) { 4720 throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!"); 4721 } 4722 Allocation ain1 = Allocation.createSized(mRSLocal, __U32_4, in1.length / 4); 4723 ain1.setAutoPadding(true); 4724 ain1.copyFrom(in1); 4725 4726 result_uint4 result = reduce_my_uint4(ain1, null); 4727 result.mTempIns = new Allocation[]{ain1}; 4728 return result; 4729 } 4730 4731 // ain1 = "uint4 val" 4732 public result_uint4 reduce_my_uint4(Allocation ain1) { 4733 return reduce_my_uint4(ain1, null); 4734 } 4735 4736 // ain1 = "uint4 val" 4737 public result_uint4 reduce_my_uint4(Allocation ain1, Script.LaunchOptions sc) { 4738 // check ain1 4739 if (!ain1.getType().getElement().isCompatible(__U32_4)) { 4740 throw new RSRuntimeException("Type mismatch with U32_4!"); 4741 } 4742 Allocation aout = Allocation.createSized(mRSLocal, __U32_4, 1); 4743 aout.setAutoPadding(true); 4744 reduce(mExportReduceIdx_my_uint4, new Allocation[]{ain1}, aout, sc); 4745 return new result_uint4(aout); 4746 } 4747 4748 private final static int mExportReduceIdx_my_array_uint = 57; 4749 // in1 = "val" 4750 public resultArray7_uint reduce_my_array_uint(int[] in1) { 4751 // Verify that "in1" is non-null. 4752 if (in1 == null) { 4753 throw new RSIllegalArgumentException("Array \"in1\" is null!"); 4754 } 4755 Allocation ain1 = Allocation.createSized(mRSLocal, __U32, in1.length); 4756 ain1.setAutoPadding(true); 4757 ain1.copyFrom(in1); 4758 4759 resultArray7_uint result = reduce_my_array_uint(ain1, null); 4760 result.mTempIns = new Allocation[]{ain1}; 4761 return result; 4762 } 4763 4764 // ain1 = "uint val" 4765 public resultArray7_uint reduce_my_array_uint(Allocation ain1) { 4766 return reduce_my_array_uint(ain1, null); 4767 } 4768 4769 // ain1 = "uint val" 4770 public resultArray7_uint reduce_my_array_uint(Allocation ain1, Script.LaunchOptions sc) { 4771 // check ain1 4772 if (!ain1.getType().getElement().isCompatible(__U32)) { 4773 throw new RSRuntimeException("Type mismatch with U32!"); 4774 } 4775 Allocation aout = Allocation.createSized(mRSLocal, __U32, 7); 4776 aout.setAutoPadding(true); 4777 reduce(mExportReduceIdx_my_array_uint, new Allocation[]{ain1}, aout, sc); 4778 return new resultArray7_uint(aout); 4779 } 4780 4781 private final static int mExportReduceIdx_my_array_uint2 = 58; 4782 // in1 = "val", flattened 2-vectors 4783 public resultArray7_uint2 reduce_my_array_uint2(int[] in1) { 4784 // Verify that "in1" is non-null. 4785 if (in1 == null) { 4786 throw new RSIllegalArgumentException("Array \"in1\" is null!"); 4787 } 4788 // Verify that the array length is a multiple of the vector size. 4789 if (in1.length % 2 != 0) { 4790 throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!"); 4791 } 4792 Allocation ain1 = Allocation.createSized(mRSLocal, __U32_2, in1.length / 2); 4793 ain1.setAutoPadding(true); 4794 ain1.copyFrom(in1); 4795 4796 resultArray7_uint2 result = reduce_my_array_uint2(ain1, null); 4797 result.mTempIns = new Allocation[]{ain1}; 4798 return result; 4799 } 4800 4801 // ain1 = "uint2 val" 4802 public resultArray7_uint2 reduce_my_array_uint2(Allocation ain1) { 4803 return reduce_my_array_uint2(ain1, null); 4804 } 4805 4806 // ain1 = "uint2 val" 4807 public resultArray7_uint2 reduce_my_array_uint2(Allocation ain1, Script.LaunchOptions sc) { 4808 // check ain1 4809 if (!ain1.getType().getElement().isCompatible(__U32_2)) { 4810 throw new RSRuntimeException("Type mismatch with U32_2!"); 4811 } 4812 Allocation aout = Allocation.createSized(mRSLocal, __U32_2, 7); 4813 aout.setAutoPadding(true); 4814 reduce(mExportReduceIdx_my_array_uint2, new Allocation[]{ain1}, aout, sc); 4815 return new resultArray7_uint2(aout); 4816 } 4817 4818 private final static int mExportReduceIdx_my_array_uint4 = 59; 4819 // in1 = "val", flattened 4-vectors 4820 public resultArray7_uint4 reduce_my_array_uint4(int[] in1) { 4821 // Verify that "in1" is non-null. 4822 if (in1 == null) { 4823 throw new RSIllegalArgumentException("Array \"in1\" is null!"); 4824 } 4825 // Verify that the array length is a multiple of the vector size. 4826 if (in1.length % 4 != 0) { 4827 throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!"); 4828 } 4829 Allocation ain1 = Allocation.createSized(mRSLocal, __U32_4, in1.length / 4); 4830 ain1.setAutoPadding(true); 4831 ain1.copyFrom(in1); 4832 4833 resultArray7_uint4 result = reduce_my_array_uint4(ain1, null); 4834 result.mTempIns = new Allocation[]{ain1}; 4835 return result; 4836 } 4837 4838 // ain1 = "uint4 val" 4839 public resultArray7_uint4 reduce_my_array_uint4(Allocation ain1) { 4840 return reduce_my_array_uint4(ain1, null); 4841 } 4842 4843 // ain1 = "uint4 val" 4844 public resultArray7_uint4 reduce_my_array_uint4(Allocation ain1, Script.LaunchOptions sc) { 4845 // check ain1 4846 if (!ain1.getType().getElement().isCompatible(__U32_4)) { 4847 throw new RSRuntimeException("Type mismatch with U32_4!"); 4848 } 4849 Allocation aout = Allocation.createSized(mRSLocal, __U32_4, 7); 4850 aout.setAutoPadding(true); 4851 reduce(mExportReduceIdx_my_array_uint4, new Allocation[]{ain1}, aout, sc); 4852 return new resultArray7_uint4(aout); 4853 } 4854 4855 private final static int mExportReduceIdx_my_ulong = 60; 4856 // in1 = "val" 4857 public result_ulong reduce_my_ulong(long[] in1) { 4858 // Verify that "in1" is non-null. 4859 if (in1 == null) { 4860 throw new RSIllegalArgumentException("Array \"in1\" is null!"); 4861 } 4862 Allocation ain1 = Allocation.createSized(mRSLocal, __U64, in1.length); 4863 ain1.setAutoPadding(true); 4864 ain1.copyFrom(in1); 4865 4866 result_ulong result = reduce_my_ulong(ain1, null); 4867 result.mTempIns = new Allocation[]{ain1}; 4868 return result; 4869 } 4870 4871 // ain1 = "ulong val" 4872 public result_ulong reduce_my_ulong(Allocation ain1) { 4873 return reduce_my_ulong(ain1, null); 4874 } 4875 4876 // ain1 = "ulong val" 4877 public result_ulong reduce_my_ulong(Allocation ain1, Script.LaunchOptions sc) { 4878 // check ain1 4879 if (!ain1.getType().getElement().isCompatible(__U64)) { 4880 throw new RSRuntimeException("Type mismatch with U64!"); 4881 } 4882 Allocation aout = Allocation.createSized(mRSLocal, __U64, 1); 4883 aout.setAutoPadding(true); 4884 reduce(mExportReduceIdx_my_ulong, new Allocation[]{ain1}, aout, sc); 4885 return new result_ulong(aout); 4886 } 4887 4888 private final static int mExportReduceIdx_my_ulong2 = 61; 4889 // in1 = "val", flattened 2-vectors 4890 public result_ulong2 reduce_my_ulong2(long[] in1) { 4891 // Verify that "in1" is non-null. 4892 if (in1 == null) { 4893 throw new RSIllegalArgumentException("Array \"in1\" is null!"); 4894 } 4895 // Verify that the array length is a multiple of the vector size. 4896 if (in1.length % 2 != 0) { 4897 throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!"); 4898 } 4899 Allocation ain1 = Allocation.createSized(mRSLocal, __U64_2, in1.length / 2); 4900 ain1.setAutoPadding(true); 4901 ain1.copyFrom(in1); 4902 4903 result_ulong2 result = reduce_my_ulong2(ain1, null); 4904 result.mTempIns = new Allocation[]{ain1}; 4905 return result; 4906 } 4907 4908 // ain1 = "ulong2 val" 4909 public result_ulong2 reduce_my_ulong2(Allocation ain1) { 4910 return reduce_my_ulong2(ain1, null); 4911 } 4912 4913 // ain1 = "ulong2 val" 4914 public result_ulong2 reduce_my_ulong2(Allocation ain1, Script.LaunchOptions sc) { 4915 // check ain1 4916 if (!ain1.getType().getElement().isCompatible(__U64_2)) { 4917 throw new RSRuntimeException("Type mismatch with U64_2!"); 4918 } 4919 Allocation aout = Allocation.createSized(mRSLocal, __U64_2, 1); 4920 aout.setAutoPadding(true); 4921 reduce(mExportReduceIdx_my_ulong2, new Allocation[]{ain1}, aout, sc); 4922 return new result_ulong2(aout); 4923 } 4924 4925 private final static int mExportReduceIdx_my_ulong4 = 62; 4926 // in1 = "val", flattened 4-vectors 4927 public result_ulong4 reduce_my_ulong4(long[] in1) { 4928 // Verify that "in1" is non-null. 4929 if (in1 == null) { 4930 throw new RSIllegalArgumentException("Array \"in1\" is null!"); 4931 } 4932 // Verify that the array length is a multiple of the vector size. 4933 if (in1.length % 4 != 0) { 4934 throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!"); 4935 } 4936 Allocation ain1 = Allocation.createSized(mRSLocal, __U64_4, in1.length / 4); 4937 ain1.setAutoPadding(true); 4938 ain1.copyFrom(in1); 4939 4940 result_ulong4 result = reduce_my_ulong4(ain1, null); 4941 result.mTempIns = new Allocation[]{ain1}; 4942 return result; 4943 } 4944 4945 // ain1 = "ulong4 val" 4946 public result_ulong4 reduce_my_ulong4(Allocation ain1) { 4947 return reduce_my_ulong4(ain1, null); 4948 } 4949 4950 // ain1 = "ulong4 val" 4951 public result_ulong4 reduce_my_ulong4(Allocation ain1, Script.LaunchOptions sc) { 4952 // check ain1 4953 if (!ain1.getType().getElement().isCompatible(__U64_4)) { 4954 throw new RSRuntimeException("Type mismatch with U64_4!"); 4955 } 4956 Allocation aout = Allocation.createSized(mRSLocal, __U64_4, 1); 4957 aout.setAutoPadding(true); 4958 reduce(mExportReduceIdx_my_ulong4, new Allocation[]{ain1}, aout, sc); 4959 return new result_ulong4(aout); 4960 } 4961 4962 private final static int mExportReduceIdx_my_array_ulong = 63; 4963 // in1 = "val" 4964 public resultArray7_ulong reduce_my_array_ulong(long[] in1) { 4965 // Verify that "in1" is non-null. 4966 if (in1 == null) { 4967 throw new RSIllegalArgumentException("Array \"in1\" is null!"); 4968 } 4969 Allocation ain1 = Allocation.createSized(mRSLocal, __U64, in1.length); 4970 ain1.setAutoPadding(true); 4971 ain1.copyFrom(in1); 4972 4973 resultArray7_ulong result = reduce_my_array_ulong(ain1, null); 4974 result.mTempIns = new Allocation[]{ain1}; 4975 return result; 4976 } 4977 4978 // ain1 = "ulong val" 4979 public resultArray7_ulong reduce_my_array_ulong(Allocation ain1) { 4980 return reduce_my_array_ulong(ain1, null); 4981 } 4982 4983 // ain1 = "ulong val" 4984 public resultArray7_ulong reduce_my_array_ulong(Allocation ain1, Script.LaunchOptions sc) { 4985 // check ain1 4986 if (!ain1.getType().getElement().isCompatible(__U64)) { 4987 throw new RSRuntimeException("Type mismatch with U64!"); 4988 } 4989 Allocation aout = Allocation.createSized(mRSLocal, __U64, 7); 4990 aout.setAutoPadding(true); 4991 reduce(mExportReduceIdx_my_array_ulong, new Allocation[]{ain1}, aout, sc); 4992 return new resultArray7_ulong(aout); 4993 } 4994 4995 private final static int mExportReduceIdx_my_array_ulong2 = 64; 4996 // in1 = "val", flattened 2-vectors 4997 public resultArray7_ulong2 reduce_my_array_ulong2(long[] in1) { 4998 // Verify that "in1" is non-null. 4999 if (in1 == null) { 5000 throw new RSIllegalArgumentException("Array \"in1\" is null!"); 5001 } 5002 // Verify that the array length is a multiple of the vector size. 5003 if (in1.length % 2 != 0) { 5004 throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!"); 5005 } 5006 Allocation ain1 = Allocation.createSized(mRSLocal, __U64_2, in1.length / 2); 5007 ain1.setAutoPadding(true); 5008 ain1.copyFrom(in1); 5009 5010 resultArray7_ulong2 result = reduce_my_array_ulong2(ain1, null); 5011 result.mTempIns = new Allocation[]{ain1}; 5012 return result; 5013 } 5014 5015 // ain1 = "ulong2 val" 5016 public resultArray7_ulong2 reduce_my_array_ulong2(Allocation ain1) { 5017 return reduce_my_array_ulong2(ain1, null); 5018 } 5019 5020 // ain1 = "ulong2 val" 5021 public resultArray7_ulong2 reduce_my_array_ulong2(Allocation ain1, Script.LaunchOptions sc) { 5022 // check ain1 5023 if (!ain1.getType().getElement().isCompatible(__U64_2)) { 5024 throw new RSRuntimeException("Type mismatch with U64_2!"); 5025 } 5026 Allocation aout = Allocation.createSized(mRSLocal, __U64_2, 7); 5027 aout.setAutoPadding(true); 5028 reduce(mExportReduceIdx_my_array_ulong2, new Allocation[]{ain1}, aout, sc); 5029 return new resultArray7_ulong2(aout); 5030 } 5031 5032 private final static int mExportReduceIdx_my_array_ulong4 = 65; 5033 // in1 = "val", flattened 4-vectors 5034 public resultArray7_ulong4 reduce_my_array_ulong4(long[] in1) { 5035 // Verify that "in1" is non-null. 5036 if (in1 == null) { 5037 throw new RSIllegalArgumentException("Array \"in1\" is null!"); 5038 } 5039 // Verify that the array length is a multiple of the vector size. 5040 if (in1.length % 4 != 0) { 5041 throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!"); 5042 } 5043 Allocation ain1 = Allocation.createSized(mRSLocal, __U64_4, in1.length / 4); 5044 ain1.setAutoPadding(true); 5045 ain1.copyFrom(in1); 5046 5047 resultArray7_ulong4 result = reduce_my_array_ulong4(ain1, null); 5048 result.mTempIns = new Allocation[]{ain1}; 5049 return result; 5050 } 5051 5052 // ain1 = "ulong4 val" 5053 public resultArray7_ulong4 reduce_my_array_ulong4(Allocation ain1) { 5054 return reduce_my_array_ulong4(ain1, null); 5055 } 5056 5057 // ain1 = "ulong4 val" 5058 public resultArray7_ulong4 reduce_my_array_ulong4(Allocation ain1, Script.LaunchOptions sc) { 5059 // check ain1 5060 if (!ain1.getType().getElement().isCompatible(__U64_4)) { 5061 throw new RSRuntimeException("Type mismatch with U64_4!"); 5062 } 5063 Allocation aout = Allocation.createSized(mRSLocal, __U64_4, 7); 5064 aout.setAutoPadding(true); 5065 reduce(mExportReduceIdx_my_array_ulong4, new Allocation[]{ain1}, aout, sc); 5066 return new resultArray7_ulong4(aout); 5067 } 5068 5069 private final static int mExportReduceIdx_my_bool = 66; 5070 // in1 = "val" 5071 public result_bool reduce_my_bool(byte[] in1) { 5072 // Verify that "in1" is non-null. 5073 if (in1 == null) { 5074 throw new RSIllegalArgumentException("Array \"in1\" is null!"); 5075 } 5076 Allocation ain1 = Allocation.createSized(mRSLocal, __BOOLEAN, in1.length); 5077 ain1.setAutoPadding(true); 5078 ain1.copyFrom(in1); 5079 5080 result_bool result = reduce_my_bool(ain1, null); 5081 result.mTempIns = new Allocation[]{ain1}; 5082 return result; 5083 } 5084 5085 // ain1 = "bool val" 5086 public result_bool reduce_my_bool(Allocation ain1) { 5087 return reduce_my_bool(ain1, null); 5088 } 5089 5090 // ain1 = "bool val" 5091 public result_bool reduce_my_bool(Allocation ain1, Script.LaunchOptions sc) { 5092 // check ain1 5093 if (!ain1.getType().getElement().isCompatible(__BOOLEAN)) { 5094 throw new RSRuntimeException("Type mismatch with BOOLEAN!"); 5095 } 5096 Allocation aout = Allocation.createSized(mRSLocal, __BOOLEAN, 1); 5097 aout.setAutoPadding(true); 5098 reduce(mExportReduceIdx_my_bool, new Allocation[]{ain1}, aout, sc); 5099 return new result_bool(aout); 5100 } 5101 5102 private final static int mExportReduceIdx_my_array_bool = 67; 5103 // in1 = "val" 5104 public resultArray7_bool reduce_my_array_bool(byte[] in1) { 5105 // Verify that "in1" is non-null. 5106 if (in1 == null) { 5107 throw new RSIllegalArgumentException("Array \"in1\" is null!"); 5108 } 5109 Allocation ain1 = Allocation.createSized(mRSLocal, __BOOLEAN, in1.length); 5110 ain1.setAutoPadding(true); 5111 ain1.copyFrom(in1); 5112 5113 resultArray7_bool result = reduce_my_array_bool(ain1, null); 5114 result.mTempIns = new Allocation[]{ain1}; 5115 return result; 5116 } 5117 5118 // ain1 = "bool val" 5119 public resultArray7_bool reduce_my_array_bool(Allocation ain1) { 5120 return reduce_my_array_bool(ain1, null); 5121 } 5122 5123 // ain1 = "bool val" 5124 public resultArray7_bool reduce_my_array_bool(Allocation ain1, Script.LaunchOptions sc) { 5125 // check ain1 5126 if (!ain1.getType().getElement().isCompatible(__BOOLEAN)) { 5127 throw new RSRuntimeException("Type mismatch with BOOLEAN!"); 5128 } 5129 Allocation aout = Allocation.createSized(mRSLocal, __BOOLEAN, 7); 5130 aout.setAutoPadding(true); 5131 reduce(mExportReduceIdx_my_array_bool, new Allocation[]{ain1}, aout, sc); 5132 return new resultArray7_bool(aout); 5133 } 5134 5135} 5136 5137