Condividi tramite


Tensor Classe

Definizione

public ref class Tensor abstract sealed
[System.Diagnostics.CodeAnalysis.Experimental("SYSLIB5001", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
public static class Tensor
[<System.Diagnostics.CodeAnalysis.Experimental("SYSLIB5001", UrlFormat="https://aka.ms/dotnet-warnings/{0}")>]
type Tensor = class
Public Module Tensor
Ereditarietà
Tensor
Attributi

Metodi

Abs<T>(ReadOnlyTensorSpan<T>)

Accetta il valore assoluto di ogni elemento del Tensor<T> e restituisce un nuovo Tensor<T> con il risultato.

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

Accetta il valore assoluto di ogni elemento del ReadOnlyTensorSpan<T> e restituisce un nuovo TensorSpan<T> con il risultato.

Acos<T>(ReadOnlyTensorSpan<T>)

Accetta il coseno inverso di ogni elemento del Tensor<T> e restituisce un nuovo Tensor<T> con il risultato.

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

Accetta il coseno inverso di ogni elemento del Tensor<T> e restituisce un nuovo Tensor<T> con il risultato.

Acosh<T>(ReadOnlyTensorSpan<T>)

Accetta il coseno iperbolico inverso di ogni elemento del ReadOnlyTensorSpan<T> e restituisce un nuovo Tensor<T> con il risultato.

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

Accetta il coseno iperbolico inverso di ogni elemento del TensorSpan<T> e restituisce un nuovo TensorSpan<T> con il risultato.

AcosPi<T>(ReadOnlyTensorSpan<T>)

Accetta il coseno iperbolico inverso diviso per pi di ogni elemento del Tensor<T> e restituisce un nuovo Tensor<T> con il risultato.

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

Accetta il coseno iperbolico inverso diviso per pi di ogni elemento del TensorSpan<T> e restituisce un nuovo TensorSpan<T> con il risultato.

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

Aggiunge ogni elemento di x a ogni elemento di y e restituisce un nuovo Tensor<T> con il risultato.

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

Aggiunge ogni elemento di x a ogni elemento di y e restituisce un nuovo ReadOnlyTensorSpan<T> con il risultato.

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

Aggiunge y a ogni elemento di x e restituisce un nuovo Tensor<T> con il risultato.

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

Aggiunge y a ogni elemento di x e restituisce un nuovo TensorSpan<T> con il risultato.

Asin<T>(ReadOnlyTensorSpan<T>)

Accetta il peccato inverso di ogni elemento del ReadOnlyTensorSpan<T> e restituisce un nuovo Tensor<T> con il risultato.

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

Accetta il peccato inverso di ogni elemento del ReadOnlyTensorSpan<T> e restituisce un nuovo TensorSpan<T> con il risultato.

Asinh<T>(ReadOnlyTensorSpan<T>)

Accetta il seno iperbolico inverso di ogni elemento del ReadOnlyTensorSpan<T> e restituisce un nuovo Tensor<T> con il risultato.

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

Accetta il seno iperbolico inverso di ogni elemento del ReadOnlyTensorSpan<T> e restituisce un nuovo TensorSpan<T> con il risultato.

AsinPi<T>(ReadOnlyTensorSpan<T>)

Accetta il seno iperbolico inverso diviso per pi di ogni elemento del ReadOnlyTensorSpan<T> e restituisce un nuovo Tensor<T> con il risultato.

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

Accetta il seno iperbolico inverso diviso per pi di ogni elemento del ReadOnlyTensorSpan<T> e restituisce un nuovo TensorSpan<T> con il risultato.

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

Metodo di estensione per creare più facilmente un tensorSpan da una matrice.

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

Metodo di estensione per creare più facilmente un tensorSpan da una matrice.

Atan<T>(ReadOnlyTensorSpan<T>)

Accetta l'arco tangente di ogni elemento del ReadOnlyTensorSpan<T> e restituisce un nuovo Tensor<T> con il risultato.

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

Accetta l'arco tangente di ogni elemento del ReadOnlyTensorSpan<T> e restituisce un nuovo TensorSpan<T> con il risultato.

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

Accetta l'arco tangente dei due ReadOnlyTensorSpan<T> di input e restituisce un nuovo Tensor<T> con il risultato.

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

Accetta l'arco tangente dei due ReadOnlyTensorSpan<T> di input e restituisce un nuovo TensorSpan<T> con il risultato.

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

Accetta l'arco tangente dei due ReadOnlyTensorSpan<T> di input e restituisce un nuovo Tensor<T> con il risultato.

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

Accetta l'arco tangente dei due ReadOnlyTensorSpan<T> di input e restituisce un nuovo TensorSpan<T> con il risultato.

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

Accetta l'arco tangente dei due ReadOnlyTensorSpan<T> di input e restituisce un nuovo Tensor<T> con il risultato.

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

Accetta l'arco tangente dei due ReadOnlyTensorSpan<T> di input e restituisce un nuovo TensorSpan<T> con il risultato.

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

Accetta l'arco tangente dei due input ReadOnlyTensorSpan<T>, divide ogni elemento per pi e restituisce un nuovo Tensor<T> con il risultato.

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

Accetta l'arco tangente dei due input ReadOnlyTensorSpan<T>, divide ogni elemento per pi e restituisce un nuovo TensorSpan<T> con il risultato.

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

Accetta l'arco tangente dei due input ReadOnlyTensorSpan<T>, divide ogni elemento per pi e restituisce un nuovo TensorSpan<T> con il risultato.

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

Accetta l'arco tangente dei due input ReadOnlyTensorSpan<T>, divide ogni elemento per pi e restituisce un nuovo TensorSpan<T> con il risultato.

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

Accetta l'arco tangente dei due input ReadOnlyTensorSpan<T>, divide ogni elemento per pi e restituisce un nuovo TensorSpan<T> con il risultato.

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

Accetta l'arco tangente dei due input ReadOnlyTensorSpan<T>, divide ogni elemento per pi e restituisce un nuovo TensorSpan<T> con il risultato.

Atanh<T>(ReadOnlyTensorSpan<T>)

Accetta la tangente iperbolica inversa di ogni elemento del ReadOnlyTensorSpan<T> e restituisce un nuovo Tensor<T> con il risultato.

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

Accetta la tangente iperbolica inversa di ogni elemento del ReadOnlyTensorSpan<T> e restituisce un nuovo TensorSpan<T> con il risultato.

AtanPi<T>(ReadOnlyTensorSpan<T>)

Accetta la tangente iperbolica inversa divisa per pi di ogni elemento del ReadOnlyTensorSpan<T> e restituisce un nuovo Tensor<T> con il risultato.

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

Accetta la tangente iperbolica inversa divisa per pi di ogni elemento del ReadOnlyTensorSpan<T> e restituisce un nuovo TensorSpan<T> con il risultato.

Average<T>(ReadOnlyTensorSpan<T>)

Restituisce la media degli elementi nel tensore x.

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

Calcola l'elemento bit per bit e dei due ReadOnlyTensorSpan<T> di input e restituisce un nuovo Tensor<T> con il risultato.

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

Calcola l'elemento bit per bit e dei due ReadOnlyTensorSpan<T> di input e restituisce un nuovo TensorSpan<T> con il risultato.

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

Calcola l'elemento bit per bit e dei due ReadOnlyTensorSpan<T> di input e restituisce un nuovo Tensor<T> con il risultato.

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

Calcola l'elemento bit per bit e dei due ReadOnlyTensorSpan<T> di input e restituisce un nuovo TensorSpan<T> con il risultato.

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

Calcola l'elemento bit per bit dei due ReadOnlyTensorSpan<T> di input e restituisce un nuovo Tensor<T> con il risultato.

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

Calcola l'elemento bit per bit dei due ReadOnlyTensorSpan<T> di input e restituisce un nuovo TensorSpan<T> con il risultato.

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

Calcola l'elemento bit per bit o dei due ReadOnlyTensorSpan<T> di input e restituisce un nuovo Tensor<T> con il risultato.

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

Calcola l'elemento bit per bit o dei due ReadOnlyTensorSpan<T> di input e restituisce un nuovo TensorSpan<T> con il risultato.

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

Trasmettere i dati da source alla nuova forma lengths. Crea un nuovo Tensor<T> e alloca nuova memoria. Se la forma del source non è compatibile con la nuova forma, viene generata un'eccezione.

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

Trasmettere i dati da source alla forma broadcastable più piccola compatibile con lengthsSource. Crea un nuovo Tensor<T> e alloca nuova memoria.

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

Trasmettere i dati da source a destination.

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

Trasmettere i dati da source a destination.

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

Trasmettere i dati da source a destination.

Cbrt<T>(ReadOnlyTensorSpan<T>)

Calcola la radice del cubo a livello di elemento del ReadOnlyTensorSpan<T> di input e restituisce un nuovo Tensor<T> con il risultato.

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

Calcola la radice del cubo a livello di elemento del ReadOnlyTensorSpan<T> di input e restituisce un nuovo TensorSpan<T> con il risultato.

Ceiling<T>(ReadOnlyTensorSpan<T>)

Calcola il soffitto a livello di elemento del ReadOnlyTensorSpan<T> di input e restituisce un nuovo Tensor<T> con il risultato.

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

Calcola il soffitto a livello di elemento del ReadOnlyTensorSpan<T> di input e restituisce un nuovo TensorSpan<T> con il risultato.

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

Unire una sequenza di tensori lungo un asse esistente.

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

Unire una sequenza di tensori lungo un asse esistente.

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

Unire una sequenza di tensori lungo un asse esistente.

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

Unire una sequenza di tensori lungo un asse esistente.

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

Copia source in un nuovo ReadOnlyTensorSpan<T> convertendo ogni valore TFrom in un valore TTo.

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

Copia source in un nuovo TensorSpan<T> convertendo ogni valore TFrom in un valore TTo.

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

Copia source in un nuovo ReadOnlyTensorSpan<T> convertendo ogni valore TFrom in un valore TTo.

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

Copia source in un nuovo TensorSpan<T> convertendo ogni valore TFrom in un valore TTo.

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

Copia source in un nuovo ReadOnlyTensorSpan<T> convertendo ogni valore TFrom in un valore TTo.

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

Copia source in un nuovo TensorSpan<T> convertendo ogni valore TFrom in un valore TTo.

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

Calcola il risultato a livello di elemento della copia del segno da un numero a un altro nei tensori specificati e restituisce un nuovo Tensor<T> con il risultato.

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

Calcola il risultato a livello di elemento della copia del segno da un numero a un altro nei tensori specificati e restituisce un nuovo TensorSpan<T> con il risultato.

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

Calcola il risultato a livello di elemento della copia del segno da un numero a un altro nei tensori specificati e restituisce un nuovo tensore con il risultato.

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

Calcola il risultato a livello di elemento della copia del segno da un numero a un altro nei tensori specificati e restituisce un nuovo tensore con il risultato.

Cos<T>(ReadOnlyTensorSpan<T>)

Accetta il coseno di ogni elemento del ReadOnlyTensorSpan<T> e restituisce un nuovo Tensor<T> con il risultato.

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

Accetta il coseno di ogni elemento del ReadOnlyTensorSpan<T> e restituisce un nuovo TensorSpan<T> con il risultato.

Cosh<T>(ReadOnlyTensorSpan<T>)

Accetta il coseno iperbolico di ogni elemento del ReadOnlyTensorSpan<T> e restituisce un nuovo Tensor<T> con il risultato.

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

Accetta il coseno iperbolico di ogni elemento del ReadOnlyTensorSpan<T> e restituisce un nuovo TensorSpan<T> con il risultato.

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

Calcolare la somiglianza del coseno tra x e y.

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

Calcolare la somiglianza del coseno tra x e y.

CosPi<T>(ReadOnlyTensorSpan<T>)

Calcola il coseno a livello di elemento del valore nel tensore specificato moltiplicato per Pi e restituisce un nuovo Tensor<T> con i risultati.

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

Calcola il coseno a livello di elemento del valore nel tensore specificato moltiplicato per Pi e restituisce un nuovo TensorSpan<T> con i risultati.

Create<T>(IEnumerable<T>, ReadOnlySpan<IntPtr>, Boolean)

Crea un Tensor<T> e lo inizializza con i dati di values.

Create<T>(IEnumerable<T>, ReadOnlySpan<IntPtr>, ReadOnlySpan<IntPtr>, Boolean)

Crea un Tensor<T> e lo inizializza con i dati di values.

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

Crea un Tensor<T> e lo inizializza con il valore predefinito T. Se pinned è true, la memoria verrà bloccata.

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

Crea un Tensor<T> e lo inizializza con il valore predefinito T. Se pinned è true, la memoria verrà bloccata.

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

Crea un Tensor<T> dal valuesfornito. Se il prodotto del lengths non è uguale alla lunghezza della matrice values, verrà generata un'eccezione.

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

Crea un Tensor<T> dal valuesfornito. Se il prodotto del lengths non è uguale alla lunghezza della matrice values, verrà generata un'eccezione.

CreateAndFillGaussianNormalDistribution<T>(Random, ReadOnlySpan<IntPtr>)

Crea un Tensor<T> e lo inizializza con dati casuali in una distribuzione normale gaussian.

CreateAndFillGaussianNormalDistribution<T>(ReadOnlySpan<IntPtr>)

Crea un Tensor<T> e lo inizializza con dati casuali in una distribuzione normale gaussian.

CreateAndFillUniformDistribution<T>(Random, ReadOnlySpan<IntPtr>)

Crea un Tensor<T> e lo inizializza con dati casuali distribuiti in modo uniforme.

CreateAndFillUniformDistribution<T>(ReadOnlySpan<IntPtr>)

Crea un Tensor<T> e lo inizializza con dati casuali distribuiti in modo uniforme.

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

Crea un Tensor<T> e non lo inizializza. Se pinned è true, la memoria verrà bloccata.

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

Crea un Tensor<T> e non lo inizializza. Se pinned è true, la memoria verrà bloccata.

DegreesToRadians<T>(ReadOnlyTensorSpan<T>)

Calcola la conversione a livello di elemento di ogni numero di gradi nel tensore specificato in radianti e restituisce un nuovo tensore con i risultati.

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

Calcola la conversione a livello di elemento di ogni numero di gradi nel tensore specificato in radianti e restituisce un nuovo tensore con i risultati.

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

Calcola la distanza tra due punti, specificata come tensori non vuoti e di lunghezza uguale dei numeri, nello spazio euclideo.

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

Divide ogni elemento di x per l'elemento corrispondente in y e restituisce un nuovo ReadOnlyTensorSpan<T> con il risultato.

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

Divide ogni elemento di x per l'elemento corrispondente in y e restituisce un nuovo TensorSpan<T> con il risultato.

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

Divide ogni elemento di x per y e restituisce un nuovo Tensor<T> con il risultato.

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

Divide ogni elemento di x per y e restituisce un nuovo TensorSpan<T> con il risultato.

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

Divide x per ogni elemento di y e restituisce un nuovo Tensor<T> con il risultato". />

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

Divide x per ogni elemento di y e restituisce un nuovo TensorSpan<T> con il risultato". />

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

Calcola il prodotto punto di due tensori contenenti numeri.

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

Confronta gli elementi di due ReadOnlyTensorSpan<T> per verificare l'uguaglianza. Se le forme non sono uguali, i tensori vengono trasmessi alle dimensioni broadcastable più piccole prima che vengano confrontate. Restituisce un TensorSpan<T> in cui il valore è true se gli elementi sono uguali e false in caso contrario". />

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

Confronta gli elementi di due ReadOnlyTensorSpan<T> per verificare l'uguaglianza. Se le forme non sono uguali, i tensori vengono trasmessi alle dimensioni broadcastable più piccole prima che vengano confrontate. Restituisce un TensorSpan<T> in cui il valore è true se gli elementi sono uguali e false in caso contrario". />

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

Confronta gli elementi di due ReadOnlyTensorSpan<T> per verificare l'uguaglianza. Se le forme non sono uguali, i tensori vengono trasmessi alle dimensioni broadcastable più piccole prima che vengano confrontate. Restituisce un TensorSpan<T> in cui il valore è true se gli elementi sono uguali e false in caso contrario". />

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

Confronta gli elementi di due ReadOnlyTensorSpan<T> per verificare l'uguaglianza. Se le forme non sono uguali, i tensori vengono trasmessi alle dimensioni broadcastable più piccole prima che vengano confrontate. Restituisce un TensorSpan<T> in cui il valore è true se gli elementi sono uguali e false in caso contrario". />

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

Confronta gli elementi di due ReadOnlyTensorSpan<T> per verificare se tutti gli elementi di x sono uguali a y. Se le forme non sono uguali, i tensori vengono trasmessi alle dimensioni broadcastable più piccole prima che vengano confrontate. Restituisce un Boolean in cui il valore è true se tutti gli elementi in x sono eqaul per y.

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

Confronta gli elementi di due ReadOnlyTensorSpan<T> per verificare se tutti gli elementi di x sono uguali a y. Se le forme non sono uguali, i tensori vengono trasmessi alle dimensioni broadcastable più piccole prima che vengano confrontate. Restituisce un Boolean in cui il valore è true se tutti gli elementi in x sono eqaul per y.

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

Confronta gli elementi di due ReadOnlyTensorSpan<T> per verificare se uno degli elementi di x è uguale a y. Se le forme non sono uguali, i tensori vengono trasmessi alle dimensioni broadcastable più piccole prima che vengano confrontate. Restituisce un Boolean in cui il valore è true se qualsiasi elemento in x è uguale a y.

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

Confronta gli elementi di due ReadOnlyTensorSpan<T> per verificare se uno degli elementi di x è uguale a y. Se le forme non sono uguali, i tensori vengono trasmessi alle dimensioni broadcastable più piccole prima che vengano confrontate. Restituisce un Boolean in cui il valore è true se qualsiasi elemento in x è uguale a y.

Exp<T>(ReadOnlyTensorSpan<T>)

Calcola il risultato dell'elemento che genera e alle potenze a virgola mobile a precisione singola nel tensore specificato.

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

Calcola il risultato dell'elemento che genera e alle potenze a virgola mobile a precisione singola nel tensore specificato.

Exp10<T>(ReadOnlyTensorSpan<T>)

Calcola il risultato a livello di elemento di aumento di 10 al numero di potenze nel tensore specificato.

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

Calcola il risultato a livello di elemento di aumento di 10 al numero di potenze nel tensore specificato.

Exp10M1<T>(ReadOnlyTensorSpan<T>)

Calcola il risultato a livello di elemento di elevare 10 ai poteri numerici nel tensore specificato, meno uno.

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

Calcola il risultato a livello di elemento di elevare 10 ai poteri numerici nel tensore specificato, meno uno.

Exp2<T>(ReadOnlyTensorSpan<T>)

Calcola il risultato a livello di elemento di aumento di 2 al numero di potenze nel tensore specificato.

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

Calcola il risultato a livello di elemento di aumento di 2 al numero di potenze nel tensore specificato.

Exp2M1<T>(ReadOnlyTensorSpan<T>)

Calcola il risultato a livello di elemento di elevare 2 ai poteri numerici nel tensore specificato, meno uno.

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

Calcola il risultato a livello di elemento di elevare 2 ai poteri numerici nel tensore specificato, meno uno.

ExpM1<T>(ReadOnlyTensorSpan<T>)

Calcola il risultato a livello di elemento della generazione di e al numero di potenze nel tensore specificato, meno 1.

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

Calcola il risultato a livello di elemento della generazione di e al numero di potenze nel tensore specificato, meno 1.

FillGaussianNormalDistribution<T>(TensorSpan<T>, Random)
FillUniformDistribution<T>(TensorSpan<T>, Random)
FilteredUpdate<T>(TensorSpan<T>, ReadOnlyTensorSpan<Boolean>, ReadOnlyTensorSpan<T>)

Aggiorna il tensore tensor con il values in cui il filter è true. Se le dimensioni non sono uguali, viene generata un'eccezione.

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

Aggiorna il tensore tensor con il value in cui il filter è true.

Floor<T>(ReadOnlyTensorSpan<T>)

Calcola il piano elemento per i numeri nel tensore specificato.

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

Calcola il piano elemento per i numeri nel tensore specificato.

GetSmallestBroadcastableLengths(ReadOnlySpan<IntPtr>, ReadOnlySpan<IntPtr>)
GreaterThan<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

Confronta gli elementi di due ReadOnlyTensorSpan<T> per vedere quali elementi di x sono maggiori di y. Se le forme non sono uguali, i tensori vengono trasmessi alle dimensioni broadcastable più piccole prima che vengano confrontate. Restituisce un Tensor<T> in cui il valore è true se gli elementi in x sono maggiori di y e false se non lo sono". />

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

Confronta gli elementi di due ReadOnlyTensorSpan<T> per vedere quali elementi di x sono maggiori di y. Se le forme non sono uguali, i tensori vengono trasmessi alle dimensioni broadcastable più piccole prima che vengano confrontate. Restituisce un Tensor<T> in cui il valore è true se gli elementi in x sono maggiori di y e false se non lo sono". />

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

Confronta gli elementi di un ReadOnlyTensorSpan<T> per vedere quali elementi sono maggiori di y. Restituisce un Tensor<T> in cui il valore è true se gli elementi in x sono maggiori di y e false se non lo sono". />

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

Confronta gli elementi di un ReadOnlyTensorSpan<T> per vedere quali elementi sono maggiori di y. Restituisce un Tensor<T> in cui il valore è true se gli elementi in x sono maggiori di y e false se non lo sono". />

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

Confronta x per vedere quali elementi sono maggiori di y. Restituisce un Tensor<T> in cui il valore è true se gli elementi in x sono maggiori di y e false se non lo sono". />

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

Confronta x per vedere quali elementi sono maggiori di y. Restituisce un Tensor<T> in cui il valore è true se gli elementi in x sono maggiori di y e false se non lo sono". />

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

Confronta gli elementi di due ReadOnlyTensorSpan<T> per verificare se tutti gli elementi di x sono maggiori di y. Se le forme non sono uguali, i tensori vengono trasmessi alle dimensioni broadcastable più piccole prima che vengano confrontate. Restituisce un Boolean in cui il valore è true se tutti gli elementi in x sono maggiori di y.

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

Confronta gli elementi di due ReadOnlyTensorSpan<T> per verificare se tutti gli elementi di x sono maggiori di y. Se le forme non sono uguali, i tensori vengono trasmessi alle dimensioni broadcastable più piccole prima che vengano confrontate. Restituisce un Boolean in cui il valore è true se tutti gli elementi in x sono maggiori di y.

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

Confronta gli elementi di due ReadOnlyTensorSpan<T> per verificare se tutti gli elementi di y sono maggiori di y. Se le forme non sono uguali, i tensori vengono trasmessi alle dimensioni broadcastable più piccole prima che vengano confrontate. Restituisce un Boolean in cui il valore è true se tutti gli elementi in y sono maggiori di y.

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

Confronta gli elementi di due ReadOnlyTensorSpan<T> per verificare se uno degli elementi di x è maggiore di y. Se le forme non sono uguali, i tensori vengono trasmessi alle dimensioni broadcastable più piccole prima che vengano confrontate. Restituisce un Boolean in cui il valore è true se qualsiasi elemento in x è maggiore di y.

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

Confronta gli elementi di due ReadOnlyTensorSpan<T> per verificare se uno degli elementi di x è maggiore di y. Se le forme non sono uguali, i tensori vengono trasmessi alle dimensioni broadcastable più piccole prima che vengano confrontate. Restituisce un Boolean in cui il valore è true se qualsiasi elemento in x è maggiore di y.

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

Confronta gli elementi di due ReadOnlyTensorSpan<T> per verificare se uno degli elementi di y è maggiore di x. Se le forme non sono uguali, i tensori vengono trasmessi alle dimensioni broadcastable più piccole prima che vengano confrontate. Restituisce un Boolean in cui il valore è true se qualsiasi elemento in y è maggiore di x.

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

Confronta gli elementi di due ReadOnlyTensorSpan<T> per vedere quali elementi di x sono maggiori o uguali a y. Se le forme non sono uguali, i tensori vengono trasmessi alle dimensioni broadcastable più piccole prima che vengano confrontate. Restituisce un Tensor<T> in cui il valore è true se gli elementi in x sono maggiori di y e false se non lo sono". />

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

Confronta gli elementi di due ReadOnlyTensorSpan<T> per vedere quali elementi di x sono maggiori o uguali a y. Se le forme non sono uguali, i tensori vengono trasmessi alle dimensioni broadcastable più piccole prima che vengano confrontate. Restituisce un Tensor<T> in cui il valore è true se gli elementi in x sono maggiori di y e false se non lo sono". />

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

Confronta gli elementi di un ReadOnlyTensorSpan<T> per vedere quali elementi sono maggiori o uguali a y. Restituisce un Tensor<T> in cui il valore è true se gli elementi in x sono maggiori di y e false se non lo sono". />

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

Confronta gli elementi di un ReadOnlyTensorSpan<T> per vedere quali elementi sono maggiori o uguali a y. Restituisce un Tensor<T> in cui il valore è true se gli elementi in x sono maggiori di y e false se non lo sono". />

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

Confronta x per vedere quali elementi sono maggiori o uguali a y. Restituisce un Tensor<T> in cui il valore è true se gli elementi in x sono maggiori di y e false se non lo sono". />

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

Confronta x per vedere quali elementi sono maggiori o uguali a y. Restituisce un Tensor<T> in cui il valore è true se gli elementi in x sono maggiori di y e false se non lo sono". />

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

Confronta gli elementi di due ReadOnlyTensorSpan<T> per verificare se tutti gli elementi di x sono maggiori di y. Se le forme non sono uguali, i tensori vengono trasmessi alle dimensioni broadcastable più piccole prima che vengano confrontate. Restituisce un Boolean in cui il valore è true se tutti gli elementi in x sono maggiori di y.

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

Confronta gli elementi di due ReadOnlyTensorSpan<T> per verificare se tutti gli elementi di s sono maggiori di y. Se le forme non sono uguali, i tensori vengono trasmessi alle dimensioni broadcastable più piccole prima che vengano confrontate. Restituisce un Boolean in cui il valore è true se tutti gli elementi in s sono maggiori di y.

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

Confronta gli elementi di due ReadOnlyTensorSpan<T> per verificare se tutti gli elementi di y sono maggiori di y. Se le forme non sono uguali, i tensori vengono trasmessi alle dimensioni broadcastable più piccole prima che vengano confrontate. Restituisce un Boolean in cui il valore è true se tutti gli elementi in y sono maggiori di y.

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

Confronta gli elementi di due ReadOnlyTensorSpan<T> per verificare se uno degli elementi di x è maggiore di y. Se le forme non sono uguali, i tensori vengono trasmessi alle dimensioni broadcastable più piccole prima che vengano confrontate. Restituisce un Boolean in cui il valore è true se qualsiasi elemento in x è maggiore di y.

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

Confronta gli elementi di due ReadOnlyTensorSpan<T> per verificare se uno degli elementi di x è maggiore di y. Se le forme non sono uguali, i tensori vengono trasmessi alle dimensioni broadcastable più piccole prima che vengano confrontate. Restituisce un Boolean in cui il valore è true se qualsiasi elemento in x è maggiore di y.

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

Confronta gli elementi di due ReadOnlyTensorSpan<T> per verificare se uno degli elementi di y è maggiore di x. Se le forme non sono uguali, i tensori vengono trasmessi alle dimensioni broadcastable più piccole prima che vengano confrontate. Restituisce un Boolean in cui il valore è true se qualsiasi elemento in y è maggiore di x.

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

Calcola l'ipotenusa per elemento in base ai valori di due tensori che rappresentano le lunghezze dei lati più corti in un triangolo con angolo destro. Se le forme non sono uguali, vengono trasmesse alla forma più piccola compatibile.

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

Calcola l'ipotenusa per elemento in base ai valori di due tensori che rappresentano le lunghezze dei lati più corti in un triangolo con angolo destro. Se le forme non sono uguali, vengono trasmesse alla forma più piccola compatibile.

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

Calcola il resto degli elementi dei numeri nei tensori specificati.

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

Calcola il resto degli elementi dei numeri nei tensori specificati.

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

Calcola il resto degli elementi dei numeri nei tensori specificati.

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

Calcola il resto degli elementi dei numeri nei tensori specificati.

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

Calcola il resto degli elementi dei numeri nei tensori specificati.

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

Calcola il resto degli elementi dei numeri nei tensori specificati.

ILogB<T>(ReadOnlyTensorSpan<T>)

Calcola il logaritmo intero a livello di elemento del tensore specificato.

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

Calcola il logaritmo intero a livello di elemento del tensore specificato.

IndexOfMax<T>(ReadOnlyTensorSpan<T>)

Cerca l'indice del numero più grande nel tensore specificato.

IndexOfMaxMagnitude<T>(ReadOnlyTensorSpan<T>)

Cerca l'indice del numero con la grandezza maggiore nel tensore specificato.

IndexOfMin<T>(ReadOnlyTensorSpan<T>)

Cerca l'indice del numero più piccolo nel tensore specificato.

IndexOfMinMagnitude<T>(ReadOnlyTensorSpan<T>)

Cerca l'indice del numero con la grandezza più piccola nel tensore specificato.

LeadingZeroCount<T>(ReadOnlyTensorSpan<T>)

Calcola il numero zero iniziale di elementi nel tensore specificato.

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

Calcola il numero zero iniziale di elementi nel tensore specificato.

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

Confronta gli elementi di due ReadOnlyTensorSpan<T> per vedere quali elementi di x sono minori di y. Se le forme non sono uguali, i tensori vengono trasmessi alle dimensioni broadcastable più piccole prima che vengano confrontate. Restituisce un Tensor<T> in cui il valore è true se gli elementi in x sono minori di y e false se non lo sono". />

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

Confronta gli elementi di due ReadOnlyTensorSpan<T> per vedere quali elementi di x sono minori di y. Se le forme non sono uguali, i tensori vengono trasmessi alle dimensioni broadcastable più piccole prima che vengano confrontate. Restituisce un Tensor<T> in cui il valore è true se gli elementi in x sono minori di y e false se non lo sono". />

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

Confronta gli elementi di un Tensor<T> per vedere quali elementi sono minori di y. Restituisce un Tensor<T> in cui il valore è true se gli elementi in x sono minori di y e false se non lo sono". />

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

Confronta gli elementi di un Tensor<T> per vedere quali elementi sono minori di y. Restituisce un Tensor<T> in cui il valore è true se gli elementi in x sono minori di y e false se non lo sono". />

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

Confronta gli elementi di un Tensor<T> per vedere quali elementi sono minori di y. Restituisce un Tensor<T> in cui il valore è true se gli elementi in x sono minori di y e false se non lo sono". />

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

Confronta gli elementi di un Tensor<T> per vedere quali elementi sono minori di y. Restituisce un Tensor<T> in cui il valore è true se gli elementi in x sono minori di y e false se non lo sono". />

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

Confronta gli elementi di due ReadOnlyTensorSpan<T> per verificare se tutti gli elementi di x sono minori di y. Se le forme non sono uguali, i tensori vengono trasmessi alle dimensioni broadcastable più piccole prima che vengano confrontate. Restituisce un Boolean in cui il valore è true se tutti gli elementi in x sono minori di y.

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

Confronta gli elementi di due ReadOnlyTensorSpan<T> per verificare se tutti gli elementi di f sono minori di x. Se le forme non sono uguali, i tensori vengono trasmessi alle dimensioni broadcastable più piccole prima che vengano confrontate. Restituisce un Boolean in cui il valore è true se tutti gli elementi in f sono minori di x.

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

Confronta gli elementi di due ReadOnlyTensorSpan<T> per verificare se tutti gli elementi di y sono minori di x. Se le forme non sono uguali, i tensori vengono trasmessi alle dimensioni broadcastable più piccole prima che vengano confrontate. Restituisce un Boolean in cui il valore è true se tutti gli elementi in y sono minori di x.

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

Confronta gli elementi di due ReadOnlyTensorSpan<T> per verificare se uno degli elementi di x è minore di y. Se le forme non sono uguali, i tensori vengono trasmessi alle dimensioni broadcastable più piccole prima che vengano confrontate. Restituisce un Boolean in cui il valore è true se qualsiasi elemento in x è minore di y.

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

Confronta gli elementi di due ReadOnlyTensorSpan<T> per verificare se uno degli elementi di f è minore di x. Se le forme non sono uguali, i tensori vengono trasmessi alle dimensioni broadcastable più piccole prima che vengano confrontate. Restituisce un Boolean in cui il valore è true se qualsiasi elemento in f è minore di x.

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

Confronta gli elementi di due ReadOnlyTensorSpan<T> per verificare se uno degli elementi di y è minore di y. Se le forme non sono uguali, i tensori vengono trasmessi alle dimensioni broadcastable più piccole prima che vengano confrontate. Restituisce un Boolean in cui il valore è true se qualsiasi elemento in y è minore di y.

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

Confronta gli elementi di due ReadOnlyTensorSpan<T> per vedere quali elementi di x sono minori di y. Se le forme non sono uguali, i tensori vengono trasmessi alle dimensioni broadcastable più piccole prima che vengano confrontate. Restituisce un Tensor<T> in cui il valore è true se gli elementi in x sono minori di y e false se non lo sono". />

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

Confronta gli elementi di due ReadOnlyTensorSpan<T> per vedere quali elementi di x sono minori di y. Se le forme non sono uguali, i tensori vengono trasmessi alle dimensioni broadcastable più piccole prima che vengano confrontate. Restituisce un Tensor<T> in cui il valore è true se gli elementi in x sono minori di y e false se non lo sono". />

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

Confronta gli elementi di un Tensor<T> per vedere quali elementi sono minori di y. Restituisce un Tensor<T> in cui il valore è true se gli elementi in x sono minori di y e false se non lo sono". />

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

Confronta gli elementi di un Tensor<T> per vedere quali elementi sono minori di y. Restituisce un Tensor<T> in cui il valore è true se gli elementi in x sono minori di y e false se non lo sono". />

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

Confronta gli elementi di un Tensor<T> per vedere quali elementi sono minori di y. Restituisce un Tensor<T> in cui il valore è true se gli elementi in x sono minori di y e false se non lo sono". />

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

Confronta gli elementi di un Tensor<T> per vedere quali elementi sono minori di y. Restituisce un Tensor<T> in cui il valore è true se gli elementi in x sono minori di y e false se non lo sono". />

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

Confronta gli elementi di due ReadOnlyTensorSpan<T> per verificare se tutti gli elementi di x sono minori di y. Se le forme non sono uguali, i tensori vengono trasmessi alle dimensioni broadcastable più piccole prima che vengano confrontate. Restituisce un Boolean in cui il valore è true se tutti gli elementi in x sono minori di y.

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

Confronta gli elementi di due ReadOnlyTensorSpan<T> per verificare se tutti gli elementi di f sono minori di x. Se le forme non sono uguali, i tensori vengono trasmessi alle dimensioni broadcastable più piccole prima che vengano confrontate. Restituisce un Boolean in cui il valore è true se tutti gli elementi in f sono minori di x.

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

Confronta gli elementi di due ReadOnlyTensorSpan<T> per verificare se tutti gli elementi di y sono minori di x. Se le forme non sono uguali, i tensori vengono trasmessi alle dimensioni broadcastable più piccole prima che vengano confrontate. Restituisce un Boolean in cui il valore è true se tutti gli elementi in y sono minori di x.

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

Confronta gli elementi di due ReadOnlyTensorSpan<T> per verificare se uno degli elementi di x è minore di y. Se le forme non sono uguali, i tensori vengono trasmessi alle dimensioni broadcastable più piccole prima che vengano confrontate. Restituisce un Boolean in cui il valore è true se qualsiasi elemento in x è minore di y.

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

Confronta gli elementi di due ReadOnlyTensorSpan<T> per verificare se uno degli elementi di f è minore di x. Se le forme non sono uguali, i tensori vengono trasmessi alle dimensioni broadcastable più piccole prima che vengano confrontate. Restituisce un Boolean in cui il valore è true se qualsiasi elemento in f è minore di x.

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

Confronta gli elementi di due ReadOnlyTensorSpan<T> per verificare se uno degli elementi di y è minore di y. Se le forme non sono uguali, i tensori vengono trasmessi alle dimensioni broadcastable più piccole prima che vengano confrontate. Restituisce un Boolean in cui il valore è true se qualsiasi elemento in y è minore di y.

Log<T>(ReadOnlyTensorSpan<T>)

Accetta il logaritmo naturale di ogni elemento del ReadOnlyTensorSpan<T> e restituisce un nuovo Tensor<T> con il risultato.

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

Calcola il logaritmo a livello di elemento dei numeri in un tensore specificato nella base specificata in un altro tensore specificato.

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

Calcola il logaritmo a livello di elemento dei numeri in un tensore specificato nella base specificata in un altro tensore specificato.

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

Calcola il logaritmo a livello di elemento dei numeri in un tensore specificato nella base specificata in un altro tensore specificato.

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

Calcola il logaritmo a livello di elemento dei numeri in un tensore specificato nella base specificata in un altro tensore specificato.

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

Accetta il logaritmo naturale di ogni elemento del ReadOnlyTensorSpan<T> e restituisce un nuovo TensorSpan<T> con il risultato.

Log10<T>(ReadOnlyTensorSpan<T>)

Accetta il logaritmo di base 10 di ogni elemento del ReadOnlyTensorSpan<T> e restituisce un nuovo Tensor<T> con il risultato.

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

Accetta il logaritmo di base 10 di ogni elemento del ReadOnlyTensorSpan<T> e restituisce un nuovo TensorSpan<T> con il risultato.

Log10P1<T>(ReadOnlyTensorSpan<T>)

Accetta il logaritmo di base 10 più 1 di ogni elemento del ReadOnlyTensorSpan<T> e restituisce un nuovo Tensor<T> con il risultato.

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

Accetta il logaritmo di base 10 più 1 di ogni elemento del ReadOnlyTensorSpan<T> e restituisce un nuovo TensorSpan<T> con il risultato.

Log2<T>(ReadOnlyTensorSpan<T>)

Accetta il logaritmo in base 2 di ogni elemento del ReadOnlyTensorSpan<T> e restituisce un nuovo Tensor<T> con il risultato.

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

Accetta il logaritmo in base 2 di ogni elemento del ReadOnlyTensorSpan<T> e restituisce un nuovo TensorSpan<T> con il risultato.

Log2P1<T>(ReadOnlyTensorSpan<T>)

Accetta il logaritmo di base 2 più 1 di ogni elemento del ReadOnlyTensorSpan<T> e restituisce un nuovo Tensor<T> con il risultato.

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

Accetta il logaritmo di base 2 più 1 di ogni elemento del ReadOnlyTensorSpan<T> e restituisce un nuovo TensorSpan<T> con il risultato.

LogP1<T>(ReadOnlyTensorSpan<T>)

Accetta il logaritmo naturale più 1 di ogni elemento del ReadOnlyTensorSpan<T> e restituisce un nuovo Tensor<T> con il risultato.

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

Accetta il logaritmo naturale più 1 di ogni elemento del ReadOnlyTensorSpan<T> e restituisce un nuovo TensorSpan<T> con il risultato.

Max<T>(ReadOnlyTensorSpan<T>)

Cerca il numero più grande nel tensore specificato.

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

Calcola il valore massimo per elemento dei numeri nei tensori specificati.

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

Calcola il valore massimo per elemento dei numeri nei tensori specificati.

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

Calcola il valore massimo per elemento dei numeri nei tensori specificati.

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

Calcola il valore massimo per elemento dei numeri nei tensori specificati.

MaxMagnitude<T>(ReadOnlyTensorSpan<T>)

Cerca il numero con la grandezza più grande nel tensore specificato.

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

Calcola il numero a livello di elemento con la grandezza più grande nei tensori specificati.

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

Calcola il numero a livello di elemento con la grandezza più grande nei tensori specificati.

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

Calcola il numero a livello di elemento con la grandezza più grande nei tensori specificati.

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

Calcola il numero a livello di elemento con la grandezza più grande nei tensori specificati.

MaxMagnitudeNumber<T>(ReadOnlyTensorSpan<T>)

Cerca il numero con la grandezza più grande nel tensore specificato.

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

Calcola il numero a livello di elemento con la grandezza più grande nei tensori specificati.

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

Calcola il numero a livello di elemento con la grandezza più grande nei tensori specificati.

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

Calcola il numero a livello di elemento con la grandezza più grande nei tensori specificati.

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

Calcola il numero a livello di elemento con la grandezza più grande nei tensori specificati.

MaxNumber<T>(ReadOnlyTensorSpan<T>)

Cerca il numero più grande nel tensore specificato.

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

Calcola il valore massimo per elemento dei numeri nei tensori specificati.

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

Calcola il valore massimo per elemento dei numeri nei tensori specificati.

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

Calcola il valore massimo per elemento dei numeri nei tensori specificati.

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

Calcola il valore massimo per elemento dei numeri nei tensori specificati.

Min<T>(ReadOnlyTensorSpan<T>)

Cerca il numero più piccolo nel tensore specificato.

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

Calcola il minimo elemento dei numeri nei tensori specificati.

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

Calcola il minimo elemento dei numeri nei tensori specificati.

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

Calcola il minimo elemento dei numeri nei tensori specificati.

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

Calcola il minimo elemento dei numeri nei tensori specificati.

MinMagnitude<T>(ReadOnlyTensorSpan<T>)

Cerca il numero con la grandezza più piccola nel tensore specificato.

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

Calcola il numero a livello di elemento con la grandezza più piccola nei tensori specificati.

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

Calcola il numero a livello di elemento con la grandezza più piccola nei tensori specificati.

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

Calcola il numero a livello di elemento con la grandezza più piccola nei tensori specificati.

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

Calcola il numero a livello di elemento con la grandezza più piccola nei tensori specificati.

MinMagnitudeNumber<T>(ReadOnlyTensorSpan<T>)

Cerca il numero con la grandezza più piccola nel tensore specificato.

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

Calcola il numero a livello di elemento con la grandezza più piccola nei tensori specificati.

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

Calcola il numero a livello di elemento con la grandezza più piccola nei tensori specificati.

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

Calcola il numero a livello di elemento con la grandezza più piccola nei tensori specificati.

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

Calcola il numero a livello di elemento con la grandezza più piccola nei tensori specificati.

MinNumber<T>(ReadOnlyTensorSpan<T>)

Cerca il numero più piccolo nel tensore specificato.

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

Calcola il minimo elemento dei numeri nei tensori specificati.

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

Calcola il minimo elemento dei numeri nei tensori specificati.

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

Calcola il minimo elemento dei numeri nei tensori specificati.

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

Calcola il minimo elemento dei numeri nei tensori specificati.

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

Moltiplica ogni elemento di x con y e restituisce un nuovo Tensor<T> con il risultato. Se le forme non sono uguali, vengono trasmesse alla forma più piccola compatibile.

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

Moltiplica ogni elemento di x con y e restituisce un nuovo TensorSpan<T> con il risultato. Se le forme non sono uguali, vengono trasmesse alla forma più piccola compatibile.

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

Moltiplica ogni elemento di x con y e restituisce un nuovo Tensor<T> con il risultato.

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

Moltiplica ogni elemento di x con y e restituisce un nuovo TensorSpan<T> con il risultato.

Negate<T>(ReadOnlyTensorSpan<T>)

Calcola la negazione per elemento di ogni numero nel tensore specificato.

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

Calcola la negazione per elemento di ogni numero nel tensore specificato.

Norm<T>(ReadOnlyTensorSpan<T>)

Accetta la norma del ReadOnlyTensorSpan<T> e restituisce il risultato.

OnesComplement<T>(ReadOnlyTensorSpan<T>)

Calcola il complemento di un elemento di numeri nel tensore specificato.

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

Calcola il complemento di un elemento di numeri nel tensore specificato.

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

Scambia le dimensioni del tensore tensor in base al parametro dimensions. Se tensor è un tensore 1D, restituirà tensor. In caso contrario, crea un nuovo Tensor<T> con il nuovo ordinamento dell'asse allocando nuova memoria.

PopCount<T>(ReadOnlyTensorSpan<T>)

Calcola il numero di popolamenti per elemento dei numeri nel tensore specificato.

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

Calcola il numero di popolamenti per elemento dei numeri nel tensore specificato.

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

Calcola la potenza per elemento di un numero in un tensore specificato elevato a un numero in un altro tensore specificato.

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

Calcola la potenza per elemento di un numero in un tensore specificato elevato a un numero in un altro tensore specificato.

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

Calcola la potenza per elemento di un numero in un tensore specificato elevato a un numero in un altro tensore specificato.

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

Calcola la potenza per elemento di un numero in un tensore specificato elevato a un numero in un altro tensore specificato.

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

Calcola la potenza per elemento di un numero in un tensore specificato elevato a un numero in un altro tensore specificato.

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

Calcola la potenza per elemento di un numero in un tensore specificato elevato a un numero in un altro tensore specificato.

Product<T>(ReadOnlyTensorSpan<T>)

Calcola il prodotto di tutti gli elementi nel tensore non vuoto specificato di numeri.

RadiansToDegrees<T>(ReadOnlyTensorSpan<T>)

Calcola la conversione a livello di elemento di ogni numero di radianti nel tensore specificato in gradi.

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

Calcola la conversione a livello di elemento di ogni numero di radianti nel tensore specificato in gradi.

Reciprocal<T>(ReadOnlyTensorSpan<T>)

Calcola il reciproco elemento-saggio di numeri nel tensore specificato.

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

Calcola il reciproco elemento-saggio di numeri nel tensore specificato.

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

Modifica il tensore tensor al lengthsspecificato. Se una delle lunghezze è -1, verrà calcolata automaticamente. Non modifica la lunghezza della memoria sottostante né alloca nuova memoria. Se la nuova forma non è compatibile con la forma precedente, viene generata un'eccezione.

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

Modifica il tensore tensor al lengthsspecificato. Se una delle lunghezze è -1, verrà calcolata automaticamente. Non modifica la lunghezza della memoria sottostante né alloca nuova memoria. Se la nuova forma non è compatibile con la forma precedente, viene generata un'eccezione.

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

Modifica il tensore tensor al lengthsspecificato. Se una delle lunghezze è -1, verrà calcolata automaticamente. Non modifica la lunghezza della memoria sottostante né alloca nuova memoria. Se la nuova forma non è compatibile con la forma precedente, viene generata un'eccezione.

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

Crea un nuovo Tensor<T>, alloca nuova memoria e copia i dati da tensor. Se la forma finale è più piccola di tutti i dati dopo che tale punto viene ignorato.

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

Copia i dati da tensor. Se la forma finale è più piccola di tutti i dati dopo che tale punto viene ignorato. Se la forma finale è più grande, viene riempita con 0s.

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

Copia i dati da tensor. Se la forma finale è più piccola di tutti i dati dopo che tale punto viene ignorato. Se la forma finale è più grande, viene riempita con 0s.

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

Copia i dati da tensor. Se la forma finale è più piccola di tutti i dati dopo che tale punto viene ignorato. Se la forma finale è più grande, viene riempita con 0s.

Reverse<T>(ReadOnlyTensorSpan<T>)

Invertire l'ordine degli elementi nel tensor. La forma del tensore viene mantenuta, ma gli elementi vengono riordinati.

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

Invertire l'ordine degli elementi nel tensor. La forma del tensore viene mantenuta, ma gli elementi vengono riordinati.

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

Invertire l'ordine degli elementi nella tensor lungo la dimensione specificata. La forma del tensore viene mantenuta, ma gli elementi vengono riordinati. dimension per impostazione predefinita -1 quando non viene specificato, che inverte l'intero tensore.

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

Invertire l'ordine degli elementi nella tensor lungo l'asse specificato. La forma del tensore viene mantenuta, ma gli elementi vengono riordinati. dimension il valore predefinito è -1 se non specificato, che inverte l'intero intervallo.

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

Calcola la radice n-th dell'elemento dei valori nel tensore specificato.

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

Calcola la radice n-th dell'elemento dei valori nel tensore specificato.

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

Calcola la rotazione dell'elemento a sinistra dei numeri nel tensore specificato in base alla quantità di rotazione specificata.

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

Calcola la rotazione dell'elemento a sinistra dei numeri nel tensore specificato in base alla quantità di rotazione specificata.

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

Calcola la rotazione dell'elemento a destra dei numeri nel tensore specificato in base alla quantità di rotazione specificata.

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

Calcola la rotazione dell'elemento a destra dei numeri nel tensore specificato in base alla quantità di rotazione specificata.

Round<T>(ReadOnlyTensorSpan<T>)

Calcola l'arrotondamento a livello di elemento dei numeri nel tensore specificato

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

Calcola l'arrotondamento a livello di elemento dei numeri nel tensore specificato

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

Calcola l'arrotondamento a livello di elemento dei numeri nel tensore specificato

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

Calcola l'arrotondamento a livello di elemento dei numeri nel tensore specificato

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

Calcola l'arrotondamento a livello di elemento dei numeri nel tensore specificato

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

Calcola l'arrotondamento a livello di elemento dei numeri nel tensore specificato

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

Calcola l'arrotondamento a livello di elemento dei numeri nel tensore specificato

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

Calcola l'arrotondamento a livello di elemento dei numeri nel tensore specificato

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

Determina se due sequenze sono uguali confrontando gli elementi usando IEquatable{T}. Equals(T).

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

Determina se due sequenze sono uguali confrontando gli elementi usando IEquatable{T}. Equals(T).

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

Imposta una sezione del tensor specificato con il values specificato per il ranges specificato

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

Imposta una sezione del tensor specificato con il values specificato per il ranges specificato

Sigmoid<T>(ReadOnlyTensorSpan<T>)

Calcola la funzione sigmoid a livello di elemento sul tensore non vuoto specificato di numeri.

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

Calcola la funzione sigmoid a livello di elemento sul tensore non vuoto specificato di numeri.

Sin<T>(ReadOnlyTensorSpan<T>)

Accetta il peccato di ogni elemento del ReadOnlyTensorSpan<T> e restituisce un nuovo Tensor<T> con il risultato.

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

Accetta il peccato di ogni elemento del ReadOnlyTensorSpan<T> e restituisce un nuovo TensorSpan<T> con il risultato.

Sinh<T>(ReadOnlyTensorSpan<T>)

Calcola il seno iperbolico a livello di elemento di ogni angolo radiante nel tensore specificato.

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

Calcola il seno iperbolico a livello di elemento di ogni angolo radiante nel tensore specificato.

SinPi<T>(ReadOnlyTensorSpan<T>)

Calcola il seno a livello di elemento del valore nel tensore specificato moltiplicato per Pi.

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

Calcola il seno a livello di elemento del valore nel tensore specificato moltiplicato per Pi.

SoftMax<T>(ReadOnlyTensorSpan<T>)

Calcola la funzione softmax sul tensore non vuoto specificato di numeri.

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

Calcola la funzione softmax sul tensore non vuoto specificato di numeri.

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

Suddividere un Tensor<T> in splitCount lungo il dimensionspecificato. Se il tensore non può essere suddiviso uniformemente nel dimension viene generata un'eccezione.

Sqrt<T>(ReadOnlyTensorSpan<T>)

Accetta la radice quadrata di ogni elemento del ReadOnlyTensorSpan<T> e restituisce un nuovo Tensor<T> con il risultato.

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

Accetta la radice quadrata di ogni elemento del x e restituisce un nuovo TensorSpan<T> con il risultato.

Squeeze<T>(ReadOnlyTensorSpan<T>)

Rimuove tutte le dimensioni di lunghezza 1 dalla tensor.

Squeeze<T>(Tensor<T>)

Rimuove tutte le dimensioni di lunghezza 1 dalla tensor.

Squeeze<T>(TensorSpan<T>)

Rimuove tutte le dimensioni di lunghezza 1 dalla tensor.

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

Rimuove l'asse di lunghezza 1 dalla tensor per il dimensionspecificato. Se la dimensione non è di lunghezza 1, genererà un'eccezione.

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

Rimuove l'asse di lunghezza 1 dalla tensor per il dimensionspecificato. Se la dimensione non è di lunghezza 1, genererà un'eccezione.

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

Rimuove l'asse di lunghezza 1 dalla tensor per il dimensionspecificato. Se la dimensione non è di lunghezza 1, genererà un'eccezione.

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

Unire più Tensor<T> lungo una nuova dimensione aggiunta nella posizione 0. Tutti i tensori devono avere la stessa forma.

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

Unire più Tensor<T> lungo una nuova dimensione aggiunta nella posizione 0. Tutti i tensori devono avere la stessa forma.

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

Unire più Tensor<T> lungo una nuova dimensione. Il parametro dell'asse specifica l'indice della nuova dimensione. Tutti i tensori devono avere la stessa forma.

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

Unire più Tensor<T> lungo una nuova dimensione. Il parametro dell'asse specifica l'indice della nuova dimensione. Tutti i tensori devono avere la stessa forma.

StdDev<T>(ReadOnlyTensorSpan<T>)

Restituisce la deviazione standard degli elementi nel tensore x.

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

Sottrae ogni elemento di x da y e restituisce un nuovo Tensor<T> con il risultato.

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

Sottrae ogni elemento di x da y e restituisce un nuovo TensorSpan<T> con il risultato.

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

Sottrae y da ogni elemento di x e restituisce un nuovo Tensor<T> con il risultato.

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

Sottrae y da ogni elemento di x e restituisce un nuovo TensorSpan<T> con il risultato.

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

Sottrae ogni elemento di y da x e restituisce un nuovo Tensor<T> con il risultato.

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

Sottrae ogni elemento di y da x e restituisce un nuovo TensorSpan<T> con il risultato.

Sum<T>(ReadOnlyTensorSpan<T>)

Somma gli elementi del tensore specificato.

Tan<T>(ReadOnlyTensorSpan<T>)

Calcola la tangente a livello di elemento del valore nel tensore specificato.

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

Calcola la tangente a livello di elemento del valore nel tensore specificato.

Tanh<T>(ReadOnlyTensorSpan<T>)

Calcola la tangente iperbolica per elemento di ogni angolo radiante nel tensore specificato.

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

Calcola la tangente iperbolica per elemento di ogni angolo radiante nel tensore specificato.

TanPi<T>(ReadOnlyTensorSpan<T>)

Calcola la tangente a livello di elemento del valore nel tensore specificato moltiplicato per Pi.

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

Calcola la tangente a livello di elemento del valore nel tensore specificato moltiplicato per Pi.

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

Crea una rappresentazione String del ReadOnlyTensorSpan<T>". />

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

Crea una rappresentazione String del Tensor<T>". />

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

Crea una rappresentazione String del TensorSpan<T>". />

TrailingZeroCount<T>(ReadOnlyTensorSpan<T>)

Calcola il conteggio di numeri finali finali a livello di elemento nel tensore specificato.

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

Calcola il conteggio di numeri finali finali a livello di elemento nel tensore specificato.

Transpose<T>(Tensor<T>)

Scambia le ultime due dimensioni del tensore tensor.

Truncate<T>(ReadOnlyTensorSpan<T>)

Calcola il troncamento a livello di elemento dei numeri nel tensore specificato.

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

Calcola il troncamento a livello di elemento dei numeri nel tensore specificato.

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

Trasmettere i dati da tensor alla forma broadcastable più piccola compatibile con destination e archiviarla in destination Se le forme non sono compatibili, viene restituito false.

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

Trasmettere i dati da tensor alla forma broadcastable più piccola compatibile con destination e archiviarla in destination Se le forme non sono compatibili, viene restituito false.

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

Trasmettere i dati da tensor alla forma broadcastable più piccola compatibile con destination e archiviarla in destination Se le forme non sono compatibili, viene restituito false.

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

Inserire una nuova dimensione di lunghezza 1 che verrà visualizzata nella posizione della dimensione.

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

Inserire una nuova dimensione di lunghezza 1 che verrà visualizzata nella posizione della dimensione.

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

Inserire una nuova dimensione di lunghezza 1 che verrà visualizzata nella posizione della dimensione.

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

Calcola l'XOR a livello di elemento dei numeri nei tensori specificati.

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

Calcola l'XOR a livello di elemento dei numeri nei tensori specificati.

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

Calcola l'elemento Xor dei due ReadOnlyTensorSpan<T> di input e restituisce un nuovo Tensor<T> con il risultato.

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

Calcola l'elemento Xor dei due ReadOnlyTensorSpan<T> di input e restituisce un nuovo TensorSpan<T> con il risultato.

Si applica a