107. Multiplying matrices via Vector API
Let’s consider two matrices of 4×4 denoted as X and Y. The Z=X*Y is:
Figure 5.10 – Multiplying two matrices (X * Y = Z)
Multiplying X with Y is about multiplying the first row from X with the first column from Y, the second row from X with the second column from Y, and so on. For instance, (1 x 3) + (2 x 7) + (5 x 5) + (4 x 5) = 3 + 14 + 25 + 20 = 62. Basically, we repeatedly apply FMA computation and fill up Z with the results.In this context, and based on the previous problem about computing FMA, we can produce the following code for multiplying X with Y:
private static final VectorSpecies<Float> VS
= FloatVector.SPECIES_PREFERRED;
public static float[] mulMatrix(
float[] x, float[] y, int size) {
final int upperBound = VS.loopBound(size);
float[] z = new float[size * size];
for (int i = 0; i < size; i++) {
for (int k = 0; k < size; k++) {
float elem = x[i * size + k];
FloatVector eVector = FloatVector.broadcast(VS, elem);
for (int j = 0; j < upperBound; j += VS.length()) {
FloatVector yVector = FloatVector.fromArray(
VS, y, k * size + j);
FloatVector zVector = FloatVector.fromArray(
VS, z, i * size + j);
zVector = eVector.fma(yVector, zVector);
zVector.intoArray(z, i * size + j);
}
}
}
return z;
}
In the bundled code, you can find this example next to another one using SPECIES_512.
108. Hooking the image negative filter with Vector API
An image is basically a matrix of pixels represented in the ARGB spectrum (Alpha, Red, Green, Blue). For instance, an image of 232×290 can be represented as a matrix of 67,280 pixels. Applying specific filters (sepia, negative, grayscale, and so on) to an image typically require processing each pixel from this matrix and performing certain calculations. For instance, the algorithm for applying the negative filter to an image can be resumed as follows:
Figure 5.11 – Apply the negative filter effect to an image
For each pixel, we extract the color components A, R, G, and B. We subtract the R, G, and B values from 255, and finally, we set the new value to the current pixel.Let’s assume that we have an array (pixel[]) containing all pixels of an image. Next, we want to pass pixel[] as an argument to a method powered by Vector API capable to apply the negative filter and setting the new values directly in pixel[].Here is a possible implementation:
private static final VectorSpecies<Integer> VS
= IntVector.SPECIES_PREFERRED;
public static void negativeFilter(
int pixel[], int width, int height) {
for (int i = 0; i <= (width * height – VS.length());
i += VS.length()) {
IntVector alphaVector = IntVector.fromArray(VS, pixel, i)
.lanewise(VectorOperators.LSHR, 24).and(0xff);
IntVector redVector = IntVector.fromArray(VS, pixel, i)
.lanewise(VectorOperators.LSHR, 16).and(0xff);
IntVector greenVector = IntVector.fromArray(VS, pixel, i)
.lanewise(VectorOperators.LSHR, 8).and(0xff);
IntVector blueVector = IntVector.fromArray(VS, pixel, i)
.and(0xff);
IntVector subAlphaVector
= alphaVector.lanewise(VectorOperators.LSHL, 24);
IntVector subRedVector = redVector.broadcast(255)
.sub(redVector).lanewise(VectorOperators.LSHL, 16);
IntVector subGreenVector = greenVector.broadcast(255)
.sub(greenVector).lanewise(VectorOperators.LSHL, 8);
IntVector subBlueVector
= blueVector.broadcast(255).sub(blueVector);
IntVector resultVector = subAlphaVector.or(subRedVector)
.or(subGreenVector).or(subBlueVector);
resultVector.intoArray(pixel, i);
}
}
In the first part, we extract A, R, G, and B in four vectors (alphaVector, redVector, greenVector, and blueVecor) by applying the leanwise operation LSHR. Afterward, we subtract R, G, and B from 255 and compute the new R, G, and B by applying the leanwise operation LSHL. Next, we compute the new color by applying the bitwise logical disjunction (|) between the new A, R, G, and B. Finally, we set the new color into the pixel[] array.Note for my: –add-modules=jdk.incubator.vector