< prev index next >
test/jdk/jdk/incubator/vector/VectorReshapeTests.java
Print this page
rev 54658 : refactored mask and shuffle creation methods, moved classes to top-level
@@ -7,12 +7,12 @@
import java.lang.invoke.MethodHandles;
import java.lang.invoke.VarHandle;
import java.util.Arrays;
import java.util.List;
import java.util.function.IntFunction;
-import jdk.incubator.vector.Vector.Shape;
-import jdk.incubator.vector.Vector.Species;
+import jdk.incubator.vector.VectorShape;
+import jdk.incubator.vector.VectorSpecies;
/**
* @test
* @modules jdk.incubator.vector
* @modules java.base/jdk.internal.vm.annotation
@@ -23,49 +23,49 @@
@Test
public class VectorReshapeTests {
static final int INVOC_COUNT = Integer.getInteger("jdk.incubator.vector.test.loop-iterations", 100);
static final int NUM_ITER = 200 * INVOC_COUNT;
- static final Shape S_Max_BIT = getMaxBit();
+ static final VectorShape S_Max_BIT = getMaxBit();
- static final Species<Integer> ispec64 = IntVector.SPECIES_64;
- static final Species<Float> fspec64 = FloatVector.SPECIES_64;
- static final Species<Long> lspec64 = LongVector.SPECIES_64;
- static final Species<Double> dspec64 = DoubleVector.SPECIES_64;
- static final Species<Byte> bspec64 = ByteVector.SPECIES_64;
- static final Species<Short> sspec64 = ShortVector.SPECIES_64;
-
- static final Species<Integer> ispec128 = IntVector.SPECIES_128;
- static final Species<Float> fspec128 = FloatVector.SPECIES_128;
- static final Species<Long> lspec128 = LongVector.SPECIES_128;
- static final Species<Double> dspec128 = DoubleVector.SPECIES_128;
- static final Species<Byte> bspec128 = ByteVector.SPECIES_128;
- static final Species<Short> sspec128 = ShortVector.SPECIES_128;
-
- static final Species<Integer> ispec256 = IntVector.SPECIES_256;
- static final Species<Float> fspec256 = FloatVector.SPECIES_256;
- static final Species<Long> lspec256 = LongVector.SPECIES_256;
- static final Species<Double> dspec256 = DoubleVector.SPECIES_256;
- static final Species<Byte> bspec256 = ByteVector.SPECIES_256;
- static final Species<Short> sspec256 = ShortVector.SPECIES_256;
-
- static final Species<Integer> ispec512 = IntVector.SPECIES_512;
- static final Species<Float> fspec512 = FloatVector.SPECIES_512;
- static final Species<Long> lspec512 = LongVector.SPECIES_512;
- static final Species<Double> dspec512 = DoubleVector.SPECIES_512;
- static final Species<Byte> bspec512 = ByteVector.SPECIES_512;
- static final Species<Short> sspec512 = ShortVector.SPECIES_512;
-
- static final Species<Integer> ispecMax = IntVector.SPECIES_MAX;
- static final Species<Float> fspecMax = FloatVector.SPECIES_MAX;
- static final Species<Long> lspecMax = LongVector.SPECIES_MAX;
- static final Species<Double> dspecMax = DoubleVector.SPECIES_MAX;
- static final Species<Byte> bspecMax = ByteVector.SPECIES_MAX;
- static final Species<Short> sspecMax = ShortVector.SPECIES_MAX;
+ static final VectorSpecies<Integer> ispec64 = IntVector.SPECIES_64;
+ static final VectorSpecies<Float> fspec64 = FloatVector.SPECIES_64;
+ static final VectorSpecies<Long> lspec64 = LongVector.SPECIES_64;
+ static final VectorSpecies<Double> dspec64 = DoubleVector.SPECIES_64;
+ static final VectorSpecies<Byte> bspec64 = ByteVector.SPECIES_64;
+ static final VectorSpecies<Short> sspec64 = ShortVector.SPECIES_64;
+
+ static final VectorSpecies<Integer> ispec128 = IntVector.SPECIES_128;
+ static final VectorSpecies<Float> fspec128 = FloatVector.SPECIES_128;
+ static final VectorSpecies<Long> lspec128 = LongVector.SPECIES_128;
+ static final VectorSpecies<Double> dspec128 = DoubleVector.SPECIES_128;
+ static final VectorSpecies<Byte> bspec128 = ByteVector.SPECIES_128;
+ static final VectorSpecies<Short> sspec128 = ShortVector.SPECIES_128;
+
+ static final VectorSpecies<Integer> ispec256 = IntVector.SPECIES_256;
+ static final VectorSpecies<Float> fspec256 = FloatVector.SPECIES_256;
+ static final VectorSpecies<Long> lspec256 = LongVector.SPECIES_256;
+ static final VectorSpecies<Double> dspec256 = DoubleVector.SPECIES_256;
+ static final VectorSpecies<Byte> bspec256 = ByteVector.SPECIES_256;
+ static final VectorSpecies<Short> sspec256 = ShortVector.SPECIES_256;
+
+ static final VectorSpecies<Integer> ispec512 = IntVector.SPECIES_512;
+ static final VectorSpecies<Float> fspec512 = FloatVector.SPECIES_512;
+ static final VectorSpecies<Long> lspec512 = LongVector.SPECIES_512;
+ static final VectorSpecies<Double> dspec512 = DoubleVector.SPECIES_512;
+ static final VectorSpecies<Byte> bspec512 = ByteVector.SPECIES_512;
+ static final VectorSpecies<Short> sspec512 = ShortVector.SPECIES_512;
+
+ static final VectorSpecies<Integer> ispecMax = IntVector.SPECIES_MAX;
+ static final VectorSpecies<Float> fspecMax = FloatVector.SPECIES_MAX;
+ static final VectorSpecies<Long> lspecMax = LongVector.SPECIES_MAX;
+ static final VectorSpecies<Double> dspecMax = DoubleVector.SPECIES_MAX;
+ static final VectorSpecies<Byte> bspecMax = ByteVector.SPECIES_MAX;
+ static final VectorSpecies<Short> sspecMax = ShortVector.SPECIES_MAX;
- static Shape getMaxBit() {
- return Shape.S_Max_BIT;
+ static VectorShape getMaxBit() {
+ return VectorShape.S_Max_BIT;
}
static <T> IntFunction<T> withToString(String s, IntFunction<T> f) {
return new IntFunction<T>() {
@Override
@@ -276,25 +276,25 @@
toArray(Object[][]::new);
}
@ForceInline
static <E>
- void testVectorReshape(Vector.Species<E> a, Vector.Species<E> b, byte[] input, byte[] output) {
+ void testVectorReshape(VectorSpecies<E> a, VectorSpecies<E> b, byte[] input, byte[] output) {
Vector<E> av;
Class<?> stype = a.elementType();
if (stype == byte.class) {
- av = (Vector) ByteVector.fromByteArray((Species<Byte>)a, input, 0);
+ av = (Vector) ByteVector.fromByteArray((VectorSpecies<Byte>)a, input, 0);
} else if (stype == short.class) {
- av = (Vector) ShortVector.fromByteArray((Species<Short>)a, input, 0);
+ av = (Vector) ShortVector.fromByteArray((VectorSpecies<Short>)a, input, 0);
} else if (stype == int.class) {
- av = (Vector) IntVector.fromByteArray((Species<Integer>)a, input, 0);
+ av = (Vector) IntVector.fromByteArray((VectorSpecies<Integer>)a, input, 0);
} else if (stype == long.class) {
- av = (Vector) LongVector.fromByteArray((Species<Long>)a, input, 0);
+ av = (Vector) LongVector.fromByteArray((VectorSpecies<Long>)a, input, 0);
} else if (stype == float.class) {
- av = (Vector) FloatVector.fromByteArray((Species<Float>)a, input, 0);
+ av = (Vector) FloatVector.fromByteArray((VectorSpecies<Float>)a, input, 0);
} else if (stype == double.class) {
- av = (Vector) DoubleVector.fromByteArray((Species<Double>)a, input, 0);
+ av = (Vector) DoubleVector.fromByteArray((VectorSpecies<Double>)a, input, 0);
} else {
throw new UnsupportedOperationException("Bad lane type");
}
Vector<E> bv = av.reshape(b);
bv.intoByteArray(output, 0);
@@ -581,27 +581,27 @@
}
}
@ForceInline
static <E,F>
- void testVectorRebracket(Vector.Species<E> a, Vector.Species<F> b, byte[] input, byte[] output) {
+ void testVectorRebracket(VectorSpecies<E> a, VectorSpecies<F> b, byte[] input, byte[] output) {
assert(input.length == output.length);
Vector<E> av;
Class<?> stype = a.elementType();
if (stype == byte.class) {
- av = (Vector) ByteVector.fromByteArray((Species<Byte>)a, input, 0);
+ av = (Vector) ByteVector.fromByteArray((VectorSpecies<Byte>)a, input, 0);
} else if (stype == short.class) {
- av = (Vector) ShortVector.fromByteArray((Species<Short>)a, input, 0);
+ av = (Vector) ShortVector.fromByteArray((VectorSpecies<Short>)a, input, 0);
} else if (stype == int.class) {
- av = (Vector) IntVector.fromByteArray((Species<Integer>)a, input, 0);
+ av = (Vector) IntVector.fromByteArray((VectorSpecies<Integer>)a, input, 0);
} else if (stype == long.class) {
- av = (Vector) LongVector.fromByteArray((Species<Long>)a, input, 0);
+ av = (Vector) LongVector.fromByteArray((VectorSpecies<Long>)a, input, 0);
} else if (stype == float.class) {
- av = (Vector) FloatVector.fromByteArray((Species<Float>)a, input, 0);
+ av = (Vector) FloatVector.fromByteArray((VectorSpecies<Float>)a, input, 0);
} else if (stype == double.class) {
- av = (Vector) DoubleVector.fromByteArray((Species<Double>)a, input, 0);
+ av = (Vector) DoubleVector.fromByteArray((VectorSpecies<Double>)a, input, 0);
} else {
throw new UnsupportedOperationException("Bad lane type");
}
Vector<F> bv = av.reinterpret(b);
bv.intoByteArray(output, 0);
@@ -854,11 +854,11 @@
}
}
@ForceInline
static
- void testVectorCastByteToFloat(Species<Byte> a, Species<Float> b, byte[] input, float[] output) {
+ void testVectorCastByteToFloat(VectorSpecies<Byte> a, VectorSpecies<Float> b, byte[] input, float[] output) {
assert(input.length == a.length());
assert(output.length == b.length());
ByteVector av = ByteVector.fromArray(a, input, 0);
FloatVector bv = (FloatVector) av.cast(b);
@@ -872,11 +872,11 @@
}
}
@ForceInline
static
- void testVectorCastByteToFloatFail(Species<Byte> a, Species<Float> b, byte[] input) {
+ void testVectorCastByteToFloatFail(VectorSpecies<Byte> a, VectorSpecies<Float> b, byte[] input) {
assert(input.length == a.length());
ByteVector av = ByteVector.fromArray(a, input, 0);
try {
av.cast(b);
@@ -887,11 +887,11 @@
}
}
@ForceInline
static
- void testVectorCastShortToFloat(Species<Short> a, Species<Float> b, short[] input, float[] output) {
+ void testVectorCastShortToFloat(VectorSpecies<Short> a, VectorSpecies<Float> b, short[] input, float[] output) {
assert(input.length == a.length());
assert(output.length == b.length());
ShortVector av = ShortVector.fromArray(a, input, 0);
FloatVector bv = (FloatVector) av.cast(b);
@@ -905,11 +905,11 @@
}
}
@ForceInline
static
- void testVectorCastShortToFloatFail(Species<Short> a, Species<Float> b, short[] input) {
+ void testVectorCastShortToFloatFail(VectorSpecies<Short> a, VectorSpecies<Float> b, short[] input) {
assert(input.length == a.length());
ShortVector av = ShortVector.fromArray(a, input, 0);
try {
av.cast(b);
@@ -920,11 +920,11 @@
}
}
@ForceInline
static
- void testVectorCastIntToFloat(Species<Integer> a, Species<Float> b, int[] input, float[] output) {
+ void testVectorCastIntToFloat(VectorSpecies<Integer> a, VectorSpecies<Float> b, int[] input, float[] output) {
assert(input.length == a.length());
assert(output.length == b.length());
IntVector av = IntVector.fromArray(a, input, 0);
FloatVector bv = (FloatVector) av.cast(b);
@@ -938,11 +938,11 @@
}
}
@ForceInline
static
- void testVectorCastIntToFloatFail(Species<Integer> a, Species<Float> b, int[] input) {
+ void testVectorCastIntToFloatFail(VectorSpecies<Integer> a, VectorSpecies<Float> b, int[] input) {
assert(input.length == a.length());
IntVector av = IntVector.fromArray(a, input, 0);
try {
av.cast(b);
@@ -953,11 +953,11 @@
}
}
@ForceInline
static
- void testVectorCastLongToFloat(Species<Long> a, Species<Float> b, long[] input, float[] output) {
+ void testVectorCastLongToFloat(VectorSpecies<Long> a, VectorSpecies<Float> b, long[] input, float[] output) {
assert(input.length == a.length());
assert(output.length == b.length());
LongVector av = LongVector.fromArray(a, input, 0);
FloatVector bv = (FloatVector) av.cast(b);
@@ -971,11 +971,11 @@
}
}
@ForceInline
static
- void testVectorCastLongToFloatFail(Species<Long> a, Species<Float> b, long[] input) {
+ void testVectorCastLongToFloatFail(VectorSpecies<Long> a, VectorSpecies<Float> b, long[] input) {
assert(input.length == a.length());
LongVector av = LongVector.fromArray(a, input, 0);
try {
av.cast(b);
@@ -986,11 +986,11 @@
}
}
@ForceInline
static
- void testVectorCastFloatToFloat(Species<Float> a, Species<Float> b, float[] input, float[] output) {
+ void testVectorCastFloatToFloat(VectorSpecies<Float> a, VectorSpecies<Float> b, float[] input, float[] output) {
assert(input.length == a.length());
assert(output.length == b.length());
FloatVector av = FloatVector.fromArray(a, input, 0);
FloatVector bv = (FloatVector) av.cast(b);
@@ -1004,11 +1004,11 @@
}
}
@ForceInline
static
- void testVectorCastFloatToFloatFail(Species<Float> a, Species<Float> b, float[] input) {
+ void testVectorCastFloatToFloatFail(VectorSpecies<Float> a, VectorSpecies<Float> b, float[] input) {
assert(input.length == a.length());
FloatVector av = FloatVector.fromArray(a, input, 0);
try {
av.cast(b);
@@ -1019,11 +1019,11 @@
}
}
@ForceInline
static
- void testVectorCastDoubleToFloat(Species<Double> a, Species<Float> b, double[] input, float[] output) {
+ void testVectorCastDoubleToFloat(VectorSpecies<Double> a, VectorSpecies<Float> b, double[] input, float[] output) {
assert(input.length == a.length());
assert(output.length == b.length());
DoubleVector av = DoubleVector.fromArray(a, input, 0);
FloatVector bv = (FloatVector) av.cast(b);
@@ -1037,11 +1037,11 @@
}
}
@ForceInline
static
- void testVectorCastDoubleToFloatFail(Species<Double> a, Species<Float> b, double[] input) {
+ void testVectorCastDoubleToFloatFail(VectorSpecies<Double> a, VectorSpecies<Float> b, double[] input) {
assert(input.length == a.length());
DoubleVector av = DoubleVector.fromArray(a, input, 0);
try {
av.cast(b);
@@ -1052,11 +1052,11 @@
}
}
@ForceInline
static
- void testVectorCastByteToByte(Species<Byte> a, Species<Byte> b, byte[] input, byte[] output) {
+ void testVectorCastByteToByte(VectorSpecies<Byte> a, VectorSpecies<Byte> b, byte[] input, byte[] output) {
assert(input.length == a.length());
assert(output.length == b.length());
ByteVector av = ByteVector.fromArray(a, input, 0);
ByteVector bv = (ByteVector) av.cast(b);
@@ -1070,11 +1070,11 @@
}
}
@ForceInline
static
- void testVectorCastByteToByteFail(Species<Byte> a, Species<Byte> b, byte[] input) {
+ void testVectorCastByteToByteFail(VectorSpecies<Byte> a, VectorSpecies<Byte> b, byte[] input) {
assert(input.length == a.length());
ByteVector av = ByteVector.fromArray(a, input, 0);
try {
av.cast(b);
@@ -1085,11 +1085,11 @@
}
}
@ForceInline
static
- void testVectorCastShortToByte(Species<Short> a, Species<Byte> b, short[] input, byte[] output) {
+ void testVectorCastShortToByte(VectorSpecies<Short> a, VectorSpecies<Byte> b, short[] input, byte[] output) {
assert(input.length == a.length());
assert(output.length == b.length());
ShortVector av = ShortVector.fromArray(a, input, 0);
ByteVector bv = (ByteVector) av.cast(b);
@@ -1103,11 +1103,11 @@
}
}
@ForceInline
static
- void testVectorCastShortToByteFail(Species<Short> a, Species<Byte> b, short[] input) {
+ void testVectorCastShortToByteFail(VectorSpecies<Short> a, VectorSpecies<Byte> b, short[] input) {
assert(input.length == a.length());
ShortVector av = ShortVector.fromArray(a, input, 0);
try {
av.cast(b);
@@ -1118,11 +1118,11 @@
}
}
@ForceInline
static
- void testVectorCastIntToByte(Species<Integer> a, Species<Byte> b, int[] input, byte[] output) {
+ void testVectorCastIntToByte(VectorSpecies<Integer> a, VectorSpecies<Byte> b, int[] input, byte[] output) {
assert(input.length == a.length());
assert(output.length == b.length());
IntVector av = IntVector.fromArray(a, input, 0);
ByteVector bv = (ByteVector) av.cast(b);
@@ -1136,11 +1136,11 @@
}
}
@ForceInline
static
- void testVectorCastIntToByteFail(Species<Integer> a, Species<Byte> b, int[] input) {
+ void testVectorCastIntToByteFail(VectorSpecies<Integer> a, VectorSpecies<Byte> b, int[] input) {
assert(input.length == a.length());
IntVector av = IntVector.fromArray(a, input, 0);
try {
av.cast(b);
@@ -1151,11 +1151,11 @@
}
}
@ForceInline
static
- void testVectorCastLongToByte(Species<Long> a, Species<Byte> b, long[] input, byte[] output) {
+ void testVectorCastLongToByte(VectorSpecies<Long> a, VectorSpecies<Byte> b, long[] input, byte[] output) {
assert(input.length == a.length());
assert(output.length == b.length());
LongVector av = LongVector.fromArray(a, input, 0);
ByteVector bv = (ByteVector) av.cast(b);
@@ -1169,11 +1169,11 @@
}
}
@ForceInline
static
- void testVectorCastLongToByteFail(Species<Long> a, Species<Byte> b, long[] input) {
+ void testVectorCastLongToByteFail(VectorSpecies<Long> a, VectorSpecies<Byte> b, long[] input) {
assert(input.length == a.length());
LongVector av = LongVector.fromArray(a, input, 0);
try {
av.cast(b);
@@ -1184,11 +1184,11 @@
}
}
@ForceInline
static
- void testVectorCastFloatToByte(Species<Float> a, Species<Byte> b, float[] input, byte[] output) {
+ void testVectorCastFloatToByte(VectorSpecies<Float> a, VectorSpecies<Byte> b, float[] input, byte[] output) {
assert(input.length == a.length());
assert(output.length == b.length());
FloatVector av = FloatVector.fromArray(a, input, 0);
ByteVector bv = (ByteVector) av.cast(b);
@@ -1202,11 +1202,11 @@
}
}
@ForceInline
static
- void testVectorCastFloatToByteFail(Species<Float> a, Species<Byte> b, float[] input) {
+ void testVectorCastFloatToByteFail(VectorSpecies<Float> a, VectorSpecies<Byte> b, float[] input) {
assert(input.length == a.length());
FloatVector av = FloatVector.fromArray(a, input, 0);
try {
av.cast(b);
@@ -1217,11 +1217,11 @@
}
}
@ForceInline
static
- void testVectorCastDoubleToByte(Species<Double> a, Species<Byte> b, double[] input, byte[] output) {
+ void testVectorCastDoubleToByte(VectorSpecies<Double> a, VectorSpecies<Byte> b, double[] input, byte[] output) {
assert(input.length == a.length());
assert(output.length == b.length());
DoubleVector av = DoubleVector.fromArray(a, input, 0);
ByteVector bv = (ByteVector) av.cast(b);
@@ -1235,11 +1235,11 @@
}
}
@ForceInline
static
- void testVectorCastDoubleToByteFail(Species<Double> a, Species<Byte> b, double[] input) {
+ void testVectorCastDoubleToByteFail(VectorSpecies<Double> a, VectorSpecies<Byte> b, double[] input) {
assert(input.length == a.length());
DoubleVector av = DoubleVector.fromArray(a, input, 0);
try {
av.cast(b);
@@ -1250,11 +1250,11 @@
}
}
@ForceInline
static
- void testVectorCastByteToShort(Species<Byte> a, Species<Short> b, byte[] input, short[] output) {
+ void testVectorCastByteToShort(VectorSpecies<Byte> a, VectorSpecies<Short> b, byte[] input, short[] output) {
assert(input.length == a.length());
assert(output.length == b.length());
ByteVector av = ByteVector.fromArray(a, input, 0);
ShortVector bv = (ShortVector) av.cast(b);
@@ -1268,11 +1268,11 @@
}
}
@ForceInline
static
- void testVectorCastByteToShortFail(Species<Byte> a, Species<Short> b, byte[] input) {
+ void testVectorCastByteToShortFail(VectorSpecies<Byte> a, VectorSpecies<Short> b, byte[] input) {
assert(input.length == a.length());
ByteVector av = ByteVector.fromArray(a, input, 0);
try {
av.cast(b);
@@ -1283,11 +1283,11 @@
}
}
@ForceInline
static
- void testVectorCastShortToShort(Species<Short> a, Species<Short> b, short[] input, short[] output) {
+ void testVectorCastShortToShort(VectorSpecies<Short> a, VectorSpecies<Short> b, short[] input, short[] output) {
assert(input.length == a.length());
assert(output.length == b.length());
ShortVector av = ShortVector.fromArray(a, input, 0);
ShortVector bv = (ShortVector) av.cast(b);
@@ -1301,11 +1301,11 @@
}
}
@ForceInline
static
- void testVectorCastShortToShortFail(Species<Short> a, Species<Short> b, short[] input) {
+ void testVectorCastShortToShortFail(VectorSpecies<Short> a, VectorSpecies<Short> b, short[] input) {
assert(input.length == a.length());
ShortVector av = ShortVector.fromArray(a, input, 0);
try {
av.cast(b);
@@ -1316,11 +1316,11 @@
}
}
@ForceInline
static
- void testVectorCastIntToShort(Species<Integer> a, Species<Short> b, int[] input, short[] output) {
+ void testVectorCastIntToShort(VectorSpecies<Integer> a, VectorSpecies<Short> b, int[] input, short[] output) {
assert(input.length == a.length());
assert(output.length == b.length());
IntVector av = IntVector.fromArray(a, input, 0);
ShortVector bv = (ShortVector) av.cast(b);
@@ -1334,11 +1334,11 @@
}
}
@ForceInline
static
- void testVectorCastIntToShortFail(Species<Integer> a, Species<Short> b, int[] input) {
+ void testVectorCastIntToShortFail(VectorSpecies<Integer> a, VectorSpecies<Short> b, int[] input) {
assert(input.length == a.length());
IntVector av = IntVector.fromArray(a, input, 0);
try {
av.cast(b);
@@ -1349,11 +1349,11 @@
}
}
@ForceInline
static
- void testVectorCastLongToShort(Species<Long> a, Species<Short> b, long[] input, short[] output) {
+ void testVectorCastLongToShort(VectorSpecies<Long> a, VectorSpecies<Short> b, long[] input, short[] output) {
assert(input.length == a.length());
assert(output.length == b.length());
LongVector av = LongVector.fromArray(a, input, 0);
ShortVector bv = (ShortVector) av.cast(b);
@@ -1367,11 +1367,11 @@
}
}
@ForceInline
static
- void testVectorCastLongToShortFail(Species<Long> a, Species<Short> b, long[] input) {
+ void testVectorCastLongToShortFail(VectorSpecies<Long> a, VectorSpecies<Short> b, long[] input) {
assert(input.length == a.length());
LongVector av = LongVector.fromArray(a, input, 0);
try {
av.cast(b);
@@ -1382,11 +1382,11 @@
}
}
@ForceInline
static
- void testVectorCastFloatToShort(Species<Float> a, Species<Short> b, float[] input, short[] output) {
+ void testVectorCastFloatToShort(VectorSpecies<Float> a, VectorSpecies<Short> b, float[] input, short[] output) {
assert(input.length == a.length());
assert(output.length == b.length());
FloatVector av = FloatVector.fromArray(a, input, 0);
ShortVector bv = (ShortVector) av.cast(b);
@@ -1400,11 +1400,11 @@
}
}
@ForceInline
static
- void testVectorCastFloatToShortFail(Species<Float> a, Species<Short> b, float[] input) {
+ void testVectorCastFloatToShortFail(VectorSpecies<Float> a, VectorSpecies<Short> b, float[] input) {
assert(input.length == a.length());
FloatVector av = FloatVector.fromArray(a, input, 0);
try {
av.cast(b);
@@ -1415,11 +1415,11 @@
}
}
@ForceInline
static
- void testVectorCastDoubleToShort(Species<Double> a, Species<Short> b, double[] input, short[] output) {
+ void testVectorCastDoubleToShort(VectorSpecies<Double> a, VectorSpecies<Short> b, double[] input, short[] output) {
assert(input.length == a.length());
assert(output.length == b.length());
DoubleVector av = DoubleVector.fromArray(a, input, 0);
ShortVector bv = (ShortVector) av.cast(b);
@@ -1433,11 +1433,11 @@
}
}
@ForceInline
static
- void testVectorCastDoubleToShortFail(Species<Double> a, Species<Short> b, double[] input) {
+ void testVectorCastDoubleToShortFail(VectorSpecies<Double> a, VectorSpecies<Short> b, double[] input) {
assert(input.length == a.length());
DoubleVector av = DoubleVector.fromArray(a, input, 0);
try {
av.cast(b);
@@ -1448,11 +1448,11 @@
}
}
@ForceInline
static
- void testVectorCastByteToInt(Species<Byte> a, Species<Integer> b, byte[] input, int[] output) {
+ void testVectorCastByteToInt(VectorSpecies<Byte> a, VectorSpecies<Integer> b, byte[] input, int[] output) {
assert(input.length == a.length());
assert(output.length == b.length());
ByteVector av = ByteVector.fromArray(a, input, 0);
IntVector bv = (IntVector) av.cast(b);
@@ -1466,11 +1466,11 @@
}
}
@ForceInline
static
- void testVectorCastByteToIntFail(Species<Byte> a, Species<Integer> b, byte[] input) {
+ void testVectorCastByteToIntFail(VectorSpecies<Byte> a, VectorSpecies<Integer> b, byte[] input) {
assert(input.length == a.length());
ByteVector av = ByteVector.fromArray(a, input, 0);
try {
av.cast(b);
@@ -1481,11 +1481,11 @@
}
}
@ForceInline
static
- void testVectorCastShortToInt(Species<Short> a, Species<Integer> b, short[] input, int[] output) {
+ void testVectorCastShortToInt(VectorSpecies<Short> a, VectorSpecies<Integer> b, short[] input, int[] output) {
assert(input.length == a.length());
assert(output.length == b.length());
ShortVector av = ShortVector.fromArray(a, input, 0);
IntVector bv = (IntVector) av.cast(b);
@@ -1499,11 +1499,11 @@
}
}
@ForceInline
static
- void testVectorCastShortToIntFail(Species<Short> a, Species<Integer> b, short[] input) {
+ void testVectorCastShortToIntFail(VectorSpecies<Short> a, VectorSpecies<Integer> b, short[] input) {
assert(input.length == a.length());
ShortVector av = ShortVector.fromArray(a, input, 0);
try {
av.cast(b);
@@ -1514,11 +1514,11 @@
}
}
@ForceInline
static
- void testVectorCastIntToInt(Species<Integer> a, Species<Integer> b, int[] input, int[] output) {
+ void testVectorCastIntToInt(VectorSpecies<Integer> a, VectorSpecies<Integer> b, int[] input, int[] output) {
assert(input.length == a.length());
assert(output.length == b.length());
IntVector av = IntVector.fromArray(a, input, 0);
IntVector bv = (IntVector) av.cast(b);
@@ -1532,11 +1532,11 @@
}
}
@ForceInline
static
- void testVectorCastIntToIntFail(Species<Integer> a, Species<Integer> b, int[] input) {
+ void testVectorCastIntToIntFail(VectorSpecies<Integer> a, VectorSpecies<Integer> b, int[] input) {
assert(input.length == a.length());
IntVector av = IntVector.fromArray(a, input, 0);
try {
av.cast(b);
@@ -1547,11 +1547,11 @@
}
}
@ForceInline
static
- void testVectorCastLongToInt(Species<Long> a, Species<Integer> b, long[] input, int[] output) {
+ void testVectorCastLongToInt(VectorSpecies<Long> a, VectorSpecies<Integer> b, long[] input, int[] output) {
assert(input.length == a.length());
assert(output.length == b.length());
LongVector av = LongVector.fromArray(a, input, 0);
IntVector bv = (IntVector) av.cast(b);
@@ -1565,11 +1565,11 @@
}
}
@ForceInline
static
- void testVectorCastLongToIntFail(Species<Long> a, Species<Integer> b, long[] input) {
+ void testVectorCastLongToIntFail(VectorSpecies<Long> a, VectorSpecies<Integer> b, long[] input) {
assert(input.length == a.length());
LongVector av = LongVector.fromArray(a, input, 0);
try {
av.cast(b);
@@ -1580,11 +1580,11 @@
}
}
@ForceInline
static
- void testVectorCastFloatToInt(Species<Float> a, Species<Integer> b, float[] input, int[] output) {
+ void testVectorCastFloatToInt(VectorSpecies<Float> a, VectorSpecies<Integer> b, float[] input, int[] output) {
assert(input.length == a.length());
assert(output.length == b.length());
FloatVector av = FloatVector.fromArray(a, input, 0);
IntVector bv = (IntVector) av.cast(b);
@@ -1598,11 +1598,11 @@
}
}
@ForceInline
static
- void testVectorCastFloatToIntFail(Species<Float> a, Species<Integer> b, float[] input) {
+ void testVectorCastFloatToIntFail(VectorSpecies<Float> a, VectorSpecies<Integer> b, float[] input) {
assert(input.length == a.length());
FloatVector av = FloatVector.fromArray(a, input, 0);
try {
av.cast(b);
@@ -1613,11 +1613,11 @@
}
}
@ForceInline
static
- void testVectorCastDoubleToInt(Species<Double> a, Species<Integer> b, double[] input, int[] output) {
+ void testVectorCastDoubleToInt(VectorSpecies<Double> a, VectorSpecies<Integer> b, double[] input, int[] output) {
assert(input.length == a.length());
assert(output.length == b.length());
DoubleVector av = DoubleVector.fromArray(a, input, 0);
IntVector bv = (IntVector) av.cast(b);
@@ -1631,11 +1631,11 @@
}
}
@ForceInline
static
- void testVectorCastDoubleToIntFail(Species<Double> a, Species<Integer> b, double[] input) {
+ void testVectorCastDoubleToIntFail(VectorSpecies<Double> a, VectorSpecies<Integer> b, double[] input) {
assert(input.length == a.length());
DoubleVector av = DoubleVector.fromArray(a, input, 0);
try {
av.cast(b);
@@ -1646,11 +1646,11 @@
}
}
@ForceInline
static
- void testVectorCastByteToLong(Species<Byte> a, Species<Long> b, byte[] input, long[] output) {
+ void testVectorCastByteToLong(VectorSpecies<Byte> a, VectorSpecies<Long> b, byte[] input, long[] output) {
assert(input.length == a.length());
assert(output.length == b.length());
ByteVector av = ByteVector.fromArray(a, input, 0);
LongVector bv = (LongVector) av.cast(b);
@@ -1664,11 +1664,11 @@
}
}
@ForceInline
static
- void testVectorCastByteToLongFail(Species<Byte> a, Species<Long> b, byte[] input) {
+ void testVectorCastByteToLongFail(VectorSpecies<Byte> a, VectorSpecies<Long> b, byte[] input) {
assert(input.length == a.length());
ByteVector av = ByteVector.fromArray(a, input, 0);
try {
av.cast(b);
@@ -1679,11 +1679,11 @@
}
}
@ForceInline
static
- void testVectorCastShortToLong(Species<Short> a, Species<Long> b, short[] input, long[] output) {
+ void testVectorCastShortToLong(VectorSpecies<Short> a, VectorSpecies<Long> b, short[] input, long[] output) {
assert(input.length == a.length());
assert(output.length == b.length());
ShortVector av = ShortVector.fromArray(a, input, 0);
LongVector bv = (LongVector) av.cast(b);
@@ -1697,11 +1697,11 @@
}
}
@ForceInline
static
- void testVectorCastShortToLongFail(Species<Short> a, Species<Long> b, short[] input) {
+ void testVectorCastShortToLongFail(VectorSpecies<Short> a, VectorSpecies<Long> b, short[] input) {
assert(input.length == a.length());
ShortVector av = ShortVector.fromArray(a, input, 0);
try {
av.cast(b);
@@ -1712,11 +1712,11 @@
}
}
@ForceInline
static
- void testVectorCastIntToLong(Species<Integer> a, Species<Long> b, int[] input, long[] output) {
+ void testVectorCastIntToLong(VectorSpecies<Integer> a, VectorSpecies<Long> b, int[] input, long[] output) {
assert(input.length == a.length());
assert(output.length == b.length());
IntVector av = IntVector.fromArray(a, input, 0);
LongVector bv = (LongVector) av.cast(b);
@@ -1730,11 +1730,11 @@
}
}
@ForceInline
static
- void testVectorCastIntToLongFail(Species<Integer> a, Species<Long> b, int[] input) {
+ void testVectorCastIntToLongFail(VectorSpecies<Integer> a, VectorSpecies<Long> b, int[] input) {
assert(input.length == a.length());
IntVector av = IntVector.fromArray(a, input, 0);
try {
av.cast(b);
@@ -1745,11 +1745,11 @@
}
}
@ForceInline
static
- void testVectorCastLongToLong(Species<Long> a, Species<Long> b, long[] input, long[] output) {
+ void testVectorCastLongToLong(VectorSpecies<Long> a, VectorSpecies<Long> b, long[] input, long[] output) {
assert(input.length == a.length());
assert(output.length == b.length());
LongVector av = LongVector.fromArray(a, input, 0);
LongVector bv = (LongVector) av.cast(b);
@@ -1763,11 +1763,11 @@
}
}
@ForceInline
static
- void testVectorCastLongToLongFail(Species<Long> a, Species<Long> b, long[] input) {
+ void testVectorCastLongToLongFail(VectorSpecies<Long> a, VectorSpecies<Long> b, long[] input) {
assert(input.length == a.length());
LongVector av = LongVector.fromArray(a, input, 0);
try {
av.cast(b);
@@ -1778,11 +1778,11 @@
}
}
@ForceInline
static
- void testVectorCastFloatToLong(Species<Float> a, Species<Long> b, float[] input, long[] output) {
+ void testVectorCastFloatToLong(VectorSpecies<Float> a, VectorSpecies<Long> b, float[] input, long[] output) {
assert(input.length == a.length());
assert(output.length == b.length());
FloatVector av = FloatVector.fromArray(a, input, 0);
LongVector bv = (LongVector) av.cast(b);
@@ -1796,11 +1796,11 @@
}
}
@ForceInline
static
- void testVectorCastFloatToLongFail(Species<Float> a, Species<Long> b, float[] input) {
+ void testVectorCastFloatToLongFail(VectorSpecies<Float> a, VectorSpecies<Long> b, float[] input) {
assert(input.length == a.length());
FloatVector av = FloatVector.fromArray(a, input, 0);
try {
av.cast(b);
@@ -1811,11 +1811,11 @@
}
}
@ForceInline
static
- void testVectorCastDoubleToLong(Species<Double> a, Species<Long> b, double[] input, long[] output) {
+ void testVectorCastDoubleToLong(VectorSpecies<Double> a, VectorSpecies<Long> b, double[] input, long[] output) {
assert(input.length == a.length());
assert(output.length == b.length());
DoubleVector av = DoubleVector.fromArray(a, input, 0);
LongVector bv = (LongVector) av.cast(b);
@@ -1829,11 +1829,11 @@
}
}
@ForceInline
static
- void testVectorCastDoubleToLongFail(Species<Double> a, Species<Long> b, double[] input) {
+ void testVectorCastDoubleToLongFail(VectorSpecies<Double> a, VectorSpecies<Long> b, double[] input) {
assert(input.length == a.length());
DoubleVector av = DoubleVector.fromArray(a, input, 0);
try {
av.cast(b);
@@ -1844,11 +1844,11 @@
}
}
@ForceInline
static
- void testVectorCastByteToDouble(Species<Byte> a, Species<Double> b, byte[] input, double[] output) {
+ void testVectorCastByteToDouble(VectorSpecies<Byte> a, VectorSpecies<Double> b, byte[] input, double[] output) {
assert(input.length == a.length());
assert(output.length == b.length());
ByteVector av = ByteVector.fromArray(a, input, 0);
DoubleVector bv = (DoubleVector) av.cast(b);
@@ -1862,11 +1862,11 @@
}
}
@ForceInline
static
- void testVectorCastByteToDoubleFail(Species<Byte> a, Species<Double> b, byte[] input) {
+ void testVectorCastByteToDoubleFail(VectorSpecies<Byte> a, VectorSpecies<Double> b, byte[] input) {
assert(input.length == a.length());
ByteVector av = ByteVector.fromArray(a, input, 0);
try {
av.cast(b);
@@ -1877,11 +1877,11 @@
}
}
@ForceInline
static
- void testVectorCastShortToDouble(Species<Short> a, Species<Double> b, short[] input, double[] output) {
+ void testVectorCastShortToDouble(VectorSpecies<Short> a, VectorSpecies<Double> b, short[] input, double[] output) {
assert(input.length == a.length());
assert(output.length == b.length());
ShortVector av = ShortVector.fromArray(a, input, 0);
DoubleVector bv = (DoubleVector) av.cast(b);
@@ -1895,11 +1895,11 @@
}
}
@ForceInline
static
- void testVectorCastShortToDoubleFail(Species<Short> a, Species<Double> b, short[] input) {
+ void testVectorCastShortToDoubleFail(VectorSpecies<Short> a, VectorSpecies<Double> b, short[] input) {
assert(input.length == a.length());
ShortVector av = ShortVector.fromArray(a, input, 0);
try {
av.cast(b);
@@ -1910,11 +1910,11 @@
}
}
@ForceInline
static
- void testVectorCastIntToDouble(Species<Integer> a, Species<Double> b, int[] input, double[] output) {
+ void testVectorCastIntToDouble(VectorSpecies<Integer> a, VectorSpecies<Double> b, int[] input, double[] output) {
assert(input.length == a.length());
assert(output.length == b.length());
IntVector av = IntVector.fromArray(a, input, 0);
DoubleVector bv = (DoubleVector) av.cast(b);
@@ -1928,11 +1928,11 @@
}
}
@ForceInline
static
- void testVectorCastIntToDoubleFail(Species<Integer> a, Species<Double> b, int[] input) {
+ void testVectorCastIntToDoubleFail(VectorSpecies<Integer> a, VectorSpecies<Double> b, int[] input) {
assert(input.length == a.length());
IntVector av = IntVector.fromArray(a, input, 0);
try {
av.cast(b);
@@ -1943,11 +1943,11 @@
}
}
@ForceInline
static
- void testVectorCastLongToDouble(Species<Long> a, Species<Double> b, long[] input, double[] output) {
+ void testVectorCastLongToDouble(VectorSpecies<Long> a, VectorSpecies<Double> b, long[] input, double[] output) {
assert(input.length == a.length());
assert(output.length == b.length());
LongVector av = LongVector.fromArray(a, input, 0);
DoubleVector bv = (DoubleVector) av.cast(b);
@@ -1961,11 +1961,11 @@
}
}
@ForceInline
static
- void testVectorCastLongToDoubleFail(Species<Long> a, Species<Double> b, long[] input) {
+ void testVectorCastLongToDoubleFail(VectorSpecies<Long> a, VectorSpecies<Double> b, long[] input) {
assert(input.length == a.length());
LongVector av = LongVector.fromArray(a, input, 0);
try {
av.cast(b);
@@ -1976,11 +1976,11 @@
}
}
@ForceInline
static
- void testVectorCastFloatToDouble(Species<Float> a, Species<Double> b, float[] input, double[] output) {
+ void testVectorCastFloatToDouble(VectorSpecies<Float> a, VectorSpecies<Double> b, float[] input, double[] output) {
assert(input.length == a.length());
assert(output.length == b.length());
FloatVector av = FloatVector.fromArray(a, input, 0);
DoubleVector bv = (DoubleVector) av.cast(b);
@@ -1994,11 +1994,11 @@
}
}
@ForceInline
static
- void testVectorCastFloatToDoubleFail(Species<Float> a, Species<Double> b, float[] input) {
+ void testVectorCastFloatToDoubleFail(VectorSpecies<Float> a, VectorSpecies<Double> b, float[] input) {
assert(input.length == a.length());
FloatVector av = FloatVector.fromArray(a, input, 0);
try {
av.cast(b);
@@ -2009,11 +2009,11 @@
}
}
@ForceInline
static
- void testVectorCastDoubleToDouble(Species<Double> a, Species<Double> b, double[] input, double[] output) {
+ void testVectorCastDoubleToDouble(VectorSpecies<Double> a, VectorSpecies<Double> b, double[] input, double[] output) {
assert(input.length == a.length());
assert(output.length == b.length());
DoubleVector av = DoubleVector.fromArray(a, input, 0);
DoubleVector bv = (DoubleVector) av.cast(b);
@@ -2027,11 +2027,11 @@
}
}
@ForceInline
static
- void testVectorCastDoubleToDoubleFail(Species<Double> a, Species<Double> b, double[] input) {
+ void testVectorCastDoubleToDoubleFail(VectorSpecies<Double> a, VectorSpecies<Double> b, double[] input) {
assert(input.length == a.length());
DoubleVector av = DoubleVector.fromArray(a, input, 0);
try {
av.cast(b);
@@ -3055,361 +3055,361 @@
testVectorCastDoubleToDoubleFail(dspec512, dspec256, din512);
}
}
static
- void testVectorCastByteMaxToByte(Species<Byte> a, Species<Byte> b,
+ void testVectorCastByteMaxToByte(VectorSpecies<Byte> a, VectorSpecies<Byte> b,
byte[] input, byte[] output) {
if (S_Max_BIT.bitSize() == b.length() * Byte.SIZE) {
testVectorCastByteToByte(a, b, input, output);
} else {
testVectorCastByteToByteFail(a, b, input);
}
}
static
- void testVectorCastByteMaxToShort(Species<Byte> a, Species<Short> b,
+ void testVectorCastByteMaxToShort(VectorSpecies<Byte> a, VectorSpecies<Short> b,
byte[] input, short[] output) {
if (S_Max_BIT.bitSize() == b.length() * Byte.SIZE) {
testVectorCastByteToShort(a, b, input, output);
} else {
testVectorCastByteToShortFail(a, b, input);
}
}
static
- void testVectorCastByteMaxToInt(Species<Byte> a, Species<Integer> b,
+ void testVectorCastByteMaxToInt(VectorSpecies<Byte> a, VectorSpecies<Integer> b,
byte[] input, int[] output) {
if (S_Max_BIT.bitSize() == b.length() * Byte.SIZE) {
testVectorCastByteToInt(a, b, input, output);
} else {
testVectorCastByteToIntFail(a, b, input);
}
}
static
- void testVectorCastByteMaxToLong(Species<Byte> a, Species<Long> b,
+ void testVectorCastByteMaxToLong(VectorSpecies<Byte> a, VectorSpecies<Long> b,
byte[] input, long[] output) {
if (S_Max_BIT.bitSize() == b.length() * Byte.SIZE) {
testVectorCastByteToLong(a, b, input, output);
} else {
testVectorCastByteToLongFail(a, b, input);
}
}
static
- void testVectorCastByteMaxToFloat(Species<Byte> a, Species<Float> b,
+ void testVectorCastByteMaxToFloat(VectorSpecies<Byte> a, VectorSpecies<Float> b,
byte[] input, float[] output) {
if (S_Max_BIT.bitSize() == b.length() * Byte.SIZE) {
testVectorCastByteToFloat(a, b, input, output);
} else {
testVectorCastByteToFloatFail(a, b, input);
}
}
static
- void testVectorCastByteMaxToDouble(Species<Byte> a, Species<Double> b,
+ void testVectorCastByteMaxToDouble(VectorSpecies<Byte> a, VectorSpecies<Double> b,
byte[] input, double[] output) {
if (S_Max_BIT.bitSize() == b.length() * Byte.SIZE) {
testVectorCastByteToDouble(a, b, input, output);
} else {
testVectorCastByteToDoubleFail(a, b, input);
}
}
static
- void testVectorCastShortMaxToByte(Species<Short> a, Species<Byte> b,
+ void testVectorCastShortMaxToByte(VectorSpecies<Short> a, VectorSpecies<Byte> b,
short[] input, byte[] output) {
if (S_Max_BIT.bitSize() == b.length() * Short.SIZE) {
testVectorCastShortToByte(a, b, input, output);
} else {
testVectorCastShortToByteFail(a, b, input);
}
}
static
- void testVectorCastShortMaxToShort(Species<Short> a, Species<Short> b,
+ void testVectorCastShortMaxToShort(VectorSpecies<Short> a, VectorSpecies<Short> b,
short[] input, short[] output) {
if (S_Max_BIT.bitSize() == b.length() * Short.SIZE) {
testVectorCastShortToShort(a, b, input, output);
} else {
testVectorCastShortToShortFail(a, b, input);
}
}
static
- void testVectorCastShortMaxToInt(Species<Short> a, Species<Integer> b,
+ void testVectorCastShortMaxToInt(VectorSpecies<Short> a, VectorSpecies<Integer> b,
short[] input, int[] output) {
if (S_Max_BIT.bitSize() == b.length() * Short.SIZE) {
testVectorCastShortToInt(a, b, input, output);
} else {
testVectorCastShortToIntFail(a, b, input);
}
}
static
- void testVectorCastShortMaxToLong(Species<Short> a, Species<Long> b,
+ void testVectorCastShortMaxToLong(VectorSpecies<Short> a, VectorSpecies<Long> b,
short[] input, long[] output) {
if (S_Max_BIT.bitSize() == b.length() * Short.SIZE) {
testVectorCastShortToLong(a, b, input, output);
} else {
testVectorCastShortToLongFail(a, b, input);
}
}
static
- void testVectorCastShortMaxToFloat(Species<Short> a, Species<Float> b,
+ void testVectorCastShortMaxToFloat(VectorSpecies<Short> a, VectorSpecies<Float> b,
short[] input, float[] output) {
if (S_Max_BIT.bitSize() == b.length() * Short.SIZE) {
testVectorCastShortToFloat(a, b, input, output);
} else {
testVectorCastShortToFloatFail(a, b, input);
}
}
static
- void testVectorCastShortMaxToDouble(Species<Short> a, Species<Double> b,
+ void testVectorCastShortMaxToDouble(VectorSpecies<Short> a, VectorSpecies<Double> b,
short[] input, double[] output) {
if (S_Max_BIT.bitSize() == b.length() * Short.SIZE) {
testVectorCastShortToDouble(a, b, input, output);
} else {
testVectorCastShortToDoubleFail(a, b, input);
}
}
static
- void testVectorCastIntMaxToByte(Species<Integer> a, Species<Byte> b,
+ void testVectorCastIntMaxToByte(VectorSpecies<Integer> a, VectorSpecies<Byte> b,
int[] input, byte[] output) {
if (S_Max_BIT.bitSize() == b.length() * Integer.SIZE) {
testVectorCastIntToByte(a, b, input, output);
} else {
testVectorCastIntToByteFail(a, b, input);
}
}
static
- void testVectorCastIntMaxToShort(Species<Integer> a, Species<Short> b,
+ void testVectorCastIntMaxToShort(VectorSpecies<Integer> a, VectorSpecies<Short> b,
int[] input, short[] output) {
if (S_Max_BIT.bitSize() == b.length() * Integer.SIZE) {
testVectorCastIntToShort(a, b, input, output);
} else {
testVectorCastIntToShortFail(a, b, input);
}
}
static
- void testVectorCastIntMaxToInt(Species<Integer> a, Species<Integer> b,
+ void testVectorCastIntMaxToInt(VectorSpecies<Integer> a, VectorSpecies<Integer> b,
int[] input, int[] output) {
if (S_Max_BIT.bitSize() == b.length() * Integer.SIZE) {
testVectorCastIntToInt(a, b, input, output);
} else {
testVectorCastIntToIntFail(a, b, input);
}
}
static
- void testVectorCastIntMaxToLong(Species<Integer> a, Species<Long> b,
+ void testVectorCastIntMaxToLong(VectorSpecies<Integer> a, VectorSpecies<Long> b,
int[] input, long[] output) {
if (S_Max_BIT.bitSize() == b.length() * Integer.SIZE) {
testVectorCastIntToLong(a, b, input, output);
} else {
testVectorCastIntToLongFail(a, b, input);
}
}
static
- void testVectorCastIntMaxToFloat(Species<Integer> a, Species<Float> b,
+ void testVectorCastIntMaxToFloat(VectorSpecies<Integer> a, VectorSpecies<Float> b,
int[] input, float[] output) {
if (S_Max_BIT.bitSize() == b.length() * Integer.SIZE) {
testVectorCastIntToFloat(a, b, input, output);
} else {
testVectorCastIntToFloatFail(a, b, input);
}
}
static
- void testVectorCastIntMaxToDouble(Species<Integer> a, Species<Double> b,
+ void testVectorCastIntMaxToDouble(VectorSpecies<Integer> a, VectorSpecies<Double> b,
int[] input, double[] output) {
if (S_Max_BIT.bitSize() == b.length() * Integer.SIZE) {
testVectorCastIntToDouble(a, b, input, output);
} else {
testVectorCastIntToDoubleFail(a, b, input);
}
}
static
- void testVectorCastLongMaxToByte(Species<Long> a, Species<Byte> b,
+ void testVectorCastLongMaxToByte(VectorSpecies<Long> a, VectorSpecies<Byte> b,
long[] input, byte[] output) {
if (S_Max_BIT.bitSize() == b.length() * Long.SIZE) {
testVectorCastLongToByte(a, b, input, output);
} else {
testVectorCastLongToByteFail(a, b, input);
}
}
static
- void testVectorCastLongMaxToShort(Species<Long> a, Species<Short> b,
+ void testVectorCastLongMaxToShort(VectorSpecies<Long> a, VectorSpecies<Short> b,
long[] input, short[] output) {
if (S_Max_BIT.bitSize() == b.length() * Long.SIZE) {
testVectorCastLongToShort(a, b, input, output);
} else {
testVectorCastLongToShortFail(a, b, input);
}
}
static
- void testVectorCastLongMaxToInt(Species<Long> a, Species<Integer> b,
+ void testVectorCastLongMaxToInt(VectorSpecies<Long> a, VectorSpecies<Integer> b,
long[] input, int[] output) {
if (S_Max_BIT.bitSize() == b.length() * Long.SIZE) {
testVectorCastLongToInt(a, b, input, output);
} else {
testVectorCastLongToIntFail(a, b, input);
}
}
static
- void testVectorCastLongMaxToLong(Species<Long> a, Species<Long> b,
+ void testVectorCastLongMaxToLong(VectorSpecies<Long> a, VectorSpecies<Long> b,
long[] input, long[] output) {
if (S_Max_BIT.bitSize() == b.length() * Long.SIZE) {
testVectorCastLongToLong(a, b, input, output);
} else {
testVectorCastLongToLongFail(a, b, input);
}
}
static
- void testVectorCastLongMaxToFloat(Species<Long> a, Species<Float> b,
+ void testVectorCastLongMaxToFloat(VectorSpecies<Long> a, VectorSpecies<Float> b,
long[] input, float[] output) {
if (S_Max_BIT.bitSize() == b.length() * Long.SIZE) {
testVectorCastLongToFloat(a, b, input, output);
} else {
testVectorCastLongToFloatFail(a, b, input);
}
}
static
- void testVectorCastLongMaxToDouble(Species<Long> a, Species<Double> b,
+ void testVectorCastLongMaxToDouble(VectorSpecies<Long> a, VectorSpecies<Double> b,
long[] input, double[] output) {
if (S_Max_BIT.bitSize() == b.length() * Long.SIZE) {
testVectorCastLongToDouble(a, b, input, output);
} else {
testVectorCastLongToDoubleFail(a, b, input);
}
}
static
- void testVectorCastFloatMaxToByte(Species<Float> a, Species<Byte> b,
+ void testVectorCastFloatMaxToByte(VectorSpecies<Float> a, VectorSpecies<Byte> b,
float[] input, byte[] output) {
if (S_Max_BIT.bitSize() == b.length() * Float.SIZE) {
testVectorCastFloatToByte(a, b, input, output);
} else {
testVectorCastFloatToByteFail(a, b, input);
}
}
static
- void testVectorCastFloatMaxToShort(Species<Float> a, Species<Short> b,
+ void testVectorCastFloatMaxToShort(VectorSpecies<Float> a, VectorSpecies<Short> b,
float[] input, short[] output) {
if (S_Max_BIT.bitSize() == b.length() * Float.SIZE) {
testVectorCastFloatToShort(a, b, input, output);
} else {
testVectorCastFloatToShortFail(a, b, input);
}
}
static
- void testVectorCastFloatMaxToInt(Species<Float> a, Species<Integer> b,
+ void testVectorCastFloatMaxToInt(VectorSpecies<Float> a, VectorSpecies<Integer> b,
float[] input, int[] output) {
if (S_Max_BIT.bitSize() == b.length() * Float.SIZE) {
testVectorCastFloatToInt(a, b, input, output);
} else {
testVectorCastFloatToIntFail(a, b, input);
}
}
static
- void testVectorCastFloatMaxToLong(Species<Float> a, Species<Long> b,
+ void testVectorCastFloatMaxToLong(VectorSpecies<Float> a, VectorSpecies<Long> b,
float[] input, long[] output) {
if (S_Max_BIT.bitSize() == b.length() * Float.SIZE) {
testVectorCastFloatToLong(a, b, input, output);
} else {
testVectorCastFloatToLongFail(a, b, input);
}
}
static
- void testVectorCastFloatMaxToFloat(Species<Float> a, Species<Float> b,
+ void testVectorCastFloatMaxToFloat(VectorSpecies<Float> a, VectorSpecies<Float> b,
float[] input, float[] output) {
if (S_Max_BIT.bitSize() == b.length() * Float.SIZE) {
testVectorCastFloatToFloat(a, b, input, output);
} else {
testVectorCastFloatToFloatFail(a, b, input);
}
}
static
- void testVectorCastFloatMaxToDouble(Species<Float> a, Species<Double> b,
+ void testVectorCastFloatMaxToDouble(VectorSpecies<Float> a, VectorSpecies<Double> b,
float[] input, double[] output) {
if (S_Max_BIT.bitSize() == b.length() * Float.SIZE) {
testVectorCastFloatToDouble(a, b, input, output);
} else {
testVectorCastFloatToDoubleFail(a, b, input);
}
}
static
- void testVectorCastDoubleMaxToByte(Species<Double> a, Species<Byte> b,
+ void testVectorCastDoubleMaxToByte(VectorSpecies<Double> a, VectorSpecies<Byte> b,
double[] input, byte[] output) {
if (S_Max_BIT.bitSize() == b.length() * Double.SIZE) {
testVectorCastDoubleToByte(a, b, input, output);
} else {
testVectorCastDoubleToByteFail(a, b, input);
}
}
static
- void testVectorCastDoubleMaxToShort(Species<Double> a, Species<Short> b,
+ void testVectorCastDoubleMaxToShort(VectorSpecies<Double> a, VectorSpecies<Short> b,
double[] input, short[] output) {
if (S_Max_BIT.bitSize() == b.length() * Double.SIZE) {
testVectorCastDoubleToShort(a, b, input, output);
} else {
testVectorCastDoubleToShortFail(a, b, input);
}
}
static
- void testVectorCastDoubleMaxToInt(Species<Double> a, Species<Integer> b,
+ void testVectorCastDoubleMaxToInt(VectorSpecies<Double> a, VectorSpecies<Integer> b,
double[] input, int[] output) {
if (S_Max_BIT.bitSize() == b.length() * Double.SIZE) {
testVectorCastDoubleToInt(a, b, input, output);
} else {
testVectorCastDoubleToIntFail(a, b, input);
}
}
static
- void testVectorCastDoubleMaxToLong(Species<Double> a, Species<Long> b,
+ void testVectorCastDoubleMaxToLong(VectorSpecies<Double> a, VectorSpecies<Long> b,
double[] input, long[] output) {
if (S_Max_BIT.bitSize() == b.length() * Double.SIZE) {
testVectorCastDoubleToLong(a, b, input, output);
} else {
testVectorCastDoubleToLongFail(a, b, input);
}
}
static
- void testVectorCastDoubleMaxToFloat(Species<Double> a, Species<Float> b,
+ void testVectorCastDoubleMaxToFloat(VectorSpecies<Double> a, VectorSpecies<Float> b,
double[] input, float[] output) {
if (S_Max_BIT.bitSize() == b.length() * Double.SIZE) {
testVectorCastDoubleToFloat(a, b, input, output);
} else {
testVectorCastDoubleToFloatFail(a, b, input);
}
}
static
- void testVectorCastDoubleMaxToDouble(Species<Double> a, Species<Double> b,
+ void testVectorCastDoubleMaxToDouble(VectorSpecies<Double> a, VectorSpecies<Double> b,
double[] input, double[] output) {
if (S_Max_BIT.bitSize() == b.length() * Double.SIZE) {
testVectorCastDoubleToDouble(a, b, input, output);
} else {
testVectorCastDoubleToDoubleFail(a, b, input);
< prev index next >