packed.h (60109B) - Raw
1 /*! @header 2 * This header defines fixed size vector types with relaxed alignment. For 3 * each vector type defined by <simd/vector_types.h> that is not a 1- or 3- 4 * element vector, there is a corresponding type defined by this header that 5 * requires only the alignment matching that of the underlying scalar type. 6 * 7 * These types should be used to access buffers that may not be sufficiently 8 * aligned to allow them to be accessed using the "normal" simd vector types. 9 * As an example of this usage, suppose that you want to load a vector of 10 * four floats from an array of floats. The type simd_float4 has sixteen byte 11 * alignment, whereas an array of floats has only four byte alignment. 12 * Thus, naively casting a pointer into the array to (simd_float4 *) would 13 * invoke undefined behavior, and likely produce an alignment fault at 14 * runtime. Instead, use the corresponding packed type to load from the array: 15 * 16 * <pre> 17 * @textblock 18 * simd_float4 vector = *(simd_packed_float4 *)&array[i]; 19 * // do something with vector ... 20 * @/textblock 21 * </pre> 22 * 23 * It's important to note that the packed_ types are only needed to work with 24 * memory; once the data is loaded, we simply operate on it as usual using 25 * the simd_float4 type, as illustrated above. 26 * 27 * @copyright 2014-2017 Apple, Inc. All rights reserved. 28 * @unsorted */ 29 30 #ifndef SIMD_PACKED_TYPES 31 #define SIMD_PACKED_TYPES 32 33 # include <simd/vector_types.h> 34 # if SIMD_COMPILER_HAS_REQUIRED_FEATURES 35 /*! @abstract A vector of two 8-bit signed (twos-complement) integers with 36 * relaxed alignment. 37 * @description In C++ and Metal, this type is also available as 38 * simd::packed::char2. The alignment of this type is that of the 39 * underlying scalar element type, so you can use it to load or store from 40 * an array of that type. */ 41 typedef __attribute__((__ext_vector_type__(2),__aligned__(1))) char simd_packed_char2; 42 43 /*! @abstract A vector of four 8-bit signed (twos-complement) integers with 44 * relaxed alignment. 45 * @description In C++ and Metal, this type is also available as 46 * simd::packed::char4. The alignment of this type is that of the 47 * underlying scalar element type, so you can use it to load or store from 48 * an array of that type. */ 49 typedef __attribute__((__ext_vector_type__(4),__aligned__(1))) char simd_packed_char4; 50 51 /*! @abstract A vector of eight 8-bit signed (twos-complement) integers with 52 * relaxed alignment. 53 * @description In C++ this type is also available as simd::packed::char8. 54 * This type is not available in Metal. The alignment of this type is only 55 * that of the underlying scalar element type, so you can use it to load or 56 * store from an array of that type. */ 57 typedef __attribute__((__ext_vector_type__(8),__aligned__(1))) char simd_packed_char8; 58 59 /*! @abstract A vector of sixteen 8-bit signed (twos-complement) integers 60 * with relaxed alignment. 61 * @description In C++ this type is also available as simd::packed::char16. 62 * This type is not available in Metal. The alignment of this type is only 63 * that of the underlying scalar element type, so you can use it to load or 64 * store from an array of that type. */ 65 typedef __attribute__((__ext_vector_type__(16),__aligned__(1))) char simd_packed_char16; 66 67 /*! @abstract A vector of thirty-two 8-bit signed (twos-complement) integers 68 * with relaxed alignment. 69 * @description In C++ this type is also available as simd::packed::char32. 70 * This type is not available in Metal. The alignment of this type is only 71 * that of the underlying scalar element type, so you can use it to load or 72 * store from an array of that type. */ 73 typedef __attribute__((__ext_vector_type__(32),__aligned__(1))) char simd_packed_char32; 74 75 /*! @abstract A vector of sixty-four 8-bit signed (twos-complement) integers 76 * with relaxed alignment. 77 * @description In C++ this type is also available as simd::packed::char64. 78 * This type is not available in Metal. The alignment of this type is only 79 * that of the underlying scalar element type, so you can use it to load or 80 * store from an array of that type. */ 81 typedef __attribute__((__ext_vector_type__(64),__aligned__(1))) char simd_packed_char64; 82 83 /*! @abstract A vector of two 8-bit unsigned integers with relaxed 84 * alignment. 85 * @description In C++ and Metal, this type is also available as 86 * simd::packed::uchar2. The alignment of this type is that of the 87 * underlying scalar element type, so you can use it to load or store from 88 * an array of that type. */ 89 typedef __attribute__((__ext_vector_type__(2),__aligned__(1))) unsigned char simd_packed_uchar2; 90 91 /*! @abstract A vector of four 8-bit unsigned integers with relaxed 92 * alignment. 93 * @description In C++ and Metal, this type is also available as 94 * simd::packed::uchar4. The alignment of this type is that of the 95 * underlying scalar element type, so you can use it to load or store from 96 * an array of that type. */ 97 typedef __attribute__((__ext_vector_type__(4),__aligned__(1))) unsigned char simd_packed_uchar4; 98 99 /*! @abstract A vector of eight 8-bit unsigned integers with relaxed 100 * alignment. 101 * @description In C++ this type is also available as simd::packed::uchar8. 102 * This type is not available in Metal. The alignment of this type is only 103 * that of the underlying scalar element type, so you can use it to load or 104 * store from an array of that type. */ 105 typedef __attribute__((__ext_vector_type__(8),__aligned__(1))) unsigned char simd_packed_uchar8; 106 107 /*! @abstract A vector of sixteen 8-bit unsigned integers with relaxed 108 * alignment. 109 * @description In C++ this type is also available as 110 * simd::packed::uchar16. This type is not available in Metal. The 111 * alignment of this type is only that of the underlying scalar element 112 * type, so you can use it to load or store from an array of that type. */ 113 typedef __attribute__((__ext_vector_type__(16),__aligned__(1))) unsigned char simd_packed_uchar16; 114 115 /*! @abstract A vector of thirty-two 8-bit unsigned integers with relaxed 116 * alignment. 117 * @description In C++ this type is also available as 118 * simd::packed::uchar32. This type is not available in Metal. The 119 * alignment of this type is only that of the underlying scalar element 120 * type, so you can use it to load or store from an array of that type. */ 121 typedef __attribute__((__ext_vector_type__(32),__aligned__(1))) unsigned char simd_packed_uchar32; 122 123 /*! @abstract A vector of sixty-four 8-bit unsigned integers with relaxed 124 * alignment. 125 * @description In C++ this type is also available as 126 * simd::packed::uchar64. This type is not available in Metal. The 127 * alignment of this type is only that of the underlying scalar element 128 * type, so you can use it to load or store from an array of that type. */ 129 typedef __attribute__((__ext_vector_type__(64),__aligned__(1))) unsigned char simd_packed_uchar64; 130 131 /*! @abstract A vector of two 16-bit signed (twos-complement) integers with 132 * relaxed alignment. 133 * @description In C++ and Metal, this type is also available as 134 * simd::packed::short2. The alignment of this type is that of the 135 * underlying scalar element type, so you can use it to load or store from 136 * an array of that type. */ 137 typedef __attribute__((__ext_vector_type__(2),__aligned__(2))) short simd_packed_short2; 138 139 /*! @abstract A vector of four 16-bit signed (twos-complement) integers with 140 * relaxed alignment. 141 * @description In C++ and Metal, this type is also available as 142 * simd::packed::short4. The alignment of this type is that of the 143 * underlying scalar element type, so you can use it to load or store from 144 * an array of that type. */ 145 typedef __attribute__((__ext_vector_type__(4),__aligned__(2))) short simd_packed_short4; 146 147 /*! @abstract A vector of eight 16-bit signed (twos-complement) integers 148 * with relaxed alignment. 149 * @description In C++ this type is also available as simd::packed::short8. 150 * This type is not available in Metal. The alignment of this type is only 151 * that of the underlying scalar element type, so you can use it to load or 152 * store from an array of that type. */ 153 typedef __attribute__((__ext_vector_type__(8),__aligned__(2))) short simd_packed_short8; 154 155 /*! @abstract A vector of sixteen 16-bit signed (twos-complement) integers 156 * with relaxed alignment. 157 * @description In C++ this type is also available as 158 * simd::packed::short16. This type is not available in Metal. The 159 * alignment of this type is only that of the underlying scalar element 160 * type, so you can use it to load or store from an array of that type. */ 161 typedef __attribute__((__ext_vector_type__(16),__aligned__(2))) short simd_packed_short16; 162 163 /*! @abstract A vector of thirty-two 16-bit signed (twos-complement) 164 * integers with relaxed alignment. 165 * @description In C++ this type is also available as 166 * simd::packed::short32. This type is not available in Metal. The 167 * alignment of this type is only that of the underlying scalar element 168 * type, so you can use it to load or store from an array of that type. */ 169 typedef __attribute__((__ext_vector_type__(32),__aligned__(2))) short simd_packed_short32; 170 171 /*! @abstract A vector of two 16-bit unsigned integers with relaxed 172 * alignment. 173 * @description In C++ and Metal, this type is also available as 174 * simd::packed::ushort2. The alignment of this type is that of the 175 * underlying scalar element type, so you can use it to load or store from 176 * an array of that type. */ 177 typedef __attribute__((__ext_vector_type__(2),__aligned__(2))) unsigned short simd_packed_ushort2; 178 179 /*! @abstract A vector of four 16-bit unsigned integers with relaxed 180 * alignment. 181 * @description In C++ and Metal, this type is also available as 182 * simd::packed::ushort4. The alignment of this type is that of the 183 * underlying scalar element type, so you can use it to load or store from 184 * an array of that type. */ 185 typedef __attribute__((__ext_vector_type__(4),__aligned__(2))) unsigned short simd_packed_ushort4; 186 187 /*! @abstract A vector of eight 16-bit unsigned integers with relaxed 188 * alignment. 189 * @description In C++ this type is also available as 190 * simd::packed::ushort8. This type is not available in Metal. The 191 * alignment of this type is only that of the underlying scalar element 192 * type, so you can use it to load or store from an array of that type. */ 193 typedef __attribute__((__ext_vector_type__(8),__aligned__(2))) unsigned short simd_packed_ushort8; 194 195 /*! @abstract A vector of sixteen 16-bit unsigned integers with relaxed 196 * alignment. 197 * @description In C++ this type is also available as 198 * simd::packed::ushort16. This type is not available in Metal. The 199 * alignment of this type is only that of the underlying scalar element 200 * type, so you can use it to load or store from an array of that type. */ 201 typedef __attribute__((__ext_vector_type__(16),__aligned__(2))) unsigned short simd_packed_ushort16; 202 203 /*! @abstract A vector of thirty-two 16-bit unsigned integers with relaxed 204 * alignment. 205 * @description In C++ this type is also available as 206 * simd::packed::ushort32. This type is not available in Metal. The 207 * alignment of this type is only that of the underlying scalar element 208 * type, so you can use it to load or store from an array of that type. */ 209 typedef __attribute__((__ext_vector_type__(32),__aligned__(2))) unsigned short simd_packed_ushort32; 210 211 /*! @abstract A vector of two 16-bit floating-point numbers with relaxed 212 * alignment. 213 * @description In C++ and Metal, this type is also available as 214 * simd::packed::half2. The alignment of this type is that of the 215 * underlying scalar element type, so you can use it to load or store from 216 * an array of that type. */ 217 typedef __attribute__((__ext_vector_type__(2),__aligned__(2))) _Float16 simd_packed_half2; 218 219 /*! @abstract A vector of four 16-bit floating-point numbers with relaxed 220 * alignment. 221 * @description In C++ and Metal, this type is also available as 222 * simd::packed::half4. The alignment of this type is that of the 223 * underlying scalar element type, so you can use it to load or store from 224 * an array of that type. */ 225 typedef __attribute__((__ext_vector_type__(4),__aligned__(2))) _Float16 simd_packed_half4; 226 227 /*! @abstract A vector of eight 16-bit floating-point numbers with relaxed 228 * alignment. 229 * @description In C++ this type is also available as simd::packed::half8. 230 * This type is not available in Metal. The alignment of this type is only 231 * that of the underlying scalar element type, so you can use it to load or 232 * store from an array of that type. */ 233 typedef __attribute__((__ext_vector_type__(8),__aligned__(2))) _Float16 simd_packed_half8; 234 235 /*! @abstract A vector of sixteen 16-bit floating-point numbers with relaxed 236 * alignment. 237 * @description In C++ this type is also available as simd::packed::half16. 238 * This type is not available in Metal. The alignment of this type is only 239 * that of the underlying scalar element type, so you can use it to load or 240 * store from an array of that type. */ 241 typedef __attribute__((__ext_vector_type__(16),__aligned__(2))) _Float16 simd_packed_half16; 242 243 /*! @abstract A vector of thirty-two 16-bit floating-point numbers with 244 * relaxed alignment. 245 * @description In C++ this type is also available as simd::packed::half32. 246 * This type is not available in Metal. The alignment of this type is only 247 * that of the underlying scalar element type, so you can use it to load or 248 * store from an array of that type. */ 249 typedef __attribute__((__ext_vector_type__(32),__aligned__(2))) _Float16 simd_packed_half32; 250 251 /*! @abstract A vector of two 32-bit signed (twos-complement) integers with 252 * relaxed alignment. 253 * @description In C++ and Metal, this type is also available as 254 * simd::packed::int2. The alignment of this type is that of the underlying 255 * scalar element type, so you can use it to load or store from an array of 256 * that type. */ 257 typedef __attribute__((__ext_vector_type__(2),__aligned__(4))) int simd_packed_int2; 258 259 /*! @abstract A vector of four 32-bit signed (twos-complement) integers with 260 * relaxed alignment. 261 * @description In C++ and Metal, this type is also available as 262 * simd::packed::int4. The alignment of this type is that of the underlying 263 * scalar element type, so you can use it to load or store from an array of 264 * that type. */ 265 typedef __attribute__((__ext_vector_type__(4),__aligned__(4))) int simd_packed_int4; 266 267 /*! @abstract A vector of eight 32-bit signed (twos-complement) integers 268 * with relaxed alignment. 269 * @description In C++ this type is also available as simd::packed::int8. 270 * This type is not available in Metal. The alignment of this type is only 271 * that of the underlying scalar element type, so you can use it to load or 272 * store from an array of that type. */ 273 typedef __attribute__((__ext_vector_type__(8),__aligned__(4))) int simd_packed_int8; 274 275 /*! @abstract A vector of sixteen 32-bit signed (twos-complement) integers 276 * with relaxed alignment. 277 * @description In C++ this type is also available as simd::packed::int16. 278 * This type is not available in Metal. The alignment of this type is only 279 * that of the underlying scalar element type, so you can use it to load or 280 * store from an array of that type. */ 281 typedef __attribute__((__ext_vector_type__(16),__aligned__(4))) int simd_packed_int16; 282 283 /*! @abstract A vector of two 32-bit unsigned integers with relaxed 284 * alignment. 285 * @description In C++ and Metal, this type is also available as 286 * simd::packed::uint2. The alignment of this type is that of the 287 * underlying scalar element type, so you can use it to load or store from 288 * an array of that type. */ 289 typedef __attribute__((__ext_vector_type__(2),__aligned__(4))) unsigned int simd_packed_uint2; 290 291 /*! @abstract A vector of four 32-bit unsigned integers with relaxed 292 * alignment. 293 * @description In C++ and Metal, this type is also available as 294 * simd::packed::uint4. The alignment of this type is that of the 295 * underlying scalar element type, so you can use it to load or store from 296 * an array of that type. */ 297 typedef __attribute__((__ext_vector_type__(4),__aligned__(4))) unsigned int simd_packed_uint4; 298 299 /*! @abstract A vector of eight 32-bit unsigned integers with relaxed 300 * alignment. 301 * @description In C++ this type is also available as simd::packed::uint8. 302 * This type is not available in Metal. The alignment of this type is only 303 * that of the underlying scalar element type, so you can use it to load or 304 * store from an array of that type. */ 305 typedef __attribute__((__ext_vector_type__(8),__aligned__(4))) unsigned int simd_packed_uint8; 306 307 /*! @abstract A vector of sixteen 32-bit unsigned integers with relaxed 308 * alignment. 309 * @description In C++ this type is also available as simd::packed::uint16. 310 * This type is not available in Metal. The alignment of this type is only 311 * that of the underlying scalar element type, so you can use it to load or 312 * store from an array of that type. */ 313 typedef __attribute__((__ext_vector_type__(16),__aligned__(4))) unsigned int simd_packed_uint16; 314 315 /*! @abstract A vector of two 32-bit floating-point numbers with relaxed 316 * alignment. 317 * @description In C++ and Metal, this type is also available as 318 * simd::packed::float2. The alignment of this type is that of the 319 * underlying scalar element type, so you can use it to load or store from 320 * an array of that type. */ 321 typedef __attribute__((__ext_vector_type__(2),__aligned__(4))) float simd_packed_float2; 322 323 /*! @abstract A vector of four 32-bit floating-point numbers with relaxed 324 * alignment. 325 * @description In C++ and Metal, this type is also available as 326 * simd::packed::float4. The alignment of this type is that of the 327 * underlying scalar element type, so you can use it to load or store from 328 * an array of that type. */ 329 typedef __attribute__((__ext_vector_type__(4),__aligned__(4))) float simd_packed_float4; 330 331 /*! @abstract A vector of eight 32-bit floating-point numbers with relaxed 332 * alignment. 333 * @description In C++ this type is also available as simd::packed::float8. 334 * This type is not available in Metal. The alignment of this type is only 335 * that of the underlying scalar element type, so you can use it to load or 336 * store from an array of that type. */ 337 typedef __attribute__((__ext_vector_type__(8),__aligned__(4))) float simd_packed_float8; 338 339 /*! @abstract A vector of sixteen 32-bit floating-point numbers with relaxed 340 * alignment. 341 * @description In C++ this type is also available as 342 * simd::packed::float16. This type is not available in Metal. The 343 * alignment of this type is only that of the underlying scalar element 344 * type, so you can use it to load or store from an array of that type. */ 345 typedef __attribute__((__ext_vector_type__(16),__aligned__(4))) float simd_packed_float16; 346 347 /*! @abstract A vector of two 64-bit signed (twos-complement) integers with 348 * relaxed alignment. 349 * @description In C++ and Metal, this type is also available as 350 * simd::packed::long2. The alignment of this type is that of the 351 * underlying scalar element type, so you can use it to load or store from 352 * an array of that type. */ 353 #if defined __LP64__ 354 typedef __attribute__((__ext_vector_type__(2),__aligned__(8))) simd_long1 simd_packed_long2; 355 #else 356 typedef __attribute__((__ext_vector_type__(2),__aligned__(4))) simd_long1 simd_packed_long2; 357 #endif 358 359 /*! @abstract A vector of four 64-bit signed (twos-complement) integers with 360 * relaxed alignment. 361 * @description In C++ and Metal, this type is also available as 362 * simd::packed::long4. The alignment of this type is that of the 363 * underlying scalar element type, so you can use it to load or store from 364 * an array of that type. */ 365 #if defined __LP64__ 366 typedef __attribute__((__ext_vector_type__(4),__aligned__(8))) simd_long1 simd_packed_long4; 367 #else 368 typedef __attribute__((__ext_vector_type__(4),__aligned__(4))) simd_long1 simd_packed_long4; 369 #endif 370 371 /*! @abstract A vector of eight 64-bit signed (twos-complement) integers 372 * with relaxed alignment. 373 * @description In C++ this type is also available as simd::packed::long8. 374 * This type is not available in Metal. The alignment of this type is only 375 * that of the underlying scalar element type, so you can use it to load or 376 * store from an array of that type. */ 377 #if defined __LP64__ 378 typedef __attribute__((__ext_vector_type__(8),__aligned__(8))) simd_long1 simd_packed_long8; 379 #else 380 typedef __attribute__((__ext_vector_type__(8),__aligned__(4))) simd_long1 simd_packed_long8; 381 #endif 382 383 /*! @abstract A vector of two 64-bit unsigned integers with relaxed 384 * alignment. 385 * @description In C++ and Metal, this type is also available as 386 * simd::packed::ulong2. The alignment of this type is that of the 387 * underlying scalar element type, so you can use it to load or store from 388 * an array of that type. */ 389 #if defined __LP64__ 390 typedef __attribute__((__ext_vector_type__(2),__aligned__(8))) simd_ulong1 simd_packed_ulong2; 391 #else 392 typedef __attribute__((__ext_vector_type__(2),__aligned__(4))) simd_ulong1 simd_packed_ulong2; 393 #endif 394 395 /*! @abstract A vector of four 64-bit unsigned integers with relaxed 396 * alignment. 397 * @description In C++ and Metal, this type is also available as 398 * simd::packed::ulong4. The alignment of this type is that of the 399 * underlying scalar element type, so you can use it to load or store from 400 * an array of that type. */ 401 #if defined __LP64__ 402 typedef __attribute__((__ext_vector_type__(4),__aligned__(8))) simd_ulong1 simd_packed_ulong4; 403 #else 404 typedef __attribute__((__ext_vector_type__(4),__aligned__(4))) simd_ulong1 simd_packed_ulong4; 405 #endif 406 407 /*! @abstract A vector of eight 64-bit unsigned integers with relaxed 408 * alignment. 409 * @description In C++ this type is also available as simd::packed::ulong8. 410 * This type is not available in Metal. The alignment of this type is only 411 * that of the underlying scalar element type, so you can use it to load or 412 * store from an array of that type. */ 413 #if defined __LP64__ 414 typedef __attribute__((__ext_vector_type__(8),__aligned__(8))) simd_ulong1 simd_packed_ulong8; 415 #else 416 typedef __attribute__((__ext_vector_type__(8),__aligned__(4))) simd_ulong1 simd_packed_ulong8; 417 #endif 418 419 /*! @abstract A vector of two 64-bit floating-point numbers with relaxed 420 * alignment. 421 * @description In C++ and Metal, this type is also available as 422 * simd::packed::double2. The alignment of this type is that of the 423 * underlying scalar element type, so you can use it to load or store from 424 * an array of that type. */ 425 #if defined __LP64__ 426 typedef __attribute__((__ext_vector_type__(2),__aligned__(8))) double simd_packed_double2; 427 #else 428 typedef __attribute__((__ext_vector_type__(2),__aligned__(4))) double simd_packed_double2; 429 #endif 430 431 /*! @abstract A vector of four 64-bit floating-point numbers with relaxed 432 * alignment. 433 * @description In C++ and Metal, this type is also available as 434 * simd::packed::double4. The alignment of this type is that of the 435 * underlying scalar element type, so you can use it to load or store from 436 * an array of that type. */ 437 #if defined __LP64__ 438 typedef __attribute__((__ext_vector_type__(4),__aligned__(8))) double simd_packed_double4; 439 #else 440 typedef __attribute__((__ext_vector_type__(4),__aligned__(4))) double simd_packed_double4; 441 #endif 442 443 /*! @abstract A vector of eight 64-bit floating-point numbers with relaxed 444 * alignment. 445 * @description In C++ this type is also available as 446 * simd::packed::double8. This type is not available in Metal. The 447 * alignment of this type is only that of the underlying scalar element 448 * type, so you can use it to load or store from an array of that type. */ 449 #if defined __LP64__ 450 typedef __attribute__((__ext_vector_type__(8),__aligned__(8))) double simd_packed_double8; 451 #else 452 typedef __attribute__((__ext_vector_type__(8),__aligned__(4))) double simd_packed_double8; 453 #endif 454 455 /* MARK: C++ vector types */ 456 #if defined __cplusplus 457 namespace simd { 458 namespace packed { 459 /*! @abstract A vector of two 8-bit signed (twos-complement) integers 460 * with relaxed alignment. 461 * @description In C or Objective-C, this type is available as 462 * simd_packed_char2. The alignment of this type is only that of the 463 * underlying scalar element type, so you can use it to load or store 464 * from an array of that type. */ 465 typedef ::simd_packed_char2 char2; 466 467 /*! @abstract A vector of four 8-bit signed (twos-complement) integers 468 * with relaxed alignment. 469 * @description In C or Objective-C, this type is available as 470 * simd_packed_char4. The alignment of this type is only that of the 471 * underlying scalar element type, so you can use it to load or store 472 * from an array of that type. */ 473 typedef ::simd_packed_char4 char4; 474 475 /*! @abstract A vector of eight 8-bit signed (twos-complement) integers 476 * with relaxed alignment. 477 * @description This type is not available in Metal. In C or 478 * Objective-C, this type is available as simd_packed_char8. The 479 * alignment of this type is only that of the underlying scalar element 480 * type, so you can use it to load or store from an array of that type. */ 481 typedef ::simd_packed_char8 char8; 482 483 /*! @abstract A vector of sixteen 8-bit signed (twos-complement) 484 * integers with relaxed alignment. 485 * @description This type is not available in Metal. In C or 486 * Objective-C, this type is available as simd_packed_char16. The 487 * alignment of this type is only that of the underlying scalar element 488 * type, so you can use it to load or store from an array of that type. */ 489 typedef ::simd_packed_char16 char16; 490 491 /*! @abstract A vector of thirty-two 8-bit signed (twos-complement) 492 * integers with relaxed alignment. 493 * @description This type is not available in Metal. In C or 494 * Objective-C, this type is available as simd_packed_char32. The 495 * alignment of this type is only that of the underlying scalar element 496 * type, so you can use it to load or store from an array of that type. */ 497 typedef ::simd_packed_char32 char32; 498 499 /*! @abstract A vector of sixty-four 8-bit signed (twos-complement) 500 * integers with relaxed alignment. 501 * @description This type is not available in Metal. In C or 502 * Objective-C, this type is available as simd_packed_char64. The 503 * alignment of this type is only that of the underlying scalar element 504 * type, so you can use it to load or store from an array of that type. */ 505 typedef ::simd_packed_char64 char64; 506 507 /*! @abstract A vector of two 8-bit unsigned integers with relaxed 508 * alignment. 509 * @description In C or Objective-C, this type is available as 510 * simd_packed_uchar2. The alignment of this type is only that of the 511 * underlying scalar element type, so you can use it to load or store 512 * from an array of that type. */ 513 typedef ::simd_packed_uchar2 uchar2; 514 515 /*! @abstract A vector of four 8-bit unsigned integers with relaxed 516 * alignment. 517 * @description In C or Objective-C, this type is available as 518 * simd_packed_uchar4. The alignment of this type is only that of the 519 * underlying scalar element type, so you can use it to load or store 520 * from an array of that type. */ 521 typedef ::simd_packed_uchar4 uchar4; 522 523 /*! @abstract A vector of eight 8-bit unsigned integers with relaxed 524 * alignment. 525 * @description This type is not available in Metal. In C or 526 * Objective-C, this type is available as simd_packed_uchar8. The 527 * alignment of this type is only that of the underlying scalar element 528 * type, so you can use it to load or store from an array of that type. */ 529 typedef ::simd_packed_uchar8 uchar8; 530 531 /*! @abstract A vector of sixteen 8-bit unsigned integers with relaxed 532 * alignment. 533 * @description This type is not available in Metal. In C or 534 * Objective-C, this type is available as simd_packed_uchar16. The 535 * alignment of this type is only that of the underlying scalar element 536 * type, so you can use it to load or store from an array of that type. */ 537 typedef ::simd_packed_uchar16 uchar16; 538 539 /*! @abstract A vector of thirty-two 8-bit unsigned integers with 540 * relaxed alignment. 541 * @description This type is not available in Metal. In C or 542 * Objective-C, this type is available as simd_packed_uchar32. The 543 * alignment of this type is only that of the underlying scalar element 544 * type, so you can use it to load or store from an array of that type. */ 545 typedef ::simd_packed_uchar32 uchar32; 546 547 /*! @abstract A vector of sixty-four 8-bit unsigned integers with 548 * relaxed alignment. 549 * @description This type is not available in Metal. In C or 550 * Objective-C, this type is available as simd_packed_uchar64. The 551 * alignment of this type is only that of the underlying scalar element 552 * type, so you can use it to load or store from an array of that type. */ 553 typedef ::simd_packed_uchar64 uchar64; 554 555 /*! @abstract A vector of two 16-bit signed (twos-complement) integers 556 * with relaxed alignment. 557 * @description In C or Objective-C, this type is available as 558 * simd_packed_short2. The alignment of this type is only that of the 559 * underlying scalar element type, so you can use it to load or store 560 * from an array of that type. */ 561 typedef ::simd_packed_short2 short2; 562 563 /*! @abstract A vector of four 16-bit signed (twos-complement) integers 564 * with relaxed alignment. 565 * @description In C or Objective-C, this type is available as 566 * simd_packed_short4. The alignment of this type is only that of the 567 * underlying scalar element type, so you can use it to load or store 568 * from an array of that type. */ 569 typedef ::simd_packed_short4 short4; 570 571 /*! @abstract A vector of eight 16-bit signed (twos-complement) integers 572 * with relaxed alignment. 573 * @description This type is not available in Metal. In C or 574 * Objective-C, this type is available as simd_packed_short8. The 575 * alignment of this type is only that of the underlying scalar element 576 * type, so you can use it to load or store from an array of that type. */ 577 typedef ::simd_packed_short8 short8; 578 579 /*! @abstract A vector of sixteen 16-bit signed (twos-complement) 580 * integers with relaxed alignment. 581 * @description This type is not available in Metal. In C or 582 * Objective-C, this type is available as simd_packed_short16. The 583 * alignment of this type is only that of the underlying scalar element 584 * type, so you can use it to load or store from an array of that type. */ 585 typedef ::simd_packed_short16 short16; 586 587 /*! @abstract A vector of thirty-two 16-bit signed (twos-complement) 588 * integers with relaxed alignment. 589 * @description This type is not available in Metal. In C or 590 * Objective-C, this type is available as simd_packed_short32. The 591 * alignment of this type is only that of the underlying scalar element 592 * type, so you can use it to load or store from an array of that type. */ 593 typedef ::simd_packed_short32 short32; 594 595 /*! @abstract A vector of two 16-bit unsigned integers with relaxed 596 * alignment. 597 * @description In C or Objective-C, this type is available as 598 * simd_packed_ushort2. The alignment of this type is only that of the 599 * underlying scalar element type, so you can use it to load or store 600 * from an array of that type. */ 601 typedef ::simd_packed_ushort2 ushort2; 602 603 /*! @abstract A vector of four 16-bit unsigned integers with relaxed 604 * alignment. 605 * @description In C or Objective-C, this type is available as 606 * simd_packed_ushort4. The alignment of this type is only that of the 607 * underlying scalar element type, so you can use it to load or store 608 * from an array of that type. */ 609 typedef ::simd_packed_ushort4 ushort4; 610 611 /*! @abstract A vector of eight 16-bit unsigned integers with relaxed 612 * alignment. 613 * @description This type is not available in Metal. In C or 614 * Objective-C, this type is available as simd_packed_ushort8. The 615 * alignment of this type is only that of the underlying scalar element 616 * type, so you can use it to load or store from an array of that type. */ 617 typedef ::simd_packed_ushort8 ushort8; 618 619 /*! @abstract A vector of sixteen 16-bit unsigned integers with relaxed 620 * alignment. 621 * @description This type is not available in Metal. In C or 622 * Objective-C, this type is available as simd_packed_ushort16. The 623 * alignment of this type is only that of the underlying scalar element 624 * type, so you can use it to load or store from an array of that type. */ 625 typedef ::simd_packed_ushort16 ushort16; 626 627 /*! @abstract A vector of thirty-two 16-bit unsigned integers with 628 * relaxed alignment. 629 * @description This type is not available in Metal. In C or 630 * Objective-C, this type is available as simd_packed_ushort32. The 631 * alignment of this type is only that of the underlying scalar element 632 * type, so you can use it to load or store from an array of that type. */ 633 typedef ::simd_packed_ushort32 ushort32; 634 635 /*! @abstract A vector of two 16-bit floating-point numbers with relaxed 636 * alignment. 637 * @description In C or Objective-C, this type is available as 638 * simd_packed_half2. The alignment of this type is only that of the 639 * underlying scalar element type, so you can use it to load or store 640 * from an array of that type. */ 641 typedef ::simd_packed_half2 half2; 642 643 /*! @abstract A vector of four 16-bit floating-point numbers with 644 * relaxed alignment. 645 * @description In C or Objective-C, this type is available as 646 * simd_packed_half4. The alignment of this type is only that of the 647 * underlying scalar element type, so you can use it to load or store 648 * from an array of that type. */ 649 typedef ::simd_packed_half4 half4; 650 651 /*! @abstract A vector of eight 16-bit floating-point numbers with 652 * relaxed alignment. 653 * @description This type is not available in Metal. In C or 654 * Objective-C, this type is available as simd_packed_half8. The 655 * alignment of this type is only that of the underlying scalar element 656 * type, so you can use it to load or store from an array of that type. */ 657 typedef ::simd_packed_half8 half8; 658 659 /*! @abstract A vector of sixteen 16-bit floating-point numbers with 660 * relaxed alignment. 661 * @description This type is not available in Metal. In C or 662 * Objective-C, this type is available as simd_packed_half16. The 663 * alignment of this type is only that of the underlying scalar element 664 * type, so you can use it to load or store from an array of that type. */ 665 typedef ::simd_packed_half16 half16; 666 667 /*! @abstract A vector of thirty-two 16-bit floating-point numbers with 668 * relaxed alignment. 669 * @description This type is not available in Metal. In C or 670 * Objective-C, this type is available as simd_packed_half32. The 671 * alignment of this type is only that of the underlying scalar element 672 * type, so you can use it to load or store from an array of that type. */ 673 typedef ::simd_packed_half32 half32; 674 675 /*! @abstract A vector of two 32-bit signed (twos-complement) integers 676 * with relaxed alignment. 677 * @description In C or Objective-C, this type is available as 678 * simd_packed_int2. The alignment of this type is only that of the 679 * underlying scalar element type, so you can use it to load or store 680 * from an array of that type. */ 681 typedef ::simd_packed_int2 int2; 682 683 /*! @abstract A vector of four 32-bit signed (twos-complement) integers 684 * with relaxed alignment. 685 * @description In C or Objective-C, this type is available as 686 * simd_packed_int4. The alignment of this type is only that of the 687 * underlying scalar element type, so you can use it to load or store 688 * from an array of that type. */ 689 typedef ::simd_packed_int4 int4; 690 691 /*! @abstract A vector of eight 32-bit signed (twos-complement) integers 692 * with relaxed alignment. 693 * @description This type is not available in Metal. In C or 694 * Objective-C, this type is available as simd_packed_int8. The 695 * alignment of this type is only that of the underlying scalar element 696 * type, so you can use it to load or store from an array of that type. */ 697 typedef ::simd_packed_int8 int8; 698 699 /*! @abstract A vector of sixteen 32-bit signed (twos-complement) 700 * integers with relaxed alignment. 701 * @description This type is not available in Metal. In C or 702 * Objective-C, this type is available as simd_packed_int16. The 703 * alignment of this type is only that of the underlying scalar element 704 * type, so you can use it to load or store from an array of that type. */ 705 typedef ::simd_packed_int16 int16; 706 707 /*! @abstract A vector of two 32-bit unsigned integers with relaxed 708 * alignment. 709 * @description In C or Objective-C, this type is available as 710 * simd_packed_uint2. The alignment of this type is only that of the 711 * underlying scalar element type, so you can use it to load or store 712 * from an array of that type. */ 713 typedef ::simd_packed_uint2 uint2; 714 715 /*! @abstract A vector of four 32-bit unsigned integers with relaxed 716 * alignment. 717 * @description In C or Objective-C, this type is available as 718 * simd_packed_uint4. The alignment of this type is only that of the 719 * underlying scalar element type, so you can use it to load or store 720 * from an array of that type. */ 721 typedef ::simd_packed_uint4 uint4; 722 723 /*! @abstract A vector of eight 32-bit unsigned integers with relaxed 724 * alignment. 725 * @description This type is not available in Metal. In C or 726 * Objective-C, this type is available as simd_packed_uint8. The 727 * alignment of this type is only that of the underlying scalar element 728 * type, so you can use it to load or store from an array of that type. */ 729 typedef ::simd_packed_uint8 uint8; 730 731 /*! @abstract A vector of sixteen 32-bit unsigned integers with relaxed 732 * alignment. 733 * @description This type is not available in Metal. In C or 734 * Objective-C, this type is available as simd_packed_uint16. The 735 * alignment of this type is only that of the underlying scalar element 736 * type, so you can use it to load or store from an array of that type. */ 737 typedef ::simd_packed_uint16 uint16; 738 739 /*! @abstract A vector of two 32-bit floating-point numbers with relaxed 740 * alignment. 741 * @description In C or Objective-C, this type is available as 742 * simd_packed_float2. The alignment of this type is only that of the 743 * underlying scalar element type, so you can use it to load or store 744 * from an array of that type. */ 745 typedef ::simd_packed_float2 float2; 746 747 /*! @abstract A vector of four 32-bit floating-point numbers with 748 * relaxed alignment. 749 * @description In C or Objective-C, this type is available as 750 * simd_packed_float4. The alignment of this type is only that of the 751 * underlying scalar element type, so you can use it to load or store 752 * from an array of that type. */ 753 typedef ::simd_packed_float4 float4; 754 755 /*! @abstract A vector of eight 32-bit floating-point numbers with 756 * relaxed alignment. 757 * @description This type is not available in Metal. In C or 758 * Objective-C, this type is available as simd_packed_float8. The 759 * alignment of this type is only that of the underlying scalar element 760 * type, so you can use it to load or store from an array of that type. */ 761 typedef ::simd_packed_float8 float8; 762 763 /*! @abstract A vector of sixteen 32-bit floating-point numbers with 764 * relaxed alignment. 765 * @description This type is not available in Metal. In C or 766 * Objective-C, this type is available as simd_packed_float16. The 767 * alignment of this type is only that of the underlying scalar element 768 * type, so you can use it to load or store from an array of that type. */ 769 typedef ::simd_packed_float16 float16; 770 771 /*! @abstract A vector of two 64-bit signed (twos-complement) integers 772 * with relaxed alignment. 773 * @description In C or Objective-C, this type is available as 774 * simd_packed_long2. The alignment of this type is only that of the 775 * underlying scalar element type, so you can use it to load or store 776 * from an array of that type. */ 777 typedef ::simd_packed_long2 long2; 778 779 /*! @abstract A vector of four 64-bit signed (twos-complement) integers 780 * with relaxed alignment. 781 * @description In C or Objective-C, this type is available as 782 * simd_packed_long4. The alignment of this type is only that of the 783 * underlying scalar element type, so you can use it to load or store 784 * from an array of that type. */ 785 typedef ::simd_packed_long4 long4; 786 787 /*! @abstract A vector of eight 64-bit signed (twos-complement) integers 788 * with relaxed alignment. 789 * @description This type is not available in Metal. In C or 790 * Objective-C, this type is available as simd_packed_long8. The 791 * alignment of this type is only that of the underlying scalar element 792 * type, so you can use it to load or store from an array of that type. */ 793 typedef ::simd_packed_long8 long8; 794 795 /*! @abstract A vector of two 64-bit unsigned integers with relaxed 796 * alignment. 797 * @description In C or Objective-C, this type is available as 798 * simd_packed_ulong2. The alignment of this type is only that of the 799 * underlying scalar element type, so you can use it to load or store 800 * from an array of that type. */ 801 typedef ::simd_packed_ulong2 ulong2; 802 803 /*! @abstract A vector of four 64-bit unsigned integers with relaxed 804 * alignment. 805 * @description In C or Objective-C, this type is available as 806 * simd_packed_ulong4. The alignment of this type is only that of the 807 * underlying scalar element type, so you can use it to load or store 808 * from an array of that type. */ 809 typedef ::simd_packed_ulong4 ulong4; 810 811 /*! @abstract A vector of eight 64-bit unsigned integers with relaxed 812 * alignment. 813 * @description This type is not available in Metal. In C or 814 * Objective-C, this type is available as simd_packed_ulong8. The 815 * alignment of this type is only that of the underlying scalar element 816 * type, so you can use it to load or store from an array of that type. */ 817 typedef ::simd_packed_ulong8 ulong8; 818 819 /*! @abstract A vector of two 64-bit floating-point numbers with relaxed 820 * alignment. 821 * @description In C or Objective-C, this type is available as 822 * simd_packed_double2. The alignment of this type is only that of the 823 * underlying scalar element type, so you can use it to load or store 824 * from an array of that type. */ 825 typedef ::simd_packed_double2 double2; 826 827 /*! @abstract A vector of four 64-bit floating-point numbers with 828 * relaxed alignment. 829 * @description In C or Objective-C, this type is available as 830 * simd_packed_double4. The alignment of this type is only that of the 831 * underlying scalar element type, so you can use it to load or store 832 * from an array of that type. */ 833 typedef ::simd_packed_double4 double4; 834 835 /*! @abstract A vector of eight 64-bit floating-point numbers with 836 * relaxed alignment. 837 * @description This type is not available in Metal. In C or 838 * Objective-C, this type is available as simd_packed_double8. The 839 * alignment of this type is only that of the underlying scalar element 840 * type, so you can use it to load or store from an array of that type. */ 841 typedef ::simd_packed_double8 double8; 842 843 } /* namespace simd::packed:: */ 844 } /* namespace simd:: */ 845 #endif /* __cplusplus */ 846 847 /* MARK: Deprecated vector types */ 848 /*! @group Deprecated vector types 849 * @discussion These are the original types used by earlier versions of the 850 * simd library; they are provided here for compatability with existing source 851 * files. Use the new ("simd_"-prefixed) types for future development. */ 852 /*! @abstract A vector of two 8-bit signed (twos-complement) integers with 853 * relaxed alignment. 854 * @description This type is deprecated; you should use simd_packed_char2 855 * or simd::packed::char2 instead. */ 856 typedef simd_packed_char2 packed_char2; 857 858 /*! @abstract A vector of four 8-bit signed (twos-complement) integers with 859 * relaxed alignment. 860 * @description This type is deprecated; you should use simd_packed_char4 861 * or simd::packed::char4 instead. */ 862 typedef simd_packed_char4 packed_char4; 863 864 /*! @abstract A vector of eight 8-bit signed (twos-complement) integers with 865 * relaxed alignment. 866 * @description This type is deprecated; you should use simd_packed_char8 867 * or simd::packed::char8 instead. */ 868 typedef simd_packed_char8 packed_char8; 869 870 /*! @abstract A vector of sixteen 8-bit signed (twos-complement) integers 871 * with relaxed alignment. 872 * @description This type is deprecated; you should use simd_packed_char16 873 * or simd::packed::char16 instead. */ 874 typedef simd_packed_char16 packed_char16; 875 876 /*! @abstract A vector of thirty-two 8-bit signed (twos-complement) integers 877 * with relaxed alignment. 878 * @description This type is deprecated; you should use simd_packed_char32 879 * or simd::packed::char32 instead. */ 880 typedef simd_packed_char32 packed_char32; 881 882 /*! @abstract A vector of sixty-four 8-bit signed (twos-complement) integers 883 * with relaxed alignment. 884 * @description This type is deprecated; you should use simd_packed_char64 885 * or simd::packed::char64 instead. */ 886 typedef simd_packed_char64 packed_char64; 887 888 /*! @abstract A vector of two 8-bit unsigned integers with relaxed 889 * alignment. 890 * @description This type is deprecated; you should use simd_packed_uchar2 891 * or simd::packed::uchar2 instead. */ 892 typedef simd_packed_uchar2 packed_uchar2; 893 894 /*! @abstract A vector of four 8-bit unsigned integers with relaxed 895 * alignment. 896 * @description This type is deprecated; you should use simd_packed_uchar4 897 * or simd::packed::uchar4 instead. */ 898 typedef simd_packed_uchar4 packed_uchar4; 899 900 /*! @abstract A vector of eight 8-bit unsigned integers with relaxed 901 * alignment. 902 * @description This type is deprecated; you should use simd_packed_uchar8 903 * or simd::packed::uchar8 instead. */ 904 typedef simd_packed_uchar8 packed_uchar8; 905 906 /*! @abstract A vector of sixteen 8-bit unsigned integers with relaxed 907 * alignment. 908 * @description This type is deprecated; you should use simd_packed_uchar16 909 * or simd::packed::uchar16 instead. */ 910 typedef simd_packed_uchar16 packed_uchar16; 911 912 /*! @abstract A vector of thirty-two 8-bit unsigned integers with relaxed 913 * alignment. 914 * @description This type is deprecated; you should use simd_packed_uchar32 915 * or simd::packed::uchar32 instead. */ 916 typedef simd_packed_uchar32 packed_uchar32; 917 918 /*! @abstract A vector of sixty-four 8-bit unsigned integers with relaxed 919 * alignment. 920 * @description This type is deprecated; you should use simd_packed_uchar64 921 * or simd::packed::uchar64 instead. */ 922 typedef simd_packed_uchar64 packed_uchar64; 923 924 /*! @abstract A vector of two 16-bit signed (twos-complement) integers with 925 * relaxed alignment. 926 * @description This type is deprecated; you should use simd_packed_short2 927 * or simd::packed::short2 instead. */ 928 typedef simd_packed_short2 packed_short2; 929 930 /*! @abstract A vector of four 16-bit signed (twos-complement) integers with 931 * relaxed alignment. 932 * @description This type is deprecated; you should use simd_packed_short4 933 * or simd::packed::short4 instead. */ 934 typedef simd_packed_short4 packed_short4; 935 936 /*! @abstract A vector of eight 16-bit signed (twos-complement) integers 937 * with relaxed alignment. 938 * @description This type is deprecated; you should use simd_packed_short8 939 * or simd::packed::short8 instead. */ 940 typedef simd_packed_short8 packed_short8; 941 942 /*! @abstract A vector of sixteen 16-bit signed (twos-complement) integers 943 * with relaxed alignment. 944 * @description This type is deprecated; you should use simd_packed_short16 945 * or simd::packed::short16 instead. */ 946 typedef simd_packed_short16 packed_short16; 947 948 /*! @abstract A vector of thirty-two 16-bit signed (twos-complement) 949 * integers with relaxed alignment. 950 * @description This type is deprecated; you should use simd_packed_short32 951 * or simd::packed::short32 instead. */ 952 typedef simd_packed_short32 packed_short32; 953 954 /*! @abstract A vector of two 16-bit unsigned integers with relaxed 955 * alignment. 956 * @description This type is deprecated; you should use simd_packed_ushort2 957 * or simd::packed::ushort2 instead. */ 958 typedef simd_packed_ushort2 packed_ushort2; 959 960 /*! @abstract A vector of four 16-bit unsigned integers with relaxed 961 * alignment. 962 * @description This type is deprecated; you should use simd_packed_ushort4 963 * or simd::packed::ushort4 instead. */ 964 typedef simd_packed_ushort4 packed_ushort4; 965 966 /*! @abstract A vector of eight 16-bit unsigned integers with relaxed 967 * alignment. 968 * @description This type is deprecated; you should use simd_packed_ushort8 969 * or simd::packed::ushort8 instead. */ 970 typedef simd_packed_ushort8 packed_ushort8; 971 972 /*! @abstract A vector of sixteen 16-bit unsigned integers with relaxed 973 * alignment. 974 * @description This type is deprecated; you should use 975 * simd_packed_ushort16 or simd::packed::ushort16 instead. */ 976 typedef simd_packed_ushort16 packed_ushort16; 977 978 /*! @abstract A vector of thirty-two 16-bit unsigned integers with relaxed 979 * alignment. 980 * @description This type is deprecated; you should use 981 * simd_packed_ushort32 or simd::packed::ushort32 instead. */ 982 typedef simd_packed_ushort32 packed_ushort32; 983 984 /*! @abstract A vector of two 32-bit signed (twos-complement) integers with 985 * relaxed alignment. 986 * @description This type is deprecated; you should use simd_packed_int2 or 987 * simd::packed::int2 instead. */ 988 typedef simd_packed_int2 packed_int2; 989 990 /*! @abstract A vector of four 32-bit signed (twos-complement) integers with 991 * relaxed alignment. 992 * @description This type is deprecated; you should use simd_packed_int4 or 993 * simd::packed::int4 instead. */ 994 typedef simd_packed_int4 packed_int4; 995 996 /*! @abstract A vector of eight 32-bit signed (twos-complement) integers 997 * with relaxed alignment. 998 * @description This type is deprecated; you should use simd_packed_int8 or 999 * simd::packed::int8 instead. */ 1000 typedef simd_packed_int8 packed_int8; 1001 1002 /*! @abstract A vector of sixteen 32-bit signed (twos-complement) integers 1003 * with relaxed alignment. 1004 * @description This type is deprecated; you should use simd_packed_int16 1005 * or simd::packed::int16 instead. */ 1006 typedef simd_packed_int16 packed_int16; 1007 1008 /*! @abstract A vector of two 32-bit unsigned integers with relaxed 1009 * alignment. 1010 * @description This type is deprecated; you should use simd_packed_uint2 1011 * or simd::packed::uint2 instead. */ 1012 typedef simd_packed_uint2 packed_uint2; 1013 1014 /*! @abstract A vector of four 32-bit unsigned integers with relaxed 1015 * alignment. 1016 * @description This type is deprecated; you should use simd_packed_uint4 1017 * or simd::packed::uint4 instead. */ 1018 typedef simd_packed_uint4 packed_uint4; 1019 1020 /*! @abstract A vector of eight 32-bit unsigned integers with relaxed 1021 * alignment. 1022 * @description This type is deprecated; you should use simd_packed_uint8 1023 * or simd::packed::uint8 instead. */ 1024 typedef simd_packed_uint8 packed_uint8; 1025 1026 /*! @abstract A vector of sixteen 32-bit unsigned integers with relaxed 1027 * alignment. 1028 * @description This type is deprecated; you should use simd_packed_uint16 1029 * or simd::packed::uint16 instead. */ 1030 typedef simd_packed_uint16 packed_uint16; 1031 1032 /*! @abstract A vector of two 32-bit floating-point numbers with relaxed 1033 * alignment. 1034 * @description This type is deprecated; you should use simd_packed_float2 1035 * or simd::packed::float2 instead. */ 1036 typedef simd_packed_float2 packed_float2; 1037 1038 /*! @abstract A vector of four 32-bit floating-point numbers with relaxed 1039 * alignment. 1040 * @description This type is deprecated; you should use simd_packed_float4 1041 * or simd::packed::float4 instead. */ 1042 typedef simd_packed_float4 packed_float4; 1043 1044 /*! @abstract A vector of eight 32-bit floating-point numbers with relaxed 1045 * alignment. 1046 * @description This type is deprecated; you should use simd_packed_float8 1047 * or simd::packed::float8 instead. */ 1048 typedef simd_packed_float8 packed_float8; 1049 1050 /*! @abstract A vector of sixteen 32-bit floating-point numbers with relaxed 1051 * alignment. 1052 * @description This type is deprecated; you should use simd_packed_float16 1053 * or simd::packed::float16 instead. */ 1054 typedef simd_packed_float16 packed_float16; 1055 1056 /*! @abstract A vector of two 64-bit signed (twos-complement) integers with 1057 * relaxed alignment. 1058 * @description This type is deprecated; you should use simd_packed_long2 1059 * or simd::packed::long2 instead. */ 1060 typedef simd_packed_long2 packed_long2; 1061 1062 /*! @abstract A vector of four 64-bit signed (twos-complement) integers with 1063 * relaxed alignment. 1064 * @description This type is deprecated; you should use simd_packed_long4 1065 * or simd::packed::long4 instead. */ 1066 typedef simd_packed_long4 packed_long4; 1067 1068 /*! @abstract A vector of eight 64-bit signed (twos-complement) integers 1069 * with relaxed alignment. 1070 * @description This type is deprecated; you should use simd_packed_long8 1071 * or simd::packed::long8 instead. */ 1072 typedef simd_packed_long8 packed_long8; 1073 1074 /*! @abstract A vector of two 64-bit unsigned integers with relaxed 1075 * alignment. 1076 * @description This type is deprecated; you should use simd_packed_ulong2 1077 * or simd::packed::ulong2 instead. */ 1078 typedef simd_packed_ulong2 packed_ulong2; 1079 1080 /*! @abstract A vector of four 64-bit unsigned integers with relaxed 1081 * alignment. 1082 * @description This type is deprecated; you should use simd_packed_ulong4 1083 * or simd::packed::ulong4 instead. */ 1084 typedef simd_packed_ulong4 packed_ulong4; 1085 1086 /*! @abstract A vector of eight 64-bit unsigned integers with relaxed 1087 * alignment. 1088 * @description This type is deprecated; you should use simd_packed_ulong8 1089 * or simd::packed::ulong8 instead. */ 1090 typedef simd_packed_ulong8 packed_ulong8; 1091 1092 /*! @abstract A vector of two 64-bit floating-point numbers with relaxed 1093 * alignment. 1094 * @description This type is deprecated; you should use simd_packed_double2 1095 * or simd::packed::double2 instead. */ 1096 typedef simd_packed_double2 packed_double2; 1097 1098 /*! @abstract A vector of four 64-bit floating-point numbers with relaxed 1099 * alignment. 1100 * @description This type is deprecated; you should use simd_packed_double4 1101 * or simd::packed::double4 instead. */ 1102 typedef simd_packed_double4 packed_double4; 1103 1104 /*! @abstract A vector of eight 64-bit floating-point numbers with relaxed 1105 * alignment. 1106 * @description This type is deprecated; you should use simd_packed_double8 1107 * or simd::packed::double8 instead. */ 1108 typedef simd_packed_double8 packed_double8; 1109 1110 # endif /* SIMD_COMPILER_HAS_REQUIRED_FEATURES */ 1111 #endif