[API Proposal]: More Vector<T> sequence and lane APIs

Background and motivation

The existing Vector.CreateSequence provides a convenient way to generate additive sequences directly into SIMD vectors. This covers many common use cases where elements are spaced apart by a fixed step.

However, a large class of numerical algorithms rely on geometric progressions (multiplicative sequences), where each element is scaled by a constant ratio relative to the previous. Scenarios include:

Alternating sign masks ([-1, 1, -1, 1 …] with multiplier = -1).
Exponential decay weights ([1.0, 0.5, 0.25, 0.125 …] with multiplier = 0.5).
Power sequences ([1, 2, 4, 8 …] with multiplier = 2).
Basis vectors for polynomial evaluation or signal processing.
etc.

Currently, developers have to manually fill the Vector<T> with a precomputed collection (eg. new Vector<double>([-1.0, 1.0, -1.0, 1.0, -1.0, 1.0, -1.0, 1.0])). This adds boilerplate and potentially leads to suboptimal codegen if the collection is populated by loop instead of being an inline collection expression, and it also reduces readability compared to the additive case.

To support these cases, I propose adding Vector.CreateGeometricSequence(initial, multiplier) as the natural counterpart to CreateSequence. The multiplier parameter should be marked with [ConstantExpected] to avoid surprising costs from Pow when non‑constant, since the implementation is conceptually start * Pow(multiplier, indices).

In addition, some special constants and helpers are worth exposing:

Vector<T>.SignSequence { get; } (sometimes also called BipolarSequence): a built‑in alternating ±1 mask [+1, -1, +1, -1 …], extremely common in math and signal processing.
Vector.CreateAlternatingSequence(first, second): a generalization of the alternating pattern, producing [first, second, first, second …].

Other sequences such as harmonic (1 / CreateSequence(start, step)) or Cauchy (Sqrt(CreateSequence(start, step))) are mathematically simple to derive but not common enough to justify dedicated APIs. They can be expressed using existing primitives without cluttering the core surface. But I included them in this API proposal anyway.

Finally, for shuffle‑like behaviors, we can add lane operations such as Zip/Unzip (lower/higher halves and even/odd lanes) and ConcatHalves. They would provide a clean way to split and merge vectors without manual element manipulation. Alternatively, the name can be Pack/Unpack instead of Zip/Unzip, and the selector can be an enum instead of a 2-bit control byte.

API Proposal

namespace System.Numerics;

public static class Vector
{
    // The elements begin at an initial value, and each subsequent element is obtained by multiplying the previous element by the multiplier.
    [Intrinsic]
    public static Vector<T> CreateGeometricSequence<T>(T initial, [ConstantExpected] T multiplier);

    // Elements alternate between two specified values, starting with the first and then repeating the pattern.
    [Intrinsic]
    public static Vector<T> CreateAlternatingSequence<T>(T first, T second);

    // Harmonic progression: [1/start, 1/(start+step), …]
    [Intrinsic]
    public static Vector<T> CreateHarmonicSequence<T>(T start, T step);

    // Cauchy progression: [1/(i+start), …] or representable via Sqrt(CreateSequence(...))
    [Intrinsic]
    public static Vector<T> CreateCauchySequence<T>(T start, T step);

    // Interleaves the lower halves of two vectors:
    // ZipLower([1,2,3,4,5,6,7,8], [9,10,11,12,13,14,15,16])
    // => [1,9,2,10,3,11,4,12]
    [Intrinsic]
    public static Vector<T> ZipLower<T>(Vector<T> left, Vector<T> right);

    // Interleaves the upper halves of two vectors:
    // ZipUpper([1,2,3,4,5,6,7,8], [9,10,11,12,13,14,15,16])
    // => [5,13,6,14,7,15,8,16]
    [Intrinsic]
    public static Vector<T> ZipUpper<T>(Vector<T> left, Vector<T> right);

    [Intrinsic]
    public static (Vector<T> Lower, Vector<T> Upper) Zip<T>(Vector<T> left, Vector<T> right);

    // De‑interleaves the even lanes from two vectors:
    // UnzipEven([1,9,2,10,3,11,4,12], [5,13,6,14,7,15,8,16])
    // => [1,2,3,4,5,6,7,8] (the even‑indexed elements from both inputs)
    [Intrinsic]
    public static Vector<T> UnzipEven<T>(Vector<T> left, Vector<T> right);

    // De‑interleaves the odd lanes from two vectors:
    // UnzipOdd([1,9,2,10,3,11,4,12], [5,13,6,14,7,15,8,16])
    // => [9,10,11,12,13,14,15,16] (the odd‑indexed elements from both inputs)
    [Intrinsic]
    public static Vector<T> UnzipOdd<T>(Vector<T> left, Vector<T> right);

    // Splits into both even and odd at once:
    // Unzip([1,9,2,10,3,11,4,12], [5,13,6,14,7,15,8,16])
    // => ([1,2,3,4,5,6,7,8], [9,10,11,12,13,14,15,16])
    [Intrinsic]
    public static (Vector<T> Even, Vector<T> Odd) Unzip<T>(Vector<T> left, Vector<T> right);

    // Constructs a new vector by concatenating halves from two input vectors.
    // The lower half of the result comes from 'left', and the upper half comes from 'right'.
    // Use a 2-bit compile-time constant:
    // 0b00 = left lower + right lower
    // 0b01 = left lower + right upper
    // 0b10 = left upper + right lower
    // 0b11 = left upper + right upper
    // or maybe introduce an enum for the selector?
    [Intrinsic]
    public static Vector<T> ConcatHalves<T>(Vector<T> left, Vector<T> right, [ConstantExpected] byte selector);

    [Intrinsic]
    public static Vector<T> Reverse<T>(Vector<T> vector);
}

public struct Vector<T>
{
    // Elements alternate between +1 and -1, starting with +1 at element 0.
    // Sometimes also referred to as a BipolarSequence.
    public static Vector<T> SignSequence { [Intrinsic] get; }
}

// same surface for Vector64/128/256/512
namespace System.Runtime.Intrinsics;

public static class Vector64
{
    [Intrinsic]
    public static Vector64<T> CreateGeometricSequence<T>(T initial, [ConstantExpected] T multiplier);

    [Intrinsic]
    public static Vector64<T> CreateAlternatingSequence<T>(T first, T second);

    [Intrinsic]
    public static Vector64<T> CreateHarmonicSequence<T>(T start, T step);

    [Intrinsic]
    public static Vector64<T> CreateCauchySequence<T>(T start, T step);

    [Intrinsic]
    public static Vector64<T> ZipLower<T>(Vector64<T> left, Vector64<T> right);

    [Intrinsic]
    public static Vector64<T> ZipUpper<T>(Vector64<T> left, Vector64<T> right);

    [Intrinsic]
    public static (Vector64<T> Lower, Vector64<T> Upper) Zip<T>(Vector64<T> left, Vector64<T> right);

    [Intrinsic]
    public static Vector64<T> UnzipEven<T>(Vector64<T> left, Vector64<T> right);

    [Intrinsic]
    public static Vector64<T> UnzipOdd<T>(Vector64<T> left, Vector64<T> right);

    [Intrinsic]
    public static (Vector64<T> Even, Vector64<T> Odd) Unzip<T>(Vector64<T> left, Vector64<T> right);

    [Intrinsic]
    public static Vector64<T> ConcatHalves<T>(Vector64<T> left, Vector64<T> right, [ConstantExpected] byte selector);

    [Intrinsic]
    public static Vector64<T> Reverse<T>(Vector64<T> vector);
}

public struct Vector64<T>
{
    public static Vector64<T> SignSequence { [Intrinsic] get; }
}

public static class Vector128
{
    [Intrinsic]
    public static Vector128<T> CreateGeometricSequence<T>(T initial, [ConstantExpected] T multiplier);

    [Intrinsic]
    public static Vector128<T> CreateAlternatingSequence<T>(T first, T second);

    [Intrinsic]
    public static Vector128<T> CreateHarmonicSequence<T>(T start, T step);

    [Intrinsic]
    public static Vector128<T> CreateCauchySequence<T>(T start, T step);

    [Intrinsic]
    public static Vector128<T> ZipLower<T>(Vector128<T> left, Vector128<T> right);

    [Intrinsic]
    public static Vector128<T> ZipUpper<T>(Vector128<T> left, Vector128<T> right);

    [Intrinsic]
    public static (Vector128<T> Lower, Vector128<T> Upper) Zip<T>(Vector128<T> left, Vector128<T> right);

    [Intrinsic]
    public static Vector128<T> UnzipEven<T>(Vector128<T> left, Vector128<T> right);

    [Intrinsic]
    public static Vector128<T> UnzipOdd<T>(Vector128<T> left, Vector128<T> right);

    [Intrinsic]
    public static (Vector128<T> Even, Vector128<T> Odd) Unzip<T>(Vector128<T> left, Vector128<T> right);

    [Intrinsic]
    public static Vector128<T> ConcatHalves<T>(Vector128<T> left, Vector128<T> right, [ConstantExpected] byte selector);

    [Intrinsic]
    public static Vector128<T> Reverse<T>(Vector128<T> vector);
}

public struct Vector128<T>
{
    public static Vector128<T> SignSequence { [Intrinsic] get; }
}

public static class Vector256
{
    [Intrinsic]
    public static Vector256<T> CreateGeometricSequence<T>(T initial, [ConstantExpected] T multiplier);

    [Intrinsic]
    public static Vector256<T> CreateAlternatingSequence<T>(T first, T second);

    [Intrinsic]
    public static Vector256<T> CreateHarmonicSequence<T>(T start, T step);

    [Intrinsic]
    public static Vector256<T> CreateCauchySequence<T>(T start, T step);

    [Intrinsic]
    public static Vector256<T> ZipLower<T>(Vector256<T> left, Vector256<T> right);

    [Intrinsic]
    public static Vector256<T> ZipUpper<T>(Vector256<T> left, Vector256<T> right);

    [Intrinsic]
    public static (Vector256<T> Lower, Vector256<T> Upper) Zip<T>(Vector256<T> left, Vector256<T> right);

    [Intrinsic]
    public static Vector256<T> UnzipEven<T>(Vector256<T> left, Vector256<T> right);

    [Intrinsic]
    public static Vector256<T> UnzipOdd<T>(Vector256<T> left, Vector256<T> right);

    [Intrinsic]
    public static (Vector256<T> Even, Vector256<T> Odd) Unzip<T>(Vector256<T> left, Vector256<T> right);

    [Intrinsic]
    public static Vector256<T> ConcatHalves<T>(Vector256<T> left, Vector256<T> right, [ConstantExpected] byte selector);

    [Intrinsic]
    public static Vector256<T> Reverse<T>(Vector256<T> vector);
}

public struct Vector256<T>
{
    public static Vector256<T> SignSequence { [Intrinsic] get; }
}

public static class Vector512
{
    [Intrinsic]
    public static Vector512<T> CreateGeometricSequence<T>(T initial, [ConstantExpected] T multiplier);

    [Intrinsic]
    public static Vector512<T> CreateAlternatingSequence<T>(T first, T second);

    [Intrinsic]
    public static Vector512<T> CreateHarmonicSequence<T>(T start, T step);

    [Intrinsic]
    public static Vector512<T> CreateCauchySequence<T>(T start, T step);

    [Intrinsic]
    public static Vector512<T> ZipLower<T>(Vector512<T> left, Vector512<T> right);

    [Intrinsic]
    public static Vector512<T> ZipUpper<T>(Vector512<T> left, Vector512<T> right);

    [Intrinsic]
    public static (Vector512<T> Lower, Vector512<T> Upper) Zip<T>(Vector512<T> left, Vector512<T> right);

    [Intrinsic]
    public static Vector512<T> UnzipEven<T>(Vector512<T> left, Vector512<T> right);

    [Intrinsic]
    public static Vector512<T> UnzipOdd<T>(Vector512<T> left, Vector512<T> right);

    [Intrinsic]
    public static (Vector512<T> Even, Vector512<T> Odd) Unzip<T>(Vector512<T> left, Vector512<T> right);

    [Intrinsic]
    public static Vector512<T> ConcatHalves<T>(Vector512<T> left, Vector512<T> right, [ConstantExpected] byte selector);

    [Intrinsic]
    public static Vector512<T> Reverse<T>(Vector512<T> vector);
}

public struct Vector512<T>
{
    public static Vector512<T> SignSequence { [Intrinsic] get; }
}

API Usage

// Arithmetic progression: [0, 1, 2, 3 …]
var seq = Vector.CreateSequence(0.0, 1.0);

// Geometric progression: [1, 2, 4, 8 …]
var powers = Vector.CreateGeometricSequence(1.0, 2.0);

// Alternating progression: [5, -5, 5, -5 …]
var alt = Vector.CreateAlternatingSequence(5.0);

// Alternating mask: [1, -1, 1, -1 …]
var mask = Vector.SignSequence<double>;

// Invert the mask: [-1, 1, -1, 1 …]
var invertedMask = -Vector.SignSequence<double>;

// Lane operations

// Interleave lower halves of two vectors
var zipLower = Vector.ZipLower(vector1, vector2);

// Interleave upper halves of two vectors
var ZipUpper = Vector.ZipUpper(vector1, vector2);

// De‑interleave even lanes from two vectors
var unzipEven = Vector.UnzipEven(zipLower, ZipUpper);

// De‑interleave odd lanes from two vectors
var unzipOdd = Vector.UnzipOdd(zipLower, ZipUpper);

// Take lower half of 'a' and upper half of 'b': [a0..aN/2-1, bN/2..bN-1]
var result = Vector.ConcatHalves(a, b, 0b01);
...

Alternative Designs

No response

Risks

No response

I think this is overall reasonable and would be a good counterpart to CreateSequence which is logically the arithmetic sequence. We would want to mark T multiplier with [ConstantExpected, however, due to the cost of Pow for non-constant likely being unexpected for a Create API and noting that it is start * Pow(step, Indices) as the implementation (where-as CreateSequence is start + (step * Indices), so it's just adding a multiplicative layer to each).

I think it is worth simultaneously proposing SignSequence which will be +1, -1, +1, -1, ... for this very common case (sometimes also called BipolarSequence). Having a CreateAlternatingSequence(T first, T second) might be reasonable as well.

I don't think that CreateCauchySequence (Sqrt(CreateSequence(start, step))) or CreateHarmonicSequence (1 / CreateSequence(start, step))) would be necessary to expose, despite being "simple" to implement as they probably aren't common enough. I can't think of any other Create*Sequence APIs that would be worthwhile off the top of my head...

Having some variant of unpack/zip or pack/unzip for low/high or even/odd pairs would likely also be beneficial for the specialized shuffle APIs. I think we have most of the other cases that are beneficial for vectors of unknown length at this point, however.

Updated the original proposal to cover more sequence and lane operations.

Tagging subscribers to this area: @dotnet/area-system-runtime-intrinsics
See info in area-owners.md if you want to be subscribed.

Made a few fixes to the proposal:

Changed UnzipEvenOdd to just Unzip
Added the tuple overload of Zip that produces lower/upper simultaneously
Renamed Higher to Upper, to match existing convention
Added Reverse to cover the other common request

Rather than ConcatHalves with a byte selector, we expanded the method into ConcatLowerLower...ConcatUpperUpper
CreateAlternatingSequence(first, second) => CreateAlternatingSequence(even, odd)

namespace System.Numerics;

public static class Vector
{
    // The elements begin at an initial value, and each subsequent element is obtained by multiplying the previous element by the multiplier.
    [Intrinsic]
    public static Vector<T> CreateGeometricSequence<T>(T initial, [ConstantExpected] T multiplier);

    // Elements alternate between two specified values, starting with the first and then repeating the pattern.
    [Intrinsic]
    public static Vector<T> CreateAlternatingSequence<T>(T even, T odd);

    // Harmonic progression: [1/start, 1/(start+step), …]
    [Intrinsic]
    public static Vector<T> CreateHarmonicSequence<T>(T start, T step);

    // Cauchy progression: [1/(i+start), …] or representable via Sqrt(CreateSequence(...))
    [Intrinsic]
    public static Vector<T> CreateCauchySequence<T>(T start, T step);

    // Interleaves the lower halves of two vectors:
    // ZipLower([1,2,3,4,5,6,7,8], [9,10,11,12,13,14,15,16])
    // => [1,9,2,10,3,11,4,12]
    [Intrinsic]
    public static Vector<T> ZipLower<T>(Vector<T> left, Vector<T> right);

    // Interleaves the upper halves of two vectors:
    // ZipUpper([1,2,3,4,5,6,7,8], [9,10,11,12,13,14,15,16])
    // => [5,13,6,14,7,15,8,16]
    [Intrinsic]
    public static Vector<T> ZipUpper<T>(Vector<T> left, Vector<T> right);

    [Intrinsic]
    public static (Vector<T> Lower, Vector<T> Upper) Zip<T>(Vector<T> left, Vector<T> right);

    // De‑interleaves the even lanes from two vectors:
    // UnzipEven([1,9,2,10,3,11,4,12], [5,13,6,14,7,15,8,16])
    // => [1,2,3,4,5,6,7,8] (the even‑indexed elements from both inputs)
    [Intrinsic]
    public static Vector<T> UnzipEven<T>(Vector<T> left, Vector<T> right);

    // De‑interleaves the odd lanes from two vectors:
    // UnzipOdd([1,9,2,10,3,11,4,12], [5,13,6,14,7,15,8,16])
    // => [9,10,11,12,13,14,15,16] (the odd‑indexed elements from both inputs)
    [Intrinsic]
    public static Vector<T> UnzipOdd<T>(Vector<T> left, Vector<T> right);

    // Splits into both even and odd at once:
    // Unzip([1,9,2,10,3,11,4,12], [5,13,6,14,7,15,8,16])
    // => ([1,2,3,4,5,6,7,8], [9,10,11,12,13,14,15,16])
    [Intrinsic]
    public static (Vector<T> Even, Vector<T> Odd) Unzip<T>(Vector<T> left, Vector<T> right);

    public static Vector<T> ConcatLowerLower<T>(Vector<T> left, Vector<T> right);
    public static Vector<T> ConcatUpperLower<T>(Vector<T> left, Vector<T> right);
    public static Vector<T> ConcatUpperUpper<T>(Vector<T> left, Vector<T> right);
    public static Vector<T> ConcatLowerUpper<T>(Vector<T> left, Vector<T> right);

    [Intrinsic]
    public static Vector<T> Reverse<T>(Vector<T> vector);
}

public struct Vector<T>
{
    // Elements alternate between +1 and -1, starting with +1 at element 0.
    // Sometimes also referred to as a BipolarSequence.
    public static Vector<T> SignSequence { [Intrinsic] get; }
}

// same surface for Vector64/128/256/512
namespace System.Runtime.Intrinsics;

public static class Vector64
{
    [Intrinsic]
    public static Vector64<T> CreateGeometricSequence<T>(T initial, [ConstantExpected] T multiplier);

    [Intrinsic]
    public static Vector64<T> CreateAlternatingSequence<T>(T even, T odd);

    [Intrinsic]
    public static Vector64<T> CreateHarmonicSequence<T>(T start, T step);

    [Intrinsic]
    public static Vector64<T> CreateCauchySequence<T>(T start, T step);

    [Intrinsic]
    public static Vector64<T> ZipLower<T>(Vector64<T> left, Vector64<T> right);

    [Intrinsic]
    public static Vector64<T> ZipUpper<T>(Vector64<T> left, Vector64<T> right);

    [Intrinsic]
    public static (Vector64<T> Lower, Vector64<T> Upper) Zip<T>(Vector64<T> left, Vector64<T> right);

    [Intrinsic]
    public static Vector64<T> UnzipEven<T>(Vector64<T> left, Vector64<T> right);

    [Intrinsic]
    public static Vector64<T> UnzipOdd<T>(Vector64<T> left, Vector64<T> right);

    [Intrinsic]
    public static (Vector64<T> Even, Vector64<T> Odd) Unzip<T>(Vector64<T> left, Vector64<T> right);

    public static Vector64<T> ConcatLowerLower<T>(Vector64<T> left, Vector64<T> right);
    public static Vector64<T> ConcatUpperLower<T>(Vector64<T> left, Vector64<T> right);
    public static Vector64<T> ConcatUpperUpper<T>(Vector64<T> left, Vector64<T> right);
    public static Vector64<T> ConcatLowerUpper<T>(Vector64<T> left, Vector64<T> right);

    [Intrinsic]
    public static Vector64<T> Reverse<T>(Vector64<T> vector);
}

public struct Vector64<T>
{
    public static Vector64<T> SignSequence { [Intrinsic] get; }
}

public static class Vector128
{
    [Intrinsic]
    public static Vector128<T> CreateGeometricSequence<T>(T initial, [ConstantExpected] T multiplier);

    [Intrinsic]
    public static Vector128<T> CreateAlternatingSequence<T>(T even, T odd);

    [Intrinsic]
    public static Vector128<T> CreateHarmonicSequence<T>(T start, T step);

    [Intrinsic]
    public static Vector128<T> CreateCauchySequence<T>(T start, T step);

    [Intrinsic]
    public static Vector128<T> ZipLower<T>(Vector128<T> left, Vector128<T> right);

    [Intrinsic]
    public static Vector128<T> ZipUpper<T>(Vector128<T> left, Vector128<T> right);

    [Intrinsic]
    public static (Vector128<T> Lower, Vector128<T> Upper) Zip<T>(Vector128<T> left, Vector128<T> right);

    [Intrinsic]
    public static Vector128<T> UnzipEven<T>(Vector128<T> left, Vector128<T> right);

    [Intrinsic]
    public static Vector128<T> UnzipOdd<T>(Vector128<T> left, Vector128<T> right);

    [Intrinsic]
    public static (Vector128<T> Even, Vector128<T> Odd) Unzip<T>(Vector128<T> left, Vector128<T> right);

    public static Vector128<T> ConcatLowerLower<T>(Vector128<T> left, Vector128<T> right);
    public static Vector128<T> ConcatUpperLower<T>(Vector128<T> left, Vector128<T> right);
    public static Vector128<T> ConcatUpperUpper<T>(Vector128<T> left, Vector128<T> right);
    public static Vector128<T> ConcatLowerUpper<T>(Vector128<T> left, Vector128<T> right);

    [Intrinsic]
    public static Vector128<T> Reverse<T>(Vector128<T> vector);
}

public struct Vector128<T>
{
    public static Vector128<T> SignSequence { [Intrinsic] get; }
}

public static class Vector256
{
    [Intrinsic]
    public static Vector256<T> CreateGeometricSequence<T>(T initial, [ConstantExpected] T multiplier);

    [Intrinsic]
    public static Vector256<T> CreateAlternatingSequence<T>(T even, T odd);

    [Intrinsic]
    public static Vector256<T> CreateHarmonicSequence<T>(T start, T step);

    [Intrinsic]
    public static Vector256<T> CreateCauchySequence<T>(T start, T step);

    [Intrinsic]
    public static Vector256<T> ZipLower<T>(Vector256<T> left, Vector256<T> right);

    [Intrinsic]
    public static Vector256<T> ZipUpper<T>(Vector256<T> left, Vector256<T> right);

    [Intrinsic]
    public static (Vector256<T> Lower, Vector256<T> Upper) Zip<T>(Vector256<T> left, Vector256<T> right);

    [Intrinsic]
    public static Vector256<T> UnzipEven<T>(Vector256<T> left, Vector256<T> right);

    [Intrinsic]
    public static Vector256<T> UnzipOdd<T>(Vector256<T> left, Vector256<T> right);

    [Intrinsic]
    public static (Vector256<T> Even, Vector256<T> Odd) Unzip<T>(Vector256<T> left, Vector256<T> right);

    public static Vector256<T> ConcatLowerLower<T>(Vector256<T> left, Vector256<T> right);
    public static Vector256<T> ConcatUpperLower<T>(Vector256<T> left, Vector256<T> right);
    public static Vector256<T> ConcatUpperUpper<T>(Vector256<T> left, Vector256<T> right);
    public static Vector256<T> ConcatLowerUpper<T>(Vector256<T> left, Vector256<T> right);

    [Intrinsic]
    public static Vector256<T> Reverse<T>(Vector256<T> vector);
}

public struct Vector256<T>
{
    public static Vector256<T> SignSequence { [Intrinsic] get; }
}

public static class Vector512
{
    [Intrinsic]
    public static Vector512<T> CreateGeometricSequence<T>(T initial, [ConstantExpected] T multiplier);

    [Intrinsic]
    public static Vector512<T> CreateAlternatingSequence<T>(T even, T odd);

    [Intrinsic]
    public static Vector512<T> CreateHarmonicSequence<T>(T start, T step);

    [Intrinsic]
    public static Vector512<T> CreateCauchySequence<T>(T start, T step);

    [Intrinsic]
    public static Vector512<T> ZipLower<T>(Vector512<T> left, Vector512<T> right);

    [Intrinsic]
    public static Vector512<T> ZipUpper<T>(Vector512<T> left, Vector512<T> right);

    [Intrinsic]
    public static (Vector512<T> Lower, Vector512<T> Upper) Zip<T>(Vector512<T> left, Vector512<T> right);

    [Intrinsic]
    public static Vector512<T> UnzipEven<T>(Vector512<T> left, Vector512<T> right);

    [Intrinsic]
    public static Vector512<T> UnzipOdd<T>(Vector512<T> left, Vector512<T> right);

    [Intrinsic]
    public static (Vector512<T> Even, Vector512<T> Odd) Unzip<T>(Vector512<T> left, Vector512<T> right);

    public static Vector512<T> ConcatLowerLower<T>(Vector512<T> left, Vector512<T> right);
    public static Vector512<T> ConcatUpperLower<T>(Vector512<T> left, Vector512<T> right);
    public static Vector512<T> ConcatUpperUpper<T>(Vector512<T> left, Vector512<T> right);
    public static Vector512<T> ConcatLowerUpper<T>(Vector512<T> left, Vector512<T> right);

    [Intrinsic]
    public static Vector512<T> Reverse<T>(Vector512<T> vector);
}

public struct Vector512<T>
{
    public static Vector512<T> SignSequence { [Intrinsic] get; }
}

Add lane construction and composition APIs (#127690)

Add lane construction and composition APIs (dotnet#127690)

Navigation Menu

Repository navigation

[API Proposal]: More Vector<T> sequence and lane APIs #122557

Background and motivation

API Proposal

API Usage

Alternative Designs

Risks

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

[API Proposal]: More Vector<T> sequence and lane APIs #122557

Description

Background and motivation

API Proposal

API Usage

Alternative Designs

Risks

Activity

tannergooding commented on Dec 15, 2025

hez2010 commented on Dec 15, 2025

dotnet-policy-service commented on Dec 15, 2025

tannergooding commented on Dec 15, 2025

bartonjs commented on Feb 17, 2026

Metadata

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Issue actions