search

dotnet / runtime

.NET is a cross-platform runtime for cloud, mobile, desktop, and IoT apps.
https://docs.microsoft.com/dotnet/core/
MIT License
15.26k stars 4.73k forks source link

[API Proposal]: Arm64: FEAT_SVE: mask #93964

Open a74nh opened 1 year ago

a74nh commented 1 year ago 
namespace System.Runtime.Intrinsics.Arm;

/// VectorT Summary
public abstract partial class Sve : AdvSimd /// Feature: FEAT_SVE  Category: mask
{

  /// T: float, double
  public static unsafe Vector<T> AbsoluteCompareGreaterThan(Vector<T> left, Vector<T> right); // FACGT // predicated

  /// T: float, double
  public static unsafe Vector<T> AbsoluteCompareGreaterThanOrEqual(Vector<T> left, Vector<T> right); // FACGE // predicated

  /// T: float, double
  public static unsafe Vector<T> AbsoluteCompareLessThan(Vector<T> left, Vector<T> right); // FACGT // predicated

  /// T: float, double
  public static unsafe Vector<T> AbsoluteCompareLessThanOrEqual(Vector<T> left, Vector<T> right); // FACGE // predicated

  /// T: float, double, int, long, uint, ulong
  public static unsafe Vector<T> Compact(Vector<T> mask, Vector<T> value); // COMPACT

  /// T: float, double, sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> CompareEqual(Vector<T> left, Vector<T> right); // FCMEQ or CMPEQ // predicated

  /// T: [sbyte, long], [short, long], [int, long]
  public static unsafe Vector<T> CompareEqual(Vector<T> left, Vector<T2> right); // CMPEQ // predicated

  /// T: float, double, sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> CompareGreaterThan(Vector<T> left, Vector<T> right); // FCMGT or CMPGT or CMPHI // predicated

  /// T: [sbyte, long], [short, long], [int, long], [byte, ulong], [ushort, ulong], [uint, ulong]
  public static unsafe Vector<T> CompareGreaterThan(Vector<T> left, Vector<T2> right); // CMPGT or CMPHI // predicated

  /// T: float, double, sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> CompareGreaterThanOrEqual(Vector<T> left, Vector<T> right); // FCMGE or CMPGE or CMPHS // predicated

  /// T: [sbyte, long], [short, long], [int, long], [byte, ulong], [ushort, ulong], [uint, ulong]
  public static unsafe Vector<T> CompareGreaterThanOrEqual(Vector<T> left, Vector<T2> right); // CMPGE or CMPHS // predicated

  /// T: float, double, sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> CompareLessThan(Vector<T> left, Vector<T> right); // FCMGT or CMPGT or CMPHI // predicated

  /// T: [sbyte, long], [short, long], [int, long], [byte, ulong], [ushort, ulong], [uint, ulong]
  public static unsafe Vector<T> CompareLessThan(Vector<T> left, Vector<T2> right); // CMPLT or CMPLO // predicated

  /// T: float, double, sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> CompareLessThanOrEqual(Vector<T> left, Vector<T> right); // FCMGE or CMPGE or CMPHS // predicated

  /// T: [sbyte, long], [short, long], [int, long], [byte, ulong], [ushort, ulong], [uint, ulong]
  public static unsafe Vector<T> CompareLessThanOrEqual(Vector<T> left, Vector<T2> right); // CMPLE or CMPLS // predicated

  /// T: float, double, sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> CompareNotEqualTo(Vector<T> left, Vector<T> right); // FCMNE or CMPNE // predicated

  /// T: [sbyte, long], [short, long], [int, long]
  public static unsafe Vector<T> CompareNotEqualTo(Vector<T> left, Vector<T2> right); // CMPNE // predicated

  /// T: float, double
  public static unsafe Vector<T> CompareUnordered(Vector<T> left, Vector<T> right); // FCMUO // predicated

  /// T: float, double, sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> ConditionalExtractAfterLastActiveElement(Vector<T> mask, Vector<T> fallback, Vector<T> data); // CLASTA // MOVPRFX

  /// T: float, double, sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> ConditionalExtractLastActiveElement(Vector<T> mask, Vector<T> fallback, Vector<T> data); // CLASTB // MOVPRFX

  /// T: float, double, sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> ConditionalSelect(Vector<T> mask, Vector<T> left, Vector<T> right); // SEL

  /// T: sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> CreateBreakAfterMask(Vector<T> mask, Vector<T> from); // BRKA // predicated

  /// T: sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> CreateBreakAfterPropagateMask(Vector<T> mask, Vector<T> left, Vector<T> right); // BRKPA

  /// T: sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> CreateBreakBeforeMask(Vector<T> mask, Vector<T> from); // BRKB // predicated

  /// T: sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> CreateBreakBeforePropagateMask(Vector<T> mask, Vector<T> left, Vector<T> right); // BRKPB

  /// T: byte, ushort, uint, ulong
  public static unsafe Vector<T> CreateWhileLessThanMask(int left, int right); // WHILELT

  /// T: byte, ushort, uint, ulong
  public static unsafe Vector<T> CreateWhileLessThanMask(long left, long right); // WHILELT

  /// T: byte, ushort, uint, ulong
  public static unsafe Vector<T> CreateWhileLessThanMask(uint left, uint right); // WHILELO

  /// T: byte, ushort, uint, ulong
  public static unsafe Vector<T> CreateWhileLessThanMask(ulong left, ulong right); // WHILELO

  /// T: byte, ushort, uint, ulong
  public static unsafe Vector<T> CreateWhileLessThanOrEqualMask(int left, int right); // WHILELE

  /// T: byte, ushort, uint, ulong
  public static unsafe Vector<T> CreateWhileLessThanOrEqualMask(long left, long right); // WHILELE

  /// T: byte, ushort, uint, ulong
  public static unsafe Vector<T> CreateWhileLessThanOrEqualMask(uint left, uint right); // WHILELS

  /// T: byte, ushort, uint, ulong
  public static unsafe Vector<T> CreateWhileLessThanOrEqualMask(ulong left, ulong right); // WHILELS

  /// T: float, double, sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe T ExtractAfterLast(Vector<T> value); // LASTA // predicated

  /// T: float, double, sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe T ExtractLast(Vector<T> value); // LASTB // predicated

  /// T: float, double, sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> ExtractVector(Vector<T> upper, Vector<T> lower, ulong index); // EXT // MOVPRFX

  public static unsafe Vector<byte> FalseMask(); // PFALSE

  /// T: byte, ushort, uint, ulong
  public static unsafe Vector<T> MaskGetFirstSet(Vector<T> mask, Vector<T> from); // PNEXT

  /// T: sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> MaskSetFirst(Vector<T> mask, Vector<T> from); // PFIRST

  /// T: sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe bool MaskTestAnyTrue(Vector<T> mask, Vector<T> from); // PTEST

  /// T: sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe bool MaskTestFirstTrue(Vector<T> mask, Vector<T> from); // PTEST

  /// T: sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe bool MaskTestLastTrue(Vector<T> mask, Vector<T> from); // PTEST

  /// T: sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> PropagateBreak(Vector<T> left, Vector<T> right); // BRKN // predicated

  public static unsafe Vector<byte> TrueMask(); // PTRUE

  public static unsafe Vector<byte> TrueMask([ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All); // PTRUE

  // All patterns used by PTRUE.
  public enum SveMaskPattern : byte
  {
    LargestPowerOf2 = 0,   // The largest power of 2.
    VectorCount1 = 1,    // 1 element.
    VectorCount2 = 2,    // 2 elements.
    VectorCount3 = 3,    // 3 elements.
    VectorCount4 = 4,    // 4 elements.
    VectorCount5 = 5,    // 5 elements.
    VectorCount6 = 6,    // 6 elements.
    VectorCount7 = 7,    // 7 elements.
    VectorCount8 = 8,    // 8 elements.
    VectorCount16 = 9,   // 16 elements.
    VectorCount32 = 10,  // 32 elements.
    VectorCount64 = 11,  // 64 elements.
    VectorCount128 = 12, // 128 elements.
    VectorCount256 = 13, // 256 elements.
    LargestMultipleOf4 = 29,  // The largest multiple of 4.
    LargestMultipleOf3 = 30,  // The largest multiple of 3.
    All  = 31    // All available (implicitly a multiple of two).
  };

  /// total method signatures: 45

  /// Optional Entries:

  /// T: float, double
  public static unsafe Vector<T> AbsoluteCompareGreaterThan(Vector<T> left, T right); // FACGT // predicated

  /// T: float, double
  public static unsafe Vector<T> AbsoluteCompareGreaterThanOrEqual(Vector<T> left, T right); // FACGE // predicated

  /// T: float, double
  public static unsafe Vector<T> AbsoluteCompareLessThan(Vector<T> left, T right); // FACGT // predicated

  /// T: float, double
  public static unsafe Vector<T> AbsoluteCompareLessThanOrEqual(Vector<T> left, T right); // FACGE // predicated

  /// T: float, double, sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> CompareEqual(Vector<T> left, T right); // FCMEQ or CMPEQ // predicated

  /// T: sbyte, short, int
  public static unsafe Vector<T> CompareEqual(Vector<T> left, long right); // CMPEQ // predicated

  /// T: float, double, sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> CompareGreaterThan(Vector<T> left, T right); // FCMGT or CMPGT or CMPHI // predicated

  /// T: sbyte, short, int
  public static unsafe Vector<T> CompareGreaterThan(Vector<T> left, long right); // CMPGT // predicated

  /// T: byte, ushort, uint
  public static unsafe Vector<T> CompareGreaterThan(Vector<T> left, ulong right); // CMPHI // predicated

  /// T: float, double, sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> CompareGreaterThanOrEqual(Vector<T> left, T right); // FCMGE or CMPGE or CMPHS // predicated

  /// T: sbyte, short, int
  public static unsafe Vector<T> CompareGreaterThanOrEqual(Vector<T> left, long right); // CMPGE // predicated

  /// T: byte, ushort, uint
  public static unsafe Vector<T> CompareGreaterThanOrEqual(Vector<T> left, ulong right); // CMPHS // predicated

  /// T: float, double, sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> CompareLessThan(Vector<T> left, T right); // FCMLT or FCMGT or CMPLT or CMPGT or CMPLO or CMPHI // predicated

  /// T: sbyte, short, int
  public static unsafe Vector<T> CompareLessThan(Vector<T> left, long right); // CMPLT // predicated

  /// T: byte, ushort, uint
  public static unsafe Vector<T> CompareLessThan(Vector<T> left, ulong right); // CMPLO // predicated

  /// T: float, double, sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> CompareLessThanOrEqual(Vector<T> left, T right); // FCMLE or FCMGE or CMPLE or CMPGE or CMPLS or CMPHS // predicated

  /// T: sbyte, short, int
  public static unsafe Vector<T> CompareLessThanOrEqual(Vector<T> left, long right); // CMPLE // predicated

  /// T: byte, ushort, uint
  public static unsafe Vector<T> CompareLessThanOrEqual(Vector<T> left, ulong right); // CMPLS // predicated

  /// T: float, double, sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> CompareNotEqualTo(Vector<T> left, T right); // FCMNE or CMPNE // predicated

  /// T: sbyte, short, int
  public static unsafe Vector<T> CompareNotEqualTo(Vector<T> left, long right); // CMPNE // predicated

  /// T: float, double
  public static unsafe Vector<T> CompareUnordered(Vector<T> left, T right); // FCMUO // predicated

  /// T: float, double, sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe T ConditionalExtractAfterLastActiveElement(Vector<T> mask, T fallback, Vector<T> data); // CLASTA

  /// T: float, double, sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe T ConditionalExtractLastActiveElement(Vector<T> mask, T fallback, Vector<T> data); // CLASTB

  /// total optional method signatures: 23

}

For all methods where the first argument is a vector mask, this is used used to determine the active elements in the input.

TrueMask

Set elements of the destination predicate to true if the element number satisfies the constraint pattern, or to false otherwise. If the constraint specifies more elements than are available at the current vector length then all elements of the destination predicate are set to false.

Returns a byte mask. This can safely be cast to a mask of any Vector type.

Compact

Shuffle active elements of vector to the right and fill with zero Read the active elements from the source vector and pack them into the lowest-numbered elements of the destination vector. Then set any remaining elements of the destination vector to zero.

CreateWhileLessThanMask

While incrementing signed scalar less than scalar

Generate a mask that starting from the lowest numbered element is true while the incrementing value of the scalar operand left is less than the scalar right operand and false thereafter up to the highest numbered element.

This is used to create a mask for the current iteration of a loop, where the final iteration may not fill a full vector width. For example:

// Add all values in an array
for (i=0; i<size; i++)
{
  vector<int> mask = Sve.CreateWhileLessThanMask(i, size);
  vector<int> values = Sve.LoadVectorInt32(mask, base);
  total = Sve.ConditionalSelect(mask, total + values, total);
  base += Sve.GetActiveElementCount(mask);
}
return Sve.AddReduce(total);

CreateWhileLessThanOrEqualMask

While incrementing signed scalar less than scalar. Similar to CreateWhileLessThanMask.

MaskSetFirst

Set the first active mask element to true

Returns a copy of the mask from, with the first active element set to true.

MaskGetFirstSet

Find next active predicate

Used to construct a loop which iterates over all true elements in mask.

If all elements in the mask from are false it finds the first true element in mask. Otherwise it finds the next true element in mask that follows the last true element in from. Returns a mask with the found element true and all other elements false.

TODO: add example.

CreateBreakAfterMask

Break after first true condition

Returns a mask containing true up to and including the first active element in from that is also true. All subsequent elements are set to false. Inactive elements in the destination predicate register remain unmodified or are set to zero, depending on whether merging or zeroing predication is selected

//  for (int i = 0; i < n; i++)
//  {
//    res += a[i] * b[i];
//    if (a[i] == 512) { break; }
//  }
for (int i = 0;
       Sve.TestFirstTrue(Sve.TrueMask(), p0 = Sve.CreateWhileLessThanMask(i, n)); 
       i += Count32BitElements())
  {
    vector<unit> a_vec = Sve.LoadVector(p0, a);
    vector<unit> b_vec = Sve.LoadVector(p0, b);
    vector<unit> p1 = Sve.CompareEqual(p0, a_vec, 512);
    if (Sve.TestAnyTrue(p0, p1))
    {  
      // One of the entries is 512. Get a mask that is true to the first match.
      // Do the final entries with the mask.
      p1 = Sve.CreateBreakAfterMask(p0, p1);
      res_vec = Sve.ConditionalSelect(p1, Sve.MultiplyAdd(, res_vec, a_vec, b_vec), res_vec);
      break;
    }
    else
    {
      // Use the loop mask p0. For the final iteration this may be a parital vector.
      res_vec = Sve.ConditionalSelect(p0, Sve.MultiplyAdd(, res_vec, a_vec, b_vec), res_vec);
      a += Sve.Count32BitElements();
      b += Sve.Count32BitElements();
    }
  }
  return Sve.AddAcross(res_vec);

CreateBreakAfterPropagateMask, CreateBreakBeforePropagateMask

ExtractAfterLast, ConditionalExtractAfterLastActiveElement

ghost commented 1 year ago

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

Issue Details
```csharp namespace System.Runtime.Intrinsics.Arm /// VectorT Summary public abstract class Sve : AdvSimd /// Feature: FEAT_SVE Category: mask { /// T: float, double public static unsafe Vector AbsoluteCompareGreaterThan(Vector left, Vector right); /// T: float, double public static unsafe Vector AbsoluteCompareGreaterThanOrEqual(Vector left, Vector right); /// T: float, double public static unsafe Vector AbsoluteCompareLessThan(Vector left, Vector right); /// T: float, double public static unsafe Vector AbsoluteCompareLessThanOrEqual(Vector left, Vector right); /// T: sbyte, short, int, long, byte, ushort, uint, ulong public static unsafe Vector BreakAfter(Vector value); /// T: sbyte, short, int, long, byte, ushort, uint, ulong public static unsafe Vector BreakAfterPropagate(Vector left, Vector right); /// T: sbyte, short, int, long, byte, ushort, uint, ulong public static unsafe Vector BreakBefore(Vector value); /// T: sbyte, short, int, long, byte, ushort, uint, ulong public static unsafe Vector BreakBeforePropagate(Vector left, Vector right); /// T: float, double, int, long, uint, ulong public static unsafe Vector Compact(Vector mask, Vector op); /// T: float, double, sbyte, short, int, long, byte, ushort, uint, ulong public static unsafe Vector CompareEqualTo(Vector left, Vector right); /// T: [sbyte, long], [short, long], [int, long] public static unsafe Vector CompareEqualTo(Vector left, Vector right); /// T: float, double, sbyte, short, int, long, byte, ushort, uint, ulong public static unsafe Vector CompareGreaterThan(Vector left, Vector right); /// T: [sbyte, long], [short, long], [int, long], [byte, ulong], [ushort, ulong], [uint, ulong] public static unsafe Vector CompareGreaterThan(Vector left, Vector right); /// T: float, double, sbyte, short, int, long, byte, ushort, uint, ulong public static unsafe Vector CompareGreaterThanOrEqual(Vector left, Vector right); /// T: [sbyte, long], [short, long], [int, long], [byte, ulong], [ushort, ulong], [uint, ulong] public static unsafe Vector CompareGreaterThanOrEqual(Vector left, Vector right); /// T: float, double, sbyte, short, int, long, byte, ushort, uint, ulong public static unsafe Vector CompareLessThan(Vector left, Vector right); /// T: [sbyte, long], [short, long], [int, long], [byte, ulong], [ushort, ulong], [uint, ulong] public static unsafe Vector CompareLessThan(Vector left, Vector right); /// T: float, double, sbyte, short, int, long, byte, ushort, uint, ulong public static unsafe Vector CompareLessThanOrEqual(Vector left, Vector right); /// T: [sbyte, long], [short, long], [int, long], [byte, ulong], [ushort, ulong], [uint, ulong] public static unsafe Vector CompareLessThanOrEqual(Vector left, Vector right); /// T: float, double, sbyte, short, int, long, byte, ushort, uint, ulong public static unsafe Vector CompareNotEqualTo(Vector left, Vector right); /// T: [sbyte, long], [short, long], [int, long] public static unsafe Vector CompareNotEqualTo(Vector left, Vector right); /// T: float, double public static unsafe Vector CompareUnordered(Vector left, Vector right); /// T: float, double, sbyte, short, int, long, byte, ushort, uint, ulong public static unsafe Vector ConditionalExtractAfterLast(Vector mask, Vector fallback, Vector data); /// T: float, double, sbyte, short, int, long, byte, ushort, uint, ulong public static unsafe Vector ConditionalExtractLast(Vector mask, Vector fallback, Vector data); /// T: float, double, sbyte, short, int, long, byte, ushort, uint, ulong public static unsafe Vector ConditionalSelect(Vector mask, Vector op1, Vector op2); /// T: float, double, sbyte, short, int, long, byte, ushort, uint, ulong public static unsafe T ExtractAfterLast(Vector value); /// T: float, double, sbyte, short, int, long, byte, ushort, uint, ulong public static unsafe T ExtractLast(Vector value); /// T: float, double, sbyte, short, int, long, byte, ushort, uint public static unsafe Vector ExtractVector(Vector upper, Vector lower, ulong index); public static unsafe Vector ExtractVector(Vector upper, Vector lower, ulong index); /// T: sbyte, short, int, long, byte, ushort, uint, ulong public static unsafe Vector MaskClearAll(); /// T: byte, ushort, uint, ulong public static unsafe Vector MaskGetFirstSet(Vector value); /// T: byte, ushort, uint, ulong public static unsafe Vector MaskSetAll(); /// T: byte, ushort, uint, ulong public static unsafe Vector MaskSetAll(enum svpattern pattern); /// T: sbyte, short, int, long, byte, ushort, uint, ulong public static unsafe Vector MaskSetFirst(Vector value); /// T: sbyte, short, int, long, byte, ushort, uint, ulong public static unsafe Vector PropagateBreak(Vector left, Vector right); /// T: byte, ushort, uint, ulong public static unsafe Vector WhileLessThan(int left, int right); /// T: byte, ushort, uint, ulong public static unsafe Vector WhileLessThan(long left, long right); /// T: byte, ushort, ulong public static unsafe Vector WhileLessThan(uint left, uint right); /// T: byte, ushort, uint public static unsafe Vector WhileLessThan(ulong left, ulong right); /// T: uint, ulong public static unsafe Vector WhileLessThan(T left, T right); /// T: byte, ushort, uint, ulong public static unsafe Vector WhileLessThanOrEqual(int left, int right); /// T: byte, ushort, uint, ulong public static unsafe Vector WhileLessThanOrEqual(long left, long right); /// T: byte, ushort, ulong public static unsafe Vector WhileLessThanOrEqual(uint left, uint right); /// T: byte, ushort, uint public static unsafe Vector WhileLessThanOrEqual(ulong left, ulong right); /// T: uint, ulong public static unsafe Vector WhileLessThanOrEqual(T left, T right); /// total method signatures: 45 } /// Full API public abstract class Sve : AdvSimd /// Feature: FEAT_SVE Category: mask { /// AbsoluteCompareGreaterThan : Absolute compare greater than /// svbool_t svacgt[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) : "FACGT Presult.S, Pg/Z, Zop1.S, Zop2.S" public static unsafe Vector AbsoluteCompareGreaterThan(Vector left, Vector right); /// svbool_t svacgt[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) : "FACGT Presult.D, Pg/Z, Zop1.D, Zop2.D" public static unsafe Vector AbsoluteCompareGreaterThan(Vector left, Vector right); /// AbsoluteCompareGreaterThanOrEqual : Absolute compare greater than or equal to /// svbool_t svacge[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) : "FACGE Presult.S, Pg/Z, Zop1.S, Zop2.S" public static unsafe Vector AbsoluteCompareGreaterThanOrEqual(Vector left, Vector right); /// svbool_t svacge[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) : "FACGE Presult.D, Pg/Z, Zop1.D, Zop2.D" public static unsafe Vector AbsoluteCompareGreaterThanOrEqual(Vector left, Vector right); /// AbsoluteCompareLessThan : Absolute compare less than /// svbool_t svaclt[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) : "FACGT Presult.S, Pg/Z, Zop2.S, Zop1.S" public static unsafe Vector AbsoluteCompareLessThan(Vector left, Vector right); /// svbool_t svaclt[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) : "FACGT Presult.D, Pg/Z, Zop2.D, Zop1.D" public static unsafe Vector AbsoluteCompareLessThan(Vector left, Vector right); /// AbsoluteCompareLessThanOrEqual : Absolute compare less than or equal to /// svbool_t svacle[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) : "FACGE Presult.S, Pg/Z, Zop2.S, Zop1.S" public static unsafe Vector AbsoluteCompareLessThanOrEqual(Vector left, Vector right); /// svbool_t svacle[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) : "FACGE Presult.D, Pg/Z, Zop2.D, Zop1.D" public static unsafe Vector AbsoluteCompareLessThanOrEqual(Vector left, Vector right); /// BreakAfter : Break after first true condition /// svbool_t svbrka[_b]_m(svbool_t inactive, svbool_t pg, svbool_t op) : "BRKA Ptied.B, Pg/M, Pop.B" /// svbool_t svbrka[_b]_z(svbool_t pg, svbool_t op) : "BRKA Presult.B, Pg/Z, Pop.B" public static unsafe Vector BreakAfter(Vector value); /// svbool_t svbrka[_b]_m(svbool_t inactive, svbool_t pg, svbool_t op) : "BRKA Ptied.B, Pg/M, Pop.B" /// svbool_t svbrka[_b]_z(svbool_t pg, svbool_t op) : "BRKA Presult.B, Pg/Z, Pop.B" public static unsafe Vector BreakAfter(Vector value); /// svbool_t svbrka[_b]_m(svbool_t inactive, svbool_t pg, svbool_t op) : "BRKA Ptied.B, Pg/M, Pop.B" /// svbool_t svbrka[_b]_z(svbool_t pg, svbool_t op) : "BRKA Presult.B, Pg/Z, Pop.B" public static unsafe Vector BreakAfter(Vector value); /// svbool_t svbrka[_b]_m(svbool_t inactive, svbool_t pg, svbool_t op) : "BRKA Ptied.B, Pg/M, Pop.B" /// svbool_t svbrka[_b]_z(svbool_t pg, svbool_t op) : "BRKA Presult.B, Pg/Z, Pop.B" public static unsafe Vector BreakAfter(Vector value); /// svbool_t svbrka[_b]_m(svbool_t inactive, svbool_t pg, svbool_t op) : "BRKA Ptied.B, Pg/M, Pop.B" /// svbool_t svbrka[_b]_z(svbool_t pg, svbool_t op) : "BRKA Presult.B, Pg/Z, Pop.B" public static unsafe Vector BreakAfter(Vector value); /// svbool_t svbrka[_b]_m(svbool_t inactive, svbool_t pg, svbool_t op) : "BRKA Ptied.B, Pg/M, Pop.B" /// svbool_t svbrka[_b]_z(svbool_t pg, svbool_t op) : "BRKA Presult.B, Pg/Z, Pop.B" public static unsafe Vector BreakAfter(Vector value); /// svbool_t svbrka[_b]_m(svbool_t inactive, svbool_t pg, svbool_t op) : "BRKA Ptied.B, Pg/M, Pop.B" /// svbool_t svbrka[_b]_z(svbool_t pg, svbool_t op) : "BRKA Presult.B, Pg/Z, Pop.B" public static unsafe Vector BreakAfter(Vector value); /// svbool_t svbrka[_b]_m(svbool_t inactive, svbool_t pg, svbool_t op) : "BRKA Ptied.B, Pg/M, Pop.B" /// svbool_t svbrka[_b]_z(svbool_t pg, svbool_t op) : "BRKA Presult.B, Pg/Z, Pop.B" public static unsafe Vector BreakAfter(Vector value); /// BreakAfterPropagate : Break after first true condition, propagating from previous partition /// svbool_t svbrkpa[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKPA Presult.B, Pg/Z, Pop1.B, Pop2.B" public static unsafe Vector BreakAfterPropagate(Vector left, Vector right); /// svbool_t svbrkpa[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKPA Presult.B, Pg/Z, Pop1.B, Pop2.B" public static unsafe Vector BreakAfterPropagate(Vector left, Vector right); /// svbool_t svbrkpa[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKPA Presult.B, Pg/Z, Pop1.B, Pop2.B" public static unsafe Vector BreakAfterPropagate(Vector left, Vector right); /// svbool_t svbrkpa[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKPA Presult.B, Pg/Z, Pop1.B, Pop2.B" public static unsafe Vector BreakAfterPropagate(Vector left, Vector right); /// svbool_t svbrkpa[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKPA Presult.B, Pg/Z, Pop1.B, Pop2.B" public static unsafe Vector BreakAfterPropagate(Vector left, Vector right); /// svbool_t svbrkpa[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKPA Presult.B, Pg/Z, Pop1.B, Pop2.B" public static unsafe Vector BreakAfterPropagate(Vector left, Vector right); /// svbool_t svbrkpa[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKPA Presult.B, Pg/Z, Pop1.B, Pop2.B" public static unsafe Vector BreakAfterPropagate(Vector left, Vector right); /// svbool_t svbrkpa[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKPA Presult.B, Pg/Z, Pop1.B, Pop2.B" public static unsafe Vector BreakAfterPropagate(Vector left, Vector right); /// BreakBefore : Break before first true condition /// svbool_t svbrkb[_b]_m(svbool_t inactive, svbool_t pg, svbool_t op) : "BRKB Ptied.B, Pg/M, Pop.B" /// svbool_t svbrkb[_b]_z(svbool_t pg, svbool_t op) : "BRKB Presult.B, Pg/Z, Pop.B" public static unsafe Vector BreakBefore(Vector value); /// svbool_t svbrkb[_b]_m(svbool_t inactive, svbool_t pg, svbool_t op) : "BRKB Ptied.B, Pg/M, Pop.B" /// svbool_t svbrkb[_b]_z(svbool_t pg, svbool_t op) : "BRKB Presult.B, Pg/Z, Pop.B" public static unsafe Vector BreakBefore(Vector value); /// svbool_t svbrkb[_b]_m(svbool_t inactive, svbool_t pg, svbool_t op) : "BRKB Ptied.B, Pg/M, Pop.B" /// svbool_t svbrkb[_b]_z(svbool_t pg, svbool_t op) : "BRKB Presult.B, Pg/Z, Pop.B" public static unsafe Vector BreakBefore(Vector value); /// svbool_t svbrkb[_b]_m(svbool_t inactive, svbool_t pg, svbool_t op) : "BRKB Ptied.B, Pg/M, Pop.B" /// svbool_t svbrkb[_b]_z(svbool_t pg, svbool_t op) : "BRKB Presult.B, Pg/Z, Pop.B" public static unsafe Vector BreakBefore(Vector value); /// svbool_t svbrkb[_b]_m(svbool_t inactive, svbool_t pg, svbool_t op) : "BRKB Ptied.B, Pg/M, Pop.B" /// svbool_t svbrkb[_b]_z(svbool_t pg, svbool_t op) : "BRKB Presult.B, Pg/Z, Pop.B" public static unsafe Vector BreakBefore(Vector value); /// svbool_t svbrkb[_b]_m(svbool_t inactive, svbool_t pg, svbool_t op) : "BRKB Ptied.B, Pg/M, Pop.B" /// svbool_t svbrkb[_b]_z(svbool_t pg, svbool_t op) : "BRKB Presult.B, Pg/Z, Pop.B" public static unsafe Vector BreakBefore(Vector value); /// svbool_t svbrkb[_b]_m(svbool_t inactive, svbool_t pg, svbool_t op) : "BRKB Ptied.B, Pg/M, Pop.B" /// svbool_t svbrkb[_b]_z(svbool_t pg, svbool_t op) : "BRKB Presult.B, Pg/Z, Pop.B" public static unsafe Vector BreakBefore(Vector value); /// svbool_t svbrkb[_b]_m(svbool_t inactive, svbool_t pg, svbool_t op) : "BRKB Ptied.B, Pg/M, Pop.B" /// svbool_t svbrkb[_b]_z(svbool_t pg, svbool_t op) : "BRKB Presult.B, Pg/Z, Pop.B" public static unsafe Vector BreakBefore(Vector value); /// BreakBeforePropagate : Break before first true condition, propagating from previous partition /// svbool_t svbrkpb[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKPB Presult.B, Pg/Z, Pop1.B, Pop2.B" public static unsafe Vector BreakBeforePropagate(Vector left, Vector right); /// svbool_t svbrkpb[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKPB Presult.B, Pg/Z, Pop1.B, Pop2.B" public static unsafe Vector BreakBeforePropagate(Vector left, Vector right); /// svbool_t svbrkpb[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKPB Presult.B, Pg/Z, Pop1.B, Pop2.B" public static unsafe Vector BreakBeforePropagate(Vector left, Vector right); /// svbool_t svbrkpb[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKPB Presult.B, Pg/Z, Pop1.B, Pop2.B" public static unsafe Vector BreakBeforePropagate(Vector left, Vector right); /// svbool_t svbrkpb[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKPB Presult.B, Pg/Z, Pop1.B, Pop2.B" public static unsafe Vector BreakBeforePropagate(Vector left, Vector right); /// svbool_t svbrkpb[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKPB Presult.B, Pg/Z, Pop1.B, Pop2.B" public static unsafe Vector BreakBeforePropagate(Vector left, Vector right); /// svbool_t svbrkpb[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKPB Presult.B, Pg/Z, Pop1.B, Pop2.B" public static unsafe Vector BreakBeforePropagate(Vector left, Vector right); /// svbool_t svbrkpb[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKPB Presult.B, Pg/Z, Pop1.B, Pop2.B" public static unsafe Vector BreakBeforePropagate(Vector left, Vector right); /// Compact : Shuffle active elements of vector to the right and fill with zero /// svfloat32_t svcompact[_f32](svbool_t pg, svfloat32_t op) : "COMPACT Zresult.S, Pg, Zop.S" public static unsafe Vector Compact(Vector mask, Vector op); /// svfloat64_t svcompact[_f64](svbool_t pg, svfloat64_t op) : "COMPACT Zresult.D, Pg, Zop.D" public static unsafe Vector Compact(Vector mask, Vector op); /// svint32_t svcompact[_s32](svbool_t pg, svint32_t op) : "COMPACT Zresult.S, Pg, Zop.S" public static unsafe Vector Compact(Vector mask, Vector op); /// svint64_t svcompact[_s64](svbool_t pg, svint64_t op) : "COMPACT Zresult.D, Pg, Zop.D" public static unsafe Vector Compact(Vector mask, Vector op); /// svuint32_t svcompact[_u32](svbool_t pg, svuint32_t op) : "COMPACT Zresult.S, Pg, Zop.S" public static unsafe Vector Compact(Vector mask, Vector op); /// svuint64_t svcompact[_u64](svbool_t pg, svuint64_t op) : "COMPACT Zresult.D, Pg, Zop.D" public static unsafe Vector Compact(Vector mask, Vector op); /// CompareEqualTo : Compare equal to /// svbool_t svcmpeq[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) : "FCMEQ Presult.S, Pg/Z, Zop1.S, Zop2.S" public static unsafe Vector CompareEqualTo(Vector left, Vector right); /// svbool_t svcmpeq[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) : "FCMEQ Presult.D, Pg/Z, Zop1.D, Zop2.D" public static unsafe Vector CompareEqualTo(Vector left, Vector right); /// svbool_t svcmpeq[_s8](svbool_t pg, svint8_t op1, svint8_t op2) : "CMPEQ Presult.B, Pg/Z, Zop1.B, Zop2.B" public static unsafe Vector CompareEqualTo(Vector left, Vector right); /// svbool_t svcmpeq[_s16](svbool_t pg, svint16_t op1, svint16_t op2) : "CMPEQ Presult.H, Pg/Z, Zop1.H, Zop2.H" public static unsafe Vector CompareEqualTo(Vector left, Vector right); /// svbool_t svcmpeq[_s32](svbool_t pg, svint32_t op1, svint32_t op2) : "CMPEQ Presult.S, Pg/Z, Zop1.S, Zop2.S" public static unsafe Vector CompareEqualTo(Vector left, Vector right); /// svbool_t svcmpeq[_s64](svbool_t pg, svint64_t op1, svint64_t op2) : "CMPEQ Presult.D, Pg/Z, Zop1.D, Zop2.D" public static unsafe Vector CompareEqualTo(Vector left, Vector right); /// svbool_t svcmpeq[_u8](svbool_t pg, svuint8_t op1, svuint8_t op2) : "CMPEQ Presult.B, Pg/Z, Zop1.B, Zop2.B" public static unsafe Vector CompareEqualTo(Vector left, Vector right); /// svbool_t svcmpeq[_u16](svbool_t pg, svuint16_t op1, svuint16_t op2) : "CMPEQ Presult.H, Pg/Z, Zop1.H, Zop2.H" public static unsafe Vector CompareEqualTo(Vector left, Vector right); /// svbool_t svcmpeq[_u32](svbool_t pg, svuint32_t op1, svuint32_t op2) : "CMPEQ Presult.S, Pg/Z, Zop1.S, Zop2.S" public static unsafe Vector CompareEqualTo(Vector left, Vector right); /// svbool_t svcmpeq[_u64](svbool_t pg, svuint64_t op1, svuint64_t op2) : "CMPEQ Presult.D, Pg/Z, Zop1.D, Zop2.D" public static unsafe Vector CompareEqualTo(Vector left, Vector right); /// svbool_t svcmpeq_wide[_s8](svbool_t pg, svint8_t op1, svint64_t op2) : "CMPEQ Presult.B, Pg/Z, Zop1.B, Zop2.D" public static unsafe Vector CompareEqualTo(Vector left, Vector right); /// svbool_t svcmpeq_wide[_s16](svbool_t pg, svint16_t op1, svint64_t op2) : "CMPEQ Presult.H, Pg/Z, Zop1.H, Zop2.D" public static unsafe Vector CompareEqualTo(Vector left, Vector right); /// svbool_t svcmpeq_wide[_s32](svbool_t pg, svint32_t op1, svint64_t op2) : "CMPEQ Presult.S, Pg/Z, Zop1.S, Zop2.D" public static unsafe Vector CompareEqualTo(Vector left, Vector right); /// CompareGreaterThan : Compare greater than /// svbool_t svcmpgt[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) : "FCMGT Presult.S, Pg/Z, Zop1.S, Zop2.S" public static unsafe Vector CompareGreaterThan(Vector left, Vector right); /// svbool_t svcmpgt[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) : "FCMGT Presult.D, Pg/Z, Zop1.D, Zop2.D" public static unsafe Vector CompareGreaterThan(Vector left, Vector right); /// svbool_t svcmpgt[_s8](svbool_t pg, svint8_t op1, svint8_t op2) : "CMPGT Presult.B, Pg/Z, Zop1.B, Zop2.B" public static unsafe Vector CompareGreaterThan(Vector left, Vector right); /// svbool_t svcmpgt[_s16](svbool_t pg, svint16_t op1, svint16_t op2) : "CMPGT Presult.H, Pg/Z, Zop1.H, Zop2.H" public static unsafe Vector CompareGreaterThan(Vector left, Vector right); /// svbool_t svcmpgt[_s32](svbool_t pg, svint32_t op1, svint32_t op2) : "CMPGT Presult.S, Pg/Z, Zop1.S, Zop2.S" public static unsafe Vector CompareGreaterThan(Vector left, Vector right); /// svbool_t svcmpgt[_s64](svbool_t pg, svint64_t op1, svint64_t op2) : "CMPGT Presult.D, Pg/Z, Zop1.D, Zop2.D" public static unsafe Vector CompareGreaterThan(Vector left, Vector right); /// svbool_t svcmpgt[_u8](svbool_t pg, svuint8_t op1, svuint8_t op2) : "CMPHI Presult.B, Pg/Z, Zop1.B, Zop2.B" public static unsafe Vector CompareGreaterThan(Vector left, Vector right); /// svbool_t svcmpgt[_u16](svbool_t pg, svuint16_t op1, svuint16_t op2) : "CMPHI Presult.H, Pg/Z, Zop1.H, Zop2.H" public static unsafe Vector CompareGreaterThan(Vector left, Vector right); /// svbool_t svcmpgt[_u32](svbool_t pg, svuint32_t op1, svuint32_t op2) : "CMPHI Presult.S, Pg/Z, Zop1.S, Zop2.S" public static unsafe Vector CompareGreaterThan(Vector left, Vector right); /// svbool_t svcmpgt[_u64](svbool_t pg, svuint64_t op1, svuint64_t op2) : "CMPHI Presult.D, Pg/Z, Zop1.D, Zop2.D" public static unsafe Vector CompareGreaterThan(Vector left, Vector right); /// svbool_t svcmpgt_wide[_s8](svbool_t pg, svint8_t op1, svint64_t op2) : "CMPGT Presult.B, Pg/Z, Zop1.B, Zop2.D" public static unsafe Vector CompareGreaterThan(Vector left, Vector right); /// svbool_t svcmpgt_wide[_s16](svbool_t pg, svint16_t op1, svint64_t op2) : "CMPGT Presult.H, Pg/Z, Zop1.H, Zop2.D" public static unsafe Vector CompareGreaterThan(Vector left, Vector right); /// svbool_t svcmpgt_wide[_s32](svbool_t pg, svint32_t op1, svint64_t op2) : "CMPGT Presult.S, Pg/Z, Zop1.S, Zop2.D" public static unsafe Vector CompareGreaterThan(Vector left, Vector right); /// svbool_t svcmpgt_wide[_u8](svbool_t pg, svuint8_t op1, svuint64_t op2) : "CMPHI Presult.B, Pg/Z, Zop1.B, Zop2.D" public static unsafe Vector CompareGreaterThan(Vector left, Vector right); /// svbool_t svcmpgt_wide[_u16](svbool_t pg, svuint16_t op1, svuint64_t op2) : "CMPHI Presult.H, Pg/Z, Zop1.H, Zop2.D" public static unsafe Vector CompareGreaterThan(Vector left, Vector right); /// svbool_t svcmpgt_wide[_u32](svbool_t pg, svuint32_t op1, svuint64_t op2) : "CMPHI Presult.S, Pg/Z, Zop1.S, Zop2.D" public static unsafe Vector CompareGreaterThan(Vector left, Vector right); /// CompareGreaterThanOrEqual : Compare greater than or equal to /// svbool_t svcmpge[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) : "FCMGE Presult.S, Pg/Z, Zop1.S, Zop2.S" public static unsafe Vector CompareGreaterThanOrEqual(Vector left, Vector right); /// svbool_t svcmpge[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) : "FCMGE Presult.D, Pg/Z, Zop1.D, Zop2.D" public static unsafe Vector CompareGreaterThanOrEqual(Vector left, Vector right); /// svbool_t svcmpge[_s8](svbool_t pg, svint8_t op1, svint8_t op2) : "CMPGE Presult.B, Pg/Z, Zop1.B, Zop2.B" public static unsafe Vector CompareGreaterThanOrEqual(Vector left, Vector right); /// svbool_t svcmpge[_s16](svbool_t pg, svint16_t op1, svint16_t op2) : "CMPGE Presult.H, Pg/Z, Zop1.H, Zop2.H" public static unsafe Vector CompareGreaterThanOrEqual(Vector left, Vector right); /// svbool_t svcmpge[_s32](svbool_t pg, svint32_t op1, svint32_t op2) : "CMPGE Presult.S, Pg/Z, Zop1.S, Zop2.S" public static unsafe Vector CompareGreaterThanOrEqual(Vector left, Vector right); /// svbool_t svcmpge[_s64](svbool_t pg, svint64_t op1, svint64_t op2) : "CMPGE Presult.D, Pg/Z, Zop1.D, Zop2.D" public static unsafe Vector CompareGreaterThanOrEqual(Vector left, Vector right); /// svbool_t svcmpge[_u8](svbool_t pg, svuint8_t op1, svuint8_t op2) : "CMPHS Presult.B, Pg/Z, Zop1.B, Zop2.B" public static unsafe Vector CompareGreaterThanOrEqual(Vector left, Vector right); /// svbool_t svcmpge[_u16](svbool_t pg, svuint16_t op1, svuint16_t op2) : "CMPHS Presult.H, Pg/Z, Zop1.H, Zop2.H" public static unsafe Vector CompareGreaterThanOrEqual(Vector left, Vector right); /// svbool_t svcmpge[_u32](svbool_t pg, svuint32_t op1, svuint32_t op2) : "CMPHS Presult.S, Pg/Z, Zop1.S, Zop2.S" public static unsafe Vector CompareGreaterThanOrEqual(Vector left, Vector right); /// svbool_t svcmpge[_u64](svbool_t pg, svuint64_t op1, svuint64_t op2) : "CMPHS Presult.D, Pg/Z, Zop1.D, Zop2.D" public static unsafe Vector CompareGreaterThanOrEqual(Vector left, Vector right); /// svbool_t svcmpge_wide[_s8](svbool_t pg, svint8_t op1, svint64_t op2) : "CMPGE Presult.B, Pg/Z, Zop1.B, Zop2.D" public static unsafe Vector CompareGreaterThanOrEqual(Vector left, Vector right); /// svbool_t svcmpge_wide[_s16](svbool_t pg, svint16_t op1, svint64_t op2) : "CMPGE Presult.H, Pg/Z, Zop1.H, Zop2.D" public static unsafe Vector CompareGreaterThanOrEqual(Vector left, Vector right); /// svbool_t svcmpge_wide[_s32](svbool_t pg, svint32_t op1, svint64_t op2) : "CMPGE Presult.S, Pg/Z, Zop1.S, Zop2.D" public static unsafe Vector CompareGreaterThanOrEqual(Vector left, Vector right); /// svbool_t svcmpge_wide[_u8](svbool_t pg, svuint8_t op1, svuint64_t op2) : "CMPHS Presult.B, Pg/Z, Zop1.B, Zop2.D" public static unsafe Vector CompareGreaterThanOrEqual(Vector left, Vector right); /// svbool_t svcmpge_wide[_u16](svbool_t pg, svuint16_t op1, svuint64_t op2) : "CMPHS Presult.H, Pg/Z, Zop1.H, Zop2.D" public static unsafe Vector CompareGreaterThanOrEqual(Vector left, Vector right); /// svbool_t svcmpge_wide[_u32](svbool_t pg, svuint32_t op1, svuint64_t op2) : "CMPHS Presult.S, Pg/Z, Zop1.S, Zop2.D" public static unsafe Vector CompareGreaterThanOrEqual(Vector left, Vector right); /// CompareLessThan : Compare less than /// svbool_t svcmplt[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) : "FCMGT Presult.S, Pg/Z, Zop2.S, Zop1.S" public static unsafe Vector CompareLessThan(Vector left, Vector right); /// svbool_t svcmplt[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) : "FCMGT Presult.D, Pg/Z, Zop2.D, Zop1.D" public static unsafe Vector CompareLessThan(Vector left, Vector right); /// svbool_t svcmplt[_s8](svbool_t pg, svint8_t op1, svint8_t op2) : "CMPGT Presult.B, Pg/Z, Zop2.B, Zop1.B" public static unsafe Vector CompareLessThan(Vector left, Vector right); /// svbool_t svcmplt[_s16](svbool_t pg, svint16_t op1, svint16_t op2) : "CMPGT Presult.H, Pg/Z, Zop2.H, Zop1.H" public static unsafe Vector CompareLessThan(Vector left, Vector right); /// svbool_t svcmplt[_s32](svbool_t pg, svint32_t op1, svint32_t op2) : "CMPGT Presult.S, Pg/Z, Zop2.S, Zop1.S" public static unsafe Vector CompareLessThan(Vector left, Vector right); /// svbool_t svcmplt[_s64](svbool_t pg, svint64_t op1, svint64_t op2) : "CMPGT Presult.D, Pg/Z, Zop2.D, Zop1.D" public static unsafe Vector CompareLessThan(Vector left, Vector right); /// svbool_t svcmplt[_u8](svbool_t pg, svuint8_t op1, svuint8_t op2) : "CMPHI Presult.B, Pg/Z, Zop2.B, Zop1.B" public static unsafe Vector CompareLessThan(Vector left, Vector right); /// svbool_t svcmplt[_u16](svbool_t pg, svuint16_t op1, svuint16_t op2) : "CMPHI Presult.H, Pg/Z, Zop2.H, Zop1.H" public static unsafe Vector CompareLessThan(Vector left, Vector right); /// svbool_t svcmplt[_u32](svbool_t pg, svuint32_t op1, svuint32_t op2) : "CMPHI Presult.S, Pg/Z, Zop2.S, Zop1.S" public static unsafe Vector CompareLessThan(Vector left, Vector right); /// svbool_t svcmplt[_u64](svbool_t pg, svuint64_t op1, svuint64_t op2) : "CMPHI Presult.D, Pg/Z, Zop2.D, Zop1.D" public static unsafe Vector CompareLessThan(Vector left, Vector right); /// svbool_t svcmplt_wide[_s8](svbool_t pg, svint8_t op1, svint64_t op2) : "CMPLT Presult.B, Pg/Z, Zop1.B, Zop2.D" public static unsafe Vector CompareLessThan(Vector left, Vector right); /// svbool_t svcmplt_wide[_s16](svbool_t pg, svint16_t op1, svint64_t op2) : "CMPLT Presult.H, Pg/Z, Zop1.H, Zop2.D" public static unsafe Vector CompareLessThan(Vector left, Vector right); /// svbool_t svcmplt_wide[_s32](svbool_t pg, svint32_t op1, svint64_t op2) : "CMPLT Presult.S, Pg/Z, Zop1.S, Zop2.D" public static unsafe Vector CompareLessThan(Vector left, Vector right); /// svbool_t svcmplt_wide[_u8](svbool_t pg, svuint8_t op1, svuint64_t op2) : "CMPLO Presult.B, Pg/Z, Zop1.B, Zop2.D" public static unsafe Vector CompareLessThan(Vector left, Vector right); /// svbool_t svcmplt_wide[_u16](svbool_t pg, svuint16_t op1, svuint64_t op2) : "CMPLO Presult.H, Pg/Z, Zop1.H, Zop2.D" public static unsafe Vector CompareLessThan(Vector left, Vector right); /// svbool_t svcmplt_wide[_u32](svbool_t pg, svuint32_t op1, svuint64_t op2) : "CMPLO Presult.S, Pg/Z, Zop1.S, Zop2.D" public static unsafe Vector CompareLessThan(Vector left, Vector right); /// CompareLessThanOrEqual : Compare less than or equal to /// svbool_t svcmple[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) : "FCMGE Presult.S, Pg/Z, Zop2.S, Zop1.S" public static unsafe Vector CompareLessThanOrEqual(Vector left, Vector right); /// svbool_t svcmple[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) : "FCMGE Presult.D, Pg/Z, Zop2.D, Zop1.D" public static unsafe Vector CompareLessThanOrEqual(Vector left, Vector right); /// svbool_t svcmple[_s8](svbool_t pg, svint8_t op1, svint8_t op2) : "CMPGE Presult.B, Pg/Z, Zop2.B, Zop1.B" public static unsafe Vector CompareLessThanOrEqual(Vector left, Vector right); /// svbool_t svcmple[_s16](svbool_t pg, svint16_t op1, svint16_t op2) : "CMPGE Presult.H, Pg/Z, Zop2.H, Zop1.H" public static unsafe Vector CompareLessThanOrEqual(Vector left, Vector right); /// svbool_t svcmple[_s32](svbool_t pg, svint32_t op1, svint32_t op2) : "CMPGE Presult.S, Pg/Z, Zop2.S, Zop1.S" public static unsafe Vector CompareLessThanOrEqual(Vector left, Vector right); /// svbool_t svcmple[_s64](svbool_t pg, svint64_t op1, svint64_t op2) : "CMPGE Presult.D, Pg/Z, Zop2.D, Zop1.D" public static unsafe Vector CompareLessThanOrEqual(Vector left, Vector right); /// svbool_t svcmple[_u8](svbool_t pg, svuint8_t op1, svuint8_t op2) : "CMPHS Presult.B, Pg/Z, Zop2.B, Zop1.B" public static unsafe Vector CompareLessThanOrEqual(Vector left, Vector right); /// svbool_t svcmple[_u16](svbool_t pg, svuint16_t op1, svuint16_t op2) : "CMPHS Presult.H, Pg/Z, Zop2.H, Zop1.H" public static unsafe Vector CompareLessThanOrEqual(Vector left, Vector right); /// svbool_t svcmple[_u32](svbool_t pg, svuint32_t op1, svuint32_t op2) : "CMPHS Presult.S, Pg/Z, Zop2.S, Zop1.S" public static unsafe Vector CompareLessThanOrEqual(Vector left, Vector right); /// svbool_t svcmple[_u64](svbool_t pg, svuint64_t op1, svuint64_t op2) : "CMPHS Presult.D, Pg/Z, Zop2.D, Zop1.D" public static unsafe Vector CompareLessThanOrEqual(Vector left, Vector right); /// svbool_t svcmple_wide[_s8](svbool_t pg, svint8_t op1, svint64_t op2) : "CMPLE Presult.B, Pg/Z, Zop1.B, Zop2.D" public static unsafe Vector CompareLessThanOrEqual(Vector left, Vector right); /// svbool_t svcmple_wide[_s16](svbool_t pg, svint16_t op1, svint64_t op2) : "CMPLE Presult.H, Pg/Z, Zop1.H, Zop2.D" public static unsafe Vector CompareLessThanOrEqual(Vector left, Vector right); /// svbool_t svcmple_wide[_s32](svbool_t pg, svint32_t op1, svint64_t op2) : "CMPLE Presult.S, Pg/Z, Zop1.S, Zop2.D" public static unsafe Vector CompareLessThanOrEqual(Vector left, Vector right); /// svbool_t svcmple_wide[_u8](svbool_t pg, svuint8_t op1, svuint64_t op2) : "CMPLS Presult.B, Pg/Z, Zop1.B, Zop2.D" public static unsafe Vector CompareLessThanOrEqual(Vector left, Vector right); /// svbool_t svcmple_wide[_u16](svbool_t pg, svuint16_t op1, svuint64_t op2) : "CMPLS Presult.H, Pg/Z, Zop1.H, Zop2.D" public static unsafe Vector CompareLessThanOrEqual(Vector left, Vector right); /// svbool_t svcmple_wide[_u32](svbool_t pg, svuint32_t op1, svuint64_t op2) : "CMPLS Presult.S, Pg/Z, Zop1.S, Zop2.D" public static unsafe Vector CompareLessThanOrEqual(Vector left, Vector right); /// CompareNotEqualTo : Compare not equal to /// svbool_t svcmpne[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) : "FCMNE Presult.S, Pg/Z, Zop1.S, Zop2.S" public static unsafe Vector CompareNotEqualTo(Vector left, Vector right); /// svbool_t svcmpne[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) : "FCMNE Presult.D, Pg/Z, Zop1.D, Zop2.D" public static unsafe Vector CompareNotEqualTo(Vector left, Vector right); /// svbool_t svcmpne[_s8](svbool_t pg, svint8_t op1, svint8_t op2) : "CMPNE Presult.B, Pg/Z, Zop1.B, Zop2.B" public static unsafe Vector CompareNotEqualTo(Vector left, Vector right); /// svbool_t svcmpne[_s16](svbool_t pg, svint16_t op1, svint16_t op2) : "CMPNE Presult.H, Pg/Z, Zop1.H, Zop2.H" public static unsafe Vector CompareNotEqualTo(Vector left, Vector right); /// svbool_t svcmpne[_s32](svbool_t pg, svint32_t op1, svint32_t op2) : "CMPNE Presult.S, Pg/Z, Zop1.S, Zop2.S" public static unsafe Vector CompareNotEqualTo(Vector left, Vector right); /// svbool_t svcmpne[_s64](svbool_t pg, svint64_t op1, svint64_t op2) : "CMPNE Presult.D, Pg/Z, Zop1.D, Zop2.D" public static unsafe Vector CompareNotEqualTo(Vector left, Vector right); /// svbool_t svcmpne[_u8](svbool_t pg, svuint8_t op1, svuint8_t op2) : "CMPNE Presult.B, Pg/Z, Zop1.B, Zop2.B" public static unsafe Vector CompareNotEqualTo(Vector left, Vector right); /// svbool_t svcmpne[_u16](svbool_t pg, svuint16_t op1, svuint16_t op2) : "CMPNE Presult.H, Pg/Z, Zop1.H, Zop2.H" public static unsafe Vector CompareNotEqualTo(Vector left, Vector right); /// svbool_t svcmpne[_u32](svbool_t pg, svuint32_t op1, svuint32_t op2) : "CMPNE Presult.S, Pg/Z, Zop1.S, Zop2.S" public static unsafe Vector CompareNotEqualTo(Vector left, Vector right); /// svbool_t svcmpne[_u64](svbool_t pg, svuint64_t op1, svuint64_t op2) : "CMPNE Presult.D, Pg/Z, Zop1.D, Zop2.D" public static unsafe Vector CompareNotEqualTo(Vector left, Vector right); /// svbool_t svcmpne_wide[_s8](svbool_t pg, svint8_t op1, svint64_t op2) : "CMPNE Presult.B, Pg/Z, Zop1.B, Zop2.D" public static unsafe Vector CompareNotEqualTo(Vector left, Vector right); /// svbool_t svcmpne_wide[_s16](svbool_t pg, svint16_t op1, svint64_t op2) : "CMPNE Presult.H, Pg/Z, Zop1.H, Zop2.D" public static unsafe Vector CompareNotEqualTo(Vector left, Vector right); /// svbool_t svcmpne_wide[_s32](svbool_t pg, svint32_t op1, svint64_t op2) : "CMPNE Presult.S, Pg/Z, Zop1.S, Zop2.D" public static unsafe Vector CompareNotEqualTo(Vector left, Vector right); /// CompareUnordered : Compare unordered with /// svbool_t svcmpuo[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) : "FCMUO Presult.S, Pg/Z, Zop1.S, Zop2.S" public static unsafe Vector CompareUnordered(Vector left, Vector right); /// svbool_t svcmpuo[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) : "FCMUO Presult.D, Pg/Z, Zop1.D, Zop2.D" public static unsafe Vector CompareUnordered(Vector left, Vector right); /// ConditionalExtractAfterLast : Conditionally extract element after last /// svfloat32_t svclasta[_f32](svbool_t pg, svfloat32_t fallback, svfloat32_t data) : "CLASTA Ztied.S, Pg, Ztied.S, Zdata.S" or "MOVPRFX Zresult, Zfallback; CLASTA Zresult.S, Pg, Zresult.S, Zdata.S" public static unsafe Vector ConditionalExtractAfterLast(Vector mask, Vector fallback, Vector data); /// svfloat64_t svclasta[_f64](svbool_t pg, svfloat64_t fallback, svfloat64_t data) : "CLASTA Ztied.D, Pg, Ztied.D, Zdata.D" or "MOVPRFX Zresult, Zfallback; CLASTA Zresult.D, Pg, Zresult.D, Zdata.D" public static unsafe Vector ConditionalExtractAfterLast(Vector mask, Vector fallback, Vector data); /// svint8_t svclasta[_s8](svbool_t pg, svint8_t fallback, svint8_t data) : "CLASTA Ztied.B, Pg, Ztied.B, Zdata.B" or "MOVPRFX Zresult, Zfallback; CLASTA Zresult.B, Pg, Zresult.B, Zdata.B" public static unsafe Vector ConditionalExtractAfterLast(Vector mask, Vector fallback, Vector data); /// svint16_t svclasta[_s16](svbool_t pg, svint16_t fallback, svint16_t data) : "CLASTA Ztied.H, Pg, Ztied.H, Zdata.H" or "MOVPRFX Zresult, Zfallback; CLASTA Zresult.H, Pg, Zresult.H, Zdata.H" public static unsafe Vector ConditionalExtractAfterLast(Vector mask, Vector fallback, Vector data); /// svint32_t svclasta[_s32](svbool_t pg, svint32_t fallback, svint32_t data) : "CLASTA Ztied.S, Pg, Ztied.S, Zdata.S" or "MOVPRFX Zresult, Zfallback; CLASTA Zresult.S, Pg, Zresult.S, Zdata.S" public static unsafe Vector ConditionalExtractAfterLast(Vector mask, Vector fallback, Vector data); /// svint64_t svclasta[_s64](svbool_t pg, svint64_t fallback, svint64_t data) : "CLASTA Ztied.D, Pg, Ztied.D, Zdata.D" or "MOVPRFX Zresult, Zfallback; CLASTA Zresult.D, Pg, Zresult.D, Zdata.D" public static unsafe Vector ConditionalExtractAfterLast(Vector mask, Vector fallback, Vector data); /// svuint8_t svclasta[_u8](svbool_t pg, svuint8_t fallback, svuint8_t data) : "CLASTA Ztied.B, Pg, Ztied.B, Zdata.B" or "MOVPRFX Zresult, Zfallback; CLASTA Zresult.B, Pg, Zresult.B, Zdata.B" public static unsafe Vector ConditionalExtractAfterLast(Vector mask, Vector fallback, Vector data); /// svuint16_t svclasta[_u16](svbool_t pg, svuint16_t fallback, svuint16_t data) : "CLASTA Ztied.H, Pg, Ztied.H, Zdata.H" or "MOVPRFX Zresult, Zfallback; CLASTA Zresult.H, Pg, Zresult.H, Zdata.H" public static unsafe Vector ConditionalExtractAfterLast(Vector mask, Vector fallback, Vector data); /// svuint32_t svclasta[_u32](svbool_t pg, svuint32_t fallback, svuint32_t data) : "CLASTA Ztied.S, Pg, Ztied.S, Zdata.S" or "MOVPRFX Zresult, Zfallback; CLASTA Zresult.S, Pg, Zresult.S, Zdata.S" public static unsafe Vector ConditionalExtractAfterLast(Vector mask, Vector fallback, Vector data); /// svuint64_t svclasta[_u64](svbool_t pg, svuint64_t fallback, svuint64_t data) : "CLASTA Ztied.D, Pg, Ztied.D, Zdata.D" or "MOVPRFX Zresult, Zfallback; CLASTA Zresult.D, Pg, Zresult.D, Zdata.D" public static unsafe Vector ConditionalExtractAfterLast(Vector mask, Vector fallback, Vector data); /// ConditionalExtractLast : Conditionally extract last element /// svfloat32_t svclastb[_f32](svbool_t pg, svfloat32_t fallback, svfloat32_t data) : "CLASTB Ztied.S, Pg, Ztied.S, Zdata.S" or "MOVPRFX Zresult, Zfallback; CLASTB Zresult.S, Pg, Zresult.S, Zdata.S" public static unsafe Vector ConditionalExtractLast(Vector mask, Vector fallback, Vector data); /// svfloat64_t svclastb[_f64](svbool_t pg, svfloat64_t fallback, svfloat64_t data) : "CLASTB Ztied.D, Pg, Ztied.D, Zdata.D" or "MOVPRFX Zresult, Zfallback; CLASTB Zresult.D, Pg, Zresult.D, Zdata.D" public static unsafe Vector ConditionalExtractLast(Vector mask, Vector fallback, Vector data); /// svint8_t svclastb[_s8](svbool_t pg, svint8_t fallback, svint8_t data) : "CLASTB Ztied.B, Pg, Ztied.B, Zdata.B" or "MOVPRFX Zresult, Zfallback; CLASTB Zresult.B, Pg, Zresult.B, Zdata.B" public static unsafe Vector ConditionalExtractLast(Vector mask, Vector fallback, Vector data); /// svint16_t svclastb[_s16](svbool_t pg, svint16_t fallback, svint16_t data) : "CLASTB Ztied.H, Pg, Ztied.H, Zdata.H" or "MOVPRFX Zresult, Zfallback; CLASTB Zresult.H, Pg, Zresult.H, Zdata.H" public static unsafe Vector ConditionalExtractLast(Vector mask, Vector fallback, Vector data); /// svint32_t svclastb[_s32](svbool_t pg, svint32_t fallback, svint32_t data) : "CLASTB Ztied.S, Pg, Ztied.S, Zdata.S" or "MOVPRFX Zresult, Zfallback; CLASTB Zresult.S, Pg, Zresult.S, Zdata.S" public static unsafe Vector ConditionalExtractLast(Vector mask, Vector fallback, Vector data); /// svint64_t svclastb[_s64](svbool_t pg, svint64_t fallback, svint64_t data) : "CLASTB Ztied.D, Pg, Ztied.D, Zdata.D" or "MOVPRFX Zresult, Zfallback; CLASTB Zresult.D, Pg, Zresult.D, Zdata.D" public static unsafe Vector ConditionalExtractLast(Vector mask, Vector fallback, Vector data); /// svuint8_t svclastb[_u8](svbool_t pg, svuint8_t fallback, svuint8_t data) : "CLASTB Ztied.B, Pg, Ztied.B, Zdata.B" or "MOVPRFX Zresult, Zfallback; CLASTB Zresult.B, Pg, Zresult.B, Zdata.B" public static unsafe Vector ConditionalExtractLast(Vector mask, Vector fallback, Vector data); /// svuint16_t svclastb[_u16](svbool_t pg, svuint16_t fallback, svuint16_t data) : "CLASTB Ztied.H, Pg, Ztied.H, Zdata.H" or "MOVPRFX Zresult, Zfallback; CLASTB Zresult.H, Pg, Zresult.H, Zdata.H" public static unsafe Vector ConditionalExtractLast(Vector mask, Vector fallback, Vector data); /// svuint32_t svclastb[_u32](svbool_t pg, svuint32_t fallback, svuint32_t data) : "CLASTB Ztied.S, Pg, Ztied.S, Zdata.S" or "MOVPRFX Zresult, Zfallback; CLASTB Zresult.S, Pg, Zresult.S, Zdata.S" public static unsafe Vector ConditionalExtractLast(Vector mask, Vector fallback, Vector data); /// svuint64_t svclastb[_u64](svbool_t pg, svuint64_t fallback, svuint64_t data) : "CLASTB Ztied.D, Pg, Ztied.D, Zdata.D" or "MOVPRFX Zresult, Zfallback; CLASTB Zresult.D, Pg, Zresult.D, Zdata.D" public static unsafe Vector ConditionalExtractLast(Vector mask, Vector fallback, Vector data); /// ConditionalSelect : Conditionally select elements /// svfloat32_t svsel[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) : "SEL Zresult.S, Pg, Zop1.S, Zop2.S" public static unsafe Vector ConditionalSelect(Vector mask, Vector op1, Vector op2); /// svfloat64_t svsel[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) : "SEL Zresult.D, Pg, Zop1.D, Zop2.D" public static unsafe Vector ConditionalSelect(Vector mask, Vector op1, Vector op2); /// svint8_t svsel[_s8](svbool_t pg, svint8_t op1, svint8_t op2) : "SEL Zresult.B, Pg, Zop1.B, Zop2.B" /// svbool_t svsel[_b](svbool_t pg, svbool_t op1, svbool_t op2) : "SEL Presult.B, Pg, Pop1.B, Pop2.B" public static unsafe Vector ConditionalSelect(Vector mask, Vector op1, Vector op2); /// svint16_t svsel[_s16](svbool_t pg, svint16_t op1, svint16_t op2) : "SEL Zresult.H, Pg, Zop1.H, Zop2.H" /// svbool_t svsel[_b](svbool_t pg, svbool_t op1, svbool_t op2) : "SEL Presult.B, Pg, Pop1.B, Pop2.B" public static unsafe Vector ConditionalSelect(Vector mask, Vector op1, Vector op2); /// svint32_t svsel[_s32](svbool_t pg, svint32_t op1, svint32_t op2) : "SEL Zresult.S, Pg, Zop1.S, Zop2.S" /// svbool_t svsel[_b](svbool_t pg, svbool_t op1, svbool_t op2) : "SEL Presult.B, Pg, Pop1.B, Pop2.B" public static unsafe Vector ConditionalSelect(Vector mask, Vector op1, Vector op2); /// svint64_t svsel[_s64](svbool_t pg, svint64_t op1, svint64_t op2) : "SEL Zresult.D, Pg, Zop1.D, Zop2.D" /// svbool_t svsel[_b](svbool_t pg, svbool_t op1, svbool_t op2) : "SEL Presult.B, Pg, Pop1.B, Pop2.B" public static unsafe Vector ConditionalSelect(Vector mask, Vector op1, Vector op2); /// svuint8_t svsel[_u8](svbool_t pg, svuint8_t op1, svuint8_t op2) : "SEL Zresult.B, Pg, Zop1.B, Zop2.B" /// svbool_t svsel[_b](svbool_t pg, svbool_t op1, svbool_t op2) : "SEL Presult.B, Pg, Pop1.B, Pop2.B" public static unsafe Vector ConditionalSelect(Vector mask, Vector op1, Vector op2); /// svuint16_t svsel[_u16](svbool_t pg, svuint16_t op1, svuint16_t op2) : "SEL Zresult.H, Pg, Zop1.H, Zop2.H" /// svbool_t svsel[_b](svbool_t pg, svbool_t op1, svbool_t op2) : "SEL Presult.B, Pg, Pop1.B, Pop2.B" public static unsafe Vector ConditionalSelect(Vector mask, Vector op1, Vector op2); /// svuint32_t svsel[_u32](svbool_t pg, svuint32_t op1, svuint32_t op2) : "SEL Zresult.S, Pg, Zop1.S, Zop2.S" /// svbool_t svsel[_b](svbool_t pg, svbool_t op1, svbool_t op2) : "SEL Presult.B, Pg, Pop1.B, Pop2.B" public static unsafe Vector ConditionalSelect(Vector mask, Vector op1, Vector op2); /// svuint64_t svsel[_u64](svbool_t pg, svuint64_t op1, svuint64_t op2) : "SEL Zresult.D, Pg, Zop1.D, Zop2.D" /// svbool_t svsel[_b](svbool_t pg, svbool_t op1, svbool_t op2) : "SEL Presult.B, Pg, Pop1.B, Pop2.B" public static unsafe Vector ConditionalSelect(Vector mask, Vector op1, Vector op2); /// ExtractAfterLast : Extract element after last /// float32_t svlasta[_f32](svbool_t pg, svfloat32_t op) : "LASTA Wresult, Pg, Zop.S" or "LASTA Sresult, Pg, Zop.S" public static unsafe float ExtractAfterLast(Vector value); /// float64_t svlasta[_f64](svbool_t pg, svfloat64_t op) : "LASTA Xresult, Pg, Zop.D" or "LASTA Dresult, Pg, Zop.D" public static unsafe double ExtractAfterLast(Vector value); /// int8_t svlasta[_s8](svbool_t pg, svint8_t op) : "LASTA Wresult, Pg, Zop.B" or "LASTA Bresult, Pg, Zop.B" public static unsafe sbyte ExtractAfterLast(Vector value); /// int16_t svlasta[_s16](svbool_t pg, svint16_t op) : "LASTA Wresult, Pg, Zop.H" or "LASTA Hresult, Pg, Zop.H" public static unsafe short ExtractAfterLast(Vector value); /// int32_t svlasta[_s32](svbool_t pg, svint32_t op) : "LASTA Wresult, Pg, Zop.S" or "LASTA Sresult, Pg, Zop.S" public static unsafe int ExtractAfterLast(Vector value); /// int64_t svlasta[_s64](svbool_t pg, svint64_t op) : "LASTA Xresult, Pg, Zop.D" or "LASTA Dresult, Pg, Zop.D" public static unsafe long ExtractAfterLast(Vector value); /// uint8_t svlasta[_u8](svbool_t pg, svuint8_t op) : "LASTA Wresult, Pg, Zop.B" or "LASTA Bresult, Pg, Zop.B" public static unsafe byte ExtractAfterLast(Vector value); /// uint16_t svlasta[_u16](svbool_t pg, svuint16_t op) : "LASTA Wresult, Pg, Zop.H" or "LASTA Hresult, Pg, Zop.H" public static unsafe ushort ExtractAfterLast(Vector value); /// uint32_t svlasta[_u32](svbool_t pg, svuint32_t op) : "LASTA Wresult, Pg, Zop.S" or "LASTA Sresult, Pg, Zop.S" public static unsafe uint ExtractAfterLast(Vector value); /// uint64_t svlasta[_u64](svbool_t pg, svuint64_t op) : "LASTA Xresult, Pg, Zop.D" or "LASTA Dresult, Pg, Zop.D" public static unsafe ulong ExtractAfterLast(Vector value); /// ExtractLast : Extract last element /// float32_t svlastb[_f32](svbool_t pg, svfloat32_t op) : "LASTB Wresult, Pg, Zop.S" or "LASTB Sresult, Pg, Zop.S" public static unsafe float ExtractLast(Vector value); /// float64_t svlastb[_f64](svbool_t pg, svfloat64_t op) : "LASTB Xresult, Pg, Zop.D" or "LASTB Dresult, Pg, Zop.D" public static unsafe double ExtractLast(Vector value); /// int8_t svlastb[_s8](svbool_t pg, svint8_t op) : "LASTB Wresult, Pg, Zop.B" or "LASTB Bresult, Pg, Zop.B" public static unsafe sbyte ExtractLast(Vector value); /// int16_t svlastb[_s16](svbool_t pg, svint16_t op) : "LASTB Wresult, Pg, Zop.H" or "LASTB Hresult, Pg, Zop.H" public static unsafe short ExtractLast(Vector value); /// int32_t svlastb[_s32](svbool_t pg, svint32_t op) : "LASTB Wresult, Pg, Zop.S" or "LASTB Sresult, Pg, Zop.S" public static unsafe int ExtractLast(Vector value); /// int64_t svlastb[_s64](svbool_t pg, svint64_t op) : "LASTB Xresult, Pg, Zop.D" or "LASTB Dresult, Pg, Zop.D" public static unsafe long ExtractLast(Vector value); /// uint8_t svlastb[_u8](svbool_t pg, svuint8_t op) : "LASTB Wresult, Pg, Zop.B" or "LASTB Bresult, Pg, Zop.B" public static unsafe byte ExtractLast(Vector value); /// uint16_t svlastb[_u16](svbool_t pg, svuint16_t op) : "LASTB Wresult, Pg, Zop.H" or "LASTB Hresult, Pg, Zop.H" public static unsafe ushort ExtractLast(Vector value); /// uint32_t svlastb[_u32](svbool_t pg, svuint32_t op) : "LASTB Wresult, Pg, Zop.S" or "LASTB Sresult, Pg, Zop.S" public static unsafe uint ExtractLast(Vector value); /// uint64_t svlastb[_u64](svbool_t pg, svuint64_t op) : "LASTB Xresult, Pg, Zop.D" or "LASTB Dresult, Pg, Zop.D" public static unsafe ulong ExtractLast(Vector value); /// ExtractVector : Extract vector from pair of vectors /// svfloat32_t svext[_f32](svfloat32_t op1, svfloat32_t op2, uint64_t imm3) : "EXT Ztied1.B, Ztied1.B, Zop2.B, #imm3 * 4" or "MOVPRFX Zresult, Zop1; EXT Zresult.B, Zresult.B, Zop2.B, #imm3 * 4" public static unsafe Vector ExtractVector(Vector upper, Vector lower, ulong index); /// svfloat64_t svext[_f64](svfloat64_t op1, svfloat64_t op2, uint64_t imm3) : "EXT Ztied1.B, Ztied1.B, Zop2.B, #imm3 * 8" or "MOVPRFX Zresult, Zop1; EXT Zresult.B, Zresult.B, Zop2.B, #imm3 * 8" public static unsafe Vector ExtractVector(Vector upper, Vector lower, ulong index); /// svint8_t svext[_s8](svint8_t op1, svint8_t op2, uint64_t imm3) : "EXT Ztied1.B, Ztied1.B, Zop2.B, #imm3" or "MOVPRFX Zresult, Zop1; EXT Zresult.B, Zresult.B, Zop2.B, #imm3" public static unsafe Vector ExtractVector(Vector upper, Vector lower, ulong index); /// svint16_t svext[_s16](svint16_t op1, svint16_t op2, uint64_t imm3) : "EXT Ztied1.B, Ztied1.B, Zop2.B, #imm3 * 2" or "MOVPRFX Zresult, Zop1; EXT Zresult.B, Zresult.B, Zop2.B, #imm3 * 2" public static unsafe Vector ExtractVector(Vector upper, Vector lower, ulong index); /// svint32_t svext[_s32](svint32_t op1, svint32_t op2, uint64_t imm3) : "EXT Ztied1.B, Ztied1.B, Zop2.B, #imm3 * 4" or "MOVPRFX Zresult, Zop1; EXT Zresult.B, Zresult.B, Zop2.B, #imm3 * 4" public static unsafe Vector ExtractVector(Vector upper, Vector lower, ulong index); /// svint64_t svext[_s64](svint64_t op1, svint64_t op2, uint64_t imm3) : "EXT Ztied1.B, Ztied1.B, Zop2.B, #imm3 * 8" or "MOVPRFX Zresult, Zop1; EXT Zresult.B, Zresult.B, Zop2.B, #imm3 * 8" public static unsafe Vector ExtractVector(Vector upper, Vector lower, ulong index); /// svuint8_t svext[_u8](svuint8_t op1, svuint8_t op2, uint64_t imm3) : "EXT Ztied1.B, Ztied1.B, Zop2.B, #imm3" or "MOVPRFX Zresult, Zop1; EXT Zresult.B, Zresult.B, Zop2.B, #imm3" public static unsafe Vector ExtractVector(Vector upper, Vector lower, ulong index); /// svuint16_t svext[_u16](svuint16_t op1, svuint16_t op2, uint64_t imm3) : "EXT Ztied1.B, Ztied1.B, Zop2.B, #imm3 * 2" or "MOVPRFX Zresult, Zop1; EXT Zresult.B, Zresult.B, Zop2.B, #imm3 * 2" public static unsafe Vector ExtractVector(Vector upper, Vector lower, ulong index); /// svuint32_t svext[_u32](svuint32_t op1, svuint32_t op2, uint64_t imm3) : "EXT Ztied1.B, Ztied1.B, Zop2.B, #imm3 * 4" or "MOVPRFX Zresult, Zop1; EXT Zresult.B, Zresult.B, Zop2.B, #imm3 * 4" public static unsafe Vector ExtractVector(Vector upper, Vector lower, ulong index); /// svuint64_t svext[_u64](svuint64_t op1, svuint64_t op2, uint64_t imm3) : "EXT Ztied1.B, Ztied1.B, Zop2.B, #imm3 * 8" or "MOVPRFX Zresult, Zop1; EXT Zresult.B, Zresult.B, Zop2.B, #imm3 * 8" public static unsafe Vector ExtractVector(Vector upper, Vector lower, ulong index); /// MaskClearAll : Set all predicate elements to false /// svbool_t svpfalse[_b]() : "PFALSE Presult.B" public static unsafe Vector MaskClearAll(); /// svbool_t svpfalse[_b]() : "PFALSE Presult.B" public static unsafe Vector MaskClearAll(); /// svbool_t svpfalse[_b]() : "PFALSE Presult.B" public static unsafe Vector MaskClearAll(); /// svbool_t svpfalse[_b]() : "PFALSE Presult.B" public static unsafe Vector MaskClearAll(); /// svbool_t svpfalse[_b]() : "PFALSE Presult.B" public static unsafe Vector MaskClearAll(); /// svbool_t svpfalse[_b]() : "PFALSE Presult.B" public static unsafe Vector MaskClearAll(); /// svbool_t svpfalse[_b]() : "PFALSE Presult.B" public static unsafe Vector MaskClearAll(); /// svbool_t svpfalse[_b]() : "PFALSE Presult.B" public static unsafe Vector MaskClearAll(); /// MaskGetFirstSet : Find next active predicate /// svbool_t svpnext_b8(svbool_t pg, svbool_t op) : "PNEXT Ptied.B, Pg, Ptied.B" public static unsafe Vector MaskGetFirstSet(Vector value); /// svbool_t svpnext_b16(svbool_t pg, svbool_t op) : "PNEXT Ptied.H, Pg, Ptied.H" public static unsafe Vector MaskGetFirstSet(Vector value); /// svbool_t svpnext_b32(svbool_t pg, svbool_t op) : "PNEXT Ptied.S, Pg, Ptied.S" public static unsafe Vector MaskGetFirstSet(Vector value); /// svbool_t svpnext_b64(svbool_t pg, svbool_t op) : "PNEXT Ptied.D, Pg, Ptied.D" public static unsafe Vector MaskGetFirstSet(Vector value); /// MaskSetAll : Set predicate elements to true /// svbool_t svptrue_b8() : "PTRUE Presult.B, ALL" public static unsafe Vector MaskSetAll(); /// svbool_t svptrue_b16() : "PTRUE Presult.H, ALL" public static unsafe Vector MaskSetAll(); /// svbool_t svptrue_b32() : "PTRUE Presult.S, ALL" public static unsafe Vector MaskSetAll(); /// svbool_t svptrue_b64() : "PTRUE Presult.D, ALL" public static unsafe Vector MaskSetAll(); /// svbool_t svptrue_pat_b8(enum svpattern pattern) : "PTRUE Presult.B, pattern" public static unsafe Vector MaskSetAll(enum svpattern pattern); /// svbool_t svptrue_pat_b16(enum svpattern pattern) : "PTRUE Presult.H, pattern" public static unsafe Vector MaskSetAll(enum svpattern pattern); /// svbool_t svptrue_pat_b32(enum svpattern pattern) : "PTRUE Presult.S, pattern" public static unsafe Vector MaskSetAll(enum svpattern pattern); /// svbool_t svptrue_pat_b64(enum svpattern pattern) : "PTRUE Presult.D, pattern" public static unsafe Vector MaskSetAll(enum svpattern pattern); /// MaskSetFirst : Set the first active predicate element to true /// svbool_t svpfirst[_b](svbool_t pg, svbool_t op) : "PFIRST Ptied.B, Pg, Ptied.B" public static unsafe Vector MaskSetFirst(Vector value); /// svbool_t svpfirst[_b](svbool_t pg, svbool_t op) : "PFIRST Ptied.B, Pg, Ptied.B" public static unsafe Vector MaskSetFirst(Vector value); /// svbool_t svpfirst[_b](svbool_t pg, svbool_t op) : "PFIRST Ptied.B, Pg, Ptied.B" public static unsafe Vector MaskSetFirst(Vector value); /// svbool_t svpfirst[_b](svbool_t pg, svbool_t op) : "PFIRST Ptied.B, Pg, Ptied.B" public static unsafe Vector MaskSetFirst(Vector value); /// svbool_t svpfirst[_b](svbool_t pg, svbool_t op) : "PFIRST Ptied.B, Pg, Ptied.B" public static unsafe Vector MaskSetFirst(Vector value); /// svbool_t svpfirst[_b](svbool_t pg, svbool_t op) : "PFIRST Ptied.B, Pg, Ptied.B" public static unsafe Vector MaskSetFirst(Vector value); /// svbool_t svpfirst[_b](svbool_t pg, svbool_t op) : "PFIRST Ptied.B, Pg, Ptied.B" public static unsafe Vector MaskSetFirst(Vector value); /// svbool_t svpfirst[_b](svbool_t pg, svbool_t op) : "PFIRST Ptied.B, Pg, Ptied.B" public static unsafe Vector MaskSetFirst(Vector value); /// PropagateBreak : Propagate break to next partition /// svbool_t svbrkn[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKN Ptied2.B, Pg/Z, Pop1.B, Ptied2.B" public static unsafe Vector PropagateBreak(Vector left, Vector right); /// svbool_t svbrkn[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKN Ptied2.B, Pg/Z, Pop1.B, Ptied2.B" public static unsafe Vector PropagateBreak(Vector left, Vector right); /// svbool_t svbrkn[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKN Ptied2.B, Pg/Z, Pop1.B, Ptied2.B" public static unsafe Vector PropagateBreak(Vector left, Vector right); /// svbool_t svbrkn[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKN Ptied2.B, Pg/Z, Pop1.B, Ptied2.B" public static unsafe Vector PropagateBreak(Vector left, Vector right); /// svbool_t svbrkn[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKN Ptied2.B, Pg/Z, Pop1.B, Ptied2.B" public static unsafe Vector PropagateBreak(Vector left, Vector right); /// svbool_t svbrkn[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKN Ptied2.B, Pg/Z, Pop1.B, Ptied2.B" public static unsafe Vector PropagateBreak(Vector left, Vector right); /// svbool_t svbrkn[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKN Ptied2.B, Pg/Z, Pop1.B, Ptied2.B" public static unsafe Vector PropagateBreak(Vector left, Vector right); /// svbool_t svbrkn[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKN Ptied2.B, Pg/Z, Pop1.B, Ptied2.B" public static unsafe Vector PropagateBreak(Vector left, Vector right); /// WhileLessThan : While incrementing scalar is less than /// svbool_t svwhilelt_b8[_s32](int32_t op1, int32_t op2) : "WHILELT Presult.B, Wop1, Wop2" public static unsafe Vector WhileLessThan(int left, int right); /// svbool_t svwhilelt_b8[_s64](int64_t op1, int64_t op2) : "WHILELT Presult.B, Xop1, Xop2" public static unsafe Vector WhileLessThan(long left, long right); /// svbool_t svwhilelt_b8[_u32](uint32_t op1, uint32_t op2) : "WHILELO Presult.B, Wop1, Wop2" public static unsafe Vector WhileLessThan(uint left, uint right); /// svbool_t svwhilelt_b8[_u64](uint64_t op1, uint64_t op2) : "WHILELO Presult.B, Xop1, Xop2" public static unsafe Vector WhileLessThan(ulong left, ulong right); /// svbool_t svwhilelt_b16[_s32](int32_t op1, int32_t op2) : "WHILELT Presult.H, Wop1, Wop2" public static unsafe Vector WhileLessThan(int left, int right); /// svbool_t svwhilelt_b16[_s64](int64_t op1, int64_t op2) : "WHILELT Presult.H, Xop1, Xop2" public static unsafe Vector WhileLessThan(long left, long right); /// svbool_t svwhilelt_b16[_u32](uint32_t op1, uint32_t op2) : "WHILELO Presult.H, Wop1, Wop2" public static unsafe Vector WhileLessThan(uint left, uint right); /// svbool_t svwhilelt_b16[_u64](uint64_t op1, uint64_t op2) : "WHILELO Presult.H, Xop1, Xop2" public static unsafe Vector WhileLessThan(ulong left, ulong right); /// svbool_t svwhilelt_b32[_s32](int32_t op1, int32_t op2) : "WHILELT Presult.S, Wop1, Wop2" public static unsafe Vector WhileLessThan(int left, int right); /// svbool_t svwhilelt_b32[_s64](int64_t op1, int64_t op2) : "WHILELT Presult.S, Xop1, Xop2" public static unsafe Vector WhileLessThan(long left, long right); /// svbool_t svwhilelt_b32[_u32](uint32_t op1, uint32_t op2) : "WHILELO Presult.S, Wop1, Wop2" public static unsafe Vector WhileLessThan(uint left, uint right); /// svbool_t svwhilelt_b32[_u64](uint64_t op1, uint64_t op2) : "WHILELO Presult.S, Xop1, Xop2" public static unsafe Vector WhileLessThan(ulong left, ulong right); /// svbool_t svwhilelt_b64[_s32](int32_t op1, int32_t op2) : "WHILELT Presult.D, Wop1, Wop2" public static unsafe Vector WhileLessThan(int left, int right); /// svbool_t svwhilelt_b64[_s64](int64_t op1, int64_t op2) : "WHILELT Presult.D, Xop1, Xop2" public static unsafe Vector WhileLessThan(long left, long right); /// svbool_t svwhilelt_b64[_u32](uint32_t op1, uint32_t op2) : "WHILELO Presult.D, Wop1, Wop2" public static unsafe Vector WhileLessThan(uint left, uint right); /// svbool_t svwhilelt_b64[_u64](uint64_t op1, uint64_t op2) : "WHILELO Presult.D, Xop1, Xop2" public static unsafe Vector WhileLessThan(ulong left, ulong right); ///continued.... ```
Author: a74nh
Assignees: -
Labels: `area-System.Runtime.Intrinsics`, `untriaged`
Milestone: -
a74nh commented 1 year ago 

/// Full API
public abstract partial class Sve : AdvSimd /// Feature: FEAT_SVE  Category: mask
{
    /// AbsoluteCompareGreaterThan : Absolute compare greater than

    /// svbool_t svacgt[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) : "FACGT Presult.S, Pg/Z, Zop1.S, Zop2.S"
  public static unsafe Vector<float> AbsoluteCompareGreaterThan(Vector<float> left, Vector<float> right);

    /// svbool_t svacgt[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) : "FACGT Presult.D, Pg/Z, Zop1.D, Zop2.D"
  public static unsafe Vector<double> AbsoluteCompareGreaterThan(Vector<double> left, Vector<double> right);

    /// AbsoluteCompareGreaterThanOrEqual : Absolute compare greater than or equal to

    /// svbool_t svacge[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) : "FACGE Presult.S, Pg/Z, Zop1.S, Zop2.S"
  public static unsafe Vector<float> AbsoluteCompareGreaterThanOrEqual(Vector<float> left, Vector<float> right);

    /// svbool_t svacge[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) : "FACGE Presult.D, Pg/Z, Zop1.D, Zop2.D"
  public static unsafe Vector<double> AbsoluteCompareGreaterThanOrEqual(Vector<double> left, Vector<double> right);

    /// AbsoluteCompareLessThan : Absolute compare less than

    /// svbool_t svaclt[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) : "FACGT Presult.S, Pg/Z, Zop2.S, Zop1.S"
  public static unsafe Vector<float> AbsoluteCompareLessThan(Vector<float> left, Vector<float> right);

    /// svbool_t svaclt[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) : "FACGT Presult.D, Pg/Z, Zop2.D, Zop1.D"
  public static unsafe Vector<double> AbsoluteCompareLessThan(Vector<double> left, Vector<double> right);

    /// AbsoluteCompareLessThanOrEqual : Absolute compare less than or equal to

    /// svbool_t svacle[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) : "FACGE Presult.S, Pg/Z, Zop2.S, Zop1.S"
  public static unsafe Vector<float> AbsoluteCompareLessThanOrEqual(Vector<float> left, Vector<float> right);

    /// svbool_t svacle[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) : "FACGE Presult.D, Pg/Z, Zop2.D, Zop1.D"
  public static unsafe Vector<double> AbsoluteCompareLessThanOrEqual(Vector<double> left, Vector<double> right);

    /// Compact : Shuffle active elements of vector to the right and fill with zero

    /// svfloat32_t svcompact[_f32](svbool_t pg, svfloat32_t op) : "COMPACT Zresult.S, Pg, Zop.S"
  public static unsafe Vector<float> Compact(Vector<float> mask, Vector<float> value);

    /// svfloat64_t svcompact[_f64](svbool_t pg, svfloat64_t op) : "COMPACT Zresult.D, Pg, Zop.D"
  public static unsafe Vector<double> Compact(Vector<double> mask, Vector<double> value);

    /// svint32_t svcompact[_s32](svbool_t pg, svint32_t op) : "COMPACT Zresult.S, Pg, Zop.S"
  public static unsafe Vector<int> Compact(Vector<int> mask, Vector<int> value);

    /// svint64_t svcompact[_s64](svbool_t pg, svint64_t op) : "COMPACT Zresult.D, Pg, Zop.D"
  public static unsafe Vector<long> Compact(Vector<long> mask, Vector<long> value);

    /// svuint32_t svcompact[_u32](svbool_t pg, svuint32_t op) : "COMPACT Zresult.S, Pg, Zop.S"
  public static unsafe Vector<uint> Compact(Vector<uint> mask, Vector<uint> value);

    /// svuint64_t svcompact[_u64](svbool_t pg, svuint64_t op) : "COMPACT Zresult.D, Pg, Zop.D"
  public static unsafe Vector<ulong> Compact(Vector<ulong> mask, Vector<ulong> value);

    /// CompareEqual : Compare equal to

    /// svbool_t svcmpeq[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) : "FCMEQ Presult.S, Pg/Z, Zop1.S, Zop2.S"
  public static unsafe Vector<float> CompareEqual(Vector<float> left, Vector<float> right);

    /// svbool_t svcmpeq[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) : "FCMEQ Presult.D, Pg/Z, Zop1.D, Zop2.D"
  public static unsafe Vector<double> CompareEqual(Vector<double> left, Vector<double> right);

    /// svbool_t svcmpeq[_s8](svbool_t pg, svint8_t op1, svint8_t op2) : "CMPEQ Presult.B, Pg/Z, Zop1.B, Zop2.B"
  public static unsafe Vector<sbyte> CompareEqual(Vector<sbyte> left, Vector<sbyte> right);

    /// svbool_t svcmpeq[_s16](svbool_t pg, svint16_t op1, svint16_t op2) : "CMPEQ Presult.H, Pg/Z, Zop1.H, Zop2.H"
  public static unsafe Vector<short> CompareEqual(Vector<short> left, Vector<short> right);

    /// svbool_t svcmpeq[_s32](svbool_t pg, svint32_t op1, svint32_t op2) : "CMPEQ Presult.S, Pg/Z, Zop1.S, Zop2.S"
  public static unsafe Vector<int> CompareEqual(Vector<int> left, Vector<int> right);

    /// svbool_t svcmpeq[_s64](svbool_t pg, svint64_t op1, svint64_t op2) : "CMPEQ Presult.D, Pg/Z, Zop1.D, Zop2.D"
  public static unsafe Vector<long> CompareEqual(Vector<long> left, Vector<long> right);

    /// svbool_t svcmpeq[_u8](svbool_t pg, svuint8_t op1, svuint8_t op2) : "CMPEQ Presult.B, Pg/Z, Zop1.B, Zop2.B"
  public static unsafe Vector<byte> CompareEqual(Vector<byte> left, Vector<byte> right);

    /// svbool_t svcmpeq[_u16](svbool_t pg, svuint16_t op1, svuint16_t op2) : "CMPEQ Presult.H, Pg/Z, Zop1.H, Zop2.H"
  public static unsafe Vector<ushort> CompareEqual(Vector<ushort> left, Vector<ushort> right);

    /// svbool_t svcmpeq[_u32](svbool_t pg, svuint32_t op1, svuint32_t op2) : "CMPEQ Presult.S, Pg/Z, Zop1.S, Zop2.S"
  public static unsafe Vector<uint> CompareEqual(Vector<uint> left, Vector<uint> right);

    /// svbool_t svcmpeq[_u64](svbool_t pg, svuint64_t op1, svuint64_t op2) : "CMPEQ Presult.D, Pg/Z, Zop1.D, Zop2.D"
  public static unsafe Vector<ulong> CompareEqual(Vector<ulong> left, Vector<ulong> right);

    /// svbool_t svcmpeq_wide[_s8](svbool_t pg, svint8_t op1, svint64_t op2) : "CMPEQ Presult.B, Pg/Z, Zop1.B, Zop2.D"
  public static unsafe Vector<sbyte> CompareEqual(Vector<sbyte> left, Vector<long> right);

    /// svbool_t svcmpeq_wide[_s16](svbool_t pg, svint16_t op1, svint64_t op2) : "CMPEQ Presult.H, Pg/Z, Zop1.H, Zop2.D"
  public static unsafe Vector<short> CompareEqual(Vector<short> left, Vector<long> right);

    /// svbool_t svcmpeq_wide[_s32](svbool_t pg, svint32_t op1, svint64_t op2) : "CMPEQ Presult.S, Pg/Z, Zop1.S, Zop2.D"
  public static unsafe Vector<int> CompareEqual(Vector<int> left, Vector<long> right);

    /// CompareGreaterThan : Compare greater than

    /// svbool_t svcmpgt[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) : "FCMGT Presult.S, Pg/Z, Zop1.S, Zop2.S"
  public static unsafe Vector<float> CompareGreaterThan(Vector<float> left, Vector<float> right);

    /// svbool_t svcmpgt[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) : "FCMGT Presult.D, Pg/Z, Zop1.D, Zop2.D"
  public static unsafe Vector<double> CompareGreaterThan(Vector<double> left, Vector<double> right);

    /// svbool_t svcmpgt[_s8](svbool_t pg, svint8_t op1, svint8_t op2) : "CMPGT Presult.B, Pg/Z, Zop1.B, Zop2.B"
  public static unsafe Vector<sbyte> CompareGreaterThan(Vector<sbyte> left, Vector<sbyte> right);

    /// svbool_t svcmpgt[_s16](svbool_t pg, svint16_t op1, svint16_t op2) : "CMPGT Presult.H, Pg/Z, Zop1.H, Zop2.H"
  public static unsafe Vector<short> CompareGreaterThan(Vector<short> left, Vector<short> right);

    /// svbool_t svcmpgt[_s32](svbool_t pg, svint32_t op1, svint32_t op2) : "CMPGT Presult.S, Pg/Z, Zop1.S, Zop2.S"
  public static unsafe Vector<int> CompareGreaterThan(Vector<int> left, Vector<int> right);

    /// svbool_t svcmpgt[_s64](svbool_t pg, svint64_t op1, svint64_t op2) : "CMPGT Presult.D, Pg/Z, Zop1.D, Zop2.D"
  public static unsafe Vector<long> CompareGreaterThan(Vector<long> left, Vector<long> right);

    /// svbool_t svcmpgt[_u8](svbool_t pg, svuint8_t op1, svuint8_t op2) : "CMPHI Presult.B, Pg/Z, Zop1.B, Zop2.B"
  public static unsafe Vector<byte> CompareGreaterThan(Vector<byte> left, Vector<byte> right);

    /// svbool_t svcmpgt[_u16](svbool_t pg, svuint16_t op1, svuint16_t op2) : "CMPHI Presult.H, Pg/Z, Zop1.H, Zop2.H"
  public static unsafe Vector<ushort> CompareGreaterThan(Vector<ushort> left, Vector<ushort> right);

    /// svbool_t svcmpgt[_u32](svbool_t pg, svuint32_t op1, svuint32_t op2) : "CMPHI Presult.S, Pg/Z, Zop1.S, Zop2.S"
  public static unsafe Vector<uint> CompareGreaterThan(Vector<uint> left, Vector<uint> right);

    /// svbool_t svcmpgt[_u64](svbool_t pg, svuint64_t op1, svuint64_t op2) : "CMPHI Presult.D, Pg/Z, Zop1.D, Zop2.D"
  public static unsafe Vector<ulong> CompareGreaterThan(Vector<ulong> left, Vector<ulong> right);

    /// svbool_t svcmpgt_wide[_s8](svbool_t pg, svint8_t op1, svint64_t op2) : "CMPGT Presult.B, Pg/Z, Zop1.B, Zop2.D"
  public static unsafe Vector<sbyte> CompareGreaterThan(Vector<sbyte> left, Vector<long> right);

    /// svbool_t svcmpgt_wide[_s16](svbool_t pg, svint16_t op1, svint64_t op2) : "CMPGT Presult.H, Pg/Z, Zop1.H, Zop2.D"
  public static unsafe Vector<short> CompareGreaterThan(Vector<short> left, Vector<long> right);

    /// svbool_t svcmpgt_wide[_s32](svbool_t pg, svint32_t op1, svint64_t op2) : "CMPGT Presult.S, Pg/Z, Zop1.S, Zop2.D"
  public static unsafe Vector<int> CompareGreaterThan(Vector<int> left, Vector<long> right);

    /// svbool_t svcmpgt_wide[_u8](svbool_t pg, svuint8_t op1, svuint64_t op2) : "CMPHI Presult.B, Pg/Z, Zop1.B, Zop2.D"
  public static unsafe Vector<byte> CompareGreaterThan(Vector<byte> left, Vector<ulong> right);

    /// svbool_t svcmpgt_wide[_u16](svbool_t pg, svuint16_t op1, svuint64_t op2) : "CMPHI Presult.H, Pg/Z, Zop1.H, Zop2.D"
  public static unsafe Vector<ushort> CompareGreaterThan(Vector<ushort> left, Vector<ulong> right);

    /// svbool_t svcmpgt_wide[_u32](svbool_t pg, svuint32_t op1, svuint64_t op2) : "CMPHI Presult.S, Pg/Z, Zop1.S, Zop2.D"
  public static unsafe Vector<uint> CompareGreaterThan(Vector<uint> left, Vector<ulong> right);

    /// CompareGreaterThanOrEqual : Compare greater than or equal to

    /// svbool_t svcmpge[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) : "FCMGE Presult.S, Pg/Z, Zop1.S, Zop2.S"
  public static unsafe Vector<float> CompareGreaterThanOrEqual(Vector<float> left, Vector<float> right);

    /// svbool_t svcmpge[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) : "FCMGE Presult.D, Pg/Z, Zop1.D, Zop2.D"
  public static unsafe Vector<double> CompareGreaterThanOrEqual(Vector<double> left, Vector<double> right);

    /// svbool_t svcmpge[_s8](svbool_t pg, svint8_t op1, svint8_t op2) : "CMPGE Presult.B, Pg/Z, Zop1.B, Zop2.B"
  public static unsafe Vector<sbyte> CompareGreaterThanOrEqual(Vector<sbyte> left, Vector<sbyte> right);

    /// svbool_t svcmpge[_s16](svbool_t pg, svint16_t op1, svint16_t op2) : "CMPGE Presult.H, Pg/Z, Zop1.H, Zop2.H"
  public static unsafe Vector<short> CompareGreaterThanOrEqual(Vector<short> left, Vector<short> right);

    /// svbool_t svcmpge[_s32](svbool_t pg, svint32_t op1, svint32_t op2) : "CMPGE Presult.S, Pg/Z, Zop1.S, Zop2.S"
  public static unsafe Vector<int> CompareGreaterThanOrEqual(Vector<int> left, Vector<int> right);

    /// svbool_t svcmpge[_s64](svbool_t pg, svint64_t op1, svint64_t op2) : "CMPGE Presult.D, Pg/Z, Zop1.D, Zop2.D"
  public static unsafe Vector<long> CompareGreaterThanOrEqual(Vector<long> left, Vector<long> right);

    /// svbool_t svcmpge[_u8](svbool_t pg, svuint8_t op1, svuint8_t op2) : "CMPHS Presult.B, Pg/Z, Zop1.B, Zop2.B"
  public static unsafe Vector<byte> CompareGreaterThanOrEqual(Vector<byte> left, Vector<byte> right);

    /// svbool_t svcmpge[_u16](svbool_t pg, svuint16_t op1, svuint16_t op2) : "CMPHS Presult.H, Pg/Z, Zop1.H, Zop2.H"
  public static unsafe Vector<ushort> CompareGreaterThanOrEqual(Vector<ushort> left, Vector<ushort> right);

    /// svbool_t svcmpge[_u32](svbool_t pg, svuint32_t op1, svuint32_t op2) : "CMPHS Presult.S, Pg/Z, Zop1.S, Zop2.S"
  public static unsafe Vector<uint> CompareGreaterThanOrEqual(Vector<uint> left, Vector<uint> right);

    /// svbool_t svcmpge[_u64](svbool_t pg, svuint64_t op1, svuint64_t op2) : "CMPHS Presult.D, Pg/Z, Zop1.D, Zop2.D"
  public static unsafe Vector<ulong> CompareGreaterThanOrEqual(Vector<ulong> left, Vector<ulong> right);

    /// svbool_t svcmpge_wide[_s8](svbool_t pg, svint8_t op1, svint64_t op2) : "CMPGE Presult.B, Pg/Z, Zop1.B, Zop2.D"
  public static unsafe Vector<sbyte> CompareGreaterThanOrEqual(Vector<sbyte> left, Vector<long> right);

    /// svbool_t svcmpge_wide[_s16](svbool_t pg, svint16_t op1, svint64_t op2) : "CMPGE Presult.H, Pg/Z, Zop1.H, Zop2.D"
  public static unsafe Vector<short> CompareGreaterThanOrEqual(Vector<short> left, Vector<long> right);

    /// svbool_t svcmpge_wide[_s32](svbool_t pg, svint32_t op1, svint64_t op2) : "CMPGE Presult.S, Pg/Z, Zop1.S, Zop2.D"
  public static unsafe Vector<int> CompareGreaterThanOrEqual(Vector<int> left, Vector<long> right);

    /// svbool_t svcmpge_wide[_u8](svbool_t pg, svuint8_t op1, svuint64_t op2) : "CMPHS Presult.B, Pg/Z, Zop1.B, Zop2.D"
  public static unsafe Vector<byte> CompareGreaterThanOrEqual(Vector<byte> left, Vector<ulong> right);

    /// svbool_t svcmpge_wide[_u16](svbool_t pg, svuint16_t op1, svuint64_t op2) : "CMPHS Presult.H, Pg/Z, Zop1.H, Zop2.D"
  public static unsafe Vector<ushort> CompareGreaterThanOrEqual(Vector<ushort> left, Vector<ulong> right);

    /// svbool_t svcmpge_wide[_u32](svbool_t pg, svuint32_t op1, svuint64_t op2) : "CMPHS Presult.S, Pg/Z, Zop1.S, Zop2.D"
  public static unsafe Vector<uint> CompareGreaterThanOrEqual(Vector<uint> left, Vector<ulong> right);

    /// CompareLessThan : Compare less than

    /// svbool_t svcmplt[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) : "FCMGT Presult.S, Pg/Z, Zop2.S, Zop1.S"
  public static unsafe Vector<float> CompareLessThan(Vector<float> left, Vector<float> right);

    /// svbool_t svcmplt[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) : "FCMGT Presult.D, Pg/Z, Zop2.D, Zop1.D"
  public static unsafe Vector<double> CompareLessThan(Vector<double> left, Vector<double> right);

    /// svbool_t svcmplt[_s8](svbool_t pg, svint8_t op1, svint8_t op2) : "CMPGT Presult.B, Pg/Z, Zop2.B, Zop1.B"
  public static unsafe Vector<sbyte> CompareLessThan(Vector<sbyte> left, Vector<sbyte> right);

    /// svbool_t svcmplt[_s16](svbool_t pg, svint16_t op1, svint16_t op2) : "CMPGT Presult.H, Pg/Z, Zop2.H, Zop1.H"
  public static unsafe Vector<short> CompareLessThan(Vector<short> left, Vector<short> right);

    /// svbool_t svcmplt[_s32](svbool_t pg, svint32_t op1, svint32_t op2) : "CMPGT Presult.S, Pg/Z, Zop2.S, Zop1.S"
  public static unsafe Vector<int> CompareLessThan(Vector<int> left, Vector<int> right);

    /// svbool_t svcmplt[_s64](svbool_t pg, svint64_t op1, svint64_t op2) : "CMPGT Presult.D, Pg/Z, Zop2.D, Zop1.D"
  public static unsafe Vector<long> CompareLessThan(Vector<long> left, Vector<long> right);

    /// svbool_t svcmplt[_u8](svbool_t pg, svuint8_t op1, svuint8_t op2) : "CMPHI Presult.B, Pg/Z, Zop2.B, Zop1.B"
  public static unsafe Vector<byte> CompareLessThan(Vector<byte> left, Vector<byte> right);

    /// svbool_t svcmplt[_u16](svbool_t pg, svuint16_t op1, svuint16_t op2) : "CMPHI Presult.H, Pg/Z, Zop2.H, Zop1.H"
  public static unsafe Vector<ushort> CompareLessThan(Vector<ushort> left, Vector<ushort> right);

    /// svbool_t svcmplt[_u32](svbool_t pg, svuint32_t op1, svuint32_t op2) : "CMPHI Presult.S, Pg/Z, Zop2.S, Zop1.S"
  public static unsafe Vector<uint> CompareLessThan(Vector<uint> left, Vector<uint> right);

    /// svbool_t svcmplt[_u64](svbool_t pg, svuint64_t op1, svuint64_t op2) : "CMPHI Presult.D, Pg/Z, Zop2.D, Zop1.D"
  public static unsafe Vector<ulong> CompareLessThan(Vector<ulong> left, Vector<ulong> right);

    /// svbool_t svcmplt_wide[_s8](svbool_t pg, svint8_t op1, svint64_t op2) : "CMPLT Presult.B, Pg/Z, Zop1.B, Zop2.D"
  public static unsafe Vector<sbyte> CompareLessThan(Vector<sbyte> left, Vector<long> right);

    /// svbool_t svcmplt_wide[_s16](svbool_t pg, svint16_t op1, svint64_t op2) : "CMPLT Presult.H, Pg/Z, Zop1.H, Zop2.D"
  public static unsafe Vector<short> CompareLessThan(Vector<short> left, Vector<long> right);

    /// svbool_t svcmplt_wide[_s32](svbool_t pg, svint32_t op1, svint64_t op2) : "CMPLT Presult.S, Pg/Z, Zop1.S, Zop2.D"
  public static unsafe Vector<int> CompareLessThan(Vector<int> left, Vector<long> right);

    /// svbool_t svcmplt_wide[_u8](svbool_t pg, svuint8_t op1, svuint64_t op2) : "CMPLO Presult.B, Pg/Z, Zop1.B, Zop2.D"
  public static unsafe Vector<byte> CompareLessThan(Vector<byte> left, Vector<ulong> right);

    /// svbool_t svcmplt_wide[_u16](svbool_t pg, svuint16_t op1, svuint64_t op2) : "CMPLO Presult.H, Pg/Z, Zop1.H, Zop2.D"
  public static unsafe Vector<ushort> CompareLessThan(Vector<ushort> left, Vector<ulong> right);

    /// svbool_t svcmplt_wide[_u32](svbool_t pg, svuint32_t op1, svuint64_t op2) : "CMPLO Presult.S, Pg/Z, Zop1.S, Zop2.D"
  public static unsafe Vector<uint> CompareLessThan(Vector<uint> left, Vector<ulong> right);

    /// CompareLessThanOrEqual : Compare less than or equal to

    /// svbool_t svcmple[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) : "FCMGE Presult.S, Pg/Z, Zop2.S, Zop1.S"
  public static unsafe Vector<float> CompareLessThanOrEqual(Vector<float> left, Vector<float> right);

    /// svbool_t svcmple[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) : "FCMGE Presult.D, Pg/Z, Zop2.D, Zop1.D"
  public static unsafe Vector<double> CompareLessThanOrEqual(Vector<double> left, Vector<double> right);

    /// svbool_t svcmple[_s8](svbool_t pg, svint8_t op1, svint8_t op2) : "CMPGE Presult.B, Pg/Z, Zop2.B, Zop1.B"
  public static unsafe Vector<sbyte> CompareLessThanOrEqual(Vector<sbyte> left, Vector<sbyte> right);

    /// svbool_t svcmple[_s16](svbool_t pg, svint16_t op1, svint16_t op2) : "CMPGE Presult.H, Pg/Z, Zop2.H, Zop1.H"
  public static unsafe Vector<short> CompareLessThanOrEqual(Vector<short> left, Vector<short> right);

    /// svbool_t svcmple[_s32](svbool_t pg, svint32_t op1, svint32_t op2) : "CMPGE Presult.S, Pg/Z, Zop2.S, Zop1.S"
  public static unsafe Vector<int> CompareLessThanOrEqual(Vector<int> left, Vector<int> right);

    /// svbool_t svcmple[_s64](svbool_t pg, svint64_t op1, svint64_t op2) : "CMPGE Presult.D, Pg/Z, Zop2.D, Zop1.D"
  public static unsafe Vector<long> CompareLessThanOrEqual(Vector<long> left, Vector<long> right);

    /// svbool_t svcmple[_u8](svbool_t pg, svuint8_t op1, svuint8_t op2) : "CMPHS Presult.B, Pg/Z, Zop2.B, Zop1.B"
  public static unsafe Vector<byte> CompareLessThanOrEqual(Vector<byte> left, Vector<byte> right);

    /// svbool_t svcmple[_u16](svbool_t pg, svuint16_t op1, svuint16_t op2) : "CMPHS Presult.H, Pg/Z, Zop2.H, Zop1.H"
  public static unsafe Vector<ushort> CompareLessThanOrEqual(Vector<ushort> left, Vector<ushort> right);

    /// svbool_t svcmple[_u32](svbool_t pg, svuint32_t op1, svuint32_t op2) : "CMPHS Presult.S, Pg/Z, Zop2.S, Zop1.S"
  public static unsafe Vector<uint> CompareLessThanOrEqual(Vector<uint> left, Vector<uint> right);

    /// svbool_t svcmple[_u64](svbool_t pg, svuint64_t op1, svuint64_t op2) : "CMPHS Presult.D, Pg/Z, Zop2.D, Zop1.D"
  public static unsafe Vector<ulong> CompareLessThanOrEqual(Vector<ulong> left, Vector<ulong> right);

    /// svbool_t svcmple_wide[_s8](svbool_t pg, svint8_t op1, svint64_t op2) : "CMPLE Presult.B, Pg/Z, Zop1.B, Zop2.D"
  public static unsafe Vector<sbyte> CompareLessThanOrEqual(Vector<sbyte> left, Vector<long> right);

    /// svbool_t svcmple_wide[_s16](svbool_t pg, svint16_t op1, svint64_t op2) : "CMPLE Presult.H, Pg/Z, Zop1.H, Zop2.D"
  public static unsafe Vector<short> CompareLessThanOrEqual(Vector<short> left, Vector<long> right);

    /// svbool_t svcmple_wide[_s32](svbool_t pg, svint32_t op1, svint64_t op2) : "CMPLE Presult.S, Pg/Z, Zop1.S, Zop2.D"
  public static unsafe Vector<int> CompareLessThanOrEqual(Vector<int> left, Vector<long> right);

    /// svbool_t svcmple_wide[_u8](svbool_t pg, svuint8_t op1, svuint64_t op2) : "CMPLS Presult.B, Pg/Z, Zop1.B, Zop2.D"
  public static unsafe Vector<byte> CompareLessThanOrEqual(Vector<byte> left, Vector<ulong> right);

    /// svbool_t svcmple_wide[_u16](svbool_t pg, svuint16_t op1, svuint64_t op2) : "CMPLS Presult.H, Pg/Z, Zop1.H, Zop2.D"
  public static unsafe Vector<ushort> CompareLessThanOrEqual(Vector<ushort> left, Vector<ulong> right);

    /// svbool_t svcmple_wide[_u32](svbool_t pg, svuint32_t op1, svuint64_t op2) : "CMPLS Presult.S, Pg/Z, Zop1.S, Zop2.D"
  public static unsafe Vector<uint> CompareLessThanOrEqual(Vector<uint> left, Vector<ulong> right);

    /// CompareNotEqualTo : Compare not equal to

    /// svbool_t svcmpne[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) : "FCMNE Presult.S, Pg/Z, Zop1.S, Zop2.S"
  public static unsafe Vector<float> CompareNotEqualTo(Vector<float> left, Vector<float> right);

    /// svbool_t svcmpne[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) : "FCMNE Presult.D, Pg/Z, Zop1.D, Zop2.D"
  public static unsafe Vector<double> CompareNotEqualTo(Vector<double> left, Vector<double> right);

    /// svbool_t svcmpne[_s8](svbool_t pg, svint8_t op1, svint8_t op2) : "CMPNE Presult.B, Pg/Z, Zop1.B, Zop2.B"
  public static unsafe Vector<sbyte> CompareNotEqualTo(Vector<sbyte> left, Vector<sbyte> right);

    /// svbool_t svcmpne[_s16](svbool_t pg, svint16_t op1, svint16_t op2) : "CMPNE Presult.H, Pg/Z, Zop1.H, Zop2.H"
  public static unsafe Vector<short> CompareNotEqualTo(Vector<short> left, Vector<short> right);

    /// svbool_t svcmpne[_s32](svbool_t pg, svint32_t op1, svint32_t op2) : "CMPNE Presult.S, Pg/Z, Zop1.S, Zop2.S"
  public static unsafe Vector<int> CompareNotEqualTo(Vector<int> left, Vector<int> right);

    /// svbool_t svcmpne[_s64](svbool_t pg, svint64_t op1, svint64_t op2) : "CMPNE Presult.D, Pg/Z, Zop1.D, Zop2.D"
  public static unsafe Vector<long> CompareNotEqualTo(Vector<long> left, Vector<long> right);

    /// svbool_t svcmpne[_u8](svbool_t pg, svuint8_t op1, svuint8_t op2) : "CMPNE Presult.B, Pg/Z, Zop1.B, Zop2.B"
  public static unsafe Vector<byte> CompareNotEqualTo(Vector<byte> left, Vector<byte> right);

    /// svbool_t svcmpne[_u16](svbool_t pg, svuint16_t op1, svuint16_t op2) : "CMPNE Presult.H, Pg/Z, Zop1.H, Zop2.H"
  public static unsafe Vector<ushort> CompareNotEqualTo(Vector<ushort> left, Vector<ushort> right);

    /// svbool_t svcmpne[_u32](svbool_t pg, svuint32_t op1, svuint32_t op2) : "CMPNE Presult.S, Pg/Z, Zop1.S, Zop2.S"
  public static unsafe Vector<uint> CompareNotEqualTo(Vector<uint> left, Vector<uint> right);

    /// svbool_t svcmpne[_u64](svbool_t pg, svuint64_t op1, svuint64_t op2) : "CMPNE Presult.D, Pg/Z, Zop1.D, Zop2.D"
  public static unsafe Vector<ulong> CompareNotEqualTo(Vector<ulong> left, Vector<ulong> right);

    /// svbool_t svcmpne_wide[_s8](svbool_t pg, svint8_t op1, svint64_t op2) : "CMPNE Presult.B, Pg/Z, Zop1.B, Zop2.D"
  public static unsafe Vector<sbyte> CompareNotEqualTo(Vector<sbyte> left, Vector<long> right);

    /// svbool_t svcmpne_wide[_s16](svbool_t pg, svint16_t op1, svint64_t op2) : "CMPNE Presult.H, Pg/Z, Zop1.H, Zop2.D"
  public static unsafe Vector<short> CompareNotEqualTo(Vector<short> left, Vector<long> right);

    /// svbool_t svcmpne_wide[_s32](svbool_t pg, svint32_t op1, svint64_t op2) : "CMPNE Presult.S, Pg/Z, Zop1.S, Zop2.D"
  public static unsafe Vector<int> CompareNotEqualTo(Vector<int> left, Vector<long> right);

    /// CompareUnordered : Compare unordered with

    /// svbool_t svcmpuo[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) : "FCMUO Presult.S, Pg/Z, Zop1.S, Zop2.S"
  public static unsafe Vector<float> CompareUnordered(Vector<float> left, Vector<float> right);

    /// svbool_t svcmpuo[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) : "FCMUO Presult.D, Pg/Z, Zop1.D, Zop2.D"
  public static unsafe Vector<double> CompareUnordered(Vector<double> left, Vector<double> right);

    /// ConditionalExtractAfterLastActiveElement : Conditionally extract element after last

    /// svfloat32_t svclasta[_f32](svbool_t pg, svfloat32_t fallback, svfloat32_t data) : "CLASTA Ztied.S, Pg, Ztied.S, Zdata.S" or "MOVPRFX Zresult, Zfallback; CLASTA Zresult.S, Pg, Zresult.S, Zdata.S"
  public static unsafe Vector<float> ConditionalExtractAfterLastActiveElement(Vector<float> mask, Vector<float> fallback, Vector<float> data);

    /// svfloat64_t svclasta[_f64](svbool_t pg, svfloat64_t fallback, svfloat64_t data) : "CLASTA Ztied.D, Pg, Ztied.D, Zdata.D" or "MOVPRFX Zresult, Zfallback; CLASTA Zresult.D, Pg, Zresult.D, Zdata.D"
  public static unsafe Vector<double> ConditionalExtractAfterLastActiveElement(Vector<double> mask, Vector<double> fallback, Vector<double> data);

    /// svint8_t svclasta[_s8](svbool_t pg, svint8_t fallback, svint8_t data) : "CLASTA Ztied.B, Pg, Ztied.B, Zdata.B" or "MOVPRFX Zresult, Zfallback; CLASTA Zresult.B, Pg, Zresult.B, Zdata.B"
  public static unsafe Vector<sbyte> ConditionalExtractAfterLastActiveElement(Vector<sbyte> mask, Vector<sbyte> fallback, Vector<sbyte> data);

    /// svint16_t svclasta[_s16](svbool_t pg, svint16_t fallback, svint16_t data) : "CLASTA Ztied.H, Pg, Ztied.H, Zdata.H" or "MOVPRFX Zresult, Zfallback; CLASTA Zresult.H, Pg, Zresult.H, Zdata.H"
  public static unsafe Vector<short> ConditionalExtractAfterLastActiveElement(Vector<short> mask, Vector<short> fallback, Vector<short> data);

    /// svint32_t svclasta[_s32](svbool_t pg, svint32_t fallback, svint32_t data) : "CLASTA Ztied.S, Pg, Ztied.S, Zdata.S" or "MOVPRFX Zresult, Zfallback; CLASTA Zresult.S, Pg, Zresult.S, Zdata.S"
  public static unsafe Vector<int> ConditionalExtractAfterLastActiveElement(Vector<int> mask, Vector<int> fallback, Vector<int> data);

    /// svint64_t svclasta[_s64](svbool_t pg, svint64_t fallback, svint64_t data) : "CLASTA Ztied.D, Pg, Ztied.D, Zdata.D" or "MOVPRFX Zresult, Zfallback; CLASTA Zresult.D, Pg, Zresult.D, Zdata.D"
  public static unsafe Vector<long> ConditionalExtractAfterLastActiveElement(Vector<long> mask, Vector<long> fallback, Vector<long> data);

    /// svuint8_t svclasta[_u8](svbool_t pg, svuint8_t fallback, svuint8_t data) : "CLASTA Ztied.B, Pg, Ztied.B, Zdata.B" or "MOVPRFX Zresult, Zfallback; CLASTA Zresult.B, Pg, Zresult.B, Zdata.B"
  public static unsafe Vector<byte> ConditionalExtractAfterLastActiveElement(Vector<byte> mask, Vector<byte> fallback, Vector<byte> data);

    /// svuint16_t svclasta[_u16](svbool_t pg, svuint16_t fallback, svuint16_t data) : "CLASTA Ztied.H, Pg, Ztied.H, Zdata.H" or "MOVPRFX Zresult, Zfallback; CLASTA Zresult.H, Pg, Zresult.H, Zdata.H"
  public static unsafe Vector<ushort> ConditionalExtractAfterLastActiveElement(Vector<ushort> mask, Vector<ushort> fallback, Vector<ushort> data);

    /// svuint32_t svclasta[_u32](svbool_t pg, svuint32_t fallback, svuint32_t data) : "CLASTA Ztied.S, Pg, Ztied.S, Zdata.S" or "MOVPRFX Zresult, Zfallback; CLASTA Zresult.S, Pg, Zresult.S, Zdata.S"
  public static unsafe Vector<uint> ConditionalExtractAfterLastActiveElement(Vector<uint> mask, Vector<uint> fallback, Vector<uint> data);

    /// svuint64_t svclasta[_u64](svbool_t pg, svuint64_t fallback, svuint64_t data) : "CLASTA Ztied.D, Pg, Ztied.D, Zdata.D" or "MOVPRFX Zresult, Zfallback; CLASTA Zresult.D, Pg, Zresult.D, Zdata.D"
  public static unsafe Vector<ulong> ConditionalExtractAfterLastActiveElement(Vector<ulong> mask, Vector<ulong> fallback, Vector<ulong> data);

    /// ConditionalExtractLastActiveElement : Conditionally extract last element

    /// svfloat32_t svclastb[_f32](svbool_t pg, svfloat32_t fallback, svfloat32_t data) : "CLASTB Ztied.S, Pg, Ztied.S, Zdata.S" or "MOVPRFX Zresult, Zfallback; CLASTB Zresult.S, Pg, Zresult.S, Zdata.S"
  public static unsafe Vector<float> ConditionalExtractLastActiveElement(Vector<float> mask, Vector<float> fallback, Vector<float> data);

    /// svfloat64_t svclastb[_f64](svbool_t pg, svfloat64_t fallback, svfloat64_t data) : "CLASTB Ztied.D, Pg, Ztied.D, Zdata.D" or "MOVPRFX Zresult, Zfallback; CLASTB Zresult.D, Pg, Zresult.D, Zdata.D"
  public static unsafe Vector<double> ConditionalExtractLastActiveElement(Vector<double> mask, Vector<double> fallback, Vector<double> data);

    /// svint8_t svclastb[_s8](svbool_t pg, svint8_t fallback, svint8_t data) : "CLASTB Ztied.B, Pg, Ztied.B, Zdata.B" or "MOVPRFX Zresult, Zfallback; CLASTB Zresult.B, Pg, Zresult.B, Zdata.B"
  public static unsafe Vector<sbyte> ConditionalExtractLastActiveElement(Vector<sbyte> mask, Vector<sbyte> fallback, Vector<sbyte> data);

    /// svint16_t svclastb[_s16](svbool_t pg, svint16_t fallback, svint16_t data) : "CLASTB Ztied.H, Pg, Ztied.H, Zdata.H" or "MOVPRFX Zresult, Zfallback; CLASTB Zresult.H, Pg, Zresult.H, Zdata.H"
  public static unsafe Vector<short> ConditionalExtractLastActiveElement(Vector<short> mask, Vector<short> fallback, Vector<short> data);

    /// svint32_t svclastb[_s32](svbool_t pg, svint32_t fallback, svint32_t data) : "CLASTB Ztied.S, Pg, Ztied.S, Zdata.S" or "MOVPRFX Zresult, Zfallback; CLASTB Zresult.S, Pg, Zresult.S, Zdata.S"
  public static unsafe Vector<int> ConditionalExtractLastActiveElement(Vector<int> mask, Vector<int> fallback, Vector<int> data);

    /// svint64_t svclastb[_s64](svbool_t pg, svint64_t fallback, svint64_t data) : "CLASTB Ztied.D, Pg, Ztied.D, Zdata.D" or "MOVPRFX Zresult, Zfallback; CLASTB Zresult.D, Pg, Zresult.D, Zdata.D"
  public static unsafe Vector<long> ConditionalExtractLastActiveElement(Vector<long> mask, Vector<long> fallback, Vector<long> data);

    /// svuint8_t svclastb[_u8](svbool_t pg, svuint8_t fallback, svuint8_t data) : "CLASTB Ztied.B, Pg, Ztied.B, Zdata.B" or "MOVPRFX Zresult, Zfallback; CLASTB Zresult.B, Pg, Zresult.B, Zdata.B"
  public static unsafe Vector<byte> ConditionalExtractLastActiveElement(Vector<byte> mask, Vector<byte> fallback, Vector<byte> data);

    /// svuint16_t svclastb[_u16](svbool_t pg, svuint16_t fallback, svuint16_t data) : "CLASTB Ztied.H, Pg, Ztied.H, Zdata.H" or "MOVPRFX Zresult, Zfallback; CLASTB Zresult.H, Pg, Zresult.H, Zdata.H"
  public static unsafe Vector<ushort> ConditionalExtractLastActiveElement(Vector<ushort> mask, Vector<ushort> fallback, Vector<ushort> data);

    /// svuint32_t svclastb[_u32](svbool_t pg, svuint32_t fallback, svuint32_t data) : "CLASTB Ztied.S, Pg, Ztied.S, Zdata.S" or "MOVPRFX Zresult, Zfallback; CLASTB Zresult.S, Pg, Zresult.S, Zdata.S"
  public static unsafe Vector<uint> ConditionalExtractLastActiveElement(Vector<uint> mask, Vector<uint> fallback, Vector<uint> data);

    /// svuint64_t svclastb[_u64](svbool_t pg, svuint64_t fallback, svuint64_t data) : "CLASTB Ztied.D, Pg, Ztied.D, Zdata.D" or "MOVPRFX Zresult, Zfallback; CLASTB Zresult.D, Pg, Zresult.D, Zdata.D"
  public static unsafe Vector<ulong> ConditionalExtractLastActiveElement(Vector<ulong> mask, Vector<ulong> fallback, Vector<ulong> data);

    /// ConditionalSelect : Conditionally select elements

    /// svfloat32_t svsel[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) : "SEL Zresult.S, Pg, Zop1.S, Zop2.S"
  public static unsafe Vector<float> ConditionalSelect(Vector<float> mask, Vector<float> left, Vector<float> right);

    /// svfloat64_t svsel[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) : "SEL Zresult.D, Pg, Zop1.D, Zop2.D"
  public static unsafe Vector<double> ConditionalSelect(Vector<double> mask, Vector<double> left, Vector<double> right);

    /// svint8_t svsel[_s8](svbool_t pg, svint8_t op1, svint8_t op2) : "SEL Zresult.B, Pg, Zop1.B, Zop2.B"
    /// svbool_t svsel[_b](svbool_t pg, svbool_t op1, svbool_t op2) : "SEL Presult.B, Pg, Pop1.B, Pop2.B"
  public static unsafe Vector<sbyte> ConditionalSelect(Vector<sbyte> mask, Vector<sbyte> left, Vector<sbyte> right);

    /// svint16_t svsel[_s16](svbool_t pg, svint16_t op1, svint16_t op2) : "SEL Zresult.H, Pg, Zop1.H, Zop2.H"
    /// svbool_t svsel[_b](svbool_t pg, svbool_t op1, svbool_t op2) : "SEL Presult.B, Pg, Pop1.B, Pop2.B"
  public static unsafe Vector<short> ConditionalSelect(Vector<short> mask, Vector<short> left, Vector<short> right);

    /// svint32_t svsel[_s32](svbool_t pg, svint32_t op1, svint32_t op2) : "SEL Zresult.S, Pg, Zop1.S, Zop2.S"
    /// svbool_t svsel[_b](svbool_t pg, svbool_t op1, svbool_t op2) : "SEL Presult.B, Pg, Pop1.B, Pop2.B"
  public static unsafe Vector<int> ConditionalSelect(Vector<int> mask, Vector<int> left, Vector<int> right);

    /// svint64_t svsel[_s64](svbool_t pg, svint64_t op1, svint64_t op2) : "SEL Zresult.D, Pg, Zop1.D, Zop2.D"
    /// svbool_t svsel[_b](svbool_t pg, svbool_t op1, svbool_t op2) : "SEL Presult.B, Pg, Pop1.B, Pop2.B"
  public static unsafe Vector<long> ConditionalSelect(Vector<long> mask, Vector<long> left, Vector<long> right);

    /// svuint8_t svsel[_u8](svbool_t pg, svuint8_t op1, svuint8_t op2) : "SEL Zresult.B, Pg, Zop1.B, Zop2.B"
    /// svbool_t svsel[_b](svbool_t pg, svbool_t op1, svbool_t op2) : "SEL Presult.B, Pg, Pop1.B, Pop2.B"
  public static unsafe Vector<byte> ConditionalSelect(Vector<byte> mask, Vector<byte> left, Vector<byte> right);

    /// svuint16_t svsel[_u16](svbool_t pg, svuint16_t op1, svuint16_t op2) : "SEL Zresult.H, Pg, Zop1.H, Zop2.H"
    /// svbool_t svsel[_b](svbool_t pg, svbool_t op1, svbool_t op2) : "SEL Presult.B, Pg, Pop1.B, Pop2.B"
  public static unsafe Vector<ushort> ConditionalSelect(Vector<ushort> mask, Vector<ushort> left, Vector<ushort> right);

    /// svuint32_t svsel[_u32](svbool_t pg, svuint32_t op1, svuint32_t op2) : "SEL Zresult.S, Pg, Zop1.S, Zop2.S"
    /// svbool_t svsel[_b](svbool_t pg, svbool_t op1, svbool_t op2) : "SEL Presult.B, Pg, Pop1.B, Pop2.B"
  public static unsafe Vector<uint> ConditionalSelect(Vector<uint> mask, Vector<uint> left, Vector<uint> right);

    /// svuint64_t svsel[_u64](svbool_t pg, svuint64_t op1, svuint64_t op2) : "SEL Zresult.D, Pg, Zop1.D, Zop2.D"
    /// svbool_t svsel[_b](svbool_t pg, svbool_t op1, svbool_t op2) : "SEL Presult.B, Pg, Pop1.B, Pop2.B"
  public static unsafe Vector<ulong> ConditionalSelect(Vector<ulong> mask, Vector<ulong> left, Vector<ulong> right);

    /// CreateBreakAfterMask : Break after first true condition

    /// svbool_t svbrka[_b]_m(svbool_t inactive, svbool_t pg, svbool_t op) : "BRKA Ptied.B, Pg/M, Pop.B"
    /// svbool_t svbrka[_b]_z(svbool_t pg, svbool_t op) : "BRKA Presult.B, Pg/Z, Pop.B"
  public static unsafe Vector<sbyte> CreateBreakAfterMask(Vector<sbyte> mask, Vector<sbyte> from);

    /// svbool_t svbrka[_b]_m(svbool_t inactive, svbool_t pg, svbool_t op) : "BRKA Ptied.B, Pg/M, Pop.B"
    /// svbool_t svbrka[_b]_z(svbool_t pg, svbool_t op) : "BRKA Presult.B, Pg/Z, Pop.B"
  public static unsafe Vector<short> CreateBreakAfterMask(Vector<short> mask, Vector<short> from);

    /// svbool_t svbrka[_b]_m(svbool_t inactive, svbool_t pg, svbool_t op) : "BRKA Ptied.B, Pg/M, Pop.B"
    /// svbool_t svbrka[_b]_z(svbool_t pg, svbool_t op) : "BRKA Presult.B, Pg/Z, Pop.B"
  public static unsafe Vector<int> CreateBreakAfterMask(Vector<int> mask, Vector<int> from);

    /// svbool_t svbrka[_b]_m(svbool_t inactive, svbool_t pg, svbool_t op) : "BRKA Ptied.B, Pg/M, Pop.B"
    /// svbool_t svbrka[_b]_z(svbool_t pg, svbool_t op) : "BRKA Presult.B, Pg/Z, Pop.B"
  public static unsafe Vector<long> CreateBreakAfterMask(Vector<long> mask, Vector<long> from);

    /// svbool_t svbrka[_b]_m(svbool_t inactive, svbool_t pg, svbool_t op) : "BRKA Ptied.B, Pg/M, Pop.B"
    /// svbool_t svbrka[_b]_z(svbool_t pg, svbool_t op) : "BRKA Presult.B, Pg/Z, Pop.B"
  public static unsafe Vector<byte> CreateBreakAfterMask(Vector<byte> mask, Vector<byte> from);

    /// svbool_t svbrka[_b]_m(svbool_t inactive, svbool_t pg, svbool_t op) : "BRKA Ptied.B, Pg/M, Pop.B"
    /// svbool_t svbrka[_b]_z(svbool_t pg, svbool_t op) : "BRKA Presult.B, Pg/Z, Pop.B"
  public static unsafe Vector<ushort> CreateBreakAfterMask(Vector<ushort> mask, Vector<ushort> from);

    /// svbool_t svbrka[_b]_m(svbool_t inactive, svbool_t pg, svbool_t op) : "BRKA Ptied.B, Pg/M, Pop.B"
    /// svbool_t svbrka[_b]_z(svbool_t pg, svbool_t op) : "BRKA Presult.B, Pg/Z, Pop.B"
  public static unsafe Vector<uint> CreateBreakAfterMask(Vector<uint> mask, Vector<uint> from);

    /// svbool_t svbrka[_b]_m(svbool_t inactive, svbool_t pg, svbool_t op) : "BRKA Ptied.B, Pg/M, Pop.B"
    /// svbool_t svbrka[_b]_z(svbool_t pg, svbool_t op) : "BRKA Presult.B, Pg/Z, Pop.B"
  public static unsafe Vector<ulong> CreateBreakAfterMask(Vector<ulong> mask, Vector<ulong> from);

    /// CreateBreakAfterPropagateMask : Break after first true condition, propagating from previous partition

    /// svbool_t svbrkpa[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKPA Presult.B, Pg/Z, Pop1.B, Pop2.B"
  public static unsafe Vector<sbyte> CreateBreakAfterPropagateMask(Vector<sbyte> mask, Vector<sbyte> left, Vector<sbyte> right);

    /// svbool_t svbrkpa[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKPA Presult.B, Pg/Z, Pop1.B, Pop2.B"
  public static unsafe Vector<short> CreateBreakAfterPropagateMask(Vector<short> mask, Vector<short> left, Vector<short> right);

    /// svbool_t svbrkpa[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKPA Presult.B, Pg/Z, Pop1.B, Pop2.B"
  public static unsafe Vector<int> CreateBreakAfterPropagateMask(Vector<int> mask, Vector<int> left, Vector<int> right);

    /// svbool_t svbrkpa[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKPA Presult.B, Pg/Z, Pop1.B, Pop2.B"
  public static unsafe Vector<long> CreateBreakAfterPropagateMask(Vector<long> mask, Vector<long> left, Vector<long> right);

    /// svbool_t svbrkpa[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKPA Presult.B, Pg/Z, Pop1.B, Pop2.B"
  public static unsafe Vector<byte> CreateBreakAfterPropagateMask(Vector<byte> mask, Vector<byte> left, Vector<byte> right);

    /// svbool_t svbrkpa[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKPA Presult.B, Pg/Z, Pop1.B, Pop2.B"
  public static unsafe Vector<ushort> CreateBreakAfterPropagateMask(Vector<ushort> mask, Vector<ushort> left, Vector<ushort> right);

    /// svbool_t svbrkpa[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKPA Presult.B, Pg/Z, Pop1.B, Pop2.B"
  public static unsafe Vector<uint> CreateBreakAfterPropagateMask(Vector<uint> mask, Vector<uint> left, Vector<uint> right);

    /// svbool_t svbrkpa[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKPA Presult.B, Pg/Z, Pop1.B, Pop2.B"
  public static unsafe Vector<ulong> CreateBreakAfterPropagateMask(Vector<ulong> mask, Vector<ulong> left, Vector<ulong> right);

    /// CreateBreakBeforeMask : Break before first true condition

    /// svbool_t svbrkb[_b]_m(svbool_t inactive, svbool_t pg, svbool_t op) : "BRKB Ptied.B, Pg/M, Pop.B"
    /// svbool_t svbrkb[_b]_z(svbool_t pg, svbool_t op) : "BRKB Presult.B, Pg/Z, Pop.B"
  public static unsafe Vector<sbyte> CreateBreakBeforeMask(Vector<sbyte> mask, Vector<sbyte> from);

    /// svbool_t svbrkb[_b]_m(svbool_t inactive, svbool_t pg, svbool_t op) : "BRKB Ptied.B, Pg/M, Pop.B"
    /// svbool_t svbrkb[_b]_z(svbool_t pg, svbool_t op) : "BRKB Presult.B, Pg/Z, Pop.B"
  public static unsafe Vector<short> CreateBreakBeforeMask(Vector<short> mask, Vector<short> from);

    /// svbool_t svbrkb[_b]_m(svbool_t inactive, svbool_t pg, svbool_t op) : "BRKB Ptied.B, Pg/M, Pop.B"
    /// svbool_t svbrkb[_b]_z(svbool_t pg, svbool_t op) : "BRKB Presult.B, Pg/Z, Pop.B"
  public static unsafe Vector<int> CreateBreakBeforeMask(Vector<int> mask, Vector<int> from);

    /// svbool_t svbrkb[_b]_m(svbool_t inactive, svbool_t pg, svbool_t op) : "BRKB Ptied.B, Pg/M, Pop.B"
    /// svbool_t svbrkb[_b]_z(svbool_t pg, svbool_t op) : "BRKB Presult.B, Pg/Z, Pop.B"
  public static unsafe Vector<long> CreateBreakBeforeMask(Vector<long> mask, Vector<long> from);

    /// svbool_t svbrkb[_b]_m(svbool_t inactive, svbool_t pg, svbool_t op) : "BRKB Ptied.B, Pg/M, Pop.B"
    /// svbool_t svbrkb[_b]_z(svbool_t pg, svbool_t op) : "BRKB Presult.B, Pg/Z, Pop.B"
  public static unsafe Vector<byte> CreateBreakBeforeMask(Vector<byte> mask, Vector<byte> from);

    /// svbool_t svbrkb[_b]_m(svbool_t inactive, svbool_t pg, svbool_t op) : "BRKB Ptied.B, Pg/M, Pop.B"
    /// svbool_t svbrkb[_b]_z(svbool_t pg, svbool_t op) : "BRKB Presult.B, Pg/Z, Pop.B"
  public static unsafe Vector<ushort> CreateBreakBeforeMask(Vector<ushort> mask, Vector<ushort> from);

    /// svbool_t svbrkb[_b]_m(svbool_t inactive, svbool_t pg, svbool_t op) : "BRKB Ptied.B, Pg/M, Pop.B"
    /// svbool_t svbrkb[_b]_z(svbool_t pg, svbool_t op) : "BRKB Presult.B, Pg/Z, Pop.B"
  public static unsafe Vector<uint> CreateBreakBeforeMask(Vector<uint> mask, Vector<uint> from);

    /// svbool_t svbrkb[_b]_m(svbool_t inactive, svbool_t pg, svbool_t op) : "BRKB Ptied.B, Pg/M, Pop.B"
    /// svbool_t svbrkb[_b]_z(svbool_t pg, svbool_t op) : "BRKB Presult.B, Pg/Z, Pop.B"
  public static unsafe Vector<ulong> CreateBreakBeforeMask(Vector<ulong> mask, Vector<ulong> from);

    /// CreateBreakBeforePropagateMask : Break before first true condition, propagating from previous partition

    /// svbool_t svbrkpb[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKPB Presult.B, Pg/Z, Pop1.B, Pop2.B"
  public static unsafe Vector<sbyte> CreateBreakBeforePropagateMask(Vector<sbyte> mask, Vector<sbyte> left, Vector<sbyte> right);

    /// svbool_t svbrkpb[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKPB Presult.B, Pg/Z, Pop1.B, Pop2.B"
  public static unsafe Vector<short> CreateBreakBeforePropagateMask(Vector<short> mask, Vector<short> left, Vector<short> right);

    /// svbool_t svbrkpb[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKPB Presult.B, Pg/Z, Pop1.B, Pop2.B"
  public static unsafe Vector<int> CreateBreakBeforePropagateMask(Vector<int> mask, Vector<int> left, Vector<int> right);

    /// svbool_t svbrkpb[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKPB Presult.B, Pg/Z, Pop1.B, Pop2.B"
  public static unsafe Vector<long> CreateBreakBeforePropagateMask(Vector<long> mask, Vector<long> left, Vector<long> right);

    /// svbool_t svbrkpb[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKPB Presult.B, Pg/Z, Pop1.B, Pop2.B"
  public static unsafe Vector<byte> CreateBreakBeforePropagateMask(Vector<byte> mask, Vector<byte> left, Vector<byte> right);

    /// svbool_t svbrkpb[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKPB Presult.B, Pg/Z, Pop1.B, Pop2.B"
  public static unsafe Vector<ushort> CreateBreakBeforePropagateMask(Vector<ushort> mask, Vector<ushort> left, Vector<ushort> right);

    /// svbool_t svbrkpb[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKPB Presult.B, Pg/Z, Pop1.B, Pop2.B"
  public static unsafe Vector<uint> CreateBreakBeforePropagateMask(Vector<uint> mask, Vector<uint> left, Vector<uint> right);

    /// svbool_t svbrkpb[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKPB Presult.B, Pg/Z, Pop1.B, Pop2.B"
  public static unsafe Vector<ulong> CreateBreakBeforePropagateMask(Vector<ulong> mask, Vector<ulong> left, Vector<ulong> right);

    /// CreateWhileLessThanMask : While incrementing scalar is less than

    /// svbool_t svwhilelt_b8[_s32](int32_t op1, int32_t op2) : "WHILELT Presult.B, Wop1, Wop2"
  public static unsafe Vector<byte> CreateWhileLessThanMask(int left, int right);

    /// svbool_t svwhilelt_b8[_s64](int64_t op1, int64_t op2) : "WHILELT Presult.B, Xop1, Xop2"
  public static unsafe Vector<byte> CreateWhileLessThanMask(long left, long right);

    /// svbool_t svwhilelt_b8[_u32](uint32_t op1, uint32_t op2) : "WHILELO Presult.B, Wop1, Wop2"
  public static unsafe Vector<byte> CreateWhileLessThanMask(uint left, uint right);

    /// svbool_t svwhilelt_b8[_u64](uint64_t op1, uint64_t op2) : "WHILELO Presult.B, Xop1, Xop2"
  public static unsafe Vector<byte> CreateWhileLessThanMask(ulong left, ulong right);

    /// svbool_t svwhilelt_b16[_s32](int32_t op1, int32_t op2) : "WHILELT Presult.H, Wop1, Wop2"
  public static unsafe Vector<ushort> CreateWhileLessThanMask(int left, int right);

    /// svbool_t svwhilelt_b16[_s64](int64_t op1, int64_t op2) : "WHILELT Presult.H, Xop1, Xop2"
  public static unsafe Vector<ushort> CreateWhileLessThanMask(long left, long right);

    /// svbool_t svwhilelt_b16[_u32](uint32_t op1, uint32_t op2) : "WHILELO Presult.H, Wop1, Wop2"
  public static unsafe Vector<ushort> CreateWhileLessThanMask(uint left, uint right);

    /// svbool_t svwhilelt_b16[_u64](uint64_t op1, uint64_t op2) : "WHILELO Presult.H, Xop1, Xop2"
  public static unsafe Vector<ushort> CreateWhileLessThanMask(ulong left, ulong right);

    /// svbool_t svwhilelt_b32[_s32](int32_t op1, int32_t op2) : "WHILELT Presult.S, Wop1, Wop2"
  public static unsafe Vector<uint> CreateWhileLessThanMask(int left, int right);

    /// svbool_t svwhilelt_b32[_s64](int64_t op1, int64_t op2) : "WHILELT Presult.S, Xop1, Xop2"
  public static unsafe Vector<uint> CreateWhileLessThanMask(long left, long right);

    /// svbool_t svwhilelt_b32[_u32](uint32_t op1, uint32_t op2) : "WHILELO Presult.S, Wop1, Wop2"
  public static unsafe Vector<uint> CreateWhileLessThanMask(uint left, uint right);

    /// svbool_t svwhilelt_b32[_u64](uint64_t op1, uint64_t op2) : "WHILELO Presult.S, Xop1, Xop2"
  public static unsafe Vector<uint> CreateWhileLessThanMask(ulong left, ulong right);

    /// svbool_t svwhilelt_b64[_s32](int32_t op1, int32_t op2) : "WHILELT Presult.D, Wop1, Wop2"
  public static unsafe Vector<ulong> CreateWhileLessThanMask(int left, int right);

    /// svbool_t svwhilelt_b64[_s64](int64_t op1, int64_t op2) : "WHILELT Presult.D, Xop1, Xop2"
  public static unsafe Vector<ulong> CreateWhileLessThanMask(long left, long right);

    /// svbool_t svwhilelt_b64[_u32](uint32_t op1, uint32_t op2) : "WHILELO Presult.D, Wop1, Wop2"
  public static unsafe Vector<ulong> CreateWhileLessThanMask(uint left, uint right);

    /// svbool_t svwhilelt_b64[_u64](uint64_t op1, uint64_t op2) : "WHILELO Presult.D, Xop1, Xop2"
  public static unsafe Vector<ulong> CreateWhileLessThanMask(ulong left, ulong right);

    /// CreateWhileLessThanOrEqualMask : While incrementing scalar is less than or equal to

    /// svbool_t svwhilele_b8[_s32](int32_t op1, int32_t op2) : "WHILELE Presult.B, Wop1, Wop2"
  public static unsafe Vector<byte> CreateWhileLessThanOrEqualMask(int left, int right);

    /// svbool_t svwhilele_b8[_s64](int64_t op1, int64_t op2) : "WHILELE Presult.B, Xop1, Xop2"
  public static unsafe Vector<byte> CreateWhileLessThanOrEqualMask(long left, long right);

    /// svbool_t svwhilele_b8[_u32](uint32_t op1, uint32_t op2) : "WHILELS Presult.B, Wop1, Wop2"
  public static unsafe Vector<byte> CreateWhileLessThanOrEqualMask(uint left, uint right);

    /// svbool_t svwhilele_b8[_u64](uint64_t op1, uint64_t op2) : "WHILELS Presult.B, Xop1, Xop2"
  public static unsafe Vector<byte> CreateWhileLessThanOrEqualMask(ulong left, ulong right);

    /// svbool_t svwhilele_b16[_s32](int32_t op1, int32_t op2) : "WHILELE Presult.H, Wop1, Wop2"
  public static unsafe Vector<ushort> CreateWhileLessThanOrEqualMask(int left, int right);

    /// svbool_t svwhilele_b16[_s64](int64_t op1, int64_t op2) : "WHILELE Presult.H, Xop1, Xop2"
  public static unsafe Vector<ushort> CreateWhileLessThanOrEqualMask(long left, long right);

    /// svbool_t svwhilele_b16[_u32](uint32_t op1, uint32_t op2) : "WHILELS Presult.H, Wop1, Wop2"
  public static unsafe Vector<ushort> CreateWhileLessThanOrEqualMask(uint left, uint right);

    /// svbool_t svwhilele_b16[_u64](uint64_t op1, uint64_t op2) : "WHILELS Presult.H, Xop1, Xop2"
  public static unsafe Vector<ushort> CreateWhileLessThanOrEqualMask(ulong left, ulong right);

    /// svbool_t svwhilele_b32[_s32](int32_t op1, int32_t op2) : "WHILELE Presult.S, Wop1, Wop2"
  public static unsafe Vector<uint> CreateWhileLessThanOrEqualMask(int left, int right);

    /// svbool_t svwhilele_b32[_s64](int64_t op1, int64_t op2) : "WHILELE Presult.S, Xop1, Xop2"
  public static unsafe Vector<uint> CreateWhileLessThanOrEqualMask(long left, long right);

    /// svbool_t svwhilele_b32[_u32](uint32_t op1, uint32_t op2) : "WHILELS Presult.S, Wop1, Wop2"
  public static unsafe Vector<uint> CreateWhileLessThanOrEqualMask(uint left, uint right);

    /// svbool_t svwhilele_b32[_u64](uint64_t op1, uint64_t op2) : "WHILELS Presult.S, Xop1, Xop2"
  public static unsafe Vector<uint> CreateWhileLessThanOrEqualMask(ulong left, ulong right);

    /// svbool_t svwhilele_b64[_s32](int32_t op1, int32_t op2) : "WHILELE Presult.D, Wop1, Wop2"
  public static unsafe Vector<ulong> CreateWhileLessThanOrEqualMask(int left, int right);

    /// svbool_t svwhilele_b64[_s64](int64_t op1, int64_t op2) : "WHILELE Presult.D, Xop1, Xop2"
  public static unsafe Vector<ulong> CreateWhileLessThanOrEqualMask(long left, long right);

    /// svbool_t svwhilele_b64[_u32](uint32_t op1, uint32_t op2) : "WHILELS Presult.D, Wop1, Wop2"
  public static unsafe Vector<ulong> CreateWhileLessThanOrEqualMask(uint left, uint right);

    /// svbool_t svwhilele_b64[_u64](uint64_t op1, uint64_t op2) : "WHILELS Presult.D, Xop1, Xop2"
  public static unsafe Vector<ulong> CreateWhileLessThanOrEqualMask(ulong left, ulong right);

    /// ExtractAfterLast : Extract element after last

    /// float32_t svlasta[_f32](svbool_t pg, svfloat32_t op) : "LASTA Wresult, Pg, Zop.S" or "LASTA Sresult, Pg, Zop.S"
  public static unsafe float ExtractAfterLast(Vector<float> value);

    /// float64_t svlasta[_f64](svbool_t pg, svfloat64_t op) : "LASTA Xresult, Pg, Zop.D" or "LASTA Dresult, Pg, Zop.D"
  public static unsafe double ExtractAfterLast(Vector<double> value);

    /// int8_t svlasta[_s8](svbool_t pg, svint8_t op) : "LASTA Wresult, Pg, Zop.B" or "LASTA Bresult, Pg, Zop.B"
  public static unsafe sbyte ExtractAfterLast(Vector<sbyte> value);

    /// int16_t svlasta[_s16](svbool_t pg, svint16_t op) : "LASTA Wresult, Pg, Zop.H" or "LASTA Hresult, Pg, Zop.H"
  public static unsafe short ExtractAfterLast(Vector<short> value);

    /// int32_t svlasta[_s32](svbool_t pg, svint32_t op) : "LASTA Wresult, Pg, Zop.S" or "LASTA Sresult, Pg, Zop.S"
  public static unsafe int ExtractAfterLast(Vector<int> value);

    /// int64_t svlasta[_s64](svbool_t pg, svint64_t op) : "LASTA Xresult, Pg, Zop.D" or "LASTA Dresult, Pg, Zop.D"
  public static unsafe long ExtractAfterLast(Vector<long> value);

    /// uint8_t svlasta[_u8](svbool_t pg, svuint8_t op) : "LASTA Wresult, Pg, Zop.B" or "LASTA Bresult, Pg, Zop.B"
  public static unsafe byte ExtractAfterLast(Vector<byte> value);

    /// uint16_t svlasta[_u16](svbool_t pg, svuint16_t op) : "LASTA Wresult, Pg, Zop.H" or "LASTA Hresult, Pg, Zop.H"
  public static unsafe ushort ExtractAfterLast(Vector<ushort> value);

    /// uint32_t svlasta[_u32](svbool_t pg, svuint32_t op) : "LASTA Wresult, Pg, Zop.S" or "LASTA Sresult, Pg, Zop.S"
  public static unsafe uint ExtractAfterLast(Vector<uint> value);

    /// uint64_t svlasta[_u64](svbool_t pg, svuint64_t op) : "LASTA Xresult, Pg, Zop.D" or "LASTA Dresult, Pg, Zop.D"
  public static unsafe ulong ExtractAfterLast(Vector<ulong> value);

    /// ExtractLast : Extract last element

    /// float32_t svlastb[_f32](svbool_t pg, svfloat32_t op) : "LASTB Wresult, Pg, Zop.S" or "LASTB Sresult, Pg, Zop.S"
  public static unsafe float ExtractLast(Vector<float> value);

    /// float64_t svlastb[_f64](svbool_t pg, svfloat64_t op) : "LASTB Xresult, Pg, Zop.D" or "LASTB Dresult, Pg, Zop.D"
  public static unsafe double ExtractLast(Vector<double> value);

    /// int8_t svlastb[_s8](svbool_t pg, svint8_t op) : "LASTB Wresult, Pg, Zop.B" or "LASTB Bresult, Pg, Zop.B"
  public static unsafe sbyte ExtractLast(Vector<sbyte> value);

    /// int16_t svlastb[_s16](svbool_t pg, svint16_t op) : "LASTB Wresult, Pg, Zop.H" or "LASTB Hresult, Pg, Zop.H"
  public static unsafe short ExtractLast(Vector<short> value);

    /// int32_t svlastb[_s32](svbool_t pg, svint32_t op) : "LASTB Wresult, Pg, Zop.S" or "LASTB Sresult, Pg, Zop.S"
  public static unsafe int ExtractLast(Vector<int> value);

    /// int64_t svlastb[_s64](svbool_t pg, svint64_t op) : "LASTB Xresult, Pg, Zop.D" or "LASTB Dresult, Pg, Zop.D"
  public static unsafe long ExtractLast(Vector<long> value);

    /// uint8_t svlastb[_u8](svbool_t pg, svuint8_t op) : "LASTB Wresult, Pg, Zop.B" or "LASTB Bresult, Pg, Zop.B"
  public static unsafe byte ExtractLast(Vector<byte> value);

    /// uint16_t svlastb[_u16](svbool_t pg, svuint16_t op) : "LASTB Wresult, Pg, Zop.H" or "LASTB Hresult, Pg, Zop.H"
  public static unsafe ushort ExtractLast(Vector<ushort> value);

    /// uint32_t svlastb[_u32](svbool_t pg, svuint32_t op) : "LASTB Wresult, Pg, Zop.S" or "LASTB Sresult, Pg, Zop.S"
  public static unsafe uint ExtractLast(Vector<uint> value);

    /// uint64_t svlastb[_u64](svbool_t pg, svuint64_t op) : "LASTB Xresult, Pg, Zop.D" or "LASTB Dresult, Pg, Zop.D"
  public static unsafe ulong ExtractLast(Vector<ulong> value);

    /// ExtractVector : Extract vector from pair of vectors

    /// svfloat32_t svext[_f32](svfloat32_t op1, svfloat32_t op2, uint64_t imm3) : "EXT Ztied1.B, Ztied1.B, Zop2.B, #imm3 * 4" or "MOVPRFX Zresult, Zop1; EXT Zresult.B, Zresult.B, Zop2.B, #imm3 * 4"
  public static unsafe Vector<float> ExtractVector(Vector<float> upper, Vector<float> lower, ulong index);

    /// svfloat64_t svext[_f64](svfloat64_t op1, svfloat64_t op2, uint64_t imm3) : "EXT Ztied1.B, Ztied1.B, Zop2.B, #imm3 * 8" or "MOVPRFX Zresult, Zop1; EXT Zresult.B, Zresult.B, Zop2.B, #imm3 * 8"
  public static unsafe Vector<double> ExtractVector(Vector<double> upper, Vector<double> lower, ulong index);

    /// svint8_t svext[_s8](svint8_t op1, svint8_t op2, uint64_t imm3) : "EXT Ztied1.B, Ztied1.B, Zop2.B, #imm3" or "MOVPRFX Zresult, Zop1; EXT Zresult.B, Zresult.B, Zop2.B, #imm3"
  public static unsafe Vector<sbyte> ExtractVector(Vector<sbyte> upper, Vector<sbyte> lower, ulong index);

    /// svint16_t svext[_s16](svint16_t op1, svint16_t op2, uint64_t imm3) : "EXT Ztied1.B, Ztied1.B, Zop2.B, #imm3 * 2" or "MOVPRFX Zresult, Zop1; EXT Zresult.B, Zresult.B, Zop2.B, #imm3 * 2"
  public static unsafe Vector<short> ExtractVector(Vector<short> upper, Vector<short> lower, ulong index);

    /// svint32_t svext[_s32](svint32_t op1, svint32_t op2, uint64_t imm3) : "EXT Ztied1.B, Ztied1.B, Zop2.B, #imm3 * 4" or "MOVPRFX Zresult, Zop1; EXT Zresult.B, Zresult.B, Zop2.B, #imm3 * 4"
  public static unsafe Vector<int> ExtractVector(Vector<int> upper, Vector<int> lower, ulong index);

    /// svint64_t svext[_s64](svint64_t op1, svint64_t op2, uint64_t imm3) : "EXT Ztied1.B, Ztied1.B, Zop2.B, #imm3 * 8" or "MOVPRFX Zresult, Zop1; EXT Zresult.B, Zresult.B, Zop2.B, #imm3 * 8"
  public static unsafe Vector<long> ExtractVector(Vector<long> upper, Vector<long> lower, ulong index);

    /// svuint8_t svext[_u8](svuint8_t op1, svuint8_t op2, uint64_t imm3) : "EXT Ztied1.B, Ztied1.B, Zop2.B, #imm3" or "MOVPRFX Zresult, Zop1; EXT Zresult.B, Zresult.B, Zop2.B, #imm3"
  public static unsafe Vector<byte> ExtractVector(Vector<byte> upper, Vector<byte> lower, ulong index);

    /// svuint16_t svext[_u16](svuint16_t op1, svuint16_t op2, uint64_t imm3) : "EXT Ztied1.B, Ztied1.B, Zop2.B, #imm3 * 2" or "MOVPRFX Zresult, Zop1; EXT Zresult.B, Zresult.B, Zop2.B, #imm3 * 2"
  public static unsafe Vector<ushort> ExtractVector(Vector<ushort> upper, Vector<ushort> lower, ulong index);

    /// svuint32_t svext[_u32](svuint32_t op1, svuint32_t op2, uint64_t imm3) : "EXT Ztied1.B, Ztied1.B, Zop2.B, #imm3 * 4" or "MOVPRFX Zresult, Zop1; EXT Zresult.B, Zresult.B, Zop2.B, #imm3 * 4"
  public static unsafe Vector<uint> ExtractVector(Vector<uint> upper, Vector<uint> lower, ulong index);

    /// svuint64_t svext[_u64](svuint64_t op1, svuint64_t op2, uint64_t imm3) : "EXT Ztied1.B, Ztied1.B, Zop2.B, #imm3 * 8" or "MOVPRFX Zresult, Zop1; EXT Zresult.B, Zresult.B, Zop2.B, #imm3 * 8"
  public static unsafe Vector<ulong> ExtractVector(Vector<ulong> upper, Vector<ulong> lower, ulong index);

    /// FalseMask : Set all predicate elements to false

    /// svbool_t svpfalse[_b]() : "PFALSE Presult.B"
  public static unsafe Vector<byte> FalseMask();

    /// MaskGetFirstSet : Find next active predicate

    /// svbool_t svpnext_b8(svbool_t pg, svbool_t op) : "PNEXT Ptied.B, Pg, Ptied.B"
  public static unsafe Vector<byte> MaskGetFirstSet(Vector<byte> mask, Vector<byte> from);

    /// svbool_t svpnext_b16(svbool_t pg, svbool_t op) : "PNEXT Ptied.H, Pg, Ptied.H"
  public static unsafe Vector<ushort> MaskGetFirstSet(Vector<ushort> mask, Vector<ushort> from);

    /// svbool_t svpnext_b32(svbool_t pg, svbool_t op) : "PNEXT Ptied.S, Pg, Ptied.S"
  public static unsafe Vector<uint> MaskGetFirstSet(Vector<uint> mask, Vector<uint> from);

    /// svbool_t svpnext_b64(svbool_t pg, svbool_t op) : "PNEXT Ptied.D, Pg, Ptied.D"
  public static unsafe Vector<ulong> MaskGetFirstSet(Vector<ulong> mask, Vector<ulong> from);

    /// MaskSetFirst : Set the first active predicate element to true

    /// svbool_t svpfirst[_b](svbool_t pg, svbool_t op) : "PFIRST Ptied.B, Pg, Ptied.B"
  public static unsafe Vector<sbyte> MaskSetFirst(Vector<sbyte> mask, Vector<sbyte> from);

    /// svbool_t svpfirst[_b](svbool_t pg, svbool_t op) : "PFIRST Ptied.B, Pg, Ptied.B"
  public static unsafe Vector<short> MaskSetFirst(Vector<short> mask, Vector<short> from);

    /// svbool_t svpfirst[_b](svbool_t pg, svbool_t op) : "PFIRST Ptied.B, Pg, Ptied.B"
  public static unsafe Vector<int> MaskSetFirst(Vector<int> mask, Vector<int> from);

    /// svbool_t svpfirst[_b](svbool_t pg, svbool_t op) : "PFIRST Ptied.B, Pg, Ptied.B"
  public static unsafe Vector<long> MaskSetFirst(Vector<long> mask, Vector<long> from);

    /// svbool_t svpfirst[_b](svbool_t pg, svbool_t op) : "PFIRST Ptied.B, Pg, Ptied.B"
  public static unsafe Vector<byte> MaskSetFirst(Vector<byte> mask, Vector<byte> from);

    /// svbool_t svpfirst[_b](svbool_t pg, svbool_t op) : "PFIRST Ptied.B, Pg, Ptied.B"
  public static unsafe Vector<ushort> MaskSetFirst(Vector<ushort> mask, Vector<ushort> from);

    /// svbool_t svpfirst[_b](svbool_t pg, svbool_t op) : "PFIRST Ptied.B, Pg, Ptied.B"
  public static unsafe Vector<uint> MaskSetFirst(Vector<uint> mask, Vector<uint> from);

    /// svbool_t svpfirst[_b](svbool_t pg, svbool_t op) : "PFIRST Ptied.B, Pg, Ptied.B"
  public static unsafe Vector<ulong> MaskSetFirst(Vector<ulong> mask, Vector<ulong> from);

    /// MaskTestAnyTrue : Test whether any active element is true

    /// bool svptest_any(svbool_t pg, svbool_t op) : PTEST
  public static unsafe bool MaskTestAnyTrue(Vector<sbyte> mask, Vector<sbyte> from);

    /// bool svptest_any(svbool_t pg, svbool_t op) : PTEST
  public static unsafe bool MaskTestAnyTrue(Vector<short> mask, Vector<short> from);

    /// bool svptest_any(svbool_t pg, svbool_t op) : PTEST
  public static unsafe bool MaskTestAnyTrue(Vector<int> mask, Vector<int> from);

    /// bool svptest_any(svbool_t pg, svbool_t op) : PTEST
  public static unsafe bool MaskTestAnyTrue(Vector<long> mask, Vector<long> from);

    /// bool svptest_any(svbool_t pg, svbool_t op) : PTEST
  public static unsafe bool MaskTestAnyTrue(Vector<byte> mask, Vector<byte> from);

    /// bool svptest_any(svbool_t pg, svbool_t op) : PTEST
  public static unsafe bool MaskTestAnyTrue(Vector<ushort> mask, Vector<ushort> from);

    /// bool svptest_any(svbool_t pg, svbool_t op) : PTEST
  public static unsafe bool MaskTestAnyTrue(Vector<uint> mask, Vector<uint> from);

    /// bool svptest_any(svbool_t pg, svbool_t op) : PTEST
  public static unsafe bool MaskTestAnyTrue(Vector<ulong> mask, Vector<ulong> from);

    /// MaskTestFirstTrue : Test whether the first active element is true

    /// bool svptest_first(svbool_t pg, svbool_t op) : PTEST
  public static unsafe bool MaskTestFirstTrue(Vector<sbyte> mask, Vector<sbyte> from);

    /// bool svptest_first(svbool_t pg, svbool_t op) : PTEST
  public static unsafe bool MaskTestFirstTrue(Vector<short> mask, Vector<short> from);

    /// bool svptest_first(svbool_t pg, svbool_t op) : PTEST
  public static unsafe bool MaskTestFirstTrue(Vector<int> mask, Vector<int> from);

    /// bool svptest_first(svbool_t pg, svbool_t op) : PTEST
  public static unsafe bool MaskTestFirstTrue(Vector<long> mask, Vector<long> from);

    /// bool svptest_first(svbool_t pg, svbool_t op) : PTEST
  public static unsafe bool MaskTestFirstTrue(Vector<byte> mask, Vector<byte> from);

    /// bool svptest_first(svbool_t pg, svbool_t op) : PTEST
  public static unsafe bool MaskTestFirstTrue(Vector<ushort> mask, Vector<ushort> from);

    /// bool svptest_first(svbool_t pg, svbool_t op) : PTEST
  public static unsafe bool MaskTestFirstTrue(Vector<uint> mask, Vector<uint> from);

    /// bool svptest_first(svbool_t pg, svbool_t op) : PTEST
  public static unsafe bool MaskTestFirstTrue(Vector<ulong> mask, Vector<ulong> from);

    /// MaskTestLastTrue : Test whether the last active element is true

    /// bool svptest_last(svbool_t pg, svbool_t op) : PTEST
  public static unsafe bool MaskTestLastTrue(Vector<sbyte> mask, Vector<sbyte> from);

    /// bool svptest_last(svbool_t pg, svbool_t op) : PTEST
  public static unsafe bool MaskTestLastTrue(Vector<short> mask, Vector<short> from);

    /// bool svptest_last(svbool_t pg, svbool_t op) : PTEST
  public static unsafe bool MaskTestLastTrue(Vector<int> mask, Vector<int> from);

    /// bool svptest_last(svbool_t pg, svbool_t op) : PTEST
  public static unsafe bool MaskTestLastTrue(Vector<long> mask, Vector<long> from);

    /// bool svptest_last(svbool_t pg, svbool_t op) : PTEST
  public static unsafe bool MaskTestLastTrue(Vector<byte> mask, Vector<byte> from);

    /// bool svptest_last(svbool_t pg, svbool_t op) : PTEST
  public static unsafe bool MaskTestLastTrue(Vector<ushort> mask, Vector<ushort> from);

    /// bool svptest_last(svbool_t pg, svbool_t op) : PTEST
  public static unsafe bool MaskTestLastTrue(Vector<uint> mask, Vector<uint> from);

    /// bool svptest_last(svbool_t pg, svbool_t op) : PTEST
  public static unsafe bool MaskTestLastTrue(Vector<ulong> mask, Vector<ulong> from);

    /// PropagateBreak : Propagate break to next partition

    /// svbool_t svbrkn[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKN Ptied2.B, Pg/Z, Pop1.B, Ptied2.B"
  public static unsafe Vector<sbyte> PropagateBreak(Vector<sbyte> left, Vector<sbyte> right);

    /// svbool_t svbrkn[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKN Ptied2.B, Pg/Z, Pop1.B, Ptied2.B"
  public static unsafe Vector<short> PropagateBreak(Vector<short> left, Vector<short> right);

    /// svbool_t svbrkn[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKN Ptied2.B, Pg/Z, Pop1.B, Ptied2.B"
  public static unsafe Vector<int> PropagateBreak(Vector<int> left, Vector<int> right);

    /// svbool_t svbrkn[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKN Ptied2.B, Pg/Z, Pop1.B, Ptied2.B"
  public static unsafe Vector<long> PropagateBreak(Vector<long> left, Vector<long> right);

    /// svbool_t svbrkn[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKN Ptied2.B, Pg/Z, Pop1.B, Ptied2.B"
  public static unsafe Vector<byte> PropagateBreak(Vector<byte> left, Vector<byte> right);

    /// svbool_t svbrkn[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKN Ptied2.B, Pg/Z, Pop1.B, Ptied2.B"
  public static unsafe Vector<ushort> PropagateBreak(Vector<ushort> left, Vector<ushort> right);

    /// svbool_t svbrkn[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKN Ptied2.B, Pg/Z, Pop1.B, Ptied2.B"
  public static unsafe Vector<uint> PropagateBreak(Vector<uint> left, Vector<uint> right);

    /// svbool_t svbrkn[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKN Ptied2.B, Pg/Z, Pop1.B, Ptied2.B"
  public static unsafe Vector<ulong> PropagateBreak(Vector<ulong> left, Vector<ulong> right);

    /// TrueMask : Set predicate elements to true

    /// svbool_t svptrue_b8() : "PTRUE Presult.B, ALL"
    /// svbool_t svptrue_b16() : "PTRUE Presult.H, ALL"
    /// svbool_t svptrue_b32() : "PTRUE Presult.S, ALL"
    /// svbool_t svptrue_b64() : "PTRUE Presult.D, ALL"
  public static unsafe Vector<byte> TrueMask();

    /// svbool_t svptrue_pat_b8(enum svpattern pattern) : "PTRUE Presult.B, pattern"
    /// svbool_t svptrue_pat_b16(enum svpattern pattern) : "PTRUE Presult.H, pattern"
    /// svbool_t svptrue_pat_b32(enum svpattern pattern) : "PTRUE Presult.S, pattern"
    /// svbool_t svptrue_pat_b64(enum svpattern pattern) : "PTRUE Presult.D, pattern"
  public static unsafe Vector<byte> TrueMask([ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All);

  /// total method signatures: 277
  /// total method names:      32
}
a74nh commented 1 year ago 

  /// Optional Entries:
  ///   public static unsafe Vector<float> AbsoluteCompareGreaterThan(Vector<float> left, float right); // svacgt[_n_f32]
  ///   public static unsafe Vector<double> AbsoluteCompareGreaterThan(Vector<double> left, double right); // svacgt[_n_f64]
  ///   public static unsafe Vector<float> AbsoluteCompareGreaterThanOrEqual(Vector<float> left, float right); // svacge[_n_f32]
  ///   public static unsafe Vector<double> AbsoluteCompareGreaterThanOrEqual(Vector<double> left, double right); // svacge[_n_f64]
  ///   public static unsafe Vector<float> AbsoluteCompareLessThan(Vector<float> left, float right); // svaclt[_n_f32]
  ///   public static unsafe Vector<double> AbsoluteCompareLessThan(Vector<double> left, double right); // svaclt[_n_f64]
  ///   public static unsafe Vector<float> AbsoluteCompareLessThanOrEqual(Vector<float> left, float right); // svacle[_n_f32]
  ///   public static unsafe Vector<double> AbsoluteCompareLessThanOrEqual(Vector<double> left, double right); // svacle[_n_f64]
  ///   public static unsafe Vector<float> CompareEqual(Vector<float> left, float right); // svcmpeq[_n_f32]
  ///   public static unsafe Vector<double> CompareEqual(Vector<double> left, double right); // svcmpeq[_n_f64]
  ///   public static unsafe Vector<sbyte> CompareEqual(Vector<sbyte> left, sbyte right); // svcmpeq[_n_s8]
  ///   public static unsafe Vector<short> CompareEqual(Vector<short> left, short right); // svcmpeq[_n_s16]
  ///   public static unsafe Vector<int> CompareEqual(Vector<int> left, int right); // svcmpeq[_n_s32]
  ///   public static unsafe Vector<long> CompareEqual(Vector<long> left, long right); // svcmpeq[_n_s64]
  ///   public static unsafe Vector<byte> CompareEqual(Vector<byte> left, byte right); // svcmpeq[_n_u8]
  ///   public static unsafe Vector<ushort> CompareEqual(Vector<ushort> left, ushort right); // svcmpeq[_n_u16]
  ///   public static unsafe Vector<uint> CompareEqual(Vector<uint> left, uint right); // svcmpeq[_n_u32]
  ///   public static unsafe Vector<ulong> CompareEqual(Vector<ulong> left, ulong right); // svcmpeq[_n_u64]
  ///   public static unsafe Vector<sbyte> CompareEqual(Vector<sbyte> left, long right); // svcmpeq_wide[_n_s8]
  ///   public static unsafe Vector<short> CompareEqual(Vector<short> left, long right); // svcmpeq_wide[_n_s16]
  ///   public static unsafe Vector<int> CompareEqual(Vector<int> left, long right); // svcmpeq_wide[_n_s32]
  ///   public static unsafe Vector<float> CompareGreaterThan(Vector<float> left, float right); // svcmpgt[_n_f32]
  ///   public static unsafe Vector<double> CompareGreaterThan(Vector<double> left, double right); // svcmpgt[_n_f64]
  ///   public static unsafe Vector<sbyte> CompareGreaterThan(Vector<sbyte> left, sbyte right); // svcmpgt[_n_s8]
  ///   public static unsafe Vector<short> CompareGreaterThan(Vector<short> left, short right); // svcmpgt[_n_s16]
  ///   public static unsafe Vector<int> CompareGreaterThan(Vector<int> left, int right); // svcmpgt[_n_s32]
  ///   public static unsafe Vector<long> CompareGreaterThan(Vector<long> left, long right); // svcmpgt[_n_s64]
  ///   public static unsafe Vector<byte> CompareGreaterThan(Vector<byte> left, byte right); // svcmpgt[_n_u8]
  ///   public static unsafe Vector<ushort> CompareGreaterThan(Vector<ushort> left, ushort right); // svcmpgt[_n_u16]
  ///   public static unsafe Vector<uint> CompareGreaterThan(Vector<uint> left, uint right); // svcmpgt[_n_u32]
  ///   public static unsafe Vector<ulong> CompareGreaterThan(Vector<ulong> left, ulong right); // svcmpgt[_n_u64]
  ///   public static unsafe Vector<sbyte> CompareGreaterThan(Vector<sbyte> left, long right); // svcmpgt_wide[_n_s8]
  ///   public static unsafe Vector<short> CompareGreaterThan(Vector<short> left, long right); // svcmpgt_wide[_n_s16]
  ///   public static unsafe Vector<int> CompareGreaterThan(Vector<int> left, long right); // svcmpgt_wide[_n_s32]
  ///   public static unsafe Vector<byte> CompareGreaterThan(Vector<byte> left, ulong right); // svcmpgt_wide[_n_u8]
  ///   public static unsafe Vector<ushort> CompareGreaterThan(Vector<ushort> left, ulong right); // svcmpgt_wide[_n_u16]
  ///   public static unsafe Vector<uint> CompareGreaterThan(Vector<uint> left, ulong right); // svcmpgt_wide[_n_u32]
  ///   public static unsafe Vector<float> CompareGreaterThanOrEqual(Vector<float> left, float right); // svcmpge[_n_f32]
  ///   public static unsafe Vector<double> CompareGreaterThanOrEqual(Vector<double> left, double right); // svcmpge[_n_f64]
  ///   public static unsafe Vector<sbyte> CompareGreaterThanOrEqual(Vector<sbyte> left, sbyte right); // svcmpge[_n_s8]
  ///   public static unsafe Vector<short> CompareGreaterThanOrEqual(Vector<short> left, short right); // svcmpge[_n_s16]
  ///   public static unsafe Vector<int> CompareGreaterThanOrEqual(Vector<int> left, int right); // svcmpge[_n_s32]
  ///   public static unsafe Vector<long> CompareGreaterThanOrEqual(Vector<long> left, long right); // svcmpge[_n_s64]
  ///   public static unsafe Vector<byte> CompareGreaterThanOrEqual(Vector<byte> left, byte right); // svcmpge[_n_u8]
  ///   public static unsafe Vector<ushort> CompareGreaterThanOrEqual(Vector<ushort> left, ushort right); // svcmpge[_n_u16]
  ///   public static unsafe Vector<uint> CompareGreaterThanOrEqual(Vector<uint> left, uint right); // svcmpge[_n_u32]
  ///   public static unsafe Vector<ulong> CompareGreaterThanOrEqual(Vector<ulong> left, ulong right); // svcmpge[_n_u64]
  ///   public static unsafe Vector<sbyte> CompareGreaterThanOrEqual(Vector<sbyte> left, long right); // svcmpge_wide[_n_s8]
  ///   public static unsafe Vector<short> CompareGreaterThanOrEqual(Vector<short> left, long right); // svcmpge_wide[_n_s16]
  ///   public static unsafe Vector<int> CompareGreaterThanOrEqual(Vector<int> left, long right); // svcmpge_wide[_n_s32]
  ///   public static unsafe Vector<byte> CompareGreaterThanOrEqual(Vector<byte> left, ulong right); // svcmpge_wide[_n_u8]
  ///   public static unsafe Vector<ushort> CompareGreaterThanOrEqual(Vector<ushort> left, ulong right); // svcmpge_wide[_n_u16]
  ///   public static unsafe Vector<uint> CompareGreaterThanOrEqual(Vector<uint> left, ulong right); // svcmpge_wide[_n_u32]
  ///   public static unsafe Vector<float> CompareLessThan(Vector<float> left, float right); // svcmplt[_n_f32]
  ///   public static unsafe Vector<double> CompareLessThan(Vector<double> left, double right); // svcmplt[_n_f64]
  ///   public static unsafe Vector<sbyte> CompareLessThan(Vector<sbyte> left, sbyte right); // svcmplt[_n_s8]
  ///   public static unsafe Vector<short> CompareLessThan(Vector<short> left, short right); // svcmplt[_n_s16]
  ///   public static unsafe Vector<int> CompareLessThan(Vector<int> left, int right); // svcmplt[_n_s32]
  ///   public static unsafe Vector<long> CompareLessThan(Vector<long> left, long right); // svcmplt[_n_s64]
  ///   public static unsafe Vector<byte> CompareLessThan(Vector<byte> left, byte right); // svcmplt[_n_u8]
  ///   public static unsafe Vector<ushort> CompareLessThan(Vector<ushort> left, ushort right); // svcmplt[_n_u16]
  ///   public static unsafe Vector<uint> CompareLessThan(Vector<uint> left, uint right); // svcmplt[_n_u32]
  ///   public static unsafe Vector<ulong> CompareLessThan(Vector<ulong> left, ulong right); // svcmplt[_n_u64]
  ///   public static unsafe Vector<sbyte> CompareLessThan(Vector<sbyte> left, long right); // svcmplt_wide[_n_s8]
  ///   public static unsafe Vector<short> CompareLessThan(Vector<short> left, long right); // svcmplt_wide[_n_s16]
  ///   public static unsafe Vector<int> CompareLessThan(Vector<int> left, long right); // svcmplt_wide[_n_s32]
  ///   public static unsafe Vector<byte> CompareLessThan(Vector<byte> left, ulong right); // svcmplt_wide[_n_u8]
  ///   public static unsafe Vector<ushort> CompareLessThan(Vector<ushort> left, ulong right); // svcmplt_wide[_n_u16]
  ///   public static unsafe Vector<uint> CompareLessThan(Vector<uint> left, ulong right); // svcmplt_wide[_n_u32]
  ///   public static unsafe Vector<float> CompareLessThanOrEqual(Vector<float> left, float right); // svcmple[_n_f32]
  ///   public static unsafe Vector<double> CompareLessThanOrEqual(Vector<double> left, double right); // svcmple[_n_f64]
  ///   public static unsafe Vector<sbyte> CompareLessThanOrEqual(Vector<sbyte> left, sbyte right); // svcmple[_n_s8]
  ///   public static unsafe Vector<short> CompareLessThanOrEqual(Vector<short> left, short right); // svcmple[_n_s16]
  ///   public static unsafe Vector<int> CompareLessThanOrEqual(Vector<int> left, int right); // svcmple[_n_s32]
  ///   public static unsafe Vector<long> CompareLessThanOrEqual(Vector<long> left, long right); // svcmple[_n_s64]
  ///   public static unsafe Vector<byte> CompareLessThanOrEqual(Vector<byte> left, byte right); // svcmple[_n_u8]
  ///   public static unsafe Vector<ushort> CompareLessThanOrEqual(Vector<ushort> left, ushort right); // svcmple[_n_u16]
  ///   public static unsafe Vector<uint> CompareLessThanOrEqual(Vector<uint> left, uint right); // svcmple[_n_u32]
  ///   public static unsafe Vector<ulong> CompareLessThanOrEqual(Vector<ulong> left, ulong right); // svcmple[_n_u64]
  ///   public static unsafe Vector<sbyte> CompareLessThanOrEqual(Vector<sbyte> left, long right); // svcmple_wide[_n_s8]
  ///   public static unsafe Vector<short> CompareLessThanOrEqual(Vector<short> left, long right); // svcmple_wide[_n_s16]
  ///   public static unsafe Vector<int> CompareLessThanOrEqual(Vector<int> left, long right); // svcmple_wide[_n_s32]
  ///   public static unsafe Vector<byte> CompareLessThanOrEqual(Vector<byte> left, ulong right); // svcmple_wide[_n_u8]
  ///   public static unsafe Vector<ushort> CompareLessThanOrEqual(Vector<ushort> left, ulong right); // svcmple_wide[_n_u16]
  ///   public static unsafe Vector<uint> CompareLessThanOrEqual(Vector<uint> left, ulong right); // svcmple_wide[_n_u32]
  ///   public static unsafe Vector<float> CompareNotEqualTo(Vector<float> left, float right); // svcmpne[_n_f32]
  ///   public static unsafe Vector<double> CompareNotEqualTo(Vector<double> left, double right); // svcmpne[_n_f64]
  ///   public static unsafe Vector<sbyte> CompareNotEqualTo(Vector<sbyte> left, sbyte right); // svcmpne[_n_s8]
  ///   public static unsafe Vector<short> CompareNotEqualTo(Vector<short> left, short right); // svcmpne[_n_s16]
  ///   public static unsafe Vector<int> CompareNotEqualTo(Vector<int> left, int right); // svcmpne[_n_s32]
  ///   public static unsafe Vector<long> CompareNotEqualTo(Vector<long> left, long right); // svcmpne[_n_s64]
  ///   public static unsafe Vector<byte> CompareNotEqualTo(Vector<byte> left, byte right); // svcmpne[_n_u8]
  ///   public static unsafe Vector<ushort> CompareNotEqualTo(Vector<ushort> left, ushort right); // svcmpne[_n_u16]
  ///   public static unsafe Vector<uint> CompareNotEqualTo(Vector<uint> left, uint right); // svcmpne[_n_u32]
  ///   public static unsafe Vector<ulong> CompareNotEqualTo(Vector<ulong> left, ulong right); // svcmpne[_n_u64]
  ///   public static unsafe Vector<sbyte> CompareNotEqualTo(Vector<sbyte> left, long right); // svcmpne_wide[_n_s8]
  ///   public static unsafe Vector<short> CompareNotEqualTo(Vector<short> left, long right); // svcmpne_wide[_n_s16]
  ///   public static unsafe Vector<int> CompareNotEqualTo(Vector<int> left, long right); // svcmpne_wide[_n_s32]
  ///   public static unsafe Vector<float> CompareUnordered(Vector<float> left, float right); // svcmpuo[_n_f32]
  ///   public static unsafe Vector<double> CompareUnordered(Vector<double> left, double right); // svcmpuo[_n_f64]
  ///   public static unsafe float ConditionalExtractAfterLastActiveElement(Vector<float> mask, float fallback, Vector<float> data); // svclasta[_n_f32]
  ///   public static unsafe double ConditionalExtractAfterLastActiveElement(Vector<double> mask, double fallback, Vector<double> data); // svclasta[_n_f64]
  ///   public static unsafe sbyte ConditionalExtractAfterLastActiveElement(Vector<sbyte> mask, sbyte fallback, Vector<sbyte> data); // svclasta[_n_s8]
  ///   public static unsafe short ConditionalExtractAfterLastActiveElement(Vector<short> mask, short fallback, Vector<short> data); // svclasta[_n_s16]
  ///   public static unsafe int ConditionalExtractAfterLastActiveElement(Vector<int> mask, int fallback, Vector<int> data); // svclasta[_n_s32]
  ///   public static unsafe long ConditionalExtractAfterLastActiveElement(Vector<long> mask, long fallback, Vector<long> data); // svclasta[_n_s64]
  ///   public static unsafe byte ConditionalExtractAfterLastActiveElement(Vector<byte> mask, byte fallback, Vector<byte> data); // svclasta[_n_u8]
  ///   public static unsafe ushort ConditionalExtractAfterLastActiveElement(Vector<ushort> mask, ushort fallback, Vector<ushort> data); // svclasta[_n_u16]
  ///   public static unsafe uint ConditionalExtractAfterLastActiveElement(Vector<uint> mask, uint fallback, Vector<uint> data); // svclasta[_n_u32]
  ///   public static unsafe ulong ConditionalExtractAfterLastActiveElement(Vector<ulong> mask, ulong fallback, Vector<ulong> data); // svclasta[_n_u64]
  ///   public static unsafe float ConditionalExtractLastActiveElement(Vector<float> mask, float fallback, Vector<float> data); // svclastb[_n_f32]
  ///   public static unsafe double ConditionalExtractLastActiveElement(Vector<double> mask, double fallback, Vector<double> data); // svclastb[_n_f64]
  ///   public static unsafe sbyte ConditionalExtractLastActiveElement(Vector<sbyte> mask, sbyte fallback, Vector<sbyte> data); // svclastb[_n_s8]
  ///   public static unsafe short ConditionalExtractLastActiveElement(Vector<short> mask, short fallback, Vector<short> data); // svclastb[_n_s16]
  ///   public static unsafe int ConditionalExtractLastActiveElement(Vector<int> mask, int fallback, Vector<int> data); // svclastb[_n_s32]
  ///   public static unsafe long ConditionalExtractLastActiveElement(Vector<long> mask, long fallback, Vector<long> data); // svclastb[_n_s64]
  ///   public static unsafe byte ConditionalExtractLastActiveElement(Vector<byte> mask, byte fallback, Vector<byte> data); // svclastb[_n_u8]
  ///   public static unsafe ushort ConditionalExtractLastActiveElement(Vector<ushort> mask, ushort fallback, Vector<ushort> data); // svclastb[_n_u16]
  ///   public static unsafe uint ConditionalExtractLastActiveElement(Vector<uint> mask, uint fallback, Vector<uint> data); // svclastb[_n_u32]
  ///   public static unsafe ulong ConditionalExtractLastActiveElement(Vector<ulong> mask, ulong fallback, Vector<ulong> data); // svclastb[_n_u64]
  ///   Total Maybe: 120

  /// Total ACLE covered across API:      427
a74nh commented 1 year ago

This contributes to https://github.com/dotnet/runtime/issues/93095

It covers instructions in FEAT_SVE related to masks.

This list was auto generated from the C ACLE for SVE, and is in three parts:

Where possible, existing C# naming conventions have been matched.

Many of the C functions include predicate argument(s), of type svbool_t as the first argument. These are missing from the C# method. It is expected that the Jit will create predicates where required, or combine with uses of conditionalSelect(). For more discussion see #88140 comment.

a74nh commented 1 year ago

@kunalspathak @tannergooding @BruceForstall @TamarChristinaArm

tannergooding commented 1 year ago

Break* and While* would benefit from a couple small examples on how they get used. They might benefit from a slightly clearer name like CreateBreak*Mask or CreateWhile*Mask to clarify that these aren't themselves doing the looping or the breaking, but rather simply generating a predicate that can be used given the current index and upper limit. -- They similarly might benefit from consideration on what a cross platform API might look, particularly given the same consideration is needed for AdvSimd or xarch when handling any trailing elements.

CompareEqualTo should just be CompareEqual. Similarly CompareNotEqualTo should be CompareNotEqual

For ConditionalExtractLast I wonder if it would make more sense to be named ConditionalExtractLastActiveElement? Similar comment for CLASTA

For MaskClearAll and MaskSetAll, I wonder if it would make more sense as Vector<T>.TrueMask (equivalent to AllBitsSet) and Vector<T>.FalseMask (equivalent to Zero).

MaskGetFirstSet and MaskSetFirst might benefit from an example showing what they do.

ghost commented 1 year ago

This issue has been marked needs-author-action and may be missing some important information.

a74nh commented 1 year ago

For MaskClearAll and MaskSetAll, I wonder if it would make more sense as Vector<T>.TrueMask (equivalent to AllBitsSet) and Vector<T>.FalseMask (equivalent to Zero).

I assume TrueMask() and TrueMask() would still be in the Sve API?

a74nh commented 1 year ago

For MaskSetFirst, MaskGetFirstSet, CreateBreak* and maybe some more in this issue, it doesn't make sense to hide the predicate mask.

For example, matching the Arm instruction:

  public static unsafe Vector<T> MaskSetFirst(Vector<T> mask, Vector<T> select); // PFIRST // predicated

This returns a mask that is a copy of select, with the first active element set to true. Where mask is used to determine the active elements in select.

If mask is made implicit. Then it becomes:

  public static unsafe Vector<T> MaskSetFirst(Vector<T> select); // PFIRST // predicated

This returns a mask that is a copy of select, with the first element set to true.

If the user now writes:

Vector<int> first = Sve.ConditionalSelect(mask, Sve.MaskSetFirst(select), select);

It's now ambiguous if this gives:

Maybe for any method which takes in a mask as input in addition to the predicate mask, then the predicate mask should not be made implicit. This stops ambiguity.

tannergooding commented 1 year ago

Maybe for any method which takes in a mask as input in addition to the predicate mask, then the predicate mask should not be made implicit. This stops ambiguity.

Sounds good to me. It's expected there is a subset of APIs where the mask needs to be explicit for the API to work and make sense.

The goal isn't to strictly remove all explicit masking, just to remove it where it can be trivially achieved via ConditionalSelect instead. For scenarios like this or predicated load/store or adding two masks, having additional functions that make the semantics straightforward and understandable is goodness

a74nh commented 1 year ago

Add some examples. Still need an example for MaskGetFirstSet and maybe some others.

CreateBreakAfterMask() has merging and zeroing variants. We're now exposing the mask for this method. Which means I think we need explicit merging and zeroing methods adding. ie:

  public static unsafe Vector<T> CreateBreakAfterMask(Vector<T> mask, Vector<T> select); // BRKA
  public static unsafe Vector<T> CreateBreakAfterMaskMerging(Vector<T> mask, Vector<T> select,  Vector<T> merge); // BRKA

CreateBreakAfterMask() could be renamed to something like CreateTrueMaskToFirstElement().

Spotted svptest_any and the other tests are missing. I'll add them in.

a74nh commented 1 year ago

Where the second argument is also a mask, I've called that select. That might be a bad idea as it's being highlighted differently:

  public static unsafe Vector<T> CreateBreakAfterMask(Vector<T> mask, Vector<T> select); // BRKA // predicated

Wanted a generic term to indicate a mask that isn't the active selection mask in arg1.

a74nh commented 1 year ago

TrueMask() returns the exact same result regardless of the type of the vector. To avoid bloating the API, we only have Vector<byte> TrueMask(). The user can cast to the correct type. I think this might be wrong.

bartonjs commented 8 months ago

Video

namespace System.Runtime.Intrinsics.Arm;

/// VectorT Summary
public abstract partial class Sve : AdvSimd /// Feature: FEAT_SVE  Category: mask
{
  /// T: float, double
  public static unsafe Vector<T> AbsoluteCompareGreaterThan(Vector<T> left, Vector<T> right); // FACGT // predicated

  /// T: float, double
  public static unsafe Vector<T> AbsoluteCompareGreaterThanOrEqual(Vector<T> left, Vector<T> right); // FACGE // predicated

  /// T: float, double
  public static unsafe Vector<T> AbsoluteCompareLessThan(Vector<T> left, Vector<T> right); // FACGT // predicated

  /// T: float, double
  public static unsafe Vector<T> AbsoluteCompareLessThanOrEqual(Vector<T> left, Vector<T> right); // FACGE // predicated

  /// T: float, double, int, long, uint, ulong
  public static unsafe Vector<T> Compact(Vector<T> mask, Vector<T> value); // COMPACT

  /// T: float, double, sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> CompareEqual(Vector<T> left, Vector<T> right); // FCMEQ or CMPEQ // predicated

  /// T: [sbyte, long], [short, long], [int, long]
  public static unsafe Vector<T> CompareEqual(Vector<T> left, Vector<T2> right); // CMPEQ // predicated

  /// T: float, double, sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> CompareGreaterThan(Vector<T> left, Vector<T> right); // FCMGT or CMPGT or CMPHI // predicated

  /// T: [sbyte, long], [short, long], [int, long], [byte, ulong], [ushort, ulong], [uint, ulong]
  public static unsafe Vector<T> CompareGreaterThan(Vector<T> left, Vector<T2> right); // CMPGT or CMPHI // predicated

  /// T: float, double, sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> CompareGreaterThanOrEqual(Vector<T> left, Vector<T> right); // FCMGE or CMPGE or CMPHS // predicated

  /// T: [sbyte, long], [short, long], [int, long], [byte, ulong], [ushort, ulong], [uint, ulong]
  public static unsafe Vector<T> CompareGreaterThanOrEqual(Vector<T> left, Vector<T2> right); // CMPGE or CMPHS // predicated

  /// T: float, double, sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> CompareLessThan(Vector<T> left, Vector<T> right); // FCMGT or CMPGT or CMPHI // predicated

  /// T: [sbyte, long], [short, long], [int, long], [byte, ulong], [ushort, ulong], [uint, ulong]
  public static unsafe Vector<T> CompareLessThan(Vector<T> left, Vector<T2> right); // CMPLT or CMPLO // predicated

  /// T: float, double, sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> CompareLessThanOrEqual(Vector<T> left, Vector<T> right); // FCMGE or CMPGE or CMPHS // predicated

  /// T: [sbyte, long], [short, long], [int, long], [byte, ulong], [ushort, ulong], [uint, ulong]
  public static unsafe Vector<T> CompareLessThanOrEqual(Vector<T> left, Vector<T2> right); // CMPLE or CMPLS // predicated

  /// T: float, double, sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> CompareNotEqualTo(Vector<T> left, Vector<T> right); // FCMNE or CMPNE // predicated

  /// T: [sbyte, long], [short, long], [int, long]
  public static unsafe Vector<T> CompareNotEqualTo(Vector<T> left, Vector<T2> right); // CMPNE // predicated

  /// T: float, double
  public static unsafe Vector<T> CompareUnordered(Vector<T> left, Vector<T> right); // FCMUO // predicated

  /// T: float, double, sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> ConditionalExtractAfterLastActiveElement(Vector<T> mask, Vector<T> defaultScalar, Vector<T> data); // CLASTA // MOVPRFX
  public static unsafe Vector<T> ConditionalExtractAfterLastActiveElementAndReplicate(Vector<T> mask, Vector<T> defaultValues, Vector<T> data); // CLASTA // MOVPRFX
  public static unsafe T ConditionalExtractAfterLastActiveElement(Vector<T> mask, T defaultValue, Vector<T> data); // CLASTA // MOVPRFX

  /// T: float, double, sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> ConditionalExtractLastActiveElement(Vector<T> mask, Vector<T> defaultScalar, Vector<T> data); // CLASTB // MOVPRFX
  public static unsafe Vector<T> ConditionalExtractLastActiveElementAndReplicate(Vector<T> mask, Vector<T> defaultValues, Vector<T> data); // CLASTB // MOVPRFX
  public static unsafe T ConditionalExtractLastActiveElement(Vector<T> mask, T defaultValue, Vector<T> data); // CLASTB // MOVPRFX
}
a74nh commented 8 months ago

Note: Items from this API that were not reviewed/approved are covered in https://github.com/dotnet/runtime/issues/98184