702 public Double64Vector blend(Vector<Double, Shapes.S64Bit> o1, Mask<Double, Shapes.S64Bit> o2) {
703 Objects.requireNonNull(o1);
704 Objects.requireNonNull(o2);
705 Double64Vector v = (Double64Vector)o1;
706 Double64Mask m = (Double64Mask)o2;
707
708 return (Double64Vector) VectorIntrinsics.blend(
709 Double64Vector.class, Double64Mask.class, double.class, LENGTH,
710 this, v, m,
711 (v1, v2, m_) -> v1.bOp(v2, (i, a, b) -> m_.getElement(i) ? b : a));
712 }
713
714 @Override
715 @ForceInline
716 @SuppressWarnings("unchecked")
717 public <F> Vector<F, Shapes.S64Bit> rebracket(Species<F, Shapes.S64Bit> species) {
718 Objects.requireNonNull(species);
719 // TODO: check proper element type
720 // TODO: update to pass the two species as an arguments and ideally
721 // push down intrinsic call into species implementation
722 return VectorIntrinsics.rebracket(
723 Double64Vector.class, double.class, LENGTH,
724 species.elementType(), this,
725 (v, t) -> species.reshape(v)
726 );
727 }
728
729 // Accessors
730
731 @Override
732 public double get(int i) {
733 double[] vec = getElements();
734 return vec[i];
735 }
736
737 @Override
738 public Double64Vector with(int i, double e) {
739 double[] res = vec.clone();
740 res[i] = e;
741 return new Double64Vector(res);
742 }
743
744 // Mask
793 public Double64Species species() {
794 return SPECIES;
795 }
796
797 @Override
798 public Double64Vector toVector() {
799 double[] res = new double[species().length()];
800 boolean[] bits = getBits();
801 for (int i = 0; i < species().length(); i++) {
802 res[i] = (double) (bits[i] ? -1 : 0);
803 }
804 return new Double64Vector(res);
805 }
806
807 @Override
808 @ForceInline
809 @SuppressWarnings("unchecked")
810 public <Z> Mask<Z, Shapes.S64Bit> rebracket(Species<Z, Shapes.S64Bit> species) {
811 Objects.requireNonNull(species);
812 // TODO: check proper element type
813 return VectorIntrinsics.rebracket(
814 Double64Mask.class, double.class, LENGTH,
815 species.elementType(), this,
816 (m, t) -> m.reshape(species)
817 );
818 }
819
820 // Unary operations
821
822 //Mask<E, S> not();
823
824 // Binary operations
825
826 @Override
827 @ForceInline
828 public Double64Mask and(Mask<Double,Shapes.S64Bit> o) {
829 Objects.requireNonNull(o);
830 Double64Mask m = (Double64Mask)o;
831 return VectorIntrinsics.binaryOp(VECTOR_OP_AND, Double64Mask.class, long.class, LENGTH,
832 this, m,
833 (m1, m2) -> m1.bOp(m2, (i, a, b) -> a & b));
834 }
835
892 public Double64Species species() {
893 return SPECIES;
894 }
895
896 static final class Double64Species extends DoubleSpecies<Shapes.S64Bit> {
897 static final int BIT_SIZE = Shapes.S_64_BIT.bitSize();
898
899 static final int LENGTH = BIT_SIZE / Double.SIZE;
900
901 @Override
902 public String toString() {
903 StringBuilder sb = new StringBuilder("Shape[");
904 sb.append(bitSize()).append(" bits, ");
905 sb.append(length()).append(" ").append(double.class.getSimpleName()).append("s x ");
906 sb.append(elementSize()).append(" bits");
907 sb.append("]");
908 return sb.toString();
909 }
910
911 @Override
912 public int bitSize() {
913 return BIT_SIZE;
914 }
915
916 @Override
917 public int length() {
918 return LENGTH;
919 }
920
921 @Override
922 public Class<Double> elementType() {
923 return Double.class;
924 }
925
926 @Override
927 public int elementSize() {
928 return Double.SIZE;
929 }
930
931 @Override
932 public Shapes.S64Bit shape() {
933 return Shapes.S_64_BIT;
934 }
935
936 @Override
937 Double64Vector op(FOp f) {
938 double[] res = new double[length()];
939 for (int i = 0; i < length(); i++) {
940 res[i] = f.apply(i);
941 }
942 return new Double64Vector(res);
943 }
944
945 @Override
946 Double64Vector op(Mask<Double, Shapes.S64Bit> o, FOp f) {
947 double[] res = new double[length()];
948 boolean[] mbits = ((Double64Mask)o).getBits();
949 for (int i = 0; i < length(); i++) {
950 if (mbits[i]) {
951 res[i] = f.apply(i);
1006 public Double64Mask maskAllFalse() {
1007 return VectorIntrinsics.broadcastCoerced(Double64Mask.class, long.class, LENGTH,
1008 0,
1009 (z -> Double64Mask.FALSE_MASK));
1010 }
1011
1012 @Override
1013 @ForceInline
1014 public Double64Vector fromArray(double[] a, int ix) {
1015 Objects.requireNonNull(a);
1016 ix = VectorIntrinsics.checkIndex(ix, a.length, LENGTH);
1017 return (Double64Vector) VectorIntrinsics.load(Double64Vector.class, double.class, LENGTH,
1018 a, ix,
1019 (arr, idx) -> super.fromArray((double[]) arr, idx));
1020 }
1021
1022 @Override
1023 @ForceInline
1024 public Double64Vector fromArray(double[] a, int ax, Mask<Double, Shapes.S64Bit> m) {
1025 return zero().blend(fromArray(a, ax), m); // TODO: use better default impl: op(m, i -> a[ax + i]);
1026 }
1027 }
1028 }
|
702 public Double64Vector blend(Vector<Double, Shapes.S64Bit> o1, Mask<Double, Shapes.S64Bit> o2) {
703 Objects.requireNonNull(o1);
704 Objects.requireNonNull(o2);
705 Double64Vector v = (Double64Vector)o1;
706 Double64Mask m = (Double64Mask)o2;
707
708 return (Double64Vector) VectorIntrinsics.blend(
709 Double64Vector.class, Double64Mask.class, double.class, LENGTH,
710 this, v, m,
711 (v1, v2, m_) -> v1.bOp(v2, (i, a, b) -> m_.getElement(i) ? b : a));
712 }
713
714 @Override
715 @ForceInline
716 @SuppressWarnings("unchecked")
717 public <F> Vector<F, Shapes.S64Bit> rebracket(Species<F, Shapes.S64Bit> species) {
718 Objects.requireNonNull(species);
719 // TODO: check proper element type
720 // TODO: update to pass the two species as an arguments and ideally
721 // push down intrinsic call into species implementation
722 return VectorIntrinsics.reinterpret(
723 Double64Vector.class, double.class, LENGTH,
724 species.elementType(), species.length(), this,
725 (v, t) -> species.reshape(v)
726 );
727 }
728
729 // Accessors
730
731 @Override
732 public double get(int i) {
733 double[] vec = getElements();
734 return vec[i];
735 }
736
737 @Override
738 public Double64Vector with(int i, double e) {
739 double[] res = vec.clone();
740 res[i] = e;
741 return new Double64Vector(res);
742 }
743
744 // Mask
793 public Double64Species species() {
794 return SPECIES;
795 }
796
797 @Override
798 public Double64Vector toVector() {
799 double[] res = new double[species().length()];
800 boolean[] bits = getBits();
801 for (int i = 0; i < species().length(); i++) {
802 res[i] = (double) (bits[i] ? -1 : 0);
803 }
804 return new Double64Vector(res);
805 }
806
807 @Override
808 @ForceInline
809 @SuppressWarnings("unchecked")
810 public <Z> Mask<Z, Shapes.S64Bit> rebracket(Species<Z, Shapes.S64Bit> species) {
811 Objects.requireNonNull(species);
812 // TODO: check proper element type
813 return VectorIntrinsics.reinterpret(
814 Double64Mask.class, double.class, LENGTH,
815 species.elementType(), species.length(), this,
816 (m, t) -> m.reshape(species)
817 );
818 }
819
820 // Unary operations
821
822 //Mask<E, S> not();
823
824 // Binary operations
825
826 @Override
827 @ForceInline
828 public Double64Mask and(Mask<Double,Shapes.S64Bit> o) {
829 Objects.requireNonNull(o);
830 Double64Mask m = (Double64Mask)o;
831 return VectorIntrinsics.binaryOp(VECTOR_OP_AND, Double64Mask.class, long.class, LENGTH,
832 this, m,
833 (m1, m2) -> m1.bOp(m2, (i, a, b) -> a & b));
834 }
835
892 public Double64Species species() {
893 return SPECIES;
894 }
895
896 static final class Double64Species extends DoubleSpecies<Shapes.S64Bit> {
897 static final int BIT_SIZE = Shapes.S_64_BIT.bitSize();
898
899 static final int LENGTH = BIT_SIZE / Double.SIZE;
900
901 @Override
902 public String toString() {
903 StringBuilder sb = new StringBuilder("Shape[");
904 sb.append(bitSize()).append(" bits, ");
905 sb.append(length()).append(" ").append(double.class.getSimpleName()).append("s x ");
906 sb.append(elementSize()).append(" bits");
907 sb.append("]");
908 return sb.toString();
909 }
910
911 @Override
912 @ForceInline
913 public int bitSize() {
914 return BIT_SIZE;
915 }
916
917 @Override
918 @ForceInline
919 public int length() {
920 return LENGTH;
921 }
922
923 @Override
924 @ForceInline
925 public Class<Double> elementType() {
926 return Double.class;
927 }
928
929 @Override
930 @ForceInline
931 public int elementSize() {
932 return Double.SIZE;
933 }
934
935 @Override
936 @ForceInline
937 public Shapes.S64Bit shape() {
938 return Shapes.S_64_BIT;
939 }
940
941 @Override
942 Double64Vector op(FOp f) {
943 double[] res = new double[length()];
944 for (int i = 0; i < length(); i++) {
945 res[i] = f.apply(i);
946 }
947 return new Double64Vector(res);
948 }
949
950 @Override
951 Double64Vector op(Mask<Double, Shapes.S64Bit> o, FOp f) {
952 double[] res = new double[length()];
953 boolean[] mbits = ((Double64Mask)o).getBits();
954 for (int i = 0; i < length(); i++) {
955 if (mbits[i]) {
956 res[i] = f.apply(i);
1011 public Double64Mask maskAllFalse() {
1012 return VectorIntrinsics.broadcastCoerced(Double64Mask.class, long.class, LENGTH,
1013 0,
1014 (z -> Double64Mask.FALSE_MASK));
1015 }
1016
1017 @Override
1018 @ForceInline
1019 public Double64Vector fromArray(double[] a, int ix) {
1020 Objects.requireNonNull(a);
1021 ix = VectorIntrinsics.checkIndex(ix, a.length, LENGTH);
1022 return (Double64Vector) VectorIntrinsics.load(Double64Vector.class, double.class, LENGTH,
1023 a, ix,
1024 (arr, idx) -> super.fromArray((double[]) arr, idx));
1025 }
1026
1027 @Override
1028 @ForceInline
1029 public Double64Vector fromArray(double[] a, int ax, Mask<Double, Shapes.S64Bit> m) {
1030 return zero().blend(fromArray(a, ax), m); // TODO: use better default impl: op(m, i -> a[ax + i]);
1031 }
1032
1033 @Override
1034 @ForceInline
1035 @SuppressWarnings("unchecked")
1036 public <T extends Shape> Double64Vector resize(Vector<Double, T> o) {
1037 Objects.requireNonNull(o);
1038 if (o.bitSize() == 64) {
1039 Double64Vector so = (Double64Vector)o;
1040 return VectorIntrinsics.reinterpret(
1041 Double64Vector.class, double.class, so.length(),
1042 Double.class, LENGTH, so,
1043 (v, t) -> (Double64Vector)reshape(v)
1044 );
1045 } else if (o.bitSize() == 128) {
1046 Double128Vector so = (Double128Vector)o;
1047 return VectorIntrinsics.reinterpret(
1048 Double128Vector.class, double.class, so.length(),
1049 Double.class, LENGTH, so,
1050 (v, t) -> (Double64Vector)reshape(v)
1051 );
1052 } else if (o.bitSize() == 256) {
1053 Double256Vector so = (Double256Vector)o;
1054 return VectorIntrinsics.reinterpret(
1055 Double256Vector.class, double.class, so.length(),
1056 Double.class, LENGTH, so,
1057 (v, t) -> (Double64Vector)reshape(v)
1058 );
1059 } else if (o.bitSize() == 512) {
1060 Double512Vector so = (Double512Vector)o;
1061 return VectorIntrinsics.reinterpret(
1062 Double512Vector.class, double.class, so.length(),
1063 Double.class, LENGTH, so,
1064 (v, t) -> (Double64Vector)reshape(v)
1065 );
1066 } else {
1067 throw new InternalError("Unimplemented size");
1068 }
1069 }
1070 }
1071 }
|