Differential D41843 Diff 139043 libcxx/test/std/experimental/simd/simd.whereexpr/where_expression.pass.cpp

# Changeset View

Changeset View

# Standalone View

Standalone View

# libcxx/test/std/experimental/simd/simd.whereexpr/where_expression.pass.cpp

- This file was added.

1 | //===----------------------------------------------------------------------===// | ||||
---|---|---|---|---|---|

2 | // | ||||

3 | // The LLVM Compiler Infrastructure | ||||

4 | // | ||||

5 | // This file is dual licensed under the MIT and the University of Illinois Open | ||||

6 | // Source Licenses. See LICENSE.TXT for details. | ||||

7 | // | ||||

8 | //===----------------------------------------------------------------------===// | ||||

9 | | ||||

10 | // UNSUPPORTED: c++98, c++03 | ||||

11 | | ||||

12 | // <experimental/simd> | ||||

13 | // | ||||

14 | // // [simd.whereexpr] | ||||

15 | // template <class M, class T> | ||||

16 | // class where_expression : public const_where_expression<M, T> { | ||||

17 | // public: | ||||

18 | // where_expression(const where_expression&) = delete; | ||||

19 | // where_expression& operator=(const where_expression&) = delete; | ||||

20 | // template <class U> void operator=(U&& x); | ||||

21 | // template <class U> void operator+=(U&& x); | ||||

22 | // template <class U> void operator-=(U&& x); | ||||

23 | // template <class U> void operator*=(U&& x); | ||||

24 | // template <class U> void operator/=(U&& x); | ||||

25 | // template <class U> void operator%=(U&& x); | ||||

26 | // template <class U> void operator&=(U&& x); | ||||

27 | // template <class U> void operator|=(U&& x); | ||||

28 | // template <class U> void operator^=(U&& x); | ||||

29 | // template <class U> void operator<<=(U&& x); | ||||

30 | // template <class U> void operator>>=(U&& x); | ||||

31 | // void operator++(); | ||||

32 | // void operator++(int); | ||||

33 | // void operator--(); | ||||

34 | // void operator--(int); | ||||

35 | // template <class U, class Flags> void copy_from(const U* mem, Flags); | ||||

36 | // }; | ||||

37 | | ||||

38 | #include <experimental/simd> | ||||

39 | #include <cassert> | ||||

40 | #include <cstdint> | ||||

41 | #include <algorithm> | ||||

42 | | ||||

43 | using namespace std::experimental::parallelism_v2; | ||||

44 | | ||||

45 | void test_operators_simd() { | ||||

46 | { | ||||

47 | fixed_size_simd<int, 4> a([](int i) { return i; }); | ||||

48 | where(a < 2, a) = -1; | ||||

49 | assert(a[0] == -1); | ||||

50 | assert(a[1] == -1); | ||||

51 | assert(a[2] == 2); | ||||

52 | assert(a[3] == 3); | ||||

53 | } | ||||

54 | { | ||||

55 | fixed_size_simd<int, 4> a([](int i) { return i; }); | ||||

56 | where(a < 2, a) = fixed_size_simd<int, 4>(-1); | ||||

57 | assert(a[0] == -1); | ||||

58 | assert(a[1] == -1); | ||||

59 | assert(a[2] == 2); | ||||

60 | assert(a[3] == 3); | ||||

61 | } | ||||

62 | { | ||||

63 | fixed_size_simd<int, 4> a([](int i) { return i; }); | ||||

64 | where(a < 2, a) += -1; | ||||

65 | assert(a[0] == -1); | ||||

66 | assert(a[1] == 0); | ||||

67 | assert(a[2] == 2); | ||||

68 | assert(a[3] == 3); | ||||

69 | } | ||||

70 | { | ||||

71 | fixed_size_simd<int, 4> a([](int i) { return i; }); | ||||

72 | where(a < 2, a) += fixed_size_simd<int, 4>(-1); | ||||

73 | assert(a[0] == -1); | ||||

74 | assert(a[1] == 0); | ||||

75 | assert(a[2] == 2); | ||||

76 | assert(a[3] == 3); | ||||

77 | } | ||||

78 | { | ||||

79 | fixed_size_simd<int, 4> a([](int i) { return i; }); | ||||

80 | where(a < 2, a) -= -1; | ||||

81 | assert(a[0] == 1); | ||||

82 | assert(a[1] == 2); | ||||

83 | assert(a[2] == 2); | ||||

84 | assert(a[3] == 3); | ||||

85 | } | ||||

86 | { | ||||

87 | fixed_size_simd<int, 4> a([](int i) { return i; }); | ||||

88 | where(a < 2, a) -= fixed_size_simd<int, 4>(-1); | ||||

89 | assert(a[0] == 1); | ||||

90 | assert(a[1] == 2); | ||||

91 | assert(a[2] == 2); | ||||

92 | assert(a[3] == 3); | ||||

93 | } | ||||

94 | { | ||||

95 | fixed_size_simd<int, 4> a([](int i) { return i; }); | ||||

96 | where(a < 2, a) *= -1; | ||||

97 | assert(a[0] == 0); | ||||

98 | assert(a[1] == -1); | ||||

99 | assert(a[2] == 2); | ||||

100 | assert(a[3] == 3); | ||||

101 | } | ||||

102 | { | ||||

103 | fixed_size_simd<int, 4> a([](int i) { return i; }); | ||||

104 | where(a < 2, a) *= fixed_size_simd<int, 4>(-1); | ||||

105 | assert(a[0] == 0); | ||||

106 | assert(a[1] == -1); | ||||

107 | assert(a[2] == 2); | ||||

108 | assert(a[3] == 3); | ||||

109 | } | ||||

110 | { | ||||

111 | fixed_size_simd<int, 4> a([](int i) { return 3 * i; }); | ||||

112 | where(a >= 6, a) /= 2; | ||||

113 | assert(a[0] == 0); | ||||

114 | assert(a[1] == 3); | ||||

115 | assert(a[2] == 3); | ||||

116 | assert(a[3] == 4); | ||||

117 | } | ||||

118 | { | ||||

119 | fixed_size_simd<int, 4> a([](int i) { return 3 * i; }); | ||||

120 | where(a >= 6, a) /= fixed_size_simd<int, 4>(2); | ||||

121 | assert(a[0] == 0); | ||||

122 | assert(a[1] == 3); | ||||

123 | assert(a[2] == 3); | ||||

124 | assert(a[3] == 4); | ||||

125 | } | ||||

126 | { | ||||

127 | fixed_size_simd<int, 4> a([](int i) { return i; }); | ||||

128 | where(a % 2 == 1, a) /= | ||||

129 | fixed_size_simd<int, 4>([](int i) { return i % 2 * 2; }); | ||||

130 | assert(a[0] == 0); | ||||

131 | assert(a[1] == 0); | ||||

132 | assert(a[2] == 2); | ||||

133 | assert(a[3] == 1); | ||||

134 | } | ||||

135 | { | ||||

136 | fixed_size_simd<int, 4> a([](int i) { return 3 * i; }); | ||||

137 | where(a >= 6, a) %= 2; | ||||

138 | assert(a[0] == 0); | ||||

139 | assert(a[1] == 3); | ||||

140 | assert(a[2] == 0); | ||||

141 | assert(a[3] == 1); | ||||

142 | } | ||||

143 | { | ||||

144 | fixed_size_simd<int, 4> a([](int i) { return 3 * i; }); | ||||

145 | where(a >= 6, a) %= fixed_size_simd<int, 4>(2); | ||||

146 | assert(a[0] == 0); | ||||

147 | assert(a[1] == 3); | ||||

148 | assert(a[2] == 0); | ||||

149 | assert(a[3] == 1); | ||||

150 | } | ||||

151 | { | ||||

152 | fixed_size_simd<int, 4> a([](int i) { return i; }); | ||||

153 | where(a % 2 == 1, a) %= | ||||

154 | fixed_size_simd<int, 4>([](int i) { return i % 2 * 2; }); | ||||

155 | assert(a[0] == 0); | ||||

156 | assert(a[1] == 1); | ||||

157 | assert(a[2] == 2); | ||||

158 | assert(a[3] == 1); | ||||

159 | } | ||||

160 | { | ||||

161 | fixed_size_simd<int, 4> a([](int i) { return i; }); | ||||

162 | where(a > -2, a) &= 1; | ||||

163 | assert(a[0] == 0); | ||||

164 | assert(a[1] == 1); | ||||

165 | assert(a[2] == 0); | ||||

166 | assert(a[3] == 1); | ||||

167 | } | ||||

168 | { | ||||

169 | fixed_size_simd<int, 4> a([](int i) { return i; }); | ||||

170 | where(a >= 2, a) &= fixed_size_simd<int, 4>(1); | ||||

171 | assert(a[0] == 0); | ||||

172 | assert(a[1] == 1); | ||||

173 | assert(a[2] == 0); | ||||

174 | assert(a[3] == 1); | ||||

175 | } | ||||

176 | { | ||||

177 | fixed_size_simd<int, 4> a([](int i) { return i; }); | ||||

178 | where(a < 2, a) |= 2; | ||||

179 | assert(a[0] == 2); | ||||

180 | assert(a[1] == 3); | ||||

181 | assert(a[2] == 2); | ||||

182 | assert(a[3] == 3); | ||||

183 | } | ||||

184 | { | ||||

185 | fixed_size_simd<int, 4> a([](int i) { return i; }); | ||||

186 | where(a < 2, a) |= fixed_size_simd<int, 4>(2); | ||||

187 | assert(a[0] == 2); | ||||

188 | assert(a[1] == 3); | ||||

189 | assert(a[2] == 2); | ||||

190 | assert(a[3] == 3); | ||||

191 | } | ||||

192 | { | ||||

193 | fixed_size_simd<int, 4> a([](int i) { return i; }); | ||||

194 | where(a < 2, a) ^= 1; | ||||

195 | assert(a[0] == 1); | ||||

196 | assert(a[1] == 0); | ||||

197 | assert(a[2] == 2); | ||||

198 | assert(a[3] == 3); | ||||

199 | } | ||||

200 | { | ||||

201 | fixed_size_simd<int, 4> a([](int i) { return i; }); | ||||

202 | where(a < 2, a) ^= fixed_size_simd<int, 4>(1); | ||||

203 | assert(a[0] == 1); | ||||

204 | assert(a[1] == 0); | ||||

205 | assert(a[2] == 2); | ||||

206 | assert(a[3] == 3); | ||||

207 | } | ||||

208 | { | ||||

209 | fixed_size_simd<int, 4> a([](int i) { return i; }); | ||||

210 | where(a < 2, a) <<= 1; | ||||

211 | assert(a[0] == 0); | ||||

212 | assert(a[1] == 2); | ||||

213 | assert(a[2] == 2); | ||||

214 | assert(a[3] == 3); | ||||

215 | } | ||||

216 | { | ||||

217 | fixed_size_simd<int, 4> a([](int i) { return i; }); | ||||

218 | where(a < 2, a) <<= fixed_size_simd<int, 4>(1); | ||||

219 | assert(a[0] == 0); | ||||

220 | assert(a[1] == 2); | ||||

221 | assert(a[2] == 2); | ||||

222 | assert(a[3] == 3); | ||||

223 | } | ||||

224 | { | ||||

225 | fixed_size_simd<int, 4> a([](int i) { return 2 * i; }); | ||||

226 | where(a < 4, a) >>= 1; | ||||

227 | assert(a[0] == 0); | ||||

228 | assert(a[1] == 1); | ||||

229 | assert(a[2] == 4); | ||||

230 | assert(a[3] == 6); | ||||

231 | } | ||||

232 | { | ||||

233 | fixed_size_simd<int, 4> a([](int i) { return 2 * i; }); | ||||

234 | where(a < 4, a) >>= fixed_size_simd<int, 4>(1); | ||||

235 | assert(a[0] == 0); | ||||

236 | assert(a[1] == 1); | ||||

237 | assert(a[2] == 4); | ||||

238 | assert(a[3] == 6); | ||||

239 | } | ||||

240 | } | ||||

241 | | ||||

242 | void test_operators_mask() { | ||||

243 | { | ||||

244 | fixed_size_simd_mask<int, 4> a; | ||||

245 | a[0] = false; | ||||

246 | a[1] = true; | ||||

247 | a[2] = true; | ||||

248 | a[3] = false; | ||||

249 | where(a, a) = fixed_size_simd_mask<int, 4>(false); | ||||

250 | assert(!a[0]); | ||||

251 | assert(!a[1]); | ||||

252 | assert(!a[2]); | ||||

253 | assert(!a[3]); | ||||

254 | } | ||||

255 | { | ||||

256 | fixed_size_simd_mask<int, 4> a; | ||||

257 | a[0] = false; | ||||

258 | a[1] = true; | ||||

259 | a[2] = true; | ||||

260 | a[3] = false; | ||||

261 | where(a, a) &= fixed_size_simd_mask<int, 4>(false); | ||||

262 | assert(!a[0]); | ||||

263 | assert(!a[1]); | ||||

264 | assert(!a[2]); | ||||

265 | assert(!a[3]); | ||||

266 | } | ||||

267 | { | ||||

268 | fixed_size_simd_mask<int, 4> a; | ||||

269 | a[0] = false; | ||||

270 | a[1] = true; | ||||

271 | a[2] = true; | ||||

272 | a[3] = false; | ||||

273 | where(!a, a) |= fixed_size_simd_mask<int, 4>(true); | ||||

274 | assert(a[0]); | ||||

275 | assert(a[1]); | ||||

276 | assert(a[2]); | ||||

277 | assert(a[3]); | ||||

278 | } | ||||

279 | { | ||||

280 | fixed_size_simd_mask<int, 4> a; | ||||

281 | a[0] = false; | ||||

282 | a[1] = true; | ||||

283 | a[2] = true; | ||||

284 | a[3] = false; | ||||

285 | where(a, a) ^= fixed_size_simd_mask<int, 4>(true); | ||||

286 | assert(!a[0]); | ||||

287 | assert(!a[1]); | ||||

288 | assert(!a[2]); | ||||

289 | assert(!a[3]); | ||||

290 | } | ||||

291 | { | ||||

292 | fixed_size_simd_mask<int, 4> a; | ||||

293 | a[0] = false; | ||||

294 | a[1] = true; | ||||

295 | a[2] = true; | ||||

296 | a[3] = false; | ||||

297 | where(!a, a) ^= fixed_size_simd_mask<int, 4>(true); | ||||

298 | assert(a[0]); | ||||

299 | assert(a[1]); | ||||

300 | assert(a[2]); | ||||

301 | assert(a[3]); | ||||

302 | } | ||||

303 | } | ||||

304 | | ||||

305 | void test_copy_from() { | ||||

306 | { | ||||

307 | const int buffer[] = {-1, -2, -3, -4}; | ||||

308 | fixed_size_simd<int, 4> a([](int i) { return i; }); | ||||

309 | where(a < 2, a).copy_from(buffer, element_aligned_tag()); | ||||

310 | assert(a[0] == -1); | ||||

311 | assert(a[1] == -2); | ||||

312 | assert(a[2] == 2); | ||||

313 | assert(a[3] == 3); | ||||

314 | } | ||||

315 | { | ||||

316 | const int buffer[] = {-1, -2, -3, -4}; | ||||

317 | fixed_size_simd<int, 4> a([](int i) { return i; }); | ||||

318 | where(a >= 2, a).copy_from(buffer, element_aligned_tag()); | ||||

319 | assert(a[0] == 0); | ||||

320 | assert(a[1] == 1); | ||||

321 | assert(a[2] == -3); | ||||

322 | assert(a[3] == -4); | ||||

323 | } | ||||

324 | { | ||||

325 | fixed_size_simd_mask<int, 4> a; | ||||

326 | const bool input[] = {false, true, true, false}; | ||||

327 | a.copy_from(input, element_aligned_tag()); | ||||

328 | | ||||

329 | const bool buffer[] = {true, true, false, false}; | ||||

330 | where(a, a).copy_from(buffer, element_aligned_tag()); | ||||

331 | assert(!a[0]); | ||||

332 | assert(a[1]); | ||||

333 | assert(!a[2]); | ||||

334 | assert(!a[3]); | ||||

335 | } | ||||

336 | { | ||||

337 | fixed_size_simd_mask<int, 4> a; | ||||

338 | const bool input[] = {false, true, true, false}; | ||||

339 | a.copy_from(input, element_aligned_tag()); | ||||

340 | | ||||

341 | const bool buffer[] = {true, true, false, false}; | ||||

342 | where(!a, a).copy_from(buffer, element_aligned_tag()); | ||||

343 | assert(a[0]); | ||||

344 | assert(a[1]); | ||||

345 | assert(a[2]); | ||||

346 | assert(!a[3]); | ||||

347 | } | ||||

348 | { | ||||

349 | const int b = 1; | ||||

350 | int a = 3; | ||||

351 | where(true, a).copy_from(&b, element_aligned_tag()); | ||||

352 | assert(a == 1); | ||||

353 | } | ||||

354 | { | ||||

355 | const int b = 1; | ||||

356 | int a = 3; | ||||

357 | where(false, a).copy_from(&b, element_aligned_tag()); | ||||

358 | assert(b == 1); | ||||

359 | } | ||||

360 | } | ||||

361 | | ||||

362 | int main() { | ||||

363 | test_operators_simd(); | ||||

364 | test_operators_mask(); | ||||

365 | test_copy_from(); | ||||

366 | } |