Int32x8 (ocaml_simd.ocaml_simd.avx.Ocaml_simd

type t = int32x8

type mask = int32x8

val box : t -> int32x8 @@ portable

val unbox : int32x8 @ local -> t @@ portable

val zero : unit -> t @@ portable

Equivalent to const1 #0l.

val one : unit -> t @@ portable

Equivalent to const1 #1l.

val set1 : int32 -> t @@ portable

_mm256_set1_epi32

val set : 
  int32 ->
  int32 ->
  int32 ->
  int32 ->
  int32 ->
  int32 ->
  int32 ->
  int32 ->
  t @@ portable

_mm256_set_epi32

val set_lanes : int32x4 -> int32x4 -> t @@ portable

_mm256_set_m128 Operates on two int32x4 lanes.

val const1 : int32 -> t @@ portable

Argument must be a literal or an unboxing function applied to a literal. Compiles to a static vector literal. Exposed as an external so user code can compile without cross-library inlining.

val const : 
  int32 ->
  int32 ->
  int32 ->
  int32 ->
  int32 ->
  int32 ->
  int32 ->
  int32 ->
  t @@ portable

Arguments must be literals or unboxing functions applied to literals. Compiles to a static vector literal. Exposed as an external so user code can compile without cross-library inlining.

module Raw : sig ... end

module String : sig ... end

module Bytes : sig ... end

module Bigstring : sig ... end

module Int32_u_array : sig ... end

module Test : sig ... end

val (>=) : t -> t -> mask @@ portable

Compiles to cmpgt,cmpeq,orpd

val (<=) : t -> t -> mask @@ portable

Compiles to cmpgt,cmpeq,orpd

val (=) : t -> t -> mask @@ portable

_mm256_cmpeq_epi32

val (>) : t -> t -> mask @@ portable

_mm256_cmpgt_epi32

val (<) : t -> t -> mask @@ portable

_mm256_cmpgt_epi32 with flipped arguments.

val (<>) : t -> t -> mask @@ portable

Compiles to cmpeq,xorpd

val equal : t -> t -> mask @@ portable

_mm256_cmpeq_epi32

val movemask : mask -> int64 @@ portable

_mm256_movemask_ps

val select : mask -> fail:t -> pass:t -> t @@ portable

_mm256_blendv_ps Only reads the sign bit of each mask lane. Selects the element from pass if the sign bit is 1, otherwise fail.

val insert : idx:int64 -> t -> int32 -> t @@ portable

idx must be in 0,7.

val extract : idx:int64 -> t -> int32 @@ portable

idx must be in 0,7.

val extract0 : t -> int32 @@ portable

Projection. More efficient than extract ~idx:#0L.

val insert_lane : idx:int64 -> t -> int32x4 -> t @@ portable

idx must be a literal in 0,1. Operates on two int32x4 lanes. Exposed as an external so user code can compile without cross-library inlining.

val extract_lane : idx:int64 -> t -> int32x4 @@ portable

idx must be a literal in 0,1. Operates on two int32x4 lanes. Exposed as an external so user code can compile without cross-library inlining.

val extract_lane0 : t -> int32x4 @@ portable

Projection. Has no runtime cost. Operates on two int32x4 lanes.

val splat : 
  t ->
  #(int32 * int32 * int32 * int32 * int32 * int32 * int32 * int32) @@ portable

Slow, intended for debugging / printing / etc.

val interleave_upper_lanes : even:t -> odd:t -> t @@ portable

_mm256_unpackhi_ps Operates on two int32x4 lanes.

  interleave_upper_lanes ~even ~odd
  = (even.(2), odd.(2), even.(3), odd.(3), even.(6), odd.(6), even.(7), odd.(7))

val interleave_lower_lanes : even:t -> odd:t -> t @@ portable

_mm256_unpacklo_ps Operates on two int32x4 lanes.

  interleave_lower_lanes ~even ~odd
  = (even.(0), odd.(0), even.(1), odd.(1), even.(4), odd.(4), even.(5), odd.(5))

val duplicate_even : t -> t @@ portable

_mm256_moveldup_ps

  duplicate_even x = (x.(0), x.(0), x.(2), x.(2), x.(4), x.(4), x.(6), x.(6))

val duplicate_odd : t -> t @@ portable

_mm256_movehdup_ps

  duplicate_odd x = (x.(1), x.(1), x.(3), x.(3), x.(5), x.(5), x.(7), x.(7))

val blend : Ocaml_simd.Blend8.t -> t -> t -> t @@ portable

_mm256_blend_ps Specify blend with ppx_simd: %blend N, N, N, N, N, N, N, N, where each N is in 0,1. Exposed as an external so user code can compile without cross-library inlining.

  blend [%blend 1, 0, 1, 0, 1, 0, 1, 0] x y
  = (y.(0), x.(1), y.(2), x.(3), y.(4), x.(5), y.(6), x.(7))

val shuffle_lanes : Ocaml_simd.Shuffle4.t -> t -> t -> t @@ portable

_mm256_shuffle_ps Specify shuffle with ppx_simd: %shuffle N, N, N, N, where each N is in 0,3. Operates on two int32x4 lanes. Exposed as an external so user code can compile without cross-library inlining.

  shuffle_lanes [%shuffle 1, 0, 3, 2] x y
  = (x.(1), x.(0), y.(3), y.(2), x.(5), x.(4), y.(7), y.(6))

val permute_lanes : Ocaml_simd.Permute4.t -> t -> t @@ portable

_mm256_permute_ps Specify permute with ppx_simd: %permute N, N, N, N, where each N is in 0,3. Operates on two int32x4 lanes. Exposed as an external so user code can compile without cross-library inlining.

  permute_lanes [%permute 3, 2, 1, 0] x
  = (x.(3), x.(2), x.(1), x.(0), x.(7), x.(6), x.(5), x.(4))

val min : t -> t -> t @@ portable

_mm256_min_epi32

val max : t -> t -> t @@ portable

_mm256_max_epi32

val min_unsigned : t -> t -> t @@ portable

_mm256_min_epu32

val max_unsigned : t -> t -> t @@ portable

_mm256_max_epu32

val add : t -> t -> t @@ portable

_mm256_add_epi32

val sub : t -> t -> t @@ portable

_mm256_sub_epi32

val neg : t -> t @@ portable

_mm256_sign_epi32 with -1.

val abs : t -> t @@ portable

_mm256_abs_epi32 Equivalent to (x < 0 ? -x : x).

val shift_left_logical : t -> int64 -> t @@ portable

_mm256_sll_epi32

val shift_right_logical : t -> int64 -> t @@ portable

_mm256_srl_epi32

val shift_right_arithmetic : t -> int64 -> t @@ portable

_mm256_sra_epi32

val shift_left_logical_by : t -> shift:t -> t @@ portable

_mm256_sllv_epi32

val shift_right_logical_by : t -> shift:t -> t @@ portable

_mm256_srlv_epi32

val shift_right_arithmetic_by : t -> shift:t -> t @@ portable

_mm256_srav_epi32

val shifti_left_bytes_lanes : int64 -> t -> t @@ portable

_mm256_bslli_epi128 First argument must be an unsigned integer literal in 0,15. Operates on two int32x4 lanes. Exposed as an external so user code can compile without cross-library inlining.

val shifti_right_bytes_lanes : int64 -> t -> t @@ portable

_mm256_bsrli_epi128 First argument must be an unsigned integer literal in 0,15. Operates on two int32x4 lanes. Exposed as an external so user code can compile without cross-library inlining.

val shifti_left_logical : int64 -> t -> t @@ portable

_mm256_slli_epi32 First argument must be an unsigned integer literal in 0,31. Exposed as an external so user code can compile without cross-library inlining.

val shifti_right_logical : int64 -> t -> t @@ portable

_mm256_srli_epi32 First argument must be an unsigned integer literal in 0,31. Exposed as an external so user code can compile without cross-library inlining.

val shifti_right_arithmetic : int64 -> t -> t @@ portable

_mm256_srai_epi32 First argument must be an unsigned integer literal in 0,31. Exposed as an external so user code can compile without cross-library inlining.

val horizontal_add_lanes : t -> t -> t @@ portable

_mm256_hadd_epi32

val horizontal_sub_lanes : t -> t -> t @@ portable

_mm256_hsub_epi32

val mul_sign : t -> t -> t @@ portable

_mm256_sign_epi32

val mul_low_bits : t -> t -> t @@ portable

_mm256_mullo_epi32

val mul_even : t -> t -> int64x4 @@ portable

_mm256_mul_epi32

val mul_even_unsigned : t -> t -> int64x4 @@ portable

_mm256_mul_epu32

val (+) : t -> t -> t @@ portable

val (-) : t -> t -> t @@ portable

val lnot : t -> t @@ portable

Compiles to xor with a static constant.

val (lor) : t -> t -> t @@ portable

_mm256_or_si256

val (land) : t -> t -> t @@ portable

_mm256_and_si256

val landnot : not:t -> t -> t @@ portable

_mm256_andnot_si256

val (lxor) : t -> t -> t @@ portable

_mm256_xor_si256

val unsafe_of_int32x4 : int32x4 -> t @@ portable

Identity; leaves upper 128 bits unspecified.

val of_float16x16_bits : float16x16 -> t @@ portable