Categories:
Audio (13)
Biotech (29)
Bytecode (36)
Database (77)
Framework (7)
Game (7)
General (507)
Graphics (53)
I/O (35)
IDE (2)
JAR Tools (101)
JavaBeans (21)
JDBC (121)
JDK (426)
JSP (20)
Logging (108)
Mail (58)
Messaging (8)
Network (84)
PDF (97)
Report (7)
Scripting (84)
Security (32)
Server (121)
Servlet (26)
SOAP (24)
Testing (54)
Web (15)
XML (309)
Collections:
Other Resources:
JDK 17 jdk.incubator.vector.jmod - JDK Incubator Vector
JDK 17 jdk.incubator.vector.jmod is the JMOD file for JDK 17 HTTP Server module.
JDK 17 Incubator Vector module compiled class files are stored in \fyicenter\jdk-17.0.5\jmods\jdk.incubator.vector.jmod.
JDK 17 Incubator Vector module compiled class files are also linked and stored in the \fyicenter\jdk-17.0.5\lib\modules JImage file.
JDK 17 Incubator Vector module source code files are stored in \fyicenter\jdk-17.0.5\lib\src.zip\jdk.incubator.vector.
You can click and view the content of each source code file in the list below.
✍: FYIcenter
⏎ jdk/incubator/vector/FloatVector.java
/* * Copyright (c) 2017, 2021, Oracle and/or its affiliates. All rights reserved. * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. * * * * * * * * * * * * * * * * * * * * */ package jdk.incubator.vector; import java.nio.ByteBuffer; import java.nio.ByteOrder; import java.nio.ReadOnlyBufferException; import java.util.Arrays; import java.util.Objects; import java.util.function.BinaryOperator; import java.util.function.Function; import java.util.function.UnaryOperator; import jdk.internal.misc.ScopedMemoryAccess; import jdk.internal.misc.Unsafe; import jdk.internal.vm.annotation.ForceInline; import jdk.internal.vm.vector.VectorSupport; import static jdk.internal.vm.vector.VectorSupport.*; import static jdk.incubator.vector.VectorIntrinsics.*; import static jdk.incubator.vector.VectorOperators.*; // -- This file was mechanically generated: Do not edit! -- // /** * A specialized {@link Vector} representing an ordered immutable sequence of * {@code float} values. */ @SuppressWarnings("cast") // warning: redundant cast public abstract class FloatVector extends AbstractVector<Float> { FloatVector(float[] vec) { super(vec); } static final int FORBID_OPCODE_KIND = VO_NOFP; @ForceInline static int opCode(Operator op) { return VectorOperators.opCode(op, VO_OPCODE_VALID, FORBID_OPCODE_KIND); } @ForceInline static int opCode(Operator op, int requireKind) { requireKind |= VO_OPCODE_VALID; return VectorOperators.opCode(op, requireKind, FORBID_OPCODE_KIND); } @ForceInline static boolean opKind(Operator op, int bit) { return VectorOperators.opKind(op, bit); } // Virtualized factories and operators, // coded with portable definitions. // These are all @ForceInline in case // they need to be used performantly. // The various shape-specific subclasses // also specialize them by wrapping // them in a call like this: // return (Byte128Vector) // super.bOp((Byte128Vector) o); // The purpose of that is to forcibly inline // the generic definition from this file // into a sharply type- and size-specific // wrapper in the subclass file, so that // the JIT can specialize the code. // The code is only inlined and expanded // if it gets hot. Think of it as a cheap // and lazy version of C++ templates. // Virtualized getter /*package-private*/ abstract float[] vec(); // Virtualized constructors /** * Build a vector directly using my own constructor. * It is an error if the array is aliased elsewhere. */ /*package-private*/ abstract FloatVector vectorFactory(float[] vec); /** * Build a mask directly using my species. * It is an error if the array is aliased elsewhere. */ /*package-private*/ @ForceInline final AbstractMask<Float> maskFactory(boolean[] bits) { return vspecies().maskFactory(bits); } // Constant loader (takes dummy as vector arg) interface FVOp { float apply(int i); } /*package-private*/ @ForceInline final FloatVector vOp(FVOp f) { float[] res = new float[length()]; for (int i = 0; i < res.length; i++) { res[i] = f.apply(i); } return vectorFactory(res); } @ForceInline final FloatVector vOp(VectorMask<Float> m, FVOp f) { float[] res = new float[length()]; boolean[] mbits = ((AbstractMask<Float>)m).getBits(); for (int i = 0; i < res.length; i++) { if (mbits[i]) { res[i] = f.apply(i); } } return vectorFactory(res); } // Unary operator /*package-private*/ interface FUnOp { float apply(int i, float a); } /*package-private*/ abstract FloatVector uOp(FUnOp f); @ForceInline final FloatVector uOpTemplate(FUnOp f) { float[] vec = vec(); float[] res = new float[length()]; for (int i = 0; i < res.length; i++) { res[i] = f.apply(i, vec[i]); } return vectorFactory(res); } /*package-private*/ abstract FloatVector uOp(VectorMask<Float> m, FUnOp f); @ForceInline final FloatVector uOpTemplate(VectorMask<Float> m, FUnOp f) { float[] vec = vec(); float[] res = new float[length()]; boolean[] mbits = ((AbstractMask<Float>)m).getBits(); for (int i = 0; i < res.length; i++) { res[i] = mbits[i] ? f.apply(i, vec[i]) : vec[i]; } return vectorFactory(res); } // Binary operator /*package-private*/ interface FBinOp { float apply(int i, float a, float b); } /*package-private*/ abstract FloatVector bOp(Vector<Float> o, FBinOp f); @ForceInline final FloatVector bOpTemplate(Vector<Float> o, FBinOp f) { float[] res = new float[length()]; float[] vec1 = this.vec(); float[] vec2 = ((FloatVector)o).vec(); for (int i = 0; i < res.length; i++) { res[i] = f.apply(i, vec1[i], vec2[i]); } return vectorFactory(res); } /*package-private*/ abstract FloatVector bOp(Vector<Float> o, VectorMask<Float> m, FBinOp f); @ForceInline final FloatVector bOpTemplate(Vector<Float> o, VectorMask<Float> m, FBinOp f) { float[] res = new float[length()]; float[] vec1 = this.vec(); float[] vec2 = ((FloatVector)o).vec(); boolean[] mbits = ((AbstractMask<Float>)m).getBits(); for (int i = 0; i < res.length; i++) { res[i] = mbits[i] ? f.apply(i, vec1[i], vec2[i]) : vec1[i]; } return vectorFactory(res); } // Ternary operator /*package-private*/ interface FTriOp { float apply(int i, float a, float b, float c); } /*package-private*/ abstract FloatVector tOp(Vector<Float> o1, Vector<Float> o2, FTriOp f); @ForceInline final FloatVector tOpTemplate(Vector<Float> o1, Vector<Float> o2, FTriOp f) { float[] res = new float[length()]; float[] vec1 = this.vec(); float[] vec2 = ((FloatVector)o1).vec(); float[] vec3 = ((FloatVector)o2).vec(); for (int i = 0; i < res.length; i++) { res[i] = f.apply(i, vec1[i], vec2[i], vec3[i]); } return vectorFactory(res); } /*package-private*/ abstract FloatVector tOp(Vector<Float> o1, Vector<Float> o2, VectorMask<Float> m, FTriOp f); @ForceInline final FloatVector tOpTemplate(Vector<Float> o1, Vector<Float> o2, VectorMask<Float> m, FTriOp f) { float[] res = new float[length()]; float[] vec1 = this.vec(); float[] vec2 = ((FloatVector)o1).vec(); float[] vec3 = ((FloatVector)o2).vec(); boolean[] mbits = ((AbstractMask<Float>)m).getBits(); for (int i = 0; i < res.length; i++) { res[i] = mbits[i] ? f.apply(i, vec1[i], vec2[i], vec3[i]) : vec1[i]; } return vectorFactory(res); } // Reduction operator /*package-private*/ abstract float rOp(float v, FBinOp f); @ForceInline final float rOpTemplate(float v, FBinOp f) { float[] vec = vec(); for (int i = 0; i < vec.length; i++) { v = f.apply(i, v, vec[i]); } return v; } // Memory reference /*package-private*/ interface FLdOp<M> { float apply(M memory, int offset, int i); } /*package-private*/ @ForceInline final <M> FloatVector ldOp(M memory, int offset, FLdOp<M> f) { //dummy; no vec = vec(); float[] res = new float[length()]; for (int i = 0; i < res.length; i++) { res[i] = f.apply(memory, offset, i); } return vectorFactory(res); } /*package-private*/ @ForceInline final <M> FloatVector ldOp(M memory, int offset, VectorMask<Float> m, FLdOp<M> f) { //float[] vec = vec(); float[] res = new float[length()]; boolean[] mbits = ((AbstractMask<Float>)m).getBits(); for (int i = 0; i < res.length; i++) { if (mbits[i]) { res[i] = f.apply(memory, offset, i); } } return vectorFactory(res); } interface FStOp<M> { void apply(M memory, int offset, int i, float a); } /*package-private*/ @ForceInline final <M> void stOp(M memory, int offset, FStOp<M> f) { float[] vec = vec(); for (int i = 0; i < vec.length; i++) { f.apply(memory, offset, i, vec[i]); } } /*package-private*/ @ForceInline final <M> void stOp(M memory, int offset, VectorMask<Float> m, FStOp<M> f) { float[] vec = vec(); boolean[] mbits = ((AbstractMask<Float>)m).getBits(); for (int i = 0; i < vec.length; i++) { if (mbits[i]) { f.apply(memory, offset, i, vec[i]); } } } // Binary test /*package-private*/ interface FBinTest { boolean apply(int cond, int i, float a, float b); } /*package-private*/ @ForceInline final AbstractMask<Float> bTest(int cond, Vector<Float> o, FBinTest f) { float[] vec1 = vec(); float[] vec2 = ((FloatVector)o).vec(); boolean[] bits = new boolean[length()]; for (int i = 0; i < length(); i++){ bits[i] = f.apply(cond, i, vec1[i], vec2[i]); } return maskFactory(bits); } /*package-private*/ @Override abstract FloatSpecies vspecies(); /*package-private*/ @ForceInline static long toBits(float e) { return Float.floatToRawIntBits(e); } /*package-private*/ @ForceInline static float fromBits(long bits) { return Float.intBitsToFloat((int)bits); } // Static factories (other than memory operations) // Note: A surprising behavior in javadoc // sometimes makes a lone /** {@inheritDoc} */ // comment drop the method altogether, // apparently if the method mentions an // parameter or return type of Vector<Float> // instead of Vector<E> as originally specified. // Adding an empty HTML fragment appears to // nudge javadoc into providing the desired // inherited documentation. We use the HTML // comment <!--workaround--> for this. /** * Returns a vector of the given species * where all lane elements are set to * zero, the default primitive value. * * @param species species of the desired zero vector * @return a zero vector */ @ForceInline public static FloatVector zero(VectorSpecies<Float> species) { FloatSpecies vsp = (FloatSpecies) species; return VectorSupport.broadcastCoerced(vsp.vectorType(), float.class, species.length(), toBits(0.0f), vsp, ((bits_, s_) -> s_.rvOp(i -> bits_))); } /** * Returns a vector of the same species as this one * where all lane elements are set to * the primitive value {@code e}. * * The contents of the current vector are discarded; * only the species is relevant to this operation. * * <p> This method returns the value of this expression: * {@code FloatVector.broadcast(this.species(), e)}. * * @apiNote * Unlike the similar method named {@code broadcast()} * in the supertype {@code Vector}, this method does not * need to validate its argument, and cannot throw * {@code IllegalArgumentException}. This method is * therefore preferable to the supertype method. * * @param e the value to broadcast * @return a vector where all lane elements are set to * the primitive value {@code e} * @see #broadcast(VectorSpecies,long) * @see Vector#broadcast(long) * @see VectorSpecies#broadcast(long) */ public abstract FloatVector broadcast(float e); /** * Returns a vector of the given species * where all lane elements are set to * the primitive value {@code e}. * * @param species species of the desired vector * @param e the value to broadcast * @return a vector where all lane elements are set to * the primitive value {@code e} * @see #broadcast(long) * @see Vector#broadcast(long) * @see VectorSpecies#broadcast(long) */ @ForceInline public static FloatVector broadcast(VectorSpecies<Float> species, float e) { FloatSpecies vsp = (FloatSpecies) species; return vsp.broadcast(e); } /*package-private*/ @ForceInline final FloatVector broadcastTemplate(float e) { FloatSpecies vsp = vspecies(); return vsp.broadcast(e); } /** * {@inheritDoc} <!--workaround--> * @apiNote * When working with vector subtypes like {@code FloatVector}, * {@linkplain #broadcast(float) the more strongly typed method} * is typically selected. It can be explicitly selected * using a cast: {@code v.broadcast((float)e)}. * The two expressions will produce numerically identical results. */ @Override public abstract FloatVector broadcast(long e); /** * Returns a vector of the given species * where all lane elements are set to * the primitive value {@code e}. * * The {@code long} value must be accurately representable * by the {@code ETYPE} of the vector species, so that * {@code e==(long)(ETYPE)e}. * * @param species species of the desired vector * @param e the value to broadcast * @return a vector where all lane elements are set to * the primitive value {@code e} * @throws IllegalArgumentException * if the given {@code long} value cannot * be represented by the vector's {@code ETYPE} * @see #broadcast(VectorSpecies,float) * @see VectorSpecies#checkValue(long) */ @ForceInline public static FloatVector broadcast(VectorSpecies<Float> species, long e) { FloatSpecies vsp = (FloatSpecies) species; return vsp.broadcast(e); } /*package-private*/ @ForceInline final FloatVector broadcastTemplate(long e) { return vspecies().broadcast(e); } // Unary lanewise support /** * {@inheritDoc} <!--workaround--> */ public abstract FloatVector lanewise(VectorOperators.Unary op); @ForceInline final FloatVector lanewiseTemplate(VectorOperators.Unary op) { if (opKind(op, VO_SPECIAL)) { if (op == ZOMO) { return blend(broadcast(-1), compare(NE, 0)); } } int opc = opCode(op); return VectorSupport.unaryOp( opc, getClass(), float.class, length(), this, UN_IMPL.find(op, opc, (opc_) -> { switch (opc_) { case VECTOR_OP_NEG: return v0 -> v0.uOp((i, a) -> (float) -a); case VECTOR_OP_ABS: return v0 -> v0.uOp((i, a) -> (float) Math.abs(a)); case VECTOR_OP_SIN: return v0 -> v0.uOp((i, a) -> (float) Math.sin(a)); case VECTOR_OP_COS: return v0 -> v0.uOp((i, a) -> (float) Math.cos(a)); case VECTOR_OP_TAN: return v0 -> v0.uOp((i, a) -> (float) Math.tan(a)); case VECTOR_OP_ASIN: return v0 -> v0.uOp((i, a) -> (float) Math.asin(a)); case VECTOR_OP_ACOS: return v0 -> v0.uOp((i, a) -> (float) Math.acos(a)); case VECTOR_OP_ATAN: return v0 -> v0.uOp((i, a) -> (float) Math.atan(a)); case VECTOR_OP_EXP: return v0 -> v0.uOp((i, a) -> (float) Math.exp(a)); case VECTOR_OP_LOG: return v0 -> v0.uOp((i, a) -> (float) Math.log(a)); case VECTOR_OP_LOG10: return v0 -> v0.uOp((i, a) -> (float) Math.log10(a)); case VECTOR_OP_SQRT: return v0 -> v0.uOp((i, a) -> (float) Math.sqrt(a)); case VECTOR_OP_CBRT: return v0 -> v0.uOp((i, a) -> (float) Math.cbrt(a)); case VECTOR_OP_SINH: return v0 -> v0.uOp((i, a) -> (float) Math.sinh(a)); case VECTOR_OP_COSH: return v0 -> v0.uOp((i, a) -> (float) Math.cosh(a)); case VECTOR_OP_TANH: return v0 -> v0.uOp((i, a) -> (float) Math.tanh(a)); case VECTOR_OP_EXPM1: return v0 -> v0.uOp((i, a) -> (float) Math.expm1(a)); case VECTOR_OP_LOG1P: return v0 -> v0.uOp((i, a) -> (float) Math.log1p(a)); default: return null; }})); } private static final ImplCache<Unary,UnaryOperator<FloatVector>> UN_IMPL = new ImplCache<>(Unary.class, FloatVector.class); /** * {@inheritDoc} <!--workaround--> */ @ForceInline public final FloatVector lanewise(VectorOperators.Unary op, VectorMask<Float> m) { return blend(lanewise(op), m); } // Binary lanewise support /** * {@inheritDoc} <!--workaround--> * @see #lanewise(VectorOperators.Binary,float) * @see #lanewise(VectorOperators.Binary,float,VectorMask) */ @Override public abstract FloatVector lanewise(VectorOperators.Binary op, Vector<Float> v); @ForceInline final FloatVector lanewiseTemplate(VectorOperators.Binary op, Vector<Float> v) { FloatVector that = (FloatVector) v; that.check(this); if (opKind(op, VO_SPECIAL )) { if (op == FIRST_NONZERO) { // FIXME: Support this in the JIT. VectorMask<Integer> thisNZ = this.viewAsIntegralLanes().compare(NE, (int) 0); that = that.blend((float) 0, thisNZ.cast(vspecies())); op = OR_UNCHECKED; // FIXME: Support OR_UNCHECKED on float/double also! return this.viewAsIntegralLanes() .lanewise(op, that.viewAsIntegralLanes()) .viewAsFloatingLanes(); } } int opc = opCode(op); return VectorSupport.binaryOp( opc, getClass(), float.class, length(), this, that, BIN_IMPL.find(op, opc, (opc_) -> { switch (opc_) { case VECTOR_OP_ADD: return (v0, v1) -> v0.bOp(v1, (i, a, b) -> (float)(a + b)); case VECTOR_OP_SUB: return (v0, v1) -> v0.bOp(v1, (i, a, b) -> (float)(a - b)); case VECTOR_OP_MUL: return (v0, v1) -> v0.bOp(v1, (i, a, b) -> (float)(a * b)); case VECTOR_OP_DIV: return (v0, v1) -> v0.bOp(v1, (i, a, b) -> (float)(a / b)); case VECTOR_OP_MAX: return (v0, v1) -> v0.bOp(v1, (i, a, b) -> (float)Math.max(a, b)); case VECTOR_OP_MIN: return (v0, v1) -> v0.bOp(v1, (i, a, b) -> (float)Math.min(a, b)); case VECTOR_OP_ATAN2: return (v0, v1) -> v0.bOp(v1, (i, a, b) -> (float) Math.atan2(a, b)); case VECTOR_OP_POW: return (v0, v1) -> v0.bOp(v1, (i, a, b) -> (float) Math.pow(a, b)); case VECTOR_OP_HYPOT: return (v0, v1) -> v0.bOp(v1, (i, a, b) -> (float) Math.hypot(a, b)); default: return null; }})); } private static final ImplCache<Binary,BinaryOperator<FloatVector>> BIN_IMPL = new ImplCache<>(Binary.class, FloatVector.class); /** * {@inheritDoc} <!--workaround--> * @see #lanewise(VectorOperators.Binary,float,VectorMask) */ @ForceInline public final FloatVector lanewise(VectorOperators.Binary op, Vector<Float> v, VectorMask<Float> m) { return blend(lanewise(op, v), m); } // FIXME: Maybe all of the public final methods in this file (the // simple ones that just call lanewise) should be pushed down to // the X-VectorBits template. They can't optimize properly at // this level, and must rely on inlining. Does it work? // (If it works, of course keep the code here.) /** * Combines the lane values of this vector * with the value of a broadcast scalar. * * This is a lane-wise binary operation which applies * the selected operation to each lane. * The return value will be equal to this expression: * {@code this.lanewise(op, this.broadcast(e))}. * * @param op the operation used to process lane values * @param e the input scalar * @return the result of applying the operation lane-wise * to the two input vectors * @throws UnsupportedOperationException if this vector does * not support the requested operation * @see #lanewise(VectorOperators.Binary,Vector) * @see #lanewise(VectorOperators.Binary,float,VectorMask) */ @ForceInline public final FloatVector lanewise(VectorOperators.Binary op, float e) { return lanewise(op, broadcast(e)); } /** * Combines the lane values of this vector * with the value of a broadcast scalar, * with selection of lane elements controlled by a mask. * * This is a masked lane-wise binary operation which applies * the selected operation to each lane. * The return value will be equal to this expression: * {@code this.lanewise(op, this.broadcast(e), m)}. * * @param op the operation used to process lane values * @param e the input scalar * @param m the mask controlling lane selection * @return the result of applying the operation lane-wise * to the input vector and the scalar * @throws UnsupportedOperationException if this vector does * not support the requested operation * @see #lanewise(VectorOperators.Binary,Vector,VectorMask) * @see #lanewise(VectorOperators.Binary,float) */ @ForceInline public final FloatVector lanewise(VectorOperators.Binary op, float e, VectorMask<Float> m) { return blend(lanewise(op, e), m); } /** * {@inheritDoc} <!--workaround--> * @apiNote * When working with vector subtypes like {@code FloatVector}, * {@linkplain #lanewise(VectorOperators.Binary,float) * the more strongly typed method} * is typically selected. It can be explicitly selected * using a cast: {@code v.lanewise(op,(float)e)}. * The two expressions will produce numerically identical results. */ @ForceInline public final FloatVector lanewise(VectorOperators.Binary op, long e) { float e1 = (float) e; if ((long)e1 != e ) { vspecies().checkValue(e); // for exception } return lanewise(op, e1); } /** * {@inheritDoc} <!--workaround--> * @apiNote * When working with vector subtypes like {@code FloatVector}, * {@linkplain #lanewise(VectorOperators.Binary,float,VectorMask) * the more strongly typed method} * is typically selected. It can be explicitly selected * using a cast: {@code v.lanewise(op,(float)e,m)}. * The two expressions will produce numerically identical results. */ @ForceInline public final FloatVector lanewise(VectorOperators.Binary op, long e, VectorMask<Float> m) { return blend(lanewise(op, e), m); } // Ternary lanewise support // Ternary operators come in eight variations: // lanewise(op, [broadcast(e1)|v1], [broadcast(e2)|v2]) // lanewise(op, [broadcast(e1)|v1], [broadcast(e2)|v2], mask) // It is annoying to support all of these variations of masking // and broadcast, but it would be more surprising not to continue // the obvious pattern started by unary and binary. /** * {@inheritDoc} <!--workaround--> * @see #lanewise(VectorOperators.Ternary,float,float,VectorMask) * @see #lanewise(VectorOperators.Ternary,Vector,float,VectorMask) * @see #lanewise(VectorOperators.Ternary,float,Vector,VectorMask) * @see #lanewise(VectorOperators.Ternary,float,float) * @see #lanewise(VectorOperators.Ternary,Vector,float) * @see #lanewise(VectorOperators.Ternary,float,Vector) */ @Override public abstract FloatVector lanewise(VectorOperators.Ternary op, Vector<Float> v1, Vector<Float> v2); @ForceInline final FloatVector lanewiseTemplate(VectorOperators.Ternary op, Vector<Float> v1, Vector<Float> v2) { FloatVector that = (FloatVector) v1; FloatVector tother = (FloatVector) v2; // It's a word: https://www.dictionary.com/browse/tother // See also Chapter 11 of Dickens, Our Mutual Friend: // "Totherest Governor," replied Mr Riderhood... that.check(this); tother.check(this); int opc = opCode(op); return VectorSupport.ternaryOp( opc, getClass(), float.class, length(), this, that, tother, TERN_IMPL.find(op, opc, (opc_) -> { switch (opc_) { case VECTOR_OP_FMA: return (v0, v1_, v2_) -> v0.tOp(v1_, v2_, (i, a, b, c) -> Math.fma(a, b, c)); default: return null; }})); } private static final ImplCache<Ternary,TernaryOperation<FloatVector>> TERN_IMPL = new ImplCache<>(Ternary.class, FloatVector.class); /** * {@inheritDoc} <!--workaround--> * @see #lanewise(VectorOperators.Ternary,float,float,VectorMask) * @see #lanewise(VectorOperators.Ternary,Vector,float,VectorMask) * @see #lanewise(VectorOperators.Ternary,float,Vector,VectorMask) */ @ForceInline public final FloatVector lanewise(VectorOperators.Ternary op, Vector<Float> v1, Vector<Float> v2, VectorMask<Float> m) { return blend(lanewise(op, v1, v2), m); } /** * Combines the lane values of this vector * with the values of two broadcast scalars. * * This is a lane-wise ternary operation which applies * the selected operation to each lane. * The return value will be equal to this expression: * {@code this.lanewise(op, this.broadcast(e1), this.broadcast(e2))}. * * @param op the operation used to combine lane values * @param e1 the first input scalar * @param e2 the second input scalar * @return the result of applying the operation lane-wise * to the input vector and the scalars * @throws UnsupportedOperationException if this vector does * not support the requested operation * @see #lanewise(VectorOperators.Ternary,Vector,Vector) * @see #lanewise(VectorOperators.Ternary,float,float,VectorMask) */ @ForceInline public final FloatVector lanewise(VectorOperators.Ternary op, //(op,e1,e2) float e1, float e2) { return lanewise(op, broadcast(e1), broadcast(e2)); } /** * Combines the lane values of this vector * with the values of two broadcast scalars, * with selection of lane elements controlled by a mask. * * This is a masked lane-wise ternary operation which applies * the selected operation to each lane. * The return value will be equal to this expression: * {@code this.lanewise(op, this.broadcast(e1), this.broadcast(e2), m)}. * * @param op the operation used to combine lane values * @param e1 the first input scalar * @param e2 the second input scalar * @param m the mask controlling lane selection * @return the result of applying the operation lane-wise * to the input vector and the scalars * @throws UnsupportedOperationException if this vector does * not support the requested operation * @see #lanewise(VectorOperators.Ternary,Vector,Vector,VectorMask) * @see #lanewise(VectorOperators.Ternary,float,float) */ @ForceInline public final FloatVector lanewise(VectorOperators.Ternary op, //(op,e1,e2,m) float e1, float e2, VectorMask<Float> m) { return blend(lanewise(op, e1, e2), m); } /** * Combines the lane values of this vector * with the values of another vector and a broadcast scalar. * * This is a lane-wise ternary operation which applies * the selected operation to each lane. * The return value will be equal to this expression: * {@code this.lanewise(op, v1, this.broadcast(e2))}. * * @param op the operation used to combine lane values * @param v1 the other input vector * @param e2 the input scalar * @return the result of applying the operation lane-wise * to the input vectors and the scalar * @throws UnsupportedOperationException if this vector does * not support the requested operation * @see #lanewise(VectorOperators.Ternary,float,float) * @see #lanewise(VectorOperators.Ternary,Vector,float,VectorMask) */ @ForceInline public final FloatVector lanewise(VectorOperators.Ternary op, //(op,v1,e2) Vector<Float> v1, float e2) { return lanewise(op, v1, broadcast(e2)); } /** * Combines the lane values of this vector * with the values of another vector and a broadcast scalar, * with selection of lane elements controlled by a mask. * * This is a masked lane-wise ternary operation which applies * the selected operation to each lane. * The return value will be equal to this expression: * {@code this.lanewise(op, v1, this.broadcast(e2), m)}. * * @param op the operation used to combine lane values * @param v1 the other input vector * @param e2 the input scalar * @param m the mask controlling lane selection * @return the result of applying the operation lane-wise * to the input vectors and the scalar * @throws UnsupportedOperationException if this vector does * not support the requested operation * @see #lanewise(VectorOperators.Ternary,Vector,Vector) * @see #lanewise(VectorOperators.Ternary,float,float,VectorMask) * @see #lanewise(VectorOperators.Ternary,Vector,float) */ @ForceInline public final FloatVector lanewise(VectorOperators.Ternary op, //(op,v1,e2,m) Vector<Float> v1, float e2, VectorMask<Float> m) { return blend(lanewise(op, v1, e2), m); } /** * Combines the lane values of this vector * with the values of another vector and a broadcast scalar. * * This is a lane-wise ternary operation which applies * the selected operation to each lane. * The return value will be equal to this expression: * {@code this.lanewise(op, this.broadcast(e1), v2)}. * * @param op the operation used to combine lane values * @param e1 the input scalar * @param v2 the other input vector * @return the result of applying the operation lane-wise * to the input vectors and the scalar * @throws UnsupportedOperationException if this vector does * not support the requested operation * @see #lanewise(VectorOperators.Ternary,Vector,Vector) * @see #lanewise(VectorOperators.Ternary,float,Vector,VectorMask) */ @ForceInline public final FloatVector lanewise(VectorOperators.Ternary op, //(op,e1,v2) float e1, Vector<Float> v2) { return lanewise(op, broadcast(e1), v2); } /** * Combines the lane values of this vector * with the values of another vector and a broadcast scalar, * with selection of lane elements controlled by a mask. * * This is a masked lane-wise ternary operation which applies * the selected operation to each lane. * The return value will be equal to this expression: * {@code this.lanewise(op, this.broadcast(e1), v2, m)}. * * @param op the operation used to combine lane values * @param e1 the input scalar * @param v2 the other input vector * @param m the mask controlling lane selection * @return the result of applying the operation lane-wise * to the input vectors and the scalar * @throws UnsupportedOperationException if this vector does * not support the requested operation * @see #lanewise(VectorOperators.Ternary,Vector,Vector,VectorMask) * @see #lanewise(VectorOperators.Ternary,float,Vector) */ @ForceInline public final FloatVector lanewise(VectorOperators.Ternary op, //(op,e1,v2,m) float e1, Vector<Float> v2, VectorMask<Float> m) { return blend(lanewise(op, e1, v2), m); } // (Thus endeth the Great and Mighty Ternary Ogdoad.) // https://en.wikipedia.org/wiki/Ogdoad /// FULL-SERVICE BINARY METHODS: ADD, SUB, MUL, DIV // // These include masked and non-masked versions. // This subclass adds broadcast (masked or not). /** * {@inheritDoc} <!--workaround--> * @see #add(float) */ @Override @ForceInline public final FloatVector add(Vector<Float> v) { return lanewise(ADD, v); } /** * Adds this vector to the broadcast of an input scalar. * * This is a lane-wise binary operation which applies * the primitive addition operation ({@code +}) to each lane. * * This method is also equivalent to the expression * {@link #lanewise(VectorOperators.Binary,float) * lanewise}{@code (}{@link VectorOperators#ADD * ADD}{@code , e)}. * * @param e the input scalar * @return the result of adding each lane of this vector to the scalar * @see #add(Vector) * @see #broadcast(float) * @see #add(float,VectorMask) * @see VectorOperators#ADD * @see #lanewise(VectorOperators.Binary,Vector) * @see #lanewise(VectorOperators.Binary,float) */ @ForceInline public final FloatVector add(float e) { return lanewise(ADD, e); } /** * {@inheritDoc} <!--workaround--> * @see #add(float,VectorMask) */ @Override @ForceInline public final FloatVector add(Vector<Float> v, VectorMask<Float> m) { return lanewise(ADD, v, m); } /** * Adds this vector to the broadcast of an input scalar, * selecting lane elements controlled by a mask. * * This is a masked lane-wise binary operation which applies * the primitive addition operation ({@code +}) to each lane. * * This method is also equivalent to the expression * {@link #lanewise(VectorOperators.Binary,float,VectorMask) * lanewise}{@code (}{@link VectorOperators#ADD * ADD}{@code , s, m)}. * * @param e the input scalar * @param m the mask controlling lane selection * @return the result of adding each lane of this vector to the scalar * @see #add(Vector,VectorMask) * @see #broadcast(float) * @see #add(float) * @see VectorOperators#ADD * @see #lanewise(VectorOperators.Binary,Vector) * @see #lanewise(VectorOperators.Binary,float) */ @ForceInline public final FloatVector add(float e, VectorMask<Float> m) { return lanewise(ADD, e, m); } /** * {@inheritDoc} <!--workaround--> * @see #sub(float) */ @Override @ForceInline public final FloatVector sub(Vector<Float> v) { return lanewise(SUB, v); } /** * Subtracts an input scalar from this vector. * * This is a masked lane-wise binary operation which applies * the primitive subtraction operation ({@code -}) to each lane. * * This method is also equivalent to the expression * {@link #lanewise(VectorOperators.Binary,float) * lanewise}{@code (}{@link VectorOperators#SUB * SUB}{@code , e)}. * * @param e the input scalar * @return the result of subtracting the scalar from each lane of this vector * @see #sub(Vector) * @see #broadcast(float) * @see #sub(float,VectorMask) * @see VectorOperators#SUB * @see #lanewise(VectorOperators.Binary,Vector) * @see #lanewise(VectorOperators.Binary,float) */ @ForceInline public final FloatVector sub(float e) { return lanewise(SUB, e); } /** * {@inheritDoc} <!--workaround--> * @see #sub(float,VectorMask) */ @Override @ForceInline public final FloatVector sub(Vector<Float> v, VectorMask<Float> m) { return lanewise(SUB, v, m); } /** * Subtracts an input scalar from this vector * under the control of a mask. * * This is a masked lane-wise binary operation which applies * the primitive subtraction operation ({@code -}) to each lane. * * This method is also equivalent to the expression * {@link #lanewise(VectorOperators.Binary,float,VectorMask) * lanewise}{@code (}{@link VectorOperators#SUB * SUB}{@code , s, m)}. * * @param e the input scalar * @param m the mask controlling lane selection * @return the result of subtracting the scalar from each lane of this vector * @see #sub(Vector,VectorMask) * @see #broadcast(float) * @see #sub(float) * @see VectorOperators#SUB * @see #lanewise(VectorOperators.Binary,Vector) * @see #lanewise(VectorOperators.Binary,float) */ @ForceInline public final FloatVector sub(float e, VectorMask<Float> m) { return lanewise(SUB, e, m); } /** * {@inheritDoc} <!--workaround--> * @see #mul(float) */ @Override @ForceInline public final FloatVector mul(Vector<Float> v) { return lanewise(MUL, v); } /** * Multiplies this vector by the broadcast of an input scalar. * * This is a lane-wise binary operation which applies * the primitive multiplication operation ({@code *}) to each lane. * * This method is also equivalent to the expression * {@link #lanewise(VectorOperators.Binary,float) * lanewise}{@code (}{@link VectorOperators#MUL * MUL}{@code , e)}. * * @param e the input scalar * @return the result of multiplying this vector by the given scalar * @see #mul(Vector) * @see #broadcast(float) * @see #mul(float,VectorMask) * @see VectorOperators#MUL * @see #lanewise(VectorOperators.Binary,Vector) * @see #lanewise(VectorOperators.Binary,float) */ @ForceInline public final FloatVector mul(float e) { return lanewise(MUL, e); } /** * {@inheritDoc} <!--workaround--> * @see #mul(float,VectorMask) */ @Override @ForceInline public final FloatVector mul(Vector<Float> v, VectorMask<Float> m) { return lanewise(MUL, v, m); } /** * Multiplies this vector by the broadcast of an input scalar, * selecting lane elements controlled by a mask. * * This is a masked lane-wise binary operation which applies * the primitive multiplication operation ({@code *}) to each lane. * * This method is also equivalent to the expression * {@link #lanewise(VectorOperators.Binary,float,VectorMask) * lanewise}{@code (}{@link VectorOperators#MUL * MUL}{@code , s, m)}. * * @param e the input scalar * @param m the mask controlling lane selection * @return the result of muling each lane of this vector to the scalar * @see #mul(Vector,VectorMask) * @see #broadcast(float) * @see #mul(float) * @see VectorOperators#MUL * @see #lanewise(VectorOperators.Binary,Vector) * @see #lanewise(VectorOperators.Binary,float) */ @ForceInline public final FloatVector mul(float e, VectorMask<Float> m) { return lanewise(MUL, e, m); } /** * {@inheritDoc} <!--workaround--> * @apiNote Because the underlying scalar operator is an IEEE * floating point number, division by zero in fact will * not throw an exception, but will yield a signed * infinity or NaN. */ @Override @ForceInline public final FloatVector div(Vector<Float> v) { return lanewise(DIV, v); } /** * Divides this vector by the broadcast of an input scalar. * * This is a lane-wise binary operation which applies * the primitive division operation ({@code /}) to each lane. * * This method is also equivalent to the expression * {@link #lanewise(VectorOperators.Binary,float) * lanewise}{@code (}{@link VectorOperators#DIV * DIV}{@code , e)}. * * @apiNote Because the underlying scalar operator is an IEEE * floating point number, division by zero in fact will * not throw an exception, but will yield a signed * infinity or NaN. * * @param e the input scalar * @return the result of dividing each lane of this vector by the scalar * @see #div(Vector) * @see #broadcast(float) * @see #div(float,VectorMask) * @see VectorOperators#DIV * @see #lanewise(VectorOperators.Binary,Vector) * @see #lanewise(VectorOperators.Binary,float) */ @ForceInline public final FloatVector div(float e) { return lanewise(DIV, e); } /** * {@inheritDoc} <!--workaround--> * @see #div(float,VectorMask) * @apiNote Because the underlying scalar operator is an IEEE * floating point number, division by zero in fact will * not throw an exception, but will yield a signed * infinity or NaN. */ @Override @ForceInline public final FloatVector div(Vector<Float> v, VectorMask<Float> m) { return lanewise(DIV, v, m); } /** * Divides this vector by the broadcast of an input scalar, * selecting lane elements controlled by a mask. * * This is a masked lane-wise binary operation which applies * the primitive division operation ({@code /}) to each lane. * * This method is also equivalent to the expression * {@link #lanewise(VectorOperators.Binary,float,VectorMask) * lanewise}{@code (}{@link VectorOperators#DIV * DIV}{@code , s, m)}. * * @apiNote Because the underlying scalar operator is an IEEE * floating point number, division by zero in fact will * not throw an exception, but will yield a signed * infinity or NaN. * * @param e the input scalar * @param m the mask controlling lane selection * @return the result of dividing each lane of this vector by the scalar * @see #div(Vector,VectorMask) * @see #broadcast(float) * @see #div(float) * @see VectorOperators#DIV * @see #lanewise(VectorOperators.Binary,Vector) * @see #lanewise(VectorOperators.Binary,float) */ @ForceInline public final FloatVector div(float e, VectorMask<Float> m) { return lanewise(DIV, e, m); } /// END OF FULL-SERVICE BINARY METHODS /// SECOND-TIER BINARY METHODS // // There are no masked versions. /** * {@inheritDoc} <!--workaround--> * @apiNote * For this method, floating point negative * zero {@code -0.0} is treated as a value distinct from, and less * than the default value (positive zero). */ @Override @ForceInline public final FloatVector min(Vector<Float> v) { return lanewise(MIN, v); } // FIXME: "broadcast of an input scalar" is really wordy. Reduce? /** * Computes the smaller of this vector and the broadcast of an input scalar. * * This is a lane-wise binary operation which applies the * operation {@code Math.min()} to each pair of * corresponding lane values. * * This method is also equivalent to the expression * {@link #lanewise(VectorOperators.Binary,float) * lanewise}{@code (}{@link VectorOperators#MIN * MIN}{@code , e)}. * * @param e the input scalar * @return the result of multiplying this vector by the given scalar * @see #min(Vector) * @see #broadcast(float) * @see VectorOperators#MIN * @see #lanewise(VectorOperators.Binary,float,VectorMask) * @apiNote * For this method, floating point negative * zero {@code -0.0} is treated as a value distinct from, and less * than the default value (positive zero). */ @ForceInline public final FloatVector min(float e) { return lanewise(MIN, e); } /** * {@inheritDoc} <!--workaround--> * @apiNote * For this method, floating point negative * zero {@code -0.0} is treated as a value distinct from, and less * than the default value (positive zero). */ @Override @ForceInline public final FloatVector max(Vector<Float> v) { return lanewise(MAX, v); } /** * Computes the larger of this vector and the broadcast of an input scalar. * * This is a lane-wise binary operation which applies the * operation {@code Math.max()} to each pair of * corresponding lane values. * * This method is also equivalent to the expression * {@link #lanewise(VectorOperators.Binary,float) * lanewise}{@code (}{@link VectorOperators#MAX * MAX}{@code , e)}. * * @param e the input scalar * @return the result of multiplying this vector by the given scalar * @see #max(Vector) * @see #broadcast(float) * @see VectorOperators#MAX * @see #lanewise(VectorOperators.Binary,float,VectorMask) * @apiNote * For this method, floating point negative * zero {@code -0.0} is treated as a value distinct from, and less * than the default value (positive zero). */ @ForceInline public final FloatVector max(float e) { return lanewise(MAX, e); } // common FP operator: pow /** * Raises this vector to the power of a second input vector. * * This is a lane-wise binary operation which applies an operation * conforming to the specification of * {@link Math#pow Math.pow(a,b)} * to each pair of corresponding lane values. * The operation is adapted to cast the operands and the result, * specifically widening {@code float} operands to {@code double} * operands and narrowing the {@code double} result to a {@code float} * result. * * This method is also equivalent to the expression * {@link #lanewise(VectorOperators.Binary,Vector) * lanewise}{@code (}{@link VectorOperators#POW * POW}{@code , b)}. * * <p> * This is not a full-service named operation like * {@link #add(Vector) add}. A masked version of * this operation is not directly available * but may be obtained via the masked version of * {@code lanewise}. * * @param b a vector exponent by which to raise this vector * @return the {@code b}-th power of this vector * @see #pow(float) * @see VectorOperators#POW * @see #lanewise(VectorOperators.Binary,Vector,VectorMask) */ @ForceInline public final FloatVector pow(Vector<Float> b) { return lanewise(POW, b); } /** * Raises this vector to a scalar power. * * This is a lane-wise binary operation which applies an operation * conforming to the specification of * {@link Math#pow Math.pow(a,b)} * to each pair of corresponding lane values. * The operation is adapted to cast the operands and the result, * specifically widening {@code float} operands to {@code double} * operands and narrowing the {@code double} result to a {@code float} * result. * * This method is also equivalent to the expression * {@link #lanewise(VectorOperators.Binary,Vector) * lanewise}{@code (}{@link VectorOperators#POW * POW}{@code , b)}. * * @param b a scalar exponent by which to raise this vector * @return the {@code b}-th power of this vector * @see #pow(Vector) * @see VectorOperators#POW * @see #lanewise(VectorOperators.Binary,float,VectorMask) */ @ForceInline public final FloatVector pow(float b) { return lanewise(POW, b); } /// UNARY METHODS /** * {@inheritDoc} <!--workaround--> */ @Override @ForceInline public final FloatVector neg() { return lanewise(NEG); } /** * {@inheritDoc} <!--workaround--> */ @Override @ForceInline public final FloatVector abs() { return lanewise(ABS); } // sqrt /** * Computes the square root of this vector. * * This is a lane-wise unary operation which applies an operation * conforming to the specification of * {@link Math#sqrt Math.sqrt(a)} * to each lane value. * The operation is adapted to cast the operand and the result, * specifically widening the {@code float} operand to a {@code double} * operand and narrowing the {@code double} result to a {@code float} * result. * * This method is also equivalent to the expression * {@link #lanewise(VectorOperators.Unary) * lanewise}{@code (}{@link VectorOperators#SQRT * SQRT}{@code )}. * * @return the square root of this vector * @see VectorOperators#SQRT * @see #lanewise(VectorOperators.Unary,VectorMask) */ @ForceInline public final FloatVector sqrt() { return lanewise(SQRT); } /// COMPARISONS /** * {@inheritDoc} <!--workaround--> */ @Override @ForceInline public final VectorMask<Float> eq(Vector<Float> v) { return compare(EQ, v); } /** * Tests if this vector is equal to an input scalar. * * This is a lane-wise binary test operation which applies * the primitive equals operation ({@code ==}) to each lane. * The result is the same as {@code compare(VectorOperators.Comparison.EQ, e)}. * * @param e the input scalar * @return the result mask of testing if this vector * is equal to {@code e} * @see #compare(VectorOperators.Comparison,float) */ @ForceInline public final VectorMask<Float> eq(float e) { return compare(EQ, e); } /** * {@inheritDoc} <!--workaround--> */ @Override @ForceInline public final VectorMask<Float> lt(Vector<Float> v) { return compare(LT, v); } /** * Tests if this vector is less than an input scalar. * * This is a lane-wise binary test operation which applies * the primitive less than operation ({@code <}) to each lane. * The result is the same as {@code compare(VectorOperators.LT, e)}. * * @param e the input scalar * @return the mask result of testing if this vector * is less than the input scalar * @see #compare(VectorOperators.Comparison,float) */ @ForceInline public final VectorMask<Float> lt(float e) { return compare(LT, e); } /** * {@inheritDoc} <!--workaround--> */ @Override public abstract VectorMask<Float> test(VectorOperators.Test op); /*package-private*/ @ForceInline final <M extends VectorMask<Float>> M testTemplate(Class<M> maskType, Test op) { FloatSpecies vsp = vspecies(); if (opKind(op, VO_SPECIAL)) { IntVector bits = this.viewAsIntegralLanes(); VectorMask<Integer> m; if (op == IS_DEFAULT) { m = bits.compare(EQ, (int) 0); } else if (op == IS_NEGATIVE) { m = bits.compare(LT, (int) 0); } else if (op == IS_FINITE || op == IS_NAN || op == IS_INFINITE) { // first kill the sign: bits = bits.and(Integer.MAX_VALUE); // next find the bit pattern for infinity: int infbits = (int) toBits(Float.POSITIVE_INFINITY); // now compare: if (op == IS_FINITE) { m = bits.compare(LT, infbits); } else if (op == IS_NAN) { m = bits.compare(GT, infbits); } else { m = bits.compare(EQ, infbits); } } else { throw new AssertionError(op); } return maskType.cast(m.cast(this.vspecies())); } int opc = opCode(op); throw new AssertionError(op); } /** * {@inheritDoc} <!--workaround--> */ @Override @ForceInline public final VectorMask<Float> test(VectorOperators.Test op, VectorMask<Float> m) { return test(op).and(m); } /** * {@inheritDoc} <!--workaround--> */ @Override public abstract VectorMask<Float> compare(VectorOperators.Comparison op, Vector<Float> v); /*package-private*/ @ForceInline final <M extends VectorMask<Float>> M compareTemplate(Class<M> maskType, Comparison op, Vector<Float> v) { Objects.requireNonNull(v); FloatSpecies vsp = vspecies(); FloatVector that = (FloatVector) v; that.check(this); int opc = opCode(op); return VectorSupport.compare( opc, getClass(), maskType, float.class, length(), this, that, (cond, v0, v1) -> { AbstractMask<Float> m = v0.bTest(cond, v1, (cond_, i, a, b) -> compareWithOp(cond, a, b)); @SuppressWarnings("unchecked") M m2 = (M) m; return m2; }); } @ForceInline private static boolean compareWithOp(int cond, float a, float b) { return switch (cond) { case BT_eq -> a == b; case BT_ne -> a != b; case BT_lt -> a < b; case BT_le -> a <= b; case BT_gt -> a > b; case BT_ge -> a >= b; default -> throw new AssertionError(); }; } /** * {@inheritDoc} <!--workaround--> */ @Override @ForceInline public final VectorMask<Float> compare(VectorOperators.Comparison op, Vector<Float> v, VectorMask<Float> m) { return compare(op, v).and(m); } /** * Tests this vector by comparing it with an input scalar, * according to the given comparison operation. * * This is a lane-wise binary test operation which applies * the comparison operation to each lane. * <p> * The result is the same as * {@code compare(op, broadcast(species(), e))}. * That is, the scalar may be regarded as broadcast to * a vector of the same species, and then compared * against the original vector, using the selected * comparison operation. * * @param op the operation used to compare lane values * @param e the input scalar * @return the mask result of testing lane-wise if this vector * compares to the input, according to the selected * comparison operator * @see FloatVector#compare(VectorOperators.Comparison,Vector) * @see #eq(float) * @see #lt(float) */ public abstract VectorMask<Float> compare(Comparison op, float e); /*package-private*/ @ForceInline final <M extends VectorMask<Float>> M compareTemplate(Class<M> maskType, Comparison op, float e) { return compareTemplate(maskType, op, broadcast(e)); } /** * Tests this vector by comparing it with an input scalar, * according to the given comparison operation, * in lanes selected by a mask. * * This is a masked lane-wise binary test operation which applies * to each pair of corresponding lane values. * * The returned result is equal to the expression * {@code compare(op,s).and(m)}. * * @param op the operation used to compare lane values * @param e the input scalar * @param m the mask controlling lane selection * @return the mask result of testing lane-wise if this vector * compares to the input, according to the selected * comparison operator, * and only in the lanes selected by the mask * @see FloatVector#compare(VectorOperators.Comparison,Vector,VectorMask) */ @ForceInline public final VectorMask<Float> compare(VectorOperators.Comparison op, float e, VectorMask<Float> m) { return compare(op, e).and(m); } /** * {@inheritDoc} <!--workaround--> */ @Override public abstract VectorMask<Float> compare(Comparison op, long e); /*package-private*/ @ForceInline final <M extends VectorMask<Float>> M compareTemplate(Class<M> maskType, Comparison op, long e) { return compareTemplate(maskType, op, broadcast(e)); } /** * {@inheritDoc} <!--workaround--> */ @Override @ForceInline public final VectorMask<Float> compare(Comparison op, long e, VectorMask<Float> m) { return compare(op, broadcast(e), m); } /** * {@inheritDoc} <!--workaround--> */ @Override public abstract FloatVector blend(Vector<Float> v, VectorMask<Float> m); /*package-private*/ @ForceInline final <M extends VectorMask<Float>> FloatVector blendTemplate(Class<M> maskType, FloatVector v, M m) { v.check(this); return VectorSupport.blend( getClass(), maskType, float.class, length(), this, v, m, (v0, v1, m_) -> v0.bOp(v1, m_, (i, a, b) -> b)); } /** * {@inheritDoc} <!--workaround--> */ @Override public abstract FloatVector addIndex(int scale); /*package-private*/ @ForceInline final FloatVector addIndexTemplate(int scale) { FloatSpecies vsp = vspecies(); // make sure VLENGTH*scale doesn't overflow: vsp.checkScale(scale); return VectorSupport.indexVector( getClass(), float.class, length(), this, scale, vsp, (v, scale_, s) -> { // If the platform doesn't support an INDEX // instruction directly, load IOTA from memory // and multiply. FloatVector iota = s.iota(); float sc = (float) scale_; return v.add(sc == 1 ? iota : iota.mul(sc)); }); } /** * Replaces selected lanes of this vector with * a scalar value * under the control of a mask. * * This is a masked lane-wise binary operation which * selects each lane value from one or the other input. * * The returned result is equal to the expression * {@code blend(broadcast(e),m)}. * * @param e the input scalar, containing the replacement lane value * @param m the mask controlling lane selection of the scalar * @return the result of blending the lane elements of this vector with * the scalar value */ @ForceInline public final FloatVector blend(float e, VectorMask<Float> m) { return blend(broadcast(e), m); } /** * Replaces selected lanes of this vector with * a scalar value * under the control of a mask. * * This is a masked lane-wise binary operation which * selects each lane value from one or the other input. * * The returned result is equal to the expression * {@code blend(broadcast(e),m)}. * * @param e the input scalar, containing the replacement lane value * @param m the mask controlling lane selection of the scalar * @return the result of blending the lane elements of this vector with * the scalar value */ @ForceInline public final FloatVector blend(long e, VectorMask<Float> m) { return blend(broadcast(e), m); } /** * {@inheritDoc} <!--workaround--> */ @Override public abstract FloatVector slice(int origin, Vector<Float> v1); /*package-private*/ final @ForceInline FloatVector sliceTemplate(int origin, Vector<Float> v1) { FloatVector that = (FloatVector) v1; that.check(this); Objects.checkIndex(origin, length() + 1); VectorShuffle<Float> iota = iotaShuffle(); VectorMask<Float> blendMask = iota.toVector().compare(VectorOperators.LT, (broadcast((float)(length() - origin)))); iota = iotaShuffle(origin, 1, true); return that.rearrange(iota).blend(this.rearrange(iota), blendMask); } /** * {@inheritDoc} <!--workaround--> */ @Override @ForceInline public final FloatVector slice(int origin, Vector<Float> w, VectorMask<Float> m) { return broadcast(0).blend(slice(origin, w), m); } /** * {@inheritDoc} <!--workaround--> */ @Override public abstract FloatVector slice(int origin); /*package-private*/ final @ForceInline FloatVector sliceTemplate(int origin) { Objects.checkIndex(origin, length() + 1); VectorShuffle<Float> iota = iotaShuffle(); VectorMask<Float> blendMask = iota.toVector().compare(VectorOperators.LT, (broadcast((float)(length() - origin)))); iota = iotaShuffle(origin, 1, true); return vspecies().zero().blend(this.rearrange(iota), blendMask); } /** * {@inheritDoc} <!--workaround--> */ @Override public abstract FloatVector unslice(int origin, Vector<Float> w, int part); /*package-private*/ final @ForceInline FloatVector unsliceTemplate(int origin, Vector<Float> w, int part) { FloatVector that = (FloatVector) w; that.check(this); Objects.checkIndex(origin, length() + 1); VectorShuffle<Float> iota = iotaShuffle(); VectorMask<Float> blendMask = iota.toVector().compare((part == 0) ? VectorOperators.GE : VectorOperators.LT, (broadcast((float)(origin)))); iota = iotaShuffle(-origin, 1, true); return that.blend(this.rearrange(iota), blendMask); } /*package-private*/ final @ForceInline <M extends VectorMask<Float>> FloatVector unsliceTemplate(Class<M> maskType, int origin, Vector<Float> w, int part, M m) { FloatVector that = (FloatVector) w; that.check(this); FloatVector slice = that.sliceTemplate(origin, that); slice = slice.blendTemplate(maskType, this, m); return slice.unsliceTemplate(origin, w, part); } /** * {@inheritDoc} <!--workaround--> */ @Override public abstract FloatVector unslice(int origin, Vector<Float> w, int part, VectorMask<Float> m); /** * {@inheritDoc} <!--workaround--> */ @Override public abstract FloatVector unslice(int origin); /*package-private*/ final @ForceInline FloatVector unsliceTemplate(int origin) { Objects.checkIndex(origin, length() + 1); VectorShuffle<Float> iota = iotaShuffle(); VectorMask<Float> blendMask = iota.toVector().compare(VectorOperators.GE, (broadcast((float)(origin)))); iota = iotaShuffle(-origin, 1, true); return vspecies().zero().blend(this.rearrange(iota), blendMask); } private ArrayIndexOutOfBoundsException wrongPartForSlice(int part) { String msg = String.format("bad part number %d for slice operation", part); return new ArrayIndexOutOfBoundsException(msg); } /** * {@inheritDoc} <!--workaround--> */ @Override public abstract FloatVector rearrange(VectorShuffle<Float> m); /*package-private*/ @ForceInline final <S extends VectorShuffle<Float>> FloatVector rearrangeTemplate(Class<S> shuffletype, S shuffle) { shuffle.checkIndexes(); return VectorSupport.rearrangeOp( getClass(), shuffletype, float.class, length(), this, shuffle, (v1, s_) -> v1.uOp((i, a) -> { int ei = s_.laneSource(i); return v1.lane(ei); })); } /** * {@inheritDoc} <!--workaround--> */ @Override public abstract FloatVector rearrange(VectorShuffle<Float> s, VectorMask<Float> m); /*package-private*/ @ForceInline final <S extends VectorShuffle<Float>> FloatVector rearrangeTemplate(Class<S> shuffletype, S shuffle, VectorMask<Float> m) { FloatVector unmasked = VectorSupport.rearrangeOp( getClass(), shuffletype, float.class, length(), this, shuffle, (v1, s_) -> v1.uOp((i, a) -> { int ei = s_.laneSource(i); return ei < 0 ? 0 : v1.lane(ei); })); VectorMask<Float> valid = shuffle.laneIsValid(); if (m.andNot(valid).anyTrue()) { shuffle.checkIndexes(); throw new AssertionError(); } return broadcast((float)0).blend(unmasked, m); } /** * {@inheritDoc} <!--workaround--> */ @Override public abstract FloatVector rearrange(VectorShuffle<Float> s, Vector<Float> v); /*package-private*/ @ForceInline final <S extends VectorShuffle<Float>> FloatVector rearrangeTemplate(Class<S> shuffletype, S shuffle, FloatVector v) { VectorMask<Float> valid = shuffle.laneIsValid(); @SuppressWarnings("unchecked") S ws = (S) shuffle.wrapIndexes(); FloatVector r0 = VectorSupport.rearrangeOp( getClass(), shuffletype, float.class, length(), this, ws, (v0, s_) -> v0.uOp((i, a) -> { int ei = s_.laneSource(i); return v0.lane(ei); })); FloatVector r1 = VectorSupport.rearrangeOp( getClass(), shuffletype, float.class, length(), v, ws, (v1, s_) -> v1.uOp((i, a) -> { int ei = s_.laneSource(i); return v1.lane(ei); })); return r1.blend(r0, valid); } @ForceInline private final VectorShuffle<Float> toShuffle0(FloatSpecies dsp) { float[] a = toArray(); int[] sa = new int[a.length]; for (int i = 0; i < a.length; i++) { sa[i] = (int) a[i]; } return VectorShuffle.fromArray(dsp, sa, 0); } /*package-private*/ @ForceInline final VectorShuffle<Float> toShuffleTemplate(Class<?> shuffleType) { FloatSpecies vsp = vspecies(); return VectorSupport.convert(VectorSupport.VECTOR_OP_CAST, getClass(), float.class, length(), shuffleType, byte.class, length(), this, vsp, FloatVector::toShuffle0); } /** * {@inheritDoc} <!--workaround--> */ @Override public abstract FloatVector selectFrom(Vector<Float> v); /*package-private*/ @ForceInline final FloatVector selectFromTemplate(FloatVector v) { return v.rearrange(this.toShuffle()); } /** * {@inheritDoc} <!--workaround--> */ @Override public abstract FloatVector selectFrom(Vector<Float> s, VectorMask<Float> m); /*package-private*/ @ForceInline final FloatVector selectFromTemplate(FloatVector v, AbstractMask<Float> m) { return v.rearrange(this.toShuffle(), m); } /// Ternary operations /** * Multiplies this vector by a second input vector, and sums * the result with a third. * * Extended precision is used for the intermediate result, * avoiding possible loss of precision from rounding once * for each of the two operations. * The result is numerically close to {@code this.mul(b).add(c)}, * and is typically closer to the true mathematical result. * * This is a lane-wise ternary operation which applies an operation * conforming to the specification of * {@link Math#fma(float,float,float) Math.fma(a,b,c)} * to each lane. * The operation is adapted to cast the operands and the result, * specifically widening {@code float} operands to {@code double} * operands and narrowing the {@code double} result to a {@code float} * result. * * This method is also equivalent to the expression * {@link #lanewise(VectorOperators.Ternary,Vector,Vector) * lanewise}{@code (}{@link VectorOperators#FMA * FMA}{@code , b, c)}. * * @param b the second input vector, supplying multiplier values * @param c the third input vector, supplying addend values * @return the product of this vector and the second input vector * summed with the third input vector, using extended precision * for the intermediate result * @see #fma(float,float) * @see VectorOperators#FMA * @see #lanewise(VectorOperators.Ternary,Vector,Vector,VectorMask) */ @ForceInline public final FloatVector fma(Vector<Float> b, Vector<Float> c) { return lanewise(FMA, b, c); } /** * Multiplies this vector by a scalar multiplier, and sums * the result with a scalar addend. * * Extended precision is used for the intermediate result, * avoiding possible loss of precision from rounding once * for each of the two operations. * The result is numerically close to {@code this.mul(b).add(c)}, * and is typically closer to the true mathematical result. * * This is a lane-wise ternary operation which applies an operation * conforming to the specification of * {@link Math#fma(float,float,float) Math.fma(a,b,c)} * to each lane. * The operation is adapted to cast the operands and the result, * specifically widening {@code float} operands to {@code double} * operands and narrowing the {@code double} result to a {@code float} * result. * * This method is also equivalent to the expression * {@link #lanewise(VectorOperators.Ternary,Vector,Vector) * lanewise}{@code (}{@link VectorOperators#FMA * FMA}{@code , b, c)}. * * @param b the scalar multiplier * @param c the scalar addend * @return the product of this vector and the scalar multiplier * summed with scalar addend, using extended precision * for the intermediate result * @see #fma(Vector,Vector) * @see VectorOperators#FMA * @see #lanewise(VectorOperators.Ternary,float,float,VectorMask) */ @ForceInline public final FloatVector fma(float b, float c) { return lanewise(FMA, b, c); } // Don't bother with (Vector,float) and (float,Vector) overloadings. // Type specific horizontal reductions /** * Returns a value accumulated from all the lanes of this vector. * * This is an associative cross-lane reduction operation which * applies the specified operation to all the lane elements. * <p> * A few reduction operations do not support arbitrary reordering * of their operands, yet are included here because of their * usefulness. * <ul> * <li> * In the case of {@code FIRST_NONZERO}, the reduction returns * the value from the lowest-numbered non-zero lane. * (As with {@code MAX} and {@code MIN}, floating point negative * zero {@code -0.0} is treated as a value distinct from * the default value, positive zero. So a first-nonzero lane reduction * might return {@code -0.0} even in the presence of non-zero * lane values.) * <li> * In the case of {@code ADD} and {@code MUL}, the * precise result will reflect the choice of an arbitrary order * of operations, which may even vary over time. * For further details see the section * <a href="VectorOperators.html#fp_assoc">Operations on floating point vectors</a>. * <li> * All other reduction operations are fully commutative and * associative. The implementation can choose any order of * processing, yet it will always produce the same result. * </ul> * * @param op the operation used to combine lane values * @return the accumulated result * @throws UnsupportedOperationException if this vector does * not support the requested operation * @see #reduceLanes(VectorOperators.Associative,VectorMask) * @see #add(Vector) * @see #mul(Vector) * @see #min(Vector) * @see #max(Vector) * @see VectorOperators#FIRST_NONZERO */ public abstract float reduceLanes(VectorOperators.Associative op); /** * Returns a value accumulated from selected lanes of this vector, * controlled by a mask. * * This is an associative cross-lane reduction operation which * applies the specified operation to the selected lane elements. * <p> * If no elements are selected, an operation-specific identity * value is returned. * <ul> * <li> * If the operation is * {@code ADD} * or {@code FIRST_NONZERO}, * then the identity value is positive zero, the default {@code float} value. * <li> * If the operation is {@code MUL}, * then the identity value is one. * <li> * If the operation is {@code MAX}, * then the identity value is {@code Float.NEGATIVE_INFINITY}. * <li> * If the operation is {@code MIN}, * then the identity value is {@code Float.POSITIVE_INFINITY}. * </ul> * <p> * A few reduction operations do not support arbitrary reordering * of their operands, yet are included here because of their * usefulness. * <ul> * <li> * In the case of {@code FIRST_NONZERO}, the reduction returns * the value from the lowest-numbered non-zero lane. * (As with {@code MAX} and {@code MIN}, floating point negative * zero {@code -0.0} is treated as a value distinct from * the default value, positive zero. So a first-nonzero lane reduction * might return {@code -0.0} even in the presence of non-zero * lane values.) * <li> * In the case of {@code ADD} and {@code MUL}, the * precise result will reflect the choice of an arbitrary order * of operations, which may even vary over time. * For further details see the section * <a href="VectorOperators.html#fp_assoc">Operations on floating point vectors</a>. * <li> * All other reduction operations are fully commutative and * associative. The implementation can choose any order of * processing, yet it will always produce the same result. * </ul> * * @param op the operation used to combine lane values * @param m the mask controlling lane selection * @return the reduced result accumulated from the selected lane values * @throws UnsupportedOperationException if this vector does * not support the requested operation * @see #reduceLanes(VectorOperators.Associative) */ public abstract float reduceLanes(VectorOperators.Associative op, VectorMask<Float> m); /*package-private*/ @ForceInline final float reduceLanesTemplate(VectorOperators.Associative op, VectorMask<Float> m) { FloatVector v = reduceIdentityVector(op).blend(this, m); return v.reduceLanesTemplate(op); } /*package-private*/ @ForceInline final float reduceLanesTemplate(VectorOperators.Associative op) { if (op == FIRST_NONZERO) { // FIXME: The JIT should handle this, and other scan ops alos. VectorMask<Integer> thisNZ = this.viewAsIntegralLanes().compare(NE, (int) 0); return this.lane(thisNZ.firstTrue()); } int opc = opCode(op); return fromBits(VectorSupport.reductionCoerced( opc, getClass(), float.class, length(), this, REDUCE_IMPL.find(op, opc, (opc_) -> { switch (opc_) { case VECTOR_OP_ADD: return v -> toBits(v.rOp((float)0, (i, a, b) -> (float)(a + b))); case VECTOR_OP_MUL: return v -> toBits(v.rOp((float)1, (i, a, b) -> (float)(a * b))); case VECTOR_OP_MIN: return v -> toBits(v.rOp(MAX_OR_INF, (i, a, b) -> (float) Math.min(a, b))); case VECTOR_OP_MAX: return v -> toBits(v.rOp(MIN_OR_INF, (i, a, b) -> (float) Math.max(a, b))); default: return null; }}))); } private static final ImplCache<Associative,Function<FloatVector,Long>> REDUCE_IMPL = new ImplCache<>(Associative.class, FloatVector.class); private @ForceInline FloatVector reduceIdentityVector(VectorOperators.Associative op) { int opc = opCode(op); UnaryOperator<FloatVector> fn = REDUCE_ID_IMPL.find(op, opc, (opc_) -> { switch (opc_) { case VECTOR_OP_ADD: return v -> v.broadcast(0); case VECTOR_OP_MUL: return v -> v.broadcast(1); case VECTOR_OP_MIN: return v -> v.broadcast(MAX_OR_INF); case VECTOR_OP_MAX: return v -> v.broadcast(MIN_OR_INF); default: return null; } }); return fn.apply(this); } private static final ImplCache<Associative,UnaryOperator<FloatVector>> REDUCE_ID_IMPL = new ImplCache<>(Associative.class, FloatVector.class); private static final float MIN_OR_INF = Float.NEGATIVE_INFINITY; private static final float MAX_OR_INF = Float.POSITIVE_INFINITY; public @Override abstract long reduceLanesToLong(VectorOperators.Associative op); public @Override abstract long reduceLanesToLong(VectorOperators.Associative op, VectorMask<Float> m); // Type specific accessors /** * Gets the lane element at lane index {@code i} * * @param i the lane index * @return the lane element at lane index {@code i} * @throws IllegalArgumentException if the index is is out of range * ({@code < 0 || >= length()}) */ public abstract float lane(int i); /** * Replaces the lane element of this vector at lane index {@code i} with * value {@code e}. * * This is a cross-lane operation and behaves as if it returns the result * of blending this vector with an input vector that is the result of * broadcasting {@code e} and a mask that has only one lane set at lane * index {@code i}. * * @param i the lane index of the lane element to be replaced * @param e the value to be placed * @return the result of replacing the lane element of this vector at lane * index {@code i} with value {@code e}. * @throws IllegalArgumentException if the index is is out of range * ({@code < 0 || >= length()}) */ public abstract FloatVector withLane(int i, float e); // Memory load operations /** * Returns an array of type {@code float[]} * containing all the lane values. * The array length is the same as the vector length. * The array elements are stored in lane order. * <p> * This method behaves as if it stores * this vector into an allocated array * (using {@link #intoArray(float[], int) intoArray}) * and returns the array as follows: * <pre>{@code * float[] a = new float[this.length()]; * this.intoArray(a, 0); * return a; * }</pre> * * @return an array containing the lane values of this vector */ @ForceInline @Override public final float[] toArray() { float[] a = new float[vspecies().laneCount()]; intoArray(a, 0); return a; } /** {@inheritDoc} <!--workaround--> */ @ForceInline @Override public final int[] toIntArray() { float[] a = toArray(); int[] res = new int[a.length]; for (int i = 0; i < a.length; i++) { float e = a[i]; res[i] = (int) FloatSpecies.toIntegralChecked(e, true); } return res; } /** {@inheritDoc} <!--workaround--> */ @ForceInline @Override public final long[] toLongArray() { float[] a = toArray(); long[] res = new long[a.length]; for (int i = 0; i < a.length; i++) { float e = a[i]; res[i] = FloatSpecies.toIntegralChecked(e, false); } return res; } /** {@inheritDoc} <!--workaround--> * @implNote * When this method is used on used on vectors * of type {@code FloatVector}, * there will be no loss of precision. */ @ForceInline @Override public final double[] toDoubleArray() { float[] a = toArray(); double[] res = new double[a.length]; for (int i = 0; i < a.length; i++) { res[i] = (double) a[i]; } return res; } /** * Loads a vector from a byte array starting at an offset. * Bytes are composed into primitive lane elements according * to the specified byte order. * The vector is arranged into lanes according to * <a href="Vector.html#lane-order">memory ordering</a>. * <p> * This method behaves as if it returns the result of calling * {@link #fromByteBuffer(VectorSpecies,ByteBuffer,int,ByteOrder,VectorMask) * fromByteBuffer()} as follows: * <pre>{@code * var bb = ByteBuffer.wrap(a); * var m = species.maskAll(true); * return fromByteBuffer(species, bb, offset, bo, m); * }</pre> * * @param species species of desired vector * @param a the byte array * @param offset the offset into the array * @param bo the intended byte order * @return a vector loaded from a byte array * @throws IndexOutOfBoundsException * if {@code offset+N*ESIZE < 0} * or {@code offset+(N+1)*ESIZE > a.length} * for any lane {@code N} in the vector */ @ForceInline public static FloatVector fromByteArray(VectorSpecies<Float> species, byte[] a, int offset, ByteOrder bo) { offset = checkFromIndexSize(offset, species.vectorByteSize(), a.length); FloatSpecies vsp = (FloatSpecies) species; return vsp.dummyVector().fromByteArray0(a, offset).maybeSwap(bo); } /** * Loads a vector from a byte array starting at an offset * and using a mask. * Lanes where the mask is unset are filled with the default * value of {@code float} (positive zero). * Bytes are composed into primitive lane elements according * to the specified byte order. * The vector is arranged into lanes according to * <a href="Vector.html#lane-order">memory ordering</a>. * <p> * This method behaves as if it returns the result of calling * {@link #fromByteBuffer(VectorSpecies,ByteBuffer,int,ByteOrder,VectorMask) * fromByteBuffer()} as follows: * <pre>{@code * var bb = ByteBuffer.wrap(a); * return fromByteBuffer(species, bb, offset, bo, m); * }</pre> * * @param species species of desired vector * @param a the byte array * @param offset the offset into the array * @param bo the intended byte order * @param m the mask controlling lane selection * @return a vector loaded from a byte array * @throws IndexOutOfBoundsException * if {@code offset+N*ESIZE < 0} * or {@code offset+(N+1)*ESIZE > a.length} * for any lane {@code N} in the vector * where the mask is set */ @ForceInline public static FloatVector fromByteArray(VectorSpecies<Float> species, byte[] a, int offset, ByteOrder bo, VectorMask<Float> m) { FloatSpecies vsp = (FloatSpecies) species; if (offset >= 0 && offset <= (a.length - species.vectorByteSize())) { FloatVector zero = vsp.zero(); FloatVector v = zero.fromByteArray0(a, offset); return zero.blend(v.maybeSwap(bo), m); } // FIXME: optimize checkMaskFromIndexSize(offset, vsp, m, 4, a.length); ByteBuffer wb = wrapper(a, bo); return vsp.ldOp(wb, offset, (AbstractMask<Float>)m, (wb_, o, i) -> wb_.getFloat(o + i * 4)); } /** * Loads a vector from an array of type {@code float[]} * starting at an offset. * For each vector lane, where {@code N} is the vector lane index, the * array element at index {@code offset + N} is placed into the * resulting vector at lane index {@code N}. * * @param species species of desired vector * @param a the array * @param offset the offset into the array * @return the vector loaded from an array * @throws IndexOutOfBoundsException * if {@code offset+N < 0} or {@code offset+N >= a.length} * for any lane {@code N} in the vector */ @ForceInline public static FloatVector fromArray(VectorSpecies<Float> species, float[] a, int offset) { offset = checkFromIndexSize(offset, species.length(), a.length); FloatSpecies vsp = (FloatSpecies) species; return vsp.dummyVector().fromArray0(a, offset); } /** * Loads a vector from an array of type {@code float[]} * starting at an offset and using a mask. * Lanes where the mask is unset are filled with the default * value of {@code float} (positive zero). * For each vector lane, where {@code N} is the vector lane index, * if the mask lane at index {@code N} is set then the array element at * index {@code offset + N} is placed into the resulting vector at lane index * {@code N}, otherwise the default element value is placed into the * resulting vector at lane index {@code N}. * * @param species species of desired vector * @param a the array * @param offset the offset into the array * @param m the mask controlling lane selection * @return the vector loaded from an array * @throws IndexOutOfBoundsException * if {@code offset+N < 0} or {@code offset+N >= a.length} * for any lane {@code N} in the vector * where the mask is set */ @ForceInline public static FloatVector fromArray(VectorSpecies<Float> species, float[] a, int offset, VectorMask<Float> m) { FloatSpecies vsp = (FloatSpecies) species; if (offset >= 0 && offset <= (a.length - species.length())) { FloatVector zero = vsp.zero(); return zero.blend(zero.fromArray0(a, offset), m); } // FIXME: optimize checkMaskFromIndexSize(offset, vsp, m, 1, a.length); return vsp.vOp(m, i -> a[offset + i]); } /** * Gathers a new vector composed of elements from an array of type * {@code float[]}, * using indexes obtained by adding a fixed {@code offset} to a * series of secondary offsets from an <em>index map</em>. * The index map is a contiguous sequence of {@code VLENGTH} * elements in a second array of {@code int}s, starting at a given * {@code mapOffset}. * <p> * For each vector lane, where {@code N} is the vector lane index, * the lane is loaded from the array * element {@code a[f(N)]}, where {@code f(N)} is the * index mapping expression * {@code offset + indexMap[mapOffset + N]]}. * * @param species species of desired vector * @param a the array * @param offset the offset into the array, may be negative if relative * indexes in the index map compensate to produce a value within the * array bounds * @param indexMap the index map * @param mapOffset the offset into the index map * @return the vector loaded from the indexed elements of the array * @throws IndexOutOfBoundsException * if {@code mapOffset+N < 0} * or if {@code mapOffset+N >= indexMap.length}, * or if {@code f(N)=offset+indexMap[mapOffset+N]} * is an invalid index into {@code a}, * for any lane {@code N} in the vector * @see FloatVector#toIntArray() */ @ForceInline public static FloatVector fromArray(VectorSpecies<Float> species, float[] a, int offset, int[] indexMap, int mapOffset) { FloatSpecies vsp = (FloatSpecies) species; IntVector.IntSpecies isp = IntVector.species(vsp.indexShape()); Objects.requireNonNull(a); Objects.requireNonNull(indexMap); Class<? extends FloatVector> vectorType = vsp.vectorType(); // Index vector: vix[0:n] = k -> offset + indexMap[mapOffset + k] IntVector vix = IntVector .fromArray(isp, indexMap, mapOffset) .add(offset); vix = VectorIntrinsics.checkIndex(vix, a.length); return VectorSupport.loadWithMap( vectorType, float.class, vsp.laneCount(), IntVector.species(vsp.indexShape()).vectorType(), a, ARRAY_BASE, vix, a, offset, indexMap, mapOffset, vsp, (float[] c, int idx, int[] iMap, int idy, FloatSpecies s) -> s.vOp(n -> c[idx + iMap[idy+n]])); } /** * Gathers a new vector composed of elements from an array of type * {@code float[]}, * under the control of a mask, and * using indexes obtained by adding a fixed {@code offset} to a * series of secondary offsets from an <em>index map</em>. * The index map is a contiguous sequence of {@code VLENGTH} * elements in a second array of {@code int}s, starting at a given * {@code mapOffset}. * <p> * For each vector lane, where {@code N} is the vector lane index, * if the lane is set in the mask, * the lane is loaded from the array * element {@code a[f(N)]}, where {@code f(N)} is the * index mapping expression * {@code offset + indexMap[mapOffset + N]]}. * Unset lanes in the resulting vector are set to zero. * * @param species species of desired vector * @param a the array * @param offset the offset into the array, may be negative if relative * indexes in the index map compensate to produce a value within the * array bounds * @param indexMap the index map * @param mapOffset the offset into the index map * @param m the mask controlling lane selection * @return the vector loaded from the indexed elements of the array * @throws IndexOutOfBoundsException * if {@code mapOffset+N < 0} * or if {@code mapOffset+N >= indexMap.length}, * or if {@code f(N)=offset+indexMap[mapOffset+N]} * is an invalid index into {@code a}, * for any lane {@code N} in the vector * where the mask is set * @see FloatVector#toIntArray() */ @ForceInline public static FloatVector fromArray(VectorSpecies<Float> species, float[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Float> m) { if (m.allTrue()) { return fromArray(species, a, offset, indexMap, mapOffset); } else { // FIXME: Cannot vectorize yet, if there's a mask. FloatSpecies vsp = (FloatSpecies) species; return vsp.vOp(m, n -> a[offset + indexMap[mapOffset + n]]); } } /** * Loads a vector from a {@linkplain ByteBuffer byte buffer} * starting at an offset into the byte buffer. * Bytes are composed into primitive lane elements according * to the specified byte order. * The vector is arranged into lanes according to * <a href="Vector.html#lane-order">memory ordering</a>. * <p> * This method behaves as if it returns the result of calling * {@link #fromByteBuffer(VectorSpecies,ByteBuffer,int,ByteOrder,VectorMask) * fromByteBuffer()} as follows: * <pre>{@code * var m = species.maskAll(true); * return fromByteBuffer(species, bb, offset, bo, m); * }</pre> * * @param species species of desired vector * @param bb the byte buffer * @param offset the offset into the byte buffer * @param bo the intended byte order * @return a vector loaded from a byte buffer * @throws IndexOutOfBoundsException * if {@code offset+N*4 < 0} * or {@code offset+N*4 >= bb.limit()} * for any lane {@code N} in the vector */ @ForceInline public static FloatVector fromByteBuffer(VectorSpecies<Float> species, ByteBuffer bb, int offset, ByteOrder bo) { offset = checkFromIndexSize(offset, species.vectorByteSize(), bb.limit()); FloatSpecies vsp = (FloatSpecies) species; return vsp.dummyVector().fromByteBuffer0(bb, offset).maybeSwap(bo); } /** * Loads a vector from a {@linkplain ByteBuffer byte buffer} * starting at an offset into the byte buffer * and using a mask. * Lanes where the mask is unset are filled with the default * value of {@code float} (positive zero). * Bytes are composed into primitive lane elements according * to the specified byte order. * The vector is arranged into lanes according to * <a href="Vector.html#lane-order">memory ordering</a>. * <p> * The following pseudocode illustrates the behavior: * <pre>{@code * FloatBuffer eb = bb.duplicate() * .position(offset) * .order(bo).asFloatBuffer(); * float[] ar = new float[species.length()]; * for (int n = 0; n < ar.length; n++) { * if (m.laneIsSet(n)) { * ar[n] = eb.get(n); * } * } * FloatVector r = FloatVector.fromArray(species, ar, 0); * }</pre> * @implNote * This operation is likely to be more efficient if * the specified byte order is the same as * {@linkplain ByteOrder#nativeOrder() * the platform native order}, * since this method will not need to reorder * the bytes of lane values. * * @param species species of desired vector * @param bb the byte buffer * @param offset the offset into the byte buffer * @param bo the intended byte order * @param m the mask controlling lane selection * @return a vector loaded from a byte buffer * @throws IndexOutOfBoundsException * if {@code offset+N*4 < 0} * or {@code offset+N*4 >= bb.limit()} * for any lane {@code N} in the vector * where the mask is set */ @ForceInline public static FloatVector fromByteBuffer(VectorSpecies<Float> species, ByteBuffer bb, int offset, ByteOrder bo, VectorMask<Float> m) { FloatSpecies vsp = (FloatSpecies) species; if (offset >= 0 && offset <= (bb.limit() - species.vectorByteSize())) { FloatVector zero = vsp.zero(); FloatVector v = zero.fromByteBuffer0(bb, offset); return zero.blend(v.maybeSwap(bo), m); } // FIXME: optimize checkMaskFromIndexSize(offset, vsp, m, 4, bb.limit()); ByteBuffer wb = wrapper(bb, bo); return vsp.ldOp(wb, offset, (AbstractMask<Float>)m, (wb_, o, i) -> wb_.getFloat(o + i * 4)); } // Memory store operations /** * Stores this vector into an array of type {@code float[]} * starting at an offset. * <p> * For each vector lane, where {@code N} is the vector lane index, * the lane element at index {@code N} is stored into the array * element {@code a[offset+N]}. * * @param a the array, of type {@code float[]} * @param offset the offset into the array * @throws IndexOutOfBoundsException * if {@code offset+N < 0} or {@code offset+N >= a.length} * for any lane {@code N} in the vector */ @ForceInline public final void intoArray(float[] a, int offset) { offset = checkFromIndexSize(offset, length(), a.length); FloatSpecies vsp = vspecies(); VectorSupport.store( vsp.vectorType(), vsp.elementType(), vsp.laneCount(), a, arrayAddress(a, offset), this, a, offset, (arr, off, v) -> v.stOp(arr, off, (arr_, off_, i, e) -> arr_[off_ + i] = e)); } /** * Stores this vector into an array of type {@code float[]} * starting at offset and using a mask. * <p> * For each vector lane, where {@code N} is the vector lane index, * the lane element at index {@code N} is stored into the array * element {@code a[offset+N]}. * If the mask lane at {@code N} is unset then the corresponding * array element {@code a[offset+N]} is left unchanged. * <p> * Array range checking is done for lanes where the mask is set. * Lanes where the mask is unset are not stored and do not need * to correspond to legitimate elements of {@code a}. * That is, unset lanes may correspond to array indexes less than * zero or beyond the end of the array. * * @param a the array, of type {@code float[]} * @param offset the offset into the array * @param m the mask controlling lane storage * @throws IndexOutOfBoundsException * if {@code offset+N < 0} or {@code offset+N >= a.length} * for any lane {@code N} in the vector * where the mask is set */ @ForceInline public final void intoArray(float[] a, int offset, VectorMask<Float> m) { if (m.allTrue()) { intoArray(a, offset); } else { // FIXME: optimize FloatSpecies vsp = vspecies(); checkMaskFromIndexSize(offset, vsp, m, 1, a.length); stOp(a, offset, m, (arr, off, i, v) -> arr[off+i] = v); } } /** * Scatters this vector into an array of type {@code float[]} * using indexes obtained by adding a fixed {@code offset} to a * series of secondary offsets from an <em>index map</em>. * The index map is a contiguous sequence of {@code VLENGTH} * elements in a second array of {@code int}s, starting at a given * {@code mapOffset}. * <p> * For each vector lane, where {@code N} is the vector lane index, * the lane element at index {@code N} is stored into the array * element {@code a[f(N)]}, where {@code f(N)} is the * index mapping expression * {@code offset + indexMap[mapOffset + N]]}. * * @param a the array * @param offset an offset to combine with the index map offsets * @param indexMap the index map * @param mapOffset the offset into the index map * @throws IndexOutOfBoundsException * if {@code mapOffset+N < 0} * or if {@code mapOffset+N >= indexMap.length}, * or if {@code f(N)=offset+indexMap[mapOffset+N]} * is an invalid index into {@code a}, * for any lane {@code N} in the vector * @see FloatVector#toIntArray() */ @ForceInline public final void intoArray(float[] a, int offset, int[] indexMap, int mapOffset) { FloatSpecies vsp = vspecies(); IntVector.IntSpecies isp = IntVector.species(vsp.indexShape()); // Index vector: vix[0:n] = i -> offset + indexMap[mo + i] IntVector vix = IntVector .fromArray(isp, indexMap, mapOffset) .add(offset); vix = VectorIntrinsics.checkIndex(vix, a.length); VectorSupport.storeWithMap( vsp.vectorType(), vsp.elementType(), vsp.laneCount(), isp.vectorType(), a, arrayAddress(a, 0), vix, this, a, offset, indexMap, mapOffset, (arr, off, v, map, mo) -> v.stOp(arr, off, (arr_, off_, i, e) -> { int j = map[mo + i]; arr[off + j] = e; })); } /** * Scatters this vector into an array of type {@code float[]}, * under the control of a mask, and * using indexes obtained by adding a fixed {@code offset} to a * series of secondary offsets from an <em>index map</em>. * The index map is a contiguous sequence of {@code VLENGTH} * elements in a second array of {@code int}s, starting at a given * {@code mapOffset}. * <p> * For each vector lane, where {@code N} is the vector lane index, * if the mask lane at index {@code N} is set then * the lane element at index {@code N} is stored into the array * element {@code a[f(N)]}, where {@code f(N)} is the * index mapping expression * {@code offset + indexMap[mapOffset + N]]}. * * @param a the array * @param offset an offset to combine with the index map offsets * @param indexMap the index map * @param mapOffset the offset into the index map * @param m the mask * @throws IndexOutOfBoundsException * if {@code mapOffset+N < 0} * or if {@code mapOffset+N >= indexMap.length}, * or if {@code f(N)=offset+indexMap[mapOffset+N]} * is an invalid index into {@code a}, * for any lane {@code N} in the vector * where the mask is set * @see FloatVector#toIntArray() */ @ForceInline public final void intoArray(float[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Float> m) { if (m.allTrue()) { intoArray(a, offset, indexMap, mapOffset); } else { // FIXME: Cannot vectorize yet, if there's a mask. stOp(a, offset, m, (arr, off, i, e) -> { int j = indexMap[mapOffset + i]; arr[off + j] = e; }); } } /** * {@inheritDoc} <!--workaround--> */ @Override @ForceInline public final void intoByteArray(byte[] a, int offset, ByteOrder bo) { offset = checkFromIndexSize(offset, byteSize(), a.length); maybeSwap(bo).intoByteArray0(a, offset); } /** * {@inheritDoc} <!--workaround--> */ @Override @ForceInline public final void intoByteArray(byte[] a, int offset, ByteOrder bo, VectorMask<Float> m) { if (m.allTrue()) { intoByteArray(a, offset, bo); } else { // FIXME: optimize FloatSpecies vsp = vspecies(); checkMaskFromIndexSize(offset, vsp, m, 4, a.length); ByteBuffer wb = wrapper(a, bo); this.stOp(wb, offset, m, (wb_, o, i, e) -> wb_.putFloat(o + i * 4, e)); } } /** * {@inheritDoc} <!--workaround--> */ @Override @ForceInline public final void intoByteBuffer(ByteBuffer bb, int offset, ByteOrder bo) { if (bb.isReadOnly()) { throw new ReadOnlyBufferException(); } offset = checkFromIndexSize(offset, byteSize(), bb.limit()); maybeSwap(bo).intoByteBuffer0(bb, offset); } /** * {@inheritDoc} <!--workaround--> */ @Override @ForceInline public final void intoByteBuffer(ByteBuffer bb, int offset, ByteOrder bo, VectorMask<Float> m) { if (m.allTrue()) { intoByteBuffer(bb, offset, bo); } else { // FIXME: optimize if (bb.isReadOnly()) { throw new ReadOnlyBufferException(); } FloatSpecies vsp = vspecies(); checkMaskFromIndexSize(offset, vsp, m, 4, bb.limit()); ByteBuffer wb = wrapper(bb, bo); this.stOp(wb, offset, m, (wb_, o, i, e) -> wb_.putFloat(o + i * 4, e)); } } // ================================================ // Low-level memory operations. // // Note that all of these operations *must* inline into a context // where the exact species of the involved vector is a // compile-time constant. Otherwise, the intrinsic generation // will fail and performance will suffer. // // In many cases this is achieved by re-deriving a version of the // method in each concrete subclass (per species). The re-derived // method simply calls one of these generic methods, with exact // parameters for the controlling metadata, which is either a // typed vector or constant species instance. // Unchecked loading operations in native byte order. // Caller is responsible for applying index checks, masking, and // byte swapping. /*package-private*/ abstract FloatVector fromArray0(float[] a, int offset); @ForceInline final FloatVector fromArray0Template(float[] a, int offset) { FloatSpecies vsp = vspecies(); return VectorSupport.load( vsp.vectorType(), vsp.elementType(), vsp.laneCount(), a, arrayAddress(a, offset), a, offset, vsp, (arr, off, s) -> s.ldOp(arr, off, (arr_, off_, i) -> arr_[off_ + i])); } @Override abstract FloatVector fromByteArray0(byte[] a, int offset); @ForceInline final FloatVector fromByteArray0Template(byte[] a, int offset) { FloatSpecies vsp = vspecies(); return VectorSupport.load( vsp.vectorType(), vsp.elementType(), vsp.laneCount(), a, byteArrayAddress(a, offset), a, offset, vsp, (arr, off, s) -> { ByteBuffer wb = wrapper(arr, NATIVE_ENDIAN); return s.ldOp(wb, off, (wb_, o, i) -> wb_.getFloat(o + i * 4)); }); } abstract FloatVector fromByteBuffer0(ByteBuffer bb, int offset); @ForceInline final FloatVector fromByteBuffer0Template(ByteBuffer bb, int offset) { FloatSpecies vsp = vspecies(); return ScopedMemoryAccess.loadFromByteBuffer( vsp.vectorType(), vsp.elementType(), vsp.laneCount(), bb, offset, vsp, (buf, off, s) -> { ByteBuffer wb = wrapper(buf, NATIVE_ENDIAN); return s.ldOp(wb, off, (wb_, o, i) -> wb_.getFloat(o + i * 4)); }); } // Unchecked storing operations in native byte order. // Caller is responsible for applying index checks, masking, and // byte swapping. abstract void intoArray0(float[] a, int offset); @ForceInline final void intoArray0Template(float[] a, int offset) { FloatSpecies vsp = vspecies(); VectorSupport.store( vsp.vectorType(), vsp.elementType(), vsp.laneCount(), a, arrayAddress(a, offset), this, a, offset, (arr, off, v) -> v.stOp(arr, off, (arr_, off_, i, e) -> arr_[off_+i] = e)); } abstract void intoByteArray0(byte[] a, int offset); @ForceInline final void intoByteArray0Template(byte[] a, int offset) { FloatSpecies vsp = vspecies(); VectorSupport.store( vsp.vectorType(), vsp.elementType(), vsp.laneCount(), a, byteArrayAddress(a, offset), this, a, offset, (arr, off, v) -> { ByteBuffer wb = wrapper(arr, NATIVE_ENDIAN); v.stOp(wb, off, (tb_, o, i, e) -> tb_.putFloat(o + i * 4, e)); }); } @ForceInline final void intoByteBuffer0(ByteBuffer bb, int offset) { FloatSpecies vsp = vspecies(); ScopedMemoryAccess.storeIntoByteBuffer( vsp.vectorType(), vsp.elementType(), vsp.laneCount(), this, bb, offset, (buf, off, v) -> { ByteBuffer wb = wrapper(buf, NATIVE_ENDIAN); v.stOp(wb, off, (wb_, o, i, e) -> wb_.putFloat(o + i * 4, e)); }); } // End of low-level memory operations. private static void checkMaskFromIndexSize(int offset, FloatSpecies vsp, VectorMask<Float> m, int scale, int limit) { ((AbstractMask<Float>)m) .checkIndexByLane(offset, limit, vsp.iota(), scale); } @ForceInline private void conditionalStoreNYI(int offset, FloatSpecies vsp, VectorMask<Float> m, int scale, int limit) { if (offset < 0 || offset + vsp.laneCount() * scale > limit) { String msg = String.format("unimplemented: store @%d in [0..%d), %s in %s", offset, limit, m, vsp); throw new AssertionError(msg); } } /*package-private*/ @Override @ForceInline final FloatVector maybeSwap(ByteOrder bo) { if (bo != NATIVE_ENDIAN) { return this.reinterpretAsBytes() .rearrange(swapBytesShuffle()) .reinterpretAsFloats(); } return this; } static final int ARRAY_SHIFT = 31 - Integer.numberOfLeadingZeros(Unsafe.ARRAY_FLOAT_INDEX_SCALE); static final long ARRAY_BASE = Unsafe.ARRAY_FLOAT_BASE_OFFSET; @ForceInline static long arrayAddress(float[] a, int index) { return ARRAY_BASE + (((long)index) << ARRAY_SHIFT); } @ForceInline static long byteArrayAddress(byte[] a, int index) { return Unsafe.ARRAY_BYTE_BASE_OFFSET + index; } // ================================================ /// Reinterpreting view methods: // lanewise reinterpret: viewAsXVector() // keep shape, redraw lanes: reinterpretAsEs() /** * {@inheritDoc} <!--workaround--> */ @ForceInline @Override public final ByteVector reinterpretAsBytes() { // Going to ByteVector, pay close attention to byte order. assert(REGISTER_ENDIAN == ByteOrder.LITTLE_ENDIAN); return asByteVectorRaw(); //return asByteVectorRaw().rearrange(swapBytesShuffle()); } /** * {@inheritDoc} <!--workaround--> */ @ForceInline @Override public final IntVector viewAsIntegralLanes() { LaneType ilt = LaneType.FLOAT.asIntegral(); return (IntVector) asVectorRaw(ilt); } /** * {@inheritDoc} <!--workaround--> */ @ForceInline @Override public final FloatVector viewAsFloatingLanes() { return this; } // ================================================ /// Object methods: toString, equals, hashCode // // Object methods are defined as if via Arrays.toString, etc., // is applied to the array of elements. Two equal vectors // are required to have equal species and equal lane values. /** * Returns a string representation of this vector, of the form * {@code "[0,1,2...]"}, reporting the lane values of this vector, * in lane order. * * The string is produced as if by a call to {@link * java.util.Arrays#toString(float[]) Arrays.toString()}, * as appropriate to the {@code float} array returned by * {@link #toArray this.toArray()}. * * @return a string of the form {@code "[0,1,2...]"} * reporting the lane values of this vector */ @Override @ForceInline public final String toString() { // now that toArray is strongly typed, we can define this return Arrays.toString(toArray()); } /** * {@inheritDoc} <!--workaround--> */ @Override @ForceInline public final boolean equals(Object obj) { if (obj instanceof Vector) { Vector<?> that = (Vector<?>) obj; if (this.species().equals(that.species())) { return this.eq(that.check(this.species())).allTrue(); } } return false; } /** * {@inheritDoc} <!--workaround--> */ @Override @ForceInline public final int hashCode() { // now that toArray is strongly typed, we can define this return Objects.hash(species(), Arrays.hashCode(toArray())); } // ================================================ // Species /** * Class representing {@link FloatVector}'s of the same {@link VectorShape VectorShape}. */ /*package-private*/ static final class FloatSpecies extends AbstractSpecies<Float> { private FloatSpecies(VectorShape shape, Class<? extends FloatVector> vectorType, Class<? extends AbstractMask<Float>> maskType, Function<Object, FloatVector> vectorFactory) { super(shape, LaneType.of(float.class), vectorType, maskType, vectorFactory); assert(this.elementSize() == Float.SIZE); } // Specializing overrides: @Override @ForceInline public final Class<Float> elementType() { return float.class; } @Override @ForceInline final Class<Float> genericElementType() { return Float.class; } @SuppressWarnings("unchecked") @Override @ForceInline public final Class<? extends FloatVector> vectorType() { return (Class<? extends FloatVector>) vectorType; } @Override @ForceInline public final long checkValue(long e) { longToElementBits(e); // only for exception return e; } /*package-private*/ @Override @ForceInline final FloatVector broadcastBits(long bits) { return (FloatVector) VectorSupport.broadcastCoerced( vectorType, float.class, laneCount, bits, this, (bits_, s_) -> s_.rvOp(i -> bits_)); } /*package-private*/ @ForceInline final FloatVector broadcast(float e) { return broadcastBits(toBits(e)); } @Override @ForceInline public final FloatVector broadcast(long e) { return broadcastBits(longToElementBits(e)); } /*package-private*/ final @Override @ForceInline long longToElementBits(long value) { // Do the conversion, and then test it for failure. float e = (float) value; if ((long) e != value) { throw badElementBits(value, e); } return toBits(e); } /*package-private*/ @ForceInline static long toIntegralChecked(float e, boolean convertToInt) { long value = convertToInt ? (int) e : (long) e; if ((float) value != e) { throw badArrayBits(e, convertToInt, value); } return value; } /* this non-public one is for internal conversions */ @Override @ForceInline final FloatVector fromIntValues(int[] values) { VectorIntrinsics.requireLength(values.length, laneCount); float[] va = new float[laneCount()]; for (int i = 0; i < va.length; i++) { int lv = values[i]; float v = (float) lv; va[i] = v; if ((int)v != lv) { throw badElementBits(lv, v); } } return dummyVector().fromArray0(va, 0); } // Virtual constructors @ForceInline @Override final public FloatVector fromArray(Object a, int offset) { // User entry point: Be careful with inputs. return FloatVector .fromArray(this, (float[]) a, offset); } @ForceInline @Override final FloatVector dummyVector() { return (FloatVector) super.dummyVector(); } /*package-private*/ final @Override @ForceInline FloatVector rvOp(RVOp f) { float[] res = new float[laneCount()]; for (int i = 0; i < res.length; i++) { int bits = (int) f.apply(i); res[i] = fromBits(bits); } return dummyVector().vectorFactory(res); } FloatVector vOp(FVOp f) { float[] res = new float[laneCount()]; for (int i = 0; i < res.length; i++) { res[i] = f.apply(i); } return dummyVector().vectorFactory(res); } FloatVector vOp(VectorMask<Float> m, FVOp f) { float[] res = new float[laneCount()]; boolean[] mbits = ((AbstractMask<Float>)m).getBits(); for (int i = 0; i < res.length; i++) { if (mbits[i]) { res[i] = f.apply(i); } } return dummyVector().vectorFactory(res); } /*package-private*/ @ForceInline <M> FloatVector ldOp(M memory, int offset, FLdOp<M> f) { return dummyVector().ldOp(memory, offset, f); } /*package-private*/ @ForceInline <M> FloatVector ldOp(M memory, int offset, AbstractMask<Float> m, FLdOp<M> f) { return dummyVector().ldOp(memory, offset, m, f); } /*package-private*/ @ForceInline <M> void stOp(M memory, int offset, FStOp<M> f) { dummyVector().stOp(memory, offset, f); } /*package-private*/ @ForceInline <M> void stOp(M memory, int offset, AbstractMask<Float> m, FStOp<M> f) { dummyVector().stOp(memory, offset, m, f); } // N.B. Make sure these constant vectors and // masks load up correctly into registers. // // Also, see if we can avoid all that switching. // Could we cache both vectors and both masks in // this species object? // Zero and iota vector access @Override @ForceInline public final FloatVector zero() { if ((Class<?>) vectorType() == FloatMaxVector.class) return FloatMaxVector.ZERO; switch (vectorBitSize()) { case 64: return Float64Vector.ZERO; case 128: return Float128Vector.ZERO; case 256: return Float256Vector.ZERO; case 512: return Float512Vector.ZERO; } throw new AssertionError(); } @Override @ForceInline public final FloatVector iota() { if ((Class<?>) vectorType() == FloatMaxVector.class) return FloatMaxVector.IOTA; switch (vectorBitSize()) { case 64: return Float64Vector.IOTA; case 128: return Float128Vector.IOTA; case 256: return Float256Vector.IOTA; case 512: return Float512Vector.IOTA; } throw new AssertionError(); } // Mask access @Override @ForceInline public final VectorMask<Float> maskAll(boolean bit) { if ((Class<?>) vectorType() == FloatMaxVector.class) return FloatMaxVector.FloatMaxMask.maskAll(bit); switch (vectorBitSize()) { case 64: return Float64Vector.Float64Mask.maskAll(bit); case 128: return Float128Vector.Float128Mask.maskAll(bit); case 256: return Float256Vector.Float256Mask.maskAll(bit); case 512: return Float512Vector.Float512Mask.maskAll(bit); } throw new AssertionError(); } } /** * Finds a species for an element type of {@code float} and shape. * * @param s the shape * @return a species for an element type of {@code float} and shape * @throws IllegalArgumentException if no such species exists for the shape */ static FloatSpecies species(VectorShape s) { Objects.requireNonNull(s); switch (s.switchKey) { case VectorShape.SK_64_BIT: return (FloatSpecies) SPECIES_64; case VectorShape.SK_128_BIT: return (FloatSpecies) SPECIES_128; case VectorShape.SK_256_BIT: return (FloatSpecies) SPECIES_256; case VectorShape.SK_512_BIT: return (FloatSpecies) SPECIES_512; case VectorShape.SK_Max_BIT: return (FloatSpecies) SPECIES_MAX; default: throw new IllegalArgumentException("Bad shape: " + s); } } /** Species representing {@link FloatVector}s of {@link VectorShape#S_64_BIT VectorShape.S_64_BIT}. */ public static final VectorSpecies<Float> SPECIES_64 = new FloatSpecies(VectorShape.S_64_BIT, Float64Vector.class, Float64Vector.Float64Mask.class, Float64Vector::new); /** Species representing {@link FloatVector}s of {@link VectorShape#S_128_BIT VectorShape.S_128_BIT}. */ public static final VectorSpecies<Float> SPECIES_128 = new FloatSpecies(VectorShape.S_128_BIT, Float128Vector.class, Float128Vector.Float128Mask.class, Float128Vector::new); /** Species representing {@link FloatVector}s of {@link VectorShape#S_256_BIT VectorShape.S_256_BIT}. */ public static final VectorSpecies<Float> SPECIES_256 = new FloatSpecies(VectorShape.S_256_BIT, Float256Vector.class, Float256Vector.Float256Mask.class, Float256Vector::new); /** Species representing {@link FloatVector}s of {@link VectorShape#S_512_BIT VectorShape.S_512_BIT}. */ public static final VectorSpecies<Float> SPECIES_512 = new FloatSpecies(VectorShape.S_512_BIT, Float512Vector.class, Float512Vector.Float512Mask.class, Float512Vector::new); /** Species representing {@link FloatVector}s of {@link VectorShape#S_Max_BIT VectorShape.S_Max_BIT}. */ public static final VectorSpecies<Float> SPECIES_MAX = new FloatSpecies(VectorShape.S_Max_BIT, FloatMaxVector.class, FloatMaxVector.FloatMaxMask.class, FloatMaxVector::new); /** * Preferred species for {@link FloatVector}s. * A preferred species is a species of maximal bit-size for the platform. */ public static final VectorSpecies<Float> SPECIES_PREFERRED = (FloatSpecies) VectorSpecies.ofPreferred(float.class); }
⏎ jdk/incubator/vector/FloatVector.java
Or download all of them as a single archive file:
File name: jdk.incubator.vector-17.0.5-src.zip File size: 350622 bytes Release date: 2022-09-13 Download
⇒ JDK 17 jdk.internal.ed.jmod - Internal Editor Module
2023-10-04, 4035👍, 0💬
Popular Posts:
What Is ojdbc8.jar for Oracle 12c R2? ojdbc8.jar for Oracle 12c R2 is the JAR files of ojdbc.jar, JD...
Provides a simple high-level Http server API, which can be used to build embedded HTTP servers. Both...
XOM™ is a new XML object model. It is an open source (LGPL), tree-based API for processing XML with ...
JDK 17 jdk.compiler.jmod is the JMOD file for JDK 17 Compiler tool, which can be invoked by the "jav...
Java Cryptography Extension 1.2.2 JAR File Size and Download Location: File name: jce.jar, jce-1.2.2...