1 /*
   2  * Copyright (c) 2017, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have
  23  * questions.
  24  */
  25 package jdk.incubator.vector;
  26 
  27 import java.nio.ByteBuffer;
  28 import java.nio.LongBuffer;
  29 import java.nio.ByteOrder;
  30 import java.util.Objects;
  31 import java.util.function.IntUnaryOperator;
  32 import java.util.function.Function;
  33 import java.util.concurrent.ThreadLocalRandom;
  34 
  35 import jdk.internal.misc.Unsafe;
  36 import jdk.internal.vm.annotation.ForceInline;
  37 import static jdk.incubator.vector.VectorIntrinsics.*;
  38 
  39 
  40 /**
  41  * A specialized {@link Vector} representing an ordered immutable sequence of
  42  * {@code long} values.
  43  */
  44 @SuppressWarnings("cast")
  45 public abstract class LongVector extends Vector<Long> {
  46 
  47     LongVector() {}
  48 
  49     private static final int ARRAY_SHIFT = 31 - Integer.numberOfLeadingZeros(Unsafe.ARRAY_LONG_INDEX_SCALE);
  50 
  51     // Unary operator
  52 
  53     interface FUnOp {
  54         long apply(int i, long a);
  55     }
  56 
  57     abstract LongVector uOp(FUnOp f);
  58 
  59     abstract LongVector uOp(VectorMask<Long> m, FUnOp f);
  60 
  61     // Binary operator
  62 
  63     interface FBinOp {
  64         long apply(int i, long a, long b);
  65     }
  66 
  67     abstract LongVector bOp(Vector<Long> v, FBinOp f);
  68 
  69     abstract LongVector bOp(Vector<Long> v, VectorMask<Long> m, FBinOp f);
  70 
  71     // Trinary operator
  72 
  73     interface FTriOp {
  74         long apply(int i, long a, long b, long c);
  75     }
  76 
  77     abstract LongVector tOp(Vector<Long> v1, Vector<Long> v2, FTriOp f);
  78 
  79     abstract LongVector tOp(Vector<Long> v1, Vector<Long> v2, VectorMask<Long> m, FTriOp f);
  80 
  81     // Reduction operator
  82 
  83     abstract long rOp(long v, FBinOp f);
  84 
  85     // Binary test
  86 
  87     interface FBinTest {
  88         boolean apply(int i, long a, long b);
  89     }
  90 
  91     abstract VectorMask<Long> bTest(Vector<Long> v, FBinTest f);
  92 
  93     // Foreach
  94 
  95     interface FUnCon {
  96         void apply(int i, long a);
  97     }
  98 
  99     abstract void forEach(FUnCon f);
 100 
 101     abstract void forEach(VectorMask<Long> m, FUnCon f);
 102 
 103     // Static factories
 104 
 105     /**
 106      * Returns a vector where all lane elements are set to the default
 107      * primitive value.
 108      *
 109      * @param species species of desired vector
 110      * @return a zero vector of given species
 111      */
 112     @ForceInline
 113     @SuppressWarnings("unchecked")
 114     public static LongVector zero(VectorSpecies<Long> species) {
 115         return VectorIntrinsics.broadcastCoerced((Class<LongVector>) species.vectorType(), long.class, species.length(),
 116                                                  0, species,
 117                                                  ((bits, s) -> ((LongSpecies)s).op(i -> (long)bits)));
 118     }
 119 




















 120     /**
 121      * Loads a vector from a byte array starting at an offset.
 122      * <p>
 123      * Bytes are composed into primitive lane elements according to the
 124      * native byte order of the underlying platform
 125      * <p>
 126      * This method behaves as if it returns the result of calling the
 127      * byte buffer, offset, and mask accepting
 128      * {@link #fromByteBuffer(VectorSpecies, ByteBuffer, int, VectorMask) method} as follows:
 129      * <pre>{@code
 130      * return fromByteBuffer(species, ByteBuffer.wrap(a), offset, VectorMask.allTrue());
 131      * }</pre>
 132      *
 133      * @param species species of desired vector
 134      * @param a the byte array
 135      * @param offset the offset into the array
 136      * @return a vector loaded from a byte array
 137      * @throws IndexOutOfBoundsException if {@code i < 0} or
 138      * {@code offset > a.length - (species.length() * species.elementSize() / Byte.SIZE)}
 139      */
 140     @ForceInline
 141     @SuppressWarnings("unchecked")
 142     public static LongVector fromByteArray(VectorSpecies<Long> species, byte[] a, int offset) {
 143         Objects.requireNonNull(a);
 144         offset = VectorIntrinsics.checkIndex(offset, a.length, species.bitSize() / Byte.SIZE);
 145         return VectorIntrinsics.load((Class<LongVector>) species.vectorType(), long.class, species.length(),
 146                                      a, ((long) offset) + Unsafe.ARRAY_BYTE_BASE_OFFSET,
 147                                      a, offset, species,
 148                                      (c, idx, s) -> {
 149                                          ByteBuffer bbc = ByteBuffer.wrap(c, idx, c.length - idx).order(ByteOrder.nativeOrder());
 150                                          LongBuffer tb = bbc.asLongBuffer();
 151                                          return ((LongSpecies)s).op(i -> tb.get());
 152                                      });
 153     }
 154 
 155     /**
 156      * Loads a vector from a byte array starting at an offset and using a
 157      * mask.
 158      * <p>
 159      * Bytes are composed into primitive lane elements according to the
 160      * native byte order of the underlying platform.
 161      * <p>
 162      * This method behaves as if it returns the result of calling the
 163      * byte buffer, offset, and mask accepting
 164      * {@link #fromByteBuffer(VectorSpecies, ByteBuffer, int, VectorMask) method} as follows:
 165      * <pre>{@code
 166      * return fromByteBuffer(species, ByteBuffer.wrap(a), offset, m);
 167      * }</pre>
 168      *
 169      * @param species species of desired vector
 170      * @param a the byte array
 171      * @param offset the offset into the array
 172      * @param m the mask
 173      * @return a vector loaded from a byte array
 174      * @throws IndexOutOfBoundsException if {@code offset < 0} or
 175      * for any vector lane index {@code N} where the mask at lane {@code N}
 176      * is set
 177      * {@code offset >= a.length - (N * species.elementSize() / Byte.SIZE)}
 178      */
 179     @ForceInline
 180     public static LongVector fromByteArray(VectorSpecies<Long> species, byte[] a, int offset, VectorMask<Long> m) {
 181         return zero(species).blend(fromByteArray(species, a, offset), m);
 182     }
 183 
 184     /**
 185      * Loads a vector from an array starting at offset.
 186      * <p>
 187      * For each vector lane, where {@code N} is the vector lane index, the
 188      * array element at index {@code offset + N} is placed into the
 189      * resulting vector at lane index {@code N}.
 190      *
 191      * @param species species of desired vector
 192      * @param a the array
 193      * @param offset the offset into the array
 194      * @return the vector loaded from an array
 195      * @throws IndexOutOfBoundsException if {@code offset < 0}, or
 196      * {@code offset > a.length - species.length()}
 197      */
 198     @ForceInline
 199     @SuppressWarnings("unchecked")
 200     public static LongVector fromArray(VectorSpecies<Long> species, long[] a, int offset){
 201         Objects.requireNonNull(a);
 202         offset = VectorIntrinsics.checkIndex(offset, a.length, species.length());
 203         return VectorIntrinsics.load((Class<LongVector>) species.vectorType(), long.class, species.length(),
 204                                      a, (((long) offset) << ARRAY_SHIFT) + Unsafe.ARRAY_LONG_BASE_OFFSET,
 205                                      a, offset, species,
 206                                      (c, idx, s) -> ((LongSpecies)s).op(n -> c[idx + n]));
 207     }
 208 
 209 
 210     /**
 211      * Loads a vector from an array starting at offset and using a mask.
 212      * <p>
 213      * For each vector lane, where {@code N} is the vector lane index,
 214      * if the mask lane at index {@code N} is set then the array element at
 215      * index {@code offset + N} is placed into the resulting vector at lane index
 216      * {@code N}, otherwise the default element value is placed into the
 217      * resulting vector at lane index {@code N}.
 218      *
 219      * @param species species of desired vector
 220      * @param a the array
 221      * @param offset the offset into the array
 222      * @param m the mask
 223      * @return the vector loaded from an array
 224      * @throws IndexOutOfBoundsException if {@code offset < 0}, or
 225      * for any vector lane index {@code N} where the mask at lane {@code N}
 226      * is set {@code offset > a.length - N}
 227      */
 228     @ForceInline
 229     public static LongVector fromArray(VectorSpecies<Long> species, long[] a, int offset, VectorMask<Long> m) {
 230         return zero(species).blend(fromArray(species, a, offset), m);
 231     }
 232 
 233     /**
 234      * Loads a vector from an array using indexes obtained from an index
 235      * map.
 236      * <p>
 237      * For each vector lane, where {@code N} is the vector lane index, the
 238      * array element at index {@code a_offset + indexMap[i_offset + N]} is placed into the
 239      * resulting vector at lane index {@code N}.
 240      *
 241      * @param species species of desired vector
 242      * @param a the array
 243      * @param a_offset the offset into the array, may be negative if relative
 244      * indexes in the index map compensate to produce a value within the
 245      * array bounds
 246      * @param indexMap the index map
 247      * @param i_offset the offset into the index map
 248      * @return the vector loaded from an array
 249      * @throws IndexOutOfBoundsException if {@code i_offset < 0}, or
 250      * {@code i_offset > indexMap.length - species.length()},
 251      * or for any vector lane index {@code N} the result of
 252      * {@code a_offset + indexMap[i_offset + N]} is {@code < 0} or {@code >= a.length}
 253      */
 254     @ForceInline
 255     @SuppressWarnings("unchecked")
 256     public static LongVector fromArray(VectorSpecies<Long> species, long[] a, int a_offset, int[] indexMap, int i_offset) {
 257         Objects.requireNonNull(a);
 258         Objects.requireNonNull(indexMap);
 259 
 260         if (species.length() == 1) {
 261           return LongVector.fromArray(species, a, a_offset + indexMap[i_offset]);
 262         }
 263 
 264         // Index vector: vix[0:n] = k -> a_offset + indexMap[i_offset + k]
 265         IntVector vix = IntVector.fromArray(IntVector.species(species.indexShape()), indexMap, i_offset).add(a_offset);
 266 
 267         vix = VectorIntrinsics.checkIndex(vix, a.length);
 268 
 269         return VectorIntrinsics.loadWithMap((Class<LongVector>) species.vectorType(), long.class, species.length(),
 270                                             IntVector.species(species.indexShape()).vectorType(), a, Unsafe.ARRAY_LONG_BASE_OFFSET, vix,
 271                                             a, a_offset, indexMap, i_offset, species,
 272                                             (long[] c, int idx, int[] iMap, int idy, VectorSpecies<Long> s) ->
 273                                                 ((LongSpecies)s).op(n -> c[idx + iMap[idy+n]]));
 274         }
 275 
 276     /**
 277      * Loads a vector from an array using indexes obtained from an index
 278      * map and using a mask.
 279      * <p>
 280      * For each vector lane, where {@code N} is the vector lane index,
 281      * if the mask lane at index {@code N} is set then the array element at
 282      * index {@code a_offset + indexMap[i_offset + N]} is placed into the resulting vector
 283      * at lane index {@code N}.
 284      *
 285      * @param species species of desired vector
 286      * @param a the array
 287      * @param a_offset the offset into the array, may be negative if relative
 288      * indexes in the index map compensate to produce a value within the
 289      * array bounds
 290      * @param m the mask
 291      * @param indexMap the index map
 292      * @param i_offset the offset into the index map
 293      * @return the vector loaded from an array
 294      * @throws IndexOutOfBoundsException if {@code i_offset < 0}, or
 295      * {@code i_offset > indexMap.length - species.length()},
 296      * or for any vector lane index {@code N} where the mask at lane
 297      * {@code N} is set the result of {@code a_offset + indexMap[i_offset + N]} is
 298      * {@code < 0} or {@code >= a.length}
 299      */
 300     @ForceInline
 301     @SuppressWarnings("unchecked")
 302     public static LongVector fromArray(VectorSpecies<Long> species, long[] a, int a_offset, VectorMask<Long> m, int[] indexMap, int i_offset) {
 303         // @@@ This can result in out of bounds errors for unset mask lanes
 304         return zero(species).blend(fromArray(species, a, a_offset, indexMap, i_offset), m);
 305     }
 306 
 307 
 308     /**
 309      * Loads a vector from a {@link ByteBuffer byte buffer} starting at an
 310      * offset into the byte buffer.
 311      * <p>
 312      * Bytes are composed into primitive lane elements according to the
 313      * native byte order of the underlying platform.
 314      * <p>
 315      * This method behaves as if it returns the result of calling the
 316      * byte buffer, offset, and mask accepting
 317      * {@link #fromByteBuffer(VectorSpecies, ByteBuffer, int, VectorMask)} method} as follows:
 318      * <pre>{@code
 319      *   return fromByteBuffer(b, offset, VectorMask.allTrue())
 320      * }</pre>
 321      *
 322      * @param species species of desired vector
 323      * @param bb the byte buffer
 324      * @param offset the offset into the byte buffer
 325      * @return a vector loaded from a byte buffer
 326      * @throws IndexOutOfBoundsException if the offset is {@code < 0},
 327      * or {@code > b.limit()},
 328      * or if there are fewer than
 329      * {@code species.length() * species.elementSize() / Byte.SIZE} bytes
 330      * remaining in the byte buffer from the given offset
 331      */
 332     @ForceInline
 333     @SuppressWarnings("unchecked")
 334     public static LongVector fromByteBuffer(VectorSpecies<Long> species, ByteBuffer bb, int offset) {
 335         if (bb.order() != ByteOrder.nativeOrder()) {
 336             throw new IllegalArgumentException();
 337         }
 338         offset = VectorIntrinsics.checkIndex(offset, bb.limit(), species.bitSize() / Byte.SIZE);
 339         return VectorIntrinsics.load((Class<LongVector>) species.vectorType(), long.class, species.length(),
 340                                      U.getReference(bb, BYTE_BUFFER_HB), U.getLong(bb, BUFFER_ADDRESS) + offset,
 341                                      bb, offset, species,
 342                                      (c, idx, s) -> {
 343                                          ByteBuffer bbc = c.duplicate().position(idx).order(ByteOrder.nativeOrder());
 344                                          LongBuffer tb = bbc.asLongBuffer();
 345                                          return ((LongSpecies)s).op(i -> tb.get());
 346                                      });
 347     }
 348 
 349     /**
 350      * Loads a vector from a {@link ByteBuffer byte buffer} starting at an
 351      * offset into the byte buffer and using a mask.
 352      * <p>
 353      * This method behaves as if the byte buffer is viewed as a primitive
 354      * {@link java.nio.Buffer buffer} for the primitive element type,
 355      * according to the native byte order of the underlying platform, and
 356      * the returned vector is loaded with a mask from a primitive array
 357      * obtained from the primitive buffer.
 358      * The following pseudocode expresses the behaviour, where
 359      * {@code EBuffer} is the primitive buffer type, {@code e} is the
 360      * primitive element type, and {@code ESpecies} is the primitive
 361      * species for {@code e}:
 362      * <pre>{@code
 363      * EBuffer eb = b.duplicate().
 364      *     order(ByteOrder.nativeOrder()).position(offset).
 365      *     asEBuffer();
 366      * e[] es = new e[species.length()];
 367      * for (int n = 0; n < t.length; n++) {
 368      *     if (m.isSet(n))
 369      *         es[n] = eb.get(n);
 370      * }
 371      * EVector r = EVector.fromArray(es, 0, m);
 372      * }</pre>
 373      *
 374      * @param species species of desired vector
 375      * @param bb the byte buffer
 376      * @param offset the offset into the byte buffer
 377      * @param m the mask
 378      * @return a vector loaded from a byte buffer
 379      * @throws IndexOutOfBoundsException if the offset is {@code < 0},
 380      * or {@code > b.limit()},
 381      * for any vector lane index {@code N} where the mask at lane {@code N}
 382      * is set
 383      * {@code offset >= b.limit() - (N * species.elementSize() / Byte.SIZE)}
 384      */
 385     @ForceInline
 386     public static LongVector fromByteBuffer(VectorSpecies<Long> species, ByteBuffer bb, int offset, VectorMask<Long> m) {
 387         return zero(species).blend(fromByteBuffer(species, bb, offset), m);
 388     }
 389 
 390     /**
 391      * Returns a vector where all lane elements are set to the primitive
 392      * value {@code e}.
 393      *
 394      * @param species species of the desired vector
 395      * @param e the value to be broadcasted
 396      * @return a vector of vector where all lane elements are set to
 397      * the primitive value {@code e}
 398      */
 399     @ForceInline
 400     @SuppressWarnings("unchecked")
 401     public static LongVector broadcast(VectorSpecies<Long> species, long e) {
 402         return VectorIntrinsics.broadcastCoerced(
 403             (Class<LongVector>) species.vectorType(), long.class, species.length(),
 404             e, species,
 405             ((bits, sp) -> ((LongSpecies)sp).op(i -> (long)bits)));
 406     }
 407 
 408     /**
 409      * Returns a vector where each lane element is set to given
 410      * primitive values.
 411      * <p>
 412      * For each vector lane, where {@code N} is the vector lane index, the
 413      * the primitive value at index {@code N} is placed into the resulting
 414      * vector at lane index {@code N}.
 415      *
 416      * @param species species of the desired vector
 417      * @param es the given primitive values
 418      * @return a vector where each lane element is set to given primitive
 419      * values
 420      * @throws IndexOutOfBoundsException if {@code es.length < species.length()}
 421      */
 422     @ForceInline
 423     @SuppressWarnings("unchecked")
 424     public static LongVector scalars(VectorSpecies<Long> species, long... es) {
 425         Objects.requireNonNull(es);
 426         int ix = VectorIntrinsics.checkIndex(0, es.length, species.length());
 427         return VectorIntrinsics.load((Class<LongVector>) species.vectorType(), long.class, species.length(),
 428                                      es, Unsafe.ARRAY_LONG_BASE_OFFSET,
 429                                      es, ix, species,
 430                                      (c, idx, sp) -> ((LongSpecies)sp).op(n -> c[idx + n]));
 431     }
 432 
 433     /**
 434      * Returns a vector where the first lane element is set to the primtive
 435      * value {@code e}, all other lane elements are set to the default
 436      * value.
 437      *
 438      * @param species species of the desired vector
 439      * @param e the value
 440      * @return a vector where the first lane element is set to the primitive
 441      * value {@code e}
 442      */
 443     @ForceInline
 444     public static final LongVector single(VectorSpecies<Long> species, long e) {
 445         return zero(species).with(0, e);
 446     }
 447 
 448     /**
 449      * Returns a vector where each lane element is set to a randomly
 450      * generated primitive value.
 451      *
 452      * The semantics are equivalent to calling
 453      * {@link ThreadLocalRandom#nextLong()}
 454      *
 455      * @param species species of the desired vector
 456      * @return a vector where each lane elements is set to a randomly
 457      * generated primitive value
 458      */
 459     public static LongVector random(VectorSpecies<Long> species) {
 460         ThreadLocalRandom r = ThreadLocalRandom.current();
 461         return ((LongSpecies)species).op(i -> r.nextLong());
 462     }
 463 
 464     // Ops
 465 
 466     /**
 467      * {@inheritDoc}
 468      */
 469     @Override
 470     public abstract LongVector add(Vector<Long> v);
 471 
 472     /**
 473      * Adds this vector to the broadcast of an input scalar.
 474      * <p>
 475      * This is a lane-wise binary operation which applies the primitive addition operation
 476      * ({@code +}) to each lane.
 477      *
 478      * @param s the input scalar
 479      * @return the result of adding this vector to the broadcast of an input
 480      * scalar
 481      */
 482     public abstract LongVector add(long s);
 483 
 484     /**
 485      * {@inheritDoc}
 486      */
 487     @Override
 488     public abstract LongVector add(Vector<Long> v, VectorMask<Long> m);
 489 
 490     /**
 491      * Adds this vector to broadcast of an input scalar,
 492      * selecting lane elements controlled by a mask.
 493      * <p>
 494      * This is a lane-wise binary operation which applies the primitive addition operation
 495      * ({@code +}) to each lane.
 496      *
 497      * @param s the input scalar
 498      * @param m the mask controlling lane selection
 499      * @return the result of adding this vector to the broadcast of an input
 500      * scalar
 501      */
 502     public abstract LongVector add(long s, VectorMask<Long> m);
 503 
 504     /**
 505      * {@inheritDoc}
 506      */
 507     @Override
 508     public abstract LongVector sub(Vector<Long> v);
 509 
 510     /**
 511      * Subtracts the broadcast of an input scalar from this vector.
 512      * <p>
 513      * This is a lane-wise binary operation which applies the primitive subtraction
 514      * operation ({@code -}) to each lane.
 515      *
 516      * @param s the input scalar
 517      * @return the result of subtracting the broadcast of an input
 518      * scalar from this vector
 519      */
 520     public abstract LongVector sub(long s);
 521 
 522     /**
 523      * {@inheritDoc}
 524      */
 525     @Override
 526     public abstract LongVector sub(Vector<Long> v, VectorMask<Long> m);
 527 
 528     /**
 529      * Subtracts the broadcast of an input scalar from this vector, selecting
 530      * lane elements controlled by a mask.
 531      * <p>
 532      * This is a lane-wise binary operation which applies the primitive subtraction
 533      * operation ({@code -}) to each lane.
 534      *
 535      * @param s the input scalar
 536      * @param m the mask controlling lane selection
 537      * @return the result of subtracting the broadcast of an input
 538      * scalar from this vector
 539      */
 540     public abstract LongVector sub(long s, VectorMask<Long> m);
 541 
 542     /**
 543      * {@inheritDoc}
 544      */
 545     @Override
 546     public abstract LongVector mul(Vector<Long> v);
 547 
 548     /**
 549      * Multiplies this vector with the broadcast of an input scalar.
 550      * <p>
 551      * This is a lane-wise binary operation which applies the primitive multiplication
 552      * operation ({@code *}) to each lane.
 553      *
 554      * @param s the input scalar
 555      * @return the result of multiplying this vector with the broadcast of an
 556      * input scalar
 557      */
 558     public abstract LongVector mul(long s);
 559 
 560     /**
 561      * {@inheritDoc}
 562      */
 563     @Override
 564     public abstract LongVector mul(Vector<Long> v, VectorMask<Long> m);
 565 
 566     /**
 567      * Multiplies this vector with the broadcast of an input scalar, selecting
 568      * lane elements controlled by a mask.
 569      * <p>
 570      * This is a lane-wise binary operation which applies the primitive multiplication
 571      * operation ({@code *}) to each lane.
 572      *
 573      * @param s the input scalar
 574      * @param m the mask controlling lane selection
 575      * @return the result of multiplying this vector with the broadcast of an
 576      * input scalar
 577      */
 578     public abstract LongVector mul(long s, VectorMask<Long> m);
 579 
 580     /**
 581      * {@inheritDoc}
 582      */
 583     @Override
 584     public abstract LongVector neg();
 585 
 586     /**
 587      * {@inheritDoc}
 588      */
 589     @Override
 590     public abstract LongVector neg(VectorMask<Long> m);
 591 
 592     /**
 593      * {@inheritDoc}
 594      */
 595     @Override
 596     public abstract LongVector abs();
 597 
 598     /**
 599      * {@inheritDoc}
 600      */
 601     @Override
 602     public abstract LongVector abs(VectorMask<Long> m);
 603 
 604     /**
 605      * {@inheritDoc}
 606      */
 607     @Override
 608     public abstract LongVector min(Vector<Long> v);
 609 
 610     /**
 611      * {@inheritDoc}
 612      */
 613     @Override
 614     public abstract LongVector min(Vector<Long> v, VectorMask<Long> m);
 615 
 616     /**
 617      * Returns the minimum of this vector and the broadcast of an input scalar.
 618      * <p>
 619      * This is a lane-wise binary operation which applies the operation
 620      * {@code (a, b) -> Math.min(a, b)} to each lane.
 621      *
 622      * @param s the input scalar
 623      * @return the minimum of this vector and the broadcast of an input scalar
 624      */
 625     public abstract LongVector min(long s);
 626 
 627     /**
 628      * {@inheritDoc}
 629      */
 630     @Override
 631     public abstract LongVector max(Vector<Long> v);
 632 
 633     /**
 634      * {@inheritDoc}
 635      */
 636     @Override
 637     public abstract LongVector max(Vector<Long> v, VectorMask<Long> m);
 638 
 639     /**
 640      * Returns the maximum of this vector and the broadcast of an input scalar.
 641      * <p>
 642      * This is a lane-wise binary operation which applies the operation
 643      * {@code (a, b) -> Math.max(a, b)} to each lane.
 644      *
 645      * @param s the input scalar
 646      * @return the maximum of this vector and the broadcast of an input scalar
 647      */
 648     public abstract LongVector max(long s);
 649 
 650     /**
 651      * {@inheritDoc}
 652      */
 653     @Override
 654     public abstract VectorMask<Long> equal(Vector<Long> v);
 655 
 656     /**
 657      * Tests if this vector is equal to the broadcast of an input scalar.
 658      * <p>
 659      * This is a lane-wise binary test operation which applies the primitive equals
 660      * operation ({@code ==}) each lane.
 661      *
 662      * @param s the input scalar
 663      * @return the result mask of testing if this vector is equal to the
 664      * broadcast of an input scalar
 665      */
 666     public abstract VectorMask<Long> equal(long s);
 667 
 668     /**
 669      * {@inheritDoc}
 670      */
 671     @Override
 672     public abstract VectorMask<Long> notEqual(Vector<Long> v);
 673 
 674     /**
 675      * Tests if this vector is not equal to the broadcast of an input scalar.
 676      * <p>
 677      * This is a lane-wise binary test operation which applies the primitive not equals
 678      * operation ({@code !=}) to each lane.
 679      *
 680      * @param s the input scalar
 681      * @return the result mask of testing if this vector is not equal to the
 682      * broadcast of an input scalar
 683      */
 684     public abstract VectorMask<Long> notEqual(long s);
 685 
 686     /**
 687      * {@inheritDoc}
 688      */
 689     @Override
 690     public abstract VectorMask<Long> lessThan(Vector<Long> v);
 691 
 692     /**
 693      * Tests if this vector is less than the broadcast of an input scalar.
 694      * <p>
 695      * This is a lane-wise binary test operation which applies the primitive less than
 696      * operation ({@code <}) to each lane.
 697      *
 698      * @param s the input scalar
 699      * @return the mask result of testing if this vector is less than the
 700      * broadcast of an input scalar
 701      */
 702     public abstract VectorMask<Long> lessThan(long s);
 703 
 704     /**
 705      * {@inheritDoc}
 706      */
 707     @Override
 708     public abstract VectorMask<Long> lessThanEq(Vector<Long> v);
 709 
 710     /**
 711      * Tests if this vector is less or equal to the broadcast of an input scalar.
 712      * <p>
 713      * This is a lane-wise binary test operation which applies the primitive less than
 714      * or equal to operation ({@code <=}) to each lane.
 715      *
 716      * @param s the input scalar
 717      * @return the mask result of testing if this vector is less than or equal
 718      * to the broadcast of an input scalar
 719      */
 720     public abstract VectorMask<Long> lessThanEq(long s);
 721 
 722     /**
 723      * {@inheritDoc}
 724      */
 725     @Override
 726     public abstract VectorMask<Long> greaterThan(Vector<Long> v);
 727 
 728     /**
 729      * Tests if this vector is greater than the broadcast of an input scalar.
 730      * <p>
 731      * This is a lane-wise binary test operation which applies the primitive greater than
 732      * operation ({@code >}) to each lane.
 733      *
 734      * @param s the input scalar
 735      * @return the mask result of testing if this vector is greater than the
 736      * broadcast of an input scalar
 737      */
 738     public abstract VectorMask<Long> greaterThan(long s);
 739 
 740     /**
 741      * {@inheritDoc}
 742      */
 743     @Override
 744     public abstract VectorMask<Long> greaterThanEq(Vector<Long> v);
 745 
 746     /**
 747      * Tests if this vector is greater than or equal to the broadcast of an
 748      * input scalar.
 749      * <p>
 750      * This is a lane-wise binary test operation which applies the primitive greater than
 751      * or equal to operation ({@code >=}) to each lane.
 752      *
 753      * @param s the input scalar
 754      * @return the mask result of testing if this vector is greater than or
 755      * equal to the broadcast of an input scalar
 756      */
 757     public abstract VectorMask<Long> greaterThanEq(long s);
 758 
 759     /**
 760      * {@inheritDoc}
 761      */
 762     @Override
 763     public abstract LongVector blend(Vector<Long> v, VectorMask<Long> m);
 764 
 765     /**
 766      * Blends the lane elements of this vector with those of the broadcast of an
 767      * input scalar, selecting lanes controlled by a mask.
 768      * <p>
 769      * For each lane of the mask, at lane index {@code N}, if the mask lane
 770      * is set then the lane element at {@code N} from the input vector is
 771      * selected and placed into the resulting vector at {@code N},
 772      * otherwise the the lane element at {@code N} from this input vector is
 773      * selected and placed into the resulting vector at {@code N}.
 774      *
 775      * @param s the input scalar
 776      * @param m the mask controlling lane selection
 777      * @return the result of blending the lane elements of this vector with
 778      * those of the broadcast of an input scalar
 779      */
 780     public abstract LongVector blend(long s, VectorMask<Long> m);
 781 
 782     /**
 783      * {@inheritDoc}
 784      */
 785     @Override
 786     public abstract LongVector rearrange(Vector<Long> v,
 787                                                       VectorShuffle<Long> s, VectorMask<Long> m);
 788 
 789     /**
 790      * {@inheritDoc}
 791      */
 792     @Override
 793     public abstract LongVector rearrange(VectorShuffle<Long> m);
 794 
 795     /**
 796      * {@inheritDoc}
 797      */
 798     @Override
 799     public abstract LongVector reshape(VectorSpecies<Long> s);
 800 
 801     /**
 802      * {@inheritDoc}
 803      */
 804     @Override
 805     public abstract LongVector rotateLanesLeft(int i);
 806 
 807     /**
 808      * {@inheritDoc}
 809      */
 810     @Override
 811     public abstract LongVector rotateLanesRight(int i);
 812 
 813     /**
 814      * {@inheritDoc}
 815      */
 816     @Override
 817     public abstract LongVector shiftLanesLeft(int i);
 818 
 819     /**
 820      * {@inheritDoc}
 821      */
 822     @Override
 823     public abstract LongVector shiftLanesRight(int i);
 824 
 825 
 826 
 827     /**
 828      * Bitwise ANDs this vector with an input vector.
 829      * <p>
 830      * This is a lane-wise binary operation which applies the primitive bitwise AND
 831      * operation ({@code &}) to each lane.
 832      *
 833      * @param v the input vector
 834      * @return the bitwise AND of this vector with the input vector
 835      */
 836     public abstract LongVector and(Vector<Long> v);
 837 
 838     /**
 839      * Bitwise ANDs this vector with the broadcast of an input scalar.
 840      * <p>
 841      * This is a lane-wise binary operation which applies the primitive bitwise AND
 842      * operation ({@code &}) to each lane.
 843      *
 844      * @param s the input scalar
 845      * @return the bitwise AND of this vector with the broadcast of an input
 846      * scalar
 847      */
 848     public abstract LongVector and(long s);
 849 
 850     /**
 851      * Bitwise ANDs this vector with an input vector, selecting lane elements
 852      * controlled by a mask.
 853      * <p>
 854      * This is a lane-wise binary operation which applies the primitive bitwise AND
 855      * operation ({@code &}) to each lane.
 856      *
 857      * @param v the input vector
 858      * @param m the mask controlling lane selection
 859      * @return the bitwise AND of this vector with the input vector
 860      */
 861     public abstract LongVector and(Vector<Long> v, VectorMask<Long> m);
 862 
 863     /**
 864      * Bitwise ANDs this vector with the broadcast of an input scalar, selecting
 865      * lane elements controlled by a mask.
 866      * <p>
 867      * This is a lane-wise binary operation which applies the primitive bitwise AND
 868      * operation ({@code &}) to each lane.
 869      *
 870      * @param s the input scalar
 871      * @param m the mask controlling lane selection
 872      * @return the bitwise AND of this vector with the broadcast of an input
 873      * scalar
 874      */
 875     public abstract LongVector and(long s, VectorMask<Long> m);
 876 
 877     /**
 878      * Bitwise ORs this vector with an input vector.
 879      * <p>
 880      * This is a lane-wise binary operation which applies the primitive bitwise OR
 881      * operation ({@code |}) to each lane.
 882      *
 883      * @param v the input vector
 884      * @return the bitwise OR of this vector with the input vector
 885      */
 886     public abstract LongVector or(Vector<Long> v);
 887 
 888     /**
 889      * Bitwise ORs this vector with the broadcast of an input scalar.
 890      * <p>
 891      * This is a lane-wise binary operation which applies the primitive bitwise OR
 892      * operation ({@code |}) to each lane.
 893      *
 894      * @param s the input scalar
 895      * @return the bitwise OR of this vector with the broadcast of an input
 896      * scalar
 897      */
 898     public abstract LongVector or(long s);
 899 
 900     /**
 901      * Bitwise ORs this vector with an input vector, selecting lane elements
 902      * controlled by a mask.
 903      * <p>
 904      * This is a lane-wise binary operation which applies the primitive bitwise OR
 905      * operation ({@code |}) to each lane.
 906      *
 907      * @param v the input vector
 908      * @param m the mask controlling lane selection
 909      * @return the bitwise OR of this vector with the input vector
 910      */
 911     public abstract LongVector or(Vector<Long> v, VectorMask<Long> m);
 912 
 913     /**
 914      * Bitwise ORs this vector with the broadcast of an input scalar, selecting
 915      * lane elements controlled by a mask.
 916      * <p>
 917      * This is a lane-wise binary operation which applies the primitive bitwise OR
 918      * operation ({@code |}) to each lane.
 919      *
 920      * @param s the input scalar
 921      * @param m the mask controlling lane selection
 922      * @return the bitwise OR of this vector with the broadcast of an input
 923      * scalar
 924      */
 925     public abstract LongVector or(long s, VectorMask<Long> m);
 926 
 927     /**
 928      * Bitwise XORs this vector with an input vector.
 929      * <p>
 930      * This is a lane-wise binary operation which applies the primitive bitwise XOR
 931      * operation ({@code ^}) to each lane.
 932      *
 933      * @param v the input vector
 934      * @return the bitwise XOR of this vector with the input vector
 935      */
 936     public abstract LongVector xor(Vector<Long> v);
 937 
 938     /**
 939      * Bitwise XORs this vector with the broadcast of an input scalar.
 940      * <p>
 941      * This is a lane-wise binary operation which applies the primitive bitwise XOR
 942      * operation ({@code ^}) to each lane.
 943      *
 944      * @param s the input scalar
 945      * @return the bitwise XOR of this vector with the broadcast of an input
 946      * scalar
 947      */
 948     public abstract LongVector xor(long s);
 949 
 950     /**
 951      * Bitwise XORs this vector with an input vector, selecting lane elements
 952      * controlled by a mask.
 953      * <p>
 954      * This is a lane-wise binary operation which applies the primitive bitwise XOR
 955      * operation ({@code ^}) to each lane.
 956      *
 957      * @param v the input vector
 958      * @param m the mask controlling lane selection
 959      * @return the bitwise XOR of this vector with the input vector
 960      */
 961     public abstract LongVector xor(Vector<Long> v, VectorMask<Long> m);
 962 
 963     /**
 964      * Bitwise XORs this vector with the broadcast of an input scalar, selecting
 965      * lane elements controlled by a mask.
 966      * <p>
 967      * This is a lane-wise binary operation which applies the primitive bitwise XOR
 968      * operation ({@code ^}) to each lane.
 969      *
 970      * @param s the input scalar
 971      * @param m the mask controlling lane selection
 972      * @return the bitwise XOR of this vector with the broadcast of an input
 973      * scalar
 974      */
 975     public abstract LongVector xor(long s, VectorMask<Long> m);
 976 
 977     /**
 978      * Bitwise NOTs this vector.
 979      * <p>
 980      * This is a lane-wise unary operation which applies the primitive bitwise NOT
 981      * operation ({@code ~}) to each lane.
 982      *
 983      * @return the bitwise NOT of this vector
 984      */
 985     public abstract LongVector not();
 986 
 987     /**
 988      * Bitwise NOTs this vector, selecting lane elements controlled by a mask.
 989      * <p>
 990      * This is a lane-wise unary operation which applies the primitive bitwise NOT
 991      * operation ({@code ~}) to each lane.
 992      *
 993      * @param m the mask controlling lane selection
 994      * @return the bitwise NOT of this vector
 995      */
 996     public abstract LongVector not(VectorMask<Long> m);
 997 
 998     /**
 999      * Logically left shifts this vector by the broadcast of an input scalar.
1000      * <p>
1001      * This is a lane-wise binary operation which applies the primitive logical left shift
1002      * operation ({@code <<}) to each lane to left shift the
1003      * element by shift value as specified by the input scalar.
1004      *
1005      * @param s the input scalar; the number of the bits to left shift
1006      * @return the result of logically left shifting this vector by the
1007      * broadcast of an input scalar
1008      */
1009     public abstract LongVector shiftLeft(int s);
1010 
1011     /**
1012      * Logically left shifts this vector by the broadcast of an input scalar,
1013      * selecting lane elements controlled by a mask.
1014      * <p>
1015      * This is a lane-wise binary operation which applies the primitive logical left shift
1016      * operation ({@code <<}) to each lane to left shift the
1017      * element by shift value as specified by the input scalar.
1018      *
1019      * @param s the input scalar; the number of the bits to left shift
1020      * @param m the mask controlling lane selection
1021      * @return the result of logically left shifting this vector by the
1022      * broadcast of an input scalar
1023      */
1024     public abstract LongVector shiftLeft(int s, VectorMask<Long> m);
1025 
1026     /**
1027      * Logically left shifts this vector by an input vector.
1028      * <p>
1029      * This is a lane-wise binary operation which applies the primitive logical left shift
1030      * operation ({@code <<}) to each lane. For each lane of this vector, the
1031      * shift value is the corresponding lane of input vector.
1032      *
1033      * @param v the input vector
1034      * @return the result of logically left shifting this vector by the input
1035      * vector
1036      */
1037     public abstract LongVector shiftLeft(Vector<Long> v);
1038 
1039     /**
1040      * Logically left shifts this vector by an input vector, selecting lane
1041      * elements controlled by a mask.
1042      * <p>
1043      * This is a lane-wise binary operation which applies the primitive logical left shift
1044      * operation ({@code <<}) to each lane. For each lane of this vector, the
1045      * shift value is the corresponding lane of input vector.
1046      *
1047      * @param v the input vector
1048      * @param m the mask controlling lane selection
1049      * @return the result of logically left shifting this vector by the input
1050      * vector
1051      */
1052     public LongVector shiftLeft(Vector<Long> v, VectorMask<Long> m) {
1053         return blend(shiftLeft(v), m);
1054     }
1055 
1056     // logical, or unsigned, shift right
1057 
1058      /**
1059      * Logically right shifts (or unsigned right shifts) this vector by the
1060      * broadcast of an input scalar.
1061      * <p>
1062      * This is a lane-wise binary operation which applies the primitive logical right shift
1063      * operation ({@code >>>}) to each lane to logically right shift the
1064      * element by shift value as specified by the input scalar.
1065      *
1066      * @param s the input scalar; the number of the bits to right shift
1067      * @return the result of logically right shifting this vector by the
1068      * broadcast of an input scalar
1069      */
1070     public abstract LongVector shiftRight(int s);
1071 
1072      /**
1073      * Logically right shifts (or unsigned right shifts) this vector by the
1074      * broadcast of an input scalar, selecting lane elements controlled by a
1075      * mask.
1076      * <p>
1077      * This is a lane-wise binary operation which applies the primitive logical right shift
1078      * operation ({@code >>}) to each lane to logically right shift the
1079      * element by shift value as specified by the input scalar.
1080      *
1081      * @param s the input scalar; the number of the bits to right shift
1082      * @param m the mask controlling lane selection
1083      * @return the result of logically right shifting this vector by the
1084      * broadcast of an input scalar
1085      */
1086     public abstract LongVector shiftRight(int s, VectorMask<Long> m);
1087 
1088     /**
1089      * Logically right shifts (or unsigned right shifts) this vector by an
1090      * input vector.
1091      * <p>
1092      * This is a lane-wise binary operation which applies the primitive logical right shift
1093      * operation ({@code >>>}) to each lane. For each lane of this vector, the
1094      * shift value is the corresponding lane of input vector.
1095      *
1096      * @param v the input vector
1097      * @return the result of logically right shifting this vector by the
1098      * input vector
1099      */
1100     public abstract LongVector shiftRight(Vector<Long> v);
1101 
1102     /**
1103      * Logically right shifts (or unsigned right shifts) this vector by an
1104      * input vector, selecting lane elements controlled by a mask.
1105      * <p>
1106      * This is a lane-wise binary operation which applies the primitive logical right shift
1107      * operation ({@code >>>}) to each lane. For each lane of this vector, the
1108      * shift value is the corresponding lane of input vector.
1109      *
1110      * @param v the input vector
1111      * @param m the mask controlling lane selection
1112      * @return the result of logically right shifting this vector by the
1113      * input vector
1114      */
1115     public LongVector shiftRight(Vector<Long> v, VectorMask<Long> m) {
1116         return blend(shiftRight(v), m);
1117     }
1118 
1119     /**
1120      * Arithmetically right shifts (or signed right shifts) this vector by the
1121      * broadcast of an input scalar.
1122      * <p>
1123      * This is a lane-wise binary operation which applies the primitive arithmetic right
1124      * shift operation ({@code >>}) to each lane to arithmetically
1125      * right shift the element by shift value as specified by the input scalar.
1126      *
1127      * @param s the input scalar; the number of the bits to right shift
1128      * @return the result of arithmetically right shifting this vector by the
1129      * broadcast of an input scalar
1130      */
1131     public abstract LongVector shiftArithmeticRight(int s);
1132 
1133     /**
1134      * Arithmetically right shifts (or signed right shifts) this vector by the
1135      * broadcast of an input scalar, selecting lane elements controlled by a
1136      * mask.
1137      * <p>
1138      * This is a lane-wise binary operation which applies the primitive arithmetic right
1139      * shift operation ({@code >>}) to each lane to arithmetically
1140      * right shift the element by shift value as specified by the input scalar.
1141      *
1142      * @param s the input scalar; the number of the bits to right shift
1143      * @param m the mask controlling lane selection
1144      * @return the result of arithmetically right shifting this vector by the
1145      * broadcast of an input scalar
1146      */
1147     public abstract LongVector shiftArithmeticRight(int s, VectorMask<Long> m);
1148 
1149     /**
1150      * Arithmetically right shifts (or signed right shifts) this vector by an
1151      * input vector.
1152      * <p>
1153      * This is a lane-wise binary operation which applies the primitive arithmetic right
1154      * shift operation ({@code >>}) to each lane. For each lane of this vector, the
1155      * shift value is the corresponding lane of input vector.
1156      *
1157      * @param v the input vector
1158      * @return the result of arithmetically right shifting this vector by the
1159      * input vector
1160      */
1161     public abstract LongVector shiftArithmeticRight(Vector<Long> v);
1162 
1163     /**
1164      * Arithmetically right shifts (or signed right shifts) this vector by an
1165      * input vector, selecting lane elements controlled by a mask.
1166      * <p>
1167      * This is a lane-wise binary operation which applies the primitive arithmetic right
1168      * shift operation ({@code >>}) to each lane. For each lane of this vector, the
1169      * shift value is the corresponding lane of input vector.
1170      *
1171      * @param v the input vector
1172      * @param m the mask controlling lane selection
1173      * @return the result of arithmetically right shifting this vector by the
1174      * input vector
1175      */
1176     public LongVector shiftArithmeticRight(Vector<Long> v, VectorMask<Long> m) {
1177         return blend(shiftArithmeticRight(v), m);
1178     }
1179 
1180     /**
1181      * Rotates left this vector by the broadcast of an input scalar.
1182      * <p>
1183      * This is a lane-wise binary operation which applies the operation
1184      * {@link Long#rotateLeft} to each lane and where
1185      * lane elements of this vector apply to the first argument, and lane
1186      * elements of the broadcast vector apply to the second argument (the
1187      * rotation distance).
1188      *
1189      * @param s the input scalar; the number of the bits to rotate left
1190      * @return the result of rotating left this vector by the broadcast of an
1191      * input scalar
1192      */
1193     @ForceInline
1194     public final LongVector rotateLeft(int s) {
1195         return shiftLeft(s).or(shiftRight(-s));
1196     }
1197 
1198     /**
1199      * Rotates left this vector by the broadcast of an input scalar, selecting
1200      * lane elements controlled by a mask.
1201      * <p>
1202      * This is a lane-wise binary operation which applies the operation
1203      * {@link Long#rotateLeft} to each lane and where
1204      * lane elements of this vector apply to the first argument, and lane
1205      * elements of the broadcast vector apply to the second argument (the
1206      * rotation distance).
1207      *
1208      * @param s the input scalar; the number of the bits to rotate left
1209      * @param m the mask controlling lane selection
1210      * @return the result of rotating left this vector by the broadcast of an
1211      * input scalar
1212      */
1213     @ForceInline
1214     public final LongVector rotateLeft(int s, VectorMask<Long> m) {
1215         return shiftLeft(s, m).or(shiftRight(-s, m), m);
1216     }
1217 
1218     /**
1219      * Rotates right this vector by the broadcast of an input scalar.
1220      * <p>
1221      * This is a lane-wise binary operation which applies the operation
1222      * {@link Long#rotateRight} to each lane and where
1223      * lane elements of this vector apply to the first argument, and lane
1224      * elements of the broadcast vector apply to the second argument (the
1225      * rotation distance).
1226      *
1227      * @param s the input scalar; the number of the bits to rotate right
1228      * @return the result of rotating right this vector by the broadcast of an
1229      * input scalar
1230      */
1231     @ForceInline
1232     public final LongVector rotateRight(int s) {
1233         return shiftRight(s).or(shiftLeft(-s));
1234     }
1235 
1236     /**
1237      * Rotates right this vector by the broadcast of an input scalar, selecting
1238      * lane elements controlled by a mask.
1239      * <p>
1240      * This is a lane-wise binary operation which applies the operation
1241      * {@link Long#rotateRight} to each lane and where
1242      * lane elements of this vector apply to the first argument, and lane
1243      * elements of the broadcast vector apply to the second argument (the
1244      * rotation distance).
1245      *
1246      * @param s the input scalar; the number of the bits to rotate right
1247      * @param m the mask controlling lane selection
1248      * @return the result of rotating right this vector by the broadcast of an
1249      * input scalar
1250      */
1251     @ForceInline
1252     public final LongVector rotateRight(int s, VectorMask<Long> m) {
1253         return shiftRight(s, m).or(shiftLeft(-s, m), m);
1254     }
1255 
1256     /**
1257      * {@inheritDoc}
1258      */
1259     @Override
1260     public abstract void intoByteArray(byte[] a, int ix);
1261 
1262     /**
1263      * {@inheritDoc}
1264      */
1265     @Override
1266     public abstract void intoByteArray(byte[] a, int ix, VectorMask<Long> m);
1267 
1268     /**
1269      * {@inheritDoc}
1270      */
1271     @Override
1272     public abstract void intoByteBuffer(ByteBuffer bb, int ix);
1273 
1274     /**
1275      * {@inheritDoc}
1276      */
1277     @Override
1278     public abstract void intoByteBuffer(ByteBuffer bb, int ix, VectorMask<Long> m);
1279 
1280 
1281     // Type specific horizontal reductions
1282     /**
1283      * Adds all lane elements of this vector.
1284      * <p>
1285      * This is an associative cross-lane reduction operation which applies the addition
1286      * operation ({@code +}) to lane elements,
1287      * and the identity value is {@code 0}.
1288      *
1289      * @return the addition of all the lane elements of this vector
1290      */
1291     public abstract long addLanes();
1292 
1293     /**
1294      * Adds all lane elements of this vector, selecting lane elements
1295      * controlled by a mask.
1296      * <p>
1297      * This is an associative cross-lane reduction operation which applies the addition
1298      * operation ({@code +}) to lane elements,
1299      * and the identity value is {@code 0}.
1300      *
1301      * @param m the mask controlling lane selection
1302      * @return the addition of the selected lane elements of this vector
1303      */
1304     public abstract long addLanes(VectorMask<Long> m);
1305 
1306     /**
1307      * Multiplies all lane elements of this vector.
1308      * <p>
1309      * This is an associative cross-lane reduction operation which applies the
1310      * multiplication operation ({@code *}) to lane elements,
1311      * and the identity value is {@code 1}.
1312      *
1313      * @return the multiplication of all the lane elements of this vector
1314      */
1315     public abstract long mulLanes();
1316 
1317     /**
1318      * Multiplies all lane elements of this vector, selecting lane elements
1319      * controlled by a mask.
1320      * <p>
1321      * This is an associative cross-lane reduction operation which applies the
1322      * multiplication operation ({@code *}) to lane elements,
1323      * and the identity value is {@code 1}.
1324      *
1325      * @param m the mask controlling lane selection
1326      * @return the multiplication of all the lane elements of this vector
1327      */
1328     public abstract long mulLanes(VectorMask<Long> m);
1329 
1330     /**
1331      * Returns the minimum lane element of this vector.
1332      * <p>
1333      * This is an associative cross-lane reduction operation which applies the operation
1334      * {@code (a, b) -> Math.min(a, b)} to lane elements,
1335      * and the identity value is
1336      * {@link Long#MAX_VALUE}.
1337      *
1338      * @return the minimum lane element of this vector
1339      */
1340     public abstract long minLanes();
1341 
1342     /**
1343      * Returns the minimum lane element of this vector, selecting lane elements
1344      * controlled by a mask.
1345      * <p>
1346      * This is an associative cross-lane reduction operation which applies the operation
1347      * {@code (a, b) -> Math.min(a, b)} to lane elements,
1348      * and the identity value is
1349      * {@link Long#MAX_VALUE}.
1350      *
1351      * @param m the mask controlling lane selection
1352      * @return the minimum lane element of this vector
1353      */
1354     public abstract long minLanes(VectorMask<Long> m);
1355 
1356     /**
1357      * Returns the maximum lane element of this vector.
1358      * <p>
1359      * This is an associative cross-lane reduction operation which applies the operation
1360      * {@code (a, b) -> Math.max(a, b)} to lane elements,
1361      * and the identity value is
1362      * {@link Long#MIN_VALUE}.
1363      *
1364      * @return the maximum lane element of this vector
1365      */
1366     public abstract long maxLanes();
1367 
1368     /**
1369      * Returns the maximum lane element of this vector, selecting lane elements
1370      * controlled by a mask.
1371      * <p>
1372      * This is an associative cross-lane reduction operation which applies the operation
1373      * {@code (a, b) -> Math.max(a, b)} to lane elements,
1374      * and the identity value is
1375      * {@link Long#MIN_VALUE}.
1376      *
1377      * @param m the mask controlling lane selection
1378      * @return the maximum lane element of this vector
1379      */
1380     public abstract long maxLanes(VectorMask<Long> m);
1381 
1382     /**
1383      * Logically ORs all lane elements of this vector.
1384      * <p>
1385      * This is an associative cross-lane reduction operation which applies the logical OR
1386      * operation ({@code |}) to lane elements,
1387      * and the identity value is {@code 0}.
1388      *
1389      * @return the logical OR all the lane elements of this vector
1390      */
1391     public abstract long orLanes();
1392 
1393     /**
1394      * Logically ORs all lane elements of this vector, selecting lane elements
1395      * controlled by a mask.
1396      * <p>
1397      * This is an associative cross-lane reduction operation which applies the logical OR
1398      * operation ({@code |}) to lane elements,
1399      * and the identity value is {@code 0}.
1400      *
1401      * @param m the mask controlling lane selection
1402      * @return the logical OR all the lane elements of this vector
1403      */
1404     public abstract long orLanes(VectorMask<Long> m);
1405 
1406     /**
1407      * Logically ANDs all lane elements of this vector.
1408      * <p>
1409      * This is an associative cross-lane reduction operation which applies the logical AND
1410      * operation ({@code |}) to lane elements,
1411      * and the identity value is {@code -1}.
1412      *
1413      * @return the logical AND all the lane elements of this vector
1414      */
1415     public abstract long andLanes();
1416 
1417     /**
1418      * Logically ANDs all lane elements of this vector, selecting lane elements
1419      * controlled by a mask.
1420      * <p>
1421      * This is an associative cross-lane reduction operation which applies the logical AND
1422      * operation ({@code |}) to lane elements,
1423      * and the identity value is {@code -1}.
1424      *
1425      * @param m the mask controlling lane selection
1426      * @return the logical AND all the lane elements of this vector
1427      */
1428     public abstract long andLanes(VectorMask<Long> m);
1429 
1430     /**
1431      * Logically XORs all lane elements of this vector.
1432      * <p>
1433      * This is an associative cross-lane reduction operation which applies the logical XOR
1434      * operation ({@code ^}) to lane elements,
1435      * and the identity value is {@code 0}.
1436      *
1437      * @return the logical XOR all the lane elements of this vector
1438      */
1439     public abstract long xorLanes();
1440 
1441     /**
1442      * Logically XORs all lane elements of this vector, selecting lane elements
1443      * controlled by a mask.
1444      * <p>
1445      * This is an associative cross-lane reduction operation which applies the logical XOR
1446      * operation ({@code ^}) to lane elements,
1447      * and the identity value is {@code 0}.
1448      *
1449      * @param m the mask controlling lane selection
1450      * @return the logical XOR all the lane elements of this vector
1451      */
1452     public abstract long xorLanes(VectorMask<Long> m);
1453 
1454     // Type specific accessors
1455 
1456     /**
1457      * Gets the lane element at lane index {@code i}
1458      *
1459      * @param i the lane index
1460      * @return the lane element at lane index {@code i}
1461      * @throws IllegalArgumentException if the index is is out of range
1462      * ({@code < 0 || >= length()})
1463      */
1464     public abstract long lane(int i);
1465 
1466     /**
1467      * Replaces the lane element of this vector at lane index {@code i} with
1468      * value {@code e}.
1469      * <p>
1470      * This is a cross-lane operation and behaves as if it returns the result
1471      * of blending this vector with an input vector that is the result of
1472      * broadcasting {@code e} and a mask that has only one lane set at lane
1473      * index {@code i}.
1474      *
1475      * @param i the lane index of the lane element to be replaced
1476      * @param e the value to be placed
1477      * @return the result of replacing the lane element of this vector at lane
1478      * index {@code i} with value {@code e}.
1479      * @throws IllegalArgumentException if the index is is out of range
1480      * ({@code < 0 || >= length()})
1481      */
1482     public abstract LongVector with(int i, long e);
1483 
1484     // Type specific extractors
1485 
1486     /**
1487      * Returns an array containing the lane elements of this vector.
1488      * <p>
1489      * This method behaves as if it {@link #intoArray(long[], int)} stores}
1490      * this vector into an allocated array and returns the array as follows:
1491      * <pre>{@code
1492      *   long[] a = new long[this.length()];
1493      *   this.intoArray(a, 0);
1494      *   return a;
1495      * }</pre>
1496      *
1497      * @return an array containing the the lane elements of this vector
1498      */
1499     @ForceInline
1500     public final long[] toArray() {
1501         long[] a = new long[species().length()];
1502         intoArray(a, 0);
1503         return a;
1504     }
1505 
1506     /**
1507      * Stores this vector into an array starting at offset.
1508      * <p>
1509      * For each vector lane, where {@code N} is the vector lane index,
1510      * the lane element at index {@code N} is stored into the array at index
1511      * {@code offset + N}.
1512      *
1513      * @param a the array
1514      * @param offset the offset into the array
1515      * @throws IndexOutOfBoundsException if {@code offset < 0}, or
1516      * {@code offset > a.length - this.length()}
1517      */
1518     public abstract void intoArray(long[] a, int offset);
1519 
1520     /**
1521      * Stores this vector into an array starting at offset and using a mask.
1522      * <p>
1523      * For each vector lane, where {@code N} is the vector lane index,
1524      * if the mask lane at index {@code N} is set then the lane element at
1525      * index {@code N} is stored into the array index {@code offset + N}.
1526      *
1527      * @param a the array
1528      * @param offset the offset into the array
1529      * @param m the mask
1530      * @throws IndexOutOfBoundsException if {@code offset < 0}, or
1531      * for any vector lane index {@code N} where the mask at lane {@code N}
1532      * is set {@code offset >= a.length - N}
1533      */
1534     public abstract void intoArray(long[] a, int offset, VectorMask<Long> m);
1535 
1536     /**
1537      * Stores this vector into an array using indexes obtained from an index
1538      * map.
1539      * <p>
1540      * For each vector lane, where {@code N} is the vector lane index, the
1541      * lane element at index {@code N} is stored into the array at index
1542      * {@code a_offset + indexMap[i_offset + N]}.
1543      *
1544      * @param a the array
1545      * @param a_offset the offset into the array, may be negative if relative
1546      * indexes in the index map compensate to produce a value within the
1547      * array bounds
1548      * @param indexMap the index map
1549      * @param i_offset the offset into the index map
1550      * @throws IndexOutOfBoundsException if {@code i_offset < 0}, or
1551      * {@code i_offset > indexMap.length - this.length()},
1552      * or for any vector lane index {@code N} the result of
1553      * {@code a_offset + indexMap[i_offset + N]} is {@code < 0} or {@code >= a.length}
1554      */
1555     public abstract void intoArray(long[] a, int a_offset, int[] indexMap, int i_offset);
1556 
1557     /**
1558      * Stores this vector into an array using indexes obtained from an index
1559      * map and using a mask.
1560      * <p>
1561      * For each vector lane, where {@code N} is the vector lane index,
1562      * if the mask lane at index {@code N} is set then the lane element at
1563      * index {@code N} is stored into the array at index
1564      * {@code a_offset + indexMap[i_offset + N]}.
1565      *
1566      * @param a the array
1567      * @param a_offset the offset into the array, may be negative if relative
1568      * indexes in the index map compensate to produce a value within the
1569      * array bounds
1570      * @param m the mask
1571      * @param indexMap the index map
1572      * @param i_offset the offset into the index map
1573      * @throws IndexOutOfBoundsException if {@code j < 0}, or
1574      * {@code i_offset > indexMap.length - this.length()},
1575      * or for any vector lane index {@code N} where the mask at lane
1576      * {@code N} is set the result of {@code a_offset + indexMap[i_offset + N]} is
1577      * {@code < 0} or {@code >= a.length}
1578      */
1579     public abstract void intoArray(long[] a, int a_offset, VectorMask<Long> m, int[] indexMap, int i_offset);
1580     // Species
1581 
1582     /**
1583      * {@inheritDoc}
1584      */
1585     @Override
1586     public abstract VectorSpecies<Long> species();
1587 
1588     /**
1589      * Class representing {@link LongVector}'s of the same {@link VectorShape VectorShape}.
1590      */
1591     static final class LongSpecies extends AbstractSpecies<Long> {
1592         final Function<long[], LongVector> vectorFactory;
1593 
1594         private LongSpecies(VectorShape shape,
1595                           Class<?> vectorType,
1596                           Class<?> maskType,
1597                           Function<long[], LongVector> vectorFactory,
1598                           Function<boolean[], VectorMask<Long>> maskFactory,
1599                           Function<IntUnaryOperator, VectorShuffle<Long>> shuffleFromArrayFactory,
1600                           fShuffleFromArray<Long> shuffleFromOpFactory) {
1601             super(shape, long.class, Long.SIZE, vectorType, maskType, maskFactory,
1602                   shuffleFromArrayFactory, shuffleFromOpFactory);
1603             this.vectorFactory = vectorFactory;
1604         }
1605 
1606         interface FOp {
1607             long apply(int i);
1608         }
1609 
1610         LongVector op(FOp f) {
1611             long[] res = new long[length()];
1612             for (int i = 0; i < length(); i++) {
1613                 res[i] = f.apply(i);
1614             }
1615             return vectorFactory.apply(res);
1616         }
1617 
1618         LongVector op(VectorMask<Long> o, FOp f) {
1619             long[] res = new long[length()];
1620             boolean[] mbits = ((AbstractMask<Long>)o).getBits();
1621             for (int i = 0; i < length(); i++) {
1622                 if (mbits[i]) {
1623                     res[i] = f.apply(i);
1624                 }
1625             }
1626             return vectorFactory.apply(res);
1627         }
1628     }
1629 
1630     /**
1631      * Finds the preferred species for an element type of {@code long}.
1632      * <p>
1633      * A preferred species is a species chosen by the platform that has a
1634      * shape of maximal bit size.  A preferred species for different element
1635      * types will have the same shape, and therefore vectors, masks, and
1636      * shuffles created from such species will be shape compatible.
1637      *
1638      * @return the preferred species for an element type of {@code long}
1639      */
1640     private static LongSpecies preferredSpecies() {
1641         return (LongSpecies) VectorSpecies.ofPreferred(long.class);
1642     }
1643 
1644     /**
1645      * Finds a species for an element type of {@code long} and shape.
1646      *
1647      * @param s the shape
1648      * @return a species for an element type of {@code long} and shape
1649      * @throws IllegalArgumentException if no such species exists for the shape
1650      */
1651     static LongSpecies species(VectorShape s) {
1652         Objects.requireNonNull(s);
1653         switch (s) {
1654             case S_64_BIT: return (LongSpecies) SPECIES_64;
1655             case S_128_BIT: return (LongSpecies) SPECIES_128;
1656             case S_256_BIT: return (LongSpecies) SPECIES_256;
1657             case S_512_BIT: return (LongSpecies) SPECIES_512;
1658             case S_Max_BIT: return (LongSpecies) SPECIES_MAX;
1659             default: throw new IllegalArgumentException("Bad shape: " + s);
1660         }
1661     }
1662 
1663     /** Species representing {@link LongVector}s of {@link VectorShape#S_64_BIT VectorShape.S_64_BIT}. */
1664     public static final VectorSpecies<Long> SPECIES_64 = new LongSpecies(VectorShape.S_64_BIT, Long64Vector.class, Long64Vector.Long64Mask.class,
1665                                                                      Long64Vector::new, Long64Vector.Long64Mask::new,
1666                                                                      Long64Vector.Long64Shuffle::new, Long64Vector.Long64Shuffle::new);
1667 
1668     /** Species representing {@link LongVector}s of {@link VectorShape#S_128_BIT VectorShape.S_128_BIT}. */
1669     public static final VectorSpecies<Long> SPECIES_128 = new LongSpecies(VectorShape.S_128_BIT, Long128Vector.class, Long128Vector.Long128Mask.class,
1670                                                                       Long128Vector::new, Long128Vector.Long128Mask::new,
1671                                                                       Long128Vector.Long128Shuffle::new, Long128Vector.Long128Shuffle::new);
1672 
1673     /** Species representing {@link LongVector}s of {@link VectorShape#S_256_BIT VectorShape.S_256_BIT}. */
1674     public static final VectorSpecies<Long> SPECIES_256 = new LongSpecies(VectorShape.S_256_BIT, Long256Vector.class, Long256Vector.Long256Mask.class,
1675                                                                       Long256Vector::new, Long256Vector.Long256Mask::new,
1676                                                                       Long256Vector.Long256Shuffle::new, Long256Vector.Long256Shuffle::new);
1677 
1678     /** Species representing {@link LongVector}s of {@link VectorShape#S_512_BIT VectorShape.S_512_BIT}. */
1679     public static final VectorSpecies<Long> SPECIES_512 = new LongSpecies(VectorShape.S_512_BIT, Long512Vector.class, Long512Vector.Long512Mask.class,
1680                                                                       Long512Vector::new, Long512Vector.Long512Mask::new,
1681                                                                       Long512Vector.Long512Shuffle::new, Long512Vector.Long512Shuffle::new);
1682 
1683     /** Species representing {@link LongVector}s of {@link VectorShape#S_Max_BIT VectorShape.S_Max_BIT}. */
1684     public static final VectorSpecies<Long> SPECIES_MAX = new LongSpecies(VectorShape.S_Max_BIT, LongMaxVector.class, LongMaxVector.LongMaxMask.class,
1685                                                                       LongMaxVector::new, LongMaxVector.LongMaxMask::new,
1686                                                                       LongMaxVector.LongMaxShuffle::new, LongMaxVector.LongMaxShuffle::new);
1687 
1688     /**
1689      * Preferred species for {@link LongVector}s.
1690      * A preferred species is a species of maximal bit size for the platform.
1691      */
1692     public static final VectorSpecies<Long> SPECIES_PREFERRED = (VectorSpecies<Long>) preferredSpecies();
1693 }
--- EOF ---