Språk

Tensor Klass

Definition

Namnområde:
System.Numerics.Tensors
Sammansättning:
System.Numerics.Tensors.dll
Paket:
System.Numerics.Tensors v11.0.0-rc.1.26425.128
Källa:
Tensor.cs
Källa:
TensorExtensions.cs
Källa:
Tensor.cs

Tillhandahåller metoder för tensor-åtgärder.

public ref class Tensor abstract sealed
public static class Tensor
type Tensor = class
Public Module Tensor
Arv
Object
Tensor

Metoder

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

Tar det absoluta värdet för varje element i ReadOnlyTensorSpan<T> och returnerar ett nytt TensorSpan<T> med resultatet.
Abs<T>(ReadOnlyTensorSpan<T>)

Tar det absoluta värdet för varje element i Tensor<T> och returnerar ett nytt Tensor<T> med resultatet.
Acos<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Tar invertera cosiné för varje element i Tensor<T> och returnerar en ny Tensor<T> med resultatet.
Acos<T>(ReadOnlyTensorSpan<T>)

Tar invertera cosiné för varje element i Tensor<T> och returnerar en ny Tensor<T> med resultatet.
Acosh<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Tar invertera hyperbolisk cosiné för varje element i TensorSpan<T> och returnerar en ny TensorSpan<T> med resultatet.
Acosh<T>(ReadOnlyTensorSpan<T>)

Tar invertera hyperbolisk cosiné för varje element i ReadOnlyTensorSpan<T> och returnerar en ny Tensor<T> med resultatet.
AcosPi<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Tar invertera hyperbolisk cosiné dividerat med pi för varje element i TensorSpan<T> och returnerar en ny TensorSpan<T> med resultatet.
AcosPi<T>(ReadOnlyTensorSpan<T>)

Tar invertera hyperbolisk cosiné dividerat med pi för varje element i Tensor<T> och returnerar en ny Tensor<T> med resultatet.
Add<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)

Utför elementmässigt tillägg mellan två tensorer.
Add<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

Utför elementmässigt tillägg mellan två tensorer.
Add<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<T>)

Utför elementmässigt tillägg mellan en tensor och skalär.
Add<T>(ReadOnlyTensorSpan<T>, T)

Utför elementmässigt tillägg mellan en tensor och skalär.
Asin<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Tar den omvända synden för varje element i ReadOnlyTensorSpan<T> och returnerar en ny TensorSpan<T> med resultatet.
Asin<T>(ReadOnlyTensorSpan<T>)

Tar den omvända synden för varje element i ReadOnlyTensorSpan<T> och returnerar en ny Tensor<T> med resultatet.
Asinh<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Tar invertera hyperbolisk sinus för varje element i ReadOnlyTensorSpan<T> och returnerar en ny TensorSpan<T> med resultatet.
Asinh<T>(ReadOnlyTensorSpan<T>)

Tar invertera hyperbolisk sinus för varje element i ReadOnlyTensorSpan<T> och returnerar en ny Tensor<T> med resultatet.
AsinPi<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Tar invertera hyperbolisk sinus dividerat med pi för varje element i ReadOnlyTensorSpan<T> och returnerar en ny TensorSpan<T> med resultatet.
AsinPi<T>(ReadOnlyTensorSpan<T>)

Tar invertera hyperbolisk sinus dividerat med pi för varje element i ReadOnlyTensorSpan<T> och returnerar en ny Tensor<T> med resultatet.
AsReadOnlyTensorSpan<T>(T[], Int32, ReadOnlySpan<IntPtr>, ReadOnlySpan<IntPtr>)

Skapar en ny tensor över den del av målmatrisen som börjar vid det angivna startindexet och använder de angivna längderna och stegen.
AsReadOnlyTensorSpan<T>(T[], ReadOnlySpan<IntPtr>, ReadOnlySpan<IntPtr>)

Skapar en ny tensor över den del av målmatrisen som börjar vid det angivna startindexet och använder de angivna längderna och stegen.
AsReadOnlyTensorSpan<T>(T[], ReadOnlySpan<IntPtr>)

Tilläggsmetod för att enklare skapa en TensorSpan från en matris.
AsReadOnlyTensorSpan<T>(T[])

Skapar en ny tensor över hela målmatrisen.
AsTensorSpan<T>(T[], Int32, ReadOnlySpan<IntPtr>, ReadOnlySpan<IntPtr>)

Skapar ett nytt spann över den del av målmatrisen som börjar vid "start"-indexet och slutar vid "slutindexet" (exklusivt).
AsTensorSpan<T>(T[], ReadOnlySpan<IntPtr>, ReadOnlySpan<IntPtr>)

Tillhandahåller metoder för tensor-åtgärder.
AsTensorSpan<T>(T[], ReadOnlySpan<IntPtr>)

Tilläggsmetod för att enklare skapa en TensorSpan från en matris.
AsTensorSpan<T>(T[])

Skapar ett nytt spann över hela målmatrisen.
Atan<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Tar arc-tangenten för varje element i ReadOnlyTensorSpan<T> och returnerar en ny TensorSpan<T> med resultatet.
Atan<T>(ReadOnlyTensorSpan<T>)

Tar arc-tangenten för varje element i ReadOnlyTensorSpan<T> och returnerar en ny Tensor<T> med resultatet.
Atan2<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)

Tar arc-tangenten för de två indata ReadOnlyTensorSpan<T> och returnerar en ny TensorSpan<T> med resultatet.
Atan2<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

Tar arc-tangenten för de två indata ReadOnlyTensorSpan<T> och returnerar en ny Tensor<T> med resultatet.
Atan2<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<T>)

Tar arc-tangenten för de två indata ReadOnlyTensorSpan<T> och returnerar en ny TensorSpan<T> med resultatet.
Atan2<T>(ReadOnlyTensorSpan<T>, T)

Tar arc-tangenten för de två indata ReadOnlyTensorSpan<T> och returnerar en ny Tensor<T> med resultatet.
Atan2<T>(T, ReadOnlyTensorSpan<T>, TensorSpan<T>)

Tar arc-tangenten för de två indata ReadOnlyTensorSpan<T> och returnerar en ny TensorSpan<T> med resultatet.
Atan2<T>(T, ReadOnlyTensorSpan<T>)

Tar arc-tangenten för de två indata ReadOnlyTensorSpan<T> och returnerar en ny Tensor<T> med resultatet.
Atan2Pi<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)

Tar arc-tangenten för de två indata ReadOnlyTensorSpan<T>, delar varje element med pi och returnerar en ny TensorSpan<T> med resultatet.
Atan2Pi<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

Tar arc-tangenten för de två indata ReadOnlyTensorSpan<T>, delar varje element med pi och returnerar en ny Tensor<T> med resultatet.
Atan2Pi<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<T>)

Tar arc-tangenten för de två indata ReadOnlyTensorSpan<T>, delar varje element med pi och returnerar en ny TensorSpan<T> med resultatet.
Atan2Pi<T>(ReadOnlyTensorSpan<T>, T)

Tar arc-tangenten för de två indata ReadOnlyTensorSpan<T>, delar varje element med pi och returnerar en ny TensorSpan<T> med resultatet.
Atan2Pi<T>(T, ReadOnlyTensorSpan<T>, TensorSpan<T>)

Tar arc-tangenten för de två indata ReadOnlyTensorSpan<T>, delar varje element med pi och returnerar en ny TensorSpan<T> med resultatet.
Atan2Pi<T>(T, ReadOnlyTensorSpan<T>)

Tar arc-tangenten för de två indata ReadOnlyTensorSpan<T>, delar varje element med pi och returnerar en ny TensorSpan<T> med resultatet.
Atanh<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Tar den invertera hyperboliska tangensen för varje element i ReadOnlyTensorSpan<T> och returnerar en ny TensorSpan<T> med resultatet.
Atanh<T>(ReadOnlyTensorSpan<T>)

Tar den invertera hyperboliska tangensen för varje element i ReadOnlyTensorSpan<T> och returnerar en ny Tensor<T> med resultatet.
AtanPi<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Tar den invertera hyperboliska tangenten dividerad med pi för varje element i ReadOnlyTensorSpan<T> och returnerar en ny TensorSpan<T> med resultatet.
AtanPi<T>(ReadOnlyTensorSpan<T>)

Tar den invertera hyperboliska tangenten dividerad med pi för varje element i ReadOnlyTensorSpan<T> och returnerar en ny Tensor<T> med resultatet.
Average<T>(ReadOnlyTensorSpan<T>)

Returnerar medelvärdet av elementen x i tensorn.
BitwiseAnd<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)

Utför bitvis och mellan två tensorer.
BitwiseAnd<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

Utför bitvis och mellan två tensorer.
BitwiseAnd<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<T>)

Utför bitvis och mellan en tensor och skalär.
BitwiseAnd<T>(ReadOnlyTensorSpan<T>, T)

Utför bitvis och mellan en tensor och skalär.
BitwiseOr<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)

Utför bitvis eller mellan två tensorer.
BitwiseOr<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

Utför bitvis eller mellan två tensorer.
BitwiseOr<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<T>)

Utför bitvis eller mellan en tensor och skalär.
BitwiseOr<T>(ReadOnlyTensorSpan<T>, T)

Utför bitvis eller mellan en tensor och skalär.
Broadcast<T>(ReadOnlyTensorSpan<T>, ReadOnlySpan<IntPtr>)

Skicka data från source till den nya formen lengths. Skapar en ny Tensor<T> och allokerar nytt minne. Om formen på source den inte är kompatibel med den nya formen utlöses ett undantag.
Broadcast<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

Skicka data från source till den minsta sändningsbara formen som är kompatibel med lengthsSource. Skapar en ny Tensor<T> och allokerar nytt minne.
BroadcastTo<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Skicka data från source till destination.
BroadcastTo<T>(Tensor<T>, TensorSpan<T>)

Skicka data från source till destination.
BroadcastTo<T>(TensorSpan<T>, TensorSpan<T>)

Skicka data från source till destination.
Cbrt<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Beräknar elementmässigt kubroten för indata ReadOnlyTensorSpan<T> och returnerar en ny TensorSpan<T> med resultatet.
Cbrt<T>(ReadOnlyTensorSpan<T>)

Beräknar elementmässigt kubroten för indata ReadOnlyTensorSpan<T> och returnerar en ny Tensor<T> med resultatet.
Ceiling<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Beräknar elementmässigt tak för indata ReadOnlyTensorSpan<T> och returnerar en ny TensorSpan<T> med resultatet.
Ceiling<T>(ReadOnlyTensorSpan<T>)

Beräknar elementmässigt tak för indata ReadOnlyTensorSpan<T> och returnerar en ny Tensor<T> med resultatet.
Concatenate<T>(ReadOnlySpan<Tensor<T>>, TensorSpan<T>)

Koppla en sekvens med tensorer längs en befintlig axel.
Concatenate<T>(ReadOnlySpan<Tensor<T>>)

Koppla en sekvens med tensorer längs en befintlig axel.
ConcatenateOnDimension<T>(Int32, ReadOnlySpan<Tensor<T>>, TensorSpan<T>)

Koppla en sekvens med tensorer längs en befintlig axel.
ConcatenateOnDimension<T>(Int32, ReadOnlySpan<Tensor<T>>)

Koppla en sekvens med tensorer längs en befintlig axel.
ConvertChecked<TFrom,TTo>(ReadOnlyTensorSpan<TFrom>, TensorSpan<TTo>)

Kopierar source till en ny TensorSpan<T> som konverterar varje TFrom värde till ett TTo värde.
ConvertChecked<TFrom,TTo>(ReadOnlyTensorSpan<TFrom>)

Kopierar source till en ny ReadOnlyTensorSpan<T> som konverterar varje TFrom värde till ett TTo värde.
ConvertSaturating<TFrom,TTo>(ReadOnlyTensorSpan<TFrom>, TensorSpan<TTo>)

Kopierar source till en ny TensorSpan<T> som konverterar varje TFrom värde till ett TTo värde.
ConvertSaturating<TFrom,TTo>(ReadOnlyTensorSpan<TFrom>)

Kopierar source till en ny ReadOnlyTensorSpan<T> som konverterar varje TFrom värde till ett TTo värde.
ConvertTruncating<TFrom,TTo>(ReadOnlyTensorSpan<TFrom>, TensorSpan<TTo>)

Kopierar source till en ny TensorSpan<T> som konverterar varje TFrom värde till ett TTo värde.
ConvertTruncating<TFrom,TTo>(ReadOnlyTensorSpan<TFrom>)

Kopierar source till en ny ReadOnlyTensorSpan<T> som konverterar varje TFrom värde till ett TTo värde.
CopySign<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)

Beräknar det elementmässigt resultatet av att kopiera tecknet från ett tal till ett annat tal i de angivna tensorerna och returnerar ett nytt TensorSpan<T> med resultatet.
CopySign<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

Beräknar det elementmässigt resultatet av att kopiera tecknet från ett tal till ett annat tal i de angivna tensorerna och returnerar ett nytt Tensor<T> med resultatet.
CopySign<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<T>)

Beräknar det elementmässigt resultatet av att kopiera tecknet från ett tal till ett annat tal i de angivna tensorerna och returnerar en ny tensor med resultatet.
CopySign<T>(ReadOnlyTensorSpan<T>, T)

Beräknar det elementmässigt resultatet av att kopiera tecknet från ett tal till ett annat tal i de angivna tensorerna och returnerar en ny tensor med resultatet.
Cos<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Tar cosininen för varje element i ReadOnlyTensorSpan<T> och returnerar en ny TensorSpan<T> med resultatet.
Cos<T>(ReadOnlyTensorSpan<T>)

Tar cosininen för varje element i ReadOnlyTensorSpan<T> och returnerar en ny Tensor<T> med resultatet.
Cosh<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Tar den hyperboliska cosinin för varje element i ReadOnlyTensorSpan<T> och returnerar en ny TensorSpan<T> med resultatet.
Cosh<T>(ReadOnlyTensorSpan<T>)

Tar den hyperboliska cosinin för varje element i ReadOnlyTensorSpan<T> och returnerar en ny Tensor<T> med resultatet.
CosineSimilarity<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

Compute cosinine likhet mellan x och y.
CosPi<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Beräknar elementmässigt cosiné för värdet i den angivna tensorn som har multiplicerats med Pi och returnerar en ny TensorSpan<T> med resultatet.
CosPi<T>(ReadOnlyTensorSpan<T>)

Beräknar elementmässigt cosiné för värdet i den angivna tensorn som har multiplicerats med Pi och returnerar en ny Tensor<T> med resultatet.
Create<T>(T[], Int32, ReadOnlySpan<IntPtr>, ReadOnlySpan<IntPtr>)

Skapar en ny tensor över den del av målmatrisen som börjar vid det angivna startindexet och använder de angivna längderna och stegen.
Create<T>(T[], ReadOnlySpan<IntPtr>, ReadOnlySpan<IntPtr>)

Skapar en ny tensor över den del av målmatrisen som börjar vid det angivna startindexet och använder de angivna längderna och stegen.
Create<T>(T[], ReadOnlySpan<IntPtr>)

Skapar en ny tensor över den del av målmatrisen som använder de angivna längderna.
Create<T>(T[])

Skapar en ny tensor över hela målmatrisen.
CreateFromShape<T>(ReadOnlySpan<IntPtr>, Boolean)

Skapar en ny tensor med angivna längder.
CreateFromShape<T>(ReadOnlySpan<IntPtr>, ReadOnlySpan<IntPtr>, Boolean)

Skapar en ny tensor med angivna längder och steg.
CreateFromShapeUninitialized<T>(ReadOnlySpan<IntPtr>, Boolean)

Skapar en ny tensor med angivna längder och steg.
CreateFromShapeUninitialized<T>(ReadOnlySpan<IntPtr>, ReadOnlySpan<IntPtr>, Boolean)

Skapar en ny tensor med angivna längder och steg. Om pinned är sant skapas den underliggande bufferten permanent fäst, annars fästs inte den underliggande bufferten. Den underliggande bufferten initieras inte.
Decrement<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Utför en minskning på en tensor.
Decrement<T>(ReadOnlyTensorSpan<T>)

Utför en minskning på en tensor.
DegreesToRadians<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Beräknar elementmässigt konvertering av varje antal grader i den angivna tensorn till radianer och returnerar en ny tensor med resultatet.
DegreesToRadians<T>(ReadOnlyTensorSpan<T>)

Beräknar elementmässigt konvertering av varje antal grader i den angivna tensorn till radianer och returnerar en ny tensor med resultatet.
Distance<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

Beräknar avståndet mellan två punkter, som anges som icke-tomma, lika långa tensorer med tal, i eukliderat utrymme.
Divide<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)

Utför elementmässigt uppdelning mellan två tensorer.
Divide<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

Utför elementmässigt uppdelning mellan två tensorer.
Divide<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<T>)

Utför elementmässigt uppdelning mellan en tensor och skalär.
Divide<T>(ReadOnlyTensorSpan<T>, T)

Utför elementmässigt uppdelning mellan en tensor och skalär.
Divide<T>(T, ReadOnlyTensorSpan<T>, TensorSpan<T>)

Utför elementmässigt uppdelning mellan en tensor och skalär.
Divide<T>(T, ReadOnlyTensorSpan<T>)

Utför elementmässigt uppdelning mellan en tensor och skalär.
Dot<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

Beräknar punktprodukten med två tensorer som innehåller tal.
Equals<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<Boolean>)

Jämför elementen i två ReadOnlyTensorSpan<T> för likhet. Om formerna inte är samma sänds tensorerna till den minsta sändningsbara storleken innan de jämförs. Den returnerar en TensorSpan<T> där värdet är sant om elementen är lika med och false om de inte är det." />
Equals<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

Jämför elementen i två ReadOnlyTensorSpan<T> för likhet. Om formerna inte är samma sänds tensorerna till den minsta sändningsbara storleken innan de jämförs. Den returnerar en TensorSpan<T> där värdet är sant om elementen är lika med och false om de inte är det." />
Equals<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<Boolean>)

Jämför elementen i två ReadOnlyTensorSpan<T> för likhet. Om formerna inte är samma sänds tensorerna till den minsta sändningsbara storleken innan de jämförs. Den returnerar en TensorSpan<T> där värdet är sant om elementen är lika med och false om de inte är det." />
Equals<T>(ReadOnlyTensorSpan<T>, T)

Jämför elementen i två ReadOnlyTensorSpan<T> för likhet. Om formerna inte är samma sänds tensorerna till den minsta sändningsbara storleken innan de jämförs. Den returnerar en TensorSpan<T> där värdet är sant om elementen är lika med och false om de inte är det." />
EqualsAll<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

Jämför elementen i två ReadOnlyTensorSpan<T> för att se om alla element x i är lika med y. Om formerna inte är samma sänds tensorerna till den minsta sändningsbara storleken innan de jämförs. Det returnerar ett Boolean värde där värdet är sant om alla element i x är eqaul till y.
EqualsAll<T>(ReadOnlyTensorSpan<T>, T)

Jämför elementen i två ReadOnlyTensorSpan<T> för att se om alla element x i är lika med y. Om formerna inte är samma sänds tensorerna till den minsta sändningsbara storleken innan de jämförs. Det returnerar ett Boolean värde där värdet är sant om alla element i x är eqaul till y.
EqualsAny<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

Jämför elementen i två ReadOnlyTensorSpan<T> för att se om några element i x är lika med y. Om formerna inte är samma sänds tensorerna till den minsta sändningsbara storleken innan de jämförs. Den returnerar ett Boolean värde där värdet är sant om några element i x är lika med y.
EqualsAny<T>(ReadOnlyTensorSpan<T>, T)

Jämför elementen i två ReadOnlyTensorSpan<T> för att se om några element i x är lika med y. Om formerna inte är samma sänds tensorerna till den minsta sändningsbara storleken innan de jämförs. Den returnerar ett Boolean värde där värdet är sant om några element i x är lika med y.
Exp<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Beräknar elementmässigt resultat av att höja e till flyttal med enkel precision i den angivna tensorn.
Exp<T>(ReadOnlyTensorSpan<T>)

Beräknar elementmässigt resultat av att höja e till flyttal med enkel precision i den angivna tensorn.
Exp10<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Beräknar elementmässigt resultat av att höja 10 till talkrafterna i den angivna tensorn.
Exp10<T>(ReadOnlyTensorSpan<T>)

Beräknar elementmässigt resultat av att höja 10 till talkrafterna i den angivna tensorn.
Exp10M1<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Beräknar det elementmässigt resultatet av att höja 10 till talkrafterna i den angivna tensorn, minus en.
Exp10M1<T>(ReadOnlyTensorSpan<T>)

Beräknar det elementmässigt resultatet av att höja 10 till talkrafterna i den angivna tensorn, minus en.
Exp2<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Beräknar elementmässigt resultat av att höja 2 till talkrafterna i den angivna tensorn.
Exp2<T>(ReadOnlyTensorSpan<T>)

Beräknar elementmässigt resultat av att höja 2 till talkrafterna i den angivna tensorn.
Exp2M1<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Beräknar elementmässigt resultat av att höja 2 till talkrafterna i angiven tensor, minus en.
Exp2M1<T>(ReadOnlyTensorSpan<T>)

Beräknar elementmässigt resultat av att höja 2 till talkrafterna i angiven tensor, minus en.
ExpM1<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Beräknar elementmässigt resultat av att höja e till talkrafterna i angiven tensor, minus 1.
ExpM1<T>(ReadOnlyTensorSpan<T>)

Beräknar elementmässigt resultat av att höja e till talkrafterna i angiven tensor, minus 1.
FillGaussianNormalDistribution<T>(TensorSpan<T>, Random)

Fyller det angivna TensorSpan<T> med slumpmässiga data i en gaussisk normal fördelning. Random kan eventuellt tillhandahållas för sådd.
FillUniformDistribution<T>(TensorSpan<T>, Random)

Fyller det angivna TensorSpan<T> med slumpmässiga data i en enhetlig fördelning. Random kan eventuellt tillhandahållas för sådd.
FilteredUpdate<T>(TensorSpan<T>, ReadOnlyTensorSpan<Boolean>, ReadOnlyTensorSpan<T>)

tensor Uppdaterar tensorn med där valuesfilter är sant. Om dimensioner inte är samma genereras ett undantag.
FilteredUpdate<T>(TensorSpan<T>, ReadOnlyTensorSpan<Boolean>, T)

tensor Uppdaterar tensorn med där valuefilter är sant.
Floor<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Beräknar den elementmässigt våning med tal i angiven tensor.
Floor<T>(ReadOnlyTensorSpan<T>)

Beräknar den elementmässigt våning med tal i angiven tensor.
GreaterThan<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<Boolean>)

Jämför elementen i två ReadOnlyTensorSpan<T> för att se vilka element i x som är större än y. Om formerna inte är samma sänds tensorerna till den minsta sändningsbara storleken innan de jämförs. Den returnerar ett Tensor<T> värde där värdet är sant om elementen i x är större än y och falska om de inte är det." />
GreaterThan<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

Jämför elementen i två ReadOnlyTensorSpan<T> för att se vilka element i x som är större än y. Om formerna inte är samma sänds tensorerna till den minsta sändningsbara storleken innan de jämförs. Den returnerar ett Tensor<T> värde där värdet är sant om elementen i x är större än y och falska om de inte är det." />
GreaterThan<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<Boolean>)

Jämför elementen i en ReadOnlyTensorSpan<T> för att se vilka element som är större än y. Den returnerar ett Tensor<T> värde där värdet är sant om elementen i x är större än y och falska om de inte är det." />
GreaterThan<T>(ReadOnlyTensorSpan<T>, T)

Jämför elementen i en ReadOnlyTensorSpan<T> för att se vilka element som är större än y. Den returnerar ett Tensor<T> värde där värdet är sant om elementen i x är större än y och falska om de inte är det." />
GreaterThan<T>(T, ReadOnlyTensorSpan<T>, TensorSpan<Boolean>)

x Jämför för att se vilka element som är större än y. Den returnerar ett Tensor<T> värde där värdet är sant om elementen i x är större än y och falska om de inte är det." />
GreaterThan<T>(T, ReadOnlyTensorSpan<T>)

x Jämför för att se vilka element som är större än y. Den returnerar ett Tensor<T> värde där värdet är sant om elementen i x är större än y och falska om de inte är det." />
GreaterThanAll<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

Jämför elementen i två ReadOnlyTensorSpan<T> för att se om alla element x i är större än y. Om formerna inte är samma sänds tensorerna till den minsta sändningsbara storleken innan de jämförs. Den returnerar ett Boolean värde där värdet är sant om alla element i x är större än y.
GreaterThanAll<T>(ReadOnlyTensorSpan<T>, T)

Jämför elementen i två ReadOnlyTensorSpan<T> för att se om alla element x i är större än y. Om formerna inte är samma sänds tensorerna till den minsta sändningsbara storleken innan de jämförs. Den returnerar ett Boolean värde där värdet är sant om alla element i x är större än y.
GreaterThanAll<T>(T, ReadOnlyTensorSpan<T>)

Jämför elementen i två ReadOnlyTensorSpan<T> för att se om alla element y i är större än y. Om formerna inte är samma sänds tensorerna till den minsta sändningsbara storleken innan de jämförs. Den returnerar ett Boolean värde där värdet är sant om alla element i y är större än y.
GreaterThanAny<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

Jämför elementen i två ReadOnlyTensorSpan<T> för att se om några element i x är större än y. Om formerna inte är samma sänds tensorerna till den minsta sändningsbara storleken innan de jämförs. Den returnerar ett Boolean värde där värdet är sant om några element i x är större än y.
GreaterThanAny<T>(ReadOnlyTensorSpan<T>, T)

Jämför elementen i två ReadOnlyTensorSpan<T> för att se om några element i x är större än y. Om formerna inte är samma sänds tensorerna till den minsta sändningsbara storleken innan de jämförs. Den returnerar ett Boolean värde där värdet är sant om några element i x är större än y.
GreaterThanAny<T>(T, ReadOnlyTensorSpan<T>)

Jämför elementen i två ReadOnlyTensorSpan<T> för att se om några element i y är större än x. Om formerna inte är samma sänds tensorerna till den minsta sändningsbara storleken innan de jämförs. Den returnerar ett Boolean värde där värdet är sant om några element i y är större än x.
GreaterThanOrEqual<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<Boolean>)

Jämför elementen i två ReadOnlyTensorSpan<T> för att se vilka element x som är större än eller lika med y. Om formerna inte är samma sänds tensorerna till den minsta sändningsbara storleken innan de jämförs. Den returnerar ett Tensor<T> värde där värdet är sant om elementen i x är större än y och falska om de inte är det." />
GreaterThanOrEqual<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

Jämför elementen i två ReadOnlyTensorSpan<T> för att se vilka element x som är större än eller lika med y. Om formerna inte är samma sänds tensorerna till den minsta sändningsbara storleken innan de jämförs. Den returnerar ett Tensor<T> värde där värdet är sant om elementen i x är större än y och falska om de inte är det." />
GreaterThanOrEqual<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<Boolean>)

Jämför elementen i en ReadOnlyTensorSpan<T> för att se vilka element som är större än eller lika med y. Den returnerar ett Tensor<T> värde där värdet är sant om elementen i x är större än y och falska om de inte är det." />
GreaterThanOrEqual<T>(ReadOnlyTensorSpan<T>, T)

Jämför elementen i en ReadOnlyTensorSpan<T> för att se vilka element som är större än eller lika med y. Den returnerar ett Tensor<T> värde där värdet är sant om elementen i x är större än y och falska om de inte är det." />
GreaterThanOrEqual<T>(T, ReadOnlyTensorSpan<T>, TensorSpan<Boolean>)

x Jämför för att se vilka element som är större än eller lika med y. Den returnerar ett Tensor<T> värde där värdet är sant om elementen i x är större än y och falska om de inte är det." />
GreaterThanOrEqual<T>(T, ReadOnlyTensorSpan<T>)

x Jämför för att se vilka element som är större än eller lika med y. Den returnerar ett Tensor<T> värde där värdet är sant om elementen i x är större än y och falska om de inte är det." />
GreaterThanOrEqualAll<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

Jämför elementen i två ReadOnlyTensorSpan<T> för att se om alla element x i är större än y. Om formerna inte är samma sänds tensorerna till den minsta sändningsbara storleken innan de jämförs. Den returnerar ett Boolean värde där värdet är sant om alla element i x är större än y.
GreaterThanOrEqualAll<T>(ReadOnlyTensorSpan<T>, T)

Jämför elementen i två ReadOnlyTensorSpan<T> för att se om alla element x i är större än y. Om formerna inte är samma sänds tensorerna till den minsta sändningsbara storleken innan de jämförs. Den returnerar ett Boolean värde där värdet är sant om alla element i x är större än y.
GreaterThanOrEqualAll<T>(T, ReadOnlyTensorSpan<T>)

Jämför elementen i två ReadOnlyTensorSpan<T> för att se om alla element y i är större än y. Om formerna inte är samma sänds tensorerna till den minsta sändningsbara storleken innan de jämförs. Den returnerar ett Boolean värde där värdet är sant om alla element i y är större än y.
GreaterThanOrEqualAny<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

Jämför elementen i två ReadOnlyTensorSpan<T> för att se om några element i x är större än y. Om formerna inte är samma sänds tensorerna till den minsta sändningsbara storleken innan de jämförs. Den returnerar ett Boolean värde där värdet är sant om några element i x är större än y.
GreaterThanOrEqualAny<T>(ReadOnlyTensorSpan<T>, T)

Jämför elementen i två ReadOnlyTensorSpan<T> för att se om några element i x är större än y. Om formerna inte är samma sänds tensorerna till den minsta sändningsbara storleken innan de jämförs. Den returnerar ett Boolean värde där värdet är sant om några element i x är större än y.
GreaterThanOrEqualAny<T>(T, ReadOnlyTensorSpan<T>)

Jämför elementen i två ReadOnlyTensorSpan<T> för att se om några element i y är större än x. Om formerna inte är samma sänds tensorerna till den minsta sändningsbara storleken innan de jämförs. Den returnerar ett Boolean värde där värdet är sant om några element i y är större än x.
Hypot<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)

Beräknar de elementvisa hypotenuse-angivna värdena från två tensorer som representerar längden på de kortare sidorna i en högervinklad triangel. Om formerna inte är samma sänds de till den minsta kompatibla formen.
Hypot<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

Beräknar de elementvisa hypotenuse-angivna värdena från två tensorer som representerar längden på de kortare sidorna i en högervinklad triangel. Om formerna inte är samma sänds de till den minsta kompatibla formen.
Ieee754Remainder<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)

Beräknar elementmässigt resten av talen i de angivna tensorerna.
Ieee754Remainder<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

Beräknar elementmässigt resten av talen i de angivna tensorerna.
Ieee754Remainder<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<T>)

Beräknar elementmässigt resten av talen i de angivna tensorerna.
Ieee754Remainder<T>(ReadOnlyTensorSpan<T>, T)

Beräknar elementmässigt resten av talen i de angivna tensorerna.
Ieee754Remainder<T>(T, ReadOnlyTensorSpan<T>, TensorSpan<T>)

Beräknar elementmässigt resten av talen i de angivna tensorerna.
Ieee754Remainder<T>(T, ReadOnlyTensorSpan<T>)

Beräknar elementmässigt resten av talen i de angivna tensorerna.
ILogB<T>(ReadOnlyTensorSpan<T>, TensorSpan<Int32>)

Beräknar elementmässigt heltalsloggaritm för tal i angiven tensor.
ILogB<T>(ReadOnlyTensorSpan<T>)

Beräknar elementmässigt heltalsloggaritm för tal i angiven tensor.
Increment<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Utför en ökning på en tensor.
Increment<T>(ReadOnlyTensorSpan<T>)

Utför en ökning på en tensor.
IndexOfMax<T>(ReadOnlyTensorSpan<T>)

Söker efter indexet för det största talet i den angivna tensorn.
IndexOfMaxMagnitude<T>(ReadOnlyTensorSpan<T>)

Söker efter indexet för talet med den största storleken i den angivna tensorn.
IndexOfMin<T>(ReadOnlyTensorSpan<T>)

Söker efter indexet för det minsta talet i den angivna tensorn.
IndexOfMinMagnitude<T>(ReadOnlyTensorSpan<T>)

Söker efter indexet för talet med den minsta storleken i den angivna tensorn.
LeadingZeroCount<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Beräknar det elementmässigt inledande nollantalet tal i den angivna tensorn.
LeadingZeroCount<T>(ReadOnlyTensorSpan<T>)

Beräknar det elementmässigt inledande nollantalet tal i den angivna tensorn.
LessThan<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<Boolean>)

Jämför elementen i två ReadOnlyTensorSpan<T> för att se vilka element x som är mindre än y. Om formerna inte är samma sänds tensorerna till den minsta sändningsbara storleken innan de jämförs. Den returnerar ett Tensor<T> värde där värdet är sant om elementen i x är mindre än y och falska om de inte är det." />
LessThan<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

Jämför elementen i två ReadOnlyTensorSpan<T> för att se vilka element x som är mindre än y. Om formerna inte är samma sänds tensorerna till den minsta sändningsbara storleken innan de jämförs. Den returnerar ett Tensor<T> värde där värdet är sant om elementen i x är mindre än y och falska om de inte är det." />
LessThan<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<Boolean>)

Jämför elementen i en Tensor<T> för att se vilka element som är mindre än y. Den returnerar ett Tensor<T> värde där värdet är sant om elementen i x är mindre än y och falska om de inte är det." />
LessThan<T>(ReadOnlyTensorSpan<T>, T)

Jämför elementen i en Tensor<T> för att se vilka element som är mindre än y. Den returnerar ett Tensor<T> värde där värdet är sant om elementen i x är mindre än y och falska om de inte är det." />
LessThan<T>(T, ReadOnlyTensorSpan<T>, TensorSpan<Boolean>)

Jämför elementen i en Tensor<T> för att se vilka element som är mindre än y. Den returnerar ett Tensor<T> värde där värdet är sant om elementen i x är mindre än y och falska om de inte är det." />
LessThan<T>(T, ReadOnlyTensorSpan<T>)

Jämför elementen i en Tensor<T> för att se vilka element som är mindre än y. Den returnerar ett Tensor<T> värde där värdet är sant om elementen i x är mindre än y och falska om de inte är det." />
LessThanAll<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

Jämför elementen i två ReadOnlyTensorSpan<T> för att se om alla element x i är mindre än y. Om formerna inte är samma sänds tensorerna till den minsta sändningsbara storleken innan de jämförs. Den returnerar ett Boolean värde där värdet är sant om alla element i x är mindre än y.
LessThanAll<T>(ReadOnlyTensorSpan<T>, T)

Jämför elementen i två ReadOnlyTensorSpan<T> för att se om alla element x i är mindre än y. Om formerna inte är samma sänds tensorerna till den minsta sändningsbara storleken innan de jämförs. Den returnerar ett Boolean värde där värdet är sant om alla element i x är mindre än y.
LessThanAll<T>(T, ReadOnlyTensorSpan<T>)

Jämför elementen i två ReadOnlyTensorSpan<T> för att se om alla element y i är mindre än x. Om formerna inte är samma sänds tensorerna till den minsta sändningsbara storleken innan de jämförs. Den returnerar ett Boolean värde där värdet är sant om alla element i y är mindre än x.
LessThanAny<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

Jämför elementen i två ReadOnlyTensorSpan<T> för att se om några element i x är mindre än y. Om formerna inte är samma sänds tensorerna till den minsta sändningsbara storleken innan de jämförs. Den returnerar ett Boolean värde där värdet är sant om några element i x är mindre än y.
LessThanAny<T>(ReadOnlyTensorSpan<T>, T)

Jämför elementen i två ReadOnlyTensorSpan<T> för att se om några element i x är mindre än y. Om formerna inte är samma sänds tensorerna till den minsta sändningsbara storleken innan de jämförs. Den returnerar ett Boolean värde där värdet är sant om några element i x är mindre än y.
LessThanAny<T>(T, ReadOnlyTensorSpan<T>)

Jämför elementen i två ReadOnlyTensorSpan<T> för att se om några element i y är mindre än y. Om formerna inte är samma sänds tensorerna till den minsta sändningsbara storleken innan de jämförs. Den returnerar ett Boolean värde där värdet är sant om några element i y är mindre än y.
LessThanOrEqual<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<Boolean>)

Jämför elementen i två ReadOnlyTensorSpan<T> för att se vilka element x som är mindre än y. Om formerna inte är samma sänds tensorerna till den minsta sändningsbara storleken innan de jämförs. Den returnerar ett Tensor<T> värde där värdet är sant om elementen i x är mindre än y och falska om de inte är det." />
LessThanOrEqual<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

Jämför elementen i två ReadOnlyTensorSpan<T> för att se vilka element x som är mindre än y. Om formerna inte är samma sänds tensorerna till den minsta sändningsbara storleken innan de jämförs. Den returnerar ett Tensor<T> värde där värdet är sant om elementen i x är mindre än y och falska om de inte är det." />
LessThanOrEqual<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<Boolean>)

Jämför elementen i en Tensor<T> för att se vilka element som är mindre än y. Den returnerar ett Tensor<T> värde där värdet är sant om elementen i x är mindre än y och falska om de inte är det." />
LessThanOrEqual<T>(ReadOnlyTensorSpan<T>, T)

Jämför elementen i en Tensor<T> för att se vilka element som är mindre än y. Den returnerar ett Tensor<T> värde där värdet är sant om elementen i x är mindre än y och falska om de inte är det." />
LessThanOrEqual<T>(T, ReadOnlyTensorSpan<T>, TensorSpan<Boolean>)

Jämför elementen i en Tensor<T> för att se vilka element som är mindre än y. Den returnerar ett Tensor<T> värde där värdet är sant om elementen i x är mindre än y och falska om de inte är det." />
LessThanOrEqual<T>(T, ReadOnlyTensorSpan<T>)

Jämför elementen i en Tensor<T> för att se vilka element som är mindre än y. Den returnerar ett Tensor<T> värde där värdet är sant om elementen i x är mindre än y och falska om de inte är det." />
LessThanOrEqualAll<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

Jämför elementen i två ReadOnlyTensorSpan<T> för att se om alla element x i är mindre än y. Om formerna inte är samma sänds tensorerna till den minsta sändningsbara storleken innan de jämförs. Den returnerar ett Boolean värde där värdet är sant om alla element i x är mindre än y.
LessThanOrEqualAll<T>(ReadOnlyTensorSpan<T>, T)

Jämför elementen i två ReadOnlyTensorSpan<T> för att se om alla element x i är mindre än y. Om formerna inte är samma sänds tensorerna till den minsta sändningsbara storleken innan de jämförs. Den returnerar ett Boolean värde där värdet är sant om alla element i x är mindre än y.
LessThanOrEqualAll<T>(T, ReadOnlyTensorSpan<T>)

Jämför elementen i två ReadOnlyTensorSpan<T> för att se om alla element y i är mindre än x. Om formerna inte är samma sänds tensorerna till den minsta sändningsbara storleken innan de jämförs. Den returnerar ett Boolean värde där värdet är sant om alla element i y är mindre än x.
LessThanOrEqualAny<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

Jämför elementen i två ReadOnlyTensorSpan<T> för att se om några element i x är mindre än y. Om formerna inte är samma sänds tensorerna till den minsta sändningsbara storleken innan de jämförs. Den returnerar ett Boolean värde där värdet är sant om några element i x är mindre än y.
LessThanOrEqualAny<T>(ReadOnlyTensorSpan<T>, T)

Jämför elementen i två ReadOnlyTensorSpan<T> för att se om några element i x är mindre än y. Om formerna inte är samma sänds tensorerna till den minsta sändningsbara storleken innan de jämförs. Den returnerar ett Boolean värde där värdet är sant om några element i x är mindre än y.
LessThanOrEqualAny<T>(T, ReadOnlyTensorSpan<T>)

Jämför elementen i två ReadOnlyTensorSpan<T> för att se om några element i y är mindre än y. Om formerna inte är samma sänds tensorerna till den minsta sändningsbara storleken innan de jämförs. Den returnerar ett Boolean värde där värdet är sant om några element i y är mindre än y.
Log<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)

Beräknar elementmässigt logaritm för talen i en angiven tensor till den angivna basen i en annan angiven tensor.
Log<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

Beräknar elementmässigt logaritm för talen i en angiven tensor till den angivna basen i en annan angiven tensor.
Log<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<T>)

Beräknar elementmässigt logaritm för talen i en angiven tensor till den angivna basen i en annan angiven tensor.
Log<T>(ReadOnlyTensorSpan<T>, T)

Beräknar elementmässigt logaritm för talen i en angiven tensor till den angivna basen i en annan angiven tensor.
Log<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Tar den naturliga logaritmen för varje element i ReadOnlyTensorSpan<T> och returnerar en ny TensorSpan<T> med resultatet.
Log<T>(ReadOnlyTensorSpan<T>)

Tar den naturliga logaritmen för varje element i ReadOnlyTensorSpan<T> och returnerar en ny Tensor<T> med resultatet.
Log10<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Tar bas 10 logaritm för varje element i ReadOnlyTensorSpan<T> och returnerar en ny TensorSpan<T> med resultatet.
Log10<T>(ReadOnlyTensorSpan<T>)

Tar bas 10 logaritm för varje element i ReadOnlyTensorSpan<T> och returnerar en ny Tensor<T> med resultatet.
Log10P1<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Tar bas 10 logaritm plus 1 av varje element i ReadOnlyTensorSpan<T> och returnerar en ny TensorSpan<T> med resultatet.
Log10P1<T>(ReadOnlyTensorSpan<T>)

Tar bas 10 logaritm plus 1 av varje element i ReadOnlyTensorSpan<T> och returnerar en ny Tensor<T> med resultatet.
Log2<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Tar bas 2-logaritmen för varje element i ReadOnlyTensorSpan<T> och returnerar en ny TensorSpan<T> med resultatet.
Log2<T>(ReadOnlyTensorSpan<T>)

Tar bas 2-logaritmen för varje element i ReadOnlyTensorSpan<T> och returnerar en ny Tensor<T> med resultatet.
Log2P1<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Tar bas 2 logaritm plus 1 av varje element i ReadOnlyTensorSpan<T> och returnerar en ny TensorSpan<T> med resultatet.
Log2P1<T>(ReadOnlyTensorSpan<T>)

Tar bas 2 logaritm plus 1 av varje element i ReadOnlyTensorSpan<T> och returnerar en ny Tensor<T> med resultatet.
LogP1<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Tar den naturliga logaritmen plus 1 av varje element i ReadOnlyTensorSpan<T> och returnerar en ny TensorSpan<T> med resultatet.
LogP1<T>(ReadOnlyTensorSpan<T>)

Tar den naturliga logaritmen plus 1 av varje element i ReadOnlyTensorSpan<T> och returnerar en ny Tensor<T> med resultatet.
Max<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)

Beräknar det elementvisa maxvärdet för talen i de angivna tensorerna.
Max<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

Beräknar det elementvisa maxvärdet för talen i de angivna tensorerna.
Max<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<T>)

Beräknar det elementvisa maxvärdet för talen i de angivna tensorerna.
Max<T>(ReadOnlyTensorSpan<T>, T)

Beräknar det elementvisa maxvärdet för talen i de angivna tensorerna.
Max<T>(ReadOnlyTensorSpan<T>)

Söker efter det största talet i den angivna tensorn.
MaxMagnitude<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)

Beräknar elementmässigt tal med den största magnituden i de angivna tensorerna.
MaxMagnitude<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

Beräknar elementmässigt tal med den största magnituden i de angivna tensorerna.
MaxMagnitude<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<T>)

Beräknar elementmässigt tal med den största magnituden i de angivna tensorerna.
MaxMagnitude<T>(ReadOnlyTensorSpan<T>, T)

Beräknar elementmässigt tal med den största magnituden i de angivna tensorerna.
MaxMagnitude<T>(ReadOnlyTensorSpan<T>)

Söker efter talet med den största storleken i den angivna tensorn.
MaxMagnitudeNumber<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)

Beräknar elementmässigt tal med den största magnituden i de angivna tensorerna.
MaxMagnitudeNumber<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

Beräknar elementmässigt tal med den största magnituden i de angivna tensorerna.
MaxMagnitudeNumber<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<T>)

Beräknar elementmässigt tal med den största magnituden i de angivna tensorerna.
MaxMagnitudeNumber<T>(ReadOnlyTensorSpan<T>, T)

Beräknar elementmässigt tal med den största magnituden i de angivna tensorerna.
MaxMagnitudeNumber<T>(ReadOnlyTensorSpan<T>)

Söker efter talet med den största storleken i den angivna tensorn.
MaxNumber<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)

Beräknar det elementvisa maxvärdet för talen i de angivna tensorerna.
MaxNumber<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

Beräknar det elementvisa maxvärdet för talen i de angivna tensorerna.
MaxNumber<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<T>)

Beräknar det elementvisa maxvärdet för talen i de angivna tensorerna.
MaxNumber<T>(ReadOnlyTensorSpan<T>, T)

Beräknar det elementvisa maxvärdet för talen i de angivna tensorerna.
MaxNumber<T>(ReadOnlyTensorSpan<T>)

Söker efter det största talet i den angivna tensorn.
Min<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)

Beräknar elementmässigt minimum av talen i de angivna tensorerna.
Min<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

Beräknar elementmässigt minimum av talen i de angivna tensorerna.
Min<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<T>)

Beräknar elementmässigt minimum av talen i de angivna tensorerna.
Min<T>(ReadOnlyTensorSpan<T>, T)

Beräknar elementmässigt minimum av talen i de angivna tensorerna.
Min<T>(ReadOnlyTensorSpan<T>)

Söker efter det minsta talet i den angivna tensorn.
MinMagnitude<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)

Beräknar elementmässigt tal med den minsta storleken i de angivna tensorerna.
MinMagnitude<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

Beräknar elementmässigt tal med den minsta storleken i de angivna tensorerna.
MinMagnitude<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<T>)

Beräknar elementmässigt tal med den minsta storleken i de angivna tensorerna.
MinMagnitude<T>(ReadOnlyTensorSpan<T>, T)

Beräknar elementmässigt tal med den minsta storleken i de angivna tensorerna.
MinMagnitude<T>(ReadOnlyTensorSpan<T>)

Söker efter talet med den minsta magnituden i den angivna tensorn.
MinMagnitudeNumber<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)

Beräknar elementmässigt tal med den minsta storleken i de angivna tensorerna.
MinMagnitudeNumber<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

Beräknar elementmässigt tal med den minsta storleken i de angivna tensorerna.
MinMagnitudeNumber<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<T>)

Beräknar elementmässigt tal med den minsta storleken i de angivna tensorerna.
MinMagnitudeNumber<T>(ReadOnlyTensorSpan<T>, T)

Beräknar elementmässigt tal med den minsta storleken i de angivna tensorerna.
MinMagnitudeNumber<T>(ReadOnlyTensorSpan<T>)

Söker efter talet med den minsta magnituden i den angivna tensorn.
MinNumber<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)

Beräknar elementmässigt minimum av talen i de angivna tensorerna.
MinNumber<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

Beräknar elementmässigt minimum av talen i de angivna tensorerna.
MinNumber<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<T>)

Beräknar elementmässigt minimum av talen i de angivna tensorerna.
MinNumber<T>(ReadOnlyTensorSpan<T>, T)

Beräknar elementmässigt minimum av talen i de angivna tensorerna.
MinNumber<T>(ReadOnlyTensorSpan<T>)

Söker efter det minsta talet i den angivna tensorn.
Multiply<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)

Utför elementmässigt multiplikation mellan två tensorer.
Multiply<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

Utför elementmässigt multiplikation mellan två tensorer.
Multiply<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<T>)

Utför elementmässigt multiplikation mellan en tensor och skalär.
Multiply<T>(ReadOnlyTensorSpan<T>, T)

Utför elementmässigt multiplikation mellan en tensor och skalär.
Negate<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Utför elementmässigt unary negation på en tensor.
Negate<T>(ReadOnlyTensorSpan<T>)

Utför elementmässigt unary negation på en tensor.
Norm<T>(ReadOnlyTensorSpan<T>)

Tar normen för ReadOnlyTensorSpan<T> och returnerar resultatet.
OnesComplement<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Utför ett komplement på en tensor.
OnesComplement<T>(ReadOnlyTensorSpan<T>)

Utför ett komplement på en tensor.
PermuteDimensions<T>(Tensor<T>, ReadOnlySpan<Int32>)

Växlar tensorns dimensioner tensor enligt parametern dimensions . Om tensor är en 1D-tensor returnerar tensorden . Annars skapas en ny Tensor<T> med den nya axelordningen genom att nytt minne allokeras.
PopCount<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Beräknar elementmässigt antal populationer i den angivna tensorn.
PopCount<T>(ReadOnlyTensorSpan<T>)

Beräknar elementmässigt antal populationer i den angivna tensorn.
Pow<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)

Beräknar elementmässigt för ett tal i en angiven tensor som höjs till ett tal i en annan angiven tensor.
Pow<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

Beräknar elementmässigt för ett tal i en angiven tensor som höjs till ett tal i en annan angiven tensor.
Pow<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<T>)

Beräknar elementmässigt för ett tal i en angiven tensor som höjs till ett tal i en annan angiven tensor.
Pow<T>(ReadOnlyTensorSpan<T>, T)

Beräknar elementmässigt för ett tal i en angiven tensor som höjs till ett tal i en annan angiven tensor.
Pow<T>(T, ReadOnlyTensorSpan<T>, TensorSpan<T>)

Beräknar elementmässigt för ett tal i en angiven tensor som höjs till ett tal i en annan angiven tensor.
Pow<T>(T, ReadOnlyTensorSpan<T>)

Beräknar elementmässigt för ett tal i en angiven tensor som höjs till ett tal i en annan angiven tensor.
Product<T>(ReadOnlyTensorSpan<T>)

Beräknar produkten av alla element i det angivna icke-tomma talet.
RadiansToDegrees<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Beräknar elementmässigt konvertering av varje antal radianer i angiven tensor till grader.
RadiansToDegrees<T>(ReadOnlyTensorSpan<T>)

Beräknar elementmässigt konvertering av varje antal radianer i angiven tensor till grader.
Reciprocal<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Beräknar elementmässigt reciprocal av tal i den angivna tensorn.
Reciprocal<T>(ReadOnlyTensorSpan<T>)

Beräknar elementmässigt reciprocal av tal i den angivna tensorn.
Reshape<T>(ReadOnlyTensorSpan<T>, ReadOnlySpan<IntPtr>)

Omformar tensor tensorn till den angivna lengths. Om en av längderna är -1 beräknas den automatiskt. Ändrar inte längden på det underliggande minnet och allokerar inte heller nytt minne. Om den nya formen inte är kompatibel med den gamla formen utlöses ett undantag.
Reshape<T>(Tensor<T>, ReadOnlySpan<IntPtr>)

Omformar tensor tensorn till den angivna lengths. Om en av längderna är -1 beräknas den automatiskt. Ändrar inte längden på det underliggande minnet och allokerar inte heller nytt minne. Om den nya formen inte är kompatibel med den gamla formen utlöses ett undantag.
Reshape<T>(TensorSpan<T>, ReadOnlySpan<IntPtr>)

Omformar tensor tensorn till den angivna lengths. Om en av längderna är -1 beräknas den automatiskt. Ändrar inte längden på det underliggande minnet och allokerar inte heller nytt minne. Om den nya formen inte är kompatibel med den gamla formen utlöses ett undantag.
Resize<T>(Tensor<T>, ReadOnlySpan<IntPtr>)

Skapar en ny Tensor<T>, allokerar nytt minne och kopierar data från tensor. Om den slutliga formen är mindre ignoreras alla data efter den punkten.
ResizeTo<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Kopierar data från tensor. Om den slutliga formen är mindre ignoreras alla data efter den punkten. Om den slutliga formen är större fylls den med 0s.
ResizeTo<T>(Tensor<T>, TensorSpan<T>)

Kopierar data från tensor. Om den slutliga formen är mindre ignoreras alla data efter den punkten. Om den slutliga formen är större fylls den med 0s.
ResizeTo<T>(TensorSpan<T>, TensorSpan<T>)

Kopierar data från tensor. Om den slutliga formen är mindre ignoreras alla data efter den punkten. Om den slutliga formen är större fylls den med 0s.
Reverse<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Ändra ordningen på elementen tensori . Tensorns form bevaras, men elementen sorteras om.
Reverse<T>(ReadOnlyTensorSpan<T>)

Ändra ordningen på elementen tensori . Tensorns form bevaras, men elementen sorteras om.
ReverseDimension<T>(ReadOnlyTensorSpan<T>, Int32)

Ändra ordningen på elementen längs den tensor angivna dimensionen. Tensorns form bevaras, men elementen sorteras om. dimension standardvärdet för att -1 när det inte anges, vilket vänder hela tensorn.
ReverseDimension<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>, Int32)

Ändra ordningen på elementen längs den tensor angivna axeln. Tensorns form bevaras, men elementen sorteras om. dimension standardvärdet är -1 när det inte anges, vilket upphäver hela intervallet.
RootN<T>(ReadOnlyTensorSpan<T>, Int32, TensorSpan<T>)

Beräknar elementmässigt n-th-roten för värdena i den angivna tensorn.
RootN<T>(ReadOnlyTensorSpan<T>, Int32)

Beräknar elementmässigt n-th-roten för värdena i den angivna tensorn.
RotateLeft<T>(ReadOnlyTensorSpan<T>, Int32, TensorSpan<T>)

Beräknar den elementbaserade rotationen till vänster om tal i angiven tensor med den angivna rotationsmängden.
RotateLeft<T>(ReadOnlyTensorSpan<T>, Int32)

Beräknar den elementbaserade rotationen till vänster om tal i angiven tensor med den angivna rotationsmängden.
RotateRight<T>(ReadOnlyTensorSpan<T>, Int32, TensorSpan<T>)

Beräknar elementmässigt rotationsrätt för tal i angiven tensor med den angivna rotationsmängden.
RotateRight<T>(ReadOnlyTensorSpan<T>, Int32)

Beräknar elementmässigt rotationsrätt för tal i angiven tensor med den angivna rotationsmängden.
Round<T>(ReadOnlyTensorSpan<T>, Int32, MidpointRounding, TensorSpan<T>)

Beräknar elementmässigt avrundning av talen i angiven tensor
Round<T>(ReadOnlyTensorSpan<T>, Int32, MidpointRounding)

Beräknar elementmässigt avrundning av talen i angiven tensor
Round<T>(ReadOnlyTensorSpan<T>, Int32, TensorSpan<T>)

Beräknar elementmässigt avrundning av talen i angiven tensor
Round<T>(ReadOnlyTensorSpan<T>, Int32)

Beräknar elementmässigt avrundning av talen i angiven tensor
Round<T>(ReadOnlyTensorSpan<T>, MidpointRounding, TensorSpan<T>)

Beräknar elementmässigt avrundning av talen i angiven tensor
Round<T>(ReadOnlyTensorSpan<T>, MidpointRounding)

Beräknar elementmässigt avrundning av talen i angiven tensor
Round<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Beräknar elementmässigt avrundning av talen i angiven tensor
Round<T>(ReadOnlyTensorSpan<T>)

Beräknar elementmässigt avrundning av talen i angiven tensor
SequenceEqual<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

Avgör om två sekvenser är lika med genom att jämföra elementen med IEquatable{T}. Lika med(T).
SequenceEqual<T>(TensorSpan<T>, ReadOnlyTensorSpan<T>)

Avgör om två sekvenser är lika med genom att jämföra elementen med IEquatable{T}. Lika med(T).
SetSlice<T>(Tensor<T>, ReadOnlyTensorSpan<T>, ReadOnlySpan<NRange>)

Anger en del av angiven tensor med angiven values för den angivna ranges
SetSlice<T>(TensorSpan<T>, ReadOnlyTensorSpan<T>, ReadOnlySpan<NRange>)

Anger en del av angiven tensor med angiven values för den angivna ranges
ShiftLeft<T>(ReadOnlyTensorSpan<T>, Int32, TensorSpan<T>)

Utför ett elementmässigt vänsterskift på en tensor.
ShiftLeft<T>(ReadOnlyTensorSpan<T>, Int32)

Utför ett elementmässigt vänsterskift på en tensor.
ShiftRightArithmetic<T>(ReadOnlyTensorSpan<T>, Int32, TensorSpan<T>)

Utför ett elementmässigt aritmetiskt högerskift på en tensor.
ShiftRightArithmetic<T>(ReadOnlyTensorSpan<T>, Int32)

Utför ett elementmässigt aritmetiskt högerskift på en tensor.
ShiftRightLogical<T>(ReadOnlyTensorSpan<T>, Int32, TensorSpan<T>)

Utför ett elementmässigt logiskt högerskifte på en tensor.
ShiftRightLogical<T>(ReadOnlyTensorSpan<T>, Int32)

Utför ett elementmässigt logiskt högerskifte på en tensor.
Sigmoid<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Beräknar funktionen elementmässigt sigmoid på den angivna icke-tomma tensorn med tal.
Sigmoid<T>(ReadOnlyTensorSpan<T>)

Beräknar funktionen elementmässigt sigmoid på den angivna icke-tomma tensorn med tal.
Sin<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Tar synden för varje element i ReadOnlyTensorSpan<T> och returnerar en ny TensorSpan<T> med resultatet.
Sin<T>(ReadOnlyTensorSpan<T>)

Tar synden för varje element i ReadOnlyTensorSpan<T> och returnerar en ny Tensor<T> med resultatet.
Sinh<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Beräknar elementmässigt hyperbolisk sinus för varje radianvinkel i angiven tensor.
Sinh<T>(ReadOnlyTensorSpan<T>)

Beräknar elementmässigt hyperbolisk sinus för varje radianvinkel i angiven tensor.
SinPi<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Beräknar elementmässigt sinus för värdet i den angivna tensorn som har multiplicerats med Pi.
SinPi<T>(ReadOnlyTensorSpan<T>)

Beräknar elementmässigt sinus för värdet i den angivna tensorn som har multiplicerats med Pi.
SoftMax<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Beräknar funktionen softmax över det angivna icke-tomma talet.
SoftMax<T>(ReadOnlyTensorSpan<T>)

Beräknar funktionen softmax över det angivna icke-tomma talet.
Split<T>(ReadOnlyTensorSpan<T>, Int32, IntPtr)

Dela upp en Tensor<T> i splitCount längs den angivna dimension. Om tensorn inte kan delas jämnt på det angivna dimension undantaget genereras.
Sqrt<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Tar kvadratroten för varje element i x och returnerar en ny TensorSpan<T> med resultatet.
Sqrt<T>(ReadOnlyTensorSpan<T>)

Tar kvadratroten för varje element i ReadOnlyTensorSpan<T> och returnerar en ny Tensor<T> med resultatet.
Squeeze<T>(ReadOnlyTensorSpan<T>)

Tar bort alla mått på längden en från tensor.
Squeeze<T>(Tensor<T>)

Tar bort alla mått på längden en från tensor.
Squeeze<T>(TensorSpan<T>)

Tar bort alla mått på längden en från tensor.
SqueezeDimension<T>(ReadOnlyTensorSpan<T>, Int32)

Tar bort en axel med en längd från tensor för den angivna dimension. Om dimensionen inte är lång utlöser den ett undantag.
SqueezeDimension<T>(Tensor<T>, Int32)

Tar bort en axel med en längd från tensor för den angivna dimension. Om dimensionen inte är lång utlöser den ett undantag.
SqueezeDimension<T>(TensorSpan<T>, Int32)

Tar bort en axel med en längd från tensor för den angivna dimension. Om dimensionen inte är lång utlöser den ett undantag.
Stack<T>(ReadOnlySpan<Tensor<T>>, TensorSpan<T>)

Koppla flera Tensor<T> längs en ny dimension som läggs till vid position 0. Alla tensorer måste ha samma form.
Stack<T>(ReadOnlySpan<Tensor<T>>)

Koppla flera Tensor<T> längs en ny dimension som läggs till vid position 0. Alla tensorer måste ha samma form.
StackAlongDimension<T>(Int32, ReadOnlySpan<Tensor<T>>)

Koppla flera Tensor<T> längs en ny dimension. Axelparametern anger indexet för den nya dimensionen. Alla tensorer måste ha samma form.
StackAlongDimension<T>(ReadOnlySpan<Tensor<T>>, TensorSpan<T>, Int32)

Koppla flera Tensor<T> längs en ny dimension. Axelparametern anger indexet för den nya dimensionen. Alla tensorer måste ha samma form.
StdDev<T>(ReadOnlyTensorSpan<T>)

Returnerar standardavvikelsen för elementen x i tensorn.
Subtract<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)

Utför elementmässigt subtraktion mellan två tensorer.
Subtract<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

Utför elementmässigt subtraktion mellan två tensorer.
Subtract<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<T>)

Utför elementmässigt subtraktion mellan en tensor och skalär.
Subtract<T>(ReadOnlyTensorSpan<T>, T)

Utför elementmässigt subtraktion mellan en tensor och skalär.
Subtract<T>(T, ReadOnlyTensorSpan<T>, TensorSpan<T>)

Utför elementmässigt subtraktion mellan en tensor och skalär.
Subtract<T>(T, ReadOnlyTensorSpan<T>)

Utför elementmässigt subtraktion mellan en tensor och skalär.
Sum<T>(ReadOnlyTensorSpan<T>)

Summerar elementen i den angivna tensorn.
Tan<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Beräknar elementmässigt tangens för värdet i den angivna tensorn.
Tan<T>(ReadOnlyTensorSpan<T>)

Beräknar elementmässigt tangens för värdet i den angivna tensorn.
Tanh<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Beräknar den elementmässigt hyperboliska tangensen för varje radianvinkel i den angivna tensorn.
Tanh<T>(ReadOnlyTensorSpan<T>)

Beräknar den elementmässigt hyperboliska tangensen för varje radianvinkel i den angivna tensorn.
TanPi<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Beräknar elementmässigt tangens för värdet i den angivna tensorn som multiplicerats med Pi.
TanPi<T>(ReadOnlyTensorSpan<T>)

Beräknar elementmässigt tangens för värdet i den angivna tensorn som multiplicerats med Pi.
TrailingZeroCount<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Beräknar det elementmässigt avslutande nollantalet tal i den angivna tensorn.
TrailingZeroCount<T>(ReadOnlyTensorSpan<T>)

Beräknar det elementmässigt avslutande nollantalet tal i den angivna tensorn.
Transpose<T>(Tensor<T>)

Växlar de två sista dimensionerna av tensor tensorn.
Truncate<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Beräknar elementmässigt trunkering av tal i angiven tensor.
Truncate<T>(ReadOnlyTensorSpan<T>)

Beräknar elementmässigt trunkering av tal i angiven tensor.
TryBroadcastTo<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Skicka data från tensor till den minsta sändningsbara formen som är kompatibel med destination och lagrar dem i destination Om formerna inte är kompatibla returneras false.
TryBroadcastTo<T>(Tensor<T>, TensorSpan<T>)

Skicka data från tensor till den minsta sändningsbara formen som är kompatibel med destination och lagrar dem i destination Om formerna inte är kompatibla returneras false.
TryBroadcastTo<T>(TensorSpan<T>, TensorSpan<T>)

Skicka data från tensor till den minsta sändningsbara formen som är kompatibel med destination och lagrar dem i destination Om formerna inte är kompatibla returneras false.
Unsqueeze<T>(ReadOnlyTensorSpan<T>, Int32)

Infoga en ny dimension av längd 1 som visas vid dimensionspositionen.
Unsqueeze<T>(Tensor<T>, Int32)

Infoga en ny dimension av längd 1 som visas vid dimensionspositionen.
Unsqueeze<T>(TensorSpan<T>, Int32)

Infoga en ny dimension av längd 1 som visas vid dimensionspositionen.
Xor<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)

Utför exklusivt eller mellan två tensorer.
Xor<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

Utför exklusivt eller mellan två tensorer.
Xor<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<T>)

Utför exklusivt eller mellan en tensor och skalär.
Xor<T>(ReadOnlyTensorSpan<T>, T)

Utför exklusivt eller mellan en tensor och skalär.

Operatorer

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

Utför elementmässigt tillägg mellan två tensorer.
Addition(ReadOnlyTensorSpan<TScalar>, TScalar)

Utför elementmässigt tillägg mellan en tensor och skalär.
Addition(Tensor<TScalar>, Tensor<TScalar>)

Utför elementmässigt tillägg mellan två tensorer.
Addition(Tensor<TScalar>, TScalar)

Utför elementmässigt tillägg mellan en tensor och skalär.
Addition(TensorSpan<TScalar>, TensorSpan<TScalar>)

Utför elementmässigt tillägg mellan två tensorer.
Addition(TensorSpan<TScalar>, TScalar)

Utför elementmässigt tillägg mellan en tensor och skalär.
Addition(TScalar, ReadOnlyTensorSpan<TScalar>)

Utför elementmässigt tillägg mellan en tensor och skalär.
Addition(TScalar, Tensor<TScalar>)

Utför elementmässigt tillägg mellan en tensor och skalär.
Addition(TScalar, TensorSpan<TScalar>)

Utför elementmässigt tillägg mellan en tensor och skalär.
Addition<TScalar>(ReadOnlyTensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)

Utför elementmässigt tillägg mellan två tensorer.
Addition<TScalar>(ReadOnlyTensorSpan<TScalar>, TScalar)

Utför elementmässigt tillägg mellan en tensor och skalär.
Addition<TScalar>(Tensor<TScalar>, Tensor<TScalar>)

Utför elementmässigt tillägg mellan två tensorer.
Addition<TScalar>(Tensor<TScalar>, TScalar)

Utför elementmässigt tillägg mellan en tensor och skalär.
Addition<TScalar>(TensorSpan<TScalar>, TensorSpan<TScalar>)

Utför elementmässigt tillägg mellan två tensorer.
Addition<TScalar>(TensorSpan<TScalar>, TScalar)

Utför elementmässigt tillägg mellan en tensor och skalär.
Addition<TScalar>(TScalar, ReadOnlyTensorSpan<TScalar>)

Utför elementmässigt tillägg mellan en tensor och skalär.
Addition<TScalar>(TScalar, Tensor<TScalar>)

Utför elementmässigt tillägg mellan en tensor och skalär.
Addition<TScalar>(TScalar, TensorSpan<TScalar>)

Utför elementmässigt tillägg mellan en tensor och skalär.
AdditionAssignment(ReadOnlyTensorSpan<TScalar>)

Utför elementmässigt tillägg på plats mellan två tensorer.
AdditionAssignment(ReadOnlyTensorSpan<TScalar>)

Utför elementmässigt tillägg på plats mellan två tensorer.
AdditionAssignment(TScalar)

Utför elementmässigt tillägg på plats mellan en tensor och skalär.
AdditionAssignment(TScalar)

Utför elementmässigt tillägg på plats mellan en tensor och skalär.
AdditionAssignment<TScalar>(Tensor<TScalar>, ReadOnlyTensorSpan<TScalar>)

Utför elementmässigt tillägg på plats mellan två tensorer.
AdditionAssignment<TScalar>(Tensor<TScalar>, TScalar)

Utför elementmässigt tillägg på plats mellan en tensor och skalär.
AdditionAssignment<TScalar>(TensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)

Utför elementmässigt tillägg på plats mellan två tensorer.
AdditionAssignment<TScalar>(TensorSpan<TScalar>, TScalar)

Utför elementmässigt tillägg på plats mellan en tensor och skalär.
BitwiseAnd(ReadOnlyTensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)

Utför bitvis och mellan två tensorer.
BitwiseAnd(ReadOnlyTensorSpan<TScalar>, TScalar)

Utför bitvis och mellan en tensor och skalär.
BitwiseAnd(Tensor<TScalar>, Tensor<TScalar>)

Utför bitvis och mellan två tensorer.
BitwiseAnd(Tensor<TScalar>, TScalar)

Utför bitvis och mellan en tensor och skalär.
BitwiseAnd(TensorSpan<TScalar>, TensorSpan<TScalar>)

Utför bitvis och mellan två tensorer.
BitwiseAnd(TensorSpan<TScalar>, TScalar)

Utför bitvis och mellan en tensor och skalär.
BitwiseAnd(TScalar, ReadOnlyTensorSpan<TScalar>)

Utför bitvis och mellan en tensor och skalär.
BitwiseAnd(TScalar, Tensor<TScalar>)

Utför bitvis och mellan en tensor och skalär.
BitwiseAnd(TScalar, TensorSpan<TScalar>)

Utför bitvis och mellan en tensor och skalär.
BitwiseAnd<TScalar>(ReadOnlyTensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)

Utför bitvis och mellan två tensorer.
BitwiseAnd<TScalar>(ReadOnlyTensorSpan<TScalar>, TScalar)

Utför bitvis och mellan en tensor och skalär.
BitwiseAnd<TScalar>(Tensor<TScalar>, Tensor<TScalar>)

Utför bitvis och mellan två tensorer.
BitwiseAnd<TScalar>(Tensor<TScalar>, TScalar)

Utför bitvis och mellan en tensor och skalär.
BitwiseAnd<TScalar>(TensorSpan<TScalar>, TensorSpan<TScalar>)

Utför bitvis och mellan två tensorer.
BitwiseAnd<TScalar>(TensorSpan<TScalar>, TScalar)

Utför bitvis och mellan en tensor och skalär.
BitwiseAnd<TScalar>(TScalar, ReadOnlyTensorSpan<TScalar>)

Utför bitvis och mellan en tensor och skalär.
BitwiseAnd<TScalar>(TScalar, Tensor<TScalar>)

Utför bitvis och mellan en tensor och skalär.
BitwiseAnd<TScalar>(TScalar, TensorSpan<TScalar>)

Utför bitvis och mellan en tensor och skalär.
BitwiseAndAssignment(ReadOnlyTensorSpan<TScalar>)

Utför bitvis på plats och mellan två tensorer.
BitwiseAndAssignment(ReadOnlyTensorSpan<TScalar>)

Utför bitvis på plats och mellan två tensorer.
BitwiseAndAssignment(TScalar)

Utför bitvis på plats och mellan en tensor och skalär.
BitwiseAndAssignment(TScalar)

Utför bitvis på plats och mellan en tensor och skalär.
BitwiseAndAssignment<TScalar>(Tensor<TScalar>, ReadOnlyTensorSpan<TScalar>)

Utför bitvis på plats och mellan två tensorer.
BitwiseAndAssignment<TScalar>(Tensor<TScalar>, TScalar)

Utför bitvis på plats och mellan en tensor och skalär.
BitwiseAndAssignment<TScalar>(TensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)

Utför bitvis på plats och mellan två tensorer.
BitwiseAndAssignment<TScalar>(TensorSpan<TScalar>, TScalar)

Utför bitvis på plats och mellan en tensor och skalär.
BitwiseOr(ReadOnlyTensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)

Utför bitvis eller mellan två tensorer.
BitwiseOr(ReadOnlyTensorSpan<TScalar>, TScalar)

Utför bitvis eller mellan en tensor och skalär.
BitwiseOr(Tensor<TScalar>, Tensor<TScalar>)

Utför bitvis eller mellan två tensorer.
BitwiseOr(Tensor<TScalar>, TScalar)

Utför bitvis eller mellan en tensor och skalär.
BitwiseOr(TensorSpan<TScalar>, TensorSpan<TScalar>)

Utför bitvis eller mellan två tensorer.
BitwiseOr(TensorSpan<TScalar>, TScalar)

Utför bitvis eller mellan en tensor och skalär.
BitwiseOr(TScalar, ReadOnlyTensorSpan<TScalar>)

Utför bitvis eller mellan en tensor och skalär.
BitwiseOr(TScalar, Tensor<TScalar>)

Utför bitvis eller mellan en tensor och skalär.
BitwiseOr(TScalar, TensorSpan<TScalar>)

Utför bitvis eller mellan en tensor och skalär.
BitwiseOr<TScalar>(ReadOnlyTensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)

Utför bitvis eller mellan två tensorer.
BitwiseOr<TScalar>(ReadOnlyTensorSpan<TScalar>, TScalar)

Utför bitvis eller mellan en tensor och skalär.
BitwiseOr<TScalar>(Tensor<TScalar>, Tensor<TScalar>)

Utför bitvis eller mellan två tensorer.
BitwiseOr<TScalar>(Tensor<TScalar>, TScalar)

Utför bitvis eller mellan en tensor och skalär.
BitwiseOr<TScalar>(TensorSpan<TScalar>, TensorSpan<TScalar>)

Utför bitvis eller mellan två tensorer.
BitwiseOr<TScalar>(TensorSpan<TScalar>, TScalar)

Utför bitvis eller mellan en tensor och skalär.
BitwiseOr<TScalar>(TScalar, ReadOnlyTensorSpan<TScalar>)

Utför bitvis eller mellan en tensor och skalär.
BitwiseOr<TScalar>(TScalar, Tensor<TScalar>)

Utför bitvis eller mellan en tensor och skalär.
BitwiseOr<TScalar>(TScalar, TensorSpan<TScalar>)

Utför bitvis eller mellan en tensor och skalär.
BitwiseOrAssignment(ReadOnlyTensorSpan<TScalar>)

Utför bitvis på plats eller mellan två tensorer.
BitwiseOrAssignment(ReadOnlyTensorSpan<TScalar>)

Utför bitvis på plats eller mellan två tensorer.
BitwiseOrAssignment(TScalar)

Utför bitvis på plats eller mellan en tensor och skalär.
BitwiseOrAssignment(TScalar)

Utför bitvis på plats eller mellan en tensor och skalär.
BitwiseOrAssignment<TScalar>(Tensor<TScalar>, ReadOnlyTensorSpan<TScalar>)

Utför bitvis på plats eller mellan två tensorer.
BitwiseOrAssignment<TScalar>(Tensor<TScalar>, TScalar)

Utför bitvis på plats eller mellan en tensor och skalär.
BitwiseOrAssignment<TScalar>(TensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)

Utför bitvis på plats eller mellan två tensorer.
BitwiseOrAssignment<TScalar>(TensorSpan<TScalar>, TScalar)

Utför bitvis på plats eller mellan en tensor och skalär.
DecrementAssignment

Utför på plats minskning på en tensor.
DecrementAssignment

Utför på plats minskning på en tensor.
DecrementAssignment<TScalar>(Tensor<TScalar>)

Utför på plats minskning på en tensor.
DecrementAssignment<TScalar>(TensorSpan<TScalar>)

Utför på plats minskning på en tensor.
Division(ReadOnlyTensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)

Utför elementmässigt uppdelning mellan två tensorer.
Division(ReadOnlyTensorSpan<TScalar>, TScalar)

Utför elementmässigt uppdelning mellan en tensor och skalär.
Division(Tensor<TScalar>, Tensor<TScalar>)

Utför elementmässigt uppdelning mellan två tensorer.
Division(Tensor<TScalar>, TScalar)

Utför elementmässigt uppdelning mellan en tensor och skalär.
Division(TensorSpan<TScalar>, TensorSpan<TScalar>)

Utför elementmässigt uppdelning mellan två tensorer.
Division(TensorSpan<TScalar>, TScalar)

Utför elementmässigt uppdelning mellan en tensor och skalär.
Division(TScalar, ReadOnlyTensorSpan<TScalar>)

Utför elementmässigt uppdelning mellan en tensor och skalär.
Division(TScalar, Tensor<TScalar>)

Utför elementmässigt uppdelning mellan en tensor och skalär.
Division(TScalar, TensorSpan<TScalar>)

Utför elementmässigt uppdelning mellan en tensor och skalär.
Division<TScalar>(ReadOnlyTensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)

Utför elementmässigt uppdelning mellan två tensorer.
Division<TScalar>(ReadOnlyTensorSpan<TScalar>, TScalar)

Utför elementmässigt uppdelning mellan en tensor och skalär.
Division<TScalar>(Tensor<TScalar>, Tensor<TScalar>)

Utför elementmässigt uppdelning mellan två tensorer.
Division<TScalar>(Tensor<TScalar>, TScalar)

Utför elementmässigt uppdelning mellan en tensor och skalär.
Division<TScalar>(TensorSpan<TScalar>, TensorSpan<TScalar>)

Utför elementmässigt uppdelning mellan två tensorer.
Division<TScalar>(TensorSpan<TScalar>, TScalar)

Utför elementmässigt uppdelning mellan en tensor och skalär.
Division<TScalar>(TScalar, ReadOnlyTensorSpan<TScalar>)

Utför elementmässigt uppdelning mellan en tensor och skalär.
Division<TScalar>(TScalar, Tensor<TScalar>)

Utför elementmässigt uppdelning mellan en tensor och skalär.
Division<TScalar>(TScalar, TensorSpan<TScalar>)

Utför elementmässigt uppdelning mellan en tensor och skalär.
DivisionAssignment(ReadOnlyTensorSpan<TScalar>)

Utför in-place element-wise division mellan två tensorer.
DivisionAssignment(ReadOnlyTensorSpan<TScalar>)

Utför in-place element-wise division mellan två tensorer.
DivisionAssignment(TScalar)

Utför elementmässigt på plats-divisionen mellan en tensor och skalär.
DivisionAssignment(TScalar)

Utför elementmässigt på plats-divisionen mellan en tensor och skalär.
DivisionAssignment<TScalar>(Tensor<TScalar>, ReadOnlyTensorSpan<TScalar>)

Utför in-place element-wise division mellan två tensorer.
DivisionAssignment<TScalar>(Tensor<TScalar>, TScalar)

Utför elementmässigt på plats-divisionen mellan en tensor och skalär.
DivisionAssignment<TScalar>(TensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)

Utför in-place element-wise division mellan två tensorer.
DivisionAssignment<TScalar>(TensorSpan<TScalar>, TScalar)

Utför elementmässigt på plats-divisionen mellan en tensor och skalär.
ExclusiveOr(ReadOnlyTensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)

Utför exklusivt eller mellan två tensorer.
ExclusiveOr(ReadOnlyTensorSpan<TScalar>, TScalar)

Utför exklusivt eller mellan en tensor och skalär.
ExclusiveOr(Tensor<TScalar>, Tensor<TScalar>)

Utför exklusivt eller mellan två tensorer.
ExclusiveOr(Tensor<TScalar>, TScalar)

Utför exklusivt eller mellan en tensor och skalär.
ExclusiveOr(TensorSpan<TScalar>, TensorSpan<TScalar>)

Utför exklusivt eller mellan två tensorer.
ExclusiveOr(TensorSpan<TScalar>, TScalar)

Utför exklusivt eller mellan en tensor och skalär.
ExclusiveOr(TScalar, ReadOnlyTensorSpan<TScalar>)

Utför exklusivt eller mellan en tensor och skalär.
ExclusiveOr(TScalar, Tensor<TScalar>)

Utför exklusivt eller mellan en tensor och skalär.
ExclusiveOr(TScalar, TensorSpan<TScalar>)

Utför exklusivt eller mellan en tensor och skalär.
ExclusiveOr<TScalar>(ReadOnlyTensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)

Utför exklusivt eller mellan två tensorer.
ExclusiveOr<TScalar>(ReadOnlyTensorSpan<TScalar>, TScalar)

Utför exklusivt eller mellan en tensor och skalär.
ExclusiveOr<TScalar>(Tensor<TScalar>, Tensor<TScalar>)

Utför exklusivt eller mellan två tensorer.
ExclusiveOr<TScalar>(Tensor<TScalar>, TScalar)

Utför exklusivt eller mellan en tensor och skalär.
ExclusiveOr<TScalar>(TensorSpan<TScalar>, TensorSpan<TScalar>)

Utför exklusivt eller mellan två tensorer.
ExclusiveOr<TScalar>(TensorSpan<TScalar>, TScalar)

Utför exklusivt eller mellan en tensor och skalär.
ExclusiveOr<TScalar>(TScalar, ReadOnlyTensorSpan<TScalar>)

Utför exklusivt eller mellan en tensor och skalär.
ExclusiveOr<TScalar>(TScalar, Tensor<TScalar>)

Utför exklusivt eller mellan en tensor och skalär.
ExclusiveOr<TScalar>(TScalar, TensorSpan<TScalar>)

Utför exklusivt eller mellan en tensor och skalär.
ExclusiveOrAssignment(ReadOnlyTensorSpan<TScalar>)

Utför exklusivt eller mellan två tensorer på plats.
ExclusiveOrAssignment(ReadOnlyTensorSpan<TScalar>)

Utför exklusivt eller mellan två tensorer på plats.
ExclusiveOrAssignment(TScalar)

Utför exklusivt på plats eller mellan en tensor och skalär.
ExclusiveOrAssignment(TScalar)

Utför exklusivt på plats eller mellan en tensor och skalär.
ExclusiveOrAssignment<TScalar>(Tensor<TScalar>, ReadOnlyTensorSpan<TScalar>)

Utför exklusivt eller mellan två tensorer på plats.
ExclusiveOrAssignment<TScalar>(Tensor<TScalar>, TScalar)

Utför exklusivt på plats eller mellan en tensor och skalär.
ExclusiveOrAssignment<TScalar>(TensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)

Utför exklusivt eller mellan två tensorer på plats.
ExclusiveOrAssignment<TScalar>(TensorSpan<TScalar>, TScalar)

Utför exklusivt på plats eller mellan en tensor och skalär.
IncrementAssignment

Utför in-place increment på en tensor.
IncrementAssignment

Utför in-place increment på en tensor.
IncrementAssignment<TScalar>(Tensor<TScalar>)

Utför in-place increment på en tensor.
IncrementAssignment<TScalar>(TensorSpan<TScalar>)

Utför in-place increment på en tensor.
LeftShift(ReadOnlyTensorSpan<TScalar>, Int32)

Utför ett elementmässigt vänsterskift på en tensor.
LeftShift(Tensor<TScalar>, Int32)

Utför ett elementmässigt vänsterskift på en tensor.
LeftShift(TensorSpan<TScalar>, Int32)

Utför ett elementmässigt vänsterskift på en tensor.
LeftShift<TScalar>(ReadOnlyTensorSpan<TScalar>, Int32)

Utför ett elementmässigt vänsterskift på en tensor.
LeftShift<TScalar>(Tensor<TScalar>, Int32)

Utför ett elementmässigt vänsterskift på en tensor.
LeftShift<TScalar>(TensorSpan<TScalar>, Int32)

Utför ett elementmässigt vänsterskift på en tensor.
LeftShiftAssignment(Int32)

Utför elementmässigt vänsterskift på plats på en tensor.
LeftShiftAssignment(Int32)

Utför elementmässigt vänsterskift på plats på en tensor.
LeftShiftAssignment<TScalar>(Tensor<TScalar>, Int32)

Utför elementmässigt vänsterskift på plats på en tensor.
LeftShiftAssignment<TScalar>(TensorSpan<TScalar>, Int32)

Utför elementmässigt vänsterskift på plats på en tensor.
MultiplicationAssignment(ReadOnlyTensorSpan<TScalar>)

Utför elementvis multiplikation på plats mellan två tensorer.
MultiplicationAssignment(ReadOnlyTensorSpan<TScalar>)

Utför elementvis multiplikation på plats mellan två tensorer.
MultiplicationAssignment(TScalar)

Utför elementmässigt multiplikation på plats mellan en tensor och skalär.
MultiplicationAssignment(TScalar)

Utför elementmässigt multiplikation på plats mellan en tensor och skalär.
MultiplicationAssignment<TScalar>(Tensor<TScalar>, ReadOnlyTensorSpan<TScalar>)

Utför elementvis multiplikation på plats mellan två tensorer.
MultiplicationAssignment<TScalar>(Tensor<TScalar>, TScalar)

Utför elementmässigt multiplikation på plats mellan en tensor och skalär.
MultiplicationAssignment<TScalar>(TensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)

Utför elementvis multiplikation på plats mellan två tensorer.
MultiplicationAssignment<TScalar>(TensorSpan<TScalar>, TScalar)

Utför elementmässigt multiplikation på plats mellan en tensor och skalär.
Multiply(ReadOnlyTensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)

Utför elementmässigt multiplikation mellan två tensorer.
Multiply(ReadOnlyTensorSpan<TScalar>, TScalar)

Utför elementmässigt multiplikation mellan en tensor och skalär.
Multiply(Tensor<TScalar>, Tensor<TScalar>)

Utför elementmässigt multiplikation mellan två tensorer.
Multiply(Tensor<TScalar>, TScalar)

Utför elementmässigt multiplikation mellan en tensor och skalär.
Multiply(TensorSpan<TScalar>, TensorSpan<TScalar>)

Utför elementmässigt multiplikation mellan två tensorer.
Multiply(TensorSpan<TScalar>, TScalar)

Utför elementmässigt multiplikation mellan en tensor och skalär.
Multiply(TScalar, ReadOnlyTensorSpan<TScalar>)

Utför elementmässigt multiplikation mellan en tensor och skalär.
Multiply(TScalar, Tensor<TScalar>)

Utför elementmässigt multiplikation mellan en tensor och skalär.
Multiply(TScalar, TensorSpan<TScalar>)

Utför elementmässigt multiplikation mellan en tensor och skalär.
Multiply<TScalar>(ReadOnlyTensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)

Utför elementmässigt multiplikation mellan två tensorer.
Multiply<TScalar>(ReadOnlyTensorSpan<TScalar>, TScalar)

Utför elementmässigt multiplikation mellan en tensor och skalär.
Multiply<TScalar>(Tensor<TScalar>, Tensor<TScalar>)

Utför elementmässigt multiplikation mellan två tensorer.
Multiply<TScalar>(Tensor<TScalar>, TScalar)

Utför elementmässigt multiplikation mellan en tensor och skalär.
Multiply<TScalar>(TensorSpan<TScalar>, TensorSpan<TScalar>)

Utför elementmässigt multiplikation mellan två tensorer.
Multiply<TScalar>(TensorSpan<TScalar>, TScalar)

Utför elementmässigt multiplikation mellan en tensor och skalär.
Multiply<TScalar>(TScalar, ReadOnlyTensorSpan<TScalar>)

Utför elementmässigt multiplikation mellan en tensor och skalär.
Multiply<TScalar>(TScalar, Tensor<TScalar>)

Utför elementmässigt multiplikation mellan en tensor och skalär.
Multiply<TScalar>(TScalar, TensorSpan<TScalar>)

Utför elementmässigt multiplikation mellan en tensor och skalär.
OnesComplement(ReadOnlyTensorSpan<TScalar>)

Utför ett komplement på en tensor.
OnesComplement(Tensor<TScalar>)

Utför ett komplement på en tensor.
OnesComplement(TensorSpan<TScalar>)

Utför ett komplement på en tensor.
OnesComplement<TScalar>(ReadOnlyTensorSpan<TScalar>)

Utför ett komplement på en tensor.
OnesComplement<TScalar>(Tensor<TScalar>)

Utför ett komplement på en tensor.
OnesComplement<TScalar>(TensorSpan<TScalar>)

Utför ett komplement på en tensor.
RightShift(ReadOnlyTensorSpan<TScalar>, Int32)

Utför ett elementmässigt aritmetiskt högerskift på en tensor.
RightShift(Tensor<TScalar>, Int32)

Utför ett elementmässigt aritmetiskt högerskift på en tensor.
RightShift(TensorSpan<TScalar>, Int32)

Utför ett elementmässigt aritmetiskt högerskift på en tensor.
RightShift<TScalar>(ReadOnlyTensorSpan<TScalar>, Int32)

Utför ett elementmässigt aritmetiskt högerskift på en tensor.
RightShift<TScalar>(Tensor<TScalar>, Int32)

Utför ett elementmässigt aritmetiskt högerskift på en tensor.
RightShift<TScalar>(TensorSpan<TScalar>, Int32)

Utför ett elementmässigt aritmetiskt högerskift på en tensor.
RightShiftAssignment(Int32)

Utför elementmässigt aritmetiska högerförskjutningar på plats på en tensor.
RightShiftAssignment(Int32)

Utför elementmässigt aritmetiska högerförskjutningar på plats på en tensor.
RightShiftAssignment<TScalar>(Tensor<TScalar>, Int32)

Utför elementmässigt aritmetiska högerförskjutningar på plats på en tensor.
RightShiftAssignment<TScalar>(TensorSpan<TScalar>, Int32)

Utför elementmässigt aritmetiska högerförskjutningar på plats på en tensor.
Subtraction(ReadOnlyTensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)

Utför elementmässigt subtraktion mellan två tensorer.
Subtraction(ReadOnlyTensorSpan<TScalar>, TScalar)

Utför elementmässigt subtraktion mellan en tensor och skalär.
Subtraction(Tensor<TScalar>, Tensor<TScalar>)

Utför elementmässigt subtraktion mellan två tensorer.
Subtraction(Tensor<TScalar>, TScalar)

Utför elementmässigt subtraktion mellan en tensor och skalär.
Subtraction(TensorSpan<TScalar>, TensorSpan<TScalar>)

Utför elementmässigt subtraktion mellan två tensorer.
Subtraction(TensorSpan<TScalar>, TScalar)

Utför elementmässigt subtraktion mellan en tensor och skalär.
Subtraction(TScalar, ReadOnlyTensorSpan<TScalar>)

Utför elementmässigt subtraktion mellan en tensor och skalär.
Subtraction(TScalar, Tensor<TScalar>)

Utför elementmässigt subtraktion mellan en tensor och skalär.
Subtraction(TScalar, TensorSpan<TScalar>)

Utför elementmässigt subtraktion mellan en tensor och skalär.
Subtraction<TScalar>(ReadOnlyTensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)

Utför elementmässigt subtraktion mellan två tensorer.
Subtraction<TScalar>(ReadOnlyTensorSpan<TScalar>, TScalar)

Utför elementmässigt subtraktion mellan en tensor och skalär.
Subtraction<TScalar>(Tensor<TScalar>, Tensor<TScalar>)

Utför elementmässigt subtraktion mellan två tensorer.
Subtraction<TScalar>(Tensor<TScalar>, TScalar)

Utför elementmässigt subtraktion mellan en tensor och skalär.
Subtraction<TScalar>(TensorSpan<TScalar>, TensorSpan<TScalar>)

Utför elementmässigt subtraktion mellan två tensorer.
Subtraction<TScalar>(TensorSpan<TScalar>, TScalar)

Utför elementmässigt subtraktion mellan en tensor och skalär.
Subtraction<TScalar>(TScalar, ReadOnlyTensorSpan<TScalar>)

Utför elementmässigt subtraktion mellan en tensor och skalär.
Subtraction<TScalar>(TScalar, Tensor<TScalar>)

Utför elementmässigt subtraktion mellan en tensor och skalär.
Subtraction<TScalar>(TScalar, TensorSpan<TScalar>)

Utför elementmässigt subtraktion mellan en tensor och skalär.
SubtractionAssignment(ReadOnlyTensorSpan<TScalar>)

Utför elementmässigt subtraktion på plats mellan två tensorer.
SubtractionAssignment(ReadOnlyTensorSpan<TScalar>)

Utför elementmässigt subtraktion på plats mellan två tensorer.
SubtractionAssignment(TScalar)

Utför elementmässigt subtraktion på plats mellan en tensor och skalär.
SubtractionAssignment(TScalar)

Utför elementmässigt subtraktion på plats mellan en tensor och skalär.
SubtractionAssignment<TScalar>(Tensor<TScalar>, ReadOnlyTensorSpan<TScalar>)

Utför elementmässigt subtraktion på plats mellan två tensorer.
SubtractionAssignment<TScalar>(Tensor<TScalar>, TScalar)

Utför elementmässigt subtraktion på plats mellan en tensor och skalär.
SubtractionAssignment<TScalar>(TensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)

Utför elementmässigt subtraktion på plats mellan två tensorer.
SubtractionAssignment<TScalar>(TensorSpan<TScalar>, TScalar)

Utför elementmässigt subtraktion på plats mellan en tensor och skalär.
UnaryNegation(ReadOnlyTensorSpan<TScalar>)

Utför elementmässigt unary negation på en tensor.
UnaryNegation(Tensor<TScalar>)

Utför elementmässigt unary negation på en tensor.
UnaryNegation(TensorSpan<TScalar>)

Utför elementmässigt unary negation på en tensor.
UnaryNegation<TScalar>(ReadOnlyTensorSpan<TScalar>)

Utför elementmässigt unary negation på en tensor.
UnaryNegation<TScalar>(Tensor<TScalar>)

Utför elementmässigt unary negation på en tensor.
UnaryNegation<TScalar>(TensorSpan<TScalar>)

Utför elementmässigt unary negation på en tensor.
UnaryPlus(ReadOnlyTensorSpan<TScalar>)

Utför elementmässigt unary plus på en tensor.
UnaryPlus(Tensor<TScalar>)

Utför elementmässigt unary plus på en tensor.
UnaryPlus(TensorSpan<TScalar>)

Utför elementmässigt unary plus på en tensor.
UnaryPlus<TScalar>(ReadOnlyTensorSpan<TScalar>)

Utför elementmässigt unary plus på en tensor.
UnaryPlus<TScalar>(Tensor<TScalar>)

Utför elementmässigt unary plus på en tensor.
UnaryPlus<TScalar>(TensorSpan<TScalar>)

Utför elementmässigt unary plus på en tensor.
UnsignedRightShift(ReadOnlyTensorSpan<TScalar>, Int32)

Utför ett elementmässigt logiskt högerskifte på en tensor.
UnsignedRightShift(Tensor<TScalar>, Int32)

Utför ett elementmässigt logiskt högerskifte på en tensor.
UnsignedRightShift(TensorSpan<TScalar>, Int32)

Utför ett elementmässigt logiskt högerskifte på en tensor.
UnsignedRightShift<TScalar>(ReadOnlyTensorSpan<TScalar>, Int32)

Utför ett elementmässigt logiskt högerskifte på en tensor.
UnsignedRightShift<TScalar>(Tensor<TScalar>, Int32)

Utför ett elementmässigt logiskt högerskifte på en tensor.
UnsignedRightShift<TScalar>(TensorSpan<TScalar>, Int32)

Utför ett elementmässigt logiskt högerskifte på en tensor.
UnsignedRightShiftAssignment(Int32)

Utför en elementmässigt logisk högerväxling på plats på en tensor.
UnsignedRightShiftAssignment(Int32)

Utför en elementmässigt logisk högerväxling på plats på en tensor.
UnsignedRightShiftAssignment<TScalar>(Tensor<TScalar>, Int32)

Utför en elementmässigt logisk högerväxling på plats på en tensor.
UnsignedRightShiftAssignment<TScalar>(TensorSpan<TScalar>, Int32)

Utför en elementmässigt logisk högerväxling på plats på en tensor.

Gäller för