< 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,18 **** 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; /** * @test * @modules jdk.incubator.vector * @modules java.base/jdk.internal.vm.annotation --- 7,18 ---- 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.VectorShape; ! import jdk.incubator.vector.VectorSpecies; /** * @test * @modules jdk.incubator.vector * @modules java.base/jdk.internal.vm.annotation
*** 23,71 **** @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 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 Shape getMaxBit() { ! return Shape.S_Max_BIT; } static <T> IntFunction<T> withToString(String s, IntFunction<T> f) { return new IntFunction<T>() { @Override --- 23,71 ---- @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 VectorShape S_Max_BIT = getMaxBit(); ! 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 VectorShape getMaxBit() { ! return VectorShape.S_Max_BIT; } static <T> IntFunction<T> withToString(String s, IntFunction<T> f) { return new IntFunction<T>() { @Override
*** 276,300 **** toArray(Object[][]::new); } @ForceInline static <E> ! void testVectorReshape(Vector.Species<E> a, Vector.Species<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); } else if (stype == short.class) { ! av = (Vector) ShortVector.fromByteArray((Species<Short>)a, input, 0); } else if (stype == int.class) { ! av = (Vector) IntVector.fromByteArray((Species<Integer>)a, input, 0); } else if (stype == long.class) { ! av = (Vector) LongVector.fromByteArray((Species<Long>)a, input, 0); } else if (stype == float.class) { ! av = (Vector) FloatVector.fromByteArray((Species<Float>)a, input, 0); } else if (stype == double.class) { ! av = (Vector) DoubleVector.fromByteArray((Species<Double>)a, input, 0); } else { throw new UnsupportedOperationException("Bad lane type"); } Vector<E> bv = av.reshape(b); bv.intoByteArray(output, 0); --- 276,300 ---- toArray(Object[][]::new); } @ForceInline static <E> ! 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((VectorSpecies<Byte>)a, input, 0); } else if (stype == short.class) { ! av = (Vector) ShortVector.fromByteArray((VectorSpecies<Short>)a, input, 0); } else if (stype == int.class) { ! av = (Vector) IntVector.fromByteArray((VectorSpecies<Integer>)a, input, 0); } else if (stype == long.class) { ! av = (Vector) LongVector.fromByteArray((VectorSpecies<Long>)a, input, 0); } else if (stype == float.class) { ! av = (Vector) FloatVector.fromByteArray((VectorSpecies<Float>)a, input, 0); } else if (stype == double.class) { ! 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,607 **** } } @ForceInline static <E,F> ! void testVectorRebracket(Vector.Species<E> a, Vector.Species<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); } else if (stype == short.class) { ! av = (Vector) ShortVector.fromByteArray((Species<Short>)a, input, 0); } else if (stype == int.class) { ! av = (Vector) IntVector.fromByteArray((Species<Integer>)a, input, 0); } else if (stype == long.class) { ! av = (Vector) LongVector.fromByteArray((Species<Long>)a, input, 0); } else if (stype == float.class) { ! av = (Vector) FloatVector.fromByteArray((Species<Float>)a, input, 0); } else if (stype == double.class) { ! av = (Vector) DoubleVector.fromByteArray((Species<Double>)a, input, 0); } else { throw new UnsupportedOperationException("Bad lane type"); } Vector<F> bv = av.reinterpret(b); bv.intoByteArray(output, 0); --- 581,607 ---- } } @ForceInline static <E,F> ! 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((VectorSpecies<Byte>)a, input, 0); } else if (stype == short.class) { ! av = (Vector) ShortVector.fromByteArray((VectorSpecies<Short>)a, input, 0); } else if (stype == int.class) { ! av = (Vector) IntVector.fromByteArray((VectorSpecies<Integer>)a, input, 0); } else if (stype == long.class) { ! av = (Vector) LongVector.fromByteArray((VectorSpecies<Long>)a, input, 0); } else if (stype == float.class) { ! av = (Vector) FloatVector.fromByteArray((VectorSpecies<Float>)a, input, 0); } else if (stype == double.class) { ! 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,864 **** } } @ForceInline static ! void testVectorCastByteToFloat(Species<Byte> a, Species<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); --- 854,864 ---- } } @ForceInline static ! 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,882 **** } } @ForceInline static ! void testVectorCastByteToFloatFail(Species<Byte> a, Species<Float> b, byte[] input) { assert(input.length == a.length()); ByteVector av = ByteVector.fromArray(a, input, 0); try { av.cast(b); --- 872,882 ---- } } @ForceInline static ! 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,897 **** } } @ForceInline static ! void testVectorCastShortToFloat(Species<Short> a, Species<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); --- 887,897 ---- } } @ForceInline static ! 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,915 **** } } @ForceInline static ! void testVectorCastShortToFloatFail(Species<Short> a, Species<Float> b, short[] input) { assert(input.length == a.length()); ShortVector av = ShortVector.fromArray(a, input, 0); try { av.cast(b); --- 905,915 ---- } } @ForceInline static ! 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,930 **** } } @ForceInline static ! void testVectorCastIntToFloat(Species<Integer> a, Species<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); --- 920,930 ---- } } @ForceInline static ! 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,948 **** } } @ForceInline static ! void testVectorCastIntToFloatFail(Species<Integer> a, Species<Float> b, int[] input) { assert(input.length == a.length()); IntVector av = IntVector.fromArray(a, input, 0); try { av.cast(b); --- 938,948 ---- } } @ForceInline static ! 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,963 **** } } @ForceInline static ! void testVectorCastLongToFloat(Species<Long> a, Species<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); --- 953,963 ---- } } @ForceInline static ! 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,981 **** } } @ForceInline static ! void testVectorCastLongToFloatFail(Species<Long> a, Species<Float> b, long[] input) { assert(input.length == a.length()); LongVector av = LongVector.fromArray(a, input, 0); try { av.cast(b); --- 971,981 ---- } } @ForceInline static ! 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,996 **** } } @ForceInline static ! void testVectorCastFloatToFloat(Species<Float> a, Species<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); --- 986,996 ---- } } @ForceInline static ! 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,1014 **** } } @ForceInline static ! void testVectorCastFloatToFloatFail(Species<Float> a, Species<Float> b, float[] input) { assert(input.length == a.length()); FloatVector av = FloatVector.fromArray(a, input, 0); try { av.cast(b); --- 1004,1014 ---- } } @ForceInline static ! 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,1029 **** } } @ForceInline static ! void testVectorCastDoubleToFloat(Species<Double> a, Species<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); --- 1019,1029 ---- } } @ForceInline static ! 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,1047 **** } } @ForceInline static ! void testVectorCastDoubleToFloatFail(Species<Double> a, Species<Float> b, double[] input) { assert(input.length == a.length()); DoubleVector av = DoubleVector.fromArray(a, input, 0); try { av.cast(b); --- 1037,1047 ---- } } @ForceInline static ! 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,1062 **** } } @ForceInline static ! void testVectorCastByteToByte(Species<Byte> a, Species<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); --- 1052,1062 ---- } } @ForceInline static ! 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,1080 **** } } @ForceInline static ! void testVectorCastByteToByteFail(Species<Byte> a, Species<Byte> b, byte[] input) { assert(input.length == a.length()); ByteVector av = ByteVector.fromArray(a, input, 0); try { av.cast(b); --- 1070,1080 ---- } } @ForceInline static ! 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,1095 **** } } @ForceInline static ! void testVectorCastShortToByte(Species<Short> a, Species<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); --- 1085,1095 ---- } } @ForceInline static ! 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,1113 **** } } @ForceInline static ! void testVectorCastShortToByteFail(Species<Short> a, Species<Byte> b, short[] input) { assert(input.length == a.length()); ShortVector av = ShortVector.fromArray(a, input, 0); try { av.cast(b); --- 1103,1113 ---- } } @ForceInline static ! 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,1128 **** } } @ForceInline static ! void testVectorCastIntToByte(Species<Integer> a, Species<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); --- 1118,1128 ---- } } @ForceInline static ! 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,1146 **** } } @ForceInline static ! void testVectorCastIntToByteFail(Species<Integer> a, Species<Byte> b, int[] input) { assert(input.length == a.length()); IntVector av = IntVector.fromArray(a, input, 0); try { av.cast(b); --- 1136,1146 ---- } } @ForceInline static ! 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,1161 **** } } @ForceInline static ! void testVectorCastLongToByte(Species<Long> a, Species<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); --- 1151,1161 ---- } } @ForceInline static ! 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,1179 **** } } @ForceInline static ! void testVectorCastLongToByteFail(Species<Long> a, Species<Byte> b, long[] input) { assert(input.length == a.length()); LongVector av = LongVector.fromArray(a, input, 0); try { av.cast(b); --- 1169,1179 ---- } } @ForceInline static ! 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,1194 **** } } @ForceInline static ! void testVectorCastFloatToByte(Species<Float> a, Species<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); --- 1184,1194 ---- } } @ForceInline static ! 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,1212 **** } } @ForceInline static ! void testVectorCastFloatToByteFail(Species<Float> a, Species<Byte> b, float[] input) { assert(input.length == a.length()); FloatVector av = FloatVector.fromArray(a, input, 0); try { av.cast(b); --- 1202,1212 ---- } } @ForceInline static ! 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,1227 **** } } @ForceInline static ! void testVectorCastDoubleToByte(Species<Double> a, Species<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); --- 1217,1227 ---- } } @ForceInline static ! 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,1245 **** } } @ForceInline static ! void testVectorCastDoubleToByteFail(Species<Double> a, Species<Byte> b, double[] input) { assert(input.length == a.length()); DoubleVector av = DoubleVector.fromArray(a, input, 0); try { av.cast(b); --- 1235,1245 ---- } } @ForceInline static ! 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,1260 **** } } @ForceInline static ! void testVectorCastByteToShort(Species<Byte> a, Species<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); --- 1250,1260 ---- } } @ForceInline static ! 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,1278 **** } } @ForceInline static ! void testVectorCastByteToShortFail(Species<Byte> a, Species<Short> b, byte[] input) { assert(input.length == a.length()); ByteVector av = ByteVector.fromArray(a, input, 0); try { av.cast(b); --- 1268,1278 ---- } } @ForceInline static ! 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,1293 **** } } @ForceInline static ! void testVectorCastShortToShort(Species<Short> a, Species<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); --- 1283,1293 ---- } } @ForceInline static ! 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,1311 **** } } @ForceInline static ! void testVectorCastShortToShortFail(Species<Short> a, Species<Short> b, short[] input) { assert(input.length == a.length()); ShortVector av = ShortVector.fromArray(a, input, 0); try { av.cast(b); --- 1301,1311 ---- } } @ForceInline static ! 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,1326 **** } } @ForceInline static ! void testVectorCastIntToShort(Species<Integer> a, Species<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); --- 1316,1326 ---- } } @ForceInline static ! 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,1344 **** } } @ForceInline static ! void testVectorCastIntToShortFail(Species<Integer> a, Species<Short> b, int[] input) { assert(input.length == a.length()); IntVector av = IntVector.fromArray(a, input, 0); try { av.cast(b); --- 1334,1344 ---- } } @ForceInline static ! 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,1359 **** } } @ForceInline static ! void testVectorCastLongToShort(Species<Long> a, Species<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); --- 1349,1359 ---- } } @ForceInline static ! 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,1377 **** } } @ForceInline static ! void testVectorCastLongToShortFail(Species<Long> a, Species<Short> b, long[] input) { assert(input.length == a.length()); LongVector av = LongVector.fromArray(a, input, 0); try { av.cast(b); --- 1367,1377 ---- } } @ForceInline static ! 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,1392 **** } } @ForceInline static ! void testVectorCastFloatToShort(Species<Float> a, Species<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); --- 1382,1392 ---- } } @ForceInline static ! 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,1410 **** } } @ForceInline static ! void testVectorCastFloatToShortFail(Species<Float> a, Species<Short> b, float[] input) { assert(input.length == a.length()); FloatVector av = FloatVector.fromArray(a, input, 0); try { av.cast(b); --- 1400,1410 ---- } } @ForceInline static ! 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,1425 **** } } @ForceInline static ! void testVectorCastDoubleToShort(Species<Double> a, Species<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); --- 1415,1425 ---- } } @ForceInline static ! 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,1443 **** } } @ForceInline static ! void testVectorCastDoubleToShortFail(Species<Double> a, Species<Short> b, double[] input) { assert(input.length == a.length()); DoubleVector av = DoubleVector.fromArray(a, input, 0); try { av.cast(b); --- 1433,1443 ---- } } @ForceInline static ! 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,1458 **** } } @ForceInline static ! void testVectorCastByteToInt(Species<Byte> a, Species<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); --- 1448,1458 ---- } } @ForceInline static ! 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,1476 **** } } @ForceInline static ! void testVectorCastByteToIntFail(Species<Byte> a, Species<Integer> b, byte[] input) { assert(input.length == a.length()); ByteVector av = ByteVector.fromArray(a, input, 0); try { av.cast(b); --- 1466,1476 ---- } } @ForceInline static ! 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,1491 **** } } @ForceInline static ! void testVectorCastShortToInt(Species<Short> a, Species<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); --- 1481,1491 ---- } } @ForceInline static ! 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,1509 **** } } @ForceInline static ! void testVectorCastShortToIntFail(Species<Short> a, Species<Integer> b, short[] input) { assert(input.length == a.length()); ShortVector av = ShortVector.fromArray(a, input, 0); try { av.cast(b); --- 1499,1509 ---- } } @ForceInline static ! 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,1524 **** } } @ForceInline static ! void testVectorCastIntToInt(Species<Integer> a, Species<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); --- 1514,1524 ---- } } @ForceInline static ! 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,1542 **** } } @ForceInline static ! void testVectorCastIntToIntFail(Species<Integer> a, Species<Integer> b, int[] input) { assert(input.length == a.length()); IntVector av = IntVector.fromArray(a, input, 0); try { av.cast(b); --- 1532,1542 ---- } } @ForceInline static ! 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,1557 **** } } @ForceInline static ! void testVectorCastLongToInt(Species<Long> a, Species<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); --- 1547,1557 ---- } } @ForceInline static ! 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,1575 **** } } @ForceInline static ! void testVectorCastLongToIntFail(Species<Long> a, Species<Integer> b, long[] input) { assert(input.length == a.length()); LongVector av = LongVector.fromArray(a, input, 0); try { av.cast(b); --- 1565,1575 ---- } } @ForceInline static ! 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,1590 **** } } @ForceInline static ! void testVectorCastFloatToInt(Species<Float> a, Species<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); --- 1580,1590 ---- } } @ForceInline static ! 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,1608 **** } } @ForceInline static ! void testVectorCastFloatToIntFail(Species<Float> a, Species<Integer> b, float[] input) { assert(input.length == a.length()); FloatVector av = FloatVector.fromArray(a, input, 0); try { av.cast(b); --- 1598,1608 ---- } } @ForceInline static ! 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,1623 **** } } @ForceInline static ! void testVectorCastDoubleToInt(Species<Double> a, Species<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); --- 1613,1623 ---- } } @ForceInline static ! 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,1641 **** } } @ForceInline static ! void testVectorCastDoubleToIntFail(Species<Double> a, Species<Integer> b, double[] input) { assert(input.length == a.length()); DoubleVector av = DoubleVector.fromArray(a, input, 0); try { av.cast(b); --- 1631,1641 ---- } } @ForceInline static ! 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,1656 **** } } @ForceInline static ! void testVectorCastByteToLong(Species<Byte> a, Species<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); --- 1646,1656 ---- } } @ForceInline static ! 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,1674 **** } } @ForceInline static ! void testVectorCastByteToLongFail(Species<Byte> a, Species<Long> b, byte[] input) { assert(input.length == a.length()); ByteVector av = ByteVector.fromArray(a, input, 0); try { av.cast(b); --- 1664,1674 ---- } } @ForceInline static ! 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,1689 **** } } @ForceInline static ! void testVectorCastShortToLong(Species<Short> a, Species<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); --- 1679,1689 ---- } } @ForceInline static ! 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,1707 **** } } @ForceInline static ! void testVectorCastShortToLongFail(Species<Short> a, Species<Long> b, short[] input) { assert(input.length == a.length()); ShortVector av = ShortVector.fromArray(a, input, 0); try { av.cast(b); --- 1697,1707 ---- } } @ForceInline static ! 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,1722 **** } } @ForceInline static ! void testVectorCastIntToLong(Species<Integer> a, Species<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); --- 1712,1722 ---- } } @ForceInline static ! 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,1740 **** } } @ForceInline static ! void testVectorCastIntToLongFail(Species<Integer> a, Species<Long> b, int[] input) { assert(input.length == a.length()); IntVector av = IntVector.fromArray(a, input, 0); try { av.cast(b); --- 1730,1740 ---- } } @ForceInline static ! 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,1755 **** } } @ForceInline static ! void testVectorCastLongToLong(Species<Long> a, Species<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); --- 1745,1755 ---- } } @ForceInline static ! 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,1773 **** } } @ForceInline static ! void testVectorCastLongToLongFail(Species<Long> a, Species<Long> b, long[] input) { assert(input.length == a.length()); LongVector av = LongVector.fromArray(a, input, 0); try { av.cast(b); --- 1763,1773 ---- } } @ForceInline static ! 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,1788 **** } } @ForceInline static ! void testVectorCastFloatToLong(Species<Float> a, Species<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); --- 1778,1788 ---- } } @ForceInline static ! 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,1806 **** } } @ForceInline static ! void testVectorCastFloatToLongFail(Species<Float> a, Species<Long> b, float[] input) { assert(input.length == a.length()); FloatVector av = FloatVector.fromArray(a, input, 0); try { av.cast(b); --- 1796,1806 ---- } } @ForceInline static ! 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,1821 **** } } @ForceInline static ! void testVectorCastDoubleToLong(Species<Double> a, Species<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); --- 1811,1821 ---- } } @ForceInline static ! 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,1839 **** } } @ForceInline static ! void testVectorCastDoubleToLongFail(Species<Double> a, Species<Long> b, double[] input) { assert(input.length == a.length()); DoubleVector av = DoubleVector.fromArray(a, input, 0); try { av.cast(b); --- 1829,1839 ---- } } @ForceInline static ! 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,1854 **** } } @ForceInline static ! void testVectorCastByteToDouble(Species<Byte> a, Species<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); --- 1844,1854 ---- } } @ForceInline static ! 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,1872 **** } } @ForceInline static ! void testVectorCastByteToDoubleFail(Species<Byte> a, Species<Double> b, byte[] input) { assert(input.length == a.length()); ByteVector av = ByteVector.fromArray(a, input, 0); try { av.cast(b); --- 1862,1872 ---- } } @ForceInline static ! 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,1887 **** } } @ForceInline static ! void testVectorCastShortToDouble(Species<Short> a, Species<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); --- 1877,1887 ---- } } @ForceInline static ! 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,1905 **** } } @ForceInline static ! void testVectorCastShortToDoubleFail(Species<Short> a, Species<Double> b, short[] input) { assert(input.length == a.length()); ShortVector av = ShortVector.fromArray(a, input, 0); try { av.cast(b); --- 1895,1905 ---- } } @ForceInline static ! 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,1920 **** } } @ForceInline static ! void testVectorCastIntToDouble(Species<Integer> a, Species<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); --- 1910,1920 ---- } } @ForceInline static ! 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,1938 **** } } @ForceInline static ! void testVectorCastIntToDoubleFail(Species<Integer> a, Species<Double> b, int[] input) { assert(input.length == a.length()); IntVector av = IntVector.fromArray(a, input, 0); try { av.cast(b); --- 1928,1938 ---- } } @ForceInline static ! 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,1953 **** } } @ForceInline static ! void testVectorCastLongToDouble(Species<Long> a, Species<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); --- 1943,1953 ---- } } @ForceInline static ! 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,1971 **** } } @ForceInline static ! void testVectorCastLongToDoubleFail(Species<Long> a, Species<Double> b, long[] input) { assert(input.length == a.length()); LongVector av = LongVector.fromArray(a, input, 0); try { av.cast(b); --- 1961,1971 ---- } } @ForceInline static ! 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,1986 **** } } @ForceInline static ! void testVectorCastFloatToDouble(Species<Float> a, Species<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); --- 1976,1986 ---- } } @ForceInline static ! 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,2004 **** } } @ForceInline static ! void testVectorCastFloatToDoubleFail(Species<Float> a, Species<Double> b, float[] input) { assert(input.length == a.length()); FloatVector av = FloatVector.fromArray(a, input, 0); try { av.cast(b); --- 1994,2004 ---- } } @ForceInline static ! 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,2019 **** } } @ForceInline static ! void testVectorCastDoubleToDouble(Species<Double> a, Species<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); --- 2009,2019 ---- } } @ForceInline static ! 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,2037 **** } } @ForceInline static ! void testVectorCastDoubleToDoubleFail(Species<Double> a, Species<Double> b, double[] input) { assert(input.length == a.length()); DoubleVector av = DoubleVector.fromArray(a, input, 0); try { av.cast(b); --- 2027,2037 ---- } } @ForceInline static ! 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,3415 **** testVectorCastDoubleToDoubleFail(dspec512, dspec256, din512); } } static ! void testVectorCastByteMaxToByte(Species<Byte> a, Species<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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, double[] input, double[] output) { if (S_Max_BIT.bitSize() == b.length() * Double.SIZE) { testVectorCastDoubleToDouble(a, b, input, output); } else { testVectorCastDoubleToDoubleFail(a, b, input); --- 3055,3415 ---- testVectorCastDoubleToDoubleFail(dspec512, dspec256, din512); } } static ! 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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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 >