Remove Select trait

Merge portable-simd#195 - portable-simd:trait-ops

Generic `core::ops` for `Simd<T, _>`

In order to maintain type soundness, we need to be sure we only implement an operation for `Simd<T, _> where T: SimdElement`... and also valid for that operation in general. While we could do this purely parametrically, it is more sound to implement the operators directly for the base scalar type arguments and then use type parameters to extend the operators to the "higher order" operations.

This implements that strategy and cleans up `simd::ops` into a few submodules:
- assign.rs: `core::ops::*Assign`
- deref.rs:  `core::ops` impls which "deref" borrowed versions of the arguments
- unary.rs: encloses the logic for unary operators on `Simd`, as unary ops are much simpler

This is possible since everything need not be nested in a single maze of macros anymore. The result simplifies the logic and allows reasoning about what operators are valid based on the expressed trait bounds, and also reduces the size of the trait implementation output in rustdoc, for a huge win of 4 MB off the size of `struct.Simd.html`! This addresses a common user complaint, as the original was over 5.5 MB and capable of crashing browsers!

This also carries a fix for a type-inference-related breakage, by removing the autosplatting (vector + scalar binop) impls, as unfortunately the presence of autosplatting was capable of busting type inference. We will likely need to see results from a Crater run before we can understand how to re-land autosplatting.

impl Op<&'_ RHS> for &'_ LHS

Drop splats for Simd<T, _>

Unfortunately, splatting impls currently break several crates.
Rust needs more time to review possible mitigations, so
drop the impls for the `impl Add<T> for Simd<T, _>` pattern, for now.

impl unary.rs for Simd<{i,u}{8,16,32,64,size}, _>

In order to assure type soundness, these "base" impls
need to go directly on Simd<T, _> for every scalar type argument.
A bit of cleanup of ops.rs is still warranted.

Uncomment AVX512 byte vector conversions

Resolves my comment in #197, at least for now; #187 is pending but since these are already here, just commented, it seemed to make sense to me to re-enable them anyway.

Generically implement horizontal_{and,or,xor}

impl assign.rs<U> for Simd<T, _>

Instead of implementing {Op}Assign traits for individual scalar type args
to Simd<_, _>, use parametric impls that reassert the bounds of the binary op.

impl deref.rs<&Self> for Simd<T, _>

Instead of implementing each "deref" pattern for every single scalar,
we can use type parameters for Simd operating on &Self.
We can use a macro, but keep it cleaner and more explicit.

Attempt to support to 64 lanes

Merge pull request #192 from pro465/patch-1

Fix outdated workflow badge

Fix outdated workflow badge

Sprinkle the crate with #[must_use]

Merge pull request #190 from alex/patch-1

Update CONTRIBUTING.md for the fact that Travis is no longer used

Update CONTRIBUTING.md for the fact that Travis is no longer used

Use new bitmask intrinsics with byte arrays

Rewrite Arm transmutes, reading std::arch closer

Restrict Arm types to Arm v7+

This mostly mirrors the restrictions in std::arch.
It can be loosened slightly with later refactoring.

Dynamically detect AVX512 in CI

We would like to check for errors with AVX512,
but we don't pick our CPU. So, detect available features.
This variance in checks stochastically reveals issues.
Nondeterminism is acceptable as our goal is protecting downstream.

Deny warnings in CI and fix

Use the right name for AVX512F

Merge pull request #175 from rust-lang/feature/more-actions

Delete travis config, move tests to github actions.

Delete travis config, move tests to github actions.

Merge pull request #181 from rust-lang/rotate_lanes

rotate_{left,right} -> rotate_lanes_{left,right}

add `Simd::from_slice` (#177)

* add `Simd::from_slice`

uses a zeroed initial array and loops so that it can be const.
unfortunately, parameterizing the assert with slice length
needs `#![feature(const_fn_fn_ptr_basics)]` to work.

rotate_{left,right} -> rotate_lanes_{left,right}

Hide select impl in sealed trait

Hide mask impl details in sealed trait.

Fixup import pathing for core

This changes simd_swizzle! to a decl_macro to give it a path,
so it can be imported using a path and not the crate root.
It also adds various uses that were missed and adjusts paths.

Improve docs

Update crates/core_simd/src/swizzle.rs

Co-authored-by: Jubilee <46493976+workingjubilee@users.noreply.github.com>

Remove adt_const_params feature

simd_shuffle -> simd_swizzle

Fix macro in core

Co-authored-by: Jubilee <46493976+workingjubilee@users.noreply.github.com>

Add new swizzle API

Expand swizzle API and migrate existing functions. Add rotate_left, rotate_right.

Hide implementation details

Add simd_shuffle macro

Simplify language for scatter/gather

Co-authored-by: Caleb Zulawski <caleb.zulawski@gmail.com>

Rewrite gather/scatter docs

Headings with # Safety and # Examples are more "std style".
Use terms like "enable" and "disable", rather than "mask" jargon.

docs: fix typo gather -> scatter

Co-authored-by: Jacob Lifshay <programmerjake@gmail.com>

Add {gather,scatter}_select_unchecked

This unsafe variant allows the thinnest API, in case LLVM cannot
perform loop-invariant code motion on a hot loop when the safe
form is used.

An unchecked variant could be added to other forms, but doesn't
seem likely to improve anything, since it would just add heavier
codegen.

Add lanes() and associated LANES const

Renovate for Edition 2021

In a still-future edition, `unsafe_op_in_unsafe_fn` may error.
Let's get ahead of that.

Add associated LANES const

Add lanes()

Make sure MaskElement is in bitmasks.rs

Feature-flag fused mul-add to block libcalls

Feature-flag doc tests so they run for core

Cleanup more for std::simd also

Restructure crate as core module

Aligns module with rust-lang/library/core, creating an... unusual
architecture that is easier to pull in as a module, as core itself can
have no dependencies (as we haven't built core yet).

Fix cargo features for nightly (#155)

* Fix cargo features for nightly

Merge pull request #154 from rust-lang/feature/generic-element-type

Change vectors to be generic over element type.

Rename element type variable

Update crates/core_simd/src/vector.rs

Co-authored-by: Jubilee <46493976+workingjubilee@users.noreply.github.com>

Remove mask aliases

Remove aliases

Remove remaining usage of aliases

Remove aliases from most tests

Remove aliases from op trait impls

Remove most usage of type aliases

Remove unused transmute file

Implement comparisons generically

Implement select generically

Convert all masks to a single type

Remove Mask trait

Remove Vector trait

Change to various generic impls

Convert all vectors to a single type

Merge pull request #153 from rust-lang/death-of-the-author

Rename to portable-simd and remove other names

Rename to portable-simd and remove other names

Clean up references to the repo's previous name.
Removes the authors field, which is non-obligatory since RFC 3052.
Better to omit than confound: let git log be our witness.

Merge pull request #152 from rust-lang/feature/const_eval_checked

Feature/const eval checked
Adds the const_evaluatable_checked cargo feature for some experimental (but very useful) function implementations. Adds testing all cargo features to CI.

Change bitmasks to use less opaque type

Fix feature flag in CI

Add CI for testing cargo features

Add const_evaluatable_checked feature, change to_bitmask to use it, and fix existing std feature

Merge pull request #142 from rust-lang/feature/traits

Combine LanesAtMost32 and SimdArray into a single trait "Vector"

Attempts to fix some unresolved questions in #139 regarding `SimdArray` having a generic parameter.

In particular, this made it not appropriate for replacing `LanesAtMost32`.  Additionally, it made it impossible to use in a context where you otherwise don't know the lane count, e.g. `impl Vector`.

An unfortunate side effect of this change is that scatter/gather no longer work in the trait (nor does anything else that references the lane count in a type.  This requires the super-unstable `const_evaluatable_checked` feature).

I also threw in the change from `as_slice` to `as_array` as discussed in zulip, and fixes #51.

Add lane count marker type

Move vector implementation

Use new module naming

Change as_slice to as_array

Add as_slice/as_mut_slice to Vector

Rename SimdArray to Vector, remove its generic parameter, and remove LanesAtMost32

Add fmt and clippy to CI (#147)

* Add fmt and clippy to CI
* Add rust components
* Fix formatting

Add portable_simd unstable feature gate (#141)

Add conversions between vendor intrinsics (#144)

* Add x86 vendor conversions
* Add wasm32 vendor types
* Add arm vendor types
* Add powerpc vendor types

add matrix_inversion example (#131)

* add matrix_inversion example

Add 32-bit SIMD types i/u16x2 and i/u8x4. (#145)

These types are useful for the "SIMD32" instructions available on ARMv6
(except M-class), ARMv7 (M-class with DSP), and ARMv8.

Fix typo. Closes #140

Merge pull request #139 from rust-lang/feat/gather

Add SimdArray trait and safe gather/scatter API (rust-lang/stdsimd#139)
This PR has four parts, without which it doesn't make a lot of sense:
-    The introduction of the SimdArray trait for abstraction over vectors.
-    The implementation of private vector-of-pointers types.
-    Using these to allow constructing vectors with SimdArray::gather_{or, or_default, select}.
-    Using these to allow writing vectors using SimdArray::scatter{,_select}.

Merge pull request #138 from rust-lang/feature/various-fns

Add various fns
- Sum/Product traits
- recip/to_degrees/to_radians/min/max/clamp/signum/copysign; rust-lang/stdsimd#14
- mul_add: rust-lang/stdsimd#14, fixes rust-lang/stdsimd#102

Document and test doubled writes in scatter

Add assoc const SimdArray::LANES

Add SimdArray::scatter{,_select}

Add SimdArray::gather_{or,or_default,select}

Add pointer vectors: SimdConstPtr, SimdMutPtr

Introduce SimdArray trait

This provides a general framework for describing relationships
between vector types and scalar types.

Extract constant from scalar to_radians as well

Remove scalar Sum/Product over questionable order of operations

Add from_bitmask (#136)

* Add from_bitmask
* Add mips workaround

Fix test typo

Add mul_add

Add min/max/clamp