Vector256 クラス

定義

名前空間:
System.Runtime.Intrinsics
アセンブリ:
System.Runtime.Intrinsics.dll
ソース:
Vector256.cs
ソース:
Vector256.cs
ソース:
Vector256.cs
ソース:
Vector256.cs
ソース:
Vector256.cs

256 ビット ベクトルを作成、操作、その他の操作を行う静的メソッドのコレクションを提供します。

public ref class Vector256 abstract sealed
public static class Vector256
type Vector256 = class
Public Module Vector256
継承
Object
Vector256

プロパティ

名前 説明
E

256 ビット ベクトルを作成、操作、その他の操作を行う静的メソッドのコレクションを提供します。
Epsilon

256 ビット ベクトルを作成、操作、その他の操作を行う静的メソッドのコレクションを提供します。
IsHardwareAccelerated

256 ビット ベクター操作が JIT 組み込みサポートによるハードウェア アクセラレーションの対象かどうかを示す値を取得します。
NaN

256 ビット ベクトルを作成、操作、その他の操作を行う静的メソッドのコレクションを提供します。
NegativeInfinity

256 ビット ベクトルを作成、操作、その他の操作を行う静的メソッドのコレクションを提供します。
NegativeOne

256 ビット ベクトルを作成、操作、その他の操作を行う静的メソッドのコレクションを提供します。
NegativeZero

256 ビット ベクトルを作成、操作、その他の操作を行う静的メソッドのコレクションを提供します。
Pi

256 ビット ベクトルを作成、操作、その他の操作を行う静的メソッドのコレクションを提供します。
PositiveInfinity

256 ビット ベクトルを作成、操作、その他の操作を行う静的メソッドのコレクションを提供します。
Tau

256 ビット ベクトルを作成、操作、その他の操作を行う静的メソッドのコレクションを提供します。

メソッド

名前 説明
Abs<T>(Vector256<T>)

ベクター内の各要素の絶対値を計算します。
Add<T>(Vector256<T>, Vector256<T>)

合計を計算する 2 つのベクターを追加します。
AddSaturate<T>(Vector256<T>, Vector256<T>)

要素ごとの飽和合計を計算する 2 つのベクトルを追加します。
All<T>(Vector256<T>, T)

ベクターのすべての要素が特定の値と等しいかどうかを判断します。
AllWhereAllBitsSet<T>(Vector256<T>)

ベクターのすべての要素に、すべてのビットが設定されているかどうかを判断します。
AndNot<T>(Vector256<T>, Vector256<T>)

特定のベクトルのビットごとの計算と、別のベクトルの補数を計算します。
Any<T>(Vector256<T>, T)

ベクターの要素が特定の値と等しいかどうかを判断します。
AnyWhereAllBitsSet<T>(Vector256<T>)

ベクターの要素に、すべてのビットが設定されているかどうかを判断します。
As<T,U>(Vector256<T>)

Vector256<T>型のTFromを、Vector256<T>型の新しいTToとして再解釈します。
AsByte<T>(Vector256<T>)

Vector256<T>型の新しいVector256としてByteを再解釈します。
AsDouble<T>(Vector256<T>)

Vector256<T>型の新しいVector256としてDoubleを再解釈します。
Asin(Vector256<Double>)

256 ビット ベクトルを作成、操作、その他の操作を行う静的メソッドのコレクションを提供します。
Asin(Vector256<Single>)

256 ビット ベクトルを作成、操作、その他の操作を行う静的メソッドのコレクションを提供します。
AsInt16<T>(Vector256<T>)

Vector256<T>型の新しいVector256としてInt16を再解釈します。
AsInt32<T>(Vector256<T>)

Vector256<T>型の新しいVector256としてInt32を再解釈します。
AsInt64<T>(Vector256<T>)

Vector256<T>型の新しいVector256としてInt64を再解釈します。
AsNInt<T>(Vector256<T>)

Vector256<T>を新しいVector256<T>として再解釈します。
AsNUInt<T>(Vector256<T>)

Vector256<T>を新しいVector256<T>として再解釈します。
AsSByte<T>(Vector256<T>)

Vector256<T>型の新しいVector256としてSByteを再解釈します。
AsSingle<T>(Vector256<T>)

Vector256<T>型の新しいVector256としてSingleを再解釈します。
AsUInt16<T>(Vector256<T>)

Vector256<T>型の新しいVector256としてUInt16を再解釈します。
AsUInt32<T>(Vector256<T>)

Vector256<T>型の新しいVector256としてUInt32を再解釈します。
AsUInt64<T>(Vector256<T>)

Vector256<T>型の新しいVector256としてUInt64を再解釈します。
AsVector<T>(Vector256<T>)

Vector256<T>を新しいVector<T>として再解釈します。
AsVector256<T>(Vector<T>)

Vector<T>を新しいVector256<T>として再解釈します。
BitwiseAnd<T>(Vector256<T>, Vector256<T>)

2 つのベクトルのビットごとの計算を行います。
BitwiseOr<T>(Vector256<T>, Vector256<T>)

2 つのベクトルのビットごとのまたは 2 つのベクトルを計算します。
Ceiling(Vector256<Double>)

ベクトル内の各要素の上限を計算します。
Ceiling(Vector256<Single>)

ベクトル内の各要素の上限を計算します。
Clamp<T>(Vector256<T>, Vector256<T>, Vector256<T>)

最小値と最大値の間でベクトルを制限します。
ClampNative<T>(Vector256<T>, Vector256<T>, Vector256<T>)

NaNとNegativeZeroのプラットフォーム固有の動作を使用して、最小値と最大値の間のベクトルを制限します。
ConditionalSelect<T>(Vector256<T>, Vector256<T>, Vector256<T>)

ビットごとの 2 つのベクトルから値を条件付きで選択します。
ConvertToDouble(Vector256<Int64>)

Vector256<T> を Vector256<T>に変換します。
ConvertToDouble(Vector256<UInt64>)

Vector256<T> を Vector256<T>に変換します。
ConvertToInt32(Vector256<Single>)

Vector256<T> を Vector256<T>に変換します。
ConvertToInt32Native(Vector256<Single>)

オーバーフロー時のプラットフォーム固有の動作を使用して、 Vector256<Single> を Vector256<Int32> に変換します。
ConvertToInt64(Vector256<Double>)

Vector256<T> を Vector256<T>に変換します。
ConvertToInt64Native(Vector256<Double>)

オーバーフロー時のプラットフォーム固有の動作を使用して、 Vector256<Double> を Vector256<Int64> に変換します。
ConvertToSingle(Vector256<Int32>)

Vector256<T> を Vector256<T>に変換します。
ConvertToSingle(Vector256<UInt32>)

Vector256<T> を Vector256<T>に変換します。
ConvertToUInt32(Vector256<Single>)

Vector256<T> を Vector256<T>に変換します。
ConvertToUInt32Native(Vector256<Single>)

オーバーフロー時のプラットフォーム固有の動作を使用して、 Vector256<Single> を Vector256<UInt32> に変換します。
ConvertToUInt64(Vector256<Double>)

Vector256<T> を Vector256<T>に変換します。
ConvertToUInt64Native(Vector256<Double>)

オーバーフロー時のプラットフォーム固有の動作を使用して、 Vector256<Double> を Vector256<UInt64> に変換します。
CopySign<T>(Vector256<T>, Vector256<T>)

ベクトルの要素ごとの符号を、別のベクトルの要素ごとの符号にコピーします。
CopyTo<T>(Vector256<T>, Span<T>)

特定のスパンに Vector256<T> をコピーします。
CopyTo<T>(Vector256<T>, T[], Int32)

指定したインデックスから始まる特定の配列に Vector256<T> をコピーします。
CopyTo<T>(Vector256<T>, T[])

Vector256<T>を特定の配列にコピーします。
Cos(Vector256<Double>)

ベクトル内の各要素のコサインを計算します。
Cos(Vector256<Single>)

ベクトル内の各要素のコサインを計算します。
Count<T>(Vector256<T>, T)

指定された値と等しいベクター内の要素の数を決定します。
CountWhereAllBitsSet<T>(Vector256<T>)

すべてのビットが設定されているベクター内の要素の数を決定します。
Create(Byte, Byte, Byte, Byte, Byte, Byte, Byte, Byte, Byte, Byte, Byte, Byte, Byte, Byte, Byte, Byte, Byte, Byte, Byte, Byte, Byte, Byte, Byte, Byte, Byte, Byte, Byte, Byte, Byte, Byte, Byte, Byte)

各要素が対応する指定した値に初期化された新しい Vector256<T> インスタンスを作成します。
Create(Byte)

指定した値に初期化されたすべての要素を持つ新しい Vector256<T> インスタンスを作成します。
Create(Double, Double, Double, Double)

各要素が対応する指定した値に初期化された新しい Vector256<T> インスタンスを作成します。
Create(Double)

指定した値に初期化されたすべての要素を持つ新しい Vector256<T> インスタンスを作成します。
Create(Int16, Int16, Int16, Int16, Int16, Int16, Int16, Int16, Int16, Int16, Int16, Int16, Int16, Int16, Int16, Int16)

各要素が対応する指定した値に初期化された新しい Vector256<T> インスタンスを作成します。
Create(Int16)

指定した値に初期化されたすべての要素を持つ新しい Vector256<T> インスタンスを作成します。
Create(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Int32)

各要素が対応する指定した値に初期化された新しい Vector256<T> インスタンスを作成します。
Create(Int32)

指定した値に初期化されたすべての要素を持つ新しい Vector256<T> インスタンスを作成します。
Create(Int64, Int64, Int64, Int64)

各要素が対応する指定した値に初期化された新しい Vector256<T> インスタンスを作成します。
Create(Int64)

指定した値に初期化されたすべての要素を持つ新しい Vector256<T> インスタンスを作成します。
Create(IntPtr)

指定した値に初期化されたすべての要素を持つ新しい Vector256<T> インスタンスを作成します。
Create(SByte, SByte, SByte, SByte, SByte, SByte, SByte, SByte, SByte, SByte, SByte, SByte, SByte, SByte, SByte, SByte, SByte, SByte, SByte, SByte, SByte, SByte, SByte, SByte, SByte, SByte, SByte, SByte, SByte, SByte, SByte, SByte)

各要素が対応する指定した値に初期化された新しい Vector256<T> インスタンスを作成します。
Create(SByte)

指定した値に初期化されたすべての要素を持つ新しい Vector256<T> インスタンスを作成します。
Create(Single, Single, Single, Single, Single, Single, Single, Single)

各要素が対応する指定した値に初期化された新しい Vector256<T> インスタンスを作成します。
Create(Single)

指定した値に初期化されたすべての要素を持つ新しい Vector256<T> インスタンスを作成します。
Create(UInt16, UInt16, UInt16, UInt16, UInt16, UInt16, UInt16, UInt16, UInt16, UInt16, UInt16, UInt16, UInt16, UInt16, UInt16, UInt16)

各要素が対応する指定した値に初期化された新しい Vector256<T> インスタンスを作成します。
Create(UInt16)

指定した値に初期化されたすべての要素を持つ新しい Vector256<T> インスタンスを作成します。
Create(UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32)

各要素が対応する指定した値に初期化された新しい Vector256<T> インスタンスを作成します。
Create(UInt32)

指定した値に初期化されたすべての要素を持つ新しい Vector256<T> インスタンスを作成します。
Create(UInt64, UInt64, UInt64, UInt64)

各要素が対応する指定した値に初期化された新しい Vector256<T> インスタンスを作成します。
Create(UInt64)

指定した値に初期化されたすべての要素を持つ新しい Vector256<T> インスタンスを作成します。
Create(UIntPtr)

指定した値に初期化されたすべての要素を持つ新しい Vector256<T> インスタンスを作成します。
Create(Vector128<Byte>, Vector128<Byte>)

2 つのVector256<T> インスタンスから新しいVector128<T> インスタンスを作成します。
Create(Vector128<Double>, Vector128<Double>)

2 つのVector256<T> インスタンスから新しいVector128<T> インスタンスを作成します。
Create(Vector128<Int16>, Vector128<Int16>)

2 つのVector256<T> インスタンスから新しいVector128<T> インスタンスを作成します。
Create(Vector128<Int32>, Vector128<Int32>)

2 つのVector256<T> インスタンスから新しいVector128<T> インスタンスを作成します。
Create(Vector128<Int64>, Vector128<Int64>)

2 つのVector256<T> インスタンスから新しいVector128<T> インスタンスを作成します。
Create(Vector128<IntPtr>, Vector128<IntPtr>)

2 つのVector256<T> インスタンスから新しいVector128<T> インスタンスを作成します。
Create(Vector128<SByte>, Vector128<SByte>)

2 つのVector256<T> インスタンスから新しいVector128<T> インスタンスを作成します。
Create(Vector128<Single>, Vector128<Single>)

2 つのVector256<T> インスタンスから新しいVector128<T> インスタンスを作成します。
Create(Vector128<UInt16>, Vector128<UInt16>)

2 つのVector256<T> インスタンスから新しいVector128<T> インスタンスを作成します。
Create(Vector128<UInt32>, Vector128<UInt32>)

2 つのVector256<T> インスタンスから新しいVector128<T> インスタンスを作成します。
Create(Vector128<UInt64>, Vector128<UInt64>)

2 つのVector256<T> インスタンスから新しいVector128<T> インスタンスを作成します。
Create(Vector128<UIntPtr>, Vector128<UIntPtr>)

2 つのVector256<T> インスタンスから新しいVector128<T> インスタンスを作成します。
Create<T>(ReadOnlySpan<T>)

特定の読み取り専用スパンから新しい Vector256<T> を作成します。
Create<T>(T)

指定した値に初期化されたすべての要素を持つ新しい Vector256<T> インスタンスを作成します。
Create<T>(T[], Int32)

指定した配列から新しい Vector256<T> を作成します。
Create<T>(T[])

指定した配列から新しい Vector256<T> を作成します。
Create<T>(Vector128<T>, Vector128<T>)

2 つのVector256<T> インスタンスから新しいVector128<T> インスタンスを作成します。
Create<T>(Vector128<T>)

指定した値に初期化された下位 128 ビットと上位 128 ビットを使用して、新しい Vector256<T> インスタンスを作成します。
Create<T>(Vector64<T>)

指定した値に初期化されたすべての 64 ビット 部分を含む新しい Vector256<T> インスタンスを作成します。
CreateScalar(Byte)

指定した値に初期化された最初の要素と 0 に初期化された残りの要素を使用して、新しい Vector256<T> インスタンスを作成します。
CreateScalar(Double)

指定した値に初期化された最初の要素と 0 に初期化された残りの要素を使用して、新しい Vector256<T> インスタンスを作成します。
CreateScalar(Int16)

指定した値に初期化された最初の要素と 0 に初期化された残りの要素を使用して、新しい Vector256<T> インスタンスを作成します。
CreateScalar(Int32)

指定した値に初期化された最初の要素と 0 に初期化された残りの要素を使用して、新しい Vector256<T> インスタンスを作成します。
CreateScalar(Int64)

指定した値に初期化された最初の要素と 0 に初期化された残りの要素を使用して、新しい Vector256<T> インスタンスを作成します。
CreateScalar(IntPtr)

指定した値に初期化された最初の要素と 0 に初期化された残りの要素を使用して、新しい Vector256<T> インスタンスを作成します。
CreateScalar(SByte)

指定した値に初期化された最初の要素と 0 に初期化された残りの要素を使用して、新しい Vector256<T> インスタンスを作成します。
CreateScalar(Single)

指定した値に初期化された最初の要素と 0 に初期化された残りの要素を使用して、新しい Vector256<T> インスタンスを作成します。
CreateScalar(UInt16)

指定した値に初期化された最初の要素と 0 に初期化された残りの要素を使用して、新しい Vector256<T> インスタンスを作成します。
CreateScalar(UInt32)

指定した値に初期化された最初の要素と 0 に初期化された残りの要素を使用して、新しい Vector256<T> インスタンスを作成します。
CreateScalar(UInt64)

指定した値に初期化された最初の要素と 0 に初期化された残りの要素を使用して、新しい Vector256<T> インスタンスを作成します。
CreateScalar(UIntPtr)

指定した値に初期化された最初の要素と 0 に初期化された残りの要素を使用して、新しい Vector256<T> インスタンスを作成します。
CreateScalar<T>(T)

指定した値に初期化された最初の要素と 0 に初期化された残りの要素を使用して、新しい Vector256<T> インスタンスを作成します。
CreateScalarUnsafe(Byte)

指定した値に初期化された最初の要素と、初期化されていない残りの要素を含む新しい Vector256<T> インスタンスを作成します。
CreateScalarUnsafe(Double)

指定した値に初期化された最初の要素と、初期化されていない残りの要素を含む新しい Vector256<T> インスタンスを作成します。
CreateScalarUnsafe(Int16)

指定した値に初期化された最初の要素と、初期化されていない残りの要素を含む新しい Vector256<T> インスタンスを作成します。
CreateScalarUnsafe(Int32)

指定した値に初期化された最初の要素と、初期化されていない残りの要素を含む新しい Vector256<T> インスタンスを作成します。
CreateScalarUnsafe(Int64)

指定した値に初期化された最初の要素と、初期化されていない残りの要素を含む新しい Vector256<T> インスタンスを作成します。
CreateScalarUnsafe(IntPtr)

指定した値に初期化された最初の要素と、初期化されていない残りの要素を含む新しい Vector256<T> インスタンスを作成します。
CreateScalarUnsafe(SByte)

指定した値に初期化された最初の要素と、初期化されていない残りの要素を含む新しい Vector256<T> インスタンスを作成します。
CreateScalarUnsafe(Single)

指定した値に初期化された最初の要素と、初期化されていない残りの要素を含む新しい Vector256<T> インスタンスを作成します。
CreateScalarUnsafe(UInt16)

指定した値に初期化された最初の要素と、初期化されていない残りの要素を含む新しい Vector256<T> インスタンスを作成します。
CreateScalarUnsafe(UInt32)

指定した値に初期化された最初の要素と、初期化されていない残りの要素を含む新しい Vector256<T> インスタンスを作成します。
CreateScalarUnsafe(UInt64)

指定した値に初期化された最初の要素と、初期化されていない残りの要素を含む新しい Vector256<T> インスタンスを作成します。
CreateScalarUnsafe(UIntPtr)

指定した値に初期化された最初の要素と、初期化されていない残りの要素を含む新しい Vector256<T> インスタンスを作成します。
CreateScalarUnsafe<T>(T)

指定した値に初期化された最初の要素と、初期化されていない残りの要素を含む新しい Vector256<T> インスタンスを作成します。
CreateSequence<T>(T, T)

要素が指定した値から始まり、別の指定した値に従って間隔を置かれた新しい Vector256<T> インスタンスを作成します。
DegreesToRadians(Vector256<Double>)

指定したベクトルを度からラジアンに変換します。
DegreesToRadians(Vector256<Single>)

指定したベクトルを度からラジアンに変換します。
Divide<T>(Vector256<T>, T)

ベクターをスカラーで除算して、要素ごとの商を計算します。
Divide<T>(Vector256<T>, Vector256<T>)

2 つのベクトルを除算して商を計算します。
Dot<T>(Vector256<T>, Vector256<T>)

2 つのベクトルのドット積を計算します。
Equals<T>(Vector256<T>, Vector256<T>)

2 つのベクトルを比較して、要素ごとに等しいかどうかを判断します。
EqualsAll<T>(Vector256<T>, Vector256<T>)

2 つのベクトルを比較して、すべての要素が等しいかどうかを判断します。
EqualsAny<T>(Vector256<T>, Vector256<T>)

2 つのベクトルを比較して、要素が等しいかどうかを判断します。
Exp(Vector256<Double>)

ベクトル内の各要素の指数関数を計算します。
Exp(Vector256<Single>)

ベクトル内の各要素の指数関数を計算します。
ExtractMostSignificantBits<T>(Vector256<T>)

ベクター内の各要素から最上位ビットを抽出します。
Floor(Vector256<Double>)

ベクター内の各要素の床を計算します。
Floor(Vector256<Single>)

ベクター内の各要素の床を計算します。
FusedMultiplyAdd(Vector256<Double>, Vector256<Double>, Vector256<Double>)

コンピューティング (left * right) + addend。1 つの三項演算として丸められます。
FusedMultiplyAdd(Vector256<Single>, Vector256<Single>, Vector256<Single>)

コンピューティング (left * right) + addend。1 つの三項演算として丸められます。
get_E<T>()

256 ビット ベクトルを作成、操作、その他の操作を行う静的メソッドのコレクションを提供します。
get_Epsilon<T>()

256 ビット ベクトルを作成、操作、その他の操作を行う静的メソッドのコレクションを提供します。
get_NaN<T>()

256 ビット ベクトルを作成、操作、その他の操作を行う静的メソッドのコレクションを提供します。
get_NegativeInfinity<T>()

256 ビット ベクトルを作成、操作、その他の操作を行う静的メソッドのコレクションを提供します。
get_NegativeOne<T>()

256 ビット ベクトルを作成、操作、その他の操作を行う静的メソッドのコレクションを提供します。
get_NegativeZero<T>()

256 ビット ベクトルを作成、操作、その他の操作を行う静的メソッドのコレクションを提供します。
get_Pi<T>()

256 ビット ベクトルを作成、操作、その他の操作を行う静的メソッドのコレクションを提供します。
get_PositiveInfinity<T>()

256 ビット ベクトルを作成、操作、その他の操作を行う静的メソッドのコレクションを提供します。
get_Tau<T>()

256 ビット ベクトルを作成、操作、その他の操作を行う静的メソッドのコレクションを提供します。
GetElement<T>(Vector256<T>, Int32)

指定したインデックス位置にある要素を取得します。
GetLower<T>(Vector256<T>)

新しい Vector128<T>として下位 128 ビットの値を取得します。
GetUpper<T>(Vector256<T>)

新しい Vector128<T>として上位 128 ビットの値を取得します。
GreaterThan<T>(Vector256<T>, Vector256<T>)

2 つのベクトルを比較して、要素ごとにどちらが大きいかを判断します。
GreaterThanAll<T>(Vector256<T>, Vector256<T>)

2 つのベクトルを比較して、すべての要素が大きいかどうかを判断します。
GreaterThanAny<T>(Vector256<T>, Vector256<T>)

2 つのベクトルを比較して、要素が大きいかどうかを判断します。
GreaterThanOrEqual<T>(Vector256<T>, Vector256<T>)

2 つのベクトルを比較して、要素ごとに大きいか等しいかを判断します。
GreaterThanOrEqualAll<T>(Vector256<T>, Vector256<T>)

2 つのベクトルを比較して、すべての要素が大きいか等しいかを判断します。
GreaterThanOrEqualAny<T>(Vector256<T>, Vector256<T>)

2 つのベクトルを比較して、要素が大きいか等しいかを判断します。
Hypot(Vector256<Double>, Vector256<Double>)

直角三角形の短辺の長さを表す 2 つのベクトルを指定して、低血圧を計算します。
Hypot(Vector256<Single>, Vector256<Single>)

直角三角形の短辺の長さを表す 2 つのベクトルを指定して、低血圧を計算します。
IndexOf<T>(Vector256<T>, T)

指定された値と等しいベクトル内の最初の要素のインデックスを決定します。
IndexOfWhereAllBitsSet<T>(Vector256<T>)

すべてのビットが設定されているベクター内の最初の要素のインデックスを決定します。
IsEvenInteger<T>(Vector256<T>)

ベクトル内のどの要素が偶数の整数値であるかを決定します。
IsFinite<T>(Vector256<T>)

ベクトル内のどの要素が有限であるかを決定します。
IsInfinity<T>(Vector256<T>)

ベクトル内のどの要素が無限大であるかを決定します。
IsInteger<T>(Vector256<T>)

ベクトル内のどの要素が整数値であるかを決定します。
IsNaN<T>(Vector256<T>)

ベクトル内のどの要素が NaN であるかを決定します。
IsNegative<T>(Vector256<T>)

負の実数を表すベクター内の要素を決定します。
IsNegativeInfinity<T>(Vector256<T>)

ベクトル内のどの要素が負の無限大であるかを決定します。
IsNormal<T>(Vector256<T>)

ベクトル内のどの要素が正常であるかを決定します。
IsOddInteger<T>(Vector256<T>)

ベクトル内のどの要素が奇数の整数値であるかを決定します。
IsPositive<T>(Vector256<T>)

ベクトル内のどの要素が正の実数を表すかを決定します。
IsPositiveInfinity<T>(Vector256<T>)

ベクトル内のどの要素が正の無限大であるかを決定します。
IsSubnormal<T>(Vector256<T>)

ベクトル内のどの要素が非正規であるかを決定します。
IsZero<T>(Vector256<T>)

ベクトル内のどの要素が 0 であるかを決定します。
LastIndexOf<T>(Vector256<T>, T)

指定された値と等しいベクター内の最後の要素のインデックスを決定します。
LastIndexOfWhereAllBitsSet<T>(Vector256<T>)

すべてのビットが設定されているベクター内の最後の要素のインデックスを決定します。
Lerp(Vector256<Double>, Vector256<Double>, Vector256<Double>)

指定された重みに基づいて、2 つのベクトル間で線形補間を実行します。
Lerp(Vector256<Single>, Vector256<Single>, Vector256<Single>)

指定された重みに基づいて、2 つのベクトル間で線形補間を実行します。
LessThan<T>(Vector256<T>, Vector256<T>)

2 つのベクトルを比較して、要素ごとにどちらが小さいかを判断します。
LessThanAll<T>(Vector256<T>, Vector256<T>)

2 つのベクトルを比較して、すべての要素が小さいかどうかを判断します。
LessThanAny<T>(Vector256<T>, Vector256<T>)

2 つのベクトルを比較して、要素が少ないかどうかを判断します。
LessThanOrEqual<T>(Vector256<T>, Vector256<T>)

2 つのベクトルを比較して、要素ごとに次のベクトルを決定します。
LessThanOrEqualAll<T>(Vector256<T>, Vector256<T>)

2 つのベクトルを比較して、すべての要素が小さいか等しいかを判断します。
LessThanOrEqualAny<T>(Vector256<T>, Vector256<T>)

2 つのベクトルを比較して、要素が小さいか等しいかを判断します。
Load<T>(T*)

指定されたソースからベクターを読み込みます。
LoadAligned<T>(T*)

指定された配置されたソースからベクターを読み込みます。
LoadAlignedNonTemporal<T>(T*)

指定された配置されたソースからベクターを読み込みます。
LoadUnsafe<T>(T, UIntPtr)

指定されたソースと要素のオフセットからベクターを読み込みます。
LoadUnsafe<T>(T)

指定されたソースからベクターを読み込みます。
Log(Vector256<Double>)

ベクター内の各要素のログを計算します。
Log(Vector256<Single>)

ベクター内の各要素のログを計算します。
Log2(Vector256<Double>)

ベクトル内の各要素の log2 を計算します。
Log2(Vector256<Single>)

ベクトル内の各要素の log2 を計算します。
Max<T>(Vector256<T>, Vector256<T>)

要素ごとに最大 2 つのベクトルを計算します。
MaxMagnitude<T>(Vector256<T>, Vector256<T>)

2 つのベクトルを比較して、要素ごとに大きな大きさを持つ計算を行います。
MaxMagnitudeNumber<T>(Vector256<T>, Vector256<T>)

要素ごとに 2 つのベクトルを比較し、大きさが大きい計算を行い、入力が NaN場合はもう一方の値を返します。
MaxNative<T>(Vector256<T>, Vector256<T>)

2 つのベクトルを比較し、 NaN と NegativeZeroのプラットフォーム固有の動作を使用して、要素ごとにどちらが大きいかを判断します。
MaxNumber<T>(Vector256<T>, Vector256<T>)

要素ごとに 2 つのベクトルを比較して、より大きい値を計算し、要素が NaN場合はもう一方の値を返します。
Min<T>(Vector256<T>, Vector256<T>)

要素ごとに 2 つのベクトルの最小値を計算します。
MinMagnitude<T>(Vector256<T>, Vector256<T>)

2 つのベクトルを比較して、要素ごとに大きさが小さい計算を行います。
MinMagnitudeNumber<T>(Vector256<T>, Vector256<T>)

要素ごとに 2 つのベクトルを比較し、入力が NaN場合は、より小さい大きさを持ち、もう一方の値を返す計算を行います。
MinNative<T>(Vector256<T>, Vector256<T>)

2 つのベクトルを比較し、 NaN と NegativeZeroのプラットフォーム固有の動作を使用して、要素ごとにどちらが小さいかを判断します。
MinNumber<T>(Vector256<T>, Vector256<T>)

要素ごとに 2 つのベクトルを比較し、小さい方を計算し、要素が NaN場合はもう一方の値を返します。
Multiply<T>(T, Vector256<T>)

ベクトルにスカラーを乗算して、その積を計算します。
Multiply<T>(Vector256<T>, T)

ベクトルにスカラーを乗算して、その積を計算します。
Multiply<T>(Vector256<T>, Vector256<T>)

2 つのベクトルを乗算して要素ごとの積を計算します。
MultiplyAddEstimate(Vector256<Double>, Vector256<Double>, Vector256<Double>)

(left * right) + addendの推定値を計算します。
MultiplyAddEstimate(Vector256<Single>, Vector256<Single>, Vector256<Single>)

(left * right) + addendの推定値を計算します。
Narrow(Vector256<Double>, Vector256<Double>)

2 つの Vector256<T> インスタンスを 1 つの Vector256<T>に絞り込む。
Narrow(Vector256<Int16>, Vector256<Int16>)

2 つの Vector256<T> インスタンスを 1 つの Vector256<T>に絞り込む。
Narrow(Vector256<Int32>, Vector256<Int32>)

2 つの Vector256<T> インスタンスを 1 つの Vector256<T>に絞り込む。
Narrow(Vector256<Int64>, Vector256<Int64>)

2 つの Vector256<T> インスタンスを 1 つの Vector256<T>に絞り込む。
Narrow(Vector256<UInt16>, Vector256<UInt16>)

2 つの Vector256<T> インスタンスを 1 つの Vector256<T>に絞り込む。
Narrow(Vector256<UInt32>, Vector256<UInt32>)

2 つの Vector256<T> インスタンスを 1 つの Vector256<T>に絞り込む。
Narrow(Vector256<UInt64>, Vector256<UInt64>)

2 つの Vector256<T> インスタンスを 1 つの Vector256<T>に絞り込む。
NarrowWithSaturation(Vector256<Double>, Vector256<Double>)

飽和変換を使用して、 Double インスタンスの 2 つのベクトルを Single の 1 つのベクトルに縮小します。
NarrowWithSaturation(Vector256<Int16>, Vector256<Int16>)

飽和変換を使用して、 Int16 インスタンスの 2 つのベクトルを SByte の 1 つのベクトルに縮小します。
NarrowWithSaturation(Vector256<Int32>, Vector256<Int32>)

飽和変換を使用して、 Int32 インスタンスの 2 つのベクトルを Int16 の 1 つのベクトルに縮小します。
NarrowWithSaturation(Vector256<Int64>, Vector256<Int64>)

飽和変換を使用して、 Int64 インスタンスの 2 つのベクトルを Int32 の 1 つのベクトルに縮小します。
NarrowWithSaturation(Vector256<UInt16>, Vector256<UInt16>)

飽和変換を使用して、 UInt16 インスタンスの 2 つのベクトルを Byte の 1 つのベクトルに縮小します。
NarrowWithSaturation(Vector256<UInt32>, Vector256<UInt32>)

飽和変換を使用して、 UInt32 インスタンスの 2 つのベクトルを UInt16 の 1 つのベクトルに縮小します。
NarrowWithSaturation(Vector256<UInt64>, Vector256<UInt64>)

飽和変換を使用して、 UInt64 インスタンスの 2 つのベクトルを UInt32 の 1 つのベクトルに縮小します。
Negate<T>(Vector256<T>)

ベクトルを否定します。
None<T>(Vector256<T>, T)

ベクターの要素が特定の値と等しくないかどうかを判断します。
NoneWhereAllBitsSet<T>(Vector256<T>)

すべてのビットが設定されているベクターの要素がないかどうかを判断します。
OnesComplement<T>(Vector256<T>)

ベクトルの 1-補数を計算します。
RadiansToDegrees(Vector256<Double>)

指定されたベクトルをラジアンから度に変換します。
RadiansToDegrees(Vector256<Single>)

指定されたベクトルをラジアンから度に変換します。
Round(Vector256<Double>, MidpointRounding)

指定した丸めモードを使用して、ベクター内の各要素を最も近い整数に丸めます。
Round(Vector256<Double>)

既定の丸めモード (ToEven) を使用して、ベクター内の各要素を最も近い整数に丸めます。
Round(Vector256<Single>, MidpointRounding)

指定した丸めモードを使用して、ベクター内の各要素を最も近い整数に丸めます。
Round(Vector256<Single>)

既定の丸めモード (ToEven) を使用して、ベクター内の各要素を最も近い整数に丸めます。
ShiftLeft(Vector256<Byte>, Int32)

ベクターの各要素を指定した量だけ左にシフトします。
ShiftLeft(Vector256<Int16>, Int32)

ベクターの各要素を指定した量だけ左にシフトします。
ShiftLeft(Vector256<Int32>, Int32)

ベクターの各要素を指定した量だけ左にシフトします。
ShiftLeft(Vector256<Int64>, Int32)

ベクターの各要素を指定した量だけ左にシフトします。
ShiftLeft(Vector256<IntPtr>, Int32)

ベクターの各要素を指定した量だけ左にシフトします。
ShiftLeft(Vector256<SByte>, Int32)

ベクターの各要素を指定した量だけ左にシフトします。
ShiftLeft(Vector256<UInt16>, Int32)

ベクターの各要素を指定した量だけ左にシフトします。
ShiftLeft(Vector256<UInt32>, Int32)

ベクターの各要素を指定した量だけ左にシフトします。
ShiftLeft(Vector256<UInt64>, Int32)

ベクターの各要素を指定した量だけ左にシフトします。
ShiftLeft(Vector256<UIntPtr>, Int32)

ベクターの各要素を指定した量だけ左にシフトします。
ShiftRightArithmetic(Vector256<Int16>, Int32)

ベクターの各要素を、指定した量だけ右にシフト (符号付き) します。
ShiftRightArithmetic(Vector256<Int32>, Int32)

ベクターの各要素を、指定した量だけ右にシフト (符号付き) します。
ShiftRightArithmetic(Vector256<Int64>, Int32)

ベクターの各要素を、指定した量だけ右にシフト (符号付き) します。
ShiftRightArithmetic(Vector256<IntPtr>, Int32)

ベクターの各要素を、指定した量だけ右にシフト (符号付き) します。
ShiftRightArithmetic(Vector256<SByte>, Int32)

ベクターの各要素を、指定した量だけ右にシフト (符号付き) します。
ShiftRightLogical(Vector256<Byte>, Int32)

ベクターの各要素を、指定した量だけ右にシフト (符号なし) します。
ShiftRightLogical(Vector256<Int16>, Int32)

ベクターの各要素を、指定した量だけ右にシフト (符号なし) します。
ShiftRightLogical(Vector256<Int32>, Int32)

ベクターの各要素を、指定した量だけ右にシフト (符号なし) します。
ShiftRightLogical(Vector256<Int64>, Int32)

ベクターの各要素を、指定した量だけ右にシフト (符号なし) します。
ShiftRightLogical(Vector256<IntPtr>, Int32)

ベクターの各要素を、指定した量だけ右にシフト (符号なし) します。
ShiftRightLogical(Vector256<SByte>, Int32)

ベクターの各要素を、指定した量だけ右にシフト (符号なし) します。
ShiftRightLogical(Vector256<UInt16>, Int32)

ベクターの各要素を、指定した量だけ右にシフト (符号なし) します。
ShiftRightLogical(Vector256<UInt32>, Int32)

ベクターの各要素を、指定した量だけ右にシフト (符号なし) します。
ShiftRightLogical(Vector256<UInt64>, Int32)

ベクターの各要素を、指定した量だけ右にシフト (符号なし) します。
ShiftRightLogical(Vector256<UIntPtr>, Int32)

ベクターの各要素を、指定した量だけ右にシフト (符号なし) します。
Shuffle(Vector256<Byte>, Vector256<Byte>)

一連のインデックスを使用して入力ベクターから値を選択して、新しいベクターを作成します。
Shuffle(Vector256<Double>, Vector256<Int64>)

一連のインデックスを使用して入力ベクターから値を選択して、新しいベクターを作成します。
Shuffle(Vector256<Int16>, Vector256<Int16>)

一連のインデックスを使用して入力ベクターから値を選択して、新しいベクターを作成します。
Shuffle(Vector256<Int32>, Vector256<Int32>)

一連のインデックスを使用して入力ベクターから値を選択して、新しいベクターを作成します。
Shuffle(Vector256<Int64>, Vector256<Int64>)

一連のインデックスを使用して入力ベクターから値を選択して、新しいベクターを作成します。
Shuffle(Vector256<SByte>, Vector256<SByte>)

一連のインデックスを使用して入力ベクターから値を選択して、新しいベクターを作成します。
Shuffle(Vector256<Single>, Vector256<Int32>)

一連のインデックスを使用して入力ベクターから値を選択して、新しいベクターを作成します。
Shuffle(Vector256<UInt16>, Vector256<UInt16>)

一連のインデックスを使用して入力ベクターから値を選択して、新しいベクターを作成します。
Shuffle(Vector256<UInt32>, Vector256<UInt32>)

一連のインデックスを使用して入力ベクターから値を選択して、新しいベクターを作成します。
Shuffle(Vector256<UInt64>, Vector256<UInt64>)

一連のインデックスを使用して入力ベクターから値を選択して、新しいベクターを作成します。
ShuffleNative(Vector256<Byte>, Vector256<Byte>)

一連のインデックスを使用して入力ベクターから値を選択して、新しいベクターを作成します。

動作は、範囲外のインデックスに対してプラットフォームに依存します。
ShuffleNative(Vector256<Double>, Vector256<Int64>)

一連のインデックスを使用して入力ベクターから値を選択して、新しいベクターを作成します。
ShuffleNative(Vector256<Int16>, Vector256<Int16>)

一連のインデックスを使用して入力ベクターから値を選択して、新しいベクターを作成します。
ShuffleNative(Vector256<Int32>, Vector256<Int32>)

一連のインデックスを使用して入力ベクターから値を選択して、新しいベクターを作成します。
ShuffleNative(Vector256<Int64>, Vector256<Int64>)

一連のインデックスを使用して入力ベクターから値を選択して、新しいベクターを作成します。
ShuffleNative(Vector256<SByte>, Vector256<SByte>)

一連のインデックスを使用して入力ベクターから値を選択して、新しいベクターを作成します。

動作は、範囲外のインデックスに対してプラットフォームに依存します。
ShuffleNative(Vector256<Single>, Vector256<Int32>)

一連のインデックスを使用して入力ベクターから値を選択して、新しいベクターを作成します。
ShuffleNative(Vector256<UInt16>, Vector256<UInt16>)

一連のインデックスを使用して入力ベクターから値を選択して、新しいベクターを作成します。
ShuffleNative(Vector256<UInt32>, Vector256<UInt32>)

一連のインデックスを使用して入力ベクターから値を選択して、新しいベクターを作成します。
ShuffleNative(Vector256<UInt64>, Vector256<UInt64>)

一連のインデックスを使用して入力ベクターから値を選択して、新しいベクターを作成します。
Sin(Vector256<Double>)

ベクトル内の各要素のサインを計算します。
Sin(Vector256<Single>)

ベクトル内の各要素のサインを計算します。
SinCos(Vector256<Double>)

ベクトル内の各要素のサインとコサインを計算します。
SinCos(Vector256<Single>)

ベクトル内の各要素のサインとコサインを計算します。
Sqrt<T>(Vector256<T>)

要素ごとにベクターの平方根を計算します。
Store<T>(Vector256<T>, T*)

指定された変換先にベクターを格納します。
StoreAligned<T>(Vector256<T>, T*)

指定された配置先にベクターを格納します。
StoreAlignedNonTemporal<T>(Vector256<T>, T*)

指定された配置先にベクターを格納します。
StoreUnsafe<T>(Vector256<T>, T, UIntPtr)

指定された変換先にベクターを格納します。
StoreUnsafe<T>(Vector256<T>, T)

指定された変換先にベクターを格納します。
Subtract<T>(Vector256<T>, Vector256<T>)

2 つのベクトルを減算して、その差を計算します。
SubtractSaturate<T>(Vector256<T>, Vector256<T>)

要素ごとの飽和差を計算するために、2 つのベクトルを減算します。
Sum<T>(Vector256<T>)

ベクトル内のすべての要素の合計を計算します。
ToScalar<T>(Vector256<T>)

指定されたベクターを、最初の要素の値を含むスカラーに変換します。
ToVector512<T>(Vector256<T>)

指定されたベクターを新しい Vector512<T> に変換し、下位 256 ビットを指定されたベクターの値に設定し、上位 256 ビットを 0 に初期化します。
ToVector512Unsafe<T>(Vector256<T>)

指定されたベクターを新しい Vector512<T> に変換します。下位 256 ビットは、指定されたベクターの値に設定され、上位 256 ビットは初期化されていません。
Truncate(Vector256<Double>)

ベクター内の各要素を切り捨てます。
Truncate(Vector256<Single>)

ベクター内の各要素を切り捨てます。
TryCopyTo<T>(Vector256<T>, Span<T>)

Vector<T>を特定のスパンにコピーしようとします。
Widen(Vector256<Byte>)

Vector256<T>を 2 つのVector256<T>に拡大します。
Widen(Vector256<Int16>)

Vector256<T>を 2 つのVector256<T>に拡大します。
Widen(Vector256<Int32>)

Vector256<T>を 2 つのVector256<T>に拡大します。
Widen(Vector256<SByte>)

Vector256<T>を 2 つのVector256<T>に拡大します。
Widen(Vector256<Single>)

Vector256<T>を 2 つのVector256<T>に拡大します。
Widen(Vector256<UInt16>)

Vector256<T>を 2 つのVector256<T>に拡大します。
Widen(Vector256<UInt32>)

Vector256<T>を 2 つのVector256<T>に拡大します。
WidenLower(Vector256<Byte>)

Vector256<T>の下半分をVector256<T>に拡大します。
WidenLower(Vector256<Int16>)

Vector256<T>の下半分をVector256<T>に拡大します。
WidenLower(Vector256<Int32>)

Vector256<T>の下半分をVector256<T>に拡大します。
WidenLower(Vector256<SByte>)

Vector256<T>の下半分をVector256<T>に拡大します。
WidenLower(Vector256<Single>)

Vector256<T>の下半分をVector256<T>に拡大します。
WidenLower(Vector256<UInt16>)

Vector256<T>の下半分をVector256<T>に拡大します。
WidenLower(Vector256<UInt32>)

Vector256<T>の下半分をVector256<T>に拡大します。
WidenUpper(Vector256<Byte>)

Vector256<T>の上半分をVector256<T>に拡大します。
WidenUpper(Vector256<Int16>)

Vector256<T>の上半分をVector256<T>に拡大します。
WidenUpper(Vector256<Int32>)

Vector256<T>の上半分をVector256<T>に拡大します。
WidenUpper(Vector256<SByte>)

Vector256<T>の上半分をVector256<T>に拡大します。
WidenUpper(Vector256<Single>)

Vector256<T>の上半分をVector256<T>に拡大します。
WidenUpper(Vector256<UInt16>)

Vector256<T>の上半分をVector256<T>に拡大します。
WidenUpper(Vector256<UInt32>)

Vector256<T>の上半分をVector256<T>に拡大します。
WithElement<T>(Vector256<T>, Int32, T)

指定したインデックス位置にある要素を指定した値に設定し、残りの要素を指定されたベクター内の要素と同じ値に設定して、新しい Vector256<T> を作成します。
WithLower<T>(Vector256<T>, Vector128<T>)

下位 128 ビットが指定した値に設定され、上位 128 ビットが指定されたベクターと同じ値に設定された新しい Vector256<T> を作成します。
WithUpper<T>(Vector256<T>, Vector128<T>)

指定した値に上位 128 ビットが設定され、下位 128 ビットが指定されたベクターと同じ値に設定された新しい Vector256<T> を作成します。
Xor<T>(Vector256<T>, Vector256<T>)

2 つのベクトルの排他的または排他的を計算します。

適用対象