[API Proposal]: Arm64: FEAT_SVE: counting

[a74nh]

namespace System.Runtime.Intrinsics.Arm

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

  public static unsafe ulong Count16BitElements(); // CNTH

  public static unsafe ulong Count16BitElements(enum SveMaskPattern pattern); // CNTH

  public static unsafe ulong Count32BitElements(); // CNTW

  public static unsafe ulong Count32BitElements(enum SveMaskPattern pattern); // CNTW

  public static unsafe ulong Count64BitElements(); // CNTD

  public static unsafe ulong Count64BitElements(enum SveMaskPattern pattern); // CNTD

  public static unsafe ulong Count8BitElements(); // CNTB

  public static unsafe ulong Count8BitElements(enum SveMaskPattern pattern); // CNTB

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

  /// T: [byte, sbyte], [ushort, short], [uint, int], [ulong, long]
  public static unsafe Vector<T> LeadingSignCount(Vector<T2> value); // CLS // predicated, MOVPRFX

  /// T: [byte, sbyte], [ushort, short], [uint, int], [ulong, long]
  public static unsafe Vector<T> LeadingZeroCount(Vector<T2> value); // CLZ // predicated, MOVPRFX

  /// T: byte, ushort, uint, ulong
  public static unsafe Vector<T> LeadingZeroCount(Vector<T> value); // CLZ // predicated, MOVPRFX

  /// T: [uint, float], [ulong, double], [byte, sbyte], [ushort, short], [uint, int], [ulong, long]
  public static unsafe Vector<T> PopCount(Vector<T2> value); // CNT // predicated, MOVPRFX

  /// T: byte, ushort, uint, ulong
  public static unsafe Vector<T> PopCount(Vector<T> value); // CNT // predicated, MOVPRFX

  /// T: byte, ushort, uint, ulong
  public static unsafe int SaturatingDecrementByActiveElementCount(int op, Vector<T> from); // SQDECP

  /// T: byte, ushort, uint, ulong
  public static unsafe long SaturatingDecrementByActiveElementCount(long op, Vector<T> from); // SQDECP

  /// T: byte, ushort, uint, ulong
  public static unsafe uint SaturatingDecrementByActiveElementCount(uint op, Vector<T> from); // UQDECP

  /// T: byte, ushort, uint, ulong
  public static unsafe ulong SaturatingDecrementByActiveElementCount(ulong op, Vector<T> from); // UQDECP

  /// T: short, int, long, ushort, uint, ulong
  public static unsafe Vector<T> SaturatingDecrementByActiveElementCount(Vector<T> op, Vector<T> from); // SQDECP or UQDECP // MOVPRFX

  public static unsafe int SaturatingDecrementByteElementCount(int op, ulong imm_factor); // SQDECB

  public static unsafe long SaturatingDecrementByteElementCount(long op, ulong imm_factor); // SQDECB

  public static unsafe uint SaturatingDecrementByteElementCount(uint op, ulong imm_factor); // UQDECB

  public static unsafe ulong SaturatingDecrementByteElementCount(ulong op, ulong imm_factor); // UQDECB

  public static unsafe int SaturatingDecrementByteElementCount(int op, enum SveMaskPattern pattern, ulong imm_factor); // SQDECB

  public static unsafe long SaturatingDecrementByteElementCount(long op, enum SveMaskPattern pattern, ulong imm_factor); // SQDECB

  public static unsafe uint SaturatingDecrementByteElementCount(uint op, enum SveMaskPattern pattern, ulong imm_factor); // UQDECB

  public static unsafe ulong SaturatingDecrementByteElementCount(ulong op, enum SveMaskPattern pattern, ulong imm_factor); // UQDECB

  public static unsafe int SaturatingDecrementInt16ElementCount(int op, ulong imm_factor); // SQDECH

  public static unsafe long SaturatingDecrementInt16ElementCount(long op, ulong imm_factor); // SQDECH

  public static unsafe uint SaturatingDecrementInt16ElementCount(uint op, ulong imm_factor); // UQDECH

  public static unsafe ulong SaturatingDecrementInt16ElementCount(ulong op, ulong imm_factor); // UQDECH

  public static unsafe int SaturatingDecrementInt16ElementCount(int op, enum SveMaskPattern pattern, ulong imm_factor); // SQDECH

  public static unsafe long SaturatingDecrementInt16ElementCount(long op, enum SveMaskPattern pattern, ulong imm_factor); // SQDECH

  public static unsafe uint SaturatingDecrementInt16ElementCount(uint op, enum SveMaskPattern pattern, ulong imm_factor); // UQDECH

  public static unsafe ulong SaturatingDecrementInt16ElementCount(ulong op, enum SveMaskPattern pattern, ulong imm_factor); // UQDECH

  /// T: short, ushort
  public static unsafe Vector<T> SaturatingDecrementInt16ElementCount(Vector<T> op, ulong imm_factor); // SQDECH or UQDECH // MOVPRFX

  /// T: short, ushort
  public static unsafe Vector<T> SaturatingDecrementInt16ElementCount(Vector<T> op, enum SveMaskPattern pattern, ulong imm_factor); // SQDECH or UQDECH // MOVPRFX

  public static unsafe int SaturatingDecrementInt32ElementCount(int op, ulong imm_factor); // SQDECW

  public static unsafe long SaturatingDecrementInt32ElementCount(long op, ulong imm_factor); // SQDECW

  public static unsafe uint SaturatingDecrementInt32ElementCount(uint op, ulong imm_factor); // UQDECW

  public static unsafe ulong SaturatingDecrementInt32ElementCount(ulong op, ulong imm_factor); // UQDECW

  public static unsafe int SaturatingDecrementInt32ElementCount(int op, enum SveMaskPattern pattern, ulong imm_factor); // SQDECW

  public static unsafe long SaturatingDecrementInt32ElementCount(long op, enum SveMaskPattern pattern, ulong imm_factor); // SQDECW

  public static unsafe uint SaturatingDecrementInt32ElementCount(uint op, enum SveMaskPattern pattern, ulong imm_factor); // UQDECW

  public static unsafe ulong SaturatingDecrementInt32ElementCount(ulong op, enum SveMaskPattern pattern, ulong imm_factor); // UQDECW

  /// T: int, uint
  public static unsafe Vector<T> SaturatingDecrementInt32ElementCount(Vector<T> op, ulong imm_factor); // SQDECW or UQDECW // MOVPRFX

  /// T: int, uint
  public static unsafe Vector<T> SaturatingDecrementInt32ElementCount(Vector<T> op, enum SveMaskPattern pattern, ulong imm_factor); // SQDECW or UQDECW // MOVPRFX

  public static unsafe int SaturatingDecrementInt64ElementCount(int op, ulong imm_factor); // SQDECD

  public static unsafe long SaturatingDecrementInt64ElementCount(long op, ulong imm_factor); // SQDECD

  public static unsafe uint SaturatingDecrementInt64ElementCount(uint op, ulong imm_factor); // UQDECD

  public static unsafe ulong SaturatingDecrementInt64ElementCount(ulong op, ulong imm_factor); // UQDECD

  public static unsafe int SaturatingDecrementInt64ElementCount(int op, enum SveMaskPattern pattern, ulong imm_factor); // SQDECD

  public static unsafe long SaturatingDecrementInt64ElementCount(long op, enum SveMaskPattern pattern, ulong imm_factor); // SQDECD

  public static unsafe uint SaturatingDecrementInt64ElementCount(uint op, enum SveMaskPattern pattern, ulong imm_factor); // UQDECD

  public static unsafe ulong SaturatingDecrementInt64ElementCount(ulong op, enum SveMaskPattern pattern, ulong imm_factor); // UQDECD

  /// T: long, ulong
  public static unsafe Vector<T> SaturatingDecrementInt64ElementCount(Vector<T> op, ulong imm_factor); // SQDECD or UQDECD // MOVPRFX

  /// T: long, ulong
  public static unsafe Vector<T> SaturatingDecrementInt64ElementCount(Vector<T> op, enum SveMaskPattern pattern, ulong imm_factor); // SQDECD or UQDECD // MOVPRFX

  /// T: byte, ushort, uint, ulong
  public static unsafe int SaturatingIncrementByActiveElementCount(int op, Vector<T> from); // SQINCP

  /// T: byte, ushort, uint, ulong
  public static unsafe long SaturatingIncrementByActiveElementCount(long op, Vector<T> from); // SQINCP

  /// T: byte, ushort, uint, ulong
  public static unsafe uint SaturatingIncrementByActiveElementCount(uint op, Vector<T> from); // UQINCP

  /// T: byte, ushort, uint, ulong
  public static unsafe ulong SaturatingIncrementByActiveElementCount(ulong op, Vector<T> from); // UQINCP

  /// T: short, int, long, ushort, uint, ulong
  public static unsafe Vector<T> SaturatingIncrementByActiveElementCount(Vector<T> op, Vector<T> from); // SQINCP or UQINCP // MOVPRFX

  public static unsafe int SaturatingIncrementByteElementCount(int op, ulong imm_factor); // SQINCB

  public static unsafe long SaturatingIncrementByteElementCount(long op, ulong imm_factor); // SQINCB

  public static unsafe uint SaturatingIncrementByteElementCount(uint op, ulong imm_factor); // UQINCB

  public static unsafe ulong SaturatingIncrementByteElementCount(ulong op, ulong imm_factor); // UQINCB

  public static unsafe int SaturatingIncrementByteElementCount(int op, enum SveMaskPattern pattern, ulong imm_factor); // SQINCB

  public static unsafe long SaturatingIncrementByteElementCount(long op, enum SveMaskPattern pattern, ulong imm_factor); // SQINCB

  public static unsafe uint SaturatingIncrementByteElementCount(uint op, enum SveMaskPattern pattern, ulong imm_factor); // UQINCB

  public static unsafe ulong SaturatingIncrementByteElementCount(ulong op, enum SveMaskPattern pattern, ulong imm_factor); // UQINCB

  public static unsafe int SaturatingIncrementInt16ElementCount(int op, ulong imm_factor); // SQINCH

  public static unsafe long SaturatingIncrementInt16ElementCount(long op, ulong imm_factor); // SQINCH

  public static unsafe uint SaturatingIncrementInt16ElementCount(uint op, ulong imm_factor); // UQINCH

  public static unsafe ulong SaturatingIncrementInt16ElementCount(ulong op, ulong imm_factor); // UQINCH

  public static unsafe int SaturatingIncrementInt16ElementCount(int op, enum SveMaskPattern pattern, ulong imm_factor); // SQINCH

  public static unsafe long SaturatingIncrementInt16ElementCount(long op, enum SveMaskPattern pattern, ulong imm_factor); // SQINCH

  public static unsafe uint SaturatingIncrementInt16ElementCount(uint op, enum SveMaskPattern pattern, ulong imm_factor); // UQINCH

  public static unsafe ulong SaturatingIncrementInt16ElementCount(ulong op, enum SveMaskPattern pattern, ulong imm_factor); // UQINCH

  /// T: short, ushort
  public static unsafe Vector<T> SaturatingIncrementInt16ElementCount(Vector<T> op, ulong imm_factor); // SQINCH or UQINCH // MOVPRFX

  /// T: short, ushort
  public static unsafe Vector<T> SaturatingIncrementInt16ElementCount(Vector<T> op, enum SveMaskPattern pattern, ulong imm_factor); // SQINCH or UQINCH // MOVPRFX

  public static unsafe int SaturatingIncrementInt32ElementCount(int op, ulong imm_factor); // SQINCW

  public static unsafe long SaturatingIncrementInt32ElementCount(long op, ulong imm_factor); // SQINCW

  public static unsafe uint SaturatingIncrementInt32ElementCount(uint op, ulong imm_factor); // UQINCW

  public static unsafe ulong SaturatingIncrementInt32ElementCount(ulong op, ulong imm_factor); // UQINCW

  public static unsafe int SaturatingIncrementInt32ElementCount(int op, enum SveMaskPattern pattern, ulong imm_factor); // SQINCW

  public static unsafe long SaturatingIncrementInt32ElementCount(long op, enum SveMaskPattern pattern, ulong imm_factor); // SQINCW

  public static unsafe uint SaturatingIncrementInt32ElementCount(uint op, enum SveMaskPattern pattern, ulong imm_factor); // UQINCW

  public static unsafe ulong SaturatingIncrementInt32ElementCount(ulong op, enum SveMaskPattern pattern, ulong imm_factor); // UQINCW

  /// T: int, uint
  public static unsafe Vector<T> SaturatingIncrementInt32ElementCount(Vector<T> op, ulong imm_factor); // SQINCW or UQINCW // MOVPRFX

  /// T: int, uint
  public static unsafe Vector<T> SaturatingIncrementInt32ElementCount(Vector<T> op, enum SveMaskPattern pattern, ulong imm_factor); // SQINCW or UQINCW // MOVPRFX

  public static unsafe int SaturatingIncrementInt64ElementCount(int op, ulong imm_factor); // SQINCD

  public static unsafe long SaturatingIncrementInt64ElementCount(long op, ulong imm_factor); // SQINCD

  public static unsafe uint SaturatingIncrementInt64ElementCount(uint op, ulong imm_factor); // UQINCD

  public static unsafe ulong SaturatingIncrementInt64ElementCount(ulong op, ulong imm_factor); // UQINCD

  public static unsafe int SaturatingIncrementInt64ElementCount(int op, enum SveMaskPattern pattern, ulong imm_factor); // SQINCD

  public static unsafe long SaturatingIncrementInt64ElementCount(long op, enum SveMaskPattern pattern, ulong imm_factor); // SQINCD

  public static unsafe uint SaturatingIncrementInt64ElementCount(uint op, enum SveMaskPattern pattern, ulong imm_factor); // UQINCD

  public static unsafe ulong SaturatingIncrementInt64ElementCount(ulong op, enum SveMaskPattern pattern, ulong imm_factor); // UQINCD

  /// T: long, ulong
  public static unsafe Vector<T> SaturatingIncrementInt64ElementCount(Vector<T> op, ulong imm_factor); // SQINCD or UQINCD // MOVPRFX

  /// T: long, ulong
  public static unsafe Vector<T> SaturatingIncrementInt64ElementCount(Vector<T> op, enum SveMaskPattern pattern, ulong imm_factor); // SQINCD or UQINCD // MOVPRFX


  // All patterns used by PTRUE.
  enum SveMaskPattern
  {
    SV_POW2 = 0,   // The largest power of 2.
    SV_VL1 = 1,    // 1 element.
    SV_VL2 = 2,    // 2 elements.
    SV_VL3 = 3,    // 3 elements.
    SV_VL4 = 4,    // 4 elements.
    SV_VL5 = 5,    // 5 elements.
    SV_VL6 = 6,    // 6 elements.
    SV_VL7 = 7,    // 7 elements.
    SV_VL8 = 8,    // 8 elements.
    SV_VL16 = 9,   // 16 elements.
    SV_VL32 = 10,  // 32 elements.
    SV_VL64 = 11,  // 64 elements.
    SV_VL128 = 12, // 128 elements.
    SV_VL256 = 13, // 256 elements.
    SV_MUL4 = 29,  // The largest multiple of 3.
    SV_MUL3 = 30,  // The largest multiple of 4.
    SV_ALL = 31    // All available (implicitly a multiple of two).
  };

  /// total method signatures: 100

}

Details

CountNBitElements(enum SveMaskPattern pattern)
Set scalar to multiple of predicate constraint element count
Determines the number of active elements implied by pattern, multiplies that by an immediate in the range 1 to 16 inclusive, and then places the result in the scalar destination.

Pattern limits the number of active elements in a single predicate to:

• A fixed number (VL1 to VL256)
• The largest power of two (POW2)
• The largest multiple of three or four (MUL3 or MUL4)
• All available, implicitly a multiple of two (ALL).

CountNBitElements()
Identical to: CountNBitElements(SV_ALL)

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

Issue Details

---

namespace System.Runtime.Intrinsics.Arm

/// VectorT Summary
public abstract class Sve : AdvSimd /// Feature: FEAT_SVE  Category: count
{
  /// T: [byte, sbyte], [ushort, short], [uint, int], [ulong, long]
  public static unsafe Vector<T> CountLeadingSignBits(Vector<T2> value); // CLS (MOVPRFX)

  /// T: [byte, sbyte], [ushort, short], [uint, int], [ulong, long]
  public static unsafe Vector<T> CountLeadingZeroBits(Vector<T2> value); // CLZ (MOVPRFX)

  /// T: byte, ushort, uint, ulong
  public static unsafe Vector<T> CountLeadingZeroBits(Vector<T> value); // CLZ (MOVPRFX)

  /// T: [uint, float], [ulong, double], [byte, sbyte], [ushort, short], [uint, int], [ulong, long]
  public static unsafe Vector<T> CountNonzeroBits(Vector<T2> value); // CNT (MOVPRFX)

  /// T: byte, ushort, uint, ulong
  public static unsafe Vector<T> CountNonzeroBits(Vector<T> value); // CNT (MOVPRFX)

  /// T: byte, ushort, uint, ulong
  public static unsafe ulong CountSetPredicateBits(Vector<T> value); // CNTP

  public static unsafe ulong CountTheNumberOf16BitElementsInAVector();

  public static unsafe ulong CountTheNumberOf16BitElementsInAVector(enum svpattern pattern);

  public static unsafe ulong CountTheNumberOf32BitElementsInAVector();

  public static unsafe ulong CountTheNumberOf32BitElementsInAVector(enum svpattern pattern);

  public static unsafe ulong CountTheNumberOf64BitElementsInAVector();

  public static unsafe ulong CountTheNumberOf64BitElementsInAVector(enum svpattern pattern);

  public static unsafe ulong CountTheNumberOf8BitElementsInAVector();

  public static unsafe ulong CountTheNumberOf8BitElementsInAVector(enum svpattern pattern);

  /// T: float, double, sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe ulong CountTheNumberOfElementsInAFullVector(Vector<T> value); // CNTW or CNTD or CNTB or CNTH

  /// T: byte, ushort, uint, ulong
  public static unsafe int SaturatingDecrementByActiveElementCount(int op, Vector<T> mask); // SQDECP

  /// T: byte, ushort, uint, ulong
  public static unsafe long SaturatingDecrementByActiveElementCount(long op, Vector<T> mask); // SQDECP

  /// T: byte, ushort, uint, ulong
  public static unsafe uint SaturatingDecrementByActiveElementCount(uint op, Vector<T> mask); // UQDECP

  /// T: byte, ushort, uint, ulong
  public static unsafe ulong SaturatingDecrementByActiveElementCount(ulong op, Vector<T> mask); // UQDECP

  /// T: short, int, long, ushort, uint, ulong
  public static unsafe Vector<T> SaturatingDecrementByActiveElementCount(Vector<T> op, Vector<T> mask); // SQDECP or UQDECP (MOVPRFX)

  public static unsafe int SaturatingDecrementByNumberOfByteElements(int op, ulong imm_factor);

  public static unsafe long SaturatingDecrementByNumberOfByteElements(long op, ulong imm_factor);

  public static unsafe uint SaturatingDecrementByNumberOfByteElements(uint op, ulong imm_factor);

  public static unsafe ulong SaturatingDecrementByNumberOfByteElements(ulong op, ulong imm_factor);

  public static unsafe int SaturatingDecrementByNumberOfByteElements(int op, enum svpattern pattern, ulong imm_factor);

  public static unsafe long SaturatingDecrementByNumberOfByteElements(long op, enum svpattern pattern, ulong imm_factor);

  public static unsafe uint SaturatingDecrementByNumberOfByteElements(uint op, enum svpattern pattern, ulong imm_factor);

  public static unsafe ulong SaturatingDecrementByNumberOfByteElements(ulong op, enum svpattern pattern, ulong imm_factor);

  public static unsafe int SaturatingDecrementByNumberOfDoublewordElements(int op, ulong imm_factor);

  public static unsafe long SaturatingDecrementByNumberOfDoublewordElements(long op, ulong imm_factor);

  public static unsafe uint SaturatingDecrementByNumberOfDoublewordElements(uint op, ulong imm_factor);

  public static unsafe ulong SaturatingDecrementByNumberOfDoublewordElements(ulong op, ulong imm_factor);

  public static unsafe int SaturatingDecrementByNumberOfDoublewordElements(int op, enum svpattern pattern, ulong imm_factor);

  public static unsafe long SaturatingDecrementByNumberOfDoublewordElements(long op, enum svpattern pattern, ulong imm_factor);

  public static unsafe uint SaturatingDecrementByNumberOfDoublewordElements(uint op, enum svpattern pattern, ulong imm_factor);

  public static unsafe ulong SaturatingDecrementByNumberOfDoublewordElements(ulong op, enum svpattern pattern, ulong imm_factor);

  /// T: long, ulong
  public static unsafe Vector<T> SaturatingDecrementByNumberOfDoublewordElements(Vector<T> op, ulong imm_factor); // SQDECD or UQDECD (MOVPRFX)

  /// T: long, ulong
  public static unsafe Vector<T> SaturatingDecrementByNumberOfDoublewordElements(Vector<T> op, enum svpattern pattern, ulong imm_factor); // SQDECD or UQDECD (MOVPRFX)

  public static unsafe int SaturatingDecrementByNumberOfHalfwordElements(int op, ulong imm_factor);

  public static unsafe long SaturatingDecrementByNumberOfHalfwordElements(long op, ulong imm_factor);

  public static unsafe uint SaturatingDecrementByNumberOfHalfwordElements(uint op, ulong imm_factor);

  public static unsafe ulong SaturatingDecrementByNumberOfHalfwordElements(ulong op, ulong imm_factor);

  public static unsafe int SaturatingDecrementByNumberOfHalfwordElements(int op, enum svpattern pattern, ulong imm_factor);

  public static unsafe long SaturatingDecrementByNumberOfHalfwordElements(long op, enum svpattern pattern, ulong imm_factor);

  public static unsafe uint SaturatingDecrementByNumberOfHalfwordElements(uint op, enum svpattern pattern, ulong imm_factor);

  public static unsafe ulong SaturatingDecrementByNumberOfHalfwordElements(ulong op, enum svpattern pattern, ulong imm_factor);

  /// T: short, ushort
  public static unsafe Vector<T> SaturatingDecrementByNumberOfHalfwordElements(Vector<T> op, ulong imm_factor); // SQDECH or UQDECH (MOVPRFX)

  /// T: short, ushort
  public static unsafe Vector<T> SaturatingDecrementByNumberOfHalfwordElements(Vector<T> op, enum svpattern pattern, ulong imm_factor); // SQDECH or UQDECH (MOVPRFX)

  public static unsafe int SaturatingDecrementByNumberOfWordElements(int op, ulong imm_factor);

  public static unsafe long SaturatingDecrementByNumberOfWordElements(long op, ulong imm_factor);

  public static unsafe uint SaturatingDecrementByNumberOfWordElements(uint op, ulong imm_factor);

  public static unsafe ulong SaturatingDecrementByNumberOfWordElements(ulong op, ulong imm_factor);

  public static unsafe int SaturatingDecrementByNumberOfWordElements(int op, enum svpattern pattern, ulong imm_factor);

  public static unsafe long SaturatingDecrementByNumberOfWordElements(long op, enum svpattern pattern, ulong imm_factor);

  public static unsafe uint SaturatingDecrementByNumberOfWordElements(uint op, enum svpattern pattern, ulong imm_factor);

  public static unsafe ulong SaturatingDecrementByNumberOfWordElements(ulong op, enum svpattern pattern, ulong imm_factor);

  /// T: int, uint
  public static unsafe Vector<T> SaturatingDecrementByNumberOfWordElements(Vector<T> op, ulong imm_factor); // SQDECW or UQDECW (MOVPRFX)

  /// T: int, uint
  public static unsafe Vector<T> SaturatingDecrementByNumberOfWordElements(Vector<T> op, enum svpattern pattern, ulong imm_factor); // SQDECW or UQDECW (MOVPRFX)

  /// T: byte, ushort, uint, ulong
  public static unsafe int SaturatingIncrementByActiveElementCount(int op, Vector<T> mask); // SQINCP

  /// T: byte, ushort, uint, ulong
  public static unsafe long SaturatingIncrementByActiveElementCount(long op, Vector<T> mask); // SQINCP

  /// T: byte, ushort, uint, ulong
  public static unsafe uint SaturatingIncrementByActiveElementCount(uint op, Vector<T> mask); // UQINCP

  /// T: byte, ushort, uint, ulong
  public static unsafe ulong SaturatingIncrementByActiveElementCount(ulong op, Vector<T> mask); // UQINCP

  /// T: short, int, long, ushort, uint, ulong
  public static unsafe Vector<T> SaturatingIncrementByActiveElementCount(Vector<T> op, Vector<T> mask); // SQINCP or UQINCP (MOVPRFX)

  public static unsafe int SaturatingIncrementByNumberOfByteElements(int op, ulong imm_factor);

  public static unsafe long SaturatingIncrementByNumberOfByteElements(long op, ulong imm_factor);

  public static unsafe uint SaturatingIncrementByNumberOfByteElements(uint op, ulong imm_factor);

  public static unsafe ulong SaturatingIncrementByNumberOfByteElements(ulong op, ulong imm_factor);

  public static unsafe int SaturatingIncrementByNumberOfByteElements(int op, enum svpattern pattern, ulong imm_factor);

  public static unsafe long SaturatingIncrementByNumberOfByteElements(long op, enum svpattern pattern, ulong imm_factor);

  public static unsafe uint SaturatingIncrementByNumberOfByteElements(uint op, enum svpattern pattern, ulong imm_factor);

  public static unsafe ulong SaturatingIncrementByNumberOfByteElements(ulong op, enum svpattern pattern, ulong imm_factor);

  public static unsafe int SaturatingIncrementByNumberOfDoublewordElements(int op, ulong imm_factor);

  public static unsafe long SaturatingIncrementByNumberOfDoublewordElements(long op, ulong imm_factor);

  public static unsafe uint SaturatingIncrementByNumberOfDoublewordElements(uint op, ulong imm_factor);

  public static unsafe ulong SaturatingIncrementByNumberOfDoublewordElements(ulong op, ulong imm_factor);

  public static unsafe int SaturatingIncrementByNumberOfDoublewordElements(int op, enum svpattern pattern, ulong imm_factor);

  public static unsafe long SaturatingIncrementByNumberOfDoublewordElements(long op, enum svpattern pattern, ulong imm_factor);

  public static unsafe uint SaturatingIncrementByNumberOfDoublewordElements(uint op, enum svpattern pattern, ulong imm_factor);

  public static unsafe ulong SaturatingIncrementByNumberOfDoublewordElements(ulong op, enum svpattern pattern, ulong imm_factor);

  /// T: long, ulong
  public static unsafe Vector<T> SaturatingIncrementByNumberOfDoublewordElements(Vector<T> op, ulong imm_factor); // SQINCD or UQINCD (MOVPRFX)

  /// T: long, ulong
  public static unsafe Vector<T> SaturatingIncrementByNumberOfDoublewordElements(Vector<T> op, enum svpattern pattern, ulong imm_factor); // SQINCD or UQINCD (MOVPRFX)

  public static unsafe int SaturatingIncrementByNumberOfHalfwordElements(int op, ulong imm_factor);

  public static unsafe long SaturatingIncrementByNumberOfHalfwordElements(long op, ulong imm_factor);

  public static unsafe uint SaturatingIncrementByNumberOfHalfwordElements(uint op, ulong imm_factor);

  public static unsafe ulong SaturatingIncrementByNumberOfHalfwordElements(ulong op, ulong imm_factor);

  public static unsafe int SaturatingIncrementByNumberOfHalfwordElements(int op, enum svpattern pattern, ulong imm_factor);

  public static unsafe long SaturatingIncrementByNumberOfHalfwordElements(long op, enum svpattern pattern, ulong imm_factor);

  public static unsafe uint SaturatingIncrementByNumberOfHalfwordElements(uint op, enum svpattern pattern, ulong imm_factor);

  public static unsafe ulong SaturatingIncrementByNumberOfHalfwordElements(ulong op, enum svpattern pattern, ulong imm_factor);

  /// T: short, ushort
  public static unsafe Vector<T> SaturatingIncrementByNumberOfHalfwordElements(Vector<T> op, ulong imm_factor); // SQINCH or UQINCH (MOVPRFX)

  /// T: short, ushort
  public static unsafe Vector<T> SaturatingIncrementByNumberOfHalfwordElements(Vector<T> op, enum svpattern pattern, ulong imm_factor); // SQINCH or UQINCH (MOVPRFX)

  public static unsafe int SaturatingIncrementByNumberOfWordElements(int op, ulong imm_factor);

  public static unsafe long SaturatingIncrementByNumberOfWordElements(long op, ulong imm_factor);

  public static unsafe uint SaturatingIncrementByNumberOfWordElements(uint op, ulong imm_factor);

  public static unsafe ulong SaturatingIncrementByNumberOfWordElements(ulong op, ulong imm_factor);

  public static unsafe int SaturatingIncrementByNumberOfWordElements(int op, enum svpattern pattern, ulong imm_factor);

  public static unsafe long SaturatingIncrementByNumberOfWordElements(long op, enum svpattern pattern, ulong imm_factor);

  public static unsafe uint SaturatingIncrementByNumberOfWordElements(uint op, enum svpattern pattern, ulong imm_factor);

  public static unsafe ulong SaturatingIncrementByNumberOfWordElements(ulong op, enum svpattern pattern, ulong imm_factor);

  /// T: int, uint
  public static unsafe Vector<T> SaturatingIncrementByNumberOfWordElements(Vector<T> op, ulong imm_factor); // SQINCW or UQINCW (MOVPRFX)

  /// T: int, uint
  public static unsafe Vector<T> SaturatingIncrementByNumberOfWordElements(Vector<T> op, enum svpattern pattern, ulong imm_factor); // SQINCW or UQINCW (MOVPRFX)

  /// total method signatures: 101
}

Author:	a74nh
Assignees:	-
Labels:	area-System.Numerics, untriaged
Milestone:	-

[a74nh]

/// Full API
public abstract class Sve : AdvSimd /// Feature: FEAT_SVE  Category: counting
{
    /// Count16BitElements : Count the number of 16-bit elements in a vector

    /// uint64_t svcnth() : "CNTH Xresult, ALL"
  public static unsafe ulong Count16BitElements();

    /// uint64_t svcnth_pat(enum svpattern pattern) : "CNTH Xresult, pattern"
  public static unsafe ulong Count16BitElements(enum SveMaskPattern pattern);


    /// Count32BitElements : Count the number of 32-bit elements in a vector

    /// uint64_t svcntw() : "CNTW Xresult, ALL"
  public static unsafe ulong Count32BitElements();

    /// uint64_t svcntw_pat(enum svpattern pattern) : "CNTW Xresult, pattern"
  public static unsafe ulong Count32BitElements(enum SveMaskPattern pattern);


    /// Count64BitElements : Count the number of 64-bit elements in a vector

    /// uint64_t svcntd() : "CNTD Xresult, ALL"
  public static unsafe ulong Count64BitElements();

    /// uint64_t svcntd_pat(enum svpattern pattern) : "CNTD Xresult, pattern"
  public static unsafe ulong Count64BitElements(enum SveMaskPattern pattern);


    /// Count8BitElements : Count the number of 8-bit elements in a vector

    /// uint64_t svcntb() : "CNTB Xresult, ALL"
  public static unsafe ulong Count8BitElements();

    /// uint64_t svcntb_pat(enum svpattern pattern) : "CNTB Xresult, pattern"
  public static unsafe ulong Count8BitElements(enum SveMaskPattern pattern);


    /// GetActiveElementCount : Count set predicate bits

    /// uint64_t svcntp_b8(svbool_t pg, svbool_t op) : "CNTP Xresult, Pg, Pop.B"
  public static unsafe ulong GetActiveElementCount(Vector<byte> mask, Vector<byte> select);

    /// uint64_t svcntp_b16(svbool_t pg, svbool_t op) : "CNTP Xresult, Pg, Pop.H"
  public static unsafe ulong GetActiveElementCount(Vector<ushort> mask, Vector<ushort> select);

    /// uint64_t svcntp_b32(svbool_t pg, svbool_t op) : "CNTP Xresult, Pg, Pop.S"
  public static unsafe ulong GetActiveElementCount(Vector<uint> mask, Vector<uint> select);

    /// uint64_t svcntp_b64(svbool_t pg, svbool_t op) : "CNTP Xresult, Pg, Pop.D"
  public static unsafe ulong GetActiveElementCount(Vector<ulong> mask, Vector<ulong> select);


    /// LeadingSignCount : Count leading sign bits

    /// svuint8_t svcls[_s8]_m(svuint8_t inactive, svbool_t pg, svint8_t op) : "CLS Ztied.B, Pg/M, Zop.B" or "MOVPRFX Zresult, Zinactive; CLS Zresult.B, Pg/M, Zop.B"
    /// svuint8_t svcls[_s8]_x(svbool_t pg, svint8_t op) : "CLS Ztied.B, Pg/M, Ztied.B" or "MOVPRFX Zresult, Zop; CLS Zresult.B, Pg/M, Zop.B"
    /// svuint8_t svcls[_s8]_z(svbool_t pg, svint8_t op) : "MOVPRFX Zresult.B, Pg/Z, Zop.B; CLS Zresult.B, Pg/M, Zop.B"
  public static unsafe Vector<byte> LeadingSignCount(Vector<sbyte> value);

    /// svuint16_t svcls[_s16]_m(svuint16_t inactive, svbool_t pg, svint16_t op) : "CLS Ztied.H, Pg/M, Zop.H" or "MOVPRFX Zresult, Zinactive; CLS Zresult.H, Pg/M, Zop.H"
    /// svuint16_t svcls[_s16]_x(svbool_t pg, svint16_t op) : "CLS Ztied.H, Pg/M, Ztied.H" or "MOVPRFX Zresult, Zop; CLS Zresult.H, Pg/M, Zop.H"
    /// svuint16_t svcls[_s16]_z(svbool_t pg, svint16_t op) : "MOVPRFX Zresult.H, Pg/Z, Zop.H; CLS Zresult.H, Pg/M, Zop.H"
  public static unsafe Vector<ushort> LeadingSignCount(Vector<short> value);

    /// svuint32_t svcls[_s32]_m(svuint32_t inactive, svbool_t pg, svint32_t op) : "CLS Ztied.S, Pg/M, Zop.S" or "MOVPRFX Zresult, Zinactive; CLS Zresult.S, Pg/M, Zop.S"
    /// svuint32_t svcls[_s32]_x(svbool_t pg, svint32_t op) : "CLS Ztied.S, Pg/M, Ztied.S" or "MOVPRFX Zresult, Zop; CLS Zresult.S, Pg/M, Zop.S"
    /// svuint32_t svcls[_s32]_z(svbool_t pg, svint32_t op) : "MOVPRFX Zresult.S, Pg/Z, Zop.S; CLS Zresult.S, Pg/M, Zop.S"
  public static unsafe Vector<uint> LeadingSignCount(Vector<int> value);

    /// svuint64_t svcls[_s64]_m(svuint64_t inactive, svbool_t pg, svint64_t op) : "CLS Ztied.D, Pg/M, Zop.D" or "MOVPRFX Zresult, Zinactive; CLS Zresult.D, Pg/M, Zop.D"
    /// svuint64_t svcls[_s64]_x(svbool_t pg, svint64_t op) : "CLS Ztied.D, Pg/M, Ztied.D" or "MOVPRFX Zresult, Zop; CLS Zresult.D, Pg/M, Zop.D"
    /// svuint64_t svcls[_s64]_z(svbool_t pg, svint64_t op) : "MOVPRFX Zresult.D, Pg/Z, Zop.D; CLS Zresult.D, Pg/M, Zop.D"
  public static unsafe Vector<ulong> LeadingSignCount(Vector<long> value);


    /// LeadingZeroCount : Count leading zero bits

    /// svuint8_t svclz[_s8]_m(svuint8_t inactive, svbool_t pg, svint8_t op) : "CLZ Ztied.B, Pg/M, Zop.B" or "MOVPRFX Zresult, Zinactive; CLZ Zresult.B, Pg/M, Zop.B"
    /// svuint8_t svclz[_s8]_x(svbool_t pg, svint8_t op) : "CLZ Ztied.B, Pg/M, Ztied.B" or "MOVPRFX Zresult, Zop; CLZ Zresult.B, Pg/M, Zop.B"
    /// svuint8_t svclz[_s8]_z(svbool_t pg, svint8_t op) : "MOVPRFX Zresult.B, Pg/Z, Zop.B; CLZ Zresult.B, Pg/M, Zop.B"
  public static unsafe Vector<byte> LeadingZeroCount(Vector<sbyte> value);

    /// svuint16_t svclz[_s16]_m(svuint16_t inactive, svbool_t pg, svint16_t op) : "CLZ Ztied.H, Pg/M, Zop.H" or "MOVPRFX Zresult, Zinactive; CLZ Zresult.H, Pg/M, Zop.H"
    /// svuint16_t svclz[_s16]_x(svbool_t pg, svint16_t op) : "CLZ Ztied.H, Pg/M, Ztied.H" or "MOVPRFX Zresult, Zop; CLZ Zresult.H, Pg/M, Zop.H"
    /// svuint16_t svclz[_s16]_z(svbool_t pg, svint16_t op) : "MOVPRFX Zresult.H, Pg/Z, Zop.H; CLZ Zresult.H, Pg/M, Zop.H"
  public static unsafe Vector<ushort> LeadingZeroCount(Vector<short> value);

    /// svuint32_t svclz[_s32]_m(svuint32_t inactive, svbool_t pg, svint32_t op) : "CLZ Ztied.S, Pg/M, Zop.S" or "MOVPRFX Zresult, Zinactive; CLZ Zresult.S, Pg/M, Zop.S"
    /// svuint32_t svclz[_s32]_x(svbool_t pg, svint32_t op) : "CLZ Ztied.S, Pg/M, Ztied.S" or "MOVPRFX Zresult, Zop; CLZ Zresult.S, Pg/M, Zop.S"
    /// svuint32_t svclz[_s32]_z(svbool_t pg, svint32_t op) : "MOVPRFX Zresult.S, Pg/Z, Zop.S; CLZ Zresult.S, Pg/M, Zop.S"
  public static unsafe Vector<uint> LeadingZeroCount(Vector<int> value);

    /// svuint64_t svclz[_s64]_m(svuint64_t inactive, svbool_t pg, svint64_t op) : "CLZ Ztied.D, Pg/M, Zop.D" or "MOVPRFX Zresult, Zinactive; CLZ Zresult.D, Pg/M, Zop.D"
    /// svuint64_t svclz[_s64]_x(svbool_t pg, svint64_t op) : "CLZ Ztied.D, Pg/M, Ztied.D" or "MOVPRFX Zresult, Zop; CLZ Zresult.D, Pg/M, Zop.D"
    /// svuint64_t svclz[_s64]_z(svbool_t pg, svint64_t op) : "MOVPRFX Zresult.D, Pg/Z, Zop.D; CLZ Zresult.D, Pg/M, Zop.D"
  public static unsafe Vector<ulong> LeadingZeroCount(Vector<long> value);

    /// svuint8_t svclz[_u8]_m(svuint8_t inactive, svbool_t pg, svuint8_t op) : "CLZ Ztied.B, Pg/M, Zop.B" or "MOVPRFX Zresult, Zinactive; CLZ Zresult.B, Pg/M, Zop.B"
    /// svuint8_t svclz[_u8]_x(svbool_t pg, svuint8_t op) : "CLZ Ztied.B, Pg/M, Ztied.B" or "MOVPRFX Zresult, Zop; CLZ Zresult.B, Pg/M, Zop.B"
    /// svuint8_t svclz[_u8]_z(svbool_t pg, svuint8_t op) : "MOVPRFX Zresult.B, Pg/Z, Zop.B; CLZ Zresult.B, Pg/M, Zop.B"
  public static unsafe Vector<byte> LeadingZeroCount(Vector<byte> value);

    /// svuint16_t svclz[_u16]_m(svuint16_t inactive, svbool_t pg, svuint16_t op) : "CLZ Ztied.H, Pg/M, Zop.H" or "MOVPRFX Zresult, Zinactive; CLZ Zresult.H, Pg/M, Zop.H"
    /// svuint16_t svclz[_u16]_x(svbool_t pg, svuint16_t op) : "CLZ Ztied.H, Pg/M, Ztied.H" or "MOVPRFX Zresult, Zop; CLZ Zresult.H, Pg/M, Zop.H"
    /// svuint16_t svclz[_u16]_z(svbool_t pg, svuint16_t op) : "MOVPRFX Zresult.H, Pg/Z, Zop.H; CLZ Zresult.H, Pg/M, Zop.H"
  public static unsafe Vector<ushort> LeadingZeroCount(Vector<ushort> value);

    /// svuint32_t svclz[_u32]_m(svuint32_t inactive, svbool_t pg, svuint32_t op) : "CLZ Ztied.S, Pg/M, Zop.S" or "MOVPRFX Zresult, Zinactive; CLZ Zresult.S, Pg/M, Zop.S"
    /// svuint32_t svclz[_u32]_x(svbool_t pg, svuint32_t op) : "CLZ Ztied.S, Pg/M, Ztied.S" or "MOVPRFX Zresult, Zop; CLZ Zresult.S, Pg/M, Zop.S"
    /// svuint32_t svclz[_u32]_z(svbool_t pg, svuint32_t op) : "MOVPRFX Zresult.S, Pg/Z, Zop.S; CLZ Zresult.S, Pg/M, Zop.S"
  public static unsafe Vector<uint> LeadingZeroCount(Vector<uint> value);

    /// svuint64_t svclz[_u64]_m(svuint64_t inactive, svbool_t pg, svuint64_t op) : "CLZ Ztied.D, Pg/M, Zop.D" or "MOVPRFX Zresult, Zinactive; CLZ Zresult.D, Pg/M, Zop.D"
    /// svuint64_t svclz[_u64]_x(svbool_t pg, svuint64_t op) : "CLZ Ztied.D, Pg/M, Ztied.D" or "MOVPRFX Zresult, Zop; CLZ Zresult.D, Pg/M, Zop.D"
    /// svuint64_t svclz[_u64]_z(svbool_t pg, svuint64_t op) : "MOVPRFX Zresult.D, Pg/Z, Zop.D; CLZ Zresult.D, Pg/M, Zop.D"
  public static unsafe Vector<ulong> LeadingZeroCount(Vector<ulong> value);


    /// PopCount : Count nonzero bits

    /// svuint32_t svcnt[_f32]_m(svuint32_t inactive, svbool_t pg, svfloat32_t op) : "CNT Ztied.S, Pg/M, Zop.S" or "MOVPRFX Zresult, Zinactive; CNT Zresult.S, Pg/M, Zop.S"
    /// svuint32_t svcnt[_f32]_x(svbool_t pg, svfloat32_t op) : "CNT Ztied.S, Pg/M, Ztied.S" or "MOVPRFX Zresult, Zop; CNT Zresult.S, Pg/M, Zop.S"
    /// svuint32_t svcnt[_f32]_z(svbool_t pg, svfloat32_t op) : "MOVPRFX Zresult.S, Pg/Z, Zop.S; CNT Zresult.S, Pg/M, Zop.S"
  public static unsafe Vector<uint> PopCount(Vector<float> value);

    /// svuint64_t svcnt[_f64]_m(svuint64_t inactive, svbool_t pg, svfloat64_t op) : "CNT Ztied.D, Pg/M, Zop.D" or "MOVPRFX Zresult, Zinactive; CNT Zresult.D, Pg/M, Zop.D"
    /// svuint64_t svcnt[_f64]_x(svbool_t pg, svfloat64_t op) : "CNT Ztied.D, Pg/M, Ztied.D" or "MOVPRFX Zresult, Zop; CNT Zresult.D, Pg/M, Zop.D"
    /// svuint64_t svcnt[_f64]_z(svbool_t pg, svfloat64_t op) : "MOVPRFX Zresult.D, Pg/Z, Zop.D; CNT Zresult.D, Pg/M, Zop.D"
  public static unsafe Vector<ulong> PopCount(Vector<double> value);

    /// svuint8_t svcnt[_s8]_m(svuint8_t inactive, svbool_t pg, svint8_t op) : "CNT Ztied.B, Pg/M, Zop.B" or "MOVPRFX Zresult, Zinactive; CNT Zresult.B, Pg/M, Zop.B"
    /// svuint8_t svcnt[_s8]_x(svbool_t pg, svint8_t op) : "CNT Ztied.B, Pg/M, Ztied.B" or "MOVPRFX Zresult, Zop; CNT Zresult.B, Pg/M, Zop.B"
    /// svuint8_t svcnt[_s8]_z(svbool_t pg, svint8_t op) : "MOVPRFX Zresult.B, Pg/Z, Zop.B; CNT Zresult.B, Pg/M, Zop.B"
  public static unsafe Vector<byte> PopCount(Vector<sbyte> value);

    /// svuint16_t svcnt[_s16]_m(svuint16_t inactive, svbool_t pg, svint16_t op) : "CNT Ztied.H, Pg/M, Zop.H" or "MOVPRFX Zresult, Zinactive; CNT Zresult.H, Pg/M, Zop.H"
    /// svuint16_t svcnt[_s16]_x(svbool_t pg, svint16_t op) : "CNT Ztied.H, Pg/M, Ztied.H" or "MOVPRFX Zresult, Zop; CNT Zresult.H, Pg/M, Zop.H"
    /// svuint16_t svcnt[_s16]_z(svbool_t pg, svint16_t op) : "MOVPRFX Zresult.H, Pg/Z, Zop.H; CNT Zresult.H, Pg/M, Zop.H"
  public static unsafe Vector<ushort> PopCount(Vector<short> value);

    /// svuint32_t svcnt[_s32]_m(svuint32_t inactive, svbool_t pg, svint32_t op) : "CNT Ztied.S, Pg/M, Zop.S" or "MOVPRFX Zresult, Zinactive; CNT Zresult.S, Pg/M, Zop.S"
    /// svuint32_t svcnt[_s32]_x(svbool_t pg, svint32_t op) : "CNT Ztied.S, Pg/M, Ztied.S" or "MOVPRFX Zresult, Zop; CNT Zresult.S, Pg/M, Zop.S"
    /// svuint32_t svcnt[_s32]_z(svbool_t pg, svint32_t op) : "MOVPRFX Zresult.S, Pg/Z, Zop.S; CNT Zresult.S, Pg/M, Zop.S"
  public static unsafe Vector<uint> PopCount(Vector<int> value);

    /// svuint64_t svcnt[_s64]_m(svuint64_t inactive, svbool_t pg, svint64_t op) : "CNT Ztied.D, Pg/M, Zop.D" or "MOVPRFX Zresult, Zinactive; CNT Zresult.D, Pg/M, Zop.D"
    /// svuint64_t svcnt[_s64]_x(svbool_t pg, svint64_t op) : "CNT Ztied.D, Pg/M, Ztied.D" or "MOVPRFX Zresult, Zop; CNT Zresult.D, Pg/M, Zop.D"
    /// svuint64_t svcnt[_s64]_z(svbool_t pg, svint64_t op) : "MOVPRFX Zresult.D, Pg/Z, Zop.D; CNT Zresult.D, Pg/M, Zop.D"
  public static unsafe Vector<ulong> PopCount(Vector<long> value);

    /// svuint8_t svcnt[_u8]_m(svuint8_t inactive, svbool_t pg, svuint8_t op) : "CNT Ztied.B, Pg/M, Zop.B" or "MOVPRFX Zresult, Zinactive; CNT Zresult.B, Pg/M, Zop.B"
    /// svuint8_t svcnt[_u8]_x(svbool_t pg, svuint8_t op) : "CNT Ztied.B, Pg/M, Ztied.B" or "MOVPRFX Zresult, Zop; CNT Zresult.B, Pg/M, Zop.B"
    /// svuint8_t svcnt[_u8]_z(svbool_t pg, svuint8_t op) : "MOVPRFX Zresult.B, Pg/Z, Zop.B; CNT Zresult.B, Pg/M, Zop.B"
  public static unsafe Vector<byte> PopCount(Vector<byte> value);

    /// svuint16_t svcnt[_u16]_m(svuint16_t inactive, svbool_t pg, svuint16_t op) : "CNT Ztied.H, Pg/M, Zop.H" or "MOVPRFX Zresult, Zinactive; CNT Zresult.H, Pg/M, Zop.H"
    /// svuint16_t svcnt[_u16]_x(svbool_t pg, svuint16_t op) : "CNT Ztied.H, Pg/M, Ztied.H" or "MOVPRFX Zresult, Zop; CNT Zresult.H, Pg/M, Zop.H"
    /// svuint16_t svcnt[_u16]_z(svbool_t pg, svuint16_t op) : "MOVPRFX Zresult.H, Pg/Z, Zop.H; CNT Zresult.H, Pg/M, Zop.H"
  public static unsafe Vector<ushort> PopCount(Vector<ushort> value);

    /// svuint32_t svcnt[_u32]_m(svuint32_t inactive, svbool_t pg, svuint32_t op) : "CNT Ztied.S, Pg/M, Zop.S" or "MOVPRFX Zresult, Zinactive; CNT Zresult.S, Pg/M, Zop.S"
    /// svuint32_t svcnt[_u32]_x(svbool_t pg, svuint32_t op) : "CNT Ztied.S, Pg/M, Ztied.S" or "MOVPRFX Zresult, Zop; CNT Zresult.S, Pg/M, Zop.S"
    /// svuint32_t svcnt[_u32]_z(svbool_t pg, svuint32_t op) : "MOVPRFX Zresult.S, Pg/Z, Zop.S; CNT Zresult.S, Pg/M, Zop.S"
  public static unsafe Vector<uint> PopCount(Vector<uint> value);

    /// svuint64_t svcnt[_u64]_m(svuint64_t inactive, svbool_t pg, svuint64_t op) : "CNT Ztied.D, Pg/M, Zop.D" or "MOVPRFX Zresult, Zinactive; CNT Zresult.D, Pg/M, Zop.D"
    /// svuint64_t svcnt[_u64]_x(svbool_t pg, svuint64_t op) : "CNT Ztied.D, Pg/M, Ztied.D" or "MOVPRFX Zresult, Zop; CNT Zresult.D, Pg/M, Zop.D"
    /// svuint64_t svcnt[_u64]_z(svbool_t pg, svuint64_t op) : "MOVPRFX Zresult.D, Pg/Z, Zop.D; CNT Zresult.D, Pg/M, Zop.D"
  public static unsafe Vector<ulong> PopCount(Vector<ulong> value);


    /// SaturatingDecrementByActiveElementCount : Saturating decrement by active element count

    /// int32_t svqdecp[_n_s32]_b8(int32_t op, svbool_t pg) : "SQDECP Xtied, Pg.B, Wtied"
  public static unsafe int SaturatingDecrementByActiveElementCount(int op, Vector<byte> select);

    /// int32_t svqdecp[_n_s32]_b16(int32_t op, svbool_t pg) : "SQDECP Xtied, Pg.H, Wtied"
  public static unsafe int SaturatingDecrementByActiveElementCount(int op, Vector<ushort> select);

    /// int32_t svqdecp[_n_s32]_b32(int32_t op, svbool_t pg) : "SQDECP Xtied, Pg.S, Wtied"
  public static unsafe int SaturatingDecrementByActiveElementCount(int op, Vector<uint> select);

    /// int32_t svqdecp[_n_s32]_b64(int32_t op, svbool_t pg) : "SQDECP Xtied, Pg.D, Wtied"
  public static unsafe int SaturatingDecrementByActiveElementCount(int op, Vector<ulong> select);

    /// int64_t svqdecp[_n_s64]_b8(int64_t op, svbool_t pg) : "SQDECP Xtied, Pg.B"
  public static unsafe long SaturatingDecrementByActiveElementCount(long op, Vector<byte> select);

    /// int64_t svqdecp[_n_s64]_b16(int64_t op, svbool_t pg) : "SQDECP Xtied, Pg.H"
  public static unsafe long SaturatingDecrementByActiveElementCount(long op, Vector<ushort> select);

    /// int64_t svqdecp[_n_s64]_b32(int64_t op, svbool_t pg) : "SQDECP Xtied, Pg.S"
  public static unsafe long SaturatingDecrementByActiveElementCount(long op, Vector<uint> select);

    /// int64_t svqdecp[_n_s64]_b64(int64_t op, svbool_t pg) : "SQDECP Xtied, Pg.D"
  public static unsafe long SaturatingDecrementByActiveElementCount(long op, Vector<ulong> select);

    /// uint32_t svqdecp[_n_u32]_b8(uint32_t op, svbool_t pg) : "UQDECP Wtied, Pg.B"
  public static unsafe uint SaturatingDecrementByActiveElementCount(uint op, Vector<byte> select);

    /// uint32_t svqdecp[_n_u32]_b16(uint32_t op, svbool_t pg) : "UQDECP Wtied, Pg.H"
  public static unsafe uint SaturatingDecrementByActiveElementCount(uint op, Vector<ushort> select);

    /// uint32_t svqdecp[_n_u32]_b32(uint32_t op, svbool_t pg) : "UQDECP Wtied, Pg.S"
  public static unsafe uint SaturatingDecrementByActiveElementCount(uint op, Vector<uint> select);

    /// uint32_t svqdecp[_n_u32]_b64(uint32_t op, svbool_t pg) : "UQDECP Wtied, Pg.D"
  public static unsafe uint SaturatingDecrementByActiveElementCount(uint op, Vector<ulong> select);

    /// uint64_t svqdecp[_n_u64]_b8(uint64_t op, svbool_t pg) : "UQDECP Xtied, Pg.B"
  public static unsafe ulong SaturatingDecrementByActiveElementCount(ulong op, Vector<byte> select);

    /// uint64_t svqdecp[_n_u64]_b16(uint64_t op, svbool_t pg) : "UQDECP Xtied, Pg.H"
  public static unsafe ulong SaturatingDecrementByActiveElementCount(ulong op, Vector<ushort> select);

    /// uint64_t svqdecp[_n_u64]_b32(uint64_t op, svbool_t pg) : "UQDECP Xtied, Pg.S"
  public static unsafe ulong SaturatingDecrementByActiveElementCount(ulong op, Vector<uint> select);

    /// uint64_t svqdecp[_n_u64]_b64(uint64_t op, svbool_t pg) : "UQDECP Xtied, Pg.D"
  public static unsafe ulong SaturatingDecrementByActiveElementCount(ulong op, Vector<ulong> select);

    /// svint16_t svqdecp[_s16](svint16_t op, svbool_t pg) : "SQDECP Ztied.H, Pg" or "MOVPRFX Zresult, Zop; SQDECP Zresult.H, Pg"
  public static unsafe Vector<short> SaturatingDecrementByActiveElementCount(Vector<short> op, Vector<short> select);

    /// svint32_t svqdecp[_s32](svint32_t op, svbool_t pg) : "SQDECP Ztied.S, Pg" or "MOVPRFX Zresult, Zop; SQDECP Zresult.S, Pg"
  public static unsafe Vector<int> SaturatingDecrementByActiveElementCount(Vector<int> op, Vector<int> select);

    /// svint64_t svqdecp[_s64](svint64_t op, svbool_t pg) : "SQDECP Ztied.D, Pg" or "MOVPRFX Zresult, Zop; SQDECP Zresult.D, Pg"
  public static unsafe Vector<long> SaturatingDecrementByActiveElementCount(Vector<long> op, Vector<long> select);

    /// svuint16_t svqdecp[_u16](svuint16_t op, svbool_t pg) : "UQDECP Ztied.H, Pg" or "MOVPRFX Zresult, Zop; UQDECP Zresult.H, Pg"
  public static unsafe Vector<ushort> SaturatingDecrementByActiveElementCount(Vector<ushort> op, Vector<ushort> select);

    /// svuint32_t svqdecp[_u32](svuint32_t op, svbool_t pg) : "UQDECP Ztied.S, Pg" or "MOVPRFX Zresult, Zop; UQDECP Zresult.S, Pg"
  public static unsafe Vector<uint> SaturatingDecrementByActiveElementCount(Vector<uint> op, Vector<uint> select);

    /// svuint64_t svqdecp[_u64](svuint64_t op, svbool_t pg) : "UQDECP Ztied.D, Pg" or "MOVPRFX Zresult, Zop; UQDECP Zresult.D, Pg"
  public static unsafe Vector<ulong> SaturatingDecrementByActiveElementCount(Vector<ulong> op, Vector<ulong> select);


    /// SaturatingDecrementByteElementCount : Saturating decrement by number of byte elements

    /// int32_t svqdecb[_n_s32](int32_t op, uint64_t imm_factor) : "SQDECB Xtied, Wtied, ALL, MUL #imm_factor"
  public static unsafe int SaturatingDecrementByteElementCount(int op, ulong imm_factor);

    /// int64_t svqdecb[_n_s64](int64_t op, uint64_t imm_factor) : "SQDECB Xtied, ALL, MUL #imm_factor"
  public static unsafe long SaturatingDecrementByteElementCount(long op, ulong imm_factor);

    /// uint32_t svqdecb[_n_u32](uint32_t op, uint64_t imm_factor) : "UQDECB Wtied, ALL, MUL #imm_factor"
  public static unsafe uint SaturatingDecrementByteElementCount(uint op, ulong imm_factor);

    /// uint64_t svqdecb[_n_u64](uint64_t op, uint64_t imm_factor) : "UQDECB Xtied, ALL, MUL #imm_factor"
  public static unsafe ulong SaturatingDecrementByteElementCount(ulong op, ulong imm_factor);

    /// int32_t svqdecb_pat[_n_s32](int32_t op, enum svpattern pattern, uint64_t imm_factor) : "SQDECB Xtied, Wtied, pattern, MUL #imm_factor"
  public static unsafe int SaturatingDecrementByteElementCount(int op, enum SveMaskPattern pattern, ulong imm_factor);

    /// int64_t svqdecb_pat[_n_s64](int64_t op, enum svpattern pattern, uint64_t imm_factor) : "SQDECB Xtied, pattern, MUL #imm_factor"
  public static unsafe long SaturatingDecrementByteElementCount(long op, enum SveMaskPattern pattern, ulong imm_factor);

    /// uint32_t svqdecb_pat[_n_u32](uint32_t op, enum svpattern pattern, uint64_t imm_factor) : "UQDECB Wtied, pattern, MUL #imm_factor"
  public static unsafe uint SaturatingDecrementByteElementCount(uint op, enum SveMaskPattern pattern, ulong imm_factor);

    /// uint64_t svqdecb_pat[_n_u64](uint64_t op, enum svpattern pattern, uint64_t imm_factor) : "UQDECB Xtied, pattern, MUL #imm_factor"
  public static unsafe ulong SaturatingDecrementByteElementCount(ulong op, enum SveMaskPattern pattern, ulong imm_factor);


    /// SaturatingDecrementInt16ElementCount : Saturating decrement by number of halfword elements

    /// int32_t svqdech[_n_s32](int32_t op, uint64_t imm_factor) : "SQDECH Xtied, Wtied, ALL, MUL #imm_factor"
  public static unsafe int SaturatingDecrementInt16ElementCount(int op, ulong imm_factor);

    /// int64_t svqdech[_n_s64](int64_t op, uint64_t imm_factor) : "SQDECH Xtied, ALL, MUL #imm_factor"
  public static unsafe long SaturatingDecrementInt16ElementCount(long op, ulong imm_factor);

    /// uint32_t svqdech[_n_u32](uint32_t op, uint64_t imm_factor) : "UQDECH Wtied, ALL, MUL #imm_factor"
  public static unsafe uint SaturatingDecrementInt16ElementCount(uint op, ulong imm_factor);

    /// uint64_t svqdech[_n_u64](uint64_t op, uint64_t imm_factor) : "UQDECH Xtied, ALL, MUL #imm_factor"
  public static unsafe ulong SaturatingDecrementInt16ElementCount(ulong op, ulong imm_factor);

    /// int32_t svqdech_pat[_n_s32](int32_t op, enum svpattern pattern, uint64_t imm_factor) : "SQDECH Xtied, Wtied, pattern, MUL #imm_factor"
  public static unsafe int SaturatingDecrementInt16ElementCount(int op, enum SveMaskPattern pattern, ulong imm_factor);

    /// int64_t svqdech_pat[_n_s64](int64_t op, enum svpattern pattern, uint64_t imm_factor) : "SQDECH Xtied, pattern, MUL #imm_factor"
  public static unsafe long SaturatingDecrementInt16ElementCount(long op, enum SveMaskPattern pattern, ulong imm_factor);

    /// uint32_t svqdech_pat[_n_u32](uint32_t op, enum svpattern pattern, uint64_t imm_factor) : "UQDECH Wtied, pattern, MUL #imm_factor"
  public static unsafe uint SaturatingDecrementInt16ElementCount(uint op, enum SveMaskPattern pattern, ulong imm_factor);

    /// uint64_t svqdech_pat[_n_u64](uint64_t op, enum svpattern pattern, uint64_t imm_factor) : "UQDECH Xtied, pattern, MUL #imm_factor"
  public static unsafe ulong SaturatingDecrementInt16ElementCount(ulong op, enum SveMaskPattern pattern, ulong imm_factor);

    /// svint16_t svqdech[_s16](svint16_t op, uint64_t imm_factor) : "SQDECH Ztied.H, ALL, MUL #imm_factor" or "MOVPRFX Zresult, Zop; SQDECH Zresult.H, ALL, MUL #imm_factor"
  public static unsafe Vector<short> SaturatingDecrementInt16ElementCount(Vector<short> op, ulong imm_factor);

    /// svuint16_t svqdech[_u16](svuint16_t op, uint64_t imm_factor) : "UQDECH Ztied.H, ALL, MUL #imm_factor" or "MOVPRFX Zresult, Zop; UQDECH Zresult.H, ALL, MUL #imm_factor"
  public static unsafe Vector<ushort> SaturatingDecrementInt16ElementCount(Vector<ushort> op, ulong imm_factor);

    /// svint16_t svqdech_pat[_s16](svint16_t op, enum svpattern pattern, uint64_t imm_factor) : "SQDECH Ztied.H, pattern, MUL #imm_factor" or "MOVPRFX Zresult, Zop; SQDECH Zresult.H, pattern, MUL #imm_factor"
  public static unsafe Vector<short> SaturatingDecrementInt16ElementCount(Vector<short> op, enum SveMaskPattern pattern, ulong imm_factor);

    /// svuint16_t svqdech_pat[_u16](svuint16_t op, enum svpattern pattern, uint64_t imm_factor) : "UQDECH Ztied.H, pattern, MUL #imm_factor" or "MOVPRFX Zresult, Zop; UQDECH Zresult.H, pattern, MUL #imm_factor"
  public static unsafe Vector<ushort> SaturatingDecrementInt16ElementCount(Vector<ushort> op, enum SveMaskPattern pattern, ulong imm_factor);


    /// SaturatingDecrementInt32ElementCount : Saturating decrement by number of word elements

    /// int32_t svqdecw[_n_s32](int32_t op, uint64_t imm_factor) : "SQDECW Xtied, Wtied, ALL, MUL #imm_factor"
  public static unsafe int SaturatingDecrementInt32ElementCount(int op, ulong imm_factor);

    /// int64_t svqdecw[_n_s64](int64_t op, uint64_t imm_factor) : "SQDECW Xtied, ALL, MUL #imm_factor"
  public static unsafe long SaturatingDecrementInt32ElementCount(long op, ulong imm_factor);

    /// uint32_t svqdecw[_n_u32](uint32_t op, uint64_t imm_factor) : "UQDECW Wtied, ALL, MUL #imm_factor"
  public static unsafe uint SaturatingDecrementInt32ElementCount(uint op, ulong imm_factor);

    /// uint64_t svqdecw[_n_u64](uint64_t op, uint64_t imm_factor) : "UQDECW Xtied, ALL, MUL #imm_factor"
  public static unsafe ulong SaturatingDecrementInt32ElementCount(ulong op, ulong imm_factor);

    /// int32_t svqdecw_pat[_n_s32](int32_t op, enum svpattern pattern, uint64_t imm_factor) : "SQDECW Xtied, Wtied, pattern, MUL #imm_factor"
  public static unsafe int SaturatingDecrementInt32ElementCount(int op, enum SveMaskPattern pattern, ulong imm_factor);

    /// int64_t svqdecw_pat[_n_s64](int64_t op, enum svpattern pattern, uint64_t imm_factor) : "SQDECW Xtied, pattern, MUL #imm_factor"
  public static unsafe long SaturatingDecrementInt32ElementCount(long op, enum SveMaskPattern pattern, ulong imm_factor);

    /// uint32_t svqdecw_pat[_n_u32](uint32_t op, enum svpattern pattern, uint64_t imm_factor) : "UQDECW Wtied, pattern, MUL #imm_factor"
  public static unsafe uint SaturatingDecrementInt32ElementCount(uint op, enum SveMaskPattern pattern, ulong imm_factor);

    /// uint64_t svqdecw_pat[_n_u64](uint64_t op, enum svpattern pattern, uint64_t imm_factor) : "UQDECW Xtied, pattern, MUL #imm_factor"
  public static unsafe ulong SaturatingDecrementInt32ElementCount(ulong op, enum SveMaskPattern pattern, ulong imm_factor);

    /// svint32_t svqdecw[_s32](svint32_t op, uint64_t imm_factor) : "SQDECW Ztied.S, ALL, MUL #imm_factor" or "MOVPRFX Zresult, Zop; SQDECW Zresult.S, ALL, MUL #imm_factor"
  public static unsafe Vector<int> SaturatingDecrementInt32ElementCount(Vector<int> op, ulong imm_factor);

    /// svuint32_t svqdecw[_u32](svuint32_t op, uint64_t imm_factor) : "UQDECW Ztied.S, ALL, MUL #imm_factor" or "MOVPRFX Zresult, Zop; UQDECW Zresult.S, ALL, MUL #imm_factor"
  public static unsafe Vector<uint> SaturatingDecrementInt32ElementCount(Vector<uint> op, ulong imm_factor);

    /// svint32_t svqdecw_pat[_s32](svint32_t op, enum svpattern pattern, uint64_t imm_factor) : "SQDECW Ztied.S, pattern, MUL #imm_factor" or "MOVPRFX Zresult, Zop; SQDECW Zresult.S, pattern, MUL #imm_factor"
  public static unsafe Vector<int> SaturatingDecrementInt32ElementCount(Vector<int> op, enum SveMaskPattern pattern, ulong imm_factor);

    /// svuint32_t svqdecw_pat[_u32](svuint32_t op, enum svpattern pattern, uint64_t imm_factor) : "UQDECW Ztied.S, pattern, MUL #imm_factor" or "MOVPRFX Zresult, Zop; UQDECW Zresult.S, pattern, MUL #imm_factor"
  public static unsafe Vector<uint> SaturatingDecrementInt32ElementCount(Vector<uint> op, enum SveMaskPattern pattern, ulong imm_factor);


    /// SaturatingDecrementInt64ElementCount : Saturating decrement by number of doubleword elements

    /// int32_t svqdecd[_n_s32](int32_t op, uint64_t imm_factor) : "SQDECD Xtied, Wtied, ALL, MUL #imm_factor"
  public static unsafe int SaturatingDecrementInt64ElementCount(int op, ulong imm_factor);

    /// int64_t svqdecd[_n_s64](int64_t op, uint64_t imm_factor) : "SQDECD Xtied, ALL, MUL #imm_factor"
  public static unsafe long SaturatingDecrementInt64ElementCount(long op, ulong imm_factor);

    /// uint32_t svqdecd[_n_u32](uint32_t op, uint64_t imm_factor) : "UQDECD Wtied, ALL, MUL #imm_factor"
  public static unsafe uint SaturatingDecrementInt64ElementCount(uint op, ulong imm_factor);

    /// uint64_t svqdecd[_n_u64](uint64_t op, uint64_t imm_factor) : "UQDECD Xtied, ALL, MUL #imm_factor"
  public static unsafe ulong SaturatingDecrementInt64ElementCount(ulong op, ulong imm_factor);

    /// int32_t svqdecd_pat[_n_s32](int32_t op, enum svpattern pattern, uint64_t imm_factor) : "SQDECD Xtied, Wtied, pattern, MUL #imm_factor"
  public static unsafe int SaturatingDecrementInt64ElementCount(int op, enum SveMaskPattern pattern, ulong imm_factor);

    /// int64_t svqdecd_pat[_n_s64](int64_t op, enum svpattern pattern, uint64_t imm_factor) : "SQDECD Xtied, pattern, MUL #imm_factor"
  public static unsafe long SaturatingDecrementInt64ElementCount(long op, enum SveMaskPattern pattern, ulong imm_factor);

    /// uint32_t svqdecd_pat[_n_u32](uint32_t op, enum svpattern pattern, uint64_t imm_factor) : "UQDECD Wtied, pattern, MUL #imm_factor"
  public static unsafe uint SaturatingDecrementInt64ElementCount(uint op, enum SveMaskPattern pattern, ulong imm_factor);

    /// uint64_t svqdecd_pat[_n_u64](uint64_t op, enum svpattern pattern, uint64_t imm_factor) : "UQDECD Xtied, pattern, MUL #imm_factor"
  public static unsafe ulong SaturatingDecrementInt64ElementCount(ulong op, enum SveMaskPattern pattern, ulong imm_factor);

    /// svint64_t svqdecd[_s64](svint64_t op, uint64_t imm_factor) : "SQDECD Ztied.D, ALL, MUL #imm_factor" or "MOVPRFX Zresult, Zop; SQDECD Zresult.D, ALL, MUL #imm_factor"
  public static unsafe Vector<long> SaturatingDecrementInt64ElementCount(Vector<long> op, ulong imm_factor);

    /// svuint64_t svqdecd[_u64](svuint64_t op, uint64_t imm_factor) : "UQDECD Ztied.D, ALL, MUL #imm_factor" or "MOVPRFX Zresult, Zop; UQDECD Zresult.D, ALL, MUL #imm_factor"
  public static unsafe Vector<ulong> SaturatingDecrementInt64ElementCount(Vector<ulong> op, ulong imm_factor);

    /// svint64_t svqdecd_pat[_s64](svint64_t op, enum svpattern pattern, uint64_t imm_factor) : "SQDECD Ztied.D, pattern, MUL #imm_factor" or "MOVPRFX Zresult, Zop; SQDECD Zresult.D, pattern, MUL #imm_factor"
  public static unsafe Vector<long> SaturatingDecrementInt64ElementCount(Vector<long> op, enum SveMaskPattern pattern, ulong imm_factor);

    /// svuint64_t svqdecd_pat[_u64](svuint64_t op, enum svpattern pattern, uint64_t imm_factor) : "UQDECD Ztied.D, pattern, MUL #imm_factor" or "MOVPRFX Zresult, Zop; UQDECD Zresult.D, pattern, MUL #imm_factor"
  public static unsafe Vector<ulong> SaturatingDecrementInt64ElementCount(Vector<ulong> op, enum SveMaskPattern pattern, ulong imm_factor);


    /// SaturatingIncrementByActiveElementCount : Saturating increment by active element count

    /// int32_t svqincp[_n_s32]_b8(int32_t op, svbool_t pg) : "SQINCP Xtied, Pg.B, Wtied"
  public static unsafe int SaturatingIncrementByActiveElementCount(int op, Vector<byte> select);

    /// int32_t svqincp[_n_s32]_b16(int32_t op, svbool_t pg) : "SQINCP Xtied, Pg.H, Wtied"
  public static unsafe int SaturatingIncrementByActiveElementCount(int op, Vector<ushort> select);

    /// int32_t svqincp[_n_s32]_b32(int32_t op, svbool_t pg) : "SQINCP Xtied, Pg.S, Wtied"
  public static unsafe int SaturatingIncrementByActiveElementCount(int op, Vector<uint> select);

    /// int32_t svqincp[_n_s32]_b64(int32_t op, svbool_t pg) : "SQINCP Xtied, Pg.D, Wtied"
  public static unsafe int SaturatingIncrementByActiveElementCount(int op, Vector<ulong> select);

    /// int64_t svqincp[_n_s64]_b8(int64_t op, svbool_t pg) : "SQINCP Xtied, Pg.B"
  public static unsafe long SaturatingIncrementByActiveElementCount(long op, Vector<byte> select);

    /// int64_t svqincp[_n_s64]_b16(int64_t op, svbool_t pg) : "SQINCP Xtied, Pg.H"
  public static unsafe long SaturatingIncrementByActiveElementCount(long op, Vector<ushort> select);

    /// int64_t svqincp[_n_s64]_b32(int64_t op, svbool_t pg) : "SQINCP Xtied, Pg.S"
  public static unsafe long SaturatingIncrementByActiveElementCount(long op, Vector<uint> select);

    /// int64_t svqincp[_n_s64]_b64(int64_t op, svbool_t pg) : "SQINCP Xtied, Pg.D"
  public static unsafe long SaturatingIncrementByActiveElementCount(long op, Vector<ulong> select);

    /// uint32_t svqincp[_n_u32]_b8(uint32_t op, svbool_t pg) : "UQINCP Wtied, Pg.B"
  public static unsafe uint SaturatingIncrementByActiveElementCount(uint op, Vector<byte> select);

    /// uint32_t svqincp[_n_u32]_b16(uint32_t op, svbool_t pg) : "UQINCP Wtied, Pg.H"
  public static unsafe uint SaturatingIncrementByActiveElementCount(uint op, Vector<ushort> select);

    /// uint32_t svqincp[_n_u32]_b32(uint32_t op, svbool_t pg) : "UQINCP Wtied, Pg.S"
  public static unsafe uint SaturatingIncrementByActiveElementCount(uint op, Vector<uint> select);

    /// uint32_t svqincp[_n_u32]_b64(uint32_t op, svbool_t pg) : "UQINCP Wtied, Pg.D"
  public static unsafe uint SaturatingIncrementByActiveElementCount(uint op, Vector<ulong> select);

    /// uint64_t svqincp[_n_u64]_b8(uint64_t op, svbool_t pg) : "UQINCP Xtied, Pg.B"
  public static unsafe ulong SaturatingIncrementByActiveElementCount(ulong op, Vector<byte> select);

    /// uint64_t svqincp[_n_u64]_b16(uint64_t op, svbool_t pg) : "UQINCP Xtied, Pg.H"
  public static unsafe ulong SaturatingIncrementByActiveElementCount(ulong op, Vector<ushort> select);

    /// uint64_t svqincp[_n_u64]_b32(uint64_t op, svbool_t pg) : "UQINCP Xtied, Pg.S"
  public static unsafe ulong SaturatingIncrementByActiveElementCount(ulong op, Vector<uint> select);

    /// uint64_t svqincp[_n_u64]_b64(uint64_t op, svbool_t pg) : "UQINCP Xtied, Pg.D"
  public static unsafe ulong SaturatingIncrementByActiveElementCount(ulong op, Vector<ulong> select);

    /// svint16_t svqincp[_s16](svint16_t op, svbool_t pg) : "SQINCP Ztied.H, Pg" or "MOVPRFX Zresult, Zop; SQINCP Zresult.H, Pg"
  public static unsafe Vector<short> SaturatingIncrementByActiveElementCount(Vector<short> op, Vector<short> select);

    /// svint32_t svqincp[_s32](svint32_t op, svbool_t pg) : "SQINCP Ztied.S, Pg" or "MOVPRFX Zresult, Zop; SQINCP Zresult.S, Pg"
  public static unsafe Vector<int> SaturatingIncrementByActiveElementCount(Vector<int> op, Vector<int> select);

    /// svint64_t svqincp[_s64](svint64_t op, svbool_t pg) : "SQINCP Ztied.D, Pg" or "MOVPRFX Zresult, Zop; SQINCP Zresult.D, Pg"
  public static unsafe Vector<long> SaturatingIncrementByActiveElementCount(Vector<long> op, Vector<long> select);

    /// svuint16_t svqincp[_u16](svuint16_t op, svbool_t pg) : "UQINCP Ztied.H, Pg" or "MOVPRFX Zresult, Zop; UQINCP Zresult.H, Pg"
  public static unsafe Vector<ushort> SaturatingIncrementByActiveElementCount(Vector<ushort> op, Vector<ushort> select);

    /// svuint32_t svqincp[_u32](svuint32_t op, svbool_t pg) : "UQINCP Ztied.S, Pg" or "MOVPRFX Zresult, Zop; UQINCP Zresult.S, Pg"
  public static unsafe Vector<uint> SaturatingIncrementByActiveElementCount(Vector<uint> op, Vector<uint> select);

    /// svuint64_t svqincp[_u64](svuint64_t op, svbool_t pg) : "UQINCP Ztied.D, Pg" or "MOVPRFX Zresult, Zop; UQINCP Zresult.D, Pg"
  public static unsafe Vector<ulong> SaturatingIncrementByActiveElementCount(Vector<ulong> op, Vector<ulong> select);


    /// SaturatingIncrementByteElementCount : Saturating increment by number of byte elements

    /// int32_t svqincb[_n_s32](int32_t op, uint64_t imm_factor) : "SQINCB Xtied, Wtied, ALL, MUL #imm_factor"
  public static unsafe int SaturatingIncrementByteElementCount(int op, ulong imm_factor);

    /// int64_t svqincb[_n_s64](int64_t op, uint64_t imm_factor) : "SQINCB Xtied, ALL, MUL #imm_factor"
  public static unsafe long SaturatingIncrementByteElementCount(long op, ulong imm_factor);

    /// uint32_t svqincb[_n_u32](uint32_t op, uint64_t imm_factor) : "UQINCB Wtied, ALL, MUL #imm_factor"
  public static unsafe uint SaturatingIncrementByteElementCount(uint op, ulong imm_factor);

    /// uint64_t svqincb[_n_u64](uint64_t op, uint64_t imm_factor) : "UQINCB Xtied, ALL, MUL #imm_factor"
  public static unsafe ulong SaturatingIncrementByteElementCount(ulong op, ulong imm_factor);

    /// int32_t svqincb_pat[_n_s32](int32_t op, enum svpattern pattern, uint64_t imm_factor) : "SQINCB Xtied, Wtied, pattern, MUL #imm_factor"
  public static unsafe int SaturatingIncrementByteElementCount(int op, enum SveMaskPattern pattern, ulong imm_factor);

    /// int64_t svqincb_pat[_n_s64](int64_t op, enum svpattern pattern, uint64_t imm_factor) : "SQINCB Xtied, pattern, MUL #imm_factor"
  public static unsafe long SaturatingIncrementByteElementCount(long op, enum SveMaskPattern pattern, ulong imm_factor);

    /// uint32_t svqincb_pat[_n_u32](uint32_t op, enum svpattern pattern, uint64_t imm_factor) : "UQINCB Wtied, pattern, MUL #imm_factor"
  public static unsafe uint SaturatingIncrementByteElementCount(uint op, enum SveMaskPattern pattern, ulong imm_factor);

    /// uint64_t svqincb_pat[_n_u64](uint64_t op, enum svpattern pattern, uint64_t imm_factor) : "UQINCB Xtied, pattern, MUL #imm_factor"
  public static unsafe ulong SaturatingIncrementByteElementCount(ulong op, enum SveMaskPattern pattern, ulong imm_factor);


    /// SaturatingIncrementInt16ElementCount : Saturating increment by number of halfword elements

    /// int32_t svqinch[_n_s32](int32_t op, uint64_t imm_factor) : "SQINCH Xtied, Wtied, ALL, MUL #imm_factor"
  public static unsafe int SaturatingIncrementInt16ElementCount(int op, ulong imm_factor);

    /// int64_t svqinch[_n_s64](int64_t op, uint64_t imm_factor) : "SQINCH Xtied, ALL, MUL #imm_factor"
  public static unsafe long SaturatingIncrementInt16ElementCount(long op, ulong imm_factor);

    /// uint32_t svqinch[_n_u32](uint32_t op, uint64_t imm_factor) : "UQINCH Wtied, ALL, MUL #imm_factor"
  public static unsafe uint SaturatingIncrementInt16ElementCount(uint op, ulong imm_factor);

    /// uint64_t svqinch[_n_u64](uint64_t op, uint64_t imm_factor) : "UQINCH Xtied, ALL, MUL #imm_factor"
  public static unsafe ulong SaturatingIncrementInt16ElementCount(ulong op, ulong imm_factor);

    /// int32_t svqinch_pat[_n_s32](int32_t op, enum svpattern pattern, uint64_t imm_factor) : "SQINCH Xtied, Wtied, pattern, MUL #imm_factor"
  public static unsafe int SaturatingIncrementInt16ElementCount(int op, enum SveMaskPattern pattern, ulong imm_factor);

    /// int64_t svqinch_pat[_n_s64](int64_t op, enum svpattern pattern, uint64_t imm_factor) : "SQINCH Xtied, pattern, MUL #imm_factor"
  public static unsafe long SaturatingIncrementInt16ElementCount(long op, enum SveMaskPattern pattern, ulong imm_factor);

    /// uint32_t svqinch_pat[_n_u32](uint32_t op, enum svpattern pattern, uint64_t imm_factor) : "UQINCH Wtied, pattern, MUL #imm_factor"
  public static unsafe uint SaturatingIncrementInt16ElementCount(uint op, enum SveMaskPattern pattern, ulong imm_factor);

    /// uint64_t svqinch_pat[_n_u64](uint64_t op, enum svpattern pattern, uint64_t imm_factor) : "UQINCH Xtied, pattern, MUL #imm_factor"
  public static unsafe ulong SaturatingIncrementInt16ElementCount(ulong op, enum SveMaskPattern pattern, ulong imm_factor);

    /// svint16_t svqinch[_s16](svint16_t op, uint64_t imm_factor) : "SQINCH Ztied.H, ALL, MUL #imm_factor" or "MOVPRFX Zresult, Zop; SQINCH Zresult.H, ALL, MUL #imm_factor"
  public static unsafe Vector<short> SaturatingIncrementInt16ElementCount(Vector<short> op, ulong imm_factor);

    /// svuint16_t svqinch[_u16](svuint16_t op, uint64_t imm_factor) : "UQINCH Ztied.H, ALL, MUL #imm_factor" or "MOVPRFX Zresult, Zop; UQINCH Zresult.H, ALL, MUL #imm_factor"
  public static unsafe Vector<ushort> SaturatingIncrementInt16ElementCount(Vector<ushort> op, ulong imm_factor);

    /// svint16_t svqinch_pat[_s16](svint16_t op, enum svpattern pattern, uint64_t imm_factor) : "SQINCH Ztied.H, pattern, MUL #imm_factor" or "MOVPRFX Zresult, Zop; SQINCH Zresult.H, pattern, MUL #imm_factor"
  public static unsafe Vector<short> SaturatingIncrementInt16ElementCount(Vector<short> op, enum SveMaskPattern pattern, ulong imm_factor);

    /// svuint16_t svqinch_pat[_u16](svuint16_t op, enum svpattern pattern, uint64_t imm_factor) : "UQINCH Ztied.H, pattern, MUL #imm_factor" or "MOVPRFX Zresult, Zop; UQINCH Zresult.H, pattern, MUL #imm_factor"
  public static unsafe Vector<ushort> SaturatingIncrementInt16ElementCount(Vector<ushort> op, enum SveMaskPattern pattern, ulong imm_factor);


    /// SaturatingIncrementInt32ElementCount : Saturating increment by number of word elements

    /// int32_t svqincw[_n_s32](int32_t op, uint64_t imm_factor) : "SQINCW Xtied, Wtied, ALL, MUL #imm_factor"
  public static unsafe int SaturatingIncrementInt32ElementCount(int op, ulong imm_factor);

    /// int64_t svqincw[_n_s64](int64_t op, uint64_t imm_factor) : "SQINCW Xtied, ALL, MUL #imm_factor"
  public static unsafe long SaturatingIncrementInt32ElementCount(long op, ulong imm_factor);

    /// uint32_t svqincw[_n_u32](uint32_t op, uint64_t imm_factor) : "UQINCW Wtied, ALL, MUL #imm_factor"
  public static unsafe uint SaturatingIncrementInt32ElementCount(uint op, ulong imm_factor);

    /// uint64_t svqincw[_n_u64](uint64_t op, uint64_t imm_factor) : "UQINCW Xtied, ALL, MUL #imm_factor"
  public static unsafe ulong SaturatingIncrementInt32ElementCount(ulong op, ulong imm_factor);

    /// int32_t svqincw_pat[_n_s32](int32_t op, enum svpattern pattern, uint64_t imm_factor) : "SQINCW Xtied, Wtied, pattern, MUL #imm_factor"
  public static unsafe int SaturatingIncrementInt32ElementCount(int op, enum SveMaskPattern pattern, ulong imm_factor);

    /// int64_t svqincw_pat[_n_s64](int64_t op, enum svpattern pattern, uint64_t imm_factor) : "SQINCW Xtied, pattern, MUL #imm_factor"
  public static unsafe long SaturatingIncrementInt32ElementCount(long op, enum SveMaskPattern pattern, ulong imm_factor);

    /// uint32_t svqincw_pat[_n_u32](uint32_t op, enum svpattern pattern, uint64_t imm_factor) : "UQINCW Wtied, pattern, MUL #imm_factor"
  public static unsafe uint SaturatingIncrementInt32ElementCount(uint op, enum SveMaskPattern pattern, ulong imm_factor);

    /// uint64_t svqincw_pat[_n_u64](uint64_t op, enum svpattern pattern, uint64_t imm_factor) : "UQINCW Xtied, pattern, MUL #imm_factor"
  public static unsafe ulong SaturatingIncrementInt32ElementCount(ulong op, enum SveMaskPattern pattern, ulong imm_factor);

    /// svint32_t svqincw[_s32](svint32_t op, uint64_t imm_factor) : "SQINCW Ztied.S, ALL, MUL #imm_factor" or "MOVPRFX Zresult, Zop; SQINCW Zresult.S, ALL, MUL #imm_factor"
  public static unsafe Vector<int> SaturatingIncrementInt32ElementCount(Vector<int> op, ulong imm_factor);

    /// svuint32_t svqincw[_u32](svuint32_t op, uint64_t imm_factor) : "UQINCW Ztied.S, ALL, MUL #imm_factor" or "MOVPRFX Zresult, Zop; UQINCW Zresult.S, ALL, MUL #imm_factor"
  public static unsafe Vector<uint> SaturatingIncrementInt32ElementCount(Vector<uint> op, ulong imm_factor);

    /// svint32_t svqincw_pat[_s32](svint32_t op, enum svpattern pattern, uint64_t imm_factor) : "SQINCW Ztied.S, pattern, MUL #imm_factor" or "MOVPRFX Zresult, Zop; SQINCW Zresult.S, pattern, MUL #imm_factor"
  public static unsafe Vector<int> SaturatingIncrementInt32ElementCount(Vector<int> op, enum SveMaskPattern pattern, ulong imm_factor);

    /// svuint32_t svqincw_pat[_u32](svuint32_t op, enum svpattern pattern, uint64_t imm_factor) : "UQINCW Ztied.S, pattern, MUL #imm_factor" or "MOVPRFX Zresult, Zop; UQINCW Zresult.S, pattern, MUL #imm_factor"
  public static unsafe Vector<uint> SaturatingIncrementInt32ElementCount(Vector<uint> op, enum SveMaskPattern pattern, ulong imm_factor);


    /// SaturatingIncrementInt64ElementCount : Saturating increment by number of doubleword elements

    /// int32_t svqincd[_n_s32](int32_t op, uint64_t imm_factor) : "SQINCD Xtied, Wtied, ALL, MUL #imm_factor"
  public static unsafe int SaturatingIncrementInt64ElementCount(int op, ulong imm_factor);

    /// int64_t svqincd[_n_s64](int64_t op, uint64_t imm_factor) : "SQINCD Xtied, ALL, MUL #imm_factor"
  public static unsafe long SaturatingIncrementInt64ElementCount(long op, ulong imm_factor);

    /// uint32_t svqincd[_n_u32](uint32_t op, uint64_t imm_factor) : "UQINCD Wtied, ALL, MUL #imm_factor"
  public static unsafe uint SaturatingIncrementInt64ElementCount(uint op, ulong imm_factor);

    /// uint64_t svqincd[_n_u64](uint64_t op, uint64_t imm_factor) : "UQINCD Xtied, ALL, MUL #imm_factor"
  public static unsafe ulong SaturatingIncrementInt64ElementCount(ulong op, ulong imm_factor);

    /// int32_t svqincd_pat[_n_s32](int32_t op, enum svpattern pattern, uint64_t imm_factor) : "SQINCD Xtied, Wtied, pattern, MUL #imm_factor"
  public static unsafe int SaturatingIncrementInt64ElementCount(int op, enum SveMaskPattern pattern, ulong imm_factor);

    /// int64_t svqincd_pat[_n_s64](int64_t op, enum svpattern pattern, uint64_t imm_factor) : "SQINCD Xtied, pattern, MUL #imm_factor"
  public static unsafe long SaturatingIncrementInt64ElementCount(long op, enum SveMaskPattern pattern, ulong imm_factor);

    /// uint32_t svqincd_pat[_n_u32](uint32_t op, enum svpattern pattern, uint64_t imm_factor) : "UQINCD Wtied, pattern, MUL #imm_factor"
  public static unsafe uint SaturatingIncrementInt64ElementCount(uint op, enum SveMaskPattern pattern, ulong imm_factor);

    /// uint64_t svqincd_pat[_n_u64](uint64_t op, enum svpattern pattern, uint64_t imm_factor) : "UQINCD Xtied, pattern, MUL #imm_factor"
  public static unsafe ulong SaturatingIncrementInt64ElementCount(ulong op, enum SveMaskPattern pattern, ulong imm_factor);

    /// svint64_t svqincd[_s64](svint64_t op, uint64_t imm_factor) : "SQINCD Ztied.D, ALL, MUL #imm_factor" or "MOVPRFX Zresult, Zop; SQINCD Zresult.D, ALL, MUL #imm_factor"
  public static unsafe Vector<long> SaturatingIncrementInt64ElementCount(Vector<long> op, ulong imm_factor);

    /// svuint64_t svqincd[_u64](svuint64_t op, uint64_t imm_factor) : "UQINCD Ztied.D, ALL, MUL #imm_factor" or "MOVPRFX Zresult, Zop; UQINCD Zresult.D, ALL, MUL #imm_factor"
  public static unsafe Vector<ulong> SaturatingIncrementInt64ElementCount(Vector<ulong> op, ulong imm_factor);

    /// svint64_t svqincd_pat[_s64](svint64_t op, enum svpattern pattern, uint64_t imm_factor) : "SQINCD Ztied.D, pattern, MUL #imm_factor" or "MOVPRFX Zresult, Zop; SQINCD Zresult.D, pattern, MUL #imm_factor"
  public static unsafe Vector<long> SaturatingIncrementInt64ElementCount(Vector<long> op, enum SveMaskPattern pattern, ulong imm_factor);

    /// svuint64_t svqincd_pat[_u64](svuint64_t op, enum svpattern pattern, uint64_t imm_factor) : "UQINCD Ztied.D, pattern, MUL #imm_factor" or "MOVPRFX Zresult, Zop; UQINCD Zresult.D, pattern, MUL #imm_factor"
  public static unsafe Vector<ulong> SaturatingIncrementInt64ElementCount(Vector<ulong> op, enum SveMaskPattern pattern, ulong imm_factor);


  /// total method signatures: 166
  /// total method names:      19
}

[a74nh]

  /// Rejected:
  ///   public static unsafe ulong CountElementsInAFullVector(Vector<float> value); // svlen[_f32]
  ///   public static unsafe ulong CountElementsInAFullVector(Vector<double> value); // svlen[_f64]
  ///   public static unsafe ulong CountElementsInAFullVector(Vector<sbyte> value); // svlen[_s8]
  ///   public static unsafe ulong CountElementsInAFullVector(Vector<short> value); // svlen[_s16]
  ///   public static unsafe ulong CountElementsInAFullVector(Vector<int> value); // svlen[_s32]
  ///   public static unsafe ulong CountElementsInAFullVector(Vector<long> value); // svlen[_s64]
  ///   public static unsafe ulong CountElementsInAFullVector(Vector<byte> value); // svlen[_u8]
  ///   public static unsafe ulong CountElementsInAFullVector(Vector<ushort> value); // svlen[_u16]
  ///   public static unsafe ulong CountElementsInAFullVector(Vector<uint> value); // svlen[_u32]
  ///   public static unsafe ulong CountElementsInAFullVector(Vector<ulong> value); // svlen[_u64]
  ///   Total Rejected: 10

  /// Total ACLE covered across API:      220

[a74nh]

This contributes to #93095

It covers instructions in FEAT_SVE related to counting.

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

The methods list reduced down to Vector versions. All possible varaints of T are given above the method.
The complete list of all methods. The corresponding ACLE methods and SVE instructions are given above the method.
All rejected ACLE methods. These are methods we have agreed that do not need including in C#.
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.

[tannergooding]

CountLeading*Bits should be Leading*Count, CountNonzeroBits should be PopCount to match the existing name in AdvSimd (these also match the cross platform names used by the scalar types, int.PopCount for example).

CountSetPredicateBits may be a confusing name given it takes a Vector<T>. GetActiveElementCount or similar may be a "better" name and fits the terminology used by the architecture manual around "active" vs "inactive" elements.

For CountTheNumber*BitElementsInAVector, could you explain what enum svpattern pattern is meant to do here and how the parameterless overload differs?

CountTheNumberOfElementsInAFullVector() should probably not be exposed and users can just use Vector<T>.Count. Coming up with a "nice" name here would be difficult, so its likely not worth making it more difficult for a user to consume.

SaturatingDecrementByNumberOf*Elements should maybe be SaturatingDecrement*ElementCount for consistency?

Doubleword should likely be Int64 to avoid confusion with the variable meaning of Doubleword across some platforms (Win32 exclusively uses dword to mean 32-bits, as does x86/x64). The same goes for Halfword (Int16), Word (Int32), and Quadword (Int128).

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

[a74nh]

CountLeading*Bits .....

All updated as suggested.