Google Git
Sign in
android / platform / libcore.git / 52d3feec412f4bafdf16c248c4b31014a8d9d72f / . / test / jdk / jdk / incubator / vector / Byte256VectorTests.java
blob: 7b68b9a4fefdf7c73cc5a7ef478f031c5b91cb17 [file] [log] [blame]
/*
* Copyright (c) 2018, 2021, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
/*
* @test
* @modules jdk.incubator.vector
* @run testng/othervm -ea -esa -Xbatch -XX:-TieredCompilation Byte256VectorTests
*/
// -- This file was mechanically generated: Do not edit! -- //
import jdk.incubator.vector.VectorShape;
import jdk.incubator.vector.VectorSpecies;
import jdk.incubator.vector.VectorShuffle;
import jdk.incubator.vector.VectorMask;
import jdk.incubator.vector.VectorOperators;
import jdk.incubator.vector.Vector;
import jdk.incubator.vector.ByteVector;
import org.testng.Assert;
import org.testng.annotations.DataProvider;
import org.testng.annotations.Test;
import java.lang.Integer;
import java.util.List;
import java.util.Arrays;
import java.util.function.BiFunction;
import java.util.function.IntFunction;
import java.util.Objects;
import java.util.stream.Collectors;
import java.util.stream.Stream;
@Test
public class Byte256VectorTests extends AbstractVectorTest {
static final VectorSpecies<Byte> SPECIES =
ByteVector.SPECIES_256;
static final int INVOC_COUNT = Integer.getInteger("jdk.incubator.vector.test.loop-iterations", 100);
static final int BUFFER_REPS = Integer.getInteger("jdk.incubator.vector.test.buffer-vectors", 25000 / 256);
static final int BUFFER_SIZE = Integer.getInteger("jdk.incubator.vector.test.buffer-size", BUFFER_REPS * (256 / 8));
interface FUnOp {
byte apply(byte a);
}
static void assertArraysEquals(byte[] r, byte[] a, FUnOp f) {
int i = 0;
try {
for (; i < a.length; i++) {
Assert.assertEquals(r[i], f.apply(a[i]));
}
} catch (AssertionError e) {
Assert.assertEquals(r[i], f.apply(a[i]), "at index #" + i + ", input = " + a[i]);
}
}
interface FUnArrayOp {
byte[] apply(byte a);
}
static void assertArraysEquals(byte[] r, byte[] a, FUnArrayOp f) {
int i = 0;
try {
for (; i < a.length; i += SPECIES.length()) {
Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
f.apply(a[i]));
}
} catch (AssertionError e) {
byte[] ref = f.apply(a[i]);
byte[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
Assert.assertEquals(res, ref, "(ref: " + Arrays.toString(ref)
+ ", res: " + Arrays.toString(res)
+ "), at index #" + i);
}
}
static void assertArraysEquals(byte[] r, byte[] a, boolean[] mask, FUnOp f) {
int i = 0;
try {
for (; i < a.length; i++) {
Assert.assertEquals(r[i], mask[i % SPECIES.length()] ? f.apply(a[i]) : a[i]);
}
} catch (AssertionError e) {
Assert.assertEquals(r[i], mask[i % SPECIES.length()] ? f.apply(a[i]) : a[i], "at index #" + i + ", input = " + a[i] + ", mask = " + mask[i % SPECIES.length()]);
}
}
interface FReductionOp {
byte apply(byte[] a, int idx);
}
interface FReductionAllOp {
byte apply(byte[] a);
}
static void assertReductionArraysEquals(byte[] r, byte rc, byte[] a,
FReductionOp f, FReductionAllOp fa) {
int i = 0;
try {
Assert.assertEquals(rc, fa.apply(a));
for (; i < a.length; i += SPECIES.length()) {
Assert.assertEquals(r[i], f.apply(a, i));
}
} catch (AssertionError e) {
Assert.assertEquals(rc, fa.apply(a), "Final result is incorrect!");
Assert.assertEquals(r[i], f.apply(a, i), "at index #" + i);
}
}
interface FReductionMaskedOp {
byte apply(byte[] a, int idx, boolean[] mask);
}
interface FReductionAllMaskedOp {
byte apply(byte[] a, boolean[] mask);
}
static void assertReductionArraysEqualsMasked(byte[] r, byte rc, byte[] a, boolean[] mask,
FReductionMaskedOp f, FReductionAllMaskedOp fa) {
int i = 0;
try {
Assert.assertEquals(rc, fa.apply(a, mask));
for (; i < a.length; i += SPECIES.length()) {
Assert.assertEquals(r[i], f.apply(a, i, mask));
}
} catch (AssertionError e) {
Assert.assertEquals(rc, fa.apply(a, mask), "Final result is incorrect!");
Assert.assertEquals(r[i], f.apply(a, i, mask), "at index #" + i);
}
}
interface FReductionOpLong {
long apply(byte[] a, int idx);
}
interface FReductionAllOpLong {
long apply(byte[] a);
}
static void assertReductionLongArraysEquals(long[] r, long rc, byte[] a,
FReductionOpLong f, FReductionAllOpLong fa) {
int i = 0;
try {
Assert.assertEquals(rc, fa.apply(a));
for (; i < a.length; i += SPECIES.length()) {
Assert.assertEquals(r[i], f.apply(a, i));
}
} catch (AssertionError e) {
Assert.assertEquals(rc, fa.apply(a), "Final result is incorrect!");
Assert.assertEquals(r[i], f.apply(a, i), "at index #" + i);
}
}
interface FReductionMaskedOpLong {
long apply(byte[] a, int idx, boolean[] mask);
}
interface FReductionAllMaskedOpLong {
long apply(byte[] a, boolean[] mask);
}
static void assertReductionLongArraysEqualsMasked(long[] r, long rc, byte[] a, boolean[] mask,
FReductionMaskedOpLong f, FReductionAllMaskedOpLong fa) {
int i = 0;
try {
Assert.assertEquals(rc, fa.apply(a, mask));
for (; i < a.length; i += SPECIES.length()) {
Assert.assertEquals(r[i], f.apply(a, i, mask));
}
} catch (AssertionError e) {
Assert.assertEquals(rc, fa.apply(a, mask), "Final result is incorrect!");
Assert.assertEquals(r[i], f.apply(a, i, mask), "at index #" + i);
}
}
interface FBoolReductionOp {
boolean apply(boolean[] a, int idx);
}
static void assertReductionBoolArraysEquals(boolean[] r, boolean[] a, FBoolReductionOp f) {
int i = 0;
try {
for (; i < a.length; i += SPECIES.length()) {
Assert.assertEquals(r[i], f.apply(a, i));
}
} catch (AssertionError e) {
Assert.assertEquals(r[i], f.apply(a, i), "at index #" + i);
}
}
static void assertInsertArraysEquals(byte[] r, byte[] a, byte element, int index) {
int i = 0;
try {
for (; i < a.length; i += 1) {
if(i%SPECIES.length() == index) {
Assert.assertEquals(r[i], element);
} else {
Assert.assertEquals(r[i], a[i]);
}
}
} catch (AssertionError e) {
if (i%SPECIES.length() == index) {
Assert.assertEquals(r[i], element, "at index #" + i);
} else {
Assert.assertEquals(r[i], a[i], "at index #" + i);
}
}
}
static void assertRearrangeArraysEquals(byte[] r, byte[] a, int[] order, int vector_len) {
int i = 0, j = 0;
try {
for (; i < a.length; i += vector_len) {
for (j = 0; j < vector_len; j++) {
Assert.assertEquals(r[i+j], a[i+order[i+j]]);
}
}
} catch (AssertionError e) {
int idx = i + j;
Assert.assertEquals(r[i+j], a[i+order[i+j]], "at index #" + idx + ", input = " + a[i+order[i+j]]);
}
}
static void assertSelectFromArraysEquals(byte[] r, byte[] a, byte[] order, int vector_len) {
int i = 0, j = 0;
try {
for (; i < a.length; i += vector_len) {
for (j = 0; j < vector_len; j++) {
Assert.assertEquals(r[i+j], a[i+(int)order[i+j]]);
}
}
} catch (AssertionError e) {
int idx = i + j;
Assert.assertEquals(r[i+j], a[i+(int)order[i+j]], "at index #" + idx + ", input = " + a[i+(int)order[i+j]]);
}
}
static void assertRearrangeArraysEquals(byte[] r, byte[] a, int[] order, boolean[] mask, int vector_len) {
int i = 0, j = 0;
try {
for (; i < a.length; i += vector_len) {
for (j = 0; j < vector_len; j++) {
if (mask[j % SPECIES.length()])
Assert.assertEquals(r[i+j], a[i+order[i+j]]);
else
Assert.assertEquals(r[i+j], (byte)0);
}
}
} catch (AssertionError e) {
int idx = i + j;
if (mask[j % SPECIES.length()])
Assert.assertEquals(r[i+j], a[i+order[i+j]], "at index #" + idx + ", input = " + a[i+order[i+j]] + ", mask = " + mask[j % SPECIES.length()]);
else
Assert.assertEquals(r[i+j], (byte)0, "at index #" + idx + ", input = " + a[i+order[i+j]] + ", mask = " + mask[j % SPECIES.length()]);
}
}
static void assertSelectFromArraysEquals(byte[] r, byte[] a, byte[] order, boolean[] mask, int vector_len) {
int i = 0, j = 0;
try {
for (; i < a.length; i += vector_len) {
for (j = 0; j < vector_len; j++) {
if (mask[j % SPECIES.length()])
Assert.assertEquals(r[i+j], a[i+(int)order[i+j]]);
else
Assert.assertEquals(r[i+j], (byte)0);
}
}
} catch (AssertionError e) {
int idx = i + j;
if (mask[j % SPECIES.length()])
Assert.assertEquals(r[i+j], a[i+(int)order[i+j]], "at index #" + idx + ", input = " + a[i+(int)order[i+j]] + ", mask = " + mask[j % SPECIES.length()]);
else
Assert.assertEquals(r[i+j], (byte)0, "at index #" + idx + ", input = " + a[i+(int)order[i+j]] + ", mask = " + mask[j % SPECIES.length()]);
}
}
static void assertBroadcastArraysEquals(byte[] r, byte[] a) {
int i = 0;
for (; i < a.length; i += SPECIES.length()) {
int idx = i;
for (int j = idx; j < (idx + SPECIES.length()); j++)
a[j]=a[idx];
}
try {
for (i = 0; i < a.length; i++) {
Assert.assertEquals(r[i], a[i]);
}
} catch (AssertionError e) {
Assert.assertEquals(r[i], a[i], "at index #" + i + ", input = " + a[i]);
}
}
interface FBinOp {
byte apply(byte a, byte b);
}
interface FBinMaskOp {
byte apply(byte a, byte b, boolean m);
static FBinMaskOp lift(FBinOp f) {
return (a, b, m) -> m ? f.apply(a, b) : a;
}
}
static void assertArraysEquals(byte[] r, byte[] a, byte[] b, FBinOp f) {
int i = 0;
try {
for (; i < a.length; i++) {
Assert.assertEquals(r[i], f.apply(a[i], b[i]));
}
} catch (AssertionError e) {
Assert.assertEquals(r[i], f.apply(a[i], b[i]), "(" + a[i] + ", " + b[i] + ") at index #" + i);
}
}
static void assertBroadcastArraysEquals(byte[] r, byte[] a, byte[] b, FBinOp f) {
int i = 0;
try {
for (; i < a.length; i++) {
Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()]));
}
} catch (AssertionError e) {
Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()]),
"(" + a[i] + ", " + b[(i / SPECIES.length()) * SPECIES.length()] + ") at index #" + i);
}
}
static void assertBroadcastLongArraysEquals(byte[] r, byte[] a, byte[] b, FBinOp f) {
int i = 0;
try {
for (; i < a.length; i++) {
Assert.assertEquals(r[i], f.apply(a[i], (byte)((long)b[(i / SPECIES.length()) * SPECIES.length()])));
}
} catch (AssertionError e) {
Assert.assertEquals(r[i], f.apply(a[i], (byte)((long)b[(i / SPECIES.length()) * SPECIES.length()])),
"(" + a[i] + ", " + b[(i / SPECIES.length()) * SPECIES.length()] + ") at index #" + i);
}
}
static void assertArraysEquals(byte[] r, byte[] a, byte[] b, boolean[] mask, FBinOp f) {
assertArraysEquals(r, a, b, mask, FBinMaskOp.lift(f));
}
static void assertArraysEquals(byte[] r, byte[] a, byte[] b, boolean[] mask, FBinMaskOp f) {
int i = 0;
try {
for (; i < a.length; i++) {
Assert.assertEquals(r[i], f.apply(a[i], b[i], mask[i % SPECIES.length()]));
}
} catch (AssertionError err) {
Assert.assertEquals(r[i], f.apply(a[i], b[i], mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] + ", input2 = " + b[i] + ", mask = " + mask[i % SPECIES.length()]);
}
}
static void assertBroadcastArraysEquals(byte[] r, byte[] a, byte[] b, boolean[] mask, FBinOp f) {
assertBroadcastArraysEquals(r, a, b, mask, FBinMaskOp.lift(f));
}
static void assertBroadcastArraysEquals(byte[] r, byte[] a, byte[] b, boolean[] mask, FBinMaskOp f) {
int i = 0;
try {
for (; i < a.length; i++) {
Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()], mask[i % SPECIES.length()]));
}
} catch (AssertionError err) {
Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()],
mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] +
", input2 = " + b[(i / SPECIES.length()) * SPECIES.length()] + ", mask = " +
mask[i % SPECIES.length()]);
}
}
static void assertBroadcastLongArraysEquals(byte[] r, byte[] a, byte[] b, boolean[] mask, FBinOp f) {
assertBroadcastLongArraysEquals(r, a, b, mask, FBinMaskOp.lift(f));
}
static void assertBroadcastLongArraysEquals(byte[] r, byte[] a, byte[] b, boolean[] mask, FBinMaskOp f) {
int i = 0;
try {
for (; i < a.length; i++) {
Assert.assertEquals(r[i], f.apply(a[i], (byte)((long)b[(i / SPECIES.length()) * SPECIES.length()]), mask[i % SPECIES.length()]));
}
} catch (AssertionError err) {
Assert.assertEquals(r[i], f.apply(a[i], (byte)((long)b[(i / SPECIES.length()) * SPECIES.length()]),
mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] +
", input2 = " + b[(i / SPECIES.length()) * SPECIES.length()] + ", mask = " +
mask[i % SPECIES.length()]);
}
}
static void assertShiftArraysEquals(byte[] r, byte[] a, byte[] b, FBinOp f) {
int i = 0;
int j = 0;
try {
for (; j < a.length; j += SPECIES.length()) {
for (i = 0; i < SPECIES.length(); i++) {
Assert.assertEquals(r[i+j], f.apply(a[i+j], b[j]));
}
}
} catch (AssertionError e) {
Assert.assertEquals(r[i+j], f.apply(a[i+j], b[j]), "at index #" + i + ", " + j);
}
}
static void assertShiftArraysEquals(byte[] r, byte[] a, byte[] b, boolean[] mask, FBinOp f) {
assertShiftArraysEquals(r, a, b, mask, FBinMaskOp.lift(f));
}
static void assertShiftArraysEquals(byte[] r, byte[] a, byte[] b, boolean[] mask, FBinMaskOp f) {
int i = 0;
int j = 0;
try {
for (; j < a.length; j += SPECIES.length()) {
for (i = 0; i < SPECIES.length(); i++) {
Assert.assertEquals(r[i+j], f.apply(a[i+j], b[j], mask[i]));
}
}
} catch (AssertionError err) {
Assert.assertEquals(r[i+j], f.apply(a[i+j], b[j], mask[i]), "at index #" + i + ", input1 = " + a[i+j] + ", input2 = " + b[j] + ", mask = " + mask[i]);
}
}
interface FTernOp {
byte apply(byte a, byte b, byte c);
}
interface FTernMaskOp {
byte apply(byte a, byte b, byte c, boolean m);
static FTernMaskOp lift(FTernOp f) {
return (a, b, c, m) -> m ? f.apply(a, b, c) : a;
}
}
static void assertArraysEquals(byte[] r, byte[] a, byte[] b, byte[] c, FTernOp f) {
int i = 0;
try {
for (; i < a.length; i++) {
Assert.assertEquals(r[i], f.apply(a[i], b[i], c[i]));
}
} catch (AssertionError e) {
Assert.assertEquals(r[i], f.apply(a[i], b[i], c[i]), "at index #" + i + ", input1 = " + a[i] + ", input2 = " + b[i] + ", input3 = " + c[i]);
}
}
static void assertArraysEquals(byte[] r, byte[] a, byte[] b, byte[] c, boolean[] mask, FTernOp f) {
assertArraysEquals(r, a, b, c, mask, FTernMaskOp.lift(f));
}
static void assertArraysEquals(byte[] r, byte[] a, byte[] b, byte[] c, boolean[] mask, FTernMaskOp f) {
int i = 0;
try {
for (; i < a.length; i++) {
Assert.assertEquals(r[i], f.apply(a[i], b[i], c[i], mask[i % SPECIES.length()]));
}
} catch (AssertionError err) {
Assert.assertEquals(r[i], f.apply(a[i], b[i], c[i], mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] + ", input2 = "
+ b[i] + ", input3 = " + c[i] + ", mask = " + mask[i % SPECIES.length()]);
}
}
static void assertBroadcastArraysEquals(byte[] r, byte[] a, byte[] b, byte[] c, FTernOp f) {
int i = 0;
try {
for (; i < a.length; i++) {
Assert.assertEquals(r[i], f.apply(a[i], b[i], c[(i / SPECIES.length()) * SPECIES.length()]));
}
} catch (AssertionError e) {
Assert.assertEquals(r[i], f.apply(a[i], b[i], c[(i / SPECIES.length()) * SPECIES.length()]), "at index #" +
i + ", input1 = " + a[i] + ", input2 = " + b[i] + ", input3 = " +
c[(i / SPECIES.length()) * SPECIES.length()]);
}
}
static void assertAltBroadcastArraysEquals(byte[] r, byte[] a, byte[] b, byte[] c, FTernOp f) {
int i = 0;
try {
for (; i < a.length; i++) {
Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()], c[i]));
}
} catch (AssertionError e) {
Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()], c[i]), "at index #" +
i + ", input1 = " + a[i] + ", input2 = " +
b[(i / SPECIES.length()) * SPECIES.length()] + ", input3 = " + c[i]);
}
}
static void assertBroadcastArraysEquals(byte[] r, byte[] a, byte[] b, byte[] c, boolean[] mask,
FTernOp f) {
assertBroadcastArraysEquals(r, a, b, c, mask, FTernMaskOp.lift(f));
}
static void assertBroadcastArraysEquals(byte[] r, byte[] a, byte[] b, byte[] c, boolean[] mask,
FTernMaskOp f) {
int i = 0;
try {
for (; i < a.length; i++) {
Assert.assertEquals(r[i], f.apply(a[i], b[i], c[(i / SPECIES.length()) * SPECIES.length()],
mask[i % SPECIES.length()]));
}
} catch (AssertionError err) {
Assert.assertEquals(r[i], f.apply(a[i], b[i], c[(i / SPECIES.length()) * SPECIES.length()],
mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] + ", input2 = " +
b[i] + ", input3 = " + c[(i / SPECIES.length()) * SPECIES.length()] + ", mask = " +
mask[i % SPECIES.length()]);
}
}
static void assertAltBroadcastArraysEquals(byte[] r, byte[] a, byte[] b, byte[] c, boolean[] mask,
FTernOp f) {
assertAltBroadcastArraysEquals(r, a, b, c, mask, FTernMaskOp.lift(f));
}
static void assertAltBroadcastArraysEquals(byte[] r, byte[] a, byte[] b, byte[] c, boolean[] mask,
FTernMaskOp f) {
int i = 0;
try {
for (; i < a.length; i++) {
Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()], c[i],
mask[i % SPECIES.length()]));
}
} catch (AssertionError err) {
Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()], c[i],
mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] +
", input2 = " + b[(i / SPECIES.length()) * SPECIES.length()] +
", input3 = " + c[i] + ", mask = " + mask[i % SPECIES.length()]);
}
}
static void assertDoubleBroadcastArraysEquals(byte[] r, byte[] a, byte[] b, byte[] c, FTernOp f) {
int i = 0;
try {
for (; i < a.length; i++) {
Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()],
c[(i / SPECIES.length()) * SPECIES.length()]));
}
} catch (AssertionError e) {
Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()],
c[(i / SPECIES.length()) * SPECIES.length()]), "at index #" + i + ", input1 = " + a[i]
+ ", input2 = " + b[(i / SPECIES.length()) * SPECIES.length()] + ", input3 = " +
c[(i / SPECIES.length()) * SPECIES.length()]);
}
}
static void assertDoubleBroadcastArraysEquals(byte[] r, byte[] a, byte[] b, byte[] c, boolean[] mask,
FTernOp f) {
assertDoubleBroadcastArraysEquals(r, a, b, c, mask, FTernMaskOp.lift(f));
}
static void assertDoubleBroadcastArraysEquals(byte[] r, byte[] a, byte[] b, byte[] c, boolean[] mask,
FTernMaskOp f) {
int i = 0;
try {
for (; i < a.length; i++) {
Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()],
c[(i / SPECIES.length()) * SPECIES.length()], mask[i % SPECIES.length()]));
}
} catch (AssertionError err) {
Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()],
c[(i / SPECIES.length()) * SPECIES.length()], mask[i % SPECIES.length()]), "at index #"
+ i + ", input1 = " + a[i] + ", input2 = " + b[(i / SPECIES.length()) * SPECIES.length()] +
", input3 = " + c[(i / SPECIES.length()) * SPECIES.length()] + ", mask = " +
mask[i % SPECIES.length()]);
}
}
interface FBinArrayOp {
byte apply(byte[] a, int b);
}
static void assertArraysEquals(byte[] r, byte[] a, FBinArrayOp f) {
int i = 0;
try {
for (; i < a.length; i++) {
Assert.assertEquals(r[i], f.apply(a, i));
}
} catch (AssertionError e) {
Assert.assertEquals(r[i], f.apply(a,i), "at index #" + i);
}
}
interface FGatherScatterOp {
byte[] apply(byte[] a, int ix, int[] b, int iy);
}
static void assertArraysEquals(byte[] r, byte[] a, int[] b, FGatherScatterOp f) {
int i = 0;
try {
for (; i < a.length; i += SPECIES.length()) {
Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
f.apply(a, i, b, i));
}
} catch (AssertionError e) {
byte[] ref = f.apply(a, i, b, i);
byte[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
Assert.assertEquals(res, ref,
"(ref: " + Arrays.toString(ref) + ", res: " + Arrays.toString(res) + ", a: "
+ Arrays.toString(Arrays.copyOfRange(a, i, i+SPECIES.length()))
+ ", b: "
+ Arrays.toString(Arrays.copyOfRange(b, i, i+SPECIES.length()))
+ " at index #" + i);
}
}
interface FGatherMaskedOp {
byte[] apply(byte[] a, int ix, boolean[] mask, int[] b, int iy);
}
interface FScatterMaskedOp {
byte[] apply(byte[] r, byte[] a, int ix, boolean[] mask, int[] b, int iy);
}
static void assertArraysEquals(byte[] r, byte[] a, int[] b, boolean[] mask, FGatherMaskedOp f) {
int i = 0;
try {
for (; i < a.length; i += SPECIES.length()) {
Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
f.apply(a, i, mask, b, i));
}
} catch (AssertionError e) {
byte[] ref = f.apply(a, i, mask, b, i);
byte[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
Assert.assertEquals(res, ref,
"(ref: " + Arrays.toString(ref) + ", res: " + Arrays.toString(res) + ", a: "
+ Arrays.toString(Arrays.copyOfRange(a, i, i+SPECIES.length()))
+ ", b: "
+ Arrays.toString(Arrays.copyOfRange(b, i, i+SPECIES.length()))
+ ", mask: "
+ Arrays.toString(mask)
+ " at index #" + i);
}
}
static void assertArraysEquals(byte[] r, byte[] a, int[] b, boolean[] mask, FScatterMaskedOp f) {
int i = 0;
try {
for (; i < a.length; i += SPECIES.length()) {
Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
f.apply(r, a, i, mask, b, i));
}
} catch (AssertionError e) {
byte[] ref = f.apply(r, a, i, mask, b, i);
byte[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
Assert.assertEquals(res, ref,
"(ref: " + Arrays.toString(ref) + ", res: " + Arrays.toString(res) + ", a: "
+ Arrays.toString(Arrays.copyOfRange(a, i, i+SPECIES.length()))
+ ", b: "
+ Arrays.toString(Arrays.copyOfRange(b, i, i+SPECIES.length()))
+ ", r: "
+ Arrays.toString(Arrays.copyOfRange(r, i, i+SPECIES.length()))
+ ", mask: "
+ Arrays.toString(mask)
+ " at index #" + i);
}
}
interface FLaneOp {
byte[] apply(byte[] a, int origin, int idx);
}
static void assertArraysEquals(byte[] r, byte[] a, int origin, FLaneOp f) {
int i = 0;
try {
for (; i < a.length; i += SPECIES.length()) {
Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
f.apply(a, origin, i));
}
} catch (AssertionError e) {
byte[] ref = f.apply(a, origin, i);
byte[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
Assert.assertEquals(res, ref, "(ref: " + Arrays.toString(ref)
+ ", res: " + Arrays.toString(res)
+ "), at index #" + i);
}
}
interface FLaneBop {
byte[] apply(byte[] a, byte[] b, int origin, int idx);
}
static void assertArraysEquals(byte[] r, byte[] a, byte[] b, int origin, FLaneBop f) {
int i = 0;
try {
for (; i < a.length; i += SPECIES.length()) {
Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
f.apply(a, b, origin, i));
}
} catch (AssertionError e) {
byte[] ref = f.apply(a, b, origin, i);
byte[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
Assert.assertEquals(res, ref, "(ref: " + Arrays.toString(ref)
+ ", res: " + Arrays.toString(res)
+ "), at index #" + i
+ ", at origin #" + origin);
}
}
interface FLaneMaskedBop {
byte[] apply(byte[] a, byte[] b, int origin, boolean[] mask, int idx);
}
static void assertArraysEquals(byte[] r, byte[] a, byte[] b, int origin, boolean[] mask, FLaneMaskedBop f) {
int i = 0;
try {
for (; i < a.length; i += SPECIES.length()) {
Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
f.apply(a, b, origin, mask, i));
}
} catch (AssertionError e) {
byte[] ref = f.apply(a, b, origin, mask, i);
byte[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
Assert.assertEquals(res, ref, "(ref: " + Arrays.toString(ref)
+ ", res: " + Arrays.toString(res)
+ "), at index #" + i
+ ", at origin #" + origin);
}
}
interface FLanePartBop {
byte[] apply(byte[] a, byte[] b, int origin, int part, int idx);
}
static void assertArraysEquals(byte[] r, byte[] a, byte[] b, int origin, int part, FLanePartBop f) {
int i = 0;
try {
for (; i < a.length; i += SPECIES.length()) {
Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
f.apply(a, b, origin, part, i));
}
} catch (AssertionError e) {
byte[] ref = f.apply(a, b, origin, part, i);
byte[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
Assert.assertEquals(res, ref, "(ref: " + Arrays.toString(ref)
+ ", res: " + Arrays.toString(res)
+ "), at index #" + i
+ ", at origin #" + origin
+ ", with part #" + part);
}
}
interface FLanePartMaskedBop {
byte[] apply(byte[] a, byte[] b, int origin, int part, boolean[] mask, int idx);
}
static void assertArraysEquals(byte[] r, byte[] a, byte[] b, int origin, int part, boolean[] mask, FLanePartMaskedBop f) {
int i = 0;
try {
for (; i < a.length; i += SPECIES.length()) {
Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
f.apply(a, b, origin, part, mask, i));
}
} catch (AssertionError e) {
byte[] ref = f.apply(a, b, origin, part, mask, i);
byte[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
Assert.assertEquals(res, ref, "(ref: " + Arrays.toString(ref)
+ ", res: " + Arrays.toString(res)
+ "), at index #" + i
+ ", at origin #" + origin
+ ", with part #" + part);
}
}
static void assertArraysEquals(int[] r, byte[] a, int offs) {
int i = 0;
try {
for (; i < r.length; i++) {
Assert.assertEquals(r[i], (int)(a[i+offs]));
}
} catch (AssertionError e) {
Assert.assertEquals(r[i], (int)(a[i+offs]), "at index #" + i + ", input = " + a[i+offs]);
}
}
static void assertArraysEquals(byte[] r, byte[] a, int offs) {
int i = 0;
try {
for (; i < r.length; i++) {
Assert.assertEquals(r[i], (long)(a[i+offs]));
}
} catch (AssertionError e) {
Assert.assertEquals(r[i], (long)(a[i+offs]), "at index #" + i + ", input = " + a[i+offs]);
}
}
static void assertArraysEquals(long[] r, byte[] a, int offs) {
int i = 0;
try {
for (; i < r.length; i++) {
Assert.assertEquals(r[i], (long)(a[i+offs]));
}
} catch (AssertionError e) {
Assert.assertEquals(r[i], (long)(a[i+offs]), "at index #" + i + ", input = " + a[i+offs]);
}
}
static void assertArraysEquals(double[] r, byte[] a, int offs) {
int i = 0;
try {
for (; i < r.length; i++) {
Assert.assertEquals(r[i], (double)(a[i+offs]));
}
} catch (AssertionError e) {
Assert.assertEquals(r[i], (double)(a[i+offs]), "at index #" + i + ", input = " + a[i+offs]);
}
}
static byte bits(byte e) {
return e;
}
static final List<IntFunction<byte[]>> BYTE_GENERATORS = List.of(
withToString("byte[-i * 5]", (int s) -> {
return fill(s * BUFFER_REPS,
i -> (byte)(-i * 5));
}),
withToString("byte[i * 5]", (int s) -> {
return fill(s * BUFFER_REPS,
i -> (byte)(i * 5));
}),
withToString("byte[i + 1]", (int s) -> {
return fill(s * BUFFER_REPS,
i -> (((byte)(i + 1) == 0) ? 1 : (byte)(i + 1)));
}),
withToString("byte[cornerCaseValue(i)]", (int s) -> {
return fill(s * BUFFER_REPS,
i -> cornerCaseValue(i));
})
);
// Create combinations of pairs
// @@@ Might be sensitive to order e.g. div by 0
static final List<List<IntFunction<byte[]>>> BYTE_GENERATOR_PAIRS =
Stream.of(BYTE_GENERATORS.get(0)).
flatMap(fa -> BYTE_GENERATORS.stream().skip(1).map(fb -> List.of(fa, fb))).
collect(Collectors.toList());
@DataProvider
public Object[][] boolUnaryOpProvider() {
return BOOL_ARRAY_GENERATORS.stream().
map(f -> new Object[]{f}).
toArray(Object[][]::new);
}
static final List<List<IntFunction<byte[]>>> BYTE_GENERATOR_TRIPLES =
BYTE_GENERATOR_PAIRS.stream().
flatMap(pair -> BYTE_GENERATORS.stream().map(f -> List.of(pair.get(0), pair.get(1), f))).
collect(Collectors.toList());
@DataProvider
public Object[][] byteBinaryOpProvider() {
return BYTE_GENERATOR_PAIRS.stream().map(List::toArray).
toArray(Object[][]::new);
}
@DataProvider
public Object[][] byteIndexedOpProvider() {
return BYTE_GENERATOR_PAIRS.stream().map(List::toArray).
toArray(Object[][]::new);
}
@DataProvider
public Object[][] byteBinaryOpMaskProvider() {
return BOOLEAN_MASK_GENERATORS.stream().
flatMap(fm -> BYTE_GENERATOR_PAIRS.stream().map(lfa -> {
return Stream.concat(lfa.stream(), Stream.of(fm)).toArray();
})).
toArray(Object[][]::new);
}
@DataProvider
public Object[][] byteTernaryOpProvider() {
return BYTE_GENERATOR_TRIPLES.stream().map(List::toArray).
toArray(Object[][]::new);
}
@DataProvider
public Object[][] byteTernaryOpMaskProvider() {
return BOOLEAN_MASK_GENERATORS.stream().
flatMap(fm -> BYTE_GENERATOR_TRIPLES.stream().map(lfa -> {
return Stream.concat(lfa.stream(), Stream.of(fm)).toArray();
})).
toArray(Object[][]::new);
}
@DataProvider
public Object[][] byteUnaryOpProvider() {
return BYTE_GENERATORS.stream().
map(f -> new Object[]{f}).
toArray(Object[][]::new);
}
@DataProvider
public Object[][] byteUnaryOpMaskProvider() {
return BOOLEAN_MASK_GENERATORS.stream().
flatMap(fm -> BYTE_GENERATORS.stream().map(fa -> {
return new Object[] {fa, fm};
})).
toArray(Object[][]::new);
}
@DataProvider
public Object[][] maskProvider() {
return BOOLEAN_MASK_GENERATORS.stream().
map(f -> new Object[]{f}).
toArray(Object[][]::new);
}
@DataProvider
public Object[][] maskCompareOpProvider() {
return BOOLEAN_MASK_COMPARE_GENERATOR_PAIRS.stream().map(List::toArray).
toArray(Object[][]::new);
}
@DataProvider
public Object[][] shuffleProvider() {
return INT_SHUFFLE_GENERATORS.stream().
map(f -> new Object[]{f}).
toArray(Object[][]::new);
}
@DataProvider
public Object[][] shuffleCompareOpProvider() {
return INT_SHUFFLE_COMPARE_GENERATOR_PAIRS.stream().map(List::toArray).
toArray(Object[][]::new);
}
@DataProvider
public Object[][] byteUnaryOpShuffleProvider() {
return INT_SHUFFLE_GENERATORS.stream().
flatMap(fs -> BYTE_GENERATORS.stream().map(fa -> {
return new Object[] {fa, fs};
})).
toArray(Object[][]::new);
}
@DataProvider
public Object[][] byteUnaryOpShuffleMaskProvider() {
return BOOLEAN_MASK_GENERATORS.stream().
flatMap(fm -> INT_SHUFFLE_GENERATORS.stream().
flatMap(fs -> BYTE_GENERATORS.stream().map(fa -> {
return new Object[] {fa, fs, fm};
}))).
toArray(Object[][]::new);
}
static final List<BiFunction<Integer,Integer,byte[]>> BYTE_SHUFFLE_GENERATORS = List.of(
withToStringBi("shuffle[random]", (Integer l, Integer m) -> {
byte[] a = new byte[l];
for (int i = 0; i < 1; i++) {
a[i] = (byte)RAND.nextInt(m);
}
return a;
})
);
@DataProvider
public Object[][] byteUnaryOpSelectFromProvider() {
return BYTE_SHUFFLE_GENERATORS.stream().
flatMap(fs -> BYTE_GENERATORS.stream().map(fa -> {
return new Object[] {fa, fs};
})).
toArray(Object[][]::new);
}
@DataProvider
public Object[][] byteUnaryOpSelectFromMaskProvider() {
return BOOLEAN_MASK_GENERATORS.stream().
flatMap(fm -> BYTE_SHUFFLE_GENERATORS.stream().
flatMap(fs -> BYTE_GENERATORS.stream().map(fa -> {
return new Object[] {fa, fs, fm};
}))).
toArray(Object[][]::new);
}
@DataProvider
public Object[][] byteUnaryOpIndexProvider() {
return INT_INDEX_GENERATORS.stream().
flatMap(fs -> BYTE_GENERATORS.stream().map(fa -> {
return new Object[] {fa, fs};
})).
toArray(Object[][]::new);
}
@DataProvider
public Object[][] byteUnaryMaskedOpIndexProvider() {
return BOOLEAN_MASK_GENERATORS.stream().
flatMap(fs -> INT_INDEX_GENERATORS.stream().flatMap(fm ->
BYTE_GENERATORS.stream().map(fa -> {
return new Object[] {fa, fm, fs};
}))).
toArray(Object[][]::new);
}
@DataProvider
public Object[][] scatterMaskedOpIndexProvider() {
return BOOLEAN_MASK_GENERATORS.stream().
flatMap(fs -> INT_INDEX_GENERATORS.stream().flatMap(fm ->
BYTE_GENERATORS.stream().flatMap(fn ->
BYTE_GENERATORS.stream().map(fa -> {
return new Object[] {fa, fn, fm, fs};
})))).
toArray(Object[][]::new);
}
static final List<IntFunction<byte[]>> BYTE_COMPARE_GENERATORS = List.of(
withToString("byte[i]", (int s) -> {
return fill(s * BUFFER_REPS,
i -> (byte)i);
}),
withToString("byte[i + 1]", (int s) -> {
return fill(s * BUFFER_REPS,
i -> (byte)(i + 1));
}),
withToString("byte[i - 2]", (int s) -> {
return fill(s * BUFFER_REPS,
i -> (byte)(i - 2));
}),
withToString("byte[zigZag(i)]", (int s) -> {
return fill(s * BUFFER_REPS,
i -> i%3 == 0 ? (byte)i : (i%3 == 1 ? (byte)(i + 1) : (byte)(i - 2)));
}),
withToString("byte[cornerCaseValue(i)]", (int s) -> {
return fill(s * BUFFER_REPS,
i -> cornerCaseValue(i));
})
);
static final List<List<IntFunction<byte[]>>> BYTE_TEST_GENERATOR_ARGS =
BYTE_COMPARE_GENERATORS.stream().
map(fa -> List.of(fa)).
collect(Collectors.toList());
@DataProvider
public Object[][] byteTestOpProvider() {
return BYTE_TEST_GENERATOR_ARGS.stream().map(List::toArray).
toArray(Object[][]::new);
}
@DataProvider
public Object[][] byteTestOpMaskProvider() {
return BOOLEAN_MASK_GENERATORS.stream().
flatMap(fm -> BYTE_TEST_GENERATOR_ARGS.stream().map(lfa -> {
return Stream.concat(lfa.stream(), Stream.of(fm)).toArray();
})).
toArray(Object[][]::new);
}
static final List<List<IntFunction<byte[]>>> BYTE_COMPARE_GENERATOR_PAIRS =
BYTE_COMPARE_GENERATORS.stream().
flatMap(fa -> BYTE_COMPARE_GENERATORS.stream().map(fb -> List.of(fa, fb))).
collect(Collectors.toList());
@DataProvider
public Object[][] byteCompareOpProvider() {
return BYTE_COMPARE_GENERATOR_PAIRS.stream().map(List::toArray).
toArray(Object[][]::new);
}
@DataProvider
public Object[][] byteCompareOpMaskProvider() {
return BOOLEAN_MASK_GENERATORS.stream().
flatMap(fm -> BYTE_COMPARE_GENERATOR_PAIRS.stream().map(lfa -> {
return Stream.concat(lfa.stream(), Stream.of(fm)).toArray();
})).
toArray(Object[][]::new);
}
interface ToByteF {
byte apply(int i);
}
static byte[] fill(int s , ToByteF f) {
return fill(new byte[s], f);
}
static byte[] fill(byte[] a, ToByteF f) {
for (int i = 0; i < a.length; i++) {
a[i] = f.apply(i);
}
return a;
}
static byte cornerCaseValue(int i) {
switch(i % 5) {
case 0:
return Byte.MAX_VALUE;
case 1:
return Byte.MIN_VALUE;
case 2:
return Byte.MIN_VALUE;
case 3:
return Byte.MAX_VALUE;
default:
return (byte)0;
}
}
static byte get(byte[] a, int i) {
return (byte) a[i];
}
static final IntFunction<byte[]> fr = (vl) -> {
int length = BUFFER_REPS * vl;
return new byte[length];
};
static final IntFunction<boolean[]> fmr = (vl) -> {
int length = BUFFER_REPS * vl;
return new boolean[length];
};
static final IntFunction<long[]> lfr = (vl) -> {
int length = BUFFER_REPS * vl;
return new long[length];
};
static void replaceZero(byte[] a, byte v) {
for (int i = 0; i < a.length; i++) {
if (a[i] == 0) {
a[i] = v;
}
}
}
static void replaceZero(byte[] a, boolean[] mask, byte v) {
for (int i = 0; i < a.length; i++) {
if (mask[i % mask.length] && a[i] == 0) {
a[i] = v;
}
}
}
@Test
static void smokeTest1() {
ByteVector three = ByteVector.broadcast(SPECIES, (byte)-3);
ByteVector three2 = (ByteVector) SPECIES.broadcast(-3);
assert(three.eq(three2).allTrue());
ByteVector three3 = three2.broadcast(1).broadcast(-3);
assert(three.eq(three3).allTrue());
int scale = 2;
Class<?> ETYPE = byte.class;
if (ETYPE == double.class || ETYPE == long.class)
scale = 1000000;
else if (ETYPE == byte.class && SPECIES.length() >= 64)
scale = 1;
ByteVector higher = three.addIndex(scale);
VectorMask<Byte> m = three.compare(VectorOperators.LE, higher);
assert(m.allTrue());
m = higher.min((byte)-1).test(VectorOperators.IS_NEGATIVE);
assert(m.allTrue());
byte max = higher.reduceLanes(VectorOperators.MAX);
assert(max == -3 + scale * (SPECIES.length()-1));
}
private static byte[]
bothToArray(ByteVector a, ByteVector b) {
byte[] r = new byte[a.length() + b.length()];
a.intoArray(r, 0);
b.intoArray(r, a.length());
return r;
}
@Test
static void smokeTest2() {
// Do some zipping and shuffling.
ByteVector io = (ByteVector) SPECIES.broadcast(0).addIndex(1);
ByteVector io2 = (ByteVector) VectorShuffle.iota(SPECIES,0,1,false).toVector();
Assert.assertEquals(io, io2);
ByteVector a = io.add((byte)1); //[1,2]
ByteVector b = a.neg(); //[-1,-2]
byte[] abValues = bothToArray(a,b); //[1,2,-1,-2]
VectorShuffle<Byte> zip0 = VectorShuffle.makeZip(SPECIES, 0);
VectorShuffle<Byte> zip1 = VectorShuffle.makeZip(SPECIES, 1);
ByteVector zab0 = a.rearrange(zip0,b); //[1,-1]
ByteVector zab1 = a.rearrange(zip1,b); //[2,-2]
byte[] zabValues = bothToArray(zab0, zab1); //[1,-1,2,-2]
// manually zip
byte[] manual = new byte[zabValues.length];
for (int i = 0; i < manual.length; i += 2) {
manual[i+0] = abValues[i/2];
manual[i+1] = abValues[a.length() + i/2];
}
Assert.assertEquals(Arrays.toString(zabValues), Arrays.toString(manual));
VectorShuffle<Byte> unz0 = VectorShuffle.makeUnzip(SPECIES, 0);
VectorShuffle<Byte> unz1 = VectorShuffle.makeUnzip(SPECIES, 1);
ByteVector uab0 = zab0.rearrange(unz0,zab1);
ByteVector uab1 = zab0.rearrange(unz1,zab1);
byte[] abValues1 = bothToArray(uab0, uab1);
Assert.assertEquals(Arrays.toString(abValues), Arrays.toString(abValues1));
}
static void iotaShuffle() {
ByteVector io = (ByteVector) SPECIES.broadcast(0).addIndex(1);
ByteVector io2 = (ByteVector) VectorShuffle.iota(SPECIES, 0 , 1, false).toVector();
Assert.assertEquals(io, io2);
}
@Test
// Test all shuffle related operations.
static void shuffleTest() {
// To test backend instructions, make sure that C2 is used.
for (int loop = 0; loop < INVOC_COUNT * INVOC_COUNT; loop++) {
iotaShuffle();
}
}
@Test
void viewAsIntegeralLanesTest() {
Vector<?> asIntegral = SPECIES.zero().viewAsIntegralLanes();
Assert.assertEquals(asIntegral.species(), SPECIES);
}
@Test(expectedExceptions = UnsupportedOperationException.class)
void viewAsFloatingLanesTest() {
SPECIES.zero().viewAsFloatingLanes();
}
@Test
// Test div by 0.
static void bitwiseDivByZeroSmokeTest() {
try {
ByteVector a = (ByteVector) SPECIES.broadcast(0).addIndex(1);
ByteVector b = (ByteVector) SPECIES.broadcast(0);
a.div(b);
Assert.fail();
} catch (ArithmeticException e) {
}
try {
ByteVector a = (ByteVector) SPECIES.broadcast(0).addIndex(1);
ByteVector b = (ByteVector) SPECIES.broadcast(0);
VectorMask<Byte> m = a.lt((byte) 1);
a.div(b, m);
Assert.fail();
} catch (ArithmeticException e) {
}
}
static byte ADD(byte a, byte b) {
return (byte)(a + b);
}
@Test(dataProvider = "byteBinaryOpProvider")
static void ADDByte256VectorTests(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
av.lanewise(VectorOperators.ADD, bv).intoArray(r, i);
}
}
assertArraysEquals(r, a, b, Byte256VectorTests::ADD);
}
static byte add(byte a, byte b) {
return (byte)(a + b);
}
@Test(dataProvider = "byteBinaryOpProvider")
static void addByte256VectorTests(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
av.add(bv).intoArray(r, i);
}
assertArraysEquals(r, a, b, Byte256VectorTests::add);
}
@Test(dataProvider = "byteBinaryOpMaskProvider")
static void ADDByte256VectorTestsMasked(IntFunction<byte[]> fa, IntFunction<byte[]> fb,
IntFunction<boolean[]> fm) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
boolean[] mask = fm.apply(SPECIES.length());
VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
av.lanewise(VectorOperators.ADD, bv, vmask).intoArray(r, i);
}
}
assertArraysEquals(r, a, b, mask, Byte256VectorTests::ADD);
}
@Test(dataProvider = "byteBinaryOpMaskProvider")
static void addByte256VectorTestsMasked(IntFunction<byte[]> fa, IntFunction<byte[]> fb,
IntFunction<boolean[]> fm) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
boolean[] mask = fm.apply(SPECIES.length());
VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
av.add(bv, vmask).intoArray(r, i);
}
assertArraysEquals(r, a, b, mask, Byte256VectorTests::add);
}
static byte SUB(byte a, byte b) {
return (byte)(a - b);
}
@Test(dataProvider = "byteBinaryOpProvider")
static void SUBByte256VectorTests(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
av.lanewise(VectorOperators.SUB, bv).intoArray(r, i);
}
}
assertArraysEquals(r, a, b, Byte256VectorTests::SUB);
}
static byte sub(byte a, byte b) {
return (byte)(a - b);
}
@Test(dataProvider = "byteBinaryOpProvider")
static void subByte256VectorTests(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
av.sub(bv).intoArray(r, i);
}
assertArraysEquals(r, a, b, Byte256VectorTests::sub);
}
@Test(dataProvider = "byteBinaryOpMaskProvider")
static void SUBByte256VectorTestsMasked(IntFunction<byte[]> fa, IntFunction<byte[]> fb,
IntFunction<boolean[]> fm) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
boolean[] mask = fm.apply(SPECIES.length());
VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
av.lanewise(VectorOperators.SUB, bv, vmask).intoArray(r, i);
}
}
assertArraysEquals(r, a, b, mask, Byte256VectorTests::SUB);
}
@Test(dataProvider = "byteBinaryOpMaskProvider")
static void subByte256VectorTestsMasked(IntFunction<byte[]> fa, IntFunction<byte[]> fb,
IntFunction<boolean[]> fm) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
boolean[] mask = fm.apply(SPECIES.length());
VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
av.sub(bv, vmask).intoArray(r, i);
}
assertArraysEquals(r, a, b, mask, Byte256VectorTests::sub);
}
static byte MUL(byte a, byte b) {
return (byte)(a * b);
}
@Test(dataProvider = "byteBinaryOpProvider")
static void MULByte256VectorTests(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
av.lanewise(VectorOperators.MUL, bv).intoArray(r, i);
}
}
assertArraysEquals(r, a, b, Byte256VectorTests::MUL);
}
static byte mul(byte a, byte b) {
return (byte)(a * b);
}
@Test(dataProvider = "byteBinaryOpProvider")
static void mulByte256VectorTests(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
av.mul(bv).intoArray(r, i);
}
assertArraysEquals(r, a, b, Byte256VectorTests::mul);
}
@Test(dataProvider = "byteBinaryOpMaskProvider")
static void MULByte256VectorTestsMasked(IntFunction<byte[]> fa, IntFunction<byte[]> fb,
IntFunction<boolean[]> fm) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
boolean[] mask = fm.apply(SPECIES.length());
VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
av.lanewise(VectorOperators.MUL, bv, vmask).intoArray(r, i);
}
}
assertArraysEquals(r, a, b, mask, Byte256VectorTests::MUL);
}
@Test(dataProvider = "byteBinaryOpMaskProvider")
static void mulByte256VectorTestsMasked(IntFunction<byte[]> fa, IntFunction<byte[]> fb,
IntFunction<boolean[]> fm) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
boolean[] mask = fm.apply(SPECIES.length());
VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
av.mul(bv, vmask).intoArray(r, i);
}
assertArraysEquals(r, a, b, mask, Byte256VectorTests::mul);
}
static byte DIV(byte a, byte b) {
return (byte)(a / b);
}
@Test(dataProvider = "byteBinaryOpProvider")
static void DIVByte256VectorTests(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
replaceZero(b, (byte) 1);
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
av.lanewise(VectorOperators.DIV, bv).intoArray(r, i);
}
}
assertArraysEquals(r, a, b, Byte256VectorTests::DIV);
}
static byte div(byte a, byte b) {
return (byte)(a / b);
}
@Test(dataProvider = "byteBinaryOpProvider")
static void divByte256VectorTests(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
replaceZero(b, (byte) 1);
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
av.div(bv).intoArray(r, i);
}
}
assertArraysEquals(r, a, b, Byte256VectorTests::div);
}
@Test(dataProvider = "byteBinaryOpMaskProvider")
static void DIVByte256VectorTestsMasked(IntFunction<byte[]> fa, IntFunction<byte[]> fb,
IntFunction<boolean[]> fm) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
boolean[] mask = fm.apply(SPECIES.length());
VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
replaceZero(b, mask, (byte) 1);
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
av.lanewise(VectorOperators.DIV, bv, vmask).intoArray(r, i);
}
}
assertArraysEquals(r, a, b, mask, Byte256VectorTests::DIV);
}
@Test(dataProvider = "byteBinaryOpMaskProvider")
static void divByte256VectorTestsMasked(IntFunction<byte[]> fa, IntFunction<byte[]> fb,
IntFunction<boolean[]> fm) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
boolean[] mask = fm.apply(SPECIES.length());
VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
replaceZero(b, mask, (byte) 1);
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
av.div(bv, vmask).intoArray(r, i);
}
}
assertArraysEquals(r, a, b, mask, Byte256VectorTests::div);
}
static byte FIRST_NONZERO(byte a, byte b) {
return (byte)((a)!=0?a:b);
}
@Test(dataProvider = "byteBinaryOpProvider")
static void FIRST_NONZEROByte256VectorTests(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
av.lanewise(VectorOperators.FIRST_NONZERO, bv).intoArray(r, i);
}
}
assertArraysEquals(r, a, b, Byte256VectorTests::FIRST_NONZERO);
}
@Test(dataProvider = "byteBinaryOpMaskProvider")
static void FIRST_NONZEROByte256VectorTestsMasked(IntFunction<byte[]> fa, IntFunction<byte[]> fb,
IntFunction<boolean[]> fm) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
boolean[] mask = fm.apply(SPECIES.length());
VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
av.lanewise(VectorOperators.FIRST_NONZERO, bv, vmask).intoArray(r, i);
}
}
assertArraysEquals(r, a, b, mask, Byte256VectorTests::FIRST_NONZERO);
}
static byte AND(byte a, byte b) {
return (byte)(a & b);
}
@Test(dataProvider = "byteBinaryOpProvider")
static void ANDByte256VectorTests(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
av.lanewise(VectorOperators.AND, bv).intoArray(r, i);
}
}
assertArraysEquals(r, a, b, Byte256VectorTests::AND);
}
static byte and(byte a, byte b) {
return (byte)(a & b);
}
@Test(dataProvider = "byteBinaryOpProvider")
static void andByte256VectorTests(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
av.and(bv).intoArray(r, i);
}
assertArraysEquals(r, a, b, Byte256VectorTests::and);
}
@Test(dataProvider = "byteBinaryOpMaskProvider")
static void ANDByte256VectorTestsMasked(IntFunction<byte[]> fa, IntFunction<byte[]> fb,
IntFunction<boolean[]> fm) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
boolean[] mask = fm.apply(SPECIES.length());
VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
av.lanewise(VectorOperators.AND, bv, vmask).intoArray(r, i);
}
}
assertArraysEquals(r, a, b, mask, Byte256VectorTests::AND);
}
static byte AND_NOT(byte a, byte b) {
return (byte)(a & ~b);
}
@Test(dataProvider = "byteBinaryOpProvider")
static void AND_NOTByte256VectorTests(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
av.lanewise(VectorOperators.AND_NOT, bv).intoArray(r, i);
}
}
assertArraysEquals(r, a, b, Byte256VectorTests::AND_NOT);
}
@Test(dataProvider = "byteBinaryOpMaskProvider")
static void AND_NOTByte256VectorTestsMasked(IntFunction<byte[]> fa, IntFunction<byte[]> fb,
IntFunction<boolean[]> fm) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
boolean[] mask = fm.apply(SPECIES.length());
VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
av.lanewise(VectorOperators.AND_NOT, bv, vmask).intoArray(r, i);
}
}
assertArraysEquals(r, a, b, mask, Byte256VectorTests::AND_NOT);
}
static byte OR(byte a, byte b) {
return (byte)(a | b);
}
@Test(dataProvider = "byteBinaryOpProvider")
static void ORByte256VectorTests(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
av.lanewise(VectorOperators.OR, bv).intoArray(r, i);
}
}
assertArraysEquals(r, a, b, Byte256VectorTests::OR);
}
static byte or(byte a, byte b) {
return (byte)(a | b);
}
@Test(dataProvider = "byteBinaryOpProvider")
static void orByte256VectorTests(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
av.or(bv).intoArray(r, i);
}
assertArraysEquals(r, a, b, Byte256VectorTests::or);
}
@Test(dataProvider = "byteBinaryOpMaskProvider")
static void ORByte256VectorTestsMasked(IntFunction<byte[]> fa, IntFunction<byte[]> fb,
IntFunction<boolean[]> fm) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
boolean[] mask = fm.apply(SPECIES.length());
VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
av.lanewise(VectorOperators.OR, bv, vmask).intoArray(r, i);
}
}
assertArraysEquals(r, a, b, mask, Byte256VectorTests::OR);
}
static byte XOR(byte a, byte b) {
return (byte)(a ^ b);
}
@Test(dataProvider = "byteBinaryOpProvider")
static void XORByte256VectorTests(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
av.lanewise(VectorOperators.XOR, bv).intoArray(r, i);
}
}
assertArraysEquals(r, a, b, Byte256VectorTests::XOR);
}
@Test(dataProvider = "byteBinaryOpMaskProvider")
static void XORByte256VectorTestsMasked(IntFunction<byte[]> fa, IntFunction<byte[]> fb,
IntFunction<boolean[]> fm) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
boolean[] mask = fm.apply(SPECIES.length());
VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
av.lanewise(VectorOperators.XOR, bv, vmask).intoArray(r, i);
}
}
assertArraysEquals(r, a, b, mask, Byte256VectorTests::XOR);
}
@Test(dataProvider = "byteBinaryOpProvider")
static void addByte256VectorTestsBroadcastSmokeTest(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
av.add(b[i]).intoArray(r, i);
}
assertBroadcastArraysEquals(r, a, b, Byte256VectorTests::add);
}
@Test(dataProvider = "byteBinaryOpMaskProvider")
static void addByte256VectorTestsBroadcastMaskedSmokeTest(IntFunction<byte[]> fa, IntFunction<byte[]> fb,
IntFunction<boolean[]> fm) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
boolean[] mask = fm.apply(SPECIES.length());
VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
av.add(b[i], vmask).intoArray(r, i);
}
assertBroadcastArraysEquals(r, a, b, mask, Byte256VectorTests::add);
}
@Test(dataProvider = "byteBinaryOpProvider")
static void subByte256VectorTestsBroadcastSmokeTest(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
av.sub(b[i]).intoArray(r, i);
}
assertBroadcastArraysEquals(r, a, b, Byte256VectorTests::sub);
}
@Test(dataProvider = "byteBinaryOpMaskProvider")
static void subByte256VectorTestsBroadcastMaskedSmokeTest(IntFunction<byte[]> fa, IntFunction<byte[]> fb,
IntFunction<boolean[]> fm) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
boolean[] mask = fm.apply(SPECIES.length());
VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
av.sub(b[i], vmask).intoArray(r, i);
}
assertBroadcastArraysEquals(r, a, b, mask, Byte256VectorTests::sub);
}
@Test(dataProvider = "byteBinaryOpProvider")
static void mulByte256VectorTestsBroadcastSmokeTest(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
av.mul(b[i]).intoArray(r, i);
}
assertBroadcastArraysEquals(r, a, b, Byte256VectorTests::mul);
}
@Test(dataProvider = "byteBinaryOpMaskProvider")
static void mulByte256VectorTestsBroadcastMaskedSmokeTest(IntFunction<byte[]> fa, IntFunction<byte[]> fb,
IntFunction<boolean[]> fm) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
boolean[] mask = fm.apply(SPECIES.length());
VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
av.mul(b[i], vmask).intoArray(r, i);
}
assertBroadcastArraysEquals(r, a, b, mask, Byte256VectorTests::mul);
}
@Test(dataProvider = "byteBinaryOpProvider")
static void divByte256VectorTestsBroadcastSmokeTest(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
replaceZero(b, (byte) 1);
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
av.div(b[i]).intoArray(r, i);
}
assertBroadcastArraysEquals(r, a, b, Byte256VectorTests::div);
}
@Test(dataProvider = "byteBinaryOpMaskProvider")
static void divByte256VectorTestsBroadcastMaskedSmokeTest(IntFunction<byte[]> fa, IntFunction<byte[]> fb,
IntFunction<boolean[]> fm) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
boolean[] mask = fm.apply(SPECIES.length());
VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
replaceZero(b, (byte) 1);
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
av.div(b[i], vmask).intoArray(r, i);
}
assertBroadcastArraysEquals(r, a, b, mask, Byte256VectorTests::div);
}
@Test(dataProvider = "byteBinaryOpProvider")
static void ORByte256VectorTestsBroadcastSmokeTest(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
av.lanewise(VectorOperators.OR, b[i]).intoArray(r, i);
}
assertBroadcastArraysEquals(r, a, b, Byte256VectorTests::OR);
}
@Test(dataProvider = "byteBinaryOpProvider")
static void orByte256VectorTestsBroadcastSmokeTest(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
av.or(b[i]).intoArray(r, i);
}
assertBroadcastArraysEquals(r, a, b, Byte256VectorTests::or);
}
@Test(dataProvider = "byteBinaryOpMaskProvider")
static void ORByte256VectorTestsBroadcastMaskedSmokeTest(IntFunction<byte[]> fa, IntFunction<byte[]> fb,
IntFunction<boolean[]> fm) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
boolean[] mask = fm.apply(SPECIES.length());
VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
av.lanewise(VectorOperators.OR, b[i], vmask).intoArray(r, i);
}
assertBroadcastArraysEquals(r, a, b, mask, Byte256VectorTests::OR);
}
@Test(dataProvider = "byteBinaryOpProvider")
static void ANDByte256VectorTestsBroadcastSmokeTest(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
av.lanewise(VectorOperators.AND, b[i]).intoArray(r, i);
}
assertBroadcastArraysEquals(r, a, b, Byte256VectorTests::AND);
}
@Test(dataProvider = "byteBinaryOpProvider")
static void andByte256VectorTestsBroadcastSmokeTest(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
av.and(b[i]).intoArray(r, i);
}
assertBroadcastArraysEquals(r, a, b, Byte256VectorTests::and);
}
@Test(dataProvider = "byteBinaryOpMaskProvider")
static void ANDByte256VectorTestsBroadcastMaskedSmokeTest(IntFunction<byte[]> fa, IntFunction<byte[]> fb,
IntFunction<boolean[]> fm) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
boolean[] mask = fm.apply(SPECIES.length());
VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
av.lanewise(VectorOperators.AND, b[i], vmask).intoArray(r, i);
}
assertBroadcastArraysEquals(r, a, b, mask, Byte256VectorTests::AND);
}
@Test(dataProvider = "byteBinaryOpProvider")
static void ORByte256VectorTestsBroadcastLongSmokeTest(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
av.lanewise(VectorOperators.OR, (long)b[i]).intoArray(r, i);
}
assertBroadcastLongArraysEquals(r, a, b, Byte256VectorTests::OR);
}
@Test(dataProvider = "byteBinaryOpMaskProvider")
static void ORByte256VectorTestsBroadcastMaskedLongSmokeTest(IntFunction<byte[]> fa, IntFunction<byte[]> fb,
IntFunction<boolean[]> fm) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
boolean[] mask = fm.apply(SPECIES.length());
VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
av.lanewise(VectorOperators.OR, (long)b[i], vmask).intoArray(r, i);
}
assertBroadcastLongArraysEquals(r, a, b, mask, Byte256VectorTests::OR);
}
@Test(dataProvider = "byteBinaryOpProvider")
static void ADDByte256VectorTestsBroadcastLongSmokeTest(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
av.lanewise(VectorOperators.ADD, (long)b[i]).intoArray(r, i);
}
assertBroadcastLongArraysEquals(r, a, b, Byte256VectorTests::ADD);
}
@Test(dataProvider = "byteBinaryOpMaskProvider")
static void ADDByte256VectorTestsBroadcastMaskedLongSmokeTest(IntFunction<byte[]> fa, IntFunction<byte[]> fb,
IntFunction<boolean[]> fm) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
boolean[] mask = fm.apply(SPECIES.length());
VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
av.lanewise(VectorOperators.ADD, (long)b[i], vmask).intoArray(r, i);
}
assertBroadcastLongArraysEquals(r, a, b, mask, Byte256VectorTests::ADD);
}
static byte LSHL(byte a, byte b) {
return (byte)((a << (b & 0x7)));
}
@Test(dataProvider = "byteBinaryOpProvider")
static void LSHLByte256VectorTests(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
av.lanewise(VectorOperators.LSHL, bv).intoArray(r, i);
}
}
assertArraysEquals(r, a, b, Byte256VectorTests::LSHL);
}
@Test(dataProvider = "byteBinaryOpMaskProvider")
static void LSHLByte256VectorTestsMasked(IntFunction<byte[]> fa, IntFunction<byte[]> fb,
IntFunction<boolean[]> fm) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
boolean[] mask = fm.apply(SPECIES.length());
VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
av.lanewise(VectorOperators.LSHL, bv, vmask).intoArray(r, i);
}
}
assertArraysEquals(r, a, b, mask, Byte256VectorTests::LSHL);
}
static byte ASHR(byte a, byte b) {
return (byte)((a >> (b & 0x7)));
}
@Test(dataProvider = "byteBinaryOpProvider")
static void ASHRByte256VectorTests(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
av.lanewise(VectorOperators.ASHR, bv).intoArray(r, i);
}
}
assertArraysEquals(r, a, b, Byte256VectorTests::ASHR);
}
@Test(dataProvider = "byteBinaryOpMaskProvider")
static void ASHRByte256VectorTestsMasked(IntFunction<byte[]> fa, IntFunction<byte[]> fb,
IntFunction<boolean[]> fm) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
boolean[] mask = fm.apply(SPECIES.length());
VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
av.lanewise(VectorOperators.ASHR, bv, vmask).intoArray(r, i);
}
}
assertArraysEquals(r, a, b, mask, Byte256VectorTests::ASHR);
}
static byte LSHR(byte a, byte b) {
return (byte)(((a & 0xFF) >>> (b & 0x7)));
}
@Test(dataProvider = "byteBinaryOpProvider")
static void LSHRByte256VectorTests(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
av.lanewise(VectorOperators.LSHR, bv).intoArray(r, i);
}
}
assertArraysEquals(r, a, b, Byte256VectorTests::LSHR);
}
@Test(dataProvider = "byteBinaryOpMaskProvider")
static void LSHRByte256VectorTestsMasked(IntFunction<byte[]> fa, IntFunction<byte[]> fb,
IntFunction<boolean[]> fm) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
boolean[] mask = fm.apply(SPECIES.length());
VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
av.lanewise(VectorOperators.LSHR, bv, vmask).intoArray(r, i);
}
}
assertArraysEquals(r, a, b, mask, Byte256VectorTests::LSHR);
}
static byte LSHL_unary(byte a, byte b) {
return (byte)((a << (b & 7)));
}
@Test(dataProvider = "byteBinaryOpProvider")
static void LSHLByte256VectorTestsShift(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
av.lanewise(VectorOperators.LSHL, (int)b[i]).intoArray(r, i);
}
}
assertShiftArraysEquals(r, a, b, Byte256VectorTests::LSHL_unary);
}
@Test(dataProvider = "byteBinaryOpMaskProvider")
static void LSHLByte256VectorTestsShift(IntFunction<byte[]> fa, IntFunction<byte[]> fb,
IntFunction<boolean[]> fm) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
boolean[] mask = fm.apply(SPECIES.length());
VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
av.lanewise(VectorOperators.LSHL, (int)b[i], vmask).intoArray(r, i);
}
}
assertShiftArraysEquals(r, a, b, mask, Byte256VectorTests::LSHL_unary);
}
static byte LSHR_unary(byte a, byte b) {
return (byte)(((a & 0xFF) >>> (b & 7)));
}
@Test(dataProvider = "byteBinaryOpProvider")
static void LSHRByte256VectorTestsShift(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
av.lanewise(VectorOperators.LSHR, (int)b[i]).intoArray(r, i);
}
}
assertShiftArraysEquals(r, a, b, Byte256VectorTests::LSHR_unary);
}
@Test(dataProvider = "byteBinaryOpMaskProvider")
static void LSHRByte256VectorTestsShift(IntFunction<byte[]> fa, IntFunction<byte[]> fb,
IntFunction<boolean[]> fm) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
boolean[] mask = fm.apply(SPECIES.length());
VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
av.lanewise(VectorOperators.LSHR, (int)b[i], vmask).intoArray(r, i);
}
}
assertShiftArraysEquals(r, a, b, mask, Byte256VectorTests::LSHR_unary);
}
static byte ASHR_unary(byte a, byte b) {
return (byte)((a >> (b & 7)));
}
@Test(dataProvider = "byteBinaryOpProvider")
static void ASHRByte256VectorTestsShift(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
av.lanewise(VectorOperators.ASHR, (int)b[i]).intoArray(r, i);
}
}
assertShiftArraysEquals(r, a, b, Byte256VectorTests::ASHR_unary);
}
@Test(dataProvider = "byteBinaryOpMaskProvider")
static void ASHRByte256VectorTestsShift(IntFunction<byte[]> fa, IntFunction<byte[]> fb,
IntFunction<boolean[]> fm) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
boolean[] mask = fm.apply(SPECIES.length());
VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
av.lanewise(VectorOperators.ASHR, (int)b[i], vmask).intoArray(r, i);
}
}
assertShiftArraysEquals(r, a, b, mask, Byte256VectorTests::ASHR_unary);
}
static byte MIN(byte a, byte b) {
return (byte)(Math.min(a, b));
}
@Test(dataProvider = "byteBinaryOpProvider")
static void MINByte256VectorTests(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
av.lanewise(VectorOperators.MIN, bv).intoArray(r, i);
}
}
assertArraysEquals(r, a, b, Byte256VectorTests::MIN);
}
static byte min(byte a, byte b) {
return (byte)(Math.min(a, b));
}
@Test(dataProvider = "byteBinaryOpProvider")
static void minByte256VectorTests(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
av.min(bv).intoArray(r, i);
}
assertArraysEquals(r, a, b, Byte256VectorTests::min);
}
static byte MAX(byte a, byte b) {
return (byte)(Math.max(a, b));
}
@Test(dataProvider = "byteBinaryOpProvider")
static void MAXByte256VectorTests(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
av.lanewise(VectorOperators.MAX, bv).intoArray(r, i);
}
}
assertArraysEquals(r, a, b, Byte256VectorTests::MAX);
}
static byte max(byte a, byte b) {
return (byte)(Math.max(a, b));
}
@Test(dataProvider = "byteBinaryOpProvider")
static void maxByte256VectorTests(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
av.max(bv).intoArray(r, i);
}
assertArraysEquals(r, a, b, Byte256VectorTests::max);
}
@Test(dataProvider = "byteBinaryOpProvider")
static void MINByte256VectorTestsBroadcastSmokeTest(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
av.lanewise(VectorOperators.MIN, b[i]).intoArray(r, i);
}
assertBroadcastArraysEquals(r, a, b, Byte256VectorTests::MIN);
}
@Test(dataProvider = "byteBinaryOpProvider")
static void minByte256VectorTestsBroadcastSmokeTest(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
av.min(b[i]).intoArray(r, i);
}
assertBroadcastArraysEquals(r, a, b, Byte256VectorTests::min);
}
@Test(dataProvider = "byteBinaryOpProvider")
static void MAXByte256VectorTestsBroadcastSmokeTest(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
av.lanewise(VectorOperators.MAX, b[i]).intoArray(r, i);
}
assertBroadcastArraysEquals(r, a, b, Byte256VectorTests::MAX);
}
@Test(dataProvider = "byteBinaryOpProvider")
static void maxByte256VectorTestsBroadcastSmokeTest(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
av.max(b[i]).intoArray(r, i);
}
assertBroadcastArraysEquals(r, a, b, Byte256VectorTests::max);
}
static byte ANDReduce(byte[] a, int idx) {
byte res = -1;
for (int i = idx; i < (idx + SPECIES.length()); i++) {
res &= a[i];
}
return res;
}
static byte ANDReduceAll(byte[] a) {
byte res = -1;
for (int i = 0; i < a.length; i += SPECIES.length()) {
res &= ANDReduce(a, i);
}
return res;
}
@Test(dataProvider = "byteUnaryOpProvider")
static void ANDReduceByte256VectorTests(IntFunction<byte[]> fa) {
byte[] a = fa.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
byte ra = -1;
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
r[i] = av.reduceLanes(VectorOperators.AND);
}
}
for (int ic = 0; ic < INVOC_COUNT; ic++) {
ra = -1;
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
ra &= av.reduceLanes(VectorOperators.AND);
}
}
assertReductionArraysEquals(r, ra, a,
Byte256VectorTests::ANDReduce, Byte256VectorTests::ANDReduceAll);
}
static byte ANDReduceMasked(byte[] a, int idx, boolean[] mask) {
byte res = -1;
for (int i = idx; i < (idx + SPECIES.length()); i++) {
if (mask[i % SPECIES.length()])
res &= a[i];
}
return res;
}
static byte ANDReduceAllMasked(byte[] a, boolean[] mask) {
byte res = -1;
for (int i = 0; i < a.length; i += SPECIES.length()) {
res &= ANDReduceMasked(a, i, mask);
}
return res;
}
@Test(dataProvider = "byteUnaryOpMaskProvider")
static void ANDReduceByte256VectorTestsMasked(IntFunction<byte[]> fa, IntFunction<boolean[]> fm) {
byte[] a = fa.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
boolean[] mask = fm.apply(SPECIES.length());
VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
byte ra = -1;
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
r[i] = av.reduceLanes(VectorOperators.AND, vmask);
}
}
for (int ic = 0; ic < INVOC_COUNT; ic++) {
ra = -1;
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
ra &= av.reduceLanes(VectorOperators.AND, vmask);
}
}
assertReductionArraysEqualsMasked(r, ra, a, mask,
Byte256VectorTests::ANDReduceMasked, Byte256VectorTests::ANDReduceAllMasked);
}
static byte ORReduce(byte[] a, int idx) {
byte res = 0;
for (int i = idx; i < (idx + SPECIES.length()); i++) {
res |= a[i];
}
return res;
}
static byte ORReduceAll(byte[] a) {
byte res = 0;
for (int i = 0; i < a.length; i += SPECIES.length()) {
res |= ORReduce(a, i);
}
return res;
}
@Test(dataProvider = "byteUnaryOpProvider")
static void ORReduceByte256VectorTests(IntFunction<byte[]> fa) {
byte[] a = fa.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
byte ra = 0;
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
r[i] = av.reduceLanes(VectorOperators.OR);
}
}
for (int ic = 0; ic < INVOC_COUNT; ic++) {
ra = 0;
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
ra |= av.reduceLanes(VectorOperators.OR);
}
}
assertReductionArraysEquals(r, ra, a,
Byte256VectorTests::ORReduce, Byte256VectorTests::ORReduceAll);
}
static byte ORReduceMasked(byte[] a, int idx, boolean[] mask) {
byte res = 0;
for (int i = idx; i < (idx + SPECIES.length()); i++) {
if (mask[i % SPECIES.length()])
res |= a[i];
}
return res;
}
static byte ORReduceAllMasked(byte[] a, boolean[] mask) {
byte res = 0;
for (int i = 0; i < a.length; i += SPECIES.length()) {
res |= ORReduceMasked(a, i, mask);
}
return res;
}
@Test(dataProvider = "byteUnaryOpMaskProvider")
static void ORReduceByte256VectorTestsMasked(IntFunction<byte[]> fa, IntFunction<boolean[]> fm) {
byte[] a = fa.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
boolean[] mask = fm.apply(SPECIES.length());
VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
byte ra = 0;
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
r[i] = av.reduceLanes(VectorOperators.OR, vmask);
}
}
for (int ic = 0; ic < INVOC_COUNT; ic++) {
ra = 0;
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
ra |= av.reduceLanes(VectorOperators.OR, vmask);
}
}
assertReductionArraysEqualsMasked(r, ra, a, mask,
Byte256VectorTests::ORReduceMasked, Byte256VectorTests::ORReduceAllMasked);
}
static byte XORReduce(byte[] a, int idx) {
byte res = 0;
for (int i = idx; i < (idx + SPECIES.length()); i++) {
res ^= a[i];
}
return res;
}
static byte XORReduceAll(byte[] a) {
byte res = 0;
for (int i = 0; i < a.length; i += SPECIES.length()) {
res ^= XORReduce(a, i);
}
return res;
}
@Test(dataProvider = "byteUnaryOpProvider")
static void XORReduceByte256VectorTests(IntFunction<byte[]> fa) {
byte[] a = fa.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
byte ra = 0;
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
r[i] = av.reduceLanes(VectorOperators.XOR);
}
}
for (int ic = 0; ic < INVOC_COUNT; ic++) {
ra = 0;
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
ra ^= av.reduceLanes(VectorOperators.XOR);
}
}
assertReductionArraysEquals(r, ra, a,
Byte256VectorTests::XORReduce, Byte256VectorTests::XORReduceAll);
}
static byte XORReduceMasked(byte[] a, int idx, boolean[] mask) {
byte res = 0;
for (int i = idx; i < (idx + SPECIES.length()); i++) {
if (mask[i % SPECIES.length()])
res ^= a[i];
}
return res;
}
static byte XORReduceAllMasked(byte[] a, boolean[] mask) {
byte res = 0;
for (int i = 0; i < a.length; i += SPECIES.length()) {
res ^= XORReduceMasked(a, i, mask);
}
return res;
}
@Test(dataProvider = "byteUnaryOpMaskProvider")
static void XORReduceByte256VectorTestsMasked(IntFunction<byte[]> fa, IntFunction<boolean[]> fm) {
byte[] a = fa.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
boolean[] mask = fm.apply(SPECIES.length());
VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
byte ra = 0;
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
r[i] = av.reduceLanes(VectorOperators.XOR, vmask);
}
}
for (int ic = 0; ic < INVOC_COUNT; ic++) {
ra = 0;
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
ra ^= av.reduceLanes(VectorOperators.XOR, vmask);
}
}
assertReductionArraysEqualsMasked(r, ra, a, mask,
Byte256VectorTests::XORReduceMasked, Byte256VectorTests::XORReduceAllMasked);
}
static byte ADDReduce(byte[] a, int idx) {
byte res = 0;
for (int i = idx; i < (idx + SPECIES.length()); i++) {
res += a[i];
}
return res;
}
static byte ADDReduceAll(byte[] a) {
byte res = 0;
for (int i = 0; i < a.length; i += SPECIES.length()) {
res += ADDReduce(a, i);
}
return res;
}
@Test(dataProvider = "byteUnaryOpProvider")
static void ADDReduceByte256VectorTests(IntFunction<byte[]> fa) {
byte[] a = fa.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
byte ra = 0;
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
r[i] = av.reduceLanes(VectorOperators.ADD);
}
}
for (int ic = 0; ic < INVOC_COUNT; ic++) {
ra = 0;
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
ra += av.reduceLanes(VectorOperators.ADD);
}
}
assertReductionArraysEquals(r, ra, a,
Byte256VectorTests::ADDReduce, Byte256VectorTests::ADDReduceAll);
}
static byte ADDReduceMasked(byte[] a, int idx, boolean[] mask) {
byte res = 0;
for (int i = idx; i < (idx + SPECIES.length()); i++) {
if (mask[i % SPECIES.length()])
res += a[i];
}
return res;
}
static byte ADDReduceAllMasked(byte[] a, boolean[] mask) {
byte res = 0;
for (int i = 0; i < a.length; i += SPECIES.length()) {
res += ADDReduceMasked(a, i, mask);
}
return res;
}
@Test(dataProvider = "byteUnaryOpMaskProvider")
static void ADDReduceByte256VectorTestsMasked(IntFunction<byte[]> fa, IntFunction<boolean[]> fm) {
byte[] a = fa.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
boolean[] mask = fm.apply(SPECIES.length());
VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
byte ra = 0;
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
r[i] = av.reduceLanes(VectorOperators.ADD, vmask);
}
}
for (int ic = 0; ic < INVOC_COUNT; ic++) {
ra = 0;
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
ra += av.reduceLanes(VectorOperators.ADD, vmask);
}
}
assertReductionArraysEqualsMasked(r, ra, a, mask,
Byte256VectorTests::ADDReduceMasked, Byte256VectorTests::ADDReduceAllMasked);
}
static byte MULReduce(byte[] a, int idx) {
byte res = 1;
for (int i = idx; i < (idx + SPECIES.length()); i++) {
res *= a[i];
}
return res;
}
static byte MULReduceAll(byte[] a) {
byte res = 1;
for (int i = 0; i < a.length; i += SPECIES.length()) {
res *= MULReduce(a, i);
}
return res;
}
@Test(dataProvider = "byteUnaryOpProvider")
static void MULReduceByte256VectorTests(IntFunction<byte[]> fa) {
byte[] a = fa.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
byte ra = 1;
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
r[i] = av.reduceLanes(VectorOperators.MUL);
}
}
for (int ic = 0; ic < INVOC_COUNT; ic++) {
ra = 1;
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
ra *= av.reduceLanes(VectorOperators.MUL);
}
}
assertReductionArraysEquals(r, ra, a,
Byte256VectorTests::MULReduce, Byte256VectorTests::MULReduceAll);
}
static byte MULReduceMasked(byte[] a, int idx, boolean[] mask) {
byte res = 1;
for (int i = idx; i < (idx + SPECIES.length()); i++) {
if (mask[i % SPECIES.length()])
res *= a[i];
}
return res;
}
static byte MULReduceAllMasked(byte[] a, boolean[] mask) {
byte res = 1;
for (int i = 0; i < a.length; i += SPECIES.length()) {
res *= MULReduceMasked(a, i, mask);
}
return res;
}
@Test(dataProvider = "byteUnaryOpMaskProvider")
static void MULReduceByte256VectorTestsMasked(IntFunction<byte[]> fa, IntFunction<boolean[]> fm) {
byte[] a = fa.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
boolean[] mask = fm.apply(SPECIES.length());
VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
byte ra = 1;
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
r[i] = av.reduceLanes(VectorOperators.MUL, vmask);
}
}
for (int ic = 0; ic < INVOC_COUNT; ic++) {
ra = 1;
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
ra *= av.reduceLanes(VectorOperators.MUL, vmask);
}
}
assertReductionArraysEqualsMasked(r, ra, a, mask,
Byte256VectorTests::MULReduceMasked, Byte256VectorTests::MULReduceAllMasked);
}
static byte MINReduce(byte[] a, int idx) {
byte res = Byte.MAX_VALUE;
for (int i = idx; i < (idx + SPECIES.length()); i++) {
res = (byte)Math.min(res, a[i]);
}
return res;
}
static byte MINReduceAll(byte[] a) {
byte res = Byte.MAX_VALUE;
for (int i = 0; i < a.length; i++) {
res = (byte)Math.min(res, a[i]);
}
return res;
}
@Test(dataProvider = "byteUnaryOpProvider")
static void MINReduceByte256VectorTests(IntFunction<byte[]> fa) {
byte[] a = fa.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
byte ra = Byte.MAX_VALUE;
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
r[i] = av.reduceLanes(VectorOperators.MIN);
}
}
for (int ic = 0; ic < INVOC_COUNT; ic++) {
ra = Byte.MAX_VALUE;
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
ra = (byte)Math.min(ra, av.reduceLanes(VectorOperators.MIN));
}
}
assertReductionArraysEquals(r, ra, a,
Byte256VectorTests::MINReduce, Byte256VectorTests::MINReduceAll);
}
static byte MINReduceMasked(byte[] a, int idx, boolean[] mask) {
byte res = Byte.MAX_VALUE;
for (int i = idx; i < (idx + SPECIES.length()); i++) {
if(mask[i % SPECIES.length()])
res = (byte)Math.min(res, a[i]);
}
return res;
}
static byte MINReduceAllMasked(byte[] a, boolean[] mask) {
byte res = Byte.MAX_VALUE;
for (int i = 0; i < a.length; i++) {
if(mask[i % SPECIES.length()])
res = (byte)Math.min(res, a[i]);
}
return res;
}
@Test(dataProvider = "byteUnaryOpMaskProvider")
static void MINReduceByte256VectorTestsMasked(IntFunction<byte[]> fa, IntFunction<boolean[]> fm) {
byte[] a = fa.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
boolean[] mask = fm.apply(SPECIES.length());
VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
byte ra = Byte.MAX_VALUE;
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
r[i] = av.reduceLanes(VectorOperators.MIN, vmask);
}
}
for (int ic = 0; ic < INVOC_COUNT; ic++) {
ra = Byte.MAX_VALUE;
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
ra = (byte)Math.min(ra, av.reduceLanes(VectorOperators.MIN, vmask));
}
}
assertReductionArraysEqualsMasked(r, ra, a, mask,
Byte256VectorTests::MINReduceMasked, Byte256VectorTests::MINReduceAllMasked);
}
static byte MAXReduce(byte[] a, int idx) {
byte res = Byte.MIN_VALUE;
for (int i = idx; i < (idx + SPECIES.length()); i++) {
res = (byte)Math.max(res, a[i]);
}
return res;
}
static byte MAXReduceAll(byte[] a) {
byte res = Byte.MIN_VALUE;
for (int i = 0; i < a.length; i++) {
res = (byte)Math.max(res, a[i]);
}
return res;
}
@Test(dataProvider = "byteUnaryOpProvider")
static void MAXReduceByte256VectorTests(IntFunction<byte[]> fa) {
byte[] a = fa.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
byte ra = Byte.MIN_VALUE;
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
r[i] = av.reduceLanes(VectorOperators.MAX);
}
}
for (int ic = 0; ic < INVOC_COUNT; ic++) {
ra = Byte.MIN_VALUE;
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
ra = (byte)Math.max(ra, av.reduceLanes(VectorOperators.MAX));
}
}
assertReductionArraysEquals(r, ra, a,
Byte256VectorTests::MAXReduce, Byte256VectorTests::MAXReduceAll);
}
static byte MAXReduceMasked(byte[] a, int idx, boolean[] mask) {
byte res = Byte.MIN_VALUE;
for (int i = idx; i < (idx + SPECIES.length()); i++) {
if(mask[i % SPECIES.length()])
res = (byte)Math.max(res, a[i]);
}
return res;
}
static byte MAXReduceAllMasked(byte[] a, boolean[] mask) {
byte res = Byte.MIN_VALUE;
for (int i = 0; i < a.length; i++) {
if(mask[i % SPECIES.length()])
res = (byte)Math.max(res, a[i]);
}
return res;
}
@Test(dataProvider = "byteUnaryOpMaskProvider")
static void MAXReduceByte256VectorTestsMasked(IntFunction<byte[]> fa, IntFunction<boolean[]> fm) {
byte[] a = fa.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
boolean[] mask = fm.apply(SPECIES.length());
VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
byte ra = Byte.MIN_VALUE;
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
r[i] = av.reduceLanes(VectorOperators.MAX, vmask);
}
}
for (int ic = 0; ic < INVOC_COUNT; ic++) {
ra = Byte.MIN_VALUE;
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
ra = (byte)Math.max(ra, av.reduceLanes(VectorOperators.MAX, vmask));
}
}
assertReductionArraysEqualsMasked(r, ra, a, mask,
Byte256VectorTests::MAXReduceMasked, Byte256VectorTests::MAXReduceAllMasked);
}
static boolean anyTrue(boolean[] a, int idx) {
boolean res = false;
for (int i = idx; i < (idx + SPECIES.length()); i++) {
res |= a[i];
}
return res;
}
@Test(dataProvider = "boolUnaryOpProvider")
static void anyTrueByte256VectorTests(IntFunction<boolean[]> fm) {
boolean[] mask = fm.apply(SPECIES.length());
boolean[] r = fmr.apply(SPECIES.length());
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < mask.length; i += SPECIES.length()) {
VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, i);
r[i] = vmask.anyTrue();
}
}
assertReductionBoolArraysEquals(r, mask, Byte256VectorTests::anyTrue);
}
static boolean allTrue(boolean[] a, int idx) {
boolean res = true;
for (int i = idx; i < (idx + SPECIES.length()); i++) {
res &= a[i];
}
return res;
}
@Test(dataProvider = "boolUnaryOpProvider")
static void allTrueByte256VectorTests(IntFunction<boolean[]> fm) {
boolean[] mask = fm.apply(SPECIES.length());
boolean[] r = fmr.apply(SPECIES.length());
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < mask.length; i += SPECIES.length()) {
VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, i);
r[i] = vmask.allTrue();
}
}
assertReductionBoolArraysEquals(r, mask, Byte256VectorTests::allTrue);
}
@Test(dataProvider = "byteUnaryOpProvider")
static void withByte256VectorTests(IntFunction<byte []> fa) {
byte[] a = fa.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
av.withLane(0, (byte)4).intoArray(r, i);
}
}
assertInsertArraysEquals(r, a, (byte)4, 0);
}
static boolean testIS_DEFAULT(byte a) {
return bits(a)==0;
}
@Test(dataProvider = "byteTestOpProvider")
static void IS_DEFAULTByte256VectorTests(IntFunction<byte[]> fa) {
byte[] a = fa.apply(SPECIES.length());
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
VectorMask<Byte> mv = av.test(VectorOperators.IS_DEFAULT);
// Check results as part of computation.
for (int j = 0; j < SPECIES.length(); j++) {
Assert.assertEquals(mv.laneIsSet(j), testIS_DEFAULT(a[i + j]));
}
}
}
}
@Test(dataProvider = "byteTestOpMaskProvider")
static void IS_DEFAULTMaskedByte256VectorTestsSmokeTest(IntFunction<byte[]> fa,
IntFunction<boolean[]> fm) {
byte[] a = fa.apply(SPECIES.length());
boolean[] mask = fm.apply(SPECIES.length());
VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
VectorMask<Byte> mv = av.test(VectorOperators.IS_DEFAULT, vmask);
// Check results as part of computation.
for (int j = 0; j < SPECIES.length(); j++) {
Assert.assertEquals(mv.laneIsSet(j), vmask.laneIsSet(j) && testIS_DEFAULT(a[i + j]));
}
}
}
static boolean testIS_NEGATIVE(byte a) {
return bits(a)<0;
}
@Test(dataProvider = "byteTestOpProvider")
static void IS_NEGATIVEByte256VectorTests(IntFunction<byte[]> fa) {
byte[] a = fa.apply(SPECIES.length());
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
VectorMask<Byte> mv = av.test(VectorOperators.IS_NEGATIVE);
// Check results as part of computation.
for (int j = 0; j < SPECIES.length(); j++) {
Assert.assertEquals(mv.laneIsSet(j), testIS_NEGATIVE(a[i + j]));
}
}
}
}
@Test(dataProvider = "byteTestOpMaskProvider")
static void IS_NEGATIVEMaskedByte256VectorTestsSmokeTest(IntFunction<byte[]> fa,
IntFunction<boolean[]> fm) {
byte[] a = fa.apply(SPECIES.length());
boolean[] mask = fm.apply(SPECIES.length());
VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
VectorMask<Byte> mv = av.test(VectorOperators.IS_NEGATIVE, vmask);
// Check results as part of computation.
for (int j = 0; j < SPECIES.length(); j++) {
Assert.assertEquals(mv.laneIsSet(j), vmask.laneIsSet(j) && testIS_NEGATIVE(a[i + j]));
}
}
}
@Test(dataProvider = "byteCompareOpProvider")
static void LTByte256VectorTests(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
VectorMask<Byte> mv = av.compare(VectorOperators.LT, bv);
// Check results as part of computation.
for (int j = 0; j < SPECIES.length(); j++) {
Assert.assertEquals(mv.laneIsSet(j), a[i + j] < b[i + j]);
}
}
}
}
@Test(dataProvider = "byteCompareOpProvider")
static void ltByte256VectorTests(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
VectorMask<Byte> mv = av.lt(bv);
// Check results as part of computation.
for (int j = 0; j < SPECIES.length(); j++) {
Assert.assertEquals(mv.laneIsSet(j), a[i + j] < b[i + j]);
}
}
}
}
@Test(dataProvider = "byteCompareOpMaskProvider")
static void LTByte256VectorTestsMasked(IntFunction<byte[]> fa, IntFunction<byte[]> fb,
IntFunction<boolean[]> fm) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
boolean[] mask = fm.apply(SPECIES.length());
VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
VectorMask<Byte> mv = av.compare(VectorOperators.LT, bv, vmask);
// Check results as part of computation.
for (int j = 0; j < SPECIES.length(); j++) {
Assert.assertEquals(mv.laneIsSet(j), mask[j] && (a[i + j] < b[i + j]));
}
}
}
}
@Test(dataProvider = "byteCompareOpProvider")
static void GTByte256VectorTests(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
VectorMask<Byte> mv = av.compare(VectorOperators.GT, bv);
// Check results as part of computation.
for (int j = 0; j < SPECIES.length(); j++) {
Assert.assertEquals(mv.laneIsSet(j), a[i + j] > b[i + j]);
}
}
}
}
@Test(dataProvider = "byteCompareOpMaskProvider")
static void GTByte256VectorTestsMasked(IntFunction<byte[]> fa, IntFunction<byte[]> fb,
IntFunction<boolean[]> fm) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
boolean[] mask = fm.apply(SPECIES.length());
VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
VectorMask<Byte> mv = av.compare(VectorOperators.GT, bv, vmask);
// Check results as part of computation.
for (int j = 0; j < SPECIES.length(); j++) {
Assert.assertEquals(mv.laneIsSet(j), mask[j] && (a[i + j] > b[i + j]));
}
}
}
}
@Test(dataProvider = "byteCompareOpProvider")
static void EQByte256VectorTests(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
VectorMask<Byte> mv = av.compare(VectorOperators.EQ, bv);
// Check results as part of computation.
for (int j = 0; j < SPECIES.length(); j++) {
Assert.assertEquals(mv.laneIsSet(j), a[i + j] == b[i + j]);
}
}
}
}
@Test(dataProvider = "byteCompareOpProvider")
static void eqByte256VectorTests(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
VectorMask<Byte> mv = av.eq(bv);
// Check results as part of computation.
for (int j = 0; j < SPECIES.length(); j++) {
Assert.assertEquals(mv.laneIsSet(j), a[i + j] == b[i + j]);
}
}
}
}
@Test(dataProvider = "byteCompareOpMaskProvider")
static void EQByte256VectorTestsMasked(IntFunction<byte[]> fa, IntFunction<byte[]> fb,
IntFunction<boolean[]> fm) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
boolean[] mask = fm.apply(SPECIES.length());
VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
VectorMask<Byte> mv = av.compare(VectorOperators.EQ, bv, vmask);
// Check results as part of computation.
for (int j = 0; j < SPECIES.length(); j++) {
Assert.assertEquals(mv.laneIsSet(j), mask[j] && (a[i + j] == b[i + j]));
}
}
}
}
@Test(dataProvider = "byteCompareOpProvider")
static void NEByte256VectorTests(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
VectorMask<Byte> mv = av.compare(VectorOperators.NE, bv);
// Check results as part of computation.
for (int j = 0; j < SPECIES.length(); j++) {
Assert.assertEquals(mv.laneIsSet(j), a[i + j] != b[i + j]);
}
}
}
}
@Test(dataProvider = "byteCompareOpMaskProvider")
static void NEByte256VectorTestsMasked(IntFunction<byte[]> fa, IntFunction<byte[]> fb,
IntFunction<boolean[]> fm) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
boolean[] mask = fm.apply(SPECIES.length());
VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
VectorMask<Byte> mv = av.compare(VectorOperators.NE, bv, vmask);
// Check results as part of computation.
for (int j = 0; j < SPECIES.length(); j++) {
Assert.assertEquals(mv.laneIsSet(j), mask[j] && (a[i + j] != b[i + j]));
}
}
}
}
@Test(dataProvider = "byteCompareOpProvider")
static void LEByte256VectorTests(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
VectorMask<Byte> mv = av.compare(VectorOperators.LE, bv);
// Check results as part of computation.
for (int j = 0; j < SPECIES.length(); j++) {
Assert.assertEquals(mv.laneIsSet(j), a[i + j] <= b[i + j]);
}
}
}
}
@Test(dataProvider = "byteCompareOpMaskProvider")
static void LEByte256VectorTestsMasked(IntFunction<byte[]> fa, IntFunction<byte[]> fb,
IntFunction<boolean[]> fm) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
boolean[] mask = fm.apply(SPECIES.length());
VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
VectorMask<Byte> mv = av.compare(VectorOperators.LE, bv, vmask);
// Check results as part of computation.
for (int j = 0; j < SPECIES.length(); j++) {
Assert.assertEquals(mv.laneIsSet(j), mask[j] && (a[i + j] <= b[i + j]));
}
}
}
}
@Test(dataProvider = "byteCompareOpProvider")
static void GEByte256VectorTests(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
VectorMask<Byte> mv = av.compare(VectorOperators.GE, bv);
// Check results as part of computation.
for (int j = 0; j < SPECIES.length(); j++) {
Assert.assertEquals(mv.laneIsSet(j), a[i + j] >= b[i + j]);
}
}
}
}
@Test(dataProvider = "byteCompareOpMaskProvider")
static void GEByte256VectorTestsMasked(IntFunction<byte[]> fa, IntFunction<byte[]> fb,
IntFunction<boolean[]> fm) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
boolean[] mask = fm.apply(SPECIES.length());
VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
VectorMask<Byte> mv = av.compare(VectorOperators.GE, bv, vmask);
// Check results as part of computation.
for (int j = 0; j < SPECIES.length(); j++) {
Assert.assertEquals(mv.laneIsSet(j), mask[j] && (a[i + j] >= b[i + j]));
}
}
}
}
@Test(dataProvider = "byteCompareOpProvider")
static void LTByte256VectorTestsBroadcastSmokeTest(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
VectorMask<Byte> mv = av.compare(VectorOperators.LT, b[i]);
// Check results as part of computation.
for (int j = 0; j < SPECIES.length(); j++) {
Assert.assertEquals(mv.laneIsSet(j), a[i + j] < b[i]);
}
}
}
@Test(dataProvider = "byteCompareOpMaskProvider")
static void LTByte256VectorTestsBroadcastMaskedSmokeTest(IntFunction<byte[]> fa,
IntFunction<byte[]> fb, IntFunction<boolean[]> fm) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
boolean[] mask = fm.apply(SPECIES.length());
VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
VectorMask<Byte> mv = av.compare(VectorOperators.LT, b[i], vmask);
// Check results as part of computation.
for (int j = 0; j < SPECIES.length(); j++) {
Assert.assertEquals(mv.laneIsSet(j), mask[j] && (a[i + j] < b[i]));
}
}
}
@Test(dataProvider = "byteCompareOpProvider")
static void LTByte256VectorTestsBroadcastLongSmokeTest(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
VectorMask<Byte> mv = av.compare(VectorOperators.LT, (long)b[i]);
// Check results as part of computation.
for (int j = 0; j < SPECIES.length(); j++) {
Assert.assertEquals(mv.laneIsSet(j), a[i + j] < (byte)((long)b[i]));
}
}
}
@Test(dataProvider = "byteCompareOpMaskProvider")
static void LTByte256VectorTestsBroadcastLongMaskedSmokeTest(IntFunction<byte[]> fa,
IntFunction<byte[]> fb, IntFunction<boolean[]> fm) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
boolean[] mask = fm.apply(SPECIES.length());
VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
VectorMask<Byte> mv = av.compare(VectorOperators.LT, (long)b[i], vmask);
// Check results as part of computation.
for (int j = 0; j < SPECIES.length(); j++) {
Assert.assertEquals(mv.laneIsSet(j), mask[j] && (a[i + j] < (byte)((long)b[i])));
}
}
}
@Test(dataProvider = "byteCompareOpProvider")
static void EQByte256VectorTestsBroadcastSmokeTest(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
VectorMask<Byte> mv = av.compare(VectorOperators.EQ, b[i]);
// Check results as part of computation.
for (int j = 0; j < SPECIES.length(); j++) {
Assert.assertEquals(mv.laneIsSet(j), a[i + j] == b[i]);
}
}
}
@Test(dataProvider = "byteCompareOpMaskProvider")
static void EQByte256VectorTestsBroadcastMaskedSmokeTest(IntFunction<byte[]> fa,
IntFunction<byte[]> fb, IntFunction<boolean[]> fm) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
boolean[] mask = fm.apply(SPECIES.length());
VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
VectorMask<Byte> mv = av.compare(VectorOperators.EQ, b[i], vmask);
// Check results as part of computation.
for (int j = 0; j < SPECIES.length(); j++) {
Assert.assertEquals(mv.laneIsSet(j), mask[j] && (a[i + j] == b[i]));
}
}
}
@Test(dataProvider = "byteCompareOpProvider")
static void EQByte256VectorTestsBroadcastLongSmokeTest(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
VectorMask<Byte> mv = av.compare(VectorOperators.EQ, (long)b[i]);
// Check results as part of computation.
for (int j = 0; j < SPECIES.length(); j++) {
Assert.assertEquals(mv.laneIsSet(j), a[i + j] == (byte)((long)b[i]));
}
}
}
@Test(dataProvider = "byteCompareOpMaskProvider")
static void EQByte256VectorTestsBroadcastLongMaskedSmokeTest(IntFunction<byte[]> fa,
IntFunction<byte[]> fb, IntFunction<boolean[]> fm) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
boolean[] mask = fm.apply(SPECIES.length());
VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
VectorMask<Byte> mv = av.compare(VectorOperators.EQ, (long)b[i], vmask);
// Check results as part of computation.
for (int j = 0; j < SPECIES.length(); j++) {
Assert.assertEquals(mv.laneIsSet(j), mask[j] && (a[i + j] == (byte)((long)b[i])));
}
}
}
static byte blend(byte a, byte b, boolean mask) {
return mask ? b : a;
}
@Test(dataProvider = "byteBinaryOpMaskProvider")
static void blendByte256VectorTests(IntFunction<byte[]> fa, IntFunction<byte[]> fb,
IntFunction<boolean[]> fm) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
boolean[] mask = fm.apply(SPECIES.length());
VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
av.blend(bv, vmask).intoArray(r, i);
}
}
assertArraysEquals(r, a, b, mask, Byte256VectorTests::blend);
}
@Test(dataProvider = "byteUnaryOpShuffleProvider")
static void RearrangeByte256VectorTests(IntFunction<byte[]> fa,
BiFunction<Integer,Integer,int[]> fs) {
byte[] a = fa.apply(SPECIES.length());
int[] order = fs.apply(a.length, SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
av.rearrange(VectorShuffle.fromArray(SPECIES, order, i)).intoArray(r, i);
}
}
assertRearrangeArraysEquals(r, a, order, SPECIES.length());
}
@Test(dataProvider = "byteUnaryOpShuffleMaskProvider")
static void RearrangeByte256VectorTestsMaskedSmokeTest(IntFunction<byte[]> fa,
BiFunction<Integer,Integer,int[]> fs,
IntFunction<boolean[]> fm) {
byte[] a = fa.apply(SPECIES.length());
int[] order = fs.apply(a.length, SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
boolean[] mask = fm.apply(SPECIES.length());
VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
av.rearrange(VectorShuffle.fromArray(SPECIES, order, i), vmask).intoArray(r, i);
}
assertRearrangeArraysEquals(r, a, order, mask, SPECIES.length());
}
@Test(dataProvider = "byteUnaryOpProvider")
static void getByte256VectorTests(IntFunction<byte[]> fa) {
byte[] a = fa.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
int num_lanes = SPECIES.length();
// Manually unroll because full unroll happens after intrinsification.
// Unroll is needed because get intrinsic requires for index to be a known constant.
if (num_lanes == 1) {
r[i]=av.lane(0);
} else if (num_lanes == 2) {
r[i]=av.lane(0);
r[i+1]=av.lane(1);
} else if (num_lanes == 4) {
r[i]=av.lane(0);
r[i+1]=av.lane(1);
r[i+2]=av.lane(2);
r[i+3]=av.lane(3);
} else if (num_lanes == 8) {
r[i]=av.lane(0);
r[i+1]=av.lane(1);
r[i+2]=av.lane(2);
r[i+3]=av.lane(3);
r[i+4]=av.lane(4);
r[i+5]=av.lane(5);
r[i+6]=av.lane(6);
r[i+7]=av.lane(7);
} else if (num_lanes == 16) {
r[i]=av.lane(0);
r[i+1]=av.lane(1);
r[i+2]=av.lane(2);
r[i+3]=av.lane(3);
r[i+4]=av.lane(4);
r[i+5]=av.lane(5);
r[i+6]=av.lane(6);
r[i+7]=av.lane(7);
r[i+8]=av.lane(8);
r[i+9]=av.lane(9);
r[i+10]=av.lane(10);
r[i+11]=av.lane(11);
r[i+12]=av.lane(12);
r[i+13]=av.lane(13);
r[i+14]=av.lane(14);
r[i+15]=av.lane(15);
} else if (num_lanes == 32) {
r[i]=av.lane(0);
r[i+1]=av.lane(1);
r[i+2]=av.lane(2);
r[i+3]=av.lane(3);
r[i+4]=av.lane(4);
r[i+5]=av.lane(5);
r[i+6]=av.lane(6);
r[i+7]=av.lane(7);
r[i+8]=av.lane(8);
r[i+9]=av.lane(9);
r[i+10]=av.lane(10);
r[i+11]=av.lane(11);
r[i+12]=av.lane(12);
r[i+13]=av.lane(13);
r[i+14]=av.lane(14);
r[i+15]=av.lane(15);
r[i+16]=av.lane(16);
r[i+17]=av.lane(17);
r[i+18]=av.lane(18);
r[i+19]=av.lane(19);
r[i+20]=av.lane(20);
r[i+21]=av.lane(21);
r[i+22]=av.lane(22);
r[i+23]=av.lane(23);
r[i+24]=av.lane(24);
r[i+25]=av.lane(25);
r[i+26]=av.lane(26);
r[i+27]=av.lane(27);
r[i+28]=av.lane(28);
r[i+29]=av.lane(29);
r[i+30]=av.lane(30);
r[i+31]=av.lane(31);
} else if (num_lanes == 64) {
r[i]=av.lane(0);
r[i+1]=av.lane(1);
r[i+2]=av.lane(2);
r[i+3]=av.lane(3);
r[i+4]=av.lane(4);
r[i+5]=av.lane(5);
r[i+6]=av.lane(6);
r[i+7]=av.lane(7);
r[i+8]=av.lane(8);
r[i+9]=av.lane(9);
r[i+10]=av.lane(10);
r[i+11]=av.lane(11);
r[i+12]=av.lane(12);
r[i+13]=av.lane(13);
r[i+14]=av.lane(14);
r[i+15]=av.lane(15);
r[i+16]=av.lane(16);
r[i+17]=av.lane(17);
r[i+18]=av.lane(18);
r[i+19]=av.lane(19);
r[i+20]=av.lane(20);
r[i+21]=av.lane(21);
r[i+22]=av.lane(22);
r[i+23]=av.lane(23);
r[i+24]=av.lane(24);
r[i+25]=av.lane(25);
r[i+26]=av.lane(26);
r[i+27]=av.lane(27);
r[i+28]=av.lane(28);
r[i+29]=av.lane(29);
r[i+30]=av.lane(30);
r[i+31]=av.lane(31);
r[i+32]=av.lane(32);
r[i+33]=av.lane(33);
r[i+34]=av.lane(34);
r[i+35]=av.lane(35);
r[i+36]=av.lane(36);
r[i+37]=av.lane(37);
r[i+38]=av.lane(38);
r[i+39]=av.lane(39);
r[i+40]=av.lane(40);
r[i+41]=av.lane(41);
r[i+42]=av.lane(42);
r[i+43]=av.lane(43);
r[i+44]=av.lane(44);
r[i+45]=av.lane(45);
r[i+46]=av.lane(46);
r[i+47]=av.lane(47);
r[i+48]=av.lane(48);
r[i+49]=av.lane(49);
r[i+50]=av.lane(50);
r[i+51]=av.lane(51);
r[i+52]=av.lane(52);
r[i+53]=av.lane(53);
r[i+54]=av.lane(54);
r[i+55]=av.lane(55);
r[i+56]=av.lane(56);
r[i+57]=av.lane(57);
r[i+58]=av.lane(58);
r[i+59]=av.lane(59);
r[i+60]=av.lane(60);
r[i+61]=av.lane(61);
r[i+62]=av.lane(62);
r[i+63]=av.lane(63);
} else {
for (int j = 0; j < SPECIES.length(); j++) {
r[i+j]=av.lane(j);
}
}
}
}
assertArraysEquals(r, a, Byte256VectorTests::get);
}
@Test(dataProvider = "byteUnaryOpProvider")
static void BroadcastByte256VectorTests(IntFunction<byte[]> fa) {
byte[] a = fa.apply(SPECIES.length());
byte[] r = new byte[a.length];
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector.broadcast(SPECIES, a[i]).intoArray(r, i);
}
}
assertBroadcastArraysEquals(r, a);
}
@Test(dataProvider = "byteUnaryOpProvider")
static void ZeroByte256VectorTests(IntFunction<byte[]> fa) {
byte[] a = fa.apply(SPECIES.length());
byte[] r = new byte[a.length];
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector.zero(SPECIES).intoArray(a, i);
}
}
Assert.assertEquals(a, r);
}
static byte[] sliceUnary(byte[] a, int origin, int idx) {
byte[] res = new byte[SPECIES.length()];
for (int i = 0; i < SPECIES.length(); i++){
if(i+origin < SPECIES.length())
res[i] = a[idx+i+origin];
else
res[i] = (byte)0;
}
return res;
}
@Test(dataProvider = "byteUnaryOpProvider")
static void sliceUnaryByte256VectorTests(IntFunction<byte[]> fa) {
byte[] a = fa.apply(SPECIES.length());
byte[] r = new byte[a.length];
int origin = (new java.util.Random()).nextInt(SPECIES.length());
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
av.slice(origin).intoArray(r, i);
}
}
assertArraysEquals(r, a, origin, Byte256VectorTests::sliceUnary);
}
static byte[] sliceBinary(byte[] a, byte[] b, int origin, int idx) {
byte[] res = new byte[SPECIES.length()];
for (int i = 0, j = 0; i < SPECIES.length(); i++){
if(i+origin < SPECIES.length())
res[i] = a[idx+i+origin];
else {
res[i] = b[idx+j];
j++;
}
}
return res;
}
@Test(dataProvider = "byteBinaryOpProvider")
static void sliceBinaryByte256VectorTestsBinary(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
byte[] r = new byte[a.length];
int origin = (new java.util.Random()).nextInt(SPECIES.length());
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
av.slice(origin, bv).intoArray(r, i);
}
}
assertArraysEquals(r, a, b, origin, Byte256VectorTests::sliceBinary);
}
static byte[] slice(byte[] a, byte[] b, int origin, boolean[] mask, int idx) {
byte[] res = new byte[SPECIES.length()];
for (int i = 0, j = 0; i < SPECIES.length(); i++){
if(i+origin < SPECIES.length())
res[i] = mask[i] ? a[idx+i+origin] : (byte)0;
else {
res[i] = mask[i] ? b[idx+j] : (byte)0;
j++;
}
}
return res;
}
@Test(dataProvider = "byteBinaryOpMaskProvider")
static void sliceByte256VectorTestsMasked(IntFunction<byte[]> fa, IntFunction<byte[]> fb,
IntFunction<boolean[]> fm) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
boolean[] mask = fm.apply(SPECIES.length());
VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
byte[] r = new byte[a.length];
int origin = (new java.util.Random()).nextInt(SPECIES.length());
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
av.slice(origin, bv, vmask).intoArray(r, i);
}
}
assertArraysEquals(r, a, b, origin, mask, Byte256VectorTests::slice);
}
static byte[] unsliceUnary(byte[] a, int origin, int idx) {
byte[] res = new byte[SPECIES.length()];
for (int i = 0, j = 0; i < SPECIES.length(); i++){
if(i < origin)
res[i] = (byte)0;
else {
res[i] = a[idx+j];
j++;
}
}
return res;
}
@Test(dataProvider = "byteUnaryOpProvider")
static void unsliceUnaryByte256VectorTests(IntFunction<byte[]> fa) {
byte[] a = fa.apply(SPECIES.length());
byte[] r = new byte[a.length];
int origin = (new java.util.Random()).nextInt(SPECIES.length());
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
av.unslice(origin).intoArray(r, i);
}
}
assertArraysEquals(r, a, origin, Byte256VectorTests::unsliceUnary);
}
static byte[] unsliceBinary(byte[] a, byte[] b, int origin, int part, int idx) {
byte[] res = new byte[SPECIES.length()];
for (int i = 0, j = 0; i < SPECIES.length(); i++){
if (part == 0) {
if (i < origin)
res[i] = b[idx+i];
else {
res[i] = a[idx+j];
j++;
}
} else if (part == 1) {
if (i < origin)
res[i] = a[idx+SPECIES.length()-origin+i];
else {
res[i] = b[idx+origin+j];
j++;
}
}
}
return res;
}
@Test(dataProvider = "byteBinaryOpProvider")
static void unsliceBinaryByte256VectorTestsBinary(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
byte[] r = new byte[a.length];
int origin = (new java.util.Random()).nextInt(SPECIES.length());
int part = (new java.util.Random()).nextInt(2);
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
av.unslice(origin, bv, part).intoArray(r, i);
}
}
assertArraysEquals(r, a, b, origin, part, Byte256VectorTests::unsliceBinary);
}
static byte[] unslice(byte[] a, byte[] b, int origin, int part, boolean[] mask, int idx) {
byte[] res = new byte[SPECIES.length()];
for (int i = 0, j = 0; i < SPECIES.length(); i++){
if(i+origin < SPECIES.length())
res[i] = b[idx+i+origin];
else {
res[i] = b[idx+j];
j++;
}
}
for (int i = 0; i < SPECIES.length(); i++){
res[i] = mask[i] ? a[idx+i] : res[i];
}
byte[] res1 = new byte[SPECIES.length()];
if (part == 0) {
for (int i = 0, j = 0; i < SPECIES.length(); i++){
if (i < origin)
res1[i] = b[idx+i];
else {
res1[i] = res[j];
j++;
}
}
} else if (part == 1) {
for (int i = 0, j = 0; i < SPECIES.length(); i++){
if (i < origin)
res1[i] = res[SPECIES.length()-origin+i];
else {
res1[i] = b[idx+origin+j];
j++;
}
}
}
return res1;
}
@Test(dataProvider = "byteBinaryOpMaskProvider")
static void unsliceByte256VectorTestsMasked(IntFunction<byte[]> fa, IntFunction<byte[]> fb,
IntFunction<boolean[]> fm) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
boolean[] mask = fm.apply(SPECIES.length());
VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
byte[] r = new byte[a.length];
int origin = (new java.util.Random()).nextInt(SPECIES.length());
int part = (new java.util.Random()).nextInt(2);
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
av.unslice(origin, bv, part, vmask).intoArray(r, i);
}
}
assertArraysEquals(r, a, b, origin, part, mask, Byte256VectorTests::unslice);
}
static byte BITWISE_BLEND(byte a, byte b, byte c) {
return (byte)((a&~(c))|(b&c));
}
static byte bitwiseBlend(byte a, byte b, byte c) {
return (byte)((a&~(c))|(b&c));
}
@Test(dataProvider = "byteTernaryOpProvider")
static void BITWISE_BLENDByte256VectorTests(IntFunction<byte[]> fa, IntFunction<byte[]> fb, IntFunction<byte[]> fc) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
byte[] c = fc.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
ByteVector cv = ByteVector.fromArray(SPECIES, c, i);
av.lanewise(VectorOperators.BITWISE_BLEND, bv, cv).intoArray(r, i);
}
}
assertArraysEquals(r, a, b, c, Byte256VectorTests::BITWISE_BLEND);
}
@Test(dataProvider = "byteTernaryOpProvider")
static void bitwiseBlendByte256VectorTests(IntFunction<byte[]> fa, IntFunction<byte[]> fb, IntFunction<byte[]> fc) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
byte[] c = fc.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
ByteVector cv = ByteVector.fromArray(SPECIES, c, i);
av.bitwiseBlend(bv, cv).intoArray(r, i);
}
assertArraysEquals(r, a, b, c, Byte256VectorTests::bitwiseBlend);
}
@Test(dataProvider = "byteTernaryOpMaskProvider")
static void BITWISE_BLENDByte256VectorTestsMasked(IntFunction<byte[]> fa, IntFunction<byte[]> fb,
IntFunction<byte[]> fc, IntFunction<boolean[]> fm) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
byte[] c = fc.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
boolean[] mask = fm.apply(SPECIES.length());
VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
ByteVector cv = ByteVector.fromArray(SPECIES, c, i);
av.lanewise(VectorOperators.BITWISE_BLEND, bv, cv, vmask).intoArray(r, i);
}
}
assertArraysEquals(r, a, b, c, mask, Byte256VectorTests::BITWISE_BLEND);
}
@Test(dataProvider = "byteTernaryOpProvider")
static void BITWISE_BLENDByte256VectorTestsBroadcastSmokeTest(IntFunction<byte[]> fa, IntFunction<byte[]> fb, IntFunction<byte[]> fc) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
byte[] c = fc.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
av.lanewise(VectorOperators.BITWISE_BLEND, bv, c[i]).intoArray(r, i);
}
assertBroadcastArraysEquals(r, a, b, c, Byte256VectorTests::BITWISE_BLEND);
}
@Test(dataProvider = "byteTernaryOpProvider")
static void BITWISE_BLENDByte256VectorTestsAltBroadcastSmokeTest(IntFunction<byte[]> fa, IntFunction<byte[]> fb, IntFunction<byte[]> fc) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
byte[] c = fc.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
ByteVector cv = ByteVector.fromArray(SPECIES, c, i);
av.lanewise(VectorOperators.BITWISE_BLEND, b[i], cv).intoArray(r, i);
}
assertAltBroadcastArraysEquals(r, a, b, c, Byte256VectorTests::BITWISE_BLEND);
}
@Test(dataProvider = "byteTernaryOpProvider")
static void bitwiseBlendByte256VectorTestsBroadcastSmokeTest(IntFunction<byte[]> fa, IntFunction<byte[]> fb, IntFunction<byte[]> fc) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
byte[] c = fc.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
av.bitwiseBlend(bv, c[i]).intoArray(r, i);
}
assertBroadcastArraysEquals(r, a, b, c, Byte256VectorTests::bitwiseBlend);
}
@Test(dataProvider = "byteTernaryOpProvider")
static void bitwiseBlendByte256VectorTestsAltBroadcastSmokeTest(IntFunction<byte[]> fa, IntFunction<byte[]> fb, IntFunction<byte[]> fc) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
byte[] c = fc.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
ByteVector cv = ByteVector.fromArray(SPECIES, c, i);
av.bitwiseBlend(b[i], cv).intoArray(r, i);
}
assertAltBroadcastArraysEquals(r, a, b, c, Byte256VectorTests::bitwiseBlend);
}
@Test(dataProvider = "byteTernaryOpMaskProvider")
static void BITWISE_BLENDByte256VectorTestsBroadcastMaskedSmokeTest(IntFunction<byte[]> fa, IntFunction<byte[]> fb,
IntFunction<byte[]> fc, IntFunction<boolean[]> fm) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
byte[] c = fc.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
boolean[] mask = fm.apply(SPECIES.length());
VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
av.lanewise(VectorOperators.BITWISE_BLEND, bv, c[i], vmask).intoArray(r, i);
}
assertBroadcastArraysEquals(r, a, b, c, mask, Byte256VectorTests::BITWISE_BLEND);
}
@Test(dataProvider = "byteTernaryOpMaskProvider")
static void BITWISE_BLENDByte256VectorTestsAltBroadcastMaskedSmokeTest(IntFunction<byte[]> fa, IntFunction<byte[]> fb,
IntFunction<byte[]> fc, IntFunction<boolean[]> fm) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
byte[] c = fc.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
boolean[] mask = fm.apply(SPECIES.length());
VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
ByteVector cv = ByteVector.fromArray(SPECIES, c, i);
av.lanewise(VectorOperators.BITWISE_BLEND, b[i], cv, vmask).intoArray(r, i);
}
assertAltBroadcastArraysEquals(r, a, b, c, mask, Byte256VectorTests::BITWISE_BLEND);
}
@Test(dataProvider = "byteTernaryOpProvider")
static void BITWISE_BLENDByte256VectorTestsDoubleBroadcastSmokeTest(IntFunction<byte[]> fa, IntFunction<byte[]> fb, IntFunction<byte[]> fc) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
byte[] c = fc.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
av.lanewise(VectorOperators.BITWISE_BLEND, b[i], c[i]).intoArray(r, i);
}
assertDoubleBroadcastArraysEquals(r, a, b, c, Byte256VectorTests::BITWISE_BLEND);
}
@Test(dataProvider = "byteTernaryOpProvider")
static void bitwiseBlendByte256VectorTestsDoubleBroadcastSmokeTest(IntFunction<byte[]> fa, IntFunction<byte[]> fb, IntFunction<byte[]> fc) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
byte[] c = fc.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
av.bitwiseBlend(b[i], c[i]).intoArray(r, i);
}
assertDoubleBroadcastArraysEquals(r, a, b, c, Byte256VectorTests::bitwiseBlend);
}
@Test(dataProvider = "byteTernaryOpMaskProvider")
static void BITWISE_BLENDByte256VectorTestsDoubleBroadcastMaskedSmokeTest(IntFunction<byte[]> fa, IntFunction<byte[]> fb,
IntFunction<byte[]> fc, IntFunction<boolean[]> fm) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
byte[] c = fc.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
boolean[] mask = fm.apply(SPECIES.length());
VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
av.lanewise(VectorOperators.BITWISE_BLEND, b[i], c[i], vmask).intoArray(r, i);
}
assertDoubleBroadcastArraysEquals(r, a, b, c, mask, Byte256VectorTests::BITWISE_BLEND);
}
static byte NEG(byte a) {
return (byte)(-((byte)a));
}
static byte neg(byte a) {
return (byte)(-((byte)a));
}
@Test(dataProvider = "byteUnaryOpProvider")
static void NEGByte256VectorTests(IntFunction<byte[]> fa) {
byte[] a = fa.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
av.lanewise(VectorOperators.NEG).intoArray(r, i);
}
}
assertArraysEquals(r, a, Byte256VectorTests::NEG);
}
@Test(dataProvider = "byteUnaryOpProvider")
static void negByte256VectorTests(IntFunction<byte[]> fa) {
byte[] a = fa.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
av.neg().intoArray(r, i);
}
}
assertArraysEquals(r, a, Byte256VectorTests::neg);
}
@Test(dataProvider = "byteUnaryOpMaskProvider")
static void NEGMaskedByte256VectorTests(IntFunction<byte[]> fa,
IntFunction<boolean[]> fm) {
byte[] a = fa.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
boolean[] mask = fm.apply(SPECIES.length());
VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
av.lanewise(VectorOperators.NEG, vmask).intoArray(r, i);
}
}
assertArraysEquals(r, a, mask, Byte256VectorTests::NEG);
}
static byte ABS(byte a) {
return (byte)(Math.abs((byte)a));
}
static byte abs(byte a) {
return (byte)(Math.abs((byte)a));
}
@Test(dataProvider = "byteUnaryOpProvider")
static void ABSByte256VectorTests(IntFunction<byte[]> fa) {
byte[] a = fa.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
av.lanewise(VectorOperators.ABS).intoArray(r, i);
}
}
assertArraysEquals(r, a, Byte256VectorTests::ABS);
}
@Test(dataProvider = "byteUnaryOpProvider")
static void absByte256VectorTests(IntFunction<byte[]> fa) {
byte[] a = fa.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
av.abs().intoArray(r, i);
}
}
assertArraysEquals(r, a, Byte256VectorTests::abs);
}
@Test(dataProvider = "byteUnaryOpMaskProvider")
static void ABSMaskedByte256VectorTests(IntFunction<byte[]> fa,
IntFunction<boolean[]> fm) {
byte[] a = fa.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
boolean[] mask = fm.apply(SPECIES.length());
VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
av.lanewise(VectorOperators.ABS, vmask).intoArray(r, i);
}
}
assertArraysEquals(r, a, mask, Byte256VectorTests::ABS);
}
static byte NOT(byte a) {
return (byte)(~((byte)a));
}
static byte not(byte a) {
return (byte)(~((byte)a));
}
@Test(dataProvider = "byteUnaryOpProvider")
static void NOTByte256VectorTests(IntFunction<byte[]> fa) {
byte[] a = fa.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
av.lanewise(VectorOperators.NOT).intoArray(r, i);
}
}
assertArraysEquals(r, a, Byte256VectorTests::NOT);
}
@Test(dataProvider = "byteUnaryOpProvider")
static void notByte256VectorTests(IntFunction<byte[]> fa) {
byte[] a = fa.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
av.not().intoArray(r, i);
}
}
assertArraysEquals(r, a, Byte256VectorTests::not);
}
@Test(dataProvider = "byteUnaryOpMaskProvider")
static void NOTMaskedByte256VectorTests(IntFunction<byte[]> fa,
IntFunction<boolean[]> fm) {
byte[] a = fa.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
boolean[] mask = fm.apply(SPECIES.length());
VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
av.lanewise(VectorOperators.NOT, vmask).intoArray(r, i);
}
}
assertArraysEquals(r, a, mask, Byte256VectorTests::NOT);
}
static byte ZOMO(byte a) {
return (byte)((a==0?0:-1));
}
@Test(dataProvider = "byteUnaryOpProvider")
static void ZOMOByte256VectorTests(IntFunction<byte[]> fa) {
byte[] a = fa.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
av.lanewise(VectorOperators.ZOMO).intoArray(r, i);
}
}
assertArraysEquals(r, a, Byte256VectorTests::ZOMO);
}
@Test(dataProvider = "byteUnaryOpMaskProvider")
static void ZOMOMaskedByte256VectorTests(IntFunction<byte[]> fa,
IntFunction<boolean[]> fm) {
byte[] a = fa.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
boolean[] mask = fm.apply(SPECIES.length());
VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
av.lanewise(VectorOperators.ZOMO, vmask).intoArray(r, i);
}
}
assertArraysEquals(r, a, mask, Byte256VectorTests::ZOMO);
}
static byte[] gather(byte a[], int ix, int[] b, int iy) {
byte[] res = new byte[SPECIES.length()];
for (int i = 0; i < SPECIES.length(); i++) {
int bi = iy + i;
res[i] = a[b[bi] + ix];
}
return res;
}
@Test(dataProvider = "byteUnaryOpIndexProvider")
static void gatherByte256VectorTests(IntFunction<byte[]> fa, BiFunction<Integer,Integer,int[]> fs) {
byte[] a = fa.apply(SPECIES.length());
int[] b = fs.apply(a.length, SPECIES.length());
byte[] r = new byte[a.length];
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i, b, i);
av.intoArray(r, i);
}
}
assertArraysEquals(r, a, b, Byte256VectorTests::gather);
}
static byte[] gatherMasked(byte a[], int ix, boolean[] mask, int[] b, int iy) {
byte[] res = new byte[SPECIES.length()];
for (int i = 0; i < SPECIES.length(); i++) {
int bi = iy + i;
if (mask[i]) {
res[i] = a[b[bi] + ix];
}
}
return res;
}
@Test(dataProvider = "byteUnaryMaskedOpIndexProvider")
static void gatherMaskedByte256VectorTests(IntFunction<byte[]> fa, BiFunction<Integer,Integer,int[]> fs, IntFunction<boolean[]> fm) {
byte[] a = fa.apply(SPECIES.length());
int[] b = fs.apply(a.length, SPECIES.length());
byte[] r = new byte[a.length];
boolean[] mask = fm.apply(SPECIES.length());
VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i, b, i, vmask);
av.intoArray(r, i);
}
}
assertArraysEquals(r, a, b, mask, Byte256VectorTests::gatherMasked);
}
static byte[] scatter(byte a[], int ix, int[] b, int iy) {
byte[] res = new byte[SPECIES.length()];
for (int i = 0; i < SPECIES.length(); i++) {
int bi = iy + i;
res[b[bi]] = a[i + ix];
}
return res;
}
@Test(dataProvider = "byteUnaryOpIndexProvider")
static void scatterByte256VectorTests(IntFunction<byte[]> fa, BiFunction<Integer,Integer,int[]> fs) {
byte[] a = fa.apply(SPECIES.length());
int[] b = fs.apply(a.length, SPECIES.length());
byte[] r = new byte[a.length];
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
av.intoArray(r, i, b, i);
}
}
assertArraysEquals(r, a, b, Byte256VectorTests::scatter);
}
static byte[] scatterMasked(byte r[], byte a[], int ix, boolean[] mask, int[] b, int iy) {
// First, gather r.
byte[] oldVal = gather(r, ix, b, iy);
byte[] newVal = new byte[SPECIES.length()];
// Second, blending it with a.
for (int i = 0; i < SPECIES.length(); i++) {
newVal[i] = blend(oldVal[i], a[i+ix], mask[i]);
}
// Third, scatter: copy old value of r, and scatter it manually.
byte[] res = Arrays.copyOfRange(r, ix, ix+SPECIES.length());
for (int i = 0; i < SPECIES.length(); i++) {
int bi = iy + i;
res[b[bi]] = newVal[i];
}
return res;
}
@Test(dataProvider = "scatterMaskedOpIndexProvider")
static void scatterMaskedByte256VectorTests(IntFunction<byte[]> fa, IntFunction<byte[]> fb, BiFunction<Integer,Integer,int[]> fs, IntFunction<boolean[]> fm) {
byte[] a = fa.apply(SPECIES.length());
int[] b = fs.apply(a.length, SPECIES.length());
byte[] r = fb.apply(SPECIES.length());
boolean[] mask = fm.apply(SPECIES.length());
VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
av.intoArray(r, i, b, i, vmask);
}
}
assertArraysEquals(r, a, b, mask, Byte256VectorTests::scatterMasked);
}
@Test(dataProvider = "byteCompareOpProvider")
static void ltByte256VectorTestsBroadcastSmokeTest(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
VectorMask<Byte> mv = av.lt(b[i]);
// Check results as part of computation.
for (int j = 0; j < SPECIES.length(); j++) {
Assert.assertEquals(mv.laneIsSet(j), a[i + j] < b[i]);
}
}
}
@Test(dataProvider = "byteCompareOpProvider")
static void eqByte256VectorTestsBroadcastMaskedSmokeTest(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
VectorMask<Byte> mv = av.eq(b[i]);
// Check results as part of computation.
for (int j = 0; j < SPECIES.length(); j++) {
Assert.assertEquals(mv.laneIsSet(j), a[i + j] == b[i]);
}
}
}
@Test(dataProvider = "byteUnaryOpProvider")
static void toIntArrayByte256VectorTestsSmokeTest(IntFunction<byte[]> fa) {
byte[] a = fa.apply(SPECIES.length());
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
int[] r = av.toIntArray();
assertArraysEquals(r, a, i);
}
}
@Test(dataProvider = "byteUnaryOpProvider")
static void toLongArrayByte256VectorTestsSmokeTest(IntFunction<byte[]> fa) {
byte[] a = fa.apply(SPECIES.length());
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
long[] r = av.toLongArray();
assertArraysEquals(r, a, i);
}
}
@Test(dataProvider = "byteUnaryOpProvider")
static void toDoubleArrayByte256VectorTestsSmokeTest(IntFunction<byte[]> fa) {
byte[] a = fa.apply(SPECIES.length());
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
double[] r = av.toDoubleArray();
assertArraysEquals(r, a, i);
}
}
@Test(dataProvider = "byteUnaryOpProvider")
static void toStringByte256VectorTestsSmokeTest(IntFunction<byte[]> fa) {
byte[] a = fa.apply(SPECIES.length());
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
String str = av.toString();
byte subarr[] = Arrays.copyOfRange(a, i, i + SPECIES.length());
Assert.assertTrue(str.equals(Arrays.toString(subarr)), "at index " + i + ", string should be = " + Arrays.toString(subarr) + ", but is = " + str);
}
}
@Test(dataProvider = "byteUnaryOpProvider")
static void hashCodeByte256VectorTestsSmokeTest(IntFunction<byte[]> fa) {
byte[] a = fa.apply(SPECIES.length());
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
int hash = av.hashCode();
byte subarr[] = Arrays.copyOfRange(a, i, i + SPECIES.length());
int expectedHash = Objects.hash(SPECIES, Arrays.hashCode(subarr));
Assert.assertTrue(hash == expectedHash, "at index " + i + ", hash should be = " + expectedHash + ", but is = " + hash);
}
}
@Test(dataProvider = "byteUnaryOpProvider")
static void reinterpretAsBytesByte256VectorTestsSmokeTest(IntFunction<byte[]> fa) {
byte[] a = fa.apply(SPECIES.length());
byte[] r = new byte[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
av.reinterpretAsBytes().intoArray(r, i);
}
assertArraysEquals(r, a, 0);
}
static long ADDReduceLong(byte[] a, int idx) {
byte res = 0;
for (int i = idx; i < (idx + SPECIES.length()); i++) {
res += a[i];
}
return (long)res;
}
static long ADDReduceAllLong(byte[] a) {
long res = 0;
for (int i = 0; i < a.length; i += SPECIES.length()) {
res += ADDReduceLong(a, i);
}
return res;
}
@Test(dataProvider = "byteUnaryOpProvider")
static void ADDReduceLongByte256VectorTests(IntFunction<byte[]> fa) {
byte[] a = fa.apply(SPECIES.length());
long[] r = lfr.apply(SPECIES.length());
long ra = 0;
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
r[i] = av.reduceLanesToLong(VectorOperators.ADD);
}
ra = 0;
for (int i = 0; i < a.length; i ++) {
ra += r[i];
}
assertReductionLongArraysEquals(r, ra, a,
Byte256VectorTests::ADDReduceLong, Byte256VectorTests::ADDReduceAllLong);
}
static long ADDReduceLongMasked(byte[] a, int idx, boolean[] mask) {
byte res = 0;
for (int i = idx; i < (idx + SPECIES.length()); i++) {
if(mask[i % SPECIES.length()])
res += a[i];
}
return (long)res;
}
static long ADDReduceAllLongMasked(byte[] a, boolean[] mask) {
long res = 0;
for (int i = 0; i < a.length; i += SPECIES.length()) {
res += ADDReduceLongMasked(a, i, mask);
}
return res;
}
@Test(dataProvider = "byteUnaryOpMaskProvider")
static void ADDReduceLongByte256VectorTestsMasked(IntFunction<byte[]> fa, IntFunction<boolean[]> fm) {
byte[] a = fa.apply(SPECIES.length());
long[] r = lfr.apply(SPECIES.length());
boolean[] mask = fm.apply(SPECIES.length());
VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
long ra = 0;
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
r[i] = av.reduceLanesToLong(VectorOperators.ADD, vmask);
}
ra = 0;
for (int i = 0; i < a.length; i ++) {
ra += r[i];
}
assertReductionLongArraysEqualsMasked(r, ra, a, mask,
Byte256VectorTests::ADDReduceLongMasked, Byte256VectorTests::ADDReduceAllLongMasked);
}
@Test(dataProvider = "byteUnaryOpProvider")
static void BroadcastLongByte256VectorTestsSmokeTest(IntFunction<byte[]> fa) {
byte[] a = fa.apply(SPECIES.length());
byte[] r = new byte[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector.broadcast(SPECIES, (long)a[i]).intoArray(r, i);
}
assertBroadcastArraysEquals(r, a);
}
@Test(dataProvider = "byteBinaryOpMaskProvider")
static void blendByte256VectorTestsBroadcastLongSmokeTest(IntFunction<byte[]> fa, IntFunction<byte[]> fb,
IntFunction<boolean[]> fm) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
boolean[] mask = fm.apply(SPECIES.length());
VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
av.blend((long)b[i], vmask).intoArray(r, i);
}
}
assertBroadcastLongArraysEquals(r, a, b, mask, Byte256VectorTests::blend);
}
@Test(dataProvider = "byteUnaryOpSelectFromProvider")
static void SelectFromByte256VectorTests(IntFunction<byte[]> fa,
BiFunction<Integer,Integer,byte[]> fs) {
byte[] a = fa.apply(SPECIES.length());
byte[] order = fs.apply(a.length, SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
ByteVector bv = ByteVector.fromArray(SPECIES, order, i);
bv.selectFrom(av).intoArray(r, i);
}
assertSelectFromArraysEquals(r, a, order, SPECIES.length());
}
@Test(dataProvider = "byteUnaryOpSelectFromMaskProvider")
static void SelectFromByte256VectorTestsMaskedSmokeTest(IntFunction<byte[]> fa,
BiFunction<Integer,Integer,byte[]> fs,
IntFunction<boolean[]> fm) {
byte[] a = fa.apply(SPECIES.length());
byte[] order = fs.apply(a.length, SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
boolean[] mask = fm.apply(SPECIES.length());
VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
ByteVector bv = ByteVector.fromArray(SPECIES, order, i);
bv.selectFrom(av, vmask).intoArray(r, i);
}
assertSelectFromArraysEquals(r, a, order, mask, SPECIES.length());
}
@Test(dataProvider = "shuffleProvider")
static void shuffleMiscellaneousByte256VectorTestsSmokeTest(BiFunction<Integer,Integer,int[]> fs) {
int[] a = fs.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length());
for (int i = 0; i < a.length; i += SPECIES.length()) {
var shuffle = VectorShuffle.fromArray(SPECIES, a, i);
int hash = shuffle.hashCode();
int length = shuffle.length();
int subarr[] = Arrays.copyOfRange(a, i, i + SPECIES.length());
int expectedHash = Objects.hash(SPECIES, Arrays.hashCode(subarr));
Assert.assertTrue(hash == expectedHash, "at index " + i + ", hash should be = " + expectedHash + ", but is = " + hash);
Assert.assertEquals(length, SPECIES.length());
}
}
@Test(dataProvider = "shuffleProvider")
static void shuffleToStringByte256VectorTestsSmokeTest(BiFunction<Integer,Integer,int[]> fs) {
int[] a = fs.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length());
for (int i = 0; i < a.length; i += SPECIES.length()) {
var shuffle = VectorShuffle.fromArray(SPECIES, a, i);
String str = shuffle.toString();
int subarr[] = Arrays.copyOfRange(a, i, i + SPECIES.length());
Assert.assertTrue(str.equals("Shuffle" + Arrays.toString(subarr)), "at index " +
i + ", string should be = " + Arrays.toString(subarr) + ", but is = " + str);
}
}
@Test(dataProvider = "shuffleCompareOpProvider")
static void shuffleEqualsByte256VectorTestsSmokeTest(BiFunction<Integer,Integer,int[]> fa, BiFunction<Integer,Integer,int[]> fb) {
int[] a = fa.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length());
int[] b = fb.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length());
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = VectorShuffle.fromArray(SPECIES, a, i);
var bv = VectorShuffle.fromArray(SPECIES, b, i);
boolean eq = av.equals(bv);
int to = i + SPECIES.length();
Assert.assertEquals(eq, Arrays.equals(a, i, to, b, i, to));
}
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskEqualsByte256VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
boolean equals = av.equals(bv);
int to = i + SPECIES.length();
Assert.assertEquals(equals, Arrays.equals(a, i, to, b, i, to));
}
}
static boolean beq(boolean a, boolean b) {
return (a == b);
}
@Test(dataProvider = "maskCompareOpProvider")
static void maskEqByte256VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
boolean[] a = fa.apply(SPECIES.length());
boolean[] b = fb.apply(SPECIES.length());
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i += SPECIES.length()) {
var av = SPECIES.loadMask(a, i);
var bv = SPECIES.loadMask(b, i);
var cv = av.eq(bv);
cv.intoArray(r, i);
}
assertArraysEquals(r, a, b, Byte256VectorTests::beq);
}
@Test(dataProvider = "maskProvider")
static void maskHashCodeByte256VectorTestsSmokeTest(IntFunction<boolean[]> fa) {
boolean[] a = fa.apply(SPECIES.length());
for (int i = 0; i < a.length; i += SPECIES.length()) {
var vmask = SPECIES.loadMask(a, i);
int hash = vmask.hashCode();
boolean subarr[] = Arrays.copyOfRange(a, i, i + SPECIES.length());
int expectedHash = Objects.hash(SPECIES, Arrays.hashCode(subarr));
Assert.assertTrue(hash == expectedHash, "at index " + i + ", hash should be = " + expectedHash + ", but is = " + hash);
}
}
@Test(dataProvider = "maskProvider")
static void maskTrueCountByte256VectorTestsSmokeTest(IntFunction<boolean[]> fa) {
boolean[] a = fa.apply(SPECIES.length());
for (int i = 0; i < a.length; i += SPECIES.length()) {
var vmask = SPECIES.loadMask(a, i);
int tcount = vmask.trueCount();
int expectedTcount = 0;
for (int j = i; j < i + SPECIES.length(); j++) {
expectedTcount += a[j] ? 1 : 0;
}
Assert.assertTrue(tcount == expectedTcount, "at index " + i + ", trueCount should be = " + expectedTcount + ", but is = " + tcount);
}
}
@Test(dataProvider = "maskProvider")
static void maskLastTrueByte256VectorTestsSmokeTest(IntFunction<boolean[]> fa) {
boolean[] a = fa.apply(SPECIES.length());
for (int i = 0; i < a.length; i += SPECIES.length()) {
var vmask = SPECIES.loadMask(a, i);
int ltrue = vmask.lastTrue();
int j = i + SPECIES.length() - 1;
for (; j >= i; j--) {
if (a[j]) break;
}
int expectedLtrue = j - i;
Assert.assertTrue(ltrue == expectedLtrue, "at index " + i +
", lastTrue should be = " + expectedLtrue + ", but is = " + ltrue);
}
}
@DataProvider
public static Object[][] longMaskProvider() {
return new Object[][]{
{0xFFFFFFFFFFFFFFFFL},
{0x0000000000000000L},
{0x5555555555555555L},
{0x0123456789abcdefL},
};
}
@Test(dataProvider = "longMaskProvider")
static void maskFromToLongByte256VectorTestsSmokeTest(long inputLong) {
var vmask = VectorMask.fromLong(SPECIES, inputLong);
long outputLong = vmask.toLong();
Assert.assertEquals(outputLong, inputLong & (((1L << (SPECIES.length() - 1)) << 1) - 1));
}
@DataProvider
public static Object[][] offsetProvider() {
return new Object[][]{
{0},
{-1},
{+1},
{+2},
{-2},
};
}
@Test(dataProvider = "offsetProvider")
static void indexInRangeByte256VectorTestsSmokeTest(int offset) {
int limit = SPECIES.length() * BUFFER_REPS;
for (int i = 0; i < limit; i += SPECIES.length()) {
var actualMask = SPECIES.indexInRange(i + offset, limit);
var expectedMask = SPECIES.maskAll(true).indexInRange(i + offset, limit);
assert(actualMask.equals(expectedMask));
for (int j = 0; j < SPECIES.length(); j++) {
int index = i + j + offset;
Assert.assertEquals(actualMask.laneIsSet(j), index >= 0 && index < limit);
}
}
}
@DataProvider
public static Object[][] lengthProvider() {
return new Object[][]{
{0},
{1},
{32},
{37},
{1024},
{1024+1},
{1024+5},
};
}
@Test(dataProvider = "lengthProvider")
static void loopBoundByte256VectorTestsSmokeTest(int length) {
int actualLoopBound = SPECIES.loopBound(length);
int expectedLoopBound = length - Math.floorMod(length, SPECIES.length());
Assert.assertEquals(actualLoopBound, expectedLoopBound);
}
@Test
static void ElementSizeByte256VectorTestsSmokeTest() {
ByteVector av = ByteVector.zero(SPECIES);
int elsize = av.elementSize();
Assert.assertEquals(elsize, Byte.SIZE);
}
@Test
static void VectorShapeByte256VectorTestsSmokeTest() {
ByteVector av = ByteVector.zero(SPECIES);
VectorShape vsh = av.shape();
assert(vsh.equals(VectorShape.S_256_BIT));
}
@Test
static void ShapeWithLanesByte256VectorTestsSmokeTest() {
ByteVector av = ByteVector.zero(SPECIES);
VectorShape vsh = av.shape();
VectorSpecies species = vsh.withLanes(byte.class);
assert(species.equals(SPECIES));
}
@Test
static void ElementTypeByte256VectorTestsSmokeTest() {
ByteVector av = ByteVector.zero(SPECIES);
assert(av.species().elementType() == byte.class);
}
@Test
static void SpeciesElementSizeByte256VectorTestsSmokeTest() {
ByteVector av = ByteVector.zero(SPECIES);
assert(av.species().elementSize() == Byte.SIZE);
}
@Test
static void VectorTypeByte256VectorTestsSmokeTest() {
ByteVector av = ByteVector.zero(SPECIES);
assert(av.species().vectorType() == av.getClass());
}
@Test
static void WithLanesByte256VectorTestsSmokeTest() {
ByteVector av = ByteVector.zero(SPECIES);
VectorSpecies species = av.species().withLanes(byte.class);
assert(species.equals(SPECIES));
}
@Test
static void WithShapeByte256VectorTestsSmokeTest() {
ByteVector av = ByteVector.zero(SPECIES);
VectorShape vsh = av.shape();
VectorSpecies species = av.species().withShape(vsh);
assert(species.equals(SPECIES));
}
}