8305461: [vectorapi] Add VectorMask::xor
Reviewed-by: psandoz
This commit is contained in:
parent
ddd50d0db3
commit
536ad9df1a
src/jdk.incubator.vector/share/classes/jdk/incubator/vector
AbstractMask.javaByte128Vector.javaByte256Vector.javaByte512Vector.javaByte64Vector.javaByteMaxVector.javaDouble128Vector.javaDouble256Vector.javaDouble512Vector.javaDouble64Vector.javaDoubleMaxVector.javaFloat128Vector.javaFloat256Vector.javaFloat512Vector.javaFloat64Vector.javaFloatMaxVector.javaInt128Vector.javaInt256Vector.javaInt512Vector.javaInt64Vector.javaIntMaxVector.javaLong128Vector.javaLong256Vector.javaLong512Vector.javaLong64Vector.javaLongMaxVector.javaShort128Vector.javaShort256Vector.javaShort512Vector.javaShort64Vector.javaShortMaxVector.javaVectorMask.javaX-VectorBits.java.template
test/jdk/jdk/incubator/vector
Byte128VectorTests.javaByte256VectorTests.javaByte512VectorTests.javaByte64VectorTests.javaByteMaxVectorTests.javaDouble128VectorTests.javaDouble256VectorTests.javaDouble512VectorTests.javaDouble64VectorTests.javaDoubleMaxVectorTests.javaFloat128VectorTests.javaFloat256VectorTests.javaFloat512VectorTests.javaFloat64VectorTests.javaFloatMaxVectorTests.javaInt128VectorTests.javaInt256VectorTests.javaInt512VectorTests.javaInt64VectorTests.javaIntMaxVectorTests.javaLong128VectorTests.javaLong256VectorTests.javaLong512VectorTests.javaLong64VectorTests.javaLongMaxVectorTests.javaShort128VectorTests.javaShort256VectorTests.javaShort512VectorTests.javaShort64VectorTests.javaShortMaxVectorTests.java
templates
@ -137,10 +137,17 @@ abstract class AbstractMask<E> extends VectorMask<E> {
|
||||
}
|
||||
|
||||
@Override
|
||||
public VectorMask<E> andNot(VectorMask<E> m) {
|
||||
@ForceInline
|
||||
public final VectorMask<E> andNot(VectorMask<E> m) {
|
||||
return and(m.not());
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
public final VectorMask<E> eq(VectorMask<E> m) {
|
||||
return xor(m.not());
|
||||
}
|
||||
|
||||
/*package-private*/
|
||||
static boolean anyTrueHelper(boolean[] bits) {
|
||||
// FIXME: Maybe use toLong() != 0 here.
|
||||
|
@ -677,14 +677,6 @@ final class Byte128Vector extends ByteVector {
|
||||
(m, s) -> s.maskFactory(m.toArray()).check(s));
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
public Byte128Mask eq(VectorMask<Byte> mask) {
|
||||
Objects.requireNonNull(mask);
|
||||
Byte128Mask m = (Byte128Mask)mask;
|
||||
return xor(m.not());
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
/*package-private*/
|
||||
@ -733,9 +725,9 @@ final class Byte128Vector extends ByteVector {
|
||||
(m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b));
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
/* package-private */
|
||||
Byte128Mask xor(VectorMask<Byte> mask) {
|
||||
public Byte128Mask xor(VectorMask<Byte> mask) {
|
||||
Objects.requireNonNull(mask);
|
||||
Byte128Mask m = (Byte128Mask)mask;
|
||||
return VectorSupport.binaryOp(VECTOR_OP_XOR, Byte128Mask.class, null, byte.class, VLENGTH,
|
||||
|
@ -709,14 +709,6 @@ final class Byte256Vector extends ByteVector {
|
||||
(m, s) -> s.maskFactory(m.toArray()).check(s));
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
public Byte256Mask eq(VectorMask<Byte> mask) {
|
||||
Objects.requireNonNull(mask);
|
||||
Byte256Mask m = (Byte256Mask)mask;
|
||||
return xor(m.not());
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
/*package-private*/
|
||||
@ -765,9 +757,9 @@ final class Byte256Vector extends ByteVector {
|
||||
(m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b));
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
/* package-private */
|
||||
Byte256Mask xor(VectorMask<Byte> mask) {
|
||||
public Byte256Mask xor(VectorMask<Byte> mask) {
|
||||
Objects.requireNonNull(mask);
|
||||
Byte256Mask m = (Byte256Mask)mask;
|
||||
return VectorSupport.binaryOp(VECTOR_OP_XOR, Byte256Mask.class, null, byte.class, VLENGTH,
|
||||
|
@ -773,14 +773,6 @@ final class Byte512Vector extends ByteVector {
|
||||
(m, s) -> s.maskFactory(m.toArray()).check(s));
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
public Byte512Mask eq(VectorMask<Byte> mask) {
|
||||
Objects.requireNonNull(mask);
|
||||
Byte512Mask m = (Byte512Mask)mask;
|
||||
return xor(m.not());
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
/*package-private*/
|
||||
@ -829,9 +821,9 @@ final class Byte512Vector extends ByteVector {
|
||||
(m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b));
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
/* package-private */
|
||||
Byte512Mask xor(VectorMask<Byte> mask) {
|
||||
public Byte512Mask xor(VectorMask<Byte> mask) {
|
||||
Objects.requireNonNull(mask);
|
||||
Byte512Mask m = (Byte512Mask)mask;
|
||||
return VectorSupport.binaryOp(VECTOR_OP_XOR, Byte512Mask.class, null, byte.class, VLENGTH,
|
||||
|
@ -661,14 +661,6 @@ final class Byte64Vector extends ByteVector {
|
||||
(m, s) -> s.maskFactory(m.toArray()).check(s));
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
public Byte64Mask eq(VectorMask<Byte> mask) {
|
||||
Objects.requireNonNull(mask);
|
||||
Byte64Mask m = (Byte64Mask)mask;
|
||||
return xor(m.not());
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
/*package-private*/
|
||||
@ -717,9 +709,9 @@ final class Byte64Vector extends ByteVector {
|
||||
(m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b));
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
/* package-private */
|
||||
Byte64Mask xor(VectorMask<Byte> mask) {
|
||||
public Byte64Mask xor(VectorMask<Byte> mask) {
|
||||
Objects.requireNonNull(mask);
|
||||
Byte64Mask m = (Byte64Mask)mask;
|
||||
return VectorSupport.binaryOp(VECTOR_OP_XOR, Byte64Mask.class, null, byte.class, VLENGTH,
|
||||
|
@ -647,14 +647,6 @@ final class ByteMaxVector extends ByteVector {
|
||||
(m, s) -> s.maskFactory(m.toArray()).check(s));
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
public ByteMaxMask eq(VectorMask<Byte> mask) {
|
||||
Objects.requireNonNull(mask);
|
||||
ByteMaxMask m = (ByteMaxMask)mask;
|
||||
return xor(m.not());
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
/*package-private*/
|
||||
@ -703,9 +695,9 @@ final class ByteMaxVector extends ByteVector {
|
||||
(m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b));
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
/* package-private */
|
||||
ByteMaxMask xor(VectorMask<Byte> mask) {
|
||||
public ByteMaxMask xor(VectorMask<Byte> mask) {
|
||||
Objects.requireNonNull(mask);
|
||||
ByteMaxMask m = (ByteMaxMask)mask;
|
||||
return VectorSupport.binaryOp(VECTOR_OP_XOR, ByteMaxMask.class, null, byte.class, VLENGTH,
|
||||
|
@ -638,14 +638,6 @@ final class Double128Vector extends DoubleVector {
|
||||
(m, s) -> s.maskFactory(m.toArray()).check(s));
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
public Double128Mask eq(VectorMask<Double> mask) {
|
||||
Objects.requireNonNull(mask);
|
||||
Double128Mask m = (Double128Mask)mask;
|
||||
return xor(m.not());
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
/*package-private*/
|
||||
@ -694,9 +686,9 @@ final class Double128Vector extends DoubleVector {
|
||||
(m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b));
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
/* package-private */
|
||||
Double128Mask xor(VectorMask<Double> mask) {
|
||||
public Double128Mask xor(VectorMask<Double> mask) {
|
||||
Objects.requireNonNull(mask);
|
||||
Double128Mask m = (Double128Mask)mask;
|
||||
return VectorSupport.binaryOp(VECTOR_OP_XOR, Double128Mask.class, null, long.class, VLENGTH,
|
||||
|
@ -642,14 +642,6 @@ final class Double256Vector extends DoubleVector {
|
||||
(m, s) -> s.maskFactory(m.toArray()).check(s));
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
public Double256Mask eq(VectorMask<Double> mask) {
|
||||
Objects.requireNonNull(mask);
|
||||
Double256Mask m = (Double256Mask)mask;
|
||||
return xor(m.not());
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
/*package-private*/
|
||||
@ -698,9 +690,9 @@ final class Double256Vector extends DoubleVector {
|
||||
(m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b));
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
/* package-private */
|
||||
Double256Mask xor(VectorMask<Double> mask) {
|
||||
public Double256Mask xor(VectorMask<Double> mask) {
|
||||
Objects.requireNonNull(mask);
|
||||
Double256Mask m = (Double256Mask)mask;
|
||||
return VectorSupport.binaryOp(VECTOR_OP_XOR, Double256Mask.class, null, long.class, VLENGTH,
|
||||
|
@ -650,14 +650,6 @@ final class Double512Vector extends DoubleVector {
|
||||
(m, s) -> s.maskFactory(m.toArray()).check(s));
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
public Double512Mask eq(VectorMask<Double> mask) {
|
||||
Objects.requireNonNull(mask);
|
||||
Double512Mask m = (Double512Mask)mask;
|
||||
return xor(m.not());
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
/*package-private*/
|
||||
@ -706,9 +698,9 @@ final class Double512Vector extends DoubleVector {
|
||||
(m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b));
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
/* package-private */
|
||||
Double512Mask xor(VectorMask<Double> mask) {
|
||||
public Double512Mask xor(VectorMask<Double> mask) {
|
||||
Objects.requireNonNull(mask);
|
||||
Double512Mask m = (Double512Mask)mask;
|
||||
return VectorSupport.binaryOp(VECTOR_OP_XOR, Double512Mask.class, null, long.class, VLENGTH,
|
||||
|
@ -636,14 +636,6 @@ final class Double64Vector extends DoubleVector {
|
||||
(m, s) -> s.maskFactory(m.toArray()).check(s));
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
public Double64Mask eq(VectorMask<Double> mask) {
|
||||
Objects.requireNonNull(mask);
|
||||
Double64Mask m = (Double64Mask)mask;
|
||||
return xor(m.not());
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
/*package-private*/
|
||||
@ -692,9 +684,9 @@ final class Double64Vector extends DoubleVector {
|
||||
(m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b));
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
/* package-private */
|
||||
Double64Mask xor(VectorMask<Double> mask) {
|
||||
public Double64Mask xor(VectorMask<Double> mask) {
|
||||
Objects.requireNonNull(mask);
|
||||
Double64Mask m = (Double64Mask)mask;
|
||||
return VectorSupport.binaryOp(VECTOR_OP_XOR, Double64Mask.class, null, long.class, VLENGTH,
|
||||
|
@ -635,14 +635,6 @@ final class DoubleMaxVector extends DoubleVector {
|
||||
(m, s) -> s.maskFactory(m.toArray()).check(s));
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
public DoubleMaxMask eq(VectorMask<Double> mask) {
|
||||
Objects.requireNonNull(mask);
|
||||
DoubleMaxMask m = (DoubleMaxMask)mask;
|
||||
return xor(m.not());
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
/*package-private*/
|
||||
@ -691,9 +683,9 @@ final class DoubleMaxVector extends DoubleVector {
|
||||
(m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b));
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
/* package-private */
|
||||
DoubleMaxMask xor(VectorMask<Double> mask) {
|
||||
public DoubleMaxMask xor(VectorMask<Double> mask) {
|
||||
Objects.requireNonNull(mask);
|
||||
DoubleMaxMask m = (DoubleMaxMask)mask;
|
||||
return VectorSupport.binaryOp(VECTOR_OP_XOR, DoubleMaxMask.class, null, long.class, VLENGTH,
|
||||
|
@ -642,14 +642,6 @@ final class Float128Vector extends FloatVector {
|
||||
(m, s) -> s.maskFactory(m.toArray()).check(s));
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
public Float128Mask eq(VectorMask<Float> mask) {
|
||||
Objects.requireNonNull(mask);
|
||||
Float128Mask m = (Float128Mask)mask;
|
||||
return xor(m.not());
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
/*package-private*/
|
||||
@ -698,9 +690,9 @@ final class Float128Vector extends FloatVector {
|
||||
(m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b));
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
/* package-private */
|
||||
Float128Mask xor(VectorMask<Float> mask) {
|
||||
public Float128Mask xor(VectorMask<Float> mask) {
|
||||
Objects.requireNonNull(mask);
|
||||
Float128Mask m = (Float128Mask)mask;
|
||||
return VectorSupport.binaryOp(VECTOR_OP_XOR, Float128Mask.class, null, int.class, VLENGTH,
|
||||
|
@ -650,14 +650,6 @@ final class Float256Vector extends FloatVector {
|
||||
(m, s) -> s.maskFactory(m.toArray()).check(s));
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
public Float256Mask eq(VectorMask<Float> mask) {
|
||||
Objects.requireNonNull(mask);
|
||||
Float256Mask m = (Float256Mask)mask;
|
||||
return xor(m.not());
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
/*package-private*/
|
||||
@ -706,9 +698,9 @@ final class Float256Vector extends FloatVector {
|
||||
(m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b));
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
/* package-private */
|
||||
Float256Mask xor(VectorMask<Float> mask) {
|
||||
public Float256Mask xor(VectorMask<Float> mask) {
|
||||
Objects.requireNonNull(mask);
|
||||
Float256Mask m = (Float256Mask)mask;
|
||||
return VectorSupport.binaryOp(VECTOR_OP_XOR, Float256Mask.class, null, int.class, VLENGTH,
|
||||
|
@ -666,14 +666,6 @@ final class Float512Vector extends FloatVector {
|
||||
(m, s) -> s.maskFactory(m.toArray()).check(s));
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
public Float512Mask eq(VectorMask<Float> mask) {
|
||||
Objects.requireNonNull(mask);
|
||||
Float512Mask m = (Float512Mask)mask;
|
||||
return xor(m.not());
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
/*package-private*/
|
||||
@ -722,9 +714,9 @@ final class Float512Vector extends FloatVector {
|
||||
(m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b));
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
/* package-private */
|
||||
Float512Mask xor(VectorMask<Float> mask) {
|
||||
public Float512Mask xor(VectorMask<Float> mask) {
|
||||
Objects.requireNonNull(mask);
|
||||
Float512Mask m = (Float512Mask)mask;
|
||||
return VectorSupport.binaryOp(VECTOR_OP_XOR, Float512Mask.class, null, int.class, VLENGTH,
|
||||
|
@ -638,14 +638,6 @@ final class Float64Vector extends FloatVector {
|
||||
(m, s) -> s.maskFactory(m.toArray()).check(s));
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
public Float64Mask eq(VectorMask<Float> mask) {
|
||||
Objects.requireNonNull(mask);
|
||||
Float64Mask m = (Float64Mask)mask;
|
||||
return xor(m.not());
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
/*package-private*/
|
||||
@ -694,9 +686,9 @@ final class Float64Vector extends FloatVector {
|
||||
(m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b));
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
/* package-private */
|
||||
Float64Mask xor(VectorMask<Float> mask) {
|
||||
public Float64Mask xor(VectorMask<Float> mask) {
|
||||
Objects.requireNonNull(mask);
|
||||
Float64Mask m = (Float64Mask)mask;
|
||||
return VectorSupport.binaryOp(VECTOR_OP_XOR, Float64Mask.class, null, int.class, VLENGTH,
|
||||
|
@ -635,14 +635,6 @@ final class FloatMaxVector extends FloatVector {
|
||||
(m, s) -> s.maskFactory(m.toArray()).check(s));
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
public FloatMaxMask eq(VectorMask<Float> mask) {
|
||||
Objects.requireNonNull(mask);
|
||||
FloatMaxMask m = (FloatMaxMask)mask;
|
||||
return xor(m.not());
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
/*package-private*/
|
||||
@ -691,9 +683,9 @@ final class FloatMaxVector extends FloatVector {
|
||||
(m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b));
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
/* package-private */
|
||||
FloatMaxMask xor(VectorMask<Float> mask) {
|
||||
public FloatMaxMask xor(VectorMask<Float> mask) {
|
||||
Objects.requireNonNull(mask);
|
||||
FloatMaxMask m = (FloatMaxMask)mask;
|
||||
return VectorSupport.binaryOp(VECTOR_OP_XOR, FloatMaxMask.class, null, int.class, VLENGTH,
|
||||
|
@ -653,14 +653,6 @@ final class Int128Vector extends IntVector {
|
||||
(m, s) -> s.maskFactory(m.toArray()).check(s));
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
public Int128Mask eq(VectorMask<Integer> mask) {
|
||||
Objects.requireNonNull(mask);
|
||||
Int128Mask m = (Int128Mask)mask;
|
||||
return xor(m.not());
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
/*package-private*/
|
||||
@ -709,9 +701,9 @@ final class Int128Vector extends IntVector {
|
||||
(m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b));
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
/* package-private */
|
||||
Int128Mask xor(VectorMask<Integer> mask) {
|
||||
public Int128Mask xor(VectorMask<Integer> mask) {
|
||||
Objects.requireNonNull(mask);
|
||||
Int128Mask m = (Int128Mask)mask;
|
||||
return VectorSupport.binaryOp(VECTOR_OP_XOR, Int128Mask.class, null, int.class, VLENGTH,
|
||||
|
@ -661,14 +661,6 @@ final class Int256Vector extends IntVector {
|
||||
(m, s) -> s.maskFactory(m.toArray()).check(s));
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
public Int256Mask eq(VectorMask<Integer> mask) {
|
||||
Objects.requireNonNull(mask);
|
||||
Int256Mask m = (Int256Mask)mask;
|
||||
return xor(m.not());
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
/*package-private*/
|
||||
@ -717,9 +709,9 @@ final class Int256Vector extends IntVector {
|
||||
(m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b));
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
/* package-private */
|
||||
Int256Mask xor(VectorMask<Integer> mask) {
|
||||
public Int256Mask xor(VectorMask<Integer> mask) {
|
||||
Objects.requireNonNull(mask);
|
||||
Int256Mask m = (Int256Mask)mask;
|
||||
return VectorSupport.binaryOp(VECTOR_OP_XOR, Int256Mask.class, null, int.class, VLENGTH,
|
||||
|
@ -677,14 +677,6 @@ final class Int512Vector extends IntVector {
|
||||
(m, s) -> s.maskFactory(m.toArray()).check(s));
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
public Int512Mask eq(VectorMask<Integer> mask) {
|
||||
Objects.requireNonNull(mask);
|
||||
Int512Mask m = (Int512Mask)mask;
|
||||
return xor(m.not());
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
/*package-private*/
|
||||
@ -733,9 +725,9 @@ final class Int512Vector extends IntVector {
|
||||
(m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b));
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
/* package-private */
|
||||
Int512Mask xor(VectorMask<Integer> mask) {
|
||||
public Int512Mask xor(VectorMask<Integer> mask) {
|
||||
Objects.requireNonNull(mask);
|
||||
Int512Mask m = (Int512Mask)mask;
|
||||
return VectorSupport.binaryOp(VECTOR_OP_XOR, Int512Mask.class, null, int.class, VLENGTH,
|
||||
|
@ -649,14 +649,6 @@ final class Int64Vector extends IntVector {
|
||||
(m, s) -> s.maskFactory(m.toArray()).check(s));
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
public Int64Mask eq(VectorMask<Integer> mask) {
|
||||
Objects.requireNonNull(mask);
|
||||
Int64Mask m = (Int64Mask)mask;
|
||||
return xor(m.not());
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
/*package-private*/
|
||||
@ -705,9 +697,9 @@ final class Int64Vector extends IntVector {
|
||||
(m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b));
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
/* package-private */
|
||||
Int64Mask xor(VectorMask<Integer> mask) {
|
||||
public Int64Mask xor(VectorMask<Integer> mask) {
|
||||
Objects.requireNonNull(mask);
|
||||
Int64Mask m = (Int64Mask)mask;
|
||||
return VectorSupport.binaryOp(VECTOR_OP_XOR, Int64Mask.class, null, int.class, VLENGTH,
|
||||
|
@ -647,14 +647,6 @@ final class IntMaxVector extends IntVector {
|
||||
(m, s) -> s.maskFactory(m.toArray()).check(s));
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
public IntMaxMask eq(VectorMask<Integer> mask) {
|
||||
Objects.requireNonNull(mask);
|
||||
IntMaxMask m = (IntMaxMask)mask;
|
||||
return xor(m.not());
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
/*package-private*/
|
||||
@ -703,9 +695,9 @@ final class IntMaxVector extends IntVector {
|
||||
(m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b));
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
/* package-private */
|
||||
IntMaxMask xor(VectorMask<Integer> mask) {
|
||||
public IntMaxMask xor(VectorMask<Integer> mask) {
|
||||
Objects.requireNonNull(mask);
|
||||
IntMaxMask m = (IntMaxMask)mask;
|
||||
return VectorSupport.binaryOp(VECTOR_OP_XOR, IntMaxMask.class, null, int.class, VLENGTH,
|
||||
|
@ -639,14 +639,6 @@ final class Long128Vector extends LongVector {
|
||||
(m, s) -> s.maskFactory(m.toArray()).check(s));
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
public Long128Mask eq(VectorMask<Long> mask) {
|
||||
Objects.requireNonNull(mask);
|
||||
Long128Mask m = (Long128Mask)mask;
|
||||
return xor(m.not());
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
/*package-private*/
|
||||
@ -695,9 +687,9 @@ final class Long128Vector extends LongVector {
|
||||
(m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b));
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
/* package-private */
|
||||
Long128Mask xor(VectorMask<Long> mask) {
|
||||
public Long128Mask xor(VectorMask<Long> mask) {
|
||||
Objects.requireNonNull(mask);
|
||||
Long128Mask m = (Long128Mask)mask;
|
||||
return VectorSupport.binaryOp(VECTOR_OP_XOR, Long128Mask.class, null, long.class, VLENGTH,
|
||||
|
@ -643,14 +643,6 @@ final class Long256Vector extends LongVector {
|
||||
(m, s) -> s.maskFactory(m.toArray()).check(s));
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
public Long256Mask eq(VectorMask<Long> mask) {
|
||||
Objects.requireNonNull(mask);
|
||||
Long256Mask m = (Long256Mask)mask;
|
||||
return xor(m.not());
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
/*package-private*/
|
||||
@ -699,9 +691,9 @@ final class Long256Vector extends LongVector {
|
||||
(m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b));
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
/* package-private */
|
||||
Long256Mask xor(VectorMask<Long> mask) {
|
||||
public Long256Mask xor(VectorMask<Long> mask) {
|
||||
Objects.requireNonNull(mask);
|
||||
Long256Mask m = (Long256Mask)mask;
|
||||
return VectorSupport.binaryOp(VECTOR_OP_XOR, Long256Mask.class, null, long.class, VLENGTH,
|
||||
|
@ -651,14 +651,6 @@ final class Long512Vector extends LongVector {
|
||||
(m, s) -> s.maskFactory(m.toArray()).check(s));
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
public Long512Mask eq(VectorMask<Long> mask) {
|
||||
Objects.requireNonNull(mask);
|
||||
Long512Mask m = (Long512Mask)mask;
|
||||
return xor(m.not());
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
/*package-private*/
|
||||
@ -707,9 +699,9 @@ final class Long512Vector extends LongVector {
|
||||
(m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b));
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
/* package-private */
|
||||
Long512Mask xor(VectorMask<Long> mask) {
|
||||
public Long512Mask xor(VectorMask<Long> mask) {
|
||||
Objects.requireNonNull(mask);
|
||||
Long512Mask m = (Long512Mask)mask;
|
||||
return VectorSupport.binaryOp(VECTOR_OP_XOR, Long512Mask.class, null, long.class, VLENGTH,
|
||||
|
@ -637,14 +637,6 @@ final class Long64Vector extends LongVector {
|
||||
(m, s) -> s.maskFactory(m.toArray()).check(s));
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
public Long64Mask eq(VectorMask<Long> mask) {
|
||||
Objects.requireNonNull(mask);
|
||||
Long64Mask m = (Long64Mask)mask;
|
||||
return xor(m.not());
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
/*package-private*/
|
||||
@ -693,9 +685,9 @@ final class Long64Vector extends LongVector {
|
||||
(m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b));
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
/* package-private */
|
||||
Long64Mask xor(VectorMask<Long> mask) {
|
||||
public Long64Mask xor(VectorMask<Long> mask) {
|
||||
Objects.requireNonNull(mask);
|
||||
Long64Mask m = (Long64Mask)mask;
|
||||
return VectorSupport.binaryOp(VECTOR_OP_XOR, Long64Mask.class, null, long.class, VLENGTH,
|
||||
|
@ -637,14 +637,6 @@ final class LongMaxVector extends LongVector {
|
||||
(m, s) -> s.maskFactory(m.toArray()).check(s));
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
public LongMaxMask eq(VectorMask<Long> mask) {
|
||||
Objects.requireNonNull(mask);
|
||||
LongMaxMask m = (LongMaxMask)mask;
|
||||
return xor(m.not());
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
/*package-private*/
|
||||
@ -693,9 +685,9 @@ final class LongMaxVector extends LongVector {
|
||||
(m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b));
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
/* package-private */
|
||||
LongMaxMask xor(VectorMask<Long> mask) {
|
||||
public LongMaxMask xor(VectorMask<Long> mask) {
|
||||
Objects.requireNonNull(mask);
|
||||
LongMaxMask m = (LongMaxMask)mask;
|
||||
return VectorSupport.binaryOp(VECTOR_OP_XOR, LongMaxMask.class, null, long.class, VLENGTH,
|
||||
|
@ -661,14 +661,6 @@ final class Short128Vector extends ShortVector {
|
||||
(m, s) -> s.maskFactory(m.toArray()).check(s));
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
public Short128Mask eq(VectorMask<Short> mask) {
|
||||
Objects.requireNonNull(mask);
|
||||
Short128Mask m = (Short128Mask)mask;
|
||||
return xor(m.not());
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
/*package-private*/
|
||||
@ -717,9 +709,9 @@ final class Short128Vector extends ShortVector {
|
||||
(m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b));
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
/* package-private */
|
||||
Short128Mask xor(VectorMask<Short> mask) {
|
||||
public Short128Mask xor(VectorMask<Short> mask) {
|
||||
Objects.requireNonNull(mask);
|
||||
Short128Mask m = (Short128Mask)mask;
|
||||
return VectorSupport.binaryOp(VECTOR_OP_XOR, Short128Mask.class, null, short.class, VLENGTH,
|
||||
|
@ -677,14 +677,6 @@ final class Short256Vector extends ShortVector {
|
||||
(m, s) -> s.maskFactory(m.toArray()).check(s));
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
public Short256Mask eq(VectorMask<Short> mask) {
|
||||
Objects.requireNonNull(mask);
|
||||
Short256Mask m = (Short256Mask)mask;
|
||||
return xor(m.not());
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
/*package-private*/
|
||||
@ -733,9 +725,9 @@ final class Short256Vector extends ShortVector {
|
||||
(m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b));
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
/* package-private */
|
||||
Short256Mask xor(VectorMask<Short> mask) {
|
||||
public Short256Mask xor(VectorMask<Short> mask) {
|
||||
Objects.requireNonNull(mask);
|
||||
Short256Mask m = (Short256Mask)mask;
|
||||
return VectorSupport.binaryOp(VECTOR_OP_XOR, Short256Mask.class, null, short.class, VLENGTH,
|
||||
|
@ -709,14 +709,6 @@ final class Short512Vector extends ShortVector {
|
||||
(m, s) -> s.maskFactory(m.toArray()).check(s));
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
public Short512Mask eq(VectorMask<Short> mask) {
|
||||
Objects.requireNonNull(mask);
|
||||
Short512Mask m = (Short512Mask)mask;
|
||||
return xor(m.not());
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
/*package-private*/
|
||||
@ -765,9 +757,9 @@ final class Short512Vector extends ShortVector {
|
||||
(m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b));
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
/* package-private */
|
||||
Short512Mask xor(VectorMask<Short> mask) {
|
||||
public Short512Mask xor(VectorMask<Short> mask) {
|
||||
Objects.requireNonNull(mask);
|
||||
Short512Mask m = (Short512Mask)mask;
|
||||
return VectorSupport.binaryOp(VECTOR_OP_XOR, Short512Mask.class, null, short.class, VLENGTH,
|
||||
|
@ -653,14 +653,6 @@ final class Short64Vector extends ShortVector {
|
||||
(m, s) -> s.maskFactory(m.toArray()).check(s));
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
public Short64Mask eq(VectorMask<Short> mask) {
|
||||
Objects.requireNonNull(mask);
|
||||
Short64Mask m = (Short64Mask)mask;
|
||||
return xor(m.not());
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
/*package-private*/
|
||||
@ -709,9 +701,9 @@ final class Short64Vector extends ShortVector {
|
||||
(m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b));
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
/* package-private */
|
||||
Short64Mask xor(VectorMask<Short> mask) {
|
||||
public Short64Mask xor(VectorMask<Short> mask) {
|
||||
Objects.requireNonNull(mask);
|
||||
Short64Mask m = (Short64Mask)mask;
|
||||
return VectorSupport.binaryOp(VECTOR_OP_XOR, Short64Mask.class, null, short.class, VLENGTH,
|
||||
|
@ -647,14 +647,6 @@ final class ShortMaxVector extends ShortVector {
|
||||
(m, s) -> s.maskFactory(m.toArray()).check(s));
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
public ShortMaxMask eq(VectorMask<Short> mask) {
|
||||
Objects.requireNonNull(mask);
|
||||
ShortMaxMask m = (ShortMaxMask)mask;
|
||||
return xor(m.not());
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
/*package-private*/
|
||||
@ -703,9 +695,9 @@ final class ShortMaxVector extends ShortVector {
|
||||
(m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b));
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
/* package-private */
|
||||
ShortMaxMask xor(VectorMask<Short> mask) {
|
||||
public ShortMaxMask xor(VectorMask<Short> mask) {
|
||||
Objects.requireNonNull(mask);
|
||||
ShortMaxMask m = (ShortMaxMask)mask;
|
||||
return VectorSupport.binaryOp(VECTOR_OP_XOR, ShortMaxMask.class, null, short.class, VLENGTH,
|
||||
|
@ -398,20 +398,18 @@ public abstract class VectorMask<E> extends jdk.internal.vm.vector.VectorSupport
|
||||
public abstract VectorMask<E> or(VectorMask<E> m);
|
||||
|
||||
/**
|
||||
* Determines logical equivalence of this mask
|
||||
* to a second input mask (as boolean {@code a==b}
|
||||
* or {@code a^~b}).
|
||||
* Determines logical symmetric difference
|
||||
* (as {@code a^b}) of this mask and a second input mask.
|
||||
* <p>
|
||||
* This is a lane-wise binary operation tests each
|
||||
* corresponding pair of mask bits for equality.
|
||||
* It is also equivalent to a inverse {@code XOR}
|
||||
* operation ({@code ^~}) on the mask bits.
|
||||
* This is a lane-wise binary operation which applies
|
||||
* the logical {@code XOR} operation
|
||||
* ({@code ^}) to each corresponding pair of mask bits.
|
||||
*
|
||||
* @param m the input mask
|
||||
* @return a mask showing where the two input masks were equal
|
||||
* @see #equals
|
||||
* @return the result of logically disjunctively disjoining the two
|
||||
* input masks
|
||||
*/
|
||||
public abstract VectorMask<E> eq(VectorMask<E> m);
|
||||
public abstract VectorMask<E> xor(VectorMask<E> m);
|
||||
|
||||
/**
|
||||
* Logically subtracts a second input mask
|
||||
@ -426,6 +424,23 @@ public abstract class VectorMask<E> extends jdk.internal.vm.vector.VectorSupport
|
||||
*/
|
||||
public abstract VectorMask<E> andNot(VectorMask<E> m);
|
||||
|
||||
/**
|
||||
* Determines logical equivalence of this mask
|
||||
* to a second input mask (as boolean {@code a==b}
|
||||
* or {@code a^~b}).
|
||||
* <p>
|
||||
* This is a lane-wise binary operation tests each
|
||||
* corresponding pair of mask bits for equality.
|
||||
* It is also equivalent to the logical {@code XNOR}
|
||||
* operation ({@code ^~}) to each corresponding pair
|
||||
* of mask bits.
|
||||
*
|
||||
* @param m the input mask
|
||||
* @return a mask showing where the two input masks were equal
|
||||
* @see #equals
|
||||
*/
|
||||
public abstract VectorMask<E> eq(VectorMask<E> m);
|
||||
|
||||
/**
|
||||
* Logically negates this mask.
|
||||
* <p>
|
||||
|
@ -920,14 +920,6 @@ final class $vectortype$ extends $abstractvectortype$ {
|
||||
(m, s) -> s.maskFactory(m.toArray()).check(s));
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
public $masktype$ eq(VectorMask<$Boxtype$> mask) {
|
||||
Objects.requireNonNull(mask);
|
||||
$masktype$ m = ($masktype$)mask;
|
||||
return xor(m.not());
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
/*package-private*/
|
||||
@ -976,9 +968,9 @@ final class $vectortype$ extends $abstractvectortype$ {
|
||||
(m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b));
|
||||
}
|
||||
|
||||
@Override
|
||||
@ForceInline
|
||||
/* package-private */
|
||||
$masktype$ xor(VectorMask<$Boxtype$> mask) {
|
||||
public $masktype$ xor(VectorMask<$Boxtype$> mask) {
|
||||
Objects.requireNonNull(mask);
|
||||
$masktype$ m = ($masktype$)mask;
|
||||
return VectorSupport.binaryOp(VECTOR_OP_XOR, $masktype$.class, null, $bitstype$.class, VLENGTH,
|
||||
|
@ -5849,6 +5849,82 @@ public class Byte128VectorTests extends AbstractVectorTest {
|
||||
}
|
||||
}
|
||||
|
||||
static boolean band(boolean a, boolean b) {
|
||||
return a & b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskAndByte128VectorTestsSmokeTest(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.and(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Byte128VectorTests::band);
|
||||
}
|
||||
|
||||
static boolean bor(boolean a, boolean b) {
|
||||
return a | b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskOrByte128VectorTestsSmokeTest(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.or(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Byte128VectorTests::bor);
|
||||
}
|
||||
|
||||
static boolean bxor(boolean a, boolean b) {
|
||||
return a != b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskXorByte128VectorTestsSmokeTest(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.xor(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Byte128VectorTests::bxor);
|
||||
}
|
||||
|
||||
static boolean bandNot(boolean a, boolean b) {
|
||||
return a & !b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskAndNotByte128VectorTestsSmokeTest(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.andNot(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Byte128VectorTests::bandNot);
|
||||
}
|
||||
|
||||
static boolean beq(boolean a, boolean b) {
|
||||
return (a == b);
|
||||
}
|
||||
|
@ -5849,6 +5849,82 @@ public class Byte256VectorTests extends AbstractVectorTest {
|
||||
}
|
||||
}
|
||||
|
||||
static boolean band(boolean a, boolean b) {
|
||||
return a & b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskAndByte256VectorTestsSmokeTest(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.and(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Byte256VectorTests::band);
|
||||
}
|
||||
|
||||
static boolean bor(boolean a, boolean b) {
|
||||
return a | b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskOrByte256VectorTestsSmokeTest(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.or(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Byte256VectorTests::bor);
|
||||
}
|
||||
|
||||
static boolean bxor(boolean a, boolean b) {
|
||||
return a != b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskXorByte256VectorTestsSmokeTest(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.xor(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Byte256VectorTests::bxor);
|
||||
}
|
||||
|
||||
static boolean bandNot(boolean a, boolean b) {
|
||||
return a & !b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskAndNotByte256VectorTestsSmokeTest(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.andNot(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Byte256VectorTests::bandNot);
|
||||
}
|
||||
|
||||
static boolean beq(boolean a, boolean b) {
|
||||
return (a == b);
|
||||
}
|
||||
|
@ -5849,6 +5849,82 @@ public class Byte512VectorTests extends AbstractVectorTest {
|
||||
}
|
||||
}
|
||||
|
||||
static boolean band(boolean a, boolean b) {
|
||||
return a & b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskAndByte512VectorTestsSmokeTest(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.and(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Byte512VectorTests::band);
|
||||
}
|
||||
|
||||
static boolean bor(boolean a, boolean b) {
|
||||
return a | b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskOrByte512VectorTestsSmokeTest(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.or(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Byte512VectorTests::bor);
|
||||
}
|
||||
|
||||
static boolean bxor(boolean a, boolean b) {
|
||||
return a != b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskXorByte512VectorTestsSmokeTest(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.xor(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Byte512VectorTests::bxor);
|
||||
}
|
||||
|
||||
static boolean bandNot(boolean a, boolean b) {
|
||||
return a & !b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskAndNotByte512VectorTestsSmokeTest(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.andNot(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Byte512VectorTests::bandNot);
|
||||
}
|
||||
|
||||
static boolean beq(boolean a, boolean b) {
|
||||
return (a == b);
|
||||
}
|
||||
|
@ -5849,6 +5849,82 @@ public class Byte64VectorTests extends AbstractVectorTest {
|
||||
}
|
||||
}
|
||||
|
||||
static boolean band(boolean a, boolean b) {
|
||||
return a & b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskAndByte64VectorTestsSmokeTest(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.and(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Byte64VectorTests::band);
|
||||
}
|
||||
|
||||
static boolean bor(boolean a, boolean b) {
|
||||
return a | b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskOrByte64VectorTestsSmokeTest(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.or(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Byte64VectorTests::bor);
|
||||
}
|
||||
|
||||
static boolean bxor(boolean a, boolean b) {
|
||||
return a != b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskXorByte64VectorTestsSmokeTest(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.xor(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Byte64VectorTests::bxor);
|
||||
}
|
||||
|
||||
static boolean bandNot(boolean a, boolean b) {
|
||||
return a & !b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskAndNotByte64VectorTestsSmokeTest(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.andNot(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Byte64VectorTests::bandNot);
|
||||
}
|
||||
|
||||
static boolean beq(boolean a, boolean b) {
|
||||
return (a == b);
|
||||
}
|
||||
|
@ -5854,6 +5854,82 @@ public class ByteMaxVectorTests extends AbstractVectorTest {
|
||||
}
|
||||
}
|
||||
|
||||
static boolean band(boolean a, boolean b) {
|
||||
return a & b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskAndByteMaxVectorTestsSmokeTest(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.and(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, ByteMaxVectorTests::band);
|
||||
}
|
||||
|
||||
static boolean bor(boolean a, boolean b) {
|
||||
return a | b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskOrByteMaxVectorTestsSmokeTest(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.or(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, ByteMaxVectorTests::bor);
|
||||
}
|
||||
|
||||
static boolean bxor(boolean a, boolean b) {
|
||||
return a != b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskXorByteMaxVectorTestsSmokeTest(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.xor(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, ByteMaxVectorTests::bxor);
|
||||
}
|
||||
|
||||
static boolean bandNot(boolean a, boolean b) {
|
||||
return a & !b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskAndNotByteMaxVectorTestsSmokeTest(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.andNot(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, ByteMaxVectorTests::bandNot);
|
||||
}
|
||||
|
||||
static boolean beq(boolean a, boolean b) {
|
||||
return (a == b);
|
||||
}
|
||||
|
@ -4880,6 +4880,82 @@ public class Double128VectorTests extends AbstractVectorTest {
|
||||
}
|
||||
}
|
||||
|
||||
static boolean band(boolean a, boolean b) {
|
||||
return a & b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskAndDouble128VectorTestsSmokeTest(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.and(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Double128VectorTests::band);
|
||||
}
|
||||
|
||||
static boolean bor(boolean a, boolean b) {
|
||||
return a | b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskOrDouble128VectorTestsSmokeTest(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.or(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Double128VectorTests::bor);
|
||||
}
|
||||
|
||||
static boolean bxor(boolean a, boolean b) {
|
||||
return a != b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskXorDouble128VectorTestsSmokeTest(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.xor(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Double128VectorTests::bxor);
|
||||
}
|
||||
|
||||
static boolean bandNot(boolean a, boolean b) {
|
||||
return a & !b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskAndNotDouble128VectorTestsSmokeTest(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.andNot(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Double128VectorTests::bandNot);
|
||||
}
|
||||
|
||||
static boolean beq(boolean a, boolean b) {
|
||||
return (a == b);
|
||||
}
|
||||
|
@ -4880,6 +4880,82 @@ public class Double256VectorTests extends AbstractVectorTest {
|
||||
}
|
||||
}
|
||||
|
||||
static boolean band(boolean a, boolean b) {
|
||||
return a & b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskAndDouble256VectorTestsSmokeTest(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.and(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Double256VectorTests::band);
|
||||
}
|
||||
|
||||
static boolean bor(boolean a, boolean b) {
|
||||
return a | b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskOrDouble256VectorTestsSmokeTest(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.or(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Double256VectorTests::bor);
|
||||
}
|
||||
|
||||
static boolean bxor(boolean a, boolean b) {
|
||||
return a != b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskXorDouble256VectorTestsSmokeTest(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.xor(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Double256VectorTests::bxor);
|
||||
}
|
||||
|
||||
static boolean bandNot(boolean a, boolean b) {
|
||||
return a & !b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskAndNotDouble256VectorTestsSmokeTest(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.andNot(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Double256VectorTests::bandNot);
|
||||
}
|
||||
|
||||
static boolean beq(boolean a, boolean b) {
|
||||
return (a == b);
|
||||
}
|
||||
|
@ -4880,6 +4880,82 @@ public class Double512VectorTests extends AbstractVectorTest {
|
||||
}
|
||||
}
|
||||
|
||||
static boolean band(boolean a, boolean b) {
|
||||
return a & b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskAndDouble512VectorTestsSmokeTest(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.and(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Double512VectorTests::band);
|
||||
}
|
||||
|
||||
static boolean bor(boolean a, boolean b) {
|
||||
return a | b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskOrDouble512VectorTestsSmokeTest(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.or(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Double512VectorTests::bor);
|
||||
}
|
||||
|
||||
static boolean bxor(boolean a, boolean b) {
|
||||
return a != b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskXorDouble512VectorTestsSmokeTest(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.xor(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Double512VectorTests::bxor);
|
||||
}
|
||||
|
||||
static boolean bandNot(boolean a, boolean b) {
|
||||
return a & !b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskAndNotDouble512VectorTestsSmokeTest(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.andNot(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Double512VectorTests::bandNot);
|
||||
}
|
||||
|
||||
static boolean beq(boolean a, boolean b) {
|
||||
return (a == b);
|
||||
}
|
||||
|
@ -4880,6 +4880,82 @@ public class Double64VectorTests extends AbstractVectorTest {
|
||||
}
|
||||
}
|
||||
|
||||
static boolean band(boolean a, boolean b) {
|
||||
return a & b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskAndDouble64VectorTestsSmokeTest(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.and(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Double64VectorTests::band);
|
||||
}
|
||||
|
||||
static boolean bor(boolean a, boolean b) {
|
||||
return a | b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskOrDouble64VectorTestsSmokeTest(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.or(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Double64VectorTests::bor);
|
||||
}
|
||||
|
||||
static boolean bxor(boolean a, boolean b) {
|
||||
return a != b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskXorDouble64VectorTestsSmokeTest(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.xor(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Double64VectorTests::bxor);
|
||||
}
|
||||
|
||||
static boolean bandNot(boolean a, boolean b) {
|
||||
return a & !b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskAndNotDouble64VectorTestsSmokeTest(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.andNot(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Double64VectorTests::bandNot);
|
||||
}
|
||||
|
||||
static boolean beq(boolean a, boolean b) {
|
||||
return (a == b);
|
||||
}
|
||||
|
@ -4885,6 +4885,82 @@ public class DoubleMaxVectorTests extends AbstractVectorTest {
|
||||
}
|
||||
}
|
||||
|
||||
static boolean band(boolean a, boolean b) {
|
||||
return a & b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskAndDoubleMaxVectorTestsSmokeTest(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.and(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, DoubleMaxVectorTests::band);
|
||||
}
|
||||
|
||||
static boolean bor(boolean a, boolean b) {
|
||||
return a | b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskOrDoubleMaxVectorTestsSmokeTest(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.or(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, DoubleMaxVectorTests::bor);
|
||||
}
|
||||
|
||||
static boolean bxor(boolean a, boolean b) {
|
||||
return a != b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskXorDoubleMaxVectorTestsSmokeTest(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.xor(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, DoubleMaxVectorTests::bxor);
|
||||
}
|
||||
|
||||
static boolean bandNot(boolean a, boolean b) {
|
||||
return a & !b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskAndNotDoubleMaxVectorTestsSmokeTest(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.andNot(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, DoubleMaxVectorTests::bandNot);
|
||||
}
|
||||
|
||||
static boolean beq(boolean a, boolean b) {
|
||||
return (a == b);
|
||||
}
|
||||
|
@ -4859,6 +4859,82 @@ public class Float128VectorTests extends AbstractVectorTest {
|
||||
}
|
||||
}
|
||||
|
||||
static boolean band(boolean a, boolean b) {
|
||||
return a & b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskAndFloat128VectorTestsSmokeTest(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.and(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Float128VectorTests::band);
|
||||
}
|
||||
|
||||
static boolean bor(boolean a, boolean b) {
|
||||
return a | b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskOrFloat128VectorTestsSmokeTest(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.or(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Float128VectorTests::bor);
|
||||
}
|
||||
|
||||
static boolean bxor(boolean a, boolean b) {
|
||||
return a != b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskXorFloat128VectorTestsSmokeTest(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.xor(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Float128VectorTests::bxor);
|
||||
}
|
||||
|
||||
static boolean bandNot(boolean a, boolean b) {
|
||||
return a & !b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskAndNotFloat128VectorTestsSmokeTest(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.andNot(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Float128VectorTests::bandNot);
|
||||
}
|
||||
|
||||
static boolean beq(boolean a, boolean b) {
|
||||
return (a == b);
|
||||
}
|
||||
|
@ -4859,6 +4859,82 @@ public class Float256VectorTests extends AbstractVectorTest {
|
||||
}
|
||||
}
|
||||
|
||||
static boolean band(boolean a, boolean b) {
|
||||
return a & b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskAndFloat256VectorTestsSmokeTest(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.and(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Float256VectorTests::band);
|
||||
}
|
||||
|
||||
static boolean bor(boolean a, boolean b) {
|
||||
return a | b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskOrFloat256VectorTestsSmokeTest(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.or(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Float256VectorTests::bor);
|
||||
}
|
||||
|
||||
static boolean bxor(boolean a, boolean b) {
|
||||
return a != b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskXorFloat256VectorTestsSmokeTest(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.xor(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Float256VectorTests::bxor);
|
||||
}
|
||||
|
||||
static boolean bandNot(boolean a, boolean b) {
|
||||
return a & !b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskAndNotFloat256VectorTestsSmokeTest(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.andNot(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Float256VectorTests::bandNot);
|
||||
}
|
||||
|
||||
static boolean beq(boolean a, boolean b) {
|
||||
return (a == b);
|
||||
}
|
||||
|
@ -4859,6 +4859,82 @@ public class Float512VectorTests extends AbstractVectorTest {
|
||||
}
|
||||
}
|
||||
|
||||
static boolean band(boolean a, boolean b) {
|
||||
return a & b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskAndFloat512VectorTestsSmokeTest(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.and(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Float512VectorTests::band);
|
||||
}
|
||||
|
||||
static boolean bor(boolean a, boolean b) {
|
||||
return a | b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskOrFloat512VectorTestsSmokeTest(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.or(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Float512VectorTests::bor);
|
||||
}
|
||||
|
||||
static boolean bxor(boolean a, boolean b) {
|
||||
return a != b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskXorFloat512VectorTestsSmokeTest(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.xor(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Float512VectorTests::bxor);
|
||||
}
|
||||
|
||||
static boolean bandNot(boolean a, boolean b) {
|
||||
return a & !b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskAndNotFloat512VectorTestsSmokeTest(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.andNot(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Float512VectorTests::bandNot);
|
||||
}
|
||||
|
||||
static boolean beq(boolean a, boolean b) {
|
||||
return (a == b);
|
||||
}
|
||||
|
@ -4859,6 +4859,82 @@ public class Float64VectorTests extends AbstractVectorTest {
|
||||
}
|
||||
}
|
||||
|
||||
static boolean band(boolean a, boolean b) {
|
||||
return a & b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskAndFloat64VectorTestsSmokeTest(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.and(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Float64VectorTests::band);
|
||||
}
|
||||
|
||||
static boolean bor(boolean a, boolean b) {
|
||||
return a | b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskOrFloat64VectorTestsSmokeTest(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.or(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Float64VectorTests::bor);
|
||||
}
|
||||
|
||||
static boolean bxor(boolean a, boolean b) {
|
||||
return a != b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskXorFloat64VectorTestsSmokeTest(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.xor(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Float64VectorTests::bxor);
|
||||
}
|
||||
|
||||
static boolean bandNot(boolean a, boolean b) {
|
||||
return a & !b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskAndNotFloat64VectorTestsSmokeTest(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.andNot(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Float64VectorTests::bandNot);
|
||||
}
|
||||
|
||||
static boolean beq(boolean a, boolean b) {
|
||||
return (a == b);
|
||||
}
|
||||
|
@ -4864,6 +4864,82 @@ public class FloatMaxVectorTests extends AbstractVectorTest {
|
||||
}
|
||||
}
|
||||
|
||||
static boolean band(boolean a, boolean b) {
|
||||
return a & b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskAndFloatMaxVectorTestsSmokeTest(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.and(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, FloatMaxVectorTests::band);
|
||||
}
|
||||
|
||||
static boolean bor(boolean a, boolean b) {
|
||||
return a | b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskOrFloatMaxVectorTestsSmokeTest(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.or(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, FloatMaxVectorTests::bor);
|
||||
}
|
||||
|
||||
static boolean bxor(boolean a, boolean b) {
|
||||
return a != b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskXorFloatMaxVectorTestsSmokeTest(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.xor(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, FloatMaxVectorTests::bxor);
|
||||
}
|
||||
|
||||
static boolean bandNot(boolean a, boolean b) {
|
||||
return a & !b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskAndNotFloatMaxVectorTestsSmokeTest(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.andNot(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, FloatMaxVectorTests::bandNot);
|
||||
}
|
||||
|
||||
static boolean beq(boolean a, boolean b) {
|
||||
return (a == b);
|
||||
}
|
||||
|
@ -5882,6 +5882,82 @@ public class Int128VectorTests extends AbstractVectorTest {
|
||||
}
|
||||
}
|
||||
|
||||
static boolean band(boolean a, boolean b) {
|
||||
return a & b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskAndInt128VectorTestsSmokeTest(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.and(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Int128VectorTests::band);
|
||||
}
|
||||
|
||||
static boolean bor(boolean a, boolean b) {
|
||||
return a | b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskOrInt128VectorTestsSmokeTest(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.or(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Int128VectorTests::bor);
|
||||
}
|
||||
|
||||
static boolean bxor(boolean a, boolean b) {
|
||||
return a != b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskXorInt128VectorTestsSmokeTest(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.xor(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Int128VectorTests::bxor);
|
||||
}
|
||||
|
||||
static boolean bandNot(boolean a, boolean b) {
|
||||
return a & !b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskAndNotInt128VectorTestsSmokeTest(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.andNot(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Int128VectorTests::bandNot);
|
||||
}
|
||||
|
||||
static boolean beq(boolean a, boolean b) {
|
||||
return (a == b);
|
||||
}
|
||||
|
@ -5882,6 +5882,82 @@ public class Int256VectorTests extends AbstractVectorTest {
|
||||
}
|
||||
}
|
||||
|
||||
static boolean band(boolean a, boolean b) {
|
||||
return a & b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskAndInt256VectorTestsSmokeTest(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.and(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Int256VectorTests::band);
|
||||
}
|
||||
|
||||
static boolean bor(boolean a, boolean b) {
|
||||
return a | b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskOrInt256VectorTestsSmokeTest(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.or(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Int256VectorTests::bor);
|
||||
}
|
||||
|
||||
static boolean bxor(boolean a, boolean b) {
|
||||
return a != b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskXorInt256VectorTestsSmokeTest(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.xor(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Int256VectorTests::bxor);
|
||||
}
|
||||
|
||||
static boolean bandNot(boolean a, boolean b) {
|
||||
return a & !b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskAndNotInt256VectorTestsSmokeTest(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.andNot(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Int256VectorTests::bandNot);
|
||||
}
|
||||
|
||||
static boolean beq(boolean a, boolean b) {
|
||||
return (a == b);
|
||||
}
|
||||
|
@ -5882,6 +5882,82 @@ public class Int512VectorTests extends AbstractVectorTest {
|
||||
}
|
||||
}
|
||||
|
||||
static boolean band(boolean a, boolean b) {
|
||||
return a & b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskAndInt512VectorTestsSmokeTest(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.and(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Int512VectorTests::band);
|
||||
}
|
||||
|
||||
static boolean bor(boolean a, boolean b) {
|
||||
return a | b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskOrInt512VectorTestsSmokeTest(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.or(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Int512VectorTests::bor);
|
||||
}
|
||||
|
||||
static boolean bxor(boolean a, boolean b) {
|
||||
return a != b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskXorInt512VectorTestsSmokeTest(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.xor(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Int512VectorTests::bxor);
|
||||
}
|
||||
|
||||
static boolean bandNot(boolean a, boolean b) {
|
||||
return a & !b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskAndNotInt512VectorTestsSmokeTest(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.andNot(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Int512VectorTests::bandNot);
|
||||
}
|
||||
|
||||
static boolean beq(boolean a, boolean b) {
|
||||
return (a == b);
|
||||
}
|
||||
|
@ -5882,6 +5882,82 @@ public class Int64VectorTests extends AbstractVectorTest {
|
||||
}
|
||||
}
|
||||
|
||||
static boolean band(boolean a, boolean b) {
|
||||
return a & b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskAndInt64VectorTestsSmokeTest(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.and(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Int64VectorTests::band);
|
||||
}
|
||||
|
||||
static boolean bor(boolean a, boolean b) {
|
||||
return a | b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskOrInt64VectorTestsSmokeTest(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.or(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Int64VectorTests::bor);
|
||||
}
|
||||
|
||||
static boolean bxor(boolean a, boolean b) {
|
||||
return a != b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskXorInt64VectorTestsSmokeTest(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.xor(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Int64VectorTests::bxor);
|
||||
}
|
||||
|
||||
static boolean bandNot(boolean a, boolean b) {
|
||||
return a & !b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskAndNotInt64VectorTestsSmokeTest(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.andNot(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Int64VectorTests::bandNot);
|
||||
}
|
||||
|
||||
static boolean beq(boolean a, boolean b) {
|
||||
return (a == b);
|
||||
}
|
||||
|
@ -5887,6 +5887,82 @@ public class IntMaxVectorTests extends AbstractVectorTest {
|
||||
}
|
||||
}
|
||||
|
||||
static boolean band(boolean a, boolean b) {
|
||||
return a & b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskAndIntMaxVectorTestsSmokeTest(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.and(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, IntMaxVectorTests::band);
|
||||
}
|
||||
|
||||
static boolean bor(boolean a, boolean b) {
|
||||
return a | b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskOrIntMaxVectorTestsSmokeTest(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.or(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, IntMaxVectorTests::bor);
|
||||
}
|
||||
|
||||
static boolean bxor(boolean a, boolean b) {
|
||||
return a != b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskXorIntMaxVectorTestsSmokeTest(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.xor(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, IntMaxVectorTests::bxor);
|
||||
}
|
||||
|
||||
static boolean bandNot(boolean a, boolean b) {
|
||||
return a & !b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskAndNotIntMaxVectorTestsSmokeTest(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.andNot(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, IntMaxVectorTests::bandNot);
|
||||
}
|
||||
|
||||
static boolean beq(boolean a, boolean b) {
|
||||
return (a == b);
|
||||
}
|
||||
|
@ -5768,6 +5768,82 @@ public class Long128VectorTests extends AbstractVectorTest {
|
||||
}
|
||||
}
|
||||
|
||||
static boolean band(boolean a, boolean b) {
|
||||
return a & b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskAndLong128VectorTestsSmokeTest(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.and(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Long128VectorTests::band);
|
||||
}
|
||||
|
||||
static boolean bor(boolean a, boolean b) {
|
||||
return a | b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskOrLong128VectorTestsSmokeTest(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.or(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Long128VectorTests::bor);
|
||||
}
|
||||
|
||||
static boolean bxor(boolean a, boolean b) {
|
||||
return a != b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskXorLong128VectorTestsSmokeTest(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.xor(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Long128VectorTests::bxor);
|
||||
}
|
||||
|
||||
static boolean bandNot(boolean a, boolean b) {
|
||||
return a & !b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskAndNotLong128VectorTestsSmokeTest(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.andNot(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Long128VectorTests::bandNot);
|
||||
}
|
||||
|
||||
static boolean beq(boolean a, boolean b) {
|
||||
return (a == b);
|
||||
}
|
||||
|
@ -5768,6 +5768,82 @@ public class Long256VectorTests extends AbstractVectorTest {
|
||||
}
|
||||
}
|
||||
|
||||
static boolean band(boolean a, boolean b) {
|
||||
return a & b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskAndLong256VectorTestsSmokeTest(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.and(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Long256VectorTests::band);
|
||||
}
|
||||
|
||||
static boolean bor(boolean a, boolean b) {
|
||||
return a | b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskOrLong256VectorTestsSmokeTest(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.or(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Long256VectorTests::bor);
|
||||
}
|
||||
|
||||
static boolean bxor(boolean a, boolean b) {
|
||||
return a != b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskXorLong256VectorTestsSmokeTest(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.xor(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Long256VectorTests::bxor);
|
||||
}
|
||||
|
||||
static boolean bandNot(boolean a, boolean b) {
|
||||
return a & !b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskAndNotLong256VectorTestsSmokeTest(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.andNot(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Long256VectorTests::bandNot);
|
||||
}
|
||||
|
||||
static boolean beq(boolean a, boolean b) {
|
||||
return (a == b);
|
||||
}
|
||||
|
@ -5768,6 +5768,82 @@ public class Long512VectorTests extends AbstractVectorTest {
|
||||
}
|
||||
}
|
||||
|
||||
static boolean band(boolean a, boolean b) {
|
||||
return a & b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskAndLong512VectorTestsSmokeTest(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.and(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Long512VectorTests::band);
|
||||
}
|
||||
|
||||
static boolean bor(boolean a, boolean b) {
|
||||
return a | b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskOrLong512VectorTestsSmokeTest(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.or(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Long512VectorTests::bor);
|
||||
}
|
||||
|
||||
static boolean bxor(boolean a, boolean b) {
|
||||
return a != b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskXorLong512VectorTestsSmokeTest(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.xor(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Long512VectorTests::bxor);
|
||||
}
|
||||
|
||||
static boolean bandNot(boolean a, boolean b) {
|
||||
return a & !b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskAndNotLong512VectorTestsSmokeTest(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.andNot(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Long512VectorTests::bandNot);
|
||||
}
|
||||
|
||||
static boolean beq(boolean a, boolean b) {
|
||||
return (a == b);
|
||||
}
|
||||
|
@ -5768,6 +5768,82 @@ public class Long64VectorTests extends AbstractVectorTest {
|
||||
}
|
||||
}
|
||||
|
||||
static boolean band(boolean a, boolean b) {
|
||||
return a & b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskAndLong64VectorTestsSmokeTest(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.and(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Long64VectorTests::band);
|
||||
}
|
||||
|
||||
static boolean bor(boolean a, boolean b) {
|
||||
return a | b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskOrLong64VectorTestsSmokeTest(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.or(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Long64VectorTests::bor);
|
||||
}
|
||||
|
||||
static boolean bxor(boolean a, boolean b) {
|
||||
return a != b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskXorLong64VectorTestsSmokeTest(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.xor(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Long64VectorTests::bxor);
|
||||
}
|
||||
|
||||
static boolean bandNot(boolean a, boolean b) {
|
||||
return a & !b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskAndNotLong64VectorTestsSmokeTest(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.andNot(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Long64VectorTests::bandNot);
|
||||
}
|
||||
|
||||
static boolean beq(boolean a, boolean b) {
|
||||
return (a == b);
|
||||
}
|
||||
|
@ -5773,6 +5773,82 @@ public class LongMaxVectorTests extends AbstractVectorTest {
|
||||
}
|
||||
}
|
||||
|
||||
static boolean band(boolean a, boolean b) {
|
||||
return a & b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskAndLongMaxVectorTestsSmokeTest(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.and(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, LongMaxVectorTests::band);
|
||||
}
|
||||
|
||||
static boolean bor(boolean a, boolean b) {
|
||||
return a | b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskOrLongMaxVectorTestsSmokeTest(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.or(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, LongMaxVectorTests::bor);
|
||||
}
|
||||
|
||||
static boolean bxor(boolean a, boolean b) {
|
||||
return a != b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskXorLongMaxVectorTestsSmokeTest(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.xor(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, LongMaxVectorTests::bxor);
|
||||
}
|
||||
|
||||
static boolean bandNot(boolean a, boolean b) {
|
||||
return a & !b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskAndNotLongMaxVectorTestsSmokeTest(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.andNot(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, LongMaxVectorTests::bandNot);
|
||||
}
|
||||
|
||||
static boolean beq(boolean a, boolean b) {
|
||||
return (a == b);
|
||||
}
|
||||
|
@ -5829,6 +5829,82 @@ public class Short128VectorTests extends AbstractVectorTest {
|
||||
}
|
||||
}
|
||||
|
||||
static boolean band(boolean a, boolean b) {
|
||||
return a & b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskAndShort128VectorTestsSmokeTest(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.and(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Short128VectorTests::band);
|
||||
}
|
||||
|
||||
static boolean bor(boolean a, boolean b) {
|
||||
return a | b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskOrShort128VectorTestsSmokeTest(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.or(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Short128VectorTests::bor);
|
||||
}
|
||||
|
||||
static boolean bxor(boolean a, boolean b) {
|
||||
return a != b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskXorShort128VectorTestsSmokeTest(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.xor(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Short128VectorTests::bxor);
|
||||
}
|
||||
|
||||
static boolean bandNot(boolean a, boolean b) {
|
||||
return a & !b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskAndNotShort128VectorTestsSmokeTest(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.andNot(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Short128VectorTests::bandNot);
|
||||
}
|
||||
|
||||
static boolean beq(boolean a, boolean b) {
|
||||
return (a == b);
|
||||
}
|
||||
|
@ -5829,6 +5829,82 @@ public class Short256VectorTests extends AbstractVectorTest {
|
||||
}
|
||||
}
|
||||
|
||||
static boolean band(boolean a, boolean b) {
|
||||
return a & b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskAndShort256VectorTestsSmokeTest(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.and(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Short256VectorTests::band);
|
||||
}
|
||||
|
||||
static boolean bor(boolean a, boolean b) {
|
||||
return a | b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskOrShort256VectorTestsSmokeTest(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.or(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Short256VectorTests::bor);
|
||||
}
|
||||
|
||||
static boolean bxor(boolean a, boolean b) {
|
||||
return a != b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskXorShort256VectorTestsSmokeTest(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.xor(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Short256VectorTests::bxor);
|
||||
}
|
||||
|
||||
static boolean bandNot(boolean a, boolean b) {
|
||||
return a & !b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskAndNotShort256VectorTestsSmokeTest(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.andNot(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Short256VectorTests::bandNot);
|
||||
}
|
||||
|
||||
static boolean beq(boolean a, boolean b) {
|
||||
return (a == b);
|
||||
}
|
||||
|
@ -5829,6 +5829,82 @@ public class Short512VectorTests extends AbstractVectorTest {
|
||||
}
|
||||
}
|
||||
|
||||
static boolean band(boolean a, boolean b) {
|
||||
return a & b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskAndShort512VectorTestsSmokeTest(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.and(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Short512VectorTests::band);
|
||||
}
|
||||
|
||||
static boolean bor(boolean a, boolean b) {
|
||||
return a | b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskOrShort512VectorTestsSmokeTest(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.or(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Short512VectorTests::bor);
|
||||
}
|
||||
|
||||
static boolean bxor(boolean a, boolean b) {
|
||||
return a != b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskXorShort512VectorTestsSmokeTest(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.xor(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Short512VectorTests::bxor);
|
||||
}
|
||||
|
||||
static boolean bandNot(boolean a, boolean b) {
|
||||
return a & !b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskAndNotShort512VectorTestsSmokeTest(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.andNot(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Short512VectorTests::bandNot);
|
||||
}
|
||||
|
||||
static boolean beq(boolean a, boolean b) {
|
||||
return (a == b);
|
||||
}
|
||||
|
@ -5829,6 +5829,82 @@ public class Short64VectorTests extends AbstractVectorTest {
|
||||
}
|
||||
}
|
||||
|
||||
static boolean band(boolean a, boolean b) {
|
||||
return a & b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskAndShort64VectorTestsSmokeTest(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.and(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Short64VectorTests::band);
|
||||
}
|
||||
|
||||
static boolean bor(boolean a, boolean b) {
|
||||
return a | b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskOrShort64VectorTestsSmokeTest(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.or(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Short64VectorTests::bor);
|
||||
}
|
||||
|
||||
static boolean bxor(boolean a, boolean b) {
|
||||
return a != b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskXorShort64VectorTestsSmokeTest(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.xor(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Short64VectorTests::bxor);
|
||||
}
|
||||
|
||||
static boolean bandNot(boolean a, boolean b) {
|
||||
return a & !b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskAndNotShort64VectorTestsSmokeTest(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.andNot(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, Short64VectorTests::bandNot);
|
||||
}
|
||||
|
||||
static boolean beq(boolean a, boolean b) {
|
||||
return (a == b);
|
||||
}
|
||||
|
@ -5834,6 +5834,82 @@ public class ShortMaxVectorTests extends AbstractVectorTest {
|
||||
}
|
||||
}
|
||||
|
||||
static boolean band(boolean a, boolean b) {
|
||||
return a & b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskAndShortMaxVectorTestsSmokeTest(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.and(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, ShortMaxVectorTests::band);
|
||||
}
|
||||
|
||||
static boolean bor(boolean a, boolean b) {
|
||||
return a | b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskOrShortMaxVectorTestsSmokeTest(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.or(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, ShortMaxVectorTests::bor);
|
||||
}
|
||||
|
||||
static boolean bxor(boolean a, boolean b) {
|
||||
return a != b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskXorShortMaxVectorTestsSmokeTest(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.xor(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, ShortMaxVectorTests::bxor);
|
||||
}
|
||||
|
||||
static boolean bandNot(boolean a, boolean b) {
|
||||
return a & !b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskAndNotShortMaxVectorTestsSmokeTest(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.andNot(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, ShortMaxVectorTests::bandNot);
|
||||
}
|
||||
|
||||
static boolean beq(boolean a, boolean b) {
|
||||
return (a == b);
|
||||
}
|
||||
|
@ -378,6 +378,82 @@
|
||||
}
|
||||
}
|
||||
|
||||
static boolean band(boolean a, boolean b) {
|
||||
return a & b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskAnd$vectorteststype$SmokeTest(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.and(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, $vectorteststype$::band);
|
||||
}
|
||||
|
||||
static boolean bor(boolean a, boolean b) {
|
||||
return a | b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskOr$vectorteststype$SmokeTest(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.or(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, $vectorteststype$::bor);
|
||||
}
|
||||
|
||||
static boolean bxor(boolean a, boolean b) {
|
||||
return a != b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskXor$vectorteststype$SmokeTest(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.xor(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, $vectorteststype$::bxor);
|
||||
}
|
||||
|
||||
static boolean bandNot(boolean a, boolean b) {
|
||||
return a & !b;
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maskCompareOpProvider")
|
||||
static void maskAndNot$vectorteststype$SmokeTest(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.andNot(bv);
|
||||
cv.intoArray(r, i);
|
||||
}
|
||||
assertArraysEquals(r, a, b, $vectorteststype$::bandNot);
|
||||
}
|
||||
|
||||
static boolean beq(boolean a, boolean b) {
|
||||
return (a == b);
|
||||
}
|
||||
|
Loading…
x
Reference in New Issue
Block a user