次の方法で共有


Tensor クラス

定義

テンソル操作のメソッドを提供します。

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

メソッド

名前 説明
Abs<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

ReadOnlyTensorSpan<T>の各要素の絶対値を取得し、結果を含む新しいTensorSpan<T>を返します。

Abs<T>(ReadOnlyTensorSpan<T>)

Tensor<T>の各要素の絶対値を取得し、結果を含む新しいTensor<T>を返します。

Acos<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Tensor<T>の各要素の逆コサインを受け取り、結果を含む新しいTensor<T>を返します。

Acos<T>(ReadOnlyTensorSpan<T>)

Tensor<T>の各要素の逆コサインを受け取り、結果を含む新しいTensor<T>を返します。

Acosh<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

TensorSpan<T>の各要素の逆双曲線余弦を取得し、結果を含む新しいTensorSpan<T>を返します。

Acosh<T>(ReadOnlyTensorSpan<T>)

ReadOnlyTensorSpan<T>の各要素の逆双曲線余弦を取得し、結果を含む新しいTensor<T>を返します。

AcosPi<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

TensorSpan<T>の各要素の pi で除算された逆双曲線余弦を受け取り、結果と共に新しいTensorSpan<T>を返します。

AcosPi<T>(ReadOnlyTensorSpan<T>)

Tensor<T>の各要素の pi で除算された逆双曲線余弦を受け取り、結果と共に新しいTensor<T>を返します。

Add<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)

2 つのテンソル間で要素ごとの加算を実行します。

Add<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

2 つのテンソル間で要素ごとの加算を実行します。

Add<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<T>)

テンソルとスカラーの間で要素ごとの加算を実行します。

Add<T>(ReadOnlyTensorSpan<T>, T)

テンソルとスカラーの間で要素ごとの加算を実行します。

Asin<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

ReadOnlyTensorSpan<T>の各要素の逆 sin を受け取り、結果を含む新しいTensorSpan<T>を返します。

Asin<T>(ReadOnlyTensorSpan<T>)

ReadOnlyTensorSpan<T>の各要素の逆 sin を受け取り、結果を含む新しいTensor<T>を返します。

Asinh<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

ReadOnlyTensorSpan<T>の各要素の逆双曲線正弦を受け取り、結果と共に新しいTensorSpan<T>を返します。

Asinh<T>(ReadOnlyTensorSpan<T>)

ReadOnlyTensorSpan<T>の各要素の逆双曲線正弦を受け取り、結果と共に新しいTensor<T>を返します。

AsinPi<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

ReadOnlyTensorSpan<T>の各要素の pi で除算された逆双曲線正弦を受け取り、結果を含む新しいTensorSpan<T>を返します。

AsinPi<T>(ReadOnlyTensorSpan<T>)

ReadOnlyTensorSpan<T>の各要素の pi で除算された逆双曲線正弦を受け取り、結果を含む新しいTensor<T>を返します。

AsReadOnlyTensorSpan<T>(T[], Int32, ReadOnlySpan<IntPtr>, ReadOnlySpan<IntPtr>)

指定した開始インデックスから始まり、指定した長さとストライドを使用して、ターゲット配列の一部に対して新しいテンソルを作成します。

AsReadOnlyTensorSpan<T>(T[], ReadOnlySpan<IntPtr>, ReadOnlySpan<IntPtr>)

指定した開始インデックスから始まり、指定した長さとストライドを使用して、ターゲット配列の一部に対して新しいテンソルを作成します。

AsReadOnlyTensorSpan<T>(T[], ReadOnlySpan<IntPtr>)

配列から TensorSpan をより簡単に作成するための拡張メソッド。

AsReadOnlyTensorSpan<T>(T[])

ターゲット配列全体に対して新しいテンソルを作成します。

AsTensorSpan<T>(T[], Int32, ReadOnlySpan<IntPtr>, ReadOnlySpan<IntPtr>)

'start' インデックスから始まり、'end' インデックスで終わるターゲット配列の部分に対して新しいスパンを作成します (排他的)。

AsTensorSpan<T>(T[], ReadOnlySpan<IntPtr>, ReadOnlySpan<IntPtr>)

テンソル操作のメソッドを提供します。

AsTensorSpan<T>(T[], ReadOnlySpan<IntPtr>)

配列から TensorSpan をより簡単に作成するための拡張メソッド。

AsTensorSpan<T>(T[])

ターゲット配列全体に対して新しいスパンを作成します。

Atan<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

ReadOnlyTensorSpan<T>の各要素のアークタンジェントを取得し、結果を含む新しいTensorSpan<T>を返します。

Atan<T>(ReadOnlyTensorSpan<T>)

ReadOnlyTensorSpan<T>の各要素のアークタンジェントを取得し、結果を含む新しいTensor<T>を返します。

Atan2<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)

2 つの入力 ReadOnlyTensorSpan<T> のアーク タンジェントを取得し、結果を含む新しい TensorSpan<T> を返します。

Atan2<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

2 つの入力 ReadOnlyTensorSpan<T> のアーク タンジェントを取得し、結果を含む新しい Tensor<T> を返します。

Atan2<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<T>)

2 つの入力 ReadOnlyTensorSpan<T> のアーク タンジェントを取得し、結果を含む新しい TensorSpan<T> を返します。

Atan2<T>(ReadOnlyTensorSpan<T>, T)

2 つの入力 ReadOnlyTensorSpan<T> のアーク タンジェントを取得し、結果を含む新しい Tensor<T> を返します。

Atan2<T>(T, ReadOnlyTensorSpan<T>, TensorSpan<T>)

2 つの入力 ReadOnlyTensorSpan<T> のアーク タンジェントを取得し、結果を含む新しい TensorSpan<T> を返します。

Atan2<T>(T, ReadOnlyTensorSpan<T>)

2 つの入力 ReadOnlyTensorSpan<T> のアーク タンジェントを取得し、結果を含む新しい Tensor<T> を返します。

Atan2Pi<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)

2 つの入力 ReadOnlyTensorSpan<T>のアークタンジェントを取得し、各要素を pi で除算し、結果を含む新しい TensorSpan<T> を返します。

Atan2Pi<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

2 つの入力 ReadOnlyTensorSpan<T>のアークタンジェントを取得し、各要素を pi で除算し、結果を含む新しい Tensor<T> を返します。

Atan2Pi<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<T>)

2 つの入力 ReadOnlyTensorSpan<T>のアークタンジェントを取得し、各要素を pi で除算し、結果を含む新しい TensorSpan<T> を返します。

Atan2Pi<T>(ReadOnlyTensorSpan<T>, T)

2 つの入力 ReadOnlyTensorSpan<T>のアークタンジェントを取得し、各要素を pi で除算し、結果を含む新しい TensorSpan<T> を返します。

Atan2Pi<T>(T, ReadOnlyTensorSpan<T>, TensorSpan<T>)

2 つの入力 ReadOnlyTensorSpan<T>のアークタンジェントを取得し、各要素を pi で除算し、結果を含む新しい TensorSpan<T> を返します。

Atan2Pi<T>(T, ReadOnlyTensorSpan<T>)

2 つの入力 ReadOnlyTensorSpan<T>のアークタンジェントを取得し、各要素を pi で除算し、結果を含む新しい TensorSpan<T> を返します。

Atanh<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

ReadOnlyTensorSpan<T>の各要素の逆双曲線正接を取得し、結果を含む新しいTensorSpan<T>を返します。

Atanh<T>(ReadOnlyTensorSpan<T>)

ReadOnlyTensorSpan<T>の各要素の逆双曲線正接を取得し、結果を含む新しいTensor<T>を返します。

AtanPi<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

ReadOnlyTensorSpan<T>の各要素の pi で除算された逆双曲線正接を受け取り、結果と共に新しいTensorSpan<T>を返します。

AtanPi<T>(ReadOnlyTensorSpan<T>)

ReadOnlyTensorSpan<T>の各要素の pi で除算された逆双曲線正接を受け取り、結果と共に新しいTensor<T>を返します。

Average<T>(ReadOnlyTensorSpan<T>)

x テンソル内の要素の平均を返します。

BitwiseAnd<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)

ビットごとの、および 2 つのテンソル間を実行します。

BitwiseAnd<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

ビットごとの、および 2 つのテンソル間を実行します。

BitwiseAnd<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<T>)

テンソルとスカラーの間でビットごとの実行を行います。

BitwiseAnd<T>(ReadOnlyTensorSpan<T>, T)

テンソルとスカラーの間でビットごとの実行を行います。

BitwiseOr<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)

ビット単位または 2 つのテンソルの間で実行します。

BitwiseOr<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

ビット単位または 2 つのテンソルの間で実行します。

BitwiseOr<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<T>)

テンソルとスカラーの間でビット単位またはビット単位で実行します。

BitwiseOr<T>(ReadOnlyTensorSpan<T>, T)

テンソルとスカラーの間でビット単位またはビット単位で実行します。

Broadcast<T>(ReadOnlyTensorSpan<T>, ReadOnlySpan<IntPtr>)

データを source から新しい図形 lengthsにブロードキャストします。 新しい Tensor<T> を作成し、新しいメモリを割り当てます。 sourceの図形が新しい図形と互換性がない場合は、例外がスローされます。

Broadcast<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

sourceから、lengthsSourceと互換性のある最小のブロードキャスト可能な図形にデータをブロードキャストします。 新しい Tensor<T> を作成し、新しいメモリを割り当てます。

BroadcastTo<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

データを source から destinationにブロードキャストします。

BroadcastTo<T>(Tensor<T>, TensorSpan<T>)

データを source から destinationにブロードキャストします。

BroadcastTo<T>(TensorSpan<T>, TensorSpan<T>)

データを source から destinationにブロードキャストします。

Cbrt<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

入力 ReadOnlyTensorSpan<T> の要素ごとのキューブ ルートを計算し、結果を含む新しい TensorSpan<T> を返します。

Cbrt<T>(ReadOnlyTensorSpan<T>)

入力 ReadOnlyTensorSpan<T> の要素ごとのキューブ ルートを計算し、結果を含む新しい Tensor<T> を返します。

Ceiling<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

入力 ReadOnlyTensorSpan<T> の要素ごとの上限を計算し、結果を含む新しい TensorSpan<T> を返します。

Ceiling<T>(ReadOnlyTensorSpan<T>)

入力 ReadOnlyTensorSpan<T> の要素ごとの上限を計算し、結果を含む新しい Tensor<T> を返します。

Concatenate<T>(ReadOnlySpan<Tensor<T>>, TensorSpan<T>)

既存の軸に沿ってテンソルのシーケンスを結合します。

Concatenate<T>(ReadOnlySpan<Tensor<T>>)

既存の軸に沿ってテンソルのシーケンスを結合します。

ConcatenateOnDimension<T>(Int32, ReadOnlySpan<Tensor<T>>, TensorSpan<T>)

既存の軸に沿ってテンソルのシーケンスを結合します。

ConcatenateOnDimension<T>(Int32, ReadOnlySpan<Tensor<T>>)

既存の軸に沿ってテンソルのシーケンスを結合します。

ConvertChecked<TFrom,TTo>(ReadOnlyTensorSpan<TFrom>, TensorSpan<TTo>)

sourceを新しいTensorSpan<T>にコピーし、各TFrom値をTTo値に変換します。

ConvertChecked<TFrom,TTo>(ReadOnlyTensorSpan<TFrom>)

sourceを新しいReadOnlyTensorSpan<T>にコピーし、各TFrom値をTTo値に変換します。

ConvertSaturating<TFrom,TTo>(ReadOnlyTensorSpan<TFrom>, TensorSpan<TTo>)

sourceを新しいTensorSpan<T>にコピーし、各TFrom値をTTo値に変換します。

ConvertSaturating<TFrom,TTo>(ReadOnlyTensorSpan<TFrom>)

sourceを新しいReadOnlyTensorSpan<T>にコピーし、各TFrom値をTTo値に変換します。

ConvertTruncating<TFrom,TTo>(ReadOnlyTensorSpan<TFrom>, TensorSpan<TTo>)

sourceを新しいTensorSpan<T>にコピーし、各TFrom値をTTo値に変換します。

ConvertTruncating<TFrom,TTo>(ReadOnlyTensorSpan<TFrom>)

sourceを新しいReadOnlyTensorSpan<T>にコピーし、各TFrom値をTTo値に変換します。

CopySign<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)

指定したテンソル内の 1 つの数値から別の数値に符号をコピーした要素ごとの結果を計算し、結果を含む新しい TensorSpan<T> を返します。

CopySign<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

指定したテンソル内の 1 つの数値から別の数値に符号をコピーした要素ごとの結果を計算し、結果を含む新しい Tensor<T> を返します。

CopySign<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<T>)

指定したテンソル内の 1 つの数値から別の数値に符号をコピーした要素ごとの結果を計算し、結果を含む新しいテンソルを返します。

CopySign<T>(ReadOnlyTensorSpan<T>, T)

指定したテンソル内の 1 つの数値から別の数値に符号をコピーした要素ごとの結果を計算し、結果を含む新しいテンソルを返します。

Cos<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

ReadOnlyTensorSpan<T>の各要素のコサインを取得し、結果を含む新しいTensorSpan<T>を返します。

Cos<T>(ReadOnlyTensorSpan<T>)

ReadOnlyTensorSpan<T>の各要素のコサインを取得し、結果を含む新しいTensor<T>を返します。

Cosh<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

ReadOnlyTensorSpan<T>の各要素の双曲線余弦を取得し、結果を含む新しいTensorSpan<T>を返します。

Cosh<T>(ReadOnlyTensorSpan<T>)

ReadOnlyTensorSpan<T>の各要素の双曲線余弦を取得し、結果を含む新しいTensor<T>を返します。

CosineSimilarity<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

xyの間のコサインの類似性を計算します。

CosPi<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Pi を乗算した、指定したテンソル内の値の要素ごとのコサインを計算し、結果と共に新しい TensorSpan<T> を返します。

CosPi<T>(ReadOnlyTensorSpan<T>)

Pi を乗算した、指定したテンソル内の値の要素ごとのコサインを計算し、結果と共に新しい Tensor<T> を返します。

Create<T>(T[], Int32, ReadOnlySpan<IntPtr>, ReadOnlySpan<IntPtr>)

指定した開始インデックスから始まり、指定した長さとストライドを使用して、ターゲット配列の一部に対して新しいテンソルを作成します。

Create<T>(T[], ReadOnlySpan<IntPtr>, ReadOnlySpan<IntPtr>)

指定した開始インデックスから始まり、指定した長さとストライドを使用して、ターゲット配列の一部に対して新しいテンソルを作成します。

Create<T>(T[], ReadOnlySpan<IntPtr>)

指定した長さを使用して、ターゲット配列の一部に新しいテンソルを作成します。

Create<T>(T[])

ターゲット配列全体に対して新しいテンソルを作成します。

CreateFromShape<T>(ReadOnlySpan<IntPtr>, Boolean)

指定した長さの新しいテンソルを作成します。

CreateFromShape<T>(ReadOnlySpan<IntPtr>, ReadOnlySpan<IntPtr>, Boolean)

指定した長さとストライドを持つ新しいテンソルを作成します。

CreateFromShapeUninitialized<T>(ReadOnlySpan<IntPtr>, Boolean)

指定した長さとストライドを持つ新しいテンソルを作成します。

CreateFromShapeUninitialized<T>(ReadOnlySpan<IntPtr>, ReadOnlySpan<IntPtr>, Boolean)

指定した長さとストライドを持つ新しいテンソルを作成します。 pinnedが true の場合、基になるバッファーは永続的に固定されて作成されます。それ以外の場合、基になるバッファーは固定されません。 基になるバッファーが初期化されていません。

Decrement<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

テンソルに対してデクリメントを実行します。

Decrement<T>(ReadOnlyTensorSpan<T>)

テンソルに対してデクリメントを実行します。

DegreesToRadians<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

指定したテンソルの各度数からラジアンへの要素ごとの変換を計算し、結果を含む新しいテンソルを返します。

DegreesToRadians<T>(ReadOnlyTensorSpan<T>)

指定したテンソルの各度数からラジアンへの要素ごとの変換を計算し、結果を含む新しいテンソルを返します。

Distance<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

ユークリッド空間で、数値の長さが等しい空でないテンソルとして指定された 2 つのポイント間の距離を計算します。

Divide<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)

2 つのテンソル間で要素ごとの除算を実行します。

Divide<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

2 つのテンソル間で要素ごとの除算を実行します。

Divide<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<T>)

テンソルとスカラーの間で要素ごとの除算を実行します。

Divide<T>(ReadOnlyTensorSpan<T>, T)

テンソルとスカラーの間で要素ごとの除算を実行します。

Divide<T>(T, ReadOnlyTensorSpan<T>, TensorSpan<T>)

テンソルとスカラーの間で要素ごとの除算を実行します。

Divide<T>(T, ReadOnlyTensorSpan<T>)

テンソルとスカラーの間で要素ごとの除算を実行します。

Dot<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

数値を含む 2 つのテンソルのドット積を計算します。

Equals<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<Boolean>)

2 つの ReadOnlyTensorSpan<T> の要素を等しいかどうかを比較します。 図形が同じでない場合は、テンソルが比較される前に、最小のブロードキャスト可能なサイズにブロードキャストされます。 要素が等しい場合は値が true、等しくない場合は false である TensorSpan<T> を返します。/>

Equals<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

2 つの ReadOnlyTensorSpan<T> の要素を等しいかどうかを比較します。 図形が同じでない場合は、テンソルが比較される前に、最小のブロードキャスト可能なサイズにブロードキャストされます。 要素が等しい場合は値が true、等しくない場合は false である TensorSpan<T> を返します。/>

Equals<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<Boolean>)

2 つの ReadOnlyTensorSpan<T> の要素を等しいかどうかを比較します。 図形が同じでない場合は、テンソルが比較される前に、最小のブロードキャスト可能なサイズにブロードキャストされます。 要素が等しい場合は値が true、等しくない場合は false である TensorSpan<T> を返します。/>

Equals<T>(ReadOnlyTensorSpan<T>, T)

2 つの ReadOnlyTensorSpan<T> の要素を等しいかどうかを比較します。 図形が同じでない場合は、テンソルが比較される前に、最小のブロードキャスト可能なサイズにブロードキャストされます。 要素が等しい場合は値が true、等しくない場合は false である TensorSpan<T> を返します。/>

EqualsAll<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

2 つの ReadOnlyTensorSpan<T> の要素を比較して、 x のすべての要素が yと等しいかどうかを確認します。 図形が同じでない場合は、テンソルが比較される前に、最小のブロードキャスト可能なサイズにブロードキャストされます。 x内のすべての要素がyに等しい場合、値が true のBooleanを返します。

EqualsAll<T>(ReadOnlyTensorSpan<T>, T)

2 つの ReadOnlyTensorSpan<T> の要素を比較して、 x のすべての要素が yと等しいかどうかを確認します。 図形が同じでない場合は、テンソルが比較される前に、最小のブロードキャスト可能なサイズにブロードキャストされます。 x内のすべての要素がyに等しい場合、値が true のBooleanを返します。

EqualsAny<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

2 つの ReadOnlyTensorSpan<T> の要素を比較して、 x の要素が yと等しいかどうかを確認します。 図形が同じでない場合は、テンソルが比較される前に、最小のブロードキャスト可能なサイズにブロードキャストされます。 x内の要素がyと等しい場合、値が true のBooleanを返します。

EqualsAny<T>(ReadOnlyTensorSpan<T>, T)

2 つの ReadOnlyTensorSpan<T> の要素を比較して、 x の要素が yと等しいかどうかを確認します。 図形が同じでない場合は、テンソルが比較される前に、最小のブロードキャスト可能なサイズにブロードキャストされます。 x内の要素がyと等しい場合、値が true のBooleanを返します。

Exp<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

指定したテンソルの単精度浮動小数点数の累乗に e を上げた要素ごとの結果を計算します。

Exp<T>(ReadOnlyTensorSpan<T>)

指定したテンソルの単精度浮動小数点数の累乗に e を上げた要素ごとの結果を計算します。

Exp10<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

10 を指定したテンソルの数値累乗に引き上げた要素ごとの結果を計算します。

Exp10<T>(ReadOnlyTensorSpan<T>)

10 を指定したテンソルの数値累乗に引き上げた要素ごとの結果を計算します。

Exp10M1<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

10 を指定したテンソルの累乗数から 1 を引いた数値に引いた要素ごとの結果を計算します。

Exp10M1<T>(ReadOnlyTensorSpan<T>)

10 を指定したテンソルの累乗数から 1 を引いた数値に引いた要素ごとの結果を計算します。

Exp2<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

2 を指定したテンソル内の累乗数に引き上げた要素ごとの結果を計算します。

Exp2<T>(ReadOnlyTensorSpan<T>)

2 を指定したテンソル内の累乗数に引き上げた要素ごとの結果を計算します。

Exp2M1<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

2 を指定したテンソルから 1 を引いた数値の累乗まで上げた要素ごとの結果を計算します。

Exp2M1<T>(ReadOnlyTensorSpan<T>)

2 を指定したテンソルから 1 を引いた数値の累乗まで上げた要素ごとの結果を計算します。

ExpM1<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

指定したテンソルの数値乗 (- 1) に e を上げた要素ごとの結果を計算します。

ExpM1<T>(ReadOnlyTensorSpan<T>)

指定したテンソルの数値乗 (- 1) に e を上げた要素ごとの結果を計算します。

FillGaussianNormalDistribution<T>(TensorSpan<T>, Random)

指定された TensorSpan<T> にガウス正規分布のランダム データを入力します。 Random は、必要に応じてシード処理用に提供できます。

FillUniformDistribution<T>(TensorSpan<T>, Random)

指定された TensorSpan<T> に、均一な分布のランダム なデータを入力します。 Random は、必要に応じてシード処理用に提供できます。

FilteredUpdate<T>(TensorSpan<T>, ReadOnlyTensorSpan<Boolean>, ReadOnlyTensorSpan<T>)

filterが true のvaluestensorテンソルを更新します。 ディメンションが同じでない場合は、例外がスローされます。

FilteredUpdate<T>(TensorSpan<T>, ReadOnlyTensorSpan<Boolean>, T)

filterが true のvaluetensorテンソルを更新します。

Floor<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

指定したテンソル内の数値の要素ごとの階数を計算します。

Floor<T>(ReadOnlyTensorSpan<T>)

指定したテンソル内の数値の要素ごとの階数を計算します。

GreaterThan<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<Boolean>)

2 つの ReadOnlyTensorSpan<T> の要素を比較して、 x のどの要素が yより大きいかを確認します。 図形が同じでない場合は、テンソルが比較される前に、最小のブロードキャスト可能なサイズにブロードキャストされます。 x内の要素がyより大きい場合は true、そうでない場合は false であるTensor<T>を返します。/>

GreaterThan<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

2 つの ReadOnlyTensorSpan<T> の要素を比較して、 x のどの要素が yより大きいかを確認します。 図形が同じでない場合は、テンソルが比較される前に、最小のブロードキャスト可能なサイズにブロードキャストされます。 x内の要素がyより大きい場合は true、そうでない場合は false であるTensor<T>を返します。/>

GreaterThan<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<Boolean>)

ReadOnlyTensorSpan<T>の要素を比較して、yより大きい要素を確認します。 x内の要素がyより大きい場合は true、そうでない場合は false であるTensor<T>を返します。/>

GreaterThan<T>(ReadOnlyTensorSpan<T>, T)

ReadOnlyTensorSpan<T>の要素を比較して、yより大きい要素を確認します。 x内の要素がyより大きい場合は true、そうでない場合は false であるTensor<T>を返します。/>

GreaterThan<T>(T, ReadOnlyTensorSpan<T>, TensorSpan<Boolean>)

xを比較して、yより大きい要素を確認します。 x内の要素がyより大きい場合は true、そうでない場合は false であるTensor<T>を返します。/>

GreaterThan<T>(T, ReadOnlyTensorSpan<T>)

xを比較して、yより大きい要素を確認します。 x内の要素がyより大きい場合は true、そうでない場合は false であるTensor<T>を返します。/>

GreaterThanAll<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

2 つの ReadOnlyTensorSpan<T> の要素を比較して、 x のすべての要素が yより大きいかどうかを確認します。 図形が同じでない場合は、テンソルが比較される前に、最小のブロードキャスト可能なサイズにブロードキャストされます。 x内のすべての要素がyより大きい場合、値が true であるBooleanを返します。

GreaterThanAll<T>(ReadOnlyTensorSpan<T>, T)

2 つの ReadOnlyTensorSpan<T> の要素を比較して、 x のすべての要素が yより大きいかどうかを確認します。 図形が同じでない場合は、テンソルが比較される前に、最小のブロードキャスト可能なサイズにブロードキャストされます。 x内のすべての要素がyより大きい場合、値が true であるBooleanを返します。

GreaterThanAll<T>(T, ReadOnlyTensorSpan<T>)

2 つの ReadOnlyTensorSpan<T> の要素を比較して、 y のすべての要素が yより大きいかどうかを確認します。 図形が同じでない場合は、テンソルが比較される前に、最小のブロードキャスト可能なサイズにブロードキャストされます。 y内のすべての要素がyより大きい場合、値が true であるBooleanを返します。

GreaterThanAny<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

2 つの ReadOnlyTensorSpan<T> の要素を比較して、 x の要素が yより大きいかどうかを確認します。 図形が同じでない場合は、テンソルが比較される前に、最小のブロードキャスト可能なサイズにブロードキャストされます。 x内の要素がyより大きい場合、値が true であるBooleanを返します。

GreaterThanAny<T>(ReadOnlyTensorSpan<T>, T)

2 つの ReadOnlyTensorSpan<T> の要素を比較して、 x の要素が yより大きいかどうかを確認します。 図形が同じでない場合は、テンソルが比較される前に、最小のブロードキャスト可能なサイズにブロードキャストされます。 x内の要素がyより大きい場合、値が true であるBooleanを返します。

GreaterThanAny<T>(T, ReadOnlyTensorSpan<T>)

2 つの ReadOnlyTensorSpan<T> の要素を比較して、 y の要素が xより大きいかどうかを確認します。 図形が同じでない場合は、テンソルが比較される前に、最小のブロードキャスト可能なサイズにブロードキャストされます。 y内の要素がxより大きい場合、値が true であるBooleanを返します。

GreaterThanOrEqual<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<Boolean>)

2 つの ReadOnlyTensorSpan<T> の要素を比較して、 x のどの要素が y以上であるかを確認します。 図形が同じでない場合は、テンソルが比較される前に、最小のブロードキャスト可能なサイズにブロードキャストされます。 x内の要素がyより大きい場合は true、そうでない場合は false であるTensor<T>を返します。/>

GreaterThanOrEqual<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

2 つの ReadOnlyTensorSpan<T> の要素を比較して、 x のどの要素が y以上であるかを確認します。 図形が同じでない場合は、テンソルが比較される前に、最小のブロードキャスト可能なサイズにブロードキャストされます。 x内の要素がyより大きい場合は true、そうでない場合は false であるTensor<T>を返します。/>

GreaterThanOrEqual<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<Boolean>)

ReadOnlyTensorSpan<T>の要素を比較して、y以上の要素を確認します。 x内の要素がyより大きい場合は true、そうでない場合は false であるTensor<T>を返します。/>

GreaterThanOrEqual<T>(ReadOnlyTensorSpan<T>, T)

ReadOnlyTensorSpan<T>の要素を比較して、y以上の要素を確認します。 x内の要素がyより大きい場合は true、そうでない場合は false であるTensor<T>を返します。/>

GreaterThanOrEqual<T>(T, ReadOnlyTensorSpan<T>, TensorSpan<Boolean>)

xを比較して、y以上の要素を確認します。 x内の要素がyより大きい場合は true、そうでない場合は false であるTensor<T>を返します。/>

GreaterThanOrEqual<T>(T, ReadOnlyTensorSpan<T>)

xを比較して、y以上の要素を確認します。 x内の要素がyより大きい場合は true、そうでない場合は false であるTensor<T>を返します。/>

GreaterThanOrEqualAll<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

2 つの ReadOnlyTensorSpan<T> の要素を比較して、 x のすべての要素が yより大きいかどうかを確認します。 図形が同じでない場合は、テンソルが比較される前に、最小のブロードキャスト可能なサイズにブロードキャストされます。 x内のすべての要素がyより大きい場合、値が true であるBooleanを返します。

GreaterThanOrEqualAll<T>(ReadOnlyTensorSpan<T>, T)

2 つの ReadOnlyTensorSpan<T> の要素を比較して、 x のすべての要素が yより大きいかどうかを確認します。 図形が同じでない場合は、テンソルが比較される前に、最小のブロードキャスト可能なサイズにブロードキャストされます。 x内のすべての要素がyより大きい場合、値が true であるBooleanを返します。

GreaterThanOrEqualAll<T>(T, ReadOnlyTensorSpan<T>)

2 つの ReadOnlyTensorSpan<T> の要素を比較して、 y のすべての要素が yより大きいかどうかを確認します。 図形が同じでない場合は、テンソルが比較される前に、最小のブロードキャスト可能なサイズにブロードキャストされます。 y内のすべての要素がyより大きい場合、値が true であるBooleanを返します。

GreaterThanOrEqualAny<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

2 つの ReadOnlyTensorSpan<T> の要素を比較して、 x の要素が yより大きいかどうかを確認します。 図形が同じでない場合は、テンソルが比較される前に、最小のブロードキャスト可能なサイズにブロードキャストされます。 x内の要素がyより大きい場合、値が true であるBooleanを返します。

GreaterThanOrEqualAny<T>(ReadOnlyTensorSpan<T>, T)

2 つの ReadOnlyTensorSpan<T> の要素を比較して、 x の要素が yより大きいかどうかを確認します。 図形が同じでない場合は、テンソルが比較される前に、最小のブロードキャスト可能なサイズにブロードキャストされます。 x内の要素がyより大きい場合、値が true であるBooleanを返します。

GreaterThanOrEqualAny<T>(T, ReadOnlyTensorSpan<T>)

2 つの ReadOnlyTensorSpan<T> の要素を比較して、 y の要素が xより大きいかどうかを確認します。 図形が同じでない場合は、テンソルが比較される前に、最小のブロードキャスト可能なサイズにブロードキャストされます。 y内の要素がxより大きい場合、値が true であるBooleanを返します。

Hypot<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)

直角三角形の短辺の長さを表す 2 つのテンソルから指定された値を、要素ごとの低血圧を計算します。 図形が同じでない場合は、最小の互換性のある図形にブロードキャストされます。

Hypot<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

直角三角形の短辺の長さを表す 2 つのテンソルから指定された値を、要素ごとの低血圧を計算します。 図形が同じでない場合は、最小の互換性のある図形にブロードキャストされます。

Ieee754Remainder<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)

指定したテンソル内の数値の要素ごとの剰余を計算します。

Ieee754Remainder<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

指定したテンソル内の数値の要素ごとの剰余を計算します。

Ieee754Remainder<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<T>)

指定したテンソル内の数値の要素ごとの剰余を計算します。

Ieee754Remainder<T>(ReadOnlyTensorSpan<T>, T)

指定したテンソル内の数値の要素ごとの剰余を計算します。

Ieee754Remainder<T>(T, ReadOnlyTensorSpan<T>, TensorSpan<T>)

指定したテンソル内の数値の要素ごとの剰余を計算します。

Ieee754Remainder<T>(T, ReadOnlyTensorSpan<T>)

指定したテンソル内の数値の要素ごとの剰余を計算します。

ILogB<T>(ReadOnlyTensorSpan<T>, TensorSpan<Int32>)

指定したテンソル内の数値の要素ごとの整数対数を計算します。

ILogB<T>(ReadOnlyTensorSpan<T>)

指定したテンソル内の数値の要素ごとの整数対数を計算します。

Increment<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

テンソルに対してインクリメントを実行します。

Increment<T>(ReadOnlyTensorSpan<T>)

テンソルに対してインクリメントを実行します。

IndexOfMax<T>(ReadOnlyTensorSpan<T>)

指定したテンソル内の最も大きい数値のインデックスを検索します。

IndexOfMaxMagnitude<T>(ReadOnlyTensorSpan<T>)

指定したテンソルの最大の大きさを持つ数値のインデックスを検索します。

IndexOfMin<T>(ReadOnlyTensorSpan<T>)

指定したテンソル内の最小数のインデックスを検索します。

IndexOfMinMagnitude<T>(ReadOnlyTensorSpan<T>)

指定したテンソルの最小の大きさを持つ数値のインデックスを検索します。

LeadingZeroCount<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

指定したテンソル内の数値の要素ごとの先行ゼロカウントを計算します。

LeadingZeroCount<T>(ReadOnlyTensorSpan<T>)

指定したテンソル内の数値の要素ごとの先行ゼロカウントを計算します。

LessThan<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<Boolean>)

2 つの ReadOnlyTensorSpan<T> の要素を比較して、 x のどの要素が y未満であるかを確認します。 図形が同じでない場合は、テンソルが比較される前に、最小のブロードキャスト可能なサイズにブロードキャストされます。 x内の要素がy未満の場合は true、そうでない場合は false であるTensor<T>を返します。/>

LessThan<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

2 つの ReadOnlyTensorSpan<T> の要素を比較して、 x のどの要素が y未満であるかを確認します。 図形が同じでない場合は、テンソルが比較される前に、最小のブロードキャスト可能なサイズにブロードキャストされます。 x内の要素がy未満の場合は true、そうでない場合は false であるTensor<T>を返します。/>

LessThan<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<Boolean>)

Tensor<T>の要素を比較して、y未満の要素を確認します。 x内の要素がy未満の場合は true、そうでない場合は false であるTensor<T>を返します。/>

LessThan<T>(ReadOnlyTensorSpan<T>, T)

Tensor<T>の要素を比較して、y未満の要素を確認します。 x内の要素がy未満の場合は true、そうでない場合は false であるTensor<T>を返します。/>

LessThan<T>(T, ReadOnlyTensorSpan<T>, TensorSpan<Boolean>)

Tensor<T>の要素を比較して、y未満の要素を確認します。 x内の要素がy未満の場合は true、そうでない場合は false であるTensor<T>を返します。/>

LessThan<T>(T, ReadOnlyTensorSpan<T>)

Tensor<T>の要素を比較して、y未満の要素を確認します。 x内の要素がy未満の場合は true、そうでない場合は false であるTensor<T>を返します。/>

LessThanAll<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

2 つの ReadOnlyTensorSpan<T> の要素を比較して、 x のすべての要素が y未満かどうかを確認します。 図形が同じでない場合は、テンソルが比較される前に、最小のブロードキャスト可能なサイズにブロードキャストされます。 x内のすべての要素がy未満の場合、値が true であるBooleanを返します。

LessThanAll<T>(ReadOnlyTensorSpan<T>, T)

2 つの ReadOnlyTensorSpan<T> の要素を比較して、 x のすべての要素が y未満かどうかを確認します。 図形が同じでない場合は、テンソルが比較される前に、最小のブロードキャスト可能なサイズにブロードキャストされます。 x内のすべての要素がy未満の場合、値が true であるBooleanを返します。

LessThanAll<T>(T, ReadOnlyTensorSpan<T>)

2 つの ReadOnlyTensorSpan<T> の要素を比較して、 y のすべての要素が x未満かどうかを確認します。 図形が同じでない場合は、テンソルが比較される前に、最小のブロードキャスト可能なサイズにブロードキャストされます。 y内のすべての要素がx未満の場合、値が true であるBooleanを返します。

LessThanAny<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

2 つの ReadOnlyTensorSpan<T> の要素を比較して、 x の要素が y未満かどうかを確認します。 図形が同じでない場合は、テンソルが比較される前に、最小のブロードキャスト可能なサイズにブロードキャストされます。 x内の要素がy未満の場合、値が true のBooleanを返します。

LessThanAny<T>(ReadOnlyTensorSpan<T>, T)

2 つの ReadOnlyTensorSpan<T> の要素を比較して、 x の要素が y未満かどうかを確認します。 図形が同じでない場合は、テンソルが比較される前に、最小のブロードキャスト可能なサイズにブロードキャストされます。 x内の要素がy未満の場合、値が true のBooleanを返します。

LessThanAny<T>(T, ReadOnlyTensorSpan<T>)

2 つの ReadOnlyTensorSpan<T> の要素を比較して、 y の要素が y未満かどうかを確認します。 図形が同じでない場合は、テンソルが比較される前に、最小のブロードキャスト可能なサイズにブロードキャストされます。 y内の要素がy未満の場合、値が true のBooleanを返します。

LessThanOrEqual<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<Boolean>)

2 つの ReadOnlyTensorSpan<T> の要素を比較して、 x のどの要素が y未満であるかを確認します。 図形が同じでない場合は、テンソルが比較される前に、最小のブロードキャスト可能なサイズにブロードキャストされます。 x内の要素がy未満の場合は true、そうでない場合は false であるTensor<T>を返します。/>

LessThanOrEqual<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

2 つの ReadOnlyTensorSpan<T> の要素を比較して、 x のどの要素が y未満であるかを確認します。 図形が同じでない場合は、テンソルが比較される前に、最小のブロードキャスト可能なサイズにブロードキャストされます。 x内の要素がy未満の場合は true、そうでない場合は false であるTensor<T>を返します。/>

LessThanOrEqual<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<Boolean>)

Tensor<T>の要素を比較して、y未満の要素を確認します。 x内の要素がy未満の場合は true、そうでない場合は false であるTensor<T>を返します。/>

LessThanOrEqual<T>(ReadOnlyTensorSpan<T>, T)

Tensor<T>の要素を比較して、y未満の要素を確認します。 x内の要素がy未満の場合は true、そうでない場合は false であるTensor<T>を返します。/>

LessThanOrEqual<T>(T, ReadOnlyTensorSpan<T>, TensorSpan<Boolean>)

Tensor<T>の要素を比較して、y未満の要素を確認します。 x内の要素がy未満の場合は true、そうでない場合は false であるTensor<T>を返します。/>

LessThanOrEqual<T>(T, ReadOnlyTensorSpan<T>)

Tensor<T>の要素を比較して、y未満の要素を確認します。 x内の要素がy未満の場合は true、そうでない場合は false であるTensor<T>を返します。/>

LessThanOrEqualAll<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

2 つの ReadOnlyTensorSpan<T> の要素を比較して、 x のすべての要素が y未満かどうかを確認します。 図形が同じでない場合は、テンソルが比較される前に、最小のブロードキャスト可能なサイズにブロードキャストされます。 x内のすべての要素がy未満の場合、値が true であるBooleanを返します。

LessThanOrEqualAll<T>(ReadOnlyTensorSpan<T>, T)

2 つの ReadOnlyTensorSpan<T> の要素を比較して、 x のすべての要素が y未満かどうかを確認します。 図形が同じでない場合は、テンソルが比較される前に、最小のブロードキャスト可能なサイズにブロードキャストされます。 x内のすべての要素がy未満の場合、値が true であるBooleanを返します。

LessThanOrEqualAll<T>(T, ReadOnlyTensorSpan<T>)

2 つの ReadOnlyTensorSpan<T> の要素を比較して、 y のすべての要素が x未満かどうかを確認します。 図形が同じでない場合は、テンソルが比較される前に、最小のブロードキャスト可能なサイズにブロードキャストされます。 y内のすべての要素がx未満の場合、値が true であるBooleanを返します。

LessThanOrEqualAny<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

2 つの ReadOnlyTensorSpan<T> の要素を比較して、 x の要素が y未満かどうかを確認します。 図形が同じでない場合は、テンソルが比較される前に、最小のブロードキャスト可能なサイズにブロードキャストされます。 x内の要素がy未満の場合、値が true のBooleanを返します。

LessThanOrEqualAny<T>(ReadOnlyTensorSpan<T>, T)

2 つの ReadOnlyTensorSpan<T> の要素を比較して、 x の要素が y未満かどうかを確認します。 図形が同じでない場合は、テンソルが比較される前に、最小のブロードキャスト可能なサイズにブロードキャストされます。 x内の要素がy未満の場合、値が true のBooleanを返します。

LessThanOrEqualAny<T>(T, ReadOnlyTensorSpan<T>)

2 つの ReadOnlyTensorSpan<T> の要素を比較して、 y の要素が y未満かどうかを確認します。 図形が同じでない場合は、テンソルが比較される前に、最小のブロードキャスト可能なサイズにブロードキャストされます。 y内の要素がy未満の場合、値が true のBooleanを返します。

Log<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)

指定したテンソル内の数値の要素ごとの対数を、別の指定したテンソルの指定された底に対して計算します。

Log<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

指定したテンソル内の数値の要素ごとの対数を、別の指定したテンソルの指定された底に対して計算します。

Log<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<T>)

指定したテンソル内の数値の要素ごとの対数を、別の指定したテンソルの指定された底に対して計算します。

Log<T>(ReadOnlyTensorSpan<T>, T)

指定したテンソル内の数値の要素ごとの対数を、別の指定したテンソルの指定された底に対して計算します。

Log<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

ReadOnlyTensorSpan<T>の各要素の自然対数を取得し、結果を含む新しいTensorSpan<T>を返します。

Log<T>(ReadOnlyTensorSpan<T>)

ReadOnlyTensorSpan<T>の各要素の自然対数を取得し、結果を含む新しいTensor<T>を返します。

Log10<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

ReadOnlyTensorSpan<T>の各要素の底 10 対数を取得し、結果を含む新しいTensorSpan<T>を返します。

Log10<T>(ReadOnlyTensorSpan<T>)

ReadOnlyTensorSpan<T>の各要素の底 10 対数を取得し、結果を含む新しいTensor<T>を返します。

Log10P1<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

底 10 の対数に ReadOnlyTensorSpan<T> の各要素の 1 を加算し、結果を含む新しい TensorSpan<T> を返します。

Log10P1<T>(ReadOnlyTensorSpan<T>)

底 10 の対数に ReadOnlyTensorSpan<T> の各要素の 1 を加算し、結果を含む新しい Tensor<T> を返します。

Log2<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

ReadOnlyTensorSpan<T>の各要素の底 2 の対数を取得し、結果を含む新しいTensorSpan<T>を返します。

Log2<T>(ReadOnlyTensorSpan<T>)

ReadOnlyTensorSpan<T>の各要素の底 2 の対数を取得し、結果を含む新しいTensor<T>を返します。

Log2P1<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

底 2 の対数に ReadOnlyTensorSpan<T> の各要素の 1 を加算し、結果を含む新しい TensorSpan<T> を返します。

Log2P1<T>(ReadOnlyTensorSpan<T>)

底 2 の対数に ReadOnlyTensorSpan<T> の各要素の 1 を加算し、結果を含む新しい Tensor<T> を返します。

LogP1<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

ReadOnlyTensorSpan<T>の各要素の自然対数に 1 を加算し、結果を含む新しいTensorSpan<T>を返します。

LogP1<T>(ReadOnlyTensorSpan<T>)

ReadOnlyTensorSpan<T>の各要素の自然対数に 1 を加算し、結果を含む新しいTensor<T>を返します。

Max<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)

指定したテンソル内の数値の要素ごとの最大値を計算します。

Max<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

指定したテンソル内の数値の要素ごとの最大値を計算します。

Max<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<T>)

指定したテンソル内の数値の要素ごとの最大値を計算します。

Max<T>(ReadOnlyTensorSpan<T>, T)

指定したテンソル内の数値の要素ごとの最大値を計算します。

Max<T>(ReadOnlyTensorSpan<T>)

指定したテンソル内の最大の数を検索します。

MaxMagnitude<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)

指定したテンソルの最大の大きさを持つ要素ごとの数値を計算します。

MaxMagnitude<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

指定したテンソルの最大の大きさを持つ要素ごとの数値を計算します。

MaxMagnitude<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<T>)

指定したテンソルの最大の大きさを持つ要素ごとの数値を計算します。

MaxMagnitude<T>(ReadOnlyTensorSpan<T>, T)

指定したテンソルの最大の大きさを持つ要素ごとの数値を計算します。

MaxMagnitude<T>(ReadOnlyTensorSpan<T>)

指定したテンソルの大きさが最も大きい数値を検索します。

MaxMagnitudeNumber<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)

指定したテンソルの最大の大きさを持つ要素ごとの数値を計算します。

MaxMagnitudeNumber<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

指定したテンソルの最大の大きさを持つ要素ごとの数値を計算します。

MaxMagnitudeNumber<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<T>)

指定したテンソルの最大の大きさを持つ要素ごとの数値を計算します。

MaxMagnitudeNumber<T>(ReadOnlyTensorSpan<T>, T)

指定したテンソルの最大の大きさを持つ要素ごとの数値を計算します。

MaxMagnitudeNumber<T>(ReadOnlyTensorSpan<T>)

指定したテンソルの大きさが最も大きい数値を検索します。

MaxNumber<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)

指定したテンソル内の数値の要素ごとの最大値を計算します。

MaxNumber<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

指定したテンソル内の数値の要素ごとの最大値を計算します。

MaxNumber<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<T>)

指定したテンソル内の数値の要素ごとの最大値を計算します。

MaxNumber<T>(ReadOnlyTensorSpan<T>, T)

指定したテンソル内の数値の要素ごとの最大値を計算します。

MaxNumber<T>(ReadOnlyTensorSpan<T>)

指定したテンソル内の最大の数を検索します。

Min<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)

指定したテンソル内の数値の要素ごとの最小値を計算します。

Min<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

指定したテンソル内の数値の要素ごとの最小値を計算します。

Min<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<T>)

指定したテンソル内の数値の要素ごとの最小値を計算します。

Min<T>(ReadOnlyTensorSpan<T>, T)

指定したテンソル内の数値の要素ごとの最小値を計算します。

Min<T>(ReadOnlyTensorSpan<T>)

指定したテンソル内の最小数を検索します。

MinMagnitude<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)

指定したテンソルの最小の大きさを持つ要素ごとの数値を計算します。

MinMagnitude<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

指定したテンソルの最小の大きさを持つ要素ごとの数値を計算します。

MinMagnitude<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<T>)

指定したテンソルの最小の大きさを持つ要素ごとの数値を計算します。

MinMagnitude<T>(ReadOnlyTensorSpan<T>, T)

指定したテンソルの最小の大きさを持つ要素ごとの数値を計算します。

MinMagnitude<T>(ReadOnlyTensorSpan<T>)

指定したテンソルで最も小さい大きさの数値を検索します。

MinMagnitudeNumber<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)

指定したテンソルの最小の大きさを持つ要素ごとの数値を計算します。

MinMagnitudeNumber<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

指定したテンソルの最小の大きさを持つ要素ごとの数値を計算します。

MinMagnitudeNumber<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<T>)

指定したテンソルの最小の大きさを持つ要素ごとの数値を計算します。

MinMagnitudeNumber<T>(ReadOnlyTensorSpan<T>, T)

指定したテンソルの最小の大きさを持つ要素ごとの数値を計算します。

MinMagnitudeNumber<T>(ReadOnlyTensorSpan<T>)

指定したテンソルで最も小さい大きさの数値を検索します。

MinNumber<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)

指定したテンソル内の数値の要素ごとの最小値を計算します。

MinNumber<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

指定したテンソル内の数値の要素ごとの最小値を計算します。

MinNumber<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<T>)

指定したテンソル内の数値の要素ごとの最小値を計算します。

MinNumber<T>(ReadOnlyTensorSpan<T>, T)

指定したテンソル内の数値の要素ごとの最小値を計算します。

MinNumber<T>(ReadOnlyTensorSpan<T>)

指定したテンソル内の最小数を検索します。

Multiply<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)

2 つのテンソル間で要素ごとの乗算を実行します。

Multiply<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

2 つのテンソル間で要素ごとの乗算を実行します。

Multiply<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<T>)

テンソルとスカラーの間で要素ごとの乗算を実行します。

Multiply<T>(ReadOnlyTensorSpan<T>, T)

テンソルとスカラーの間で要素ごとの乗算を実行します。

Negate<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

テンソルに対して要素ごとの単項否定を実行します。

Negate<T>(ReadOnlyTensorSpan<T>)

テンソルに対して要素ごとの単項否定を実行します。

Norm<T>(ReadOnlyTensorSpan<T>)

ReadOnlyTensorSpan<T>のノルムを受け取り、結果を返します。

OnesComplement<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

テンソルに対して 1 の補数を実行します。

OnesComplement<T>(ReadOnlyTensorSpan<T>)

テンソルに対して 1 の補数を実行します。

PermuteDimensions<T>(Tensor<T>, ReadOnlySpan<Int32>)

dimensions パラメーターに従って、tensor テンソルの寸法を入れ替えます。 tensorが 1D テンソルの場合、tensorが返されます。 それ以外の場合は、新しいメモリを割り当てることによって、新しい軸の順序を持つ新しい Tensor<T> が作成されます。

PopCount<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

指定したテンソル内の数値の要素ごとの母集団数を計算します。

PopCount<T>(ReadOnlyTensorSpan<T>)

指定したテンソル内の数値の要素ごとの母集団数を計算します。

Pow<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)

指定したテンソル内の数値の要素ごとの累乗を、別の指定したテンソルの数値に計算します。

Pow<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

指定したテンソル内の数値の要素ごとの累乗を、別の指定したテンソルの数値に計算します。

Pow<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<T>)

指定したテンソル内の数値の要素ごとの累乗を、別の指定したテンソルの数値に計算します。

Pow<T>(ReadOnlyTensorSpan<T>, T)

指定したテンソル内の数値の要素ごとの累乗を、別の指定したテンソルの数値に計算します。

Pow<T>(T, ReadOnlyTensorSpan<T>, TensorSpan<T>)

指定したテンソル内の数値の要素ごとの累乗を、別の指定したテンソルの数値に計算します。

Pow<T>(T, ReadOnlyTensorSpan<T>)

指定したテンソル内の数値の要素ごとの累乗を、別の指定したテンソルの数値に計算します。

Product<T>(ReadOnlyTensorSpan<T>)

指定した空でない数値テンソル内のすべての要素の積を計算します。

RadiansToDegrees<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

指定したテンソル内のラジアンの各数から度への要素ごとの変換を計算します。

RadiansToDegrees<T>(ReadOnlyTensorSpan<T>)

指定したテンソル内のラジアンの各数から度への要素ごとの変換を計算します。

Reciprocal<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

指定したテンソル内の数値の要素ごとの逆数を計算します。

Reciprocal<T>(ReadOnlyTensorSpan<T>)

指定したテンソル内の数値の要素ごとの逆数を計算します。

Reshape<T>(ReadOnlyTensorSpan<T>, ReadOnlySpan<IntPtr>)

指定したlengthstensorテンソルの形状を変更します。 いずれかの長さが -1 の場合は、自動的に計算されます。 基になるメモリの長さを変更したり、新しいメモリを割り当てたりしません。 新しい図形が古い図形と互換性がない場合は、例外がスローされます。

Reshape<T>(Tensor<T>, ReadOnlySpan<IntPtr>)

指定したlengthstensorテンソルの形状を変更します。 いずれかの長さが -1 の場合は、自動的に計算されます。 基になるメモリの長さを変更したり、新しいメモリを割り当てたりしません。 新しい図形が古い図形と互換性がない場合は、例外がスローされます。

Reshape<T>(TensorSpan<T>, ReadOnlySpan<IntPtr>)

指定したlengthstensorテンソルの形状を変更します。 いずれかの長さが -1 の場合は、自動的に計算されます。 基になるメモリの長さを変更したり、新しいメモリを割り当てたりしません。 新しい図形が古い図形と互換性がない場合は、例外がスローされます。

Resize<T>(Tensor<T>, ReadOnlySpan<IntPtr>)

新しい Tensor<T>を作成し、新しいメモリを割り当て、 tensorからデータをコピーします。 最終的な図形が小さい場合、そのポイント以降のすべてのデータは無視されます。

ResizeTo<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

tensorからデータをコピーします。 最終的な図形が小さい場合、そのポイント以降のすべてのデータは無視されます。 最終的な図形が大きい場合は、0 で塗りつぶされます。

ResizeTo<T>(Tensor<T>, TensorSpan<T>)

tensorからデータをコピーします。 最終的な図形が小さい場合、そのポイント以降のすべてのデータは無視されます。 最終的な図形が大きい場合は、0 で塗りつぶされます。

ResizeTo<T>(TensorSpan<T>, TensorSpan<T>)

tensorからデータをコピーします。 最終的な図形が小さい場合、そのポイント以降のすべてのデータは無視されます。 最終的な図形が大きい場合は、0 で塗りつぶされます。

Reverse<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

tensor内の要素の順序を逆にします。 テンソルの形状は保持されますが、要素は並べ替えされます。

Reverse<T>(ReadOnlyTensorSpan<T>)

tensor内の要素の順序を逆にします。 テンソルの形状は保持されますが、要素は並べ替えされます。

ReverseDimension<T>(ReadOnlyTensorSpan<T>, Int32)

指定したディメンションに沿って、 tensor 内の要素の順序を逆にします。 テンソルの形状は保持されますが、要素は並べ替えされます。 dimension は、指定されていない場合は既定で -1 に設定され、テンソル全体が逆になります。

ReverseDimension<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>, Int32)

指定した軸に沿って、 tensor 内の要素の順序を逆にします。 テンソルの形状は保持されますが、要素は並べ替えされます。 dimension は、指定されていない場合は既定で -1 に設定され、スパン全体が逆になります。

RootN<T>(ReadOnlyTensorSpan<T>, Int32, TensorSpan<T>)

指定したテンソル内の値の要素ごとの n 番目のルートを計算します。

RootN<T>(ReadOnlyTensorSpan<T>, Int32)

指定したテンソル内の値の要素ごとの n 番目のルートを計算します。

RotateLeft<T>(ReadOnlyTensorSpan<T>, Int32, TensorSpan<T>)

指定したテンソル内の数値の左の要素ごとの回転を、指定した回転量で計算します。

RotateLeft<T>(ReadOnlyTensorSpan<T>, Int32)

指定したテンソル内の数値の左の要素ごとの回転を、指定した回転量で計算します。

RotateRight<T>(ReadOnlyTensorSpan<T>, Int32, TensorSpan<T>)

指定したテンソル内の数値の要素ごとの回転右を、指定した回転量で計算します。

RotateRight<T>(ReadOnlyTensorSpan<T>, Int32)

指定したテンソル内の数値の要素ごとの回転右を、指定した回転量で計算します。

Round<T>(ReadOnlyTensorSpan<T>, Int32, MidpointRounding, TensorSpan<T>)

指定したテンソル内の数値の要素ごとの丸めを計算します

Round<T>(ReadOnlyTensorSpan<T>, Int32, MidpointRounding)

指定したテンソル内の数値の要素ごとの丸めを計算します

Round<T>(ReadOnlyTensorSpan<T>, Int32, TensorSpan<T>)

指定したテンソル内の数値の要素ごとの丸めを計算します

Round<T>(ReadOnlyTensorSpan<T>, Int32)

指定したテンソル内の数値の要素ごとの丸めを計算します

Round<T>(ReadOnlyTensorSpan<T>, MidpointRounding, TensorSpan<T>)

指定したテンソル内の数値の要素ごとの丸めを計算します

Round<T>(ReadOnlyTensorSpan<T>, MidpointRounding)

指定したテンソル内の数値の要素ごとの丸めを計算します

Round<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

指定したテンソル内の数値の要素ごとの丸めを計算します

Round<T>(ReadOnlyTensorSpan<T>)

指定したテンソル内の数値の要素ごとの丸めを計算します

SequenceEqual<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

IEquatable{T} を使用して要素を比較することで、2 つのシーケンスが等しいかどうかを判断します。Equals(T)。

SequenceEqual<T>(TensorSpan<T>, ReadOnlyTensorSpan<T>)

IEquatable{T} を使用して要素を比較することで、2 つのシーケンスが等しいかどうかを判断します。Equals(T)。

SetSlice<T>(Tensor<T>, ReadOnlyTensorSpan<T>, ReadOnlySpan<NRange>)

指定された tensor のスライスを、指定された values に設定します。 ranges

SetSlice<T>(TensorSpan<T>, ReadOnlyTensorSpan<T>, ReadOnlySpan<NRange>)

指定された tensor のスライスを、指定された values に設定します。 ranges

ShiftLeft<T>(ReadOnlyTensorSpan<T>, Int32, TensorSpan<T>)

テンソルに対して要素ごとの左シフトを実行します。

ShiftLeft<T>(ReadOnlyTensorSpan<T>, Int32)

テンソルに対して要素ごとの左シフトを実行します。

ShiftRightArithmetic<T>(ReadOnlyTensorSpan<T>, Int32, TensorSpan<T>)

テンソルに対して要素ごとの算術右シフトを実行します。

ShiftRightArithmetic<T>(ReadOnlyTensorSpan<T>, Int32)

テンソルに対して要素ごとの算術右シフトを実行します。

ShiftRightLogical<T>(ReadOnlyTensorSpan<T>, Int32, TensorSpan<T>)

テンソルに対して要素ごとの論理右シフトを実行します。

ShiftRightLogical<T>(ReadOnlyTensorSpan<T>, Int32)

テンソルに対して要素ごとの論理右シフトを実行します。

Sigmoid<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

指定された空でない数値テンソルに対する要素ごとのシグモイド関数を計算します。

Sigmoid<T>(ReadOnlyTensorSpan<T>)

指定された空でない数値テンソルに対する要素ごとのシグモイド関数を計算します。

Sin<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

ReadOnlyTensorSpan<T>の各要素の sin を受け取り、結果を含む新しいTensorSpan<T>を返します。

Sin<T>(ReadOnlyTensorSpan<T>)

ReadOnlyTensorSpan<T>の各要素の sin を受け取り、結果を含む新しいTensor<T>を返します。

Sinh<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

指定したテンソルの各ラジアン角度の要素ごとの双曲線正弦を計算します。

Sinh<T>(ReadOnlyTensorSpan<T>)

指定したテンソルの各ラジアン角度の要素ごとの双曲線正弦を計算します。

SinPi<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Pi を乗算した、指定したテンソルの値の要素ごとのサインを計算します。

SinPi<T>(ReadOnlyTensorSpan<T>)

Pi を乗算した、指定したテンソルの値の要素ごとのサインを計算します。

SoftMax<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

指定された空でない数値テンソルに対して softmax 関数を計算します。

SoftMax<T>(ReadOnlyTensorSpan<T>)

指定された空でない数値テンソルに対して softmax 関数を計算します。

Split<T>(ReadOnlyTensorSpan<T>, Int32, IntPtr)

指定したdimensionに沿ってTensor<T>splitCountに分割します。 特定の dimension でテンソルを均等に分割できない場合は、例外がスローされます。

Sqrt<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

xの各要素の平方根を取得し、結果を含む新しいTensorSpan<T>を返します。

Sqrt<T>(ReadOnlyTensorSpan<T>)

ReadOnlyTensorSpan<T>の各要素の平方根を取得し、結果を含む新しいTensor<T>を返します。

Squeeze<T>(ReadOnlyTensorSpan<T>)

長さ 1 のすべての寸法を tensorから削除します。

Squeeze<T>(Tensor<T>)

長さ 1 のすべての寸法を tensorから削除します。

Squeeze<T>(TensorSpan<T>)

長さ 1 のすべての寸法を tensorから削除します。

SqueezeDimension<T>(ReadOnlyTensorSpan<T>, Int32)

指定したdimensiontensorから長さ 1 の軸を削除します。 ディメンションが長さ 1 でない場合は、例外がスローされます。

SqueezeDimension<T>(Tensor<T>, Int32)

指定したdimensiontensorから長さ 1 の軸を削除します。 ディメンションが長さ 1 でない場合は、例外がスローされます。

SqueezeDimension<T>(TensorSpan<T>, Int32)

指定したdimensiontensorから長さ 1 の軸を削除します。 ディメンションが長さ 1 でない場合は、例外がスローされます。

Stack<T>(ReadOnlySpan<Tensor<T>>, TensorSpan<T>)

位置 0 に追加された新しいディメンションに沿って複数の Tensor<T> を結合します。 すべてのテンソルの形状は同じである必要があります。

Stack<T>(ReadOnlySpan<Tensor<T>>)

位置 0 に追加された新しいディメンションに沿って複数の Tensor<T> を結合します。 すべてのテンソルの形状は同じである必要があります。

StackAlongDimension<T>(Int32, ReadOnlySpan<Tensor<T>>)

新しいディメンションに沿って複数の Tensor<T> を結合します。 軸パラメーターは、新しいディメンションのインデックスを指定します。 すべてのテンソルの形状は同じである必要があります。

StackAlongDimension<T>(ReadOnlySpan<Tensor<T>>, TensorSpan<T>, Int32)

新しいディメンションに沿って複数の Tensor<T> を結合します。 軸パラメーターは、新しいディメンションのインデックスを指定します。 すべてのテンソルの形状は同じである必要があります。

StdDev<T>(ReadOnlyTensorSpan<T>)

x テンソル内の要素の標準偏差を返します。

Subtract<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)

2 つのテンソル間で要素ごとの減算を実行します。

Subtract<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

2 つのテンソル間で要素ごとの減算を実行します。

Subtract<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<T>)

テンソルとスカラーの間で要素ごとの減算を実行します。

Subtract<T>(ReadOnlyTensorSpan<T>, T)

テンソルとスカラーの間で要素ごとの減算を実行します。

Subtract<T>(T, ReadOnlyTensorSpan<T>, TensorSpan<T>)

テンソルとスカラーの間で要素ごとの減算を実行します。

Subtract<T>(T, ReadOnlyTensorSpan<T>)

テンソルとスカラーの間で要素ごとの減算を実行します。

Sum<T>(ReadOnlyTensorSpan<T>)

指定したテンソルの要素を合計します。

Tan<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

指定したテンソル内の値の要素ごとのタンジェントを計算します。

Tan<T>(ReadOnlyTensorSpan<T>)

指定したテンソル内の値の要素ごとのタンジェントを計算します。

Tanh<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

指定したテンソル内の各ラジアン角度の要素ごとの双曲線正接を計算します。

Tanh<T>(ReadOnlyTensorSpan<T>)

指定したテンソル内の各ラジアン角度の要素ごとの双曲線正接を計算します。

TanPi<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Pi を乗算した、指定したテンソル内の値の要素ごとのタンジェントを計算します。

TanPi<T>(ReadOnlyTensorSpan<T>)

Pi を乗算した、指定したテンソル内の値の要素ごとのタンジェントを計算します。

TrailingZeroCount<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

指定したテンソル内の数値の要素ごとの末尾の 0 カウントを計算します。

TrailingZeroCount<T>(ReadOnlyTensorSpan<T>)

指定したテンソル内の数値の要素ごとの末尾の 0 カウントを計算します。

Transpose<T>(Tensor<T>)

tensor テンソルの最後の 2 次元を入れ替えます。

Truncate<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

指定したテンソル内の数値の要素ごとの切り捨てを計算します。

Truncate<T>(ReadOnlyTensorSpan<T>)

指定したテンソル内の数値の要素ごとの切り捨てを計算します。

TryBroadcastTo<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

tensorからdestinationと互換性のある最小のブロードキャスト可能な図形にデータをブロードキャストし、destinationに格納する図形に互換性がない場合は false が返されます。

TryBroadcastTo<T>(Tensor<T>, TensorSpan<T>)

tensorからdestinationと互換性のある最小のブロードキャスト可能な図形にデータをブロードキャストし、destinationに格納する図形に互換性がない場合は false が返されます。

TryBroadcastTo<T>(TensorSpan<T>, TensorSpan<T>)

tensorからdestinationと互換性のある最小のブロードキャスト可能な図形にデータをブロードキャストし、destinationに格納する図形に互換性がない場合は false が返されます。

Unsqueeze<T>(ReadOnlyTensorSpan<T>, Int32)

寸法位置に表示される長さ 1 の新しい寸法を挿入します。

Unsqueeze<T>(Tensor<T>, Int32)

寸法位置に表示される長さ 1 の新しい寸法を挿入します。

Unsqueeze<T>(TensorSpan<T>, Int32)

寸法位置に表示される長さ 1 の新しい寸法を挿入します。

Xor<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)

排他的または 2 つのテンソルの間で実行します。

Xor<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

排他的または 2 つのテンソルの間で実行します。

Xor<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<T>)

テンソルとスカラーの間で排他的または排他的に実行します。

Xor<T>(ReadOnlyTensorSpan<T>, T)

テンソルとスカラーの間で排他的または排他的に実行します。

演算子

名前 説明
Addition(ReadOnlyTensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)

2 つのテンソル間で要素ごとの加算を実行します。

Addition(ReadOnlyTensorSpan<TScalar>, TScalar)

テンソルとスカラーの間で要素ごとの加算を実行します。

Addition(Tensor<TScalar>, Tensor<TScalar>)

2 つのテンソル間で要素ごとの加算を実行します。

Addition(Tensor<TScalar>, TScalar)

テンソルとスカラーの間で要素ごとの加算を実行します。

Addition(TensorSpan<TScalar>, TensorSpan<TScalar>)

2 つのテンソル間で要素ごとの加算を実行します。

Addition(TensorSpan<TScalar>, TScalar)

テンソルとスカラーの間で要素ごとの加算を実行します。

Addition(TScalar, ReadOnlyTensorSpan<TScalar>)

テンソルとスカラーの間で要素ごとの加算を実行します。

Addition(TScalar, Tensor<TScalar>)

テンソルとスカラーの間で要素ごとの加算を実行します。

Addition(TScalar, TensorSpan<TScalar>)

テンソルとスカラーの間で要素ごとの加算を実行します。

Addition<TScalar>(ReadOnlyTensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)

2 つのテンソル間で要素ごとの加算を実行します。

Addition<TScalar>(ReadOnlyTensorSpan<TScalar>, TScalar)

テンソルとスカラーの間で要素ごとの加算を実行します。

Addition<TScalar>(Tensor<TScalar>, Tensor<TScalar>)

2 つのテンソル間で要素ごとの加算を実行します。

Addition<TScalar>(Tensor<TScalar>, TScalar)

テンソルとスカラーの間で要素ごとの加算を実行します。

Addition<TScalar>(TensorSpan<TScalar>, TensorSpan<TScalar>)

2 つのテンソル間で要素ごとの加算を実行します。

Addition<TScalar>(TensorSpan<TScalar>, TScalar)

テンソルとスカラーの間で要素ごとの加算を実行します。

Addition<TScalar>(TScalar, ReadOnlyTensorSpan<TScalar>)

テンソルとスカラーの間で要素ごとの加算を実行します。

Addition<TScalar>(TScalar, Tensor<TScalar>)

テンソルとスカラーの間で要素ごとの加算を実行します。

Addition<TScalar>(TScalar, TensorSpan<TScalar>)

テンソルとスカラーの間で要素ごとの加算を実行します。

AdditionAssignment(ReadOnlyTensorSpan<TScalar>)

2 つのテンソル間でインプレース要素ごとの加算を実行します。

AdditionAssignment(ReadOnlyTensorSpan<TScalar>)

2 つのテンソル間でインプレース要素ごとの加算を実行します。

AdditionAssignment(TScalar)

テンソルとスカラーの間でインプレース要素ごとの加算を実行します。

AdditionAssignment(TScalar)

テンソルとスカラーの間でインプレース要素ごとの加算を実行します。

AdditionAssignment<TScalar>(Tensor<TScalar>, ReadOnlyTensorSpan<TScalar>)

2 つのテンソル間でインプレース要素ごとの加算を実行します。

AdditionAssignment<TScalar>(Tensor<TScalar>, TScalar)

テンソルとスカラーの間でインプレース要素ごとの加算を実行します。

AdditionAssignment<TScalar>(TensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)

2 つのテンソル間でインプレース要素ごとの加算を実行します。

AdditionAssignment<TScalar>(TensorSpan<TScalar>, TScalar)

テンソルとスカラーの間でインプレース要素ごとの加算を実行します。

BitwiseAnd(ReadOnlyTensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)

ビットごとの、および 2 つのテンソル間を実行します。

BitwiseAnd(ReadOnlyTensorSpan<TScalar>, TScalar)

テンソルとスカラーの間でビットごとの実行を行います。

BitwiseAnd(Tensor<TScalar>, Tensor<TScalar>)

ビットごとの、および 2 つのテンソル間を実行します。

BitwiseAnd(Tensor<TScalar>, TScalar)

テンソルとスカラーの間でビットごとの実行を行います。

BitwiseAnd(TensorSpan<TScalar>, TensorSpan<TScalar>)

ビットごとの、および 2 つのテンソル間を実行します。

BitwiseAnd(TensorSpan<TScalar>, TScalar)

テンソルとスカラーの間でビットごとの実行を行います。

BitwiseAnd(TScalar, ReadOnlyTensorSpan<TScalar>)

テンソルとスカラーの間でビットごとの実行を行います。

BitwiseAnd(TScalar, Tensor<TScalar>)

テンソルとスカラーの間でビットごとの実行を行います。

BitwiseAnd(TScalar, TensorSpan<TScalar>)

テンソルとスカラーの間でビットごとの実行を行います。

BitwiseAnd<TScalar>(ReadOnlyTensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)

ビットごとの、および 2 つのテンソル間を実行します。

BitwiseAnd<TScalar>(ReadOnlyTensorSpan<TScalar>, TScalar)

テンソルとスカラーの間でビットごとの実行を行います。

BitwiseAnd<TScalar>(Tensor<TScalar>, Tensor<TScalar>)

ビットごとの、および 2 つのテンソル間を実行します。

BitwiseAnd<TScalar>(Tensor<TScalar>, TScalar)

テンソルとスカラーの間でビットごとの実行を行います。

BitwiseAnd<TScalar>(TensorSpan<TScalar>, TensorSpan<TScalar>)

ビットごとの、および 2 つのテンソル間を実行します。

BitwiseAnd<TScalar>(TensorSpan<TScalar>, TScalar)

テンソルとスカラーの間でビットごとの実行を行います。

BitwiseAnd<TScalar>(TScalar, ReadOnlyTensorSpan<TScalar>)

テンソルとスカラーの間でビットごとの実行を行います。

BitwiseAnd<TScalar>(TScalar, Tensor<TScalar>)

テンソルとスカラーの間でビットごとの実行を行います。

BitwiseAnd<TScalar>(TScalar, TensorSpan<TScalar>)

テンソルとスカラーの間でビットごとの実行を行います。

BitwiseAndAssignment(ReadOnlyTensorSpan<TScalar>)

インプレース ビットごとの、および 2 つのテンソルの間を実行します。

BitwiseAndAssignment(ReadOnlyTensorSpan<TScalar>)

インプレース ビットごとの、および 2 つのテンソルの間を実行します。

BitwiseAndAssignment(TScalar)

テンソルとスカラーの間で、インプレース ビットごとの実行を行います。

BitwiseAndAssignment(TScalar)

テンソルとスカラーの間で、インプレース ビットごとの実行を行います。

BitwiseAndAssignment<TScalar>(Tensor<TScalar>, ReadOnlyTensorSpan<TScalar>)

インプレース ビットごとの、および 2 つのテンソルの間を実行します。

BitwiseAndAssignment<TScalar>(Tensor<TScalar>, TScalar)

テンソルとスカラーの間で、インプレース ビットごとの実行を行います。

BitwiseAndAssignment<TScalar>(TensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)

インプレース ビットごとの、および 2 つのテンソルの間を実行します。

BitwiseAndAssignment<TScalar>(TensorSpan<TScalar>, TScalar)

テンソルとスカラーの間で、インプレース ビットごとの実行を行います。

BitwiseOr(ReadOnlyTensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)

ビット単位または 2 つのテンソルの間で実行します。

BitwiseOr(ReadOnlyTensorSpan<TScalar>, TScalar)

テンソルとスカラーの間でビット単位またはビット単位で実行します。

BitwiseOr(Tensor<TScalar>, Tensor<TScalar>)

ビット単位または 2 つのテンソルの間で実行します。

BitwiseOr(Tensor<TScalar>, TScalar)

テンソルとスカラーの間でビット単位またはビット単位で実行します。

BitwiseOr(TensorSpan<TScalar>, TensorSpan<TScalar>)

ビット単位または 2 つのテンソルの間で実行します。

BitwiseOr(TensorSpan<TScalar>, TScalar)

テンソルとスカラーの間でビット単位またはビット単位で実行します。

BitwiseOr(TScalar, ReadOnlyTensorSpan<TScalar>)

テンソルとスカラーの間でビット単位またはビット単位で実行します。

BitwiseOr(TScalar, Tensor<TScalar>)

テンソルとスカラーの間でビット単位またはビット単位で実行します。

BitwiseOr(TScalar, TensorSpan<TScalar>)

テンソルとスカラーの間でビット単位またはビット単位で実行します。

BitwiseOr<TScalar>(ReadOnlyTensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)

ビット単位または 2 つのテンソルの間で実行します。

BitwiseOr<TScalar>(ReadOnlyTensorSpan<TScalar>, TScalar)

テンソルとスカラーの間でビット単位またはビット単位で実行します。

BitwiseOr<TScalar>(Tensor<TScalar>, Tensor<TScalar>)

ビット単位または 2 つのテンソルの間で実行します。

BitwiseOr<TScalar>(Tensor<TScalar>, TScalar)

テンソルとスカラーの間でビット単位またはビット単位で実行します。

BitwiseOr<TScalar>(TensorSpan<TScalar>, TensorSpan<TScalar>)

ビット単位または 2 つのテンソルの間で実行します。

BitwiseOr<TScalar>(TensorSpan<TScalar>, TScalar)

テンソルとスカラーの間でビット単位またはビット単位で実行します。

BitwiseOr<TScalar>(TScalar, ReadOnlyTensorSpan<TScalar>)

テンソルとスカラーの間でビット単位またはビット単位で実行します。

BitwiseOr<TScalar>(TScalar, Tensor<TScalar>)

テンソルとスカラーの間でビット単位またはビット単位で実行します。

BitwiseOr<TScalar>(TScalar, TensorSpan<TScalar>)

テンソルとスカラーの間でビット単位またはビット単位で実行します。

BitwiseOrAssignment(ReadOnlyTensorSpan<TScalar>)

インプレース ビット単位または 2 つのテンソルの間で実行します。

BitwiseOrAssignment(ReadOnlyTensorSpan<TScalar>)

インプレース ビット単位または 2 つのテンソルの間で実行します。

BitwiseOrAssignment(TScalar)

インプレース ビット単位またはテンソルとスカラーの間で実行します。

BitwiseOrAssignment(TScalar)

インプレース ビット単位またはテンソルとスカラーの間で実行します。

BitwiseOrAssignment<TScalar>(Tensor<TScalar>, ReadOnlyTensorSpan<TScalar>)

インプレース ビット単位または 2 つのテンソルの間で実行します。

BitwiseOrAssignment<TScalar>(Tensor<TScalar>, TScalar)

インプレース ビット単位またはテンソルとスカラーの間で実行します。

BitwiseOrAssignment<TScalar>(TensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)

インプレース ビット単位または 2 つのテンソルの間で実行します。

BitwiseOrAssignment<TScalar>(TensorSpan<TScalar>, TScalar)

インプレース ビット単位またはテンソルとスカラーの間で実行します。

DecrementAssignment

テンソルに対してインプレース デクリメントを実行します。

DecrementAssignment

テンソルに対してインプレース デクリメントを実行します。

DecrementAssignment<TScalar>(Tensor<TScalar>)

テンソルに対してインプレース デクリメントを実行します。

DecrementAssignment<TScalar>(TensorSpan<TScalar>)

テンソルに対してインプレース デクリメントを実行します。

Division(ReadOnlyTensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)

2 つのテンソル間で要素ごとの除算を実行します。

Division(ReadOnlyTensorSpan<TScalar>, TScalar)

テンソルとスカラーの間で要素ごとの除算を実行します。

Division(Tensor<TScalar>, Tensor<TScalar>)

2 つのテンソル間で要素ごとの除算を実行します。

Division(Tensor<TScalar>, TScalar)

テンソルとスカラーの間で要素ごとの除算を実行します。

Division(TensorSpan<TScalar>, TensorSpan<TScalar>)

2 つのテンソル間で要素ごとの除算を実行します。

Division(TensorSpan<TScalar>, TScalar)

テンソルとスカラーの間で要素ごとの除算を実行します。

Division(TScalar, ReadOnlyTensorSpan<TScalar>)

テンソルとスカラーの間で要素ごとの除算を実行します。

Division(TScalar, Tensor<TScalar>)

テンソルとスカラーの間で要素ごとの除算を実行します。

Division(TScalar, TensorSpan<TScalar>)

テンソルとスカラーの間で要素ごとの除算を実行します。

Division<TScalar>(ReadOnlyTensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)

2 つのテンソル間で要素ごとの除算を実行します。

Division<TScalar>(ReadOnlyTensorSpan<TScalar>, TScalar)

テンソルとスカラーの間で要素ごとの除算を実行します。

Division<TScalar>(Tensor<TScalar>, Tensor<TScalar>)

2 つのテンソル間で要素ごとの除算を実行します。

Division<TScalar>(Tensor<TScalar>, TScalar)

テンソルとスカラーの間で要素ごとの除算を実行します。

Division<TScalar>(TensorSpan<TScalar>, TensorSpan<TScalar>)

2 つのテンソル間で要素ごとの除算を実行します。

Division<TScalar>(TensorSpan<TScalar>, TScalar)

テンソルとスカラーの間で要素ごとの除算を実行します。

Division<TScalar>(TScalar, ReadOnlyTensorSpan<TScalar>)

テンソルとスカラーの間で要素ごとの除算を実行します。

Division<TScalar>(TScalar, Tensor<TScalar>)

テンソルとスカラーの間で要素ごとの除算を実行します。

Division<TScalar>(TScalar, TensorSpan<TScalar>)

テンソルとスカラーの間で要素ごとの除算を実行します。

DivisionAssignment(ReadOnlyTensorSpan<TScalar>)

2 つのテンソル間でインプレース要素ごとの除算を実行します。

DivisionAssignment(ReadOnlyTensorSpan<TScalar>)

2 つのテンソル間でインプレース要素ごとの除算を実行します。

DivisionAssignment(TScalar)

テンソルとスカラーの間でインプレース要素ごとの除算を実行します。

DivisionAssignment(TScalar)

テンソルとスカラーの間でインプレース要素ごとの除算を実行します。

DivisionAssignment<TScalar>(Tensor<TScalar>, ReadOnlyTensorSpan<TScalar>)

2 つのテンソル間でインプレース要素ごとの除算を実行します。

DivisionAssignment<TScalar>(Tensor<TScalar>, TScalar)

テンソルとスカラーの間でインプレース要素ごとの除算を実行します。

DivisionAssignment<TScalar>(TensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)

2 つのテンソル間でインプレース要素ごとの除算を実行します。

DivisionAssignment<TScalar>(TensorSpan<TScalar>, TScalar)

テンソルとスカラーの間でインプレース要素ごとの除算を実行します。

ExclusiveOr(ReadOnlyTensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)

排他的または 2 つのテンソルの間で実行します。

ExclusiveOr(ReadOnlyTensorSpan<TScalar>, TScalar)

テンソルとスカラーの間で排他的または排他的に実行します。

ExclusiveOr(Tensor<TScalar>, Tensor<TScalar>)

排他的または 2 つのテンソルの間で実行します。

ExclusiveOr(Tensor<TScalar>, TScalar)

テンソルとスカラーの間で排他的または排他的に実行します。

ExclusiveOr(TensorSpan<TScalar>, TensorSpan<TScalar>)

排他的または 2 つのテンソルの間で実行します。

ExclusiveOr(TensorSpan<TScalar>, TScalar)

テンソルとスカラーの間で排他的または排他的に実行します。

ExclusiveOr(TScalar, ReadOnlyTensorSpan<TScalar>)

テンソルとスカラーの間で排他的または排他的に実行します。

ExclusiveOr(TScalar, Tensor<TScalar>)

テンソルとスカラーの間で排他的または排他的に実行します。

ExclusiveOr(TScalar, TensorSpan<TScalar>)

テンソルとスカラーの間で排他的または排他的に実行します。

ExclusiveOr<TScalar>(ReadOnlyTensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)

排他的または 2 つのテンソルの間で実行します。

ExclusiveOr<TScalar>(ReadOnlyTensorSpan<TScalar>, TScalar)

テンソルとスカラーの間で排他的または排他的に実行します。

ExclusiveOr<TScalar>(Tensor<TScalar>, Tensor<TScalar>)

排他的または 2 つのテンソルの間で実行します。

ExclusiveOr<TScalar>(Tensor<TScalar>, TScalar)

テンソルとスカラーの間で排他的または排他的に実行します。

ExclusiveOr<TScalar>(TensorSpan<TScalar>, TensorSpan<TScalar>)

排他的または 2 つのテンソルの間で実行します。

ExclusiveOr<TScalar>(TensorSpan<TScalar>, TScalar)

テンソルとスカラーの間で排他的または排他的に実行します。

ExclusiveOr<TScalar>(TScalar, ReadOnlyTensorSpan<TScalar>)

テンソルとスカラーの間で排他的または排他的に実行します。

ExclusiveOr<TScalar>(TScalar, Tensor<TScalar>)

テンソルとスカラーの間で排他的または排他的に実行します。

ExclusiveOr<TScalar>(TScalar, TensorSpan<TScalar>)

テンソルとスカラーの間で排他的または排他的に実行します。

ExclusiveOrAssignment(ReadOnlyTensorSpan<TScalar>)

インプレース排他的または 2 つのテンソルの間で実行します。

ExclusiveOrAssignment(ReadOnlyTensorSpan<TScalar>)

インプレース排他的または 2 つのテンソルの間で実行します。

ExclusiveOrAssignment(TScalar)

インプレース排他、またはテンソルとスカラーの間で実行します。

ExclusiveOrAssignment(TScalar)

インプレース排他、またはテンソルとスカラーの間で実行します。

ExclusiveOrAssignment<TScalar>(Tensor<TScalar>, ReadOnlyTensorSpan<TScalar>)

インプレース排他的または 2 つのテンソルの間で実行します。

ExclusiveOrAssignment<TScalar>(Tensor<TScalar>, TScalar)

インプレース排他、またはテンソルとスカラーの間で実行します。

ExclusiveOrAssignment<TScalar>(TensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)

インプレース排他的または 2 つのテンソルの間で実行します。

ExclusiveOrAssignment<TScalar>(TensorSpan<TScalar>, TScalar)

インプレース排他、またはテンソルとスカラーの間で実行します。

IncrementAssignment

テンソルに対してインプレース インクリメントを実行します。

IncrementAssignment

テンソルに対してインプレース インクリメントを実行します。

IncrementAssignment<TScalar>(Tensor<TScalar>)

テンソルに対してインプレース インクリメントを実行します。

IncrementAssignment<TScalar>(TensorSpan<TScalar>)

テンソルに対してインプレース インクリメントを実行します。

LeftShift(ReadOnlyTensorSpan<TScalar>, Int32)

テンソルに対して要素ごとの左シフトを実行します。

LeftShift(Tensor<TScalar>, Int32)

テンソルに対して要素ごとの左シフトを実行します。

LeftShift(TensorSpan<TScalar>, Int32)

テンソルに対して要素ごとの左シフトを実行します。

LeftShift<TScalar>(ReadOnlyTensorSpan<TScalar>, Int32)

テンソルに対して要素ごとの左シフトを実行します。

LeftShift<TScalar>(Tensor<TScalar>, Int32)

テンソルに対して要素ごとの左シフトを実行します。

LeftShift<TScalar>(TensorSpan<TScalar>, Int32)

テンソルに対して要素ごとの左シフトを実行します。

LeftShiftAssignment(Int32)

テンソルに対してインプレース要素単位の左シフトを実行します。

LeftShiftAssignment(Int32)

テンソルに対してインプレース要素単位の左シフトを実行します。

LeftShiftAssignment<TScalar>(Tensor<TScalar>, Int32)

テンソルに対してインプレース要素単位の左シフトを実行します。

LeftShiftAssignment<TScalar>(TensorSpan<TScalar>, Int32)

テンソルに対してインプレース要素単位の左シフトを実行します。

MultiplicationAssignment(ReadOnlyTensorSpan<TScalar>)

2 つのテンソル間でインプレース要素ごとの乗算を実行します。

MultiplicationAssignment(ReadOnlyTensorSpan<TScalar>)

2 つのテンソル間でインプレース要素ごとの乗算を実行します。

MultiplicationAssignment(TScalar)

テンソルとスカラーの間でインプレース要素ごとの乗算を実行します。

MultiplicationAssignment(TScalar)

テンソルとスカラーの間でインプレース要素ごとの乗算を実行します。

MultiplicationAssignment<TScalar>(Tensor<TScalar>, ReadOnlyTensorSpan<TScalar>)

2 つのテンソル間でインプレース要素ごとの乗算を実行します。

MultiplicationAssignment<TScalar>(Tensor<TScalar>, TScalar)

テンソルとスカラーの間でインプレース要素ごとの乗算を実行します。

MultiplicationAssignment<TScalar>(TensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)

2 つのテンソル間でインプレース要素ごとの乗算を実行します。

MultiplicationAssignment<TScalar>(TensorSpan<TScalar>, TScalar)

テンソルとスカラーの間でインプレース要素ごとの乗算を実行します。

Multiply(ReadOnlyTensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)

2 つのテンソル間で要素ごとの乗算を実行します。

Multiply(ReadOnlyTensorSpan<TScalar>, TScalar)

テンソルとスカラーの間で要素ごとの乗算を実行します。

Multiply(Tensor<TScalar>, Tensor<TScalar>)

2 つのテンソル間で要素ごとの乗算を実行します。

Multiply(Tensor<TScalar>, TScalar)

テンソルとスカラーの間で要素ごとの乗算を実行します。

Multiply(TensorSpan<TScalar>, TensorSpan<TScalar>)

2 つのテンソル間で要素ごとの乗算を実行します。

Multiply(TensorSpan<TScalar>, TScalar)

テンソルとスカラーの間で要素ごとの乗算を実行します。

Multiply(TScalar, ReadOnlyTensorSpan<TScalar>)

テンソルとスカラーの間で要素ごとの乗算を実行します。

Multiply(TScalar, Tensor<TScalar>)

テンソルとスカラーの間で要素ごとの乗算を実行します。

Multiply(TScalar, TensorSpan<TScalar>)

テンソルとスカラーの間で要素ごとの乗算を実行します。

Multiply<TScalar>(ReadOnlyTensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)

2 つのテンソル間で要素ごとの乗算を実行します。

Multiply<TScalar>(ReadOnlyTensorSpan<TScalar>, TScalar)

テンソルとスカラーの間で要素ごとの乗算を実行します。

Multiply<TScalar>(Tensor<TScalar>, Tensor<TScalar>)

2 つのテンソル間で要素ごとの乗算を実行します。

Multiply<TScalar>(Tensor<TScalar>, TScalar)

テンソルとスカラーの間で要素ごとの乗算を実行します。

Multiply<TScalar>(TensorSpan<TScalar>, TensorSpan<TScalar>)

2 つのテンソル間で要素ごとの乗算を実行します。

Multiply<TScalar>(TensorSpan<TScalar>, TScalar)

テンソルとスカラーの間で要素ごとの乗算を実行します。

Multiply<TScalar>(TScalar, ReadOnlyTensorSpan<TScalar>)

テンソルとスカラーの間で要素ごとの乗算を実行します。

Multiply<TScalar>(TScalar, Tensor<TScalar>)

テンソルとスカラーの間で要素ごとの乗算を実行します。

Multiply<TScalar>(TScalar, TensorSpan<TScalar>)

テンソルとスカラーの間で要素ごとの乗算を実行します。

OnesComplement(ReadOnlyTensorSpan<TScalar>)

テンソルに対して 1 の補数を実行します。

OnesComplement(Tensor<TScalar>)

テンソルに対して 1 の補数を実行します。

OnesComplement(TensorSpan<TScalar>)

テンソルに対して 1 の補数を実行します。

OnesComplement<TScalar>(ReadOnlyTensorSpan<TScalar>)

テンソルに対して 1 の補数を実行します。

OnesComplement<TScalar>(Tensor<TScalar>)

テンソルに対して 1 の補数を実行します。

OnesComplement<TScalar>(TensorSpan<TScalar>)

テンソルに対して 1 の補数を実行します。

RightShift(ReadOnlyTensorSpan<TScalar>, Int32)

テンソルに対して要素ごとの算術右シフトを実行します。

RightShift(Tensor<TScalar>, Int32)

テンソルに対して要素ごとの算術右シフトを実行します。

RightShift(TensorSpan<TScalar>, Int32)

テンソルに対して要素ごとの算術右シフトを実行します。

RightShift<TScalar>(ReadOnlyTensorSpan<TScalar>, Int32)

テンソルに対して要素ごとの算術右シフトを実行します。

RightShift<TScalar>(Tensor<TScalar>, Int32)

テンソルに対して要素ごとの算術右シフトを実行します。

RightShift<TScalar>(TensorSpan<TScalar>, Int32)

テンソルに対して要素ごとの算術右シフトを実行します。

RightShiftAssignment(Int32)

テンソルに対してインプレース要素ごとの算術右シフトを実行します。

RightShiftAssignment(Int32)

テンソルに対してインプレース要素ごとの算術右シフトを実行します。

RightShiftAssignment<TScalar>(Tensor<TScalar>, Int32)

テンソルに対してインプレース要素ごとの算術右シフトを実行します。

RightShiftAssignment<TScalar>(TensorSpan<TScalar>, Int32)

テンソルに対してインプレース要素ごとの算術右シフトを実行します。

Subtraction(ReadOnlyTensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)

2 つのテンソル間で要素ごとの減算を実行します。

Subtraction(ReadOnlyTensorSpan<TScalar>, TScalar)

テンソルとスカラーの間で要素ごとの減算を実行します。

Subtraction(Tensor<TScalar>, Tensor<TScalar>)

2 つのテンソル間で要素ごとの減算を実行します。

Subtraction(Tensor<TScalar>, TScalar)

テンソルとスカラーの間で要素ごとの減算を実行します。

Subtraction(TensorSpan<TScalar>, TensorSpan<TScalar>)

2 つのテンソル間で要素ごとの減算を実行します。

Subtraction(TensorSpan<TScalar>, TScalar)

テンソルとスカラーの間で要素ごとの減算を実行します。

Subtraction(TScalar, ReadOnlyTensorSpan<TScalar>)

テンソルとスカラーの間で要素ごとの減算を実行します。

Subtraction(TScalar, Tensor<TScalar>)

テンソルとスカラーの間で要素ごとの減算を実行します。

Subtraction(TScalar, TensorSpan<TScalar>)

テンソルとスカラーの間で要素ごとの減算を実行します。

Subtraction<TScalar>(ReadOnlyTensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)

2 つのテンソル間で要素ごとの減算を実行します。

Subtraction<TScalar>(ReadOnlyTensorSpan<TScalar>, TScalar)

テンソルとスカラーの間で要素ごとの減算を実行します。

Subtraction<TScalar>(Tensor<TScalar>, Tensor<TScalar>)

2 つのテンソル間で要素ごとの減算を実行します。

Subtraction<TScalar>(Tensor<TScalar>, TScalar)

テンソルとスカラーの間で要素ごとの減算を実行します。

Subtraction<TScalar>(TensorSpan<TScalar>, TensorSpan<TScalar>)

2 つのテンソル間で要素ごとの減算を実行します。

Subtraction<TScalar>(TensorSpan<TScalar>, TScalar)

テンソルとスカラーの間で要素ごとの減算を実行します。

Subtraction<TScalar>(TScalar, ReadOnlyTensorSpan<TScalar>)

テンソルとスカラーの間で要素ごとの減算を実行します。

Subtraction<TScalar>(TScalar, Tensor<TScalar>)

テンソルとスカラーの間で要素ごとの減算を実行します。

Subtraction<TScalar>(TScalar, TensorSpan<TScalar>)

テンソルとスカラーの間で要素ごとの減算を実行します。

SubtractionAssignment(ReadOnlyTensorSpan<TScalar>)

2 つのテンソル間でインプレース要素ごとの減算を実行します。

SubtractionAssignment(ReadOnlyTensorSpan<TScalar>)

2 つのテンソル間でインプレース要素ごとの減算を実行します。

SubtractionAssignment(TScalar)

テンソルとスカラーの間のインプレース要素ごとの減算を実行します。

SubtractionAssignment(TScalar)

テンソルとスカラーの間のインプレース要素ごとの減算を実行します。

SubtractionAssignment<TScalar>(Tensor<TScalar>, ReadOnlyTensorSpan<TScalar>)

2 つのテンソル間でインプレース要素ごとの減算を実行します。

SubtractionAssignment<TScalar>(Tensor<TScalar>, TScalar)

テンソルとスカラーの間のインプレース要素ごとの減算を実行します。

SubtractionAssignment<TScalar>(TensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)

2 つのテンソル間でインプレース要素ごとの減算を実行します。

SubtractionAssignment<TScalar>(TensorSpan<TScalar>, TScalar)

テンソルとスカラーの間のインプレース要素ごとの減算を実行します。

UnaryNegation(ReadOnlyTensorSpan<TScalar>)

テンソルに対して要素ごとの単項否定を実行します。

UnaryNegation(Tensor<TScalar>)

テンソルに対して要素ごとの単項否定を実行します。

UnaryNegation(TensorSpan<TScalar>)

テンソルに対して要素ごとの単項否定を実行します。

UnaryNegation<TScalar>(ReadOnlyTensorSpan<TScalar>)

テンソルに対して要素ごとの単項否定を実行します。

UnaryNegation<TScalar>(Tensor<TScalar>)

テンソルに対して要素ごとの単項否定を実行します。

UnaryNegation<TScalar>(TensorSpan<TScalar>)

テンソルに対して要素ごとの単項否定を実行します。

UnaryPlus(ReadOnlyTensorSpan<TScalar>)

テンソルに対して要素ごとの単項プラスを実行します。

UnaryPlus(Tensor<TScalar>)

テンソルに対して要素ごとの単項プラスを実行します。

UnaryPlus(TensorSpan<TScalar>)

テンソルに対して要素ごとの単項プラスを実行します。

UnaryPlus<TScalar>(ReadOnlyTensorSpan<TScalar>)

テンソルに対して要素ごとの単項プラスを実行します。

UnaryPlus<TScalar>(Tensor<TScalar>)

テンソルに対して要素ごとの単項プラスを実行します。

UnaryPlus<TScalar>(TensorSpan<TScalar>)

テンソルに対して要素ごとの単項プラスを実行します。

UnsignedRightShift(ReadOnlyTensorSpan<TScalar>, Int32)

テンソルに対して要素ごとの論理右シフトを実行します。

UnsignedRightShift(Tensor<TScalar>, Int32)

テンソルに対して要素ごとの論理右シフトを実行します。

UnsignedRightShift(TensorSpan<TScalar>, Int32)

テンソルに対して要素ごとの論理右シフトを実行します。

UnsignedRightShift<TScalar>(ReadOnlyTensorSpan<TScalar>, Int32)

テンソルに対して要素ごとの論理右シフトを実行します。

UnsignedRightShift<TScalar>(Tensor<TScalar>, Int32)

テンソルに対して要素ごとの論理右シフトを実行します。

UnsignedRightShift<TScalar>(TensorSpan<TScalar>, Int32)

テンソルに対して要素ごとの論理右シフトを実行します。

UnsignedRightShiftAssignment(Int32)

テンソルに対してインプレース要素ごとの論理右シフトを実行します。

UnsignedRightShiftAssignment(Int32)

テンソルに対してインプレース要素ごとの論理右シフトを実行します。

UnsignedRightShiftAssignment<TScalar>(Tensor<TScalar>, Int32)

テンソルに対してインプレース要素ごとの論理右シフトを実行します。

UnsignedRightShiftAssignment<TScalar>(TensorSpan<TScalar>, Int32)

テンソルに対してインプレース要素ごとの論理右シフトを実行します。

適用対象