1 /*
2 * Copyright (c) 2018, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have
23 * questions.
24 */
25 package jdk.incubator.vector;
26
27 /**
28 * Operations on vectors that are not intrinsic candidates
29 */
30 @SuppressWarnings("cast")
31 public final class FloatVectorHelper {
32
33 private FloatVectorHelper() {}
34
35 public interface BinaryOp {
36 float apply(int i, float a, float b);
37 }
38
39 public interface UnaryOp {
40 float apply(int i, float a);
41 }
42
43 public static
44 FloatVector map(FloatVector va, FloatVector vb, BinaryOp op) {
45 return va.bOp(vb, (i, a, b) -> op.apply(i, a, b));
46 }
47
48 public static
49 FloatVector map(FloatVector va, FloatVector vb, Vector.Mask<Float> m, BinaryOp op) {
50 return va.bOp(vb, m, (i, a, b) -> op.apply(i, a, b));
51 }
52
53 public static
54 FloatVector map(FloatVector va, UnaryOp op) {
55 return va.uOp((i, a) -> op.apply(i, a));
56 }
57
58 public static
59 FloatVector map(FloatVector va, Vector.Mask<Float> m, UnaryOp op) {
60 return va.uOp(m, (i, a) -> op.apply(i, a));
61 }
62
63
64
65 public static
66 FloatVector ceil(FloatVector va) {
67 return va.uOp((i, a) -> (float) Math.ceil((double) a));
68 }
69
70 public static
71 FloatVector ceil(FloatVector va, Vector.Mask<Float> m) {
72 return va.uOp(m, (i, a) -> (float) Math.ceil((double) a));
73 }
74
75 public static
76 FloatVector copySign(FloatVector va, FloatVector vb) {
77 return va.bOp(vb, (i, a, b) -> (float) Math.copySign((double) a, (double) b));
78 }
79
80 public static
81 FloatVector copySign(FloatVector va, FloatVector vb, Vector.Mask<Float> m) {
82 return va.bOp(vb, m, (i, a, b) -> (float) Math.copySign((double) a, (double) b));
83 }
84
85 public static
86 FloatVector floor(FloatVector va) {
87 return va.uOp((i, a) -> (float) Math.floor((double) a));
88 }
89
90 public static
91 FloatVector floor(FloatVector va, Vector.Mask<Float> m) {
92 return va.uOp(m, (i, a) -> (float) Math.floor((double) a));
93 }
94
95 public static
96 FloatVector getExponent(FloatVector va) {
97 return va.uOp((i, a) -> (float) Math.getExponent((double) a));
98 }
99
100 public static
101 FloatVector getExponent(FloatVector va, Vector.Mask<Float> m) {
102 return va.uOp(m, (i, a) -> (float) Math.getExponent((double) a));
103 }
104
105 public static
106 FloatVector IEEEremainder(FloatVector va, FloatVector vb) {
107 return va.bOp(vb, (i, a, b) -> (float) Math.IEEEremainder((double) a, (double) b));
108 }
109
110 public static
111 FloatVector IEEEremainder(FloatVector va, FloatVector vb, Vector.Mask<Float> m) {
112 return va.bOp(vb, m, (i, a, b) -> (float) Math.IEEEremainder((double) a, (double) b));
113 }
114
115 public static
116 FloatVector nextAfter(FloatVector va, FloatVector vb) {
117 return va.bOp(vb, (i, a, b) -> (float) Math.nextAfter((double) a, (double) b));
118 }
119
120 public static
121 FloatVector nextAfter(FloatVector va, FloatVector vb, Vector.Mask<Float> m) {
122 return va.bOp(vb, m, (i, a, b) -> (float) Math.nextAfter((double) a, (double) b));
123 }
124
125 public static
126 FloatVector nextDown(FloatVector va) {
127 return va.uOp((i, a) -> (float) Math.nextDown((double) a));
128 }
129
130 public static
131 FloatVector nextDown(FloatVector va, Vector.Mask<Float> m) {
132 return va.uOp(m, (i, a) -> (float) Math.nextDown((double) a));
133 }
134
135 public static
136 FloatVector nextUp(FloatVector va) {
137 return va.uOp((i, a) -> (float) Math.nextUp((double) a));
138 }
139
140 public static
141 FloatVector nextUp(FloatVector va, Vector.Mask<Float> m) {
142 return va.uOp(m, (i, a) -> (float) Math.nextUp((double) a));
143 }
144
145 public static
146 FloatVector rint(FloatVector va) {
147 return va.uOp((i, a) -> (float) Math.rint((double) a));
148 }
149
150 public static
151 FloatVector rint(FloatVector va, Vector.Mask<Float> m) {
152 return va.uOp(m, (i, a) -> (float) Math.rint((double) a));
153 }
154
155 public static
156 FloatVector round(FloatVector va) {
157 return va.uOp((i, a) -> (float) Math.round((double) a));
158 }
159
160 public static
161 FloatVector round(FloatVector va, Vector.Mask<Float> m) {
162 return va.uOp(m, (i, a) -> (float) Math.round((double) a));
163 }
164
165 public static
166 FloatVector scalb(Vector<Integer> o) {
167 throw new UnsupportedOperationException("Scalb not implemented yet.");
168 }
169
170 public static
171 FloatVector scalb(Vector<Integer> o, Vector.Mask<Float> m) {
172 throw new UnsupportedOperationException("Scalb not implemented yet.");
173 }
174
175 public static
176 FloatVector signum(FloatVector va) {
177 return va.uOp((i, a) -> (float) Math.signum((double) a));
178 }
179
180 public static
181 FloatVector signum(FloatVector va, Vector.Mask<Float> m) {
182 return va.uOp(m, (i, a) -> (float) Math.signum((double) a));
183 }
184
185 public static
186 FloatVector toDegrees(FloatVector va) {
187 return va.uOp((i, a) -> (float) Math.toDegrees((double) a));
188 }
189
190 public static
191 FloatVector toDegrees(FloatVector va, Vector.Mask<Float> m) {
192 return va.uOp(m, (i, a) -> (float) Math.toDegrees((double) a));
193 }
194
195 public static
196 FloatVector toRadians(FloatVector va) {
197 return va.uOp((i, a) -> (float) Math.toRadians((double) a));
198 }
199
200 public static
201 FloatVector toRadians(FloatVector va, Vector.Mask<Float> m) {
202 return va.uOp(m, (i, a) -> (float) Math.toRadians((double) a));
203 }
204
205 public static
206 FloatVector ulp(FloatVector va) {
207 return va.uOp((i, a) -> (float) Math.ulp((double) a));
208 }
209
210 public static
211 FloatVector ulp(FloatVector va, Vector.Mask<Float> m) {
212 return va.uOp(m, (i, a) -> (float) Math.ulp((double) a));
213 }
214
215 }