Tensor 類別

定義

命名空間:

System.Numerics.Tensors

組件:

System.Numerics.Tensors.dll

套件:

System.Numerics.Tensors v11.0.0-rc.1.26425.128

來源:

Tensor.cs

提供張量操作的方法。

public ref class Tensor abstract sealed

public static class Tensor

type Tensor = class

Public Module Tensor

繼承

Object

Tensor

方法

名稱	Description
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> 的反雙曲餘弦除以π，並返回一個 TensorSpan<T> 新的結果。
AcosPi<T>(ReadOnlyTensorSpan<T>)	取每個元素 Tensor<T> 的反雙曲餘弦除以π，並返回一個 Tensor<T> 新的結果。
Add<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)	在兩個張量之間進行元素層加法。
Add<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)	在兩個張量之間進行元素層加法。
Add<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<T>)	在張量與純量之間進行元素層的加法。
Add<T>(ReadOnlyTensorSpan<T>, T)	在張量與純量之間進行元素層的加法。
Asin<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)	取每個元素 ReadOnlyTensorSpan<T> 的逆正弦，並返回一個 TensorSpan<T> 新的結果。
Asin<T>(ReadOnlyTensorSpan<T>)	取每個元素 ReadOnlyTensorSpan<T> 的逆正弦，並返回一個 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> 的逆雙曲正弦除以圓周率，並返回一個 TensorSpan<T> 新的結果。
AsinPi<T>(ReadOnlyTensorSpan<T>)	對 中每個元素 ReadOnlyTensorSpan<T> 的逆雙曲正弦除以圓周率，並返回一個 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>)	在目標陣列中從「起始」索引開始到「結束」索引結束的部分（排他）建立一個新的區間。
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>)	取兩個輸入 ReadOnlyTensorSpan<T> 的弧切線，並回傳一個新的 TensorSpan<T> 結果。
Atan2<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)	取兩個輸入 ReadOnlyTensorSpan<T> 的弧切線，並回傳一個新的 Tensor<T> 結果。
Atan2<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<T>)	取兩個輸入 ReadOnlyTensorSpan<T> 的弧切線，並回傳一個新的 TensorSpan<T> 結果。
Atan2<T>(ReadOnlyTensorSpan<T>, T)	取兩個輸入 ReadOnlyTensorSpan<T> 的弧切線，並回傳一個新的 Tensor<T> 結果。
Atan2<T>(T, ReadOnlyTensorSpan<T>, TensorSpan<T>)	取兩個輸入 ReadOnlyTensorSpan<T> 的弧切線，並回傳一個新的 TensorSpan<T> 結果。
Atan2<T>(T, ReadOnlyTensorSpan<T>)	取兩個輸入 ReadOnlyTensorSpan<T> 的弧切線，並回傳一個新的 Tensor<T> 結果。
Atan2Pi<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)	取兩個輸入 ReadOnlyTensorSpan<T>的弧切線，將每個元素除以圓周率，並返回一個 TensorSpan<T> 新的結果。
Atan2Pi<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)	取兩個輸入 ReadOnlyTensorSpan<T>的弧切線，將每個元素除以圓周率，並返回一個 Tensor<T> 新的結果。
Atan2Pi<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<T>)	取兩個輸入 ReadOnlyTensorSpan<T>的弧切線，將每個元素除以圓周率，並返回一個 TensorSpan<T> 新的結果。
Atan2Pi<T>(ReadOnlyTensorSpan<T>, T)	取兩個輸入 ReadOnlyTensorSpan<T>的弧切線，將每個元素除以圓周率，並返回一個 TensorSpan<T> 新的結果。
Atan2Pi<T>(T, ReadOnlyTensorSpan<T>, TensorSpan<T>)	取兩個輸入 ReadOnlyTensorSpan<T>的弧切線，將每個元素除以圓周率，並返回一個 TensorSpan<T> 新的結果。
Atan2Pi<T>(T, ReadOnlyTensorSpan<T>)	取兩個輸入 ReadOnlyTensorSpan<T>的弧切線，將每個元素除以圓周率，並返回一個 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> 的逆雙曲切除以圓周率，並返回一個新的 TensorSpan<T> 結果。
AtanPi<T>(ReadOnlyTensorSpan<T>)	對每個元素 ReadOnlyTensorSpan<T> 的逆雙曲切除以圓周率，並返回一個新的 Tensor<T> 結果。
Average<T>(ReadOnlyTensorSpan<T>)	回傳張量中元素 x 的平均值。
BitwiseAnd<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)	在兩個張量間執行位元和。
BitwiseAnd<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)	在兩個張量間執行位元和。
BitwiseAnd<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<T>)	在位元和張量之間執行。
BitwiseAnd<T>(ReadOnlyTensorSpan<T>, T)	在位元和張量之間執行。
BitwiseOr<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)	在兩個張量間執行位元或位元操作。
BitwiseOr<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)	在兩個張量間執行位元或位元操作。
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>)	計算將符號從一個數字複製到指定張量中另一個數字的元素層次結果，並返回新的 TensorSpan<T> 結果。
CopySign<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)	計算將符號從一個數字複製到指定張量中另一個數字的元素層次結果，並返回新的 Tensor<T> 結果。
CopySign<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<T>)	計算將正負號從一個數位複製到指定張量中的另一個數位的項目結果，並傳回具有結果的新張量。
CopySign<T>(ReadOnlyTensorSpan<T>, T)	計算將正負號從一個數位複製到指定張量中的另一個數位的項目結果，並傳回具有結果的新張量。
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>)	計算與 x之間的y餘弦相似度。
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 為真，則底層緩衝區會被永久釘選，否則底層緩衝區不會被釘選。 底層緩衝區尚未初始化。
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>)	在 Euclidean 空間中，計算兩個點之間的距離，指定為非空白、相等長度的數字張量。
Divide<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)	執行兩個張量之間的元素分割。
Divide<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)	執行兩個張量之間的元素分割。
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>)	計算包含數位的兩個張量點乘積。
Equals<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<Boolean>)	比較二 ReadOnlyTensorSpan<T> 的元素以求相等。 如果圖形不相同，則會在比較圖形之前，將張量廣播到最小的可廣播大小。 它回傳 a TensorSpan<T> ，當元素相等時，該值為真;若不相等則為假。」/>
Equals<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)	比較二 ReadOnlyTensorSpan<T> 的元素以求相等。 如果圖形不相同，則會在比較圖形之前，將張量廣播到最小的可廣播大小。 它回傳 a TensorSpan<T> ，當元素相等時，該值為真;若不相等則為假。」/>
Equals<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<Boolean>)	比較二 ReadOnlyTensorSpan<T> 的元素以求相等。 如果圖形不相同，則會在比較圖形之前，將張量廣播到最小的可廣播大小。 它回傳 a TensorSpan<T> ，當元素相等時，該值為真;若不相等則為假。」/>
Equals<T>(ReadOnlyTensorSpan<T>, T)	比較二 ReadOnlyTensorSpan<T> 的元素以求相等。 如果圖形不相同，則會在比較圖形之前，將張量廣播到最小的可廣播大小。 它回傳 a TensorSpan<T> ，當元素相等時，該值為真;若不相等則為假。」/>
EqualsAll<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)	比較 2 ReadOnlyTensorSpan<T> 的元素，以判斷 中 x 的所有元素是否都相等於 y。 如果圖形不相同，則會在比較圖形之前，將張量廣播到最小的可廣播大小。 它會回傳 ， Boolean 其中若 中所有 x 元素均等於 ， y則 值為真。
EqualsAll<T>(ReadOnlyTensorSpan<T>, T)	比較 2 ReadOnlyTensorSpan<T> 的元素，以判斷 中 x 的所有元素是否都相等於 y。 如果圖形不相同，則會在比較圖形之前，將張量廣播到最小的可廣播大小。 它會回傳 ， Boolean 其中若 中所有 x 元素均等於 ， y則 值為真。
EqualsAny<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)	比較 2 ReadOnlyTensorSpan<T> 的元素，以判斷 中 x 是否有元素等於 y。 如果圖形不相同，則會在比較圖形之前，將張量廣播到最小的可廣播大小。 它會回傳 ， Boolean 其中若 中 x 任一元素等於 y，則該值為真。
EqualsAny<T>(ReadOnlyTensorSpan<T>, T)	比較 2 ReadOnlyTensorSpan<T> 的元素，以判斷 中 x 是否有元素等於 y。 如果圖形不相同，則會在比較圖形之前，將張量廣播到最小的可廣播大小。 它會回傳 ， Boolean 其中若 中 x 任一元素等於 y，則該值為真。
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乘以數位乘冪的項目結果，減一。
Exp10M1<T>(ReadOnlyTensorSpan<T>)	計算在指定張量中將10乘以數位乘冪的項目結果，減一。
Exp2<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)	計算在指定張量中將 2 提高到數位乘冪的項目結果。
Exp2<T>(ReadOnlyTensorSpan<T>)	計算在指定張量中將 2 提高到數位乘冪的項目結果。
Exp2M1<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)	計算將 2 乘以指定張量中的數位乘冪乘以減一的元素結果。
Exp2M1<T>(ReadOnlyTensorSpan<T>)	計算將 2 乘以指定張量中的數位乘冪乘以減一的元素結果。
ExpM1<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)	計算將 提升 e 到指定張量的數次方負 1 的元素層次結果。
ExpM1<T>(ReadOnlyTensorSpan<T>)	計算將 提升 e 到指定張量的數次方負 1 的元素層次結果。
FillGaussianNormalDistribution<T>(TensorSpan<T>, Random)	以高斯常態分布中隨機資料填充所給。TensorSpan<T> Random 可選擇性地提供種子。
FillUniformDistribution<T>(TensorSpan<T>, Random)	以均勻分布填充隨機 TensorSpan<T> 資料。 Random 可選擇性地提供種子。
FilteredUpdate<T>(TensorSpan<T>, ReadOnlyTensorSpan<Boolean>, ReadOnlyTensorSpan<T>)	更新 tensor 張量，其中 values 為 filter 真。 如果維度不同，則會擲回例外狀況。
FilteredUpdate<T>(TensorSpan<T>, ReadOnlyTensorSpan<Boolean>, T)	更新 tensor 張量，其中 value 為 filter 真。
Floor<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)	計算指定之張量中的以元素為底數的數位。
Floor<T>(ReadOnlyTensorSpan<T>)	計算指定之張量中的以元素為底數的數位。
GreaterThan<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<Boolean>)	比較 2 ReadOnlyTensorSpan<T> 的元素，以判斷哪些元素 x 大於 y。 如果圖形不相同，則會在比較圖形之前，將張量廣播到最小的可廣播大小。 它回傳 aTensor<T>，其中當 元素大於 x 時y，值為真;若不大則為假。」/>
GreaterThan<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)	比較 2 ReadOnlyTensorSpan<T> 的元素，以判斷哪些元素 x 大於 y。 如果圖形不相同，則會在比較圖形之前，將張量廣播到最小的可廣播大小。 它回傳 aTensor<T>，其中當 元素大於 x 時y，值為真;若不大則為假。」/>
GreaterThan<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<Boolean>)	比較 的 ReadOnlyTensorSpan<T> 元素，以判斷哪些元素大於 y。 它回傳 aTensor<T>，其中當 元素大於 x 時y，值為真;若不大則為假。」/>
GreaterThan<T>(ReadOnlyTensorSpan<T>, T)	比較 的 ReadOnlyTensorSpan<T> 元素，以判斷哪些元素大於 y。 它回傳 aTensor<T>，其中當 元素大於 x 時y，值為真;若不大則為假。」/>
GreaterThan<T>(T, ReadOnlyTensorSpan<T>, TensorSpan<Boolean>)	比較 x 以觀察哪些元素大於 y。 它回傳 aTensor<T>，其中當 元素大於 x 時y，值為真;若不大則為假。」/>
GreaterThan<T>(T, ReadOnlyTensorSpan<T>)	比較 x 以觀察哪些元素大於 y。 它回傳 aTensor<T>，其中當 元素大於 x 時y，值為真;若不大則為假。」/>
GreaterThanAll<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)	比較 2 ReadOnlyTensorSpan<T> 的元素，以判斷所有元素 x 是否大於 y。 如果圖形不相同，則會在比較圖形之前，將張量廣播到最小的可廣播大小。 它會回傳 ， Boolean 其中若 中 x 所有元素都大於 y，則該值為真。
GreaterThanAll<T>(ReadOnlyTensorSpan<T>, T)	比較 2 ReadOnlyTensorSpan<T> 的元素，以判斷所有元素 x 是否大於 y。 如果圖形不相同，則會在比較圖形之前，將張量廣播到最小的可廣播大小。 它會回傳 ， Boolean 其中若 中 x 所有元素都大於 y，則該值為真。
GreaterThanAll<T>(T, ReadOnlyTensorSpan<T>)	比較 2 ReadOnlyTensorSpan<T> 的元素，以判斷所有元素 y 是否大於 y。 如果圖形不相同，則會在比較圖形之前，將張量廣播到最小的可廣播大小。 它會回傳 ， Boolean 其中若 中 y 所有元素都大於 y，則該值為真。
GreaterThanAny<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)	比較 2 ReadOnlyTensorSpan<T> 的元素，以判斷是否有 x 任何元素大於 y。 如果圖形不相同，則會在比較圖形之前，將張量廣播到最小的可廣播大小。 它會回傳 ， Boolean 其中若 中 x 任一元素大於 y，則 值為真。
GreaterThanAny<T>(ReadOnlyTensorSpan<T>, T)	比較 2 ReadOnlyTensorSpan<T> 的元素，以判斷是否有 x 任何元素大於 y。 如果圖形不相同，則會在比較圖形之前，將張量廣播到最小的可廣播大小。 它會回傳 ， Boolean 其中若 中 x 任一元素大於 y，則 值為真。
GreaterThanAny<T>(T, ReadOnlyTensorSpan<T>)	比較 2 ReadOnlyTensorSpan<T> 的元素，以判斷是否有 y 任何元素大於 x。 如果圖形不相同，則會在比較圖形之前，將張量廣播到最小的可廣播大小。 它會回傳 ， Boolean 其中若 中 y 任一元素大於 x，則 值為真。
GreaterThanOrEqual<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<Boolean>)	比較 2 ReadOnlyTensorSpan<T> 的元素，以判斷哪些元素 x 大於或等於 y。 如果圖形不相同，則會在比較圖形之前，將張量廣播到最小的可廣播大小。 它回傳 aTensor<T>，其中當 元素大於 x 時y，值為真;若不大則為假。」/>
GreaterThanOrEqual<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)	比較 2 ReadOnlyTensorSpan<T> 的元素，以判斷哪些元素 x 大於或等於 y。 如果圖形不相同，則會在比較圖形之前，將張量廣播到最小的可廣播大小。 它回傳 aTensor<T>，其中當 元素大於 x 時y，值為真;若不大則為假。」/>
GreaterThanOrEqual<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<Boolean>)	比較 的ReadOnlyTensorSpan<T>元素，以判斷哪些元素大於或等於。y 它回傳 aTensor<T>，其中當 元素大於 x 時y，值為真;若不大則為假。」/>
GreaterThanOrEqual<T>(ReadOnlyTensorSpan<T>, T)	比較 的ReadOnlyTensorSpan<T>元素，以判斷哪些元素大於或等於。y 它回傳 aTensor<T>，其中當 元素大於 x 時y，值為真;若不大則為假。」/>
GreaterThanOrEqual<T>(T, ReadOnlyTensorSpan<T>, TensorSpan<Boolean>)	比較 x 以判斷哪些元素大於或等於 y。 它回傳 aTensor<T>，其中當 元素大於 x 時y，值為真;若不大則為假。」/>
GreaterThanOrEqual<T>(T, ReadOnlyTensorSpan<T>)	比較 x 以判斷哪些元素大於或等於 y。 它回傳 aTensor<T>，其中當 元素大於 x 時y，值為真;若不大則為假。」/>
GreaterThanOrEqualAll<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)	比較 2 ReadOnlyTensorSpan<T> 的元素，以判斷所有元素 x 是否大於 y。 如果圖形不相同，則會在比較圖形之前，將張量廣播到最小的可廣播大小。 它會回傳 ， Boolean 其中若 中 x 所有元素都大於 y，則該值為真。
GreaterThanOrEqualAll<T>(ReadOnlyTensorSpan<T>, T)	比較 2 ReadOnlyTensorSpan<T> 的元素，以判斷所有元素 x 是否大於 y。 如果圖形不相同，則會在比較圖形之前，將張量廣播到最小的可廣播大小。 它會回傳 ， Boolean 其中若 中 x 所有元素都大於 y，則該值為真。
GreaterThanOrEqualAll<T>(T, ReadOnlyTensorSpan<T>)	比較 2 ReadOnlyTensorSpan<T> 的元素，以判斷所有元素 y 是否大於 y。 如果圖形不相同，則會在比較圖形之前，將張量廣播到最小的可廣播大小。 它會回傳 ， Boolean 其中若 中 y 所有元素都大於 y，則該值為真。
GreaterThanOrEqualAny<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)	比較 2 ReadOnlyTensorSpan<T> 的元素，以判斷是否有 x 任何元素大於 y。 如果圖形不相同，則會在比較圖形之前，將張量廣播到最小的可廣播大小。 它會回傳 ， Boolean 其中若 中 x 任一元素大於 y，則 值為真。
GreaterThanOrEqualAny<T>(ReadOnlyTensorSpan<T>, T)	比較 2 ReadOnlyTensorSpan<T> 的元素，以判斷是否有 x 任何元素大於 y。 如果圖形不相同，則會在比較圖形之前，將張量廣播到最小的可廣播大小。 它會回傳 ， Boolean 其中若 中 x 任一元素大於 y，則 值為真。
GreaterThanOrEqualAny<T>(T, ReadOnlyTensorSpan<T>)	比較 2 ReadOnlyTensorSpan<T> 的元素，以判斷是否有 y 任何元素大於 x。 如果圖形不相同，則會在比較圖形之前，將張量廣播到最小的可廣播大小。 它會回傳 ， Boolean 其中若 中 y 任一元素大於 x，則 值為真。
Hypot<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)	從代表右角三角形中較短側邊長度的兩個張量計算元素的低階乘法。 如果圖形不相同，則會廣播到最小的相容圖形。
Hypot<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)	從代表右角三角形中較短側邊長度的兩個張量計算元素的低階乘法。 如果圖形不相同，則會廣播到最小的相容圖形。
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>)	比較二 ReadOnlyTensorSpan<T> 的元素，以判斷哪些元素 x 小於 y。 如果圖形不相同，則會在比較圖形之前，將張量廣播到最小的可廣播大小。 它會回傳 a Tensor<T> ，其中當元素 x 小 y 於 時 為真;若不小則為假。」/>
LessThan<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)	比較二 ReadOnlyTensorSpan<T> 的元素，以判斷哪些元素 x 小於 y。 如果圖形不相同，則會在比較圖形之前，將張量廣播到最小的可廣播大小。 它會回傳 a Tensor<T> ，其中當元素 x 小 y 於 時 為真;若不小則為假。」/>
LessThan<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<Boolean>)	比較 的 Tensor<T> 元素，以判斷哪些元素小於 y。 它會回傳 a Tensor<T> ，其中當元素 x 小 y 於 時 為真;若不小則為假。」/>
LessThan<T>(ReadOnlyTensorSpan<T>, T)	比較 的 Tensor<T> 元素，以判斷哪些元素小於 y。 它會回傳 a Tensor<T> ，其中當元素 x 小 y 於 時 為真;若不小則為假。」/>
LessThan<T>(T, ReadOnlyTensorSpan<T>, TensorSpan<Boolean>)	比較 的 Tensor<T> 元素，以判斷哪些元素小於 y。 它會回傳 a Tensor<T> ，其中當元素 x 小 y 於 時 為真;若不小則為假。」/>
LessThan<T>(T, ReadOnlyTensorSpan<T>)	比較 的 Tensor<T> 元素，以判斷哪些元素小於 y。 它會回傳 a Tensor<T> ，其中當元素 x 小 y 於 時 為真;若不小則為假。」/>
LessThanAll<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)	比較 2 ReadOnlyTensorSpan<T> 的元素，以判斷所有元素 x 是否小於 y。 如果圖形不相同，則會在比較圖形之前，將張量廣播到最小的可廣播大小。 它會回傳 ， Boolean 當 中 x 所有元素小於 y時，該值為真。
LessThanAll<T>(ReadOnlyTensorSpan<T>, T)	比較 2 ReadOnlyTensorSpan<T> 的元素，以判斷所有元素 x 是否小於 y。 如果圖形不相同，則會在比較圖形之前，將張量廣播到最小的可廣播大小。 它會回傳 ， Boolean 當 中 x 所有元素小於 y時，該值為真。
LessThanAll<T>(T, ReadOnlyTensorSpan<T>)	比較 2 ReadOnlyTensorSpan<T> 的元素，以判斷所有元素 y 是否小於 x。 如果圖形不相同，則會在比較圖形之前，將張量廣播到最小的可廣播大小。 它會回傳 ， Boolean 當 中 y 所有元素小於 x時，該值為真。
LessThanAny<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)	比較 2 ReadOnlyTensorSpan<T> 的元素，以判斷 中 x 是否有小於 y的元素。 如果圖形不相同，則會在比較圖形之前，將張量廣播到最小的可廣播大小。 它會回傳 ， Boolean 其中若 中 x 任一元素小於 y，則該值為真。
LessThanAny<T>(ReadOnlyTensorSpan<T>, T)	比較 2 ReadOnlyTensorSpan<T> 的元素，以判斷 中 x 是否有小於 y的元素。 如果圖形不相同，則會在比較圖形之前，將張量廣播到最小的可廣播大小。 它會回傳 ， Boolean 其中若 中 x 任一元素小於 y，則該值為真。
LessThanAny<T>(T, ReadOnlyTensorSpan<T>)	比較 2 ReadOnlyTensorSpan<T> 的元素，以判斷 中 y 是否有小於 y的元素。 如果圖形不相同，則會在比較圖形之前，將張量廣播到最小的可廣播大小。 它會回傳 ， Boolean 其中若 中 y 任一元素小於 y，則該值為真。
LessThanOrEqual<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<Boolean>)	比較二 ReadOnlyTensorSpan<T> 的元素，以判斷哪些元素 x 小於 y。 如果圖形不相同，則會在比較圖形之前，將張量廣播到最小的可廣播大小。 它會回傳 a Tensor<T> ，其中當元素 x 小 y 於 時 為真;若不小則為假。」/>
LessThanOrEqual<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)	比較二 ReadOnlyTensorSpan<T> 的元素，以判斷哪些元素 x 小於 y。 如果圖形不相同，則會在比較圖形之前，將張量廣播到最小的可廣播大小。 它會回傳 a Tensor<T> ，其中當元素 x 小 y 於 時 為真;若不小則為假。」/>
LessThanOrEqual<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<Boolean>)	比較 的 Tensor<T> 元素，以判斷哪些元素小於 y。 它會回傳 a Tensor<T> ，其中當元素 x 小 y 於 時 為真;若不小則為假。」/>
LessThanOrEqual<T>(ReadOnlyTensorSpan<T>, T)	比較 的 Tensor<T> 元素，以判斷哪些元素小於 y。 它會回傳 a Tensor<T> ，其中當元素 x 小 y 於 時 為真;若不小則為假。」/>
LessThanOrEqual<T>(T, ReadOnlyTensorSpan<T>, TensorSpan<Boolean>)	比較 的 Tensor<T> 元素，以判斷哪些元素小於 y。 它會回傳 a Tensor<T> ，其中當元素 x 小 y 於 時 為真;若不小則為假。」/>
LessThanOrEqual<T>(T, ReadOnlyTensorSpan<T>)	比較 的 Tensor<T> 元素，以判斷哪些元素小於 y。 它會回傳 a Tensor<T> ，其中當元素 x 小 y 於 時 為真;若不小則為假。」/>
LessThanOrEqualAll<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)	比較 2 ReadOnlyTensorSpan<T> 的元素，以判斷所有元素 x 是否小於 y。 如果圖形不相同，則會在比較圖形之前，將張量廣播到最小的可廣播大小。 它會回傳 ， Boolean 當 中 x 所有元素小於 y時，該值為真。
LessThanOrEqualAll<T>(ReadOnlyTensorSpan<T>, T)	比較 2 ReadOnlyTensorSpan<T> 的元素，以判斷所有元素 x 是否小於 y。 如果圖形不相同，則會在比較圖形之前，將張量廣播到最小的可廣播大小。 它會回傳 ， Boolean 當 中 x 所有元素小於 y時，該值為真。
LessThanOrEqualAll<T>(T, ReadOnlyTensorSpan<T>)	比較 2 ReadOnlyTensorSpan<T> 的元素，以判斷所有元素 y 是否小於 x。 如果圖形不相同，則會在比較圖形之前，將張量廣播到最小的可廣播大小。 它會回傳 ， Boolean 當 中 y 所有元素小於 x時，該值為真。
LessThanOrEqualAny<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)	比較 2 ReadOnlyTensorSpan<T> 的元素，以判斷 中 x 是否有小於 y的元素。 如果圖形不相同，則會在比較圖形之前，將張量廣播到最小的可廣播大小。 它會回傳 ， Boolean 其中若 中 x 任一元素小於 y，則該值為真。
LessThanOrEqualAny<T>(ReadOnlyTensorSpan<T>, T)	比較 2 ReadOnlyTensorSpan<T> 的元素，以判斷 中 x 是否有小於 y的元素。 如果圖形不相同，則會在比較圖形之前，將張量廣播到最小的可廣播大小。 它會回傳 ， Boolean 其中若 中 x 任一元素小於 y，則該值為真。
LessThanOrEqualAny<T>(T, ReadOnlyTensorSpan<T>)	比較 2 ReadOnlyTensorSpan<T> 的元素，以判斷 中 y 是否有小於 y的元素。 如果圖形不相同，則會在比較圖形之前，將張量廣播到最小的可廣播大小。 它會回傳 ， Boolean 其中若 中 y 任一元素小於 y，則該值為真。
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>)	在兩個張量間進行元素相乘。
Multiply<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)	在兩個張量間進行元素相乘。
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>)	對張量進行一補補。
OnesComplement<T>(ReadOnlyTensorSpan<T>)	對張量進行一補補。
PermuteDimensions<T>(Tensor<T>, ReadOnlySpan<Int32>)	根據參數交換張量tensor的維度dimensions。 若 tensor 是一維張量，則會返回 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>)	將 tensor 張量重新塑造為指定的 lengths。 如果其中一個長度為 -1，則會自動計算。 不會變更基礎記憶體的長度，也不會配置新的記憶體。 如果新圖形與舊圖形不相容，則會擲回例外狀況。
Reshape<T>(Tensor<T>, ReadOnlySpan<IntPtr>)	將 tensor 張量重新塑造為指定的 lengths。 如果其中一個長度為 -1，則會自動計算。 不會變更基礎記憶體的長度，也不會配置新的記憶體。 如果新圖形與舊圖形不相容，則會擲回例外狀況。
Reshape<T>(TensorSpan<T>, ReadOnlySpan<IntPtr>)	將 tensor 張量重新塑造為指定的 lengths。 如果其中一個長度為 -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} 比較元素，判斷兩個序列是否相等。Equals（T）。
SequenceEqual<T>(TensorSpan<T>, ReadOnlyTensorSpan<T>)	使用 IEquatable{T} 比較元素，判斷兩個序列是否相等。Equals（T）。
SetSlice<T>(Tensor<T>, ReadOnlyTensorSpan<T>, ReadOnlySpan<NRange>)	將給定tensor的切片與給定的 所提供valuesranges
SetSlice<T>(TensorSpan<T>, ReadOnlyTensorSpan<T>, ReadOnlySpan<NRange>)	將給定tensor的切片與給定的 所提供valuesranges
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 函數。
Sigmoid<T>(ReadOnlyTensorSpan<T>)	在指定的非空白數位張量上計算元素型 sigmoid 函數。
Sin<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)	取 中 ReadOnlyTensorSpan<T> 每個元素的罪，並返回一個新的 TensorSpan<T> 結果。
Sin<T>(ReadOnlyTensorSpan<T>)	取 中 ReadOnlyTensorSpan<T> 每個元素的罪，並返回一個新的 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)	將 a Tensor<T> 分割成 splitCountdimension。 若張量無法在給定 dimension 的 上均勻分割，則會拋出例外。
Sqrt<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)	取每個元素 x 的平方根，並返回一個新的 TensorSpan<T> 結果。
Sqrt<T>(ReadOnlyTensorSpan<T>)	取每個元素 ReadOnlyTensorSpan<T> 的平方根，並返回一個新的 Tensor<T> 結果。
Squeeze<T>(ReadOnlyTensorSpan<T>)	從 中移除所有長度為一的維度。tensor
Squeeze<T>(Tensor<T>)	從 中移除所有長度為一的維度。tensor
Squeeze<T>(TensorSpan<T>)	從 中移除所有長度為一的維度。tensor
SqueezeDimension<T>(ReadOnlyTensorSpan<T>, Int32)	對於給定tensor的 ，從 中dimension移除長度為一的軸。 如果維度不是長度，則會擲回例外狀況。
SqueezeDimension<T>(Tensor<T>, Int32)	對於給定tensor的 ，從 中dimension移除長度為一的軸。 如果維度不是長度，則會擲回例外狀況。
SqueezeDimension<T>(TensorSpan<T>, Int32)	對於給定tensor的 ，從 中dimension移除長度為一的軸。 如果維度不是長度，則會擲回例外狀況。
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>)	在兩個張量間進行元素層次減法。
Subtract<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)	在兩個張量間進行元素層次減法。
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>)	計算指定之張量中的元素尾端零個數字計數。
TrailingZeroCount<T>(ReadOnlyTensorSpan<T>)	計算指定之張量中的元素尾端零個數字計數。
Transpose<T>(Tensor<T>)	交換張量的最後兩個維度 tensor 。
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>)	在兩個張量之間執行異或異。
Xor<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)	在兩個張量之間執行異或異。
Xor<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<T>)	能在張量與純量之間執行異物或介於兩者之間。
Xor<T>(ReadOnlyTensorSpan<T>, T)	能在張量與純量之間執行異物或介於兩者之間。

運算子

名稱	Description
Addition(ReadOnlyTensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)	在兩個張量之間進行元素層加法。
Addition(ReadOnlyTensorSpan<TScalar>, TScalar)	在張量與純量之間進行元素層的加法。
Addition(Tensor<TScalar>, Tensor<TScalar>)	在兩個張量之間進行元素層加法。
Addition(Tensor<TScalar>, TScalar)	在張量與純量之間進行元素層的加法。
Addition(TensorSpan<TScalar>, TensorSpan<TScalar>)	在兩個張量之間進行元素層加法。
Addition(TensorSpan<TScalar>, TScalar)	在張量與純量之間進行元素層的加法。
Addition(TScalar, ReadOnlyTensorSpan<TScalar>)	在張量與純量之間進行元素層的加法。
Addition(TScalar, Tensor<TScalar>)	在張量與純量之間進行元素層的加法。
Addition(TScalar, TensorSpan<TScalar>)	在張量與純量之間進行元素層的加法。
Addition<TScalar>(ReadOnlyTensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)	在兩個張量之間進行元素層加法。
Addition<TScalar>(ReadOnlyTensorSpan<TScalar>, TScalar)	在張量與純量之間進行元素層的加法。
Addition<TScalar>(Tensor<TScalar>, Tensor<TScalar>)	在兩個張量之間進行元素層加法。
Addition<TScalar>(Tensor<TScalar>, TScalar)	在張量與純量之間進行元素層的加法。
Addition<TScalar>(TensorSpan<TScalar>, TensorSpan<TScalar>)	在兩個張量之間進行元素層加法。
Addition<TScalar>(TensorSpan<TScalar>, TScalar)	在張量與純量之間進行元素層的加法。
Addition<TScalar>(TScalar, ReadOnlyTensorSpan<TScalar>)	在張量與純量之間進行元素層的加法。
Addition<TScalar>(TScalar, Tensor<TScalar>)	在張量與純量之間進行元素層的加法。
Addition<TScalar>(TScalar, TensorSpan<TScalar>)	在張量與純量之間進行元素層的加法。
AdditionAssignment(ReadOnlyTensorSpan<TScalar>)	在兩個張量間進行原位元素加法。
AdditionAssignment(ReadOnlyTensorSpan<TScalar>)	在兩個張量間進行原位元素加法。
AdditionAssignment(TScalar)	在張量與純量之間進行原位元素加法。
AdditionAssignment(TScalar)	在張量與純量之間進行原位元素加法。
AdditionAssignment<TScalar>(Tensor<TScalar>, ReadOnlyTensorSpan<TScalar>)	在兩個張量間進行原位元素加法。
AdditionAssignment<TScalar>(Tensor<TScalar>, TScalar)	在張量與純量之間進行原位元素加法。
AdditionAssignment<TScalar>(TensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)	在兩個張量間進行原位元素加法。
AdditionAssignment<TScalar>(TensorSpan<TScalar>, TScalar)	在張量與純量之間進行原位元素加法。
BitwiseAnd(ReadOnlyTensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)	在兩個張量間執行位元和。
BitwiseAnd(ReadOnlyTensorSpan<TScalar>, TScalar)	在位元和張量之間執行。
BitwiseAnd(Tensor<TScalar>, Tensor<TScalar>)	在兩個張量間執行位元和。
BitwiseAnd(Tensor<TScalar>, TScalar)	在位元和張量之間執行。
BitwiseAnd(TensorSpan<TScalar>, TensorSpan<TScalar>)	在兩個張量間執行位元和。
BitwiseAnd(TensorSpan<TScalar>, TScalar)	在位元和張量之間執行。
BitwiseAnd(TScalar, ReadOnlyTensorSpan<TScalar>)	在位元和張量之間執行。
BitwiseAnd(TScalar, Tensor<TScalar>)	在位元和張量之間執行。
BitwiseAnd(TScalar, TensorSpan<TScalar>)	在位元和張量之間執行。
BitwiseAnd<TScalar>(ReadOnlyTensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)	在兩個張量間執行位元和。
BitwiseAnd<TScalar>(ReadOnlyTensorSpan<TScalar>, TScalar)	在位元和張量之間執行。
BitwiseAnd<TScalar>(Tensor<TScalar>, Tensor<TScalar>)	在兩個張量間執行位元和。
BitwiseAnd<TScalar>(Tensor<TScalar>, TScalar)	在位元和張量之間執行。
BitwiseAnd<TScalar>(TensorSpan<TScalar>, TensorSpan<TScalar>)	在兩個張量間執行位元和。
BitwiseAnd<TScalar>(TensorSpan<TScalar>, TScalar)	在位元和張量之間執行。
BitwiseAnd<TScalar>(TScalar, ReadOnlyTensorSpan<TScalar>)	在位元和張量之間執行。
BitwiseAnd<TScalar>(TScalar, Tensor<TScalar>)	在位元和張量之間執行。
BitwiseAnd<TScalar>(TScalar, TensorSpan<TScalar>)	在位元和張量之間執行。
BitwiseAndAssignment(ReadOnlyTensorSpan<TScalar>)	在位元和兩個張量之間進行原位元操作。
BitwiseAndAssignment(ReadOnlyTensorSpan<TScalar>)	在位元和兩個張量之間進行原位元操作。
BitwiseAndAssignment(TScalar)	原位元執行，介於張量與純量之間。
BitwiseAndAssignment(TScalar)	原位元執行，介於張量與純量之間。
BitwiseAndAssignment<TScalar>(Tensor<TScalar>, ReadOnlyTensorSpan<TScalar>)	在位元和兩個張量之間進行原位元操作。
BitwiseAndAssignment<TScalar>(Tensor<TScalar>, TScalar)	原位元執行，介於張量與純量之間。
BitwiseAndAssignment<TScalar>(TensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)	在位元和兩個張量之間進行原位元操作。
BitwiseAndAssignment<TScalar>(TensorSpan<TScalar>, TScalar)	原位元執行，介於張量與純量之間。
BitwiseOr(ReadOnlyTensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)	在兩個張量間執行位元或位元操作。
BitwiseOr(ReadOnlyTensorSpan<TScalar>, TScalar)	以位元方式或介於張量與純量之間執行。
BitwiseOr(Tensor<TScalar>, Tensor<TScalar>)	在兩個張量間執行位元或位元操作。
BitwiseOr(Tensor<TScalar>, TScalar)	以位元方式或介於張量與純量之間執行。
BitwiseOr(TensorSpan<TScalar>, TensorSpan<TScalar>)	在兩個張量間執行位元或位元操作。
BitwiseOr(TensorSpan<TScalar>, TScalar)	以位元方式或介於張量與純量之間執行。
BitwiseOr(TScalar, ReadOnlyTensorSpan<TScalar>)	以位元方式或介於張量與純量之間執行。
BitwiseOr(TScalar, Tensor<TScalar>)	以位元方式或介於張量與純量之間執行。
BitwiseOr(TScalar, TensorSpan<TScalar>)	以位元方式或介於張量與純量之間執行。
BitwiseOr<TScalar>(ReadOnlyTensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)	在兩個張量間執行位元或位元操作。
BitwiseOr<TScalar>(ReadOnlyTensorSpan<TScalar>, TScalar)	以位元方式或介於張量與純量之間執行。
BitwiseOr<TScalar>(Tensor<TScalar>, Tensor<TScalar>)	在兩個張量間執行位元或位元操作。
BitwiseOr<TScalar>(Tensor<TScalar>, TScalar)	以位元方式或介於張量與純量之間執行。
BitwiseOr<TScalar>(TensorSpan<TScalar>, TensorSpan<TScalar>)	在兩個張量間執行位元或位元操作。
BitwiseOr<TScalar>(TensorSpan<TScalar>, TScalar)	以位元方式或介於張量與純量之間執行。
BitwiseOr<TScalar>(TScalar, ReadOnlyTensorSpan<TScalar>)	以位元方式或介於張量與純量之間執行。
BitwiseOr<TScalar>(TScalar, Tensor<TScalar>)	以位元方式或介於張量與純量之間執行。
BitwiseOr<TScalar>(TScalar, TensorSpan<TScalar>)	以位元方式或介於張量與純量之間執行。
BitwiseOrAssignment(ReadOnlyTensorSpan<TScalar>)	在位元或兩個張量之間進行原位元操作。
BitwiseOrAssignment(ReadOnlyTensorSpan<TScalar>)	在位元或兩個張量之間進行原位元操作。
BitwiseOrAssignment(TScalar)	在位元或張量與純量之間進行原位元操作。
BitwiseOrAssignment(TScalar)	在位元或張量與純量之間進行原位元操作。
BitwiseOrAssignment<TScalar>(Tensor<TScalar>, ReadOnlyTensorSpan<TScalar>)	在位元或兩個張量之間進行原位元操作。
BitwiseOrAssignment<TScalar>(Tensor<TScalar>, TScalar)	在位元或張量與純量之間進行原位元操作。
BitwiseOrAssignment<TScalar>(TensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)	在位元或兩個張量之間進行原位元操作。
BitwiseOrAssignment<TScalar>(TensorSpan<TScalar>, TScalar)	在位元或張量與純量之間進行原位元操作。
DecrementAssignment	對張量進行原位遞減。
DecrementAssignment	對張量進行原位遞減。
DecrementAssignment<TScalar>(Tensor<TScalar>)	對張量進行原位遞減。
DecrementAssignment<TScalar>(TensorSpan<TScalar>)	對張量進行原位遞減。
Division(ReadOnlyTensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)	執行兩個張量之間的元素分割。
Division(ReadOnlyTensorSpan<TScalar>, TScalar)	在張量與純量之間進行元素分割。
Division(Tensor<TScalar>, Tensor<TScalar>)	執行兩個張量之間的元素分割。
Division(Tensor<TScalar>, TScalar)	在張量與純量之間進行元素分割。
Division(TensorSpan<TScalar>, TensorSpan<TScalar>)	執行兩個張量之間的元素分割。
Division(TensorSpan<TScalar>, TScalar)	在張量與純量之間進行元素分割。
Division(TScalar, ReadOnlyTensorSpan<TScalar>)	在張量與純量之間進行元素分割。
Division(TScalar, Tensor<TScalar>)	在張量與純量之間進行元素分割。
Division(TScalar, TensorSpan<TScalar>)	在張量與純量之間進行元素分割。
Division<TScalar>(ReadOnlyTensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)	執行兩個張量之間的元素分割。
Division<TScalar>(ReadOnlyTensorSpan<TScalar>, TScalar)	在張量與純量之間進行元素分割。
Division<TScalar>(Tensor<TScalar>, Tensor<TScalar>)	執行兩個張量之間的元素分割。
Division<TScalar>(Tensor<TScalar>, TScalar)	在張量與純量之間進行元素分割。
Division<TScalar>(TensorSpan<TScalar>, TensorSpan<TScalar>)	執行兩個張量之間的元素分割。
Division<TScalar>(TensorSpan<TScalar>, TScalar)	在張量與純量之間進行元素分割。
Division<TScalar>(TScalar, ReadOnlyTensorSpan<TScalar>)	在張量與純量之間進行元素分割。
Division<TScalar>(TScalar, Tensor<TScalar>)	在張量與純量之間進行元素分割。
Division<TScalar>(TScalar, TensorSpan<TScalar>)	在張量與純量之間進行元素分割。
DivisionAssignment(ReadOnlyTensorSpan<TScalar>)	在兩個張量之間執行元素層層的局部分割。
DivisionAssignment(ReadOnlyTensorSpan<TScalar>)	在兩個張量之間執行元素層層的局部分割。
DivisionAssignment(TScalar)	在張量與純量之間進行元素分割。
DivisionAssignment(TScalar)	在張量與純量之間進行元素分割。
DivisionAssignment<TScalar>(Tensor<TScalar>, ReadOnlyTensorSpan<TScalar>)	在兩個張量之間執行元素層層的局部分割。
DivisionAssignment<TScalar>(Tensor<TScalar>, TScalar)	在張量與純量之間進行元素分割。
DivisionAssignment<TScalar>(TensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)	在兩個張量之間執行元素層層的局部分割。
DivisionAssignment<TScalar>(TensorSpan<TScalar>, TScalar)	在張量與純量之間進行元素分割。
ExclusiveOr(ReadOnlyTensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)	在兩個張量之間執行異或異。
ExclusiveOr(ReadOnlyTensorSpan<TScalar>, TScalar)	能在張量與純量之間執行異物或介於兩者之間。
ExclusiveOr(Tensor<TScalar>, Tensor<TScalar>)	在兩個張量之間執行異或異。
ExclusiveOr(Tensor<TScalar>, TScalar)	能在張量與純量之間執行異物或介於兩者之間。
ExclusiveOr(TensorSpan<TScalar>, TensorSpan<TScalar>)	在兩個張量之間執行異或異。
ExclusiveOr(TensorSpan<TScalar>, TScalar)	能在張量與純量之間執行異物或介於兩者之間。
ExclusiveOr(TScalar, ReadOnlyTensorSpan<TScalar>)	能在張量與純量之間執行異物或介於兩者之間。
ExclusiveOr(TScalar, Tensor<TScalar>)	能在張量與純量之間執行異物或介於兩者之間。
ExclusiveOr(TScalar, TensorSpan<TScalar>)	能在張量與純量之間執行異物或介於兩者之間。
ExclusiveOr<TScalar>(ReadOnlyTensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)	在兩個張量之間執行異或異。
ExclusiveOr<TScalar>(ReadOnlyTensorSpan<TScalar>, TScalar)	能在張量與純量之間執行異物或介於兩者之間。
ExclusiveOr<TScalar>(Tensor<TScalar>, Tensor<TScalar>)	在兩個張量之間執行異或異。
ExclusiveOr<TScalar>(Tensor<TScalar>, TScalar)	能在張量與純量之間執行異物或介於兩者之間。
ExclusiveOr<TScalar>(TensorSpan<TScalar>, TensorSpan<TScalar>)	在兩個張量之間執行異或異。
ExclusiveOr<TScalar>(TensorSpan<TScalar>, TScalar)	能在張量與純量之間執行異物或介於兩者之間。
ExclusiveOr<TScalar>(TScalar, ReadOnlyTensorSpan<TScalar>)	能在張量與純量之間執行異物或介於兩者之間。
ExclusiveOr<TScalar>(TScalar, Tensor<TScalar>)	能在張量與純量之間執行異物或介於兩者之間。
ExclusiveOr<TScalar>(TScalar, TensorSpan<TScalar>)	能在張量與純量之間執行異物或介於兩者之間。
ExclusiveOrAssignment(ReadOnlyTensorSpan<TScalar>)	在原位進行異置或介於兩個張量之間。
ExclusiveOrAssignment(ReadOnlyTensorSpan<TScalar>)	在原位進行異置或介於兩個張量之間。
ExclusiveOrAssignment(TScalar)	在原地進行排他，或介於張量與純量之間。
ExclusiveOrAssignment(TScalar)	在原地進行排他，或介於張量與純量之間。
ExclusiveOrAssignment<TScalar>(Tensor<TScalar>, ReadOnlyTensorSpan<TScalar>)	在原位進行異置或介於兩個張量之間。
ExclusiveOrAssignment<TScalar>(Tensor<TScalar>, TScalar)	在原地進行排他，或介於張量與純量之間。
ExclusiveOrAssignment<TScalar>(TensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)	在原位進行異置或介於兩個張量之間。
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>)	在兩個張量間進行原位元素逐元素乘法。
MultiplicationAssignment(ReadOnlyTensorSpan<TScalar>)	在兩個張量間進行原位元素逐元素乘法。
MultiplicationAssignment(TScalar)	在張量與純量之間進行元素相乘。
MultiplicationAssignment(TScalar)	在張量與純量之間進行元素相乘。
MultiplicationAssignment<TScalar>(Tensor<TScalar>, ReadOnlyTensorSpan<TScalar>)	在兩個張量間進行原位元素逐元素乘法。
MultiplicationAssignment<TScalar>(Tensor<TScalar>, TScalar)	在張量與純量之間進行元素相乘。
MultiplicationAssignment<TScalar>(TensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)	在兩個張量間進行原位元素逐元素乘法。
MultiplicationAssignment<TScalar>(TensorSpan<TScalar>, TScalar)	在張量與純量之間進行元素相乘。
Multiply(ReadOnlyTensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)	在兩個張量間進行元素相乘。
Multiply(ReadOnlyTensorSpan<TScalar>, TScalar)	在張量與純量之間進行元素相乘。
Multiply(Tensor<TScalar>, Tensor<TScalar>)	在兩個張量間進行元素相乘。
Multiply(Tensor<TScalar>, TScalar)	在張量與純量之間進行元素相乘。
Multiply(TensorSpan<TScalar>, TensorSpan<TScalar>)	在兩個張量間進行元素相乘。
Multiply(TensorSpan<TScalar>, TScalar)	在張量與純量之間進行元素相乘。
Multiply(TScalar, ReadOnlyTensorSpan<TScalar>)	在張量與純量之間進行元素相乘。
Multiply(TScalar, Tensor<TScalar>)	在張量與純量之間進行元素相乘。
Multiply(TScalar, TensorSpan<TScalar>)	在張量與純量之間進行元素相乘。
Multiply<TScalar>(ReadOnlyTensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)	在兩個張量間進行元素相乘。
Multiply<TScalar>(ReadOnlyTensorSpan<TScalar>, TScalar)	在張量與純量之間進行元素相乘。
Multiply<TScalar>(Tensor<TScalar>, Tensor<TScalar>)	在兩個張量間進行元素相乘。
Multiply<TScalar>(Tensor<TScalar>, TScalar)	在張量與純量之間進行元素相乘。
Multiply<TScalar>(TensorSpan<TScalar>, TensorSpan<TScalar>)	在兩個張量間進行元素相乘。
Multiply<TScalar>(TensorSpan<TScalar>, TScalar)	在張量與純量之間進行元素相乘。
Multiply<TScalar>(TScalar, ReadOnlyTensorSpan<TScalar>)	在張量與純量之間進行元素相乘。
Multiply<TScalar>(TScalar, Tensor<TScalar>)	在張量與純量之間進行元素相乘。
Multiply<TScalar>(TScalar, TensorSpan<TScalar>)	在張量與純量之間進行元素相乘。
OnesComplement(ReadOnlyTensorSpan<TScalar>)	對張量進行一補補。
OnesComplement(Tensor<TScalar>)	對張量進行一補補。
OnesComplement(TensorSpan<TScalar>)	對張量進行一補補。
OnesComplement<TScalar>(ReadOnlyTensorSpan<TScalar>)	對張量進行一補補。
OnesComplement<TScalar>(Tensor<TScalar>)	對張量進行一補補。
OnesComplement<TScalar>(TensorSpan<TScalar>)	對張量進行一補補。
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>)	在兩個張量間進行元素層次減法。
Subtraction(ReadOnlyTensorSpan<TScalar>, TScalar)	在張量與純量之間進行元素相減。
Subtraction(Tensor<TScalar>, Tensor<TScalar>)	在兩個張量間進行元素層次減法。
Subtraction(Tensor<TScalar>, TScalar)	在張量與純量之間進行元素相減。
Subtraction(TensorSpan<TScalar>, TensorSpan<TScalar>)	在兩個張量間進行元素層次減法。
Subtraction(TensorSpan<TScalar>, TScalar)	在張量與純量之間進行元素相減。
Subtraction(TScalar, ReadOnlyTensorSpan<TScalar>)	在張量與純量之間進行元素相減。
Subtraction(TScalar, Tensor<TScalar>)	在張量與純量之間進行元素相減。
Subtraction(TScalar, TensorSpan<TScalar>)	在張量與純量之間進行元素相減。
Subtraction<TScalar>(ReadOnlyTensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)	在兩個張量間進行元素層次減法。
Subtraction<TScalar>(ReadOnlyTensorSpan<TScalar>, TScalar)	在張量與純量之間進行元素相減。
Subtraction<TScalar>(Tensor<TScalar>, Tensor<TScalar>)	在兩個張量間進行元素層次減法。
Subtraction<TScalar>(Tensor<TScalar>, TScalar)	在張量與純量之間進行元素相減。
Subtraction<TScalar>(TensorSpan<TScalar>, TensorSpan<TScalar>)	在兩個張量間進行元素層次減法。
Subtraction<TScalar>(TensorSpan<TScalar>, TScalar)	在張量與純量之間進行元素相減。
Subtraction<TScalar>(TScalar, ReadOnlyTensorSpan<TScalar>)	在張量與純量之間進行元素相減。
Subtraction<TScalar>(TScalar, Tensor<TScalar>)	在張量與純量之間進行元素相減。
Subtraction<TScalar>(TScalar, TensorSpan<TScalar>)	在張量與純量之間進行元素相減。
SubtractionAssignment(ReadOnlyTensorSpan<TScalar>)	在兩個張量間進行元素層次的原位減法。
SubtractionAssignment(ReadOnlyTensorSpan<TScalar>)	在兩個張量間進行元素層次的原位減法。
SubtractionAssignment(TScalar)	在張量與純量之間進行元素相減。
SubtractionAssignment(TScalar)	在張量與純量之間進行元素相減。
SubtractionAssignment<TScalar>(Tensor<TScalar>, ReadOnlyTensorSpan<TScalar>)	在兩個張量間進行元素層次的原位減法。
SubtractionAssignment<TScalar>(Tensor<TScalar>, TScalar)	在張量與純量之間進行元素相減。
SubtractionAssignment<TScalar>(TensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)	在兩個張量間進行元素層次的原位減法。
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)	在張量上執行元素層位邏輯右移。