Tensor Classe

Definição

Espaço de Nomes:
System.Numerics.Tensors
Assemblagem:
System.Numerics.Tensors.dll
Pacote:
System.Numerics.Tensors v11.0.0-preview.4.26230.115
Origem:
Tensor.cs
Origem:
TensorExtensions.cs
Origem:
Tensor.cs

Fornece métodos para operações tensoriais.

public ref class Tensor abstract sealed
public static class Tensor
type Tensor = class
Public Module Tensor
Herança
Object
Tensor

Métodos

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

Toma o valor absoluto de cada elemento do ReadOnlyTensorSpan<T> e devolve um novo TensorSpan<T> com o resultado.
Abs<T>(ReadOnlyTensorSpan<T>)

Toma o valor absoluto de cada elemento do Tensor<T> e devolve um novo Tensor<T> com o resultado.
Acos<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Toma o cosseno inverso de cada elemento do Tensor<T> e devolve um novo Tensor<T> com o resultado.
Acos<T>(ReadOnlyTensorSpan<T>)

Toma o cosseno inverso de cada elemento do Tensor<T> e devolve um novo Tensor<T> com o resultado.
Acosh<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Toma o cosseno hiperbólico inverso de cada elemento do TensorSpan<T> e devolve um novo TensorSpan<T> com o resultado.
Acosh<T>(ReadOnlyTensorSpan<T>)

Toma o cosseno hiperbólico inverso de cada elemento do ReadOnlyTensorSpan<T> e devolve um novo Tensor<T> com o resultado.
AcosPi<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Toma o cosseno hiperbólico inverso dividido por pi de cada elemento do TensorSpan<T> e devolve um novo TensorSpan<T> com o resultado.
AcosPi<T>(ReadOnlyTensorSpan<T>)

Toma o cosseno hiperbólico inverso dividido por pi de cada elemento do Tensor<T> e devolve um novo Tensor<T> com o resultado.
Add<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)

Realiza a adição elemento a elemento entre dois tensores.
Add<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

Realiza a adição elemento a elemento entre dois tensores.
Add<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<T>)

Realiza adição elemento a elemento entre um tensor e um escalar.
Add<T>(ReadOnlyTensorSpan<T>, T)

Realiza adição elemento a elemento entre um tensor e um escalar.
Asin<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Toma o seno inverso de cada elemento do ReadOnlyTensorSpan<T> e devolve um novo TensorSpan<T> com o resultado.
Asin<T>(ReadOnlyTensorSpan<T>)

Toma o seno inverso de cada elemento do ReadOnlyTensorSpan<T> e devolve um novo Tensor<T> com o resultado.
Asinh<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Toma o seno hiperbólico inverso de cada elemento do ReadOnlyTensorSpan<T> e devolve um novo TensorSpan<T> com o resultado.
Asinh<T>(ReadOnlyTensorSpan<T>)

Toma o seno hiperbólico inverso de cada elemento do ReadOnlyTensorSpan<T> e devolve um novo Tensor<T> com o resultado.
AsinPi<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Toma o seno hiperbólico inverso dividido por pi de cada elemento do ReadOnlyTensorSpan<T> e devolve um novo TensorSpan<T> com o resultado.
AsinPi<T>(ReadOnlyTensorSpan<T>)

Toma o seno hiperbólico inverso dividido por pi de cada elemento do ReadOnlyTensorSpan<T> e devolve um novo Tensor<T> com o resultado.
AsReadOnlyTensorSpan<T>(T[], Int32, ReadOnlySpan<IntPtr>, ReadOnlySpan<IntPtr>)

Cria um novo tensor sobre a porção do array alvo que começa no índice inicial especificado e utiliza os comprimentos e passos especificados.
AsReadOnlyTensorSpan<T>(T[], ReadOnlySpan<IntPtr>, ReadOnlySpan<IntPtr>)

Cria um novo tensor sobre a porção do array alvo que começa no índice inicial especificado e utiliza os comprimentos e passos especificados.
AsReadOnlyTensorSpan<T>(T[], ReadOnlySpan<IntPtr>)

Método de extensão para criar mais facilmente um TensorSpan a partir de um array.
AsReadOnlyTensorSpan<T>(T[])

Cria um novo tensor em toda a matriz alvo.
AsTensorSpan<T>(T[], Int32, ReadOnlySpan<IntPtr>, ReadOnlySpan<IntPtr>)

Cria um novo espaço sobre a porção do array alvo que começa no índice 'start' e termina no índice 'end' (exclusivo).
AsTensorSpan<T>(T[], ReadOnlySpan<IntPtr>, ReadOnlySpan<IntPtr>)

Fornece métodos para operações tensoriais.
AsTensorSpan<T>(T[], ReadOnlySpan<IntPtr>)

Método de extensão para criar mais facilmente um TensorSpan a partir de um array.
AsTensorSpan<T>(T[])

Cria um novo vão sobre toda a matriz alvo.
Atan<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Toma a tangente de arco de cada elemento do ReadOnlyTensorSpan<T> e devolve um novo TensorSpan<T> com o resultado.
Atan<T>(ReadOnlyTensorSpan<T>)

Toma a tangente de arco de cada elemento do ReadOnlyTensorSpan<T> e devolve um novo Tensor<T> com o resultado.
Atan2<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)

Pega na tangente de arco das duas entradas ReadOnlyTensorSpan<T> e devolve uma nova TensorSpan<T> com o resultado.
Atan2<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

Pega na tangente de arco das duas entradas ReadOnlyTensorSpan<T> e devolve uma nova Tensor<T> com o resultado.
Atan2<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<T>)

Pega na tangente de arco das duas entradas ReadOnlyTensorSpan<T> e devolve uma nova TensorSpan<T> com o resultado.
Atan2<T>(ReadOnlyTensorSpan<T>, T)

Pega na tangente de arco das duas entradas ReadOnlyTensorSpan<T> e devolve uma nova Tensor<T> com o resultado.
Atan2<T>(T, ReadOnlyTensorSpan<T>, TensorSpan<T>)

Pega na tangente de arco das duas entradas ReadOnlyTensorSpan<T> e devolve uma nova TensorSpan<T> com o resultado.
Atan2<T>(T, ReadOnlyTensorSpan<T>)

Pega na tangente de arco das duas entradas ReadOnlyTensorSpan<T> e devolve uma nova Tensor<T> com o resultado.
Atan2Pi<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)

Toma a tangente de arco das duas entradas ReadOnlyTensorSpan<T>, divide cada elemento por pi e devolve um novo TensorSpan<T> com o resultado.
Atan2Pi<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

Toma a tangente de arco das duas entradas ReadOnlyTensorSpan<T>, divide cada elemento por pi e devolve um novo Tensor<T> com o resultado.
Atan2Pi<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<T>)

Toma a tangente de arco das duas entradas ReadOnlyTensorSpan<T>, divide cada elemento por pi e devolve um novo TensorSpan<T> com o resultado.
Atan2Pi<T>(ReadOnlyTensorSpan<T>, T)

Toma a tangente de arco das duas entradas ReadOnlyTensorSpan<T>, divide cada elemento por pi e devolve um novo TensorSpan<T> com o resultado.
Atan2Pi<T>(T, ReadOnlyTensorSpan<T>, TensorSpan<T>)

Toma a tangente de arco das duas entradas ReadOnlyTensorSpan<T>, divide cada elemento por pi e devolve um novo TensorSpan<T> com o resultado.
Atan2Pi<T>(T, ReadOnlyTensorSpan<T>)

Toma a tangente de arco das duas entradas ReadOnlyTensorSpan<T>, divide cada elemento por pi e devolve um novo TensorSpan<T> com o resultado.
Atanh<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Toma a tangente hiperbólica inversa de cada elemento do ReadOnlyTensorSpan<T> e devolve um novo TensorSpan<T> com o resultado.
Atanh<T>(ReadOnlyTensorSpan<T>)

Toma a tangente hiperbólica inversa de cada elemento do ReadOnlyTensorSpan<T> e devolve um novo Tensor<T> com o resultado.
AtanPi<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Toma a tangente hiperbólica inversa dividida por pi de cada elemento do ReadOnlyTensorSpan<T> e devolve um novo TensorSpan<T> com o resultado.
AtanPi<T>(ReadOnlyTensorSpan<T>)

Toma a tangente hiperbólica inversa dividida por pi de cada elemento do ReadOnlyTensorSpan<T> e devolve um novo Tensor<T> com o resultado.
Average<T>(ReadOnlyTensorSpan<T>)

Devolve a média dos elementos no x tensor.
BitwiseAnd<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)

Executa bit a bit e entre dois tensores.
BitwiseAnd<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

Executa bit a bit e entre dois tensores.
BitwiseAnd<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<T>)

Executa bit a bit e entre um tensor e um escalar.
BitwiseAnd<T>(ReadOnlyTensorSpan<T>, T)

Executa bit a bit e entre um tensor e um escalar.
BitwiseOr<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)

Executa bitwise-or entre dois tensores.
BitwiseOr<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

Executa bitwise-or entre dois tensores.
BitwiseOr<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<T>)

Executa bits a bits—ou entre um tensor e um escalar.
BitwiseOr<T>(ReadOnlyTensorSpan<T>, T)

Executa bits a bits—ou entre um tensor e um escalar.
Broadcast<T>(ReadOnlyTensorSpan<T>, ReadOnlySpan<IntPtr>)

Transmite os dados de source para a nova forma lengths. Cria uma nova Tensor<T> memória e aloca nova. Se a forma do source não for compatível com a nova forma, é lançada uma exceção.
Broadcast<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

Transmita os dados de source para a menor forma difusível compatível com lengthsSource. Cria uma nova Tensor<T> memória e aloca nova.
BroadcastTo<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Transmita os dados de source para destination.
BroadcastTo<T>(Tensor<T>, TensorSpan<T>)

Transmita os dados de source para destination.
BroadcastTo<T>(TensorSpan<T>, TensorSpan<T>)

Transmita os dados de source para destination.
Cbrt<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Calcula a raiz cúbica elemento a elemento da entrada ReadOnlyTensorSpan<T> e devolve uma nova TensorSpan<T> com o resultado.
Cbrt<T>(ReadOnlyTensorSpan<T>)

Calcula a raiz cúbica elemento a elemento da entrada ReadOnlyTensorSpan<T> e devolve uma nova Tensor<T> com o resultado.
Ceiling<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Calcula o teto elemento a elemento da entrada ReadOnlyTensorSpan<T> e devolve um novo TensorSpan<T> com o resultado.
Ceiling<T>(ReadOnlyTensorSpan<T>)

Calcula o teto elemento a elemento da entrada ReadOnlyTensorSpan<T> e devolve um novo Tensor<T> com o resultado.
Concatenate<T>(ReadOnlySpan<Tensor<T>>, TensorSpan<T>)

Junta uma sequência de tensores ao longo de um eixo existente.
Concatenate<T>(ReadOnlySpan<Tensor<T>>)

Junta uma sequência de tensores ao longo de um eixo existente.
ConcatenateOnDimension<T>(Int32, ReadOnlySpan<Tensor<T>>, TensorSpan<T>)

Junta uma sequência de tensores ao longo de um eixo existente.
ConcatenateOnDimension<T>(Int32, ReadOnlySpan<Tensor<T>>)

Junta uma sequência de tensores ao longo de um eixo existente.
ConvertChecked<TFrom,TTo>(ReadOnlyTensorSpan<TFrom>, TensorSpan<TTo>)

Cópias source para um novo TensorSpan<T> , convertendo cada TFrom valor num TTo valor.
ConvertChecked<TFrom,TTo>(ReadOnlyTensorSpan<TFrom>)

Cópias source para um novo ReadOnlyTensorSpan<T> , convertendo cada TFrom valor num TTo valor.
ConvertSaturating<TFrom,TTo>(ReadOnlyTensorSpan<TFrom>, TensorSpan<TTo>)

Cópias source para um novo TensorSpan<T> , convertendo cada TFrom valor num TTo valor.
ConvertSaturating<TFrom,TTo>(ReadOnlyTensorSpan<TFrom>)

Cópias source para um novo ReadOnlyTensorSpan<T> , convertendo cada TFrom valor num TTo valor.
ConvertTruncating<TFrom,TTo>(ReadOnlyTensorSpan<TFrom>, TensorSpan<TTo>)

Cópias source para um novo TensorSpan<T> , convertendo cada TFrom valor num TTo valor.
ConvertTruncating<TFrom,TTo>(ReadOnlyTensorSpan<TFrom>)

Cópias source para um novo ReadOnlyTensorSpan<T> , convertendo cada TFrom valor num TTo valor.
CopySign<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)

Calcula o resultado elemento a elemento de copiar o sinal de um número para outro número nos tensores especificados e devolve um novo TensorSpan<T> com o resultado.
CopySign<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

Calcula o resultado elemento a elemento de copiar o sinal de um número para outro número nos tensores especificados e devolve um novo Tensor<T> com o resultado.
CopySign<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<T>)

Calcula o resultado elemento a elemento de copiar o sinal de um número para outro número nos tensores especificados e devolve um novo tensor com o resultado.
CopySign<T>(ReadOnlyTensorSpan<T>, T)

Calcula o resultado elemento a elemento de copiar o sinal de um número para outro número nos tensores especificados e devolve um novo tensor com o resultado.
Cos<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Toma o cosseno de cada elemento do ReadOnlyTensorSpan<T> e devolve um novo TensorSpan<T> com o resultado.
Cos<T>(ReadOnlyTensorSpan<T>)

Toma o cosseno de cada elemento do ReadOnlyTensorSpan<T> e devolve um novo Tensor<T> com o resultado.
Cosh<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Toma o cosseno hiperbólico de cada elemento do ReadOnlyTensorSpan<T> e devolve um novo TensorSpan<T> com o resultado.
Cosh<T>(ReadOnlyTensorSpan<T>)

Toma o cosseno hiperbólico de cada elemento do ReadOnlyTensorSpan<T> e devolve um novo Tensor<T> com o resultado.
CosineSimilarity<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

Calcule a similaridade cosseno entre x e y.
CosPi<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Calcula o cosseno elemento a elemento do valor no tensor especificado que foi multiplicado por Pi e devolve um novo TensorSpan<T> com os resultados.
CosPi<T>(ReadOnlyTensorSpan<T>)

Calcula o cosseno elemento a elemento do valor no tensor especificado que foi multiplicado por Pi e devolve um novo Tensor<T> com os resultados.
Create<T>(T[], Int32, ReadOnlySpan<IntPtr>, ReadOnlySpan<IntPtr>)

Cria um novo tensor sobre a porção do array alvo que começa no índice inicial especificado e utiliza os comprimentos e passos especificados.
Create<T>(T[], ReadOnlySpan<IntPtr>, ReadOnlySpan<IntPtr>)

Cria um novo tensor sobre a porção do array alvo que começa no índice inicial especificado e utiliza os comprimentos e passos especificados.
Create<T>(T[], ReadOnlySpan<IntPtr>)

Cria um novo tensor sobre a porção do array alvo usando os comprimentos especificados.
Create<T>(T[])

Cria um novo tensor em toda a matriz alvo.
CreateFromShape<T>(ReadOnlySpan<IntPtr>, Boolean)

Cria um novo tensor com os comprimentos especificados.
CreateFromShape<T>(ReadOnlySpan<IntPtr>, ReadOnlySpan<IntPtr>, Boolean)

Cria um novo tensor com os comprimentos e passos especificados.
CreateFromShapeUninitialized<T>(ReadOnlySpan<IntPtr>, Boolean)

Cria um novo tensor com os comprimentos e passos especificados.
CreateFromShapeUninitialized<T>(ReadOnlySpan<IntPtr>, ReadOnlySpan<IntPtr>, Boolean)

Cria um novo tensor com os comprimentos e passos especificados. Se pinned for verdadeiro, o buffer subjacente é criado permanentemente fixado, caso contrário o buffer subjacente não está fixado. O buffer subjacente não está inicializado.
Decrement<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Faz um decremento num tensor.
Decrement<T>(ReadOnlyTensorSpan<T>)

Faz um decremento num tensor.
DegreesToRadians<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Calcula a conversão elemento de cada número de graus no tensor especificado para radianos e retorna um novo tensor com os resultados.
DegreesToRadians<T>(ReadOnlyTensorSpan<T>)

Calcula a conversão elemento de cada número de graus no tensor especificado para radianos e retorna um novo tensor com os resultados.
Distance<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

Calcula a distância entre dois pontos, especificada como tensores de números não vazios e de comprimento igual, no espaço euclidiano.
Divide<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)

Realiza divisão elemento a elemento entre dois tensores.
Divide<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

Realiza divisão elemento a elemento entre dois tensores.
Divide<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<T>)

Realiza a divisão elemento a elemento entre um tensor e um escalar.
Divide<T>(ReadOnlyTensorSpan<T>, T)

Realiza a divisão elemento a elemento entre um tensor e um escalar.
Divide<T>(T, ReadOnlyTensorSpan<T>, TensorSpan<T>)

Realiza a divisão elemento a elemento entre um tensor e um escalar.
Divide<T>(T, ReadOnlyTensorSpan<T>)

Realiza a divisão elemento a elemento entre um tensor e um escalar.
Dot<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

Calcula o produto escalar de dois tensores que contêm números.
Equals<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<Boolean>)

Compara os elementos de dois ReadOnlyTensorSpan<T> para igualdade. Se as formas não forem iguais, os tensores são transmitidos para o menor tamanho possível antes de serem comparados. Devolve a TensorSpan<T> onde o valor é verdadeiro se os elementos forem iguais e falso se não forem." />
Equals<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

Compara os elementos de dois ReadOnlyTensorSpan<T> para igualdade. Se as formas não forem iguais, os tensores são transmitidos para o menor tamanho possível antes de serem comparados. Devolve a TensorSpan<T> onde o valor é verdadeiro se os elementos forem iguais e falso se não forem." />
Equals<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<Boolean>)

Compara os elementos de dois ReadOnlyTensorSpan<T> para igualdade. Se as formas não forem iguais, os tensores são transmitidos para o menor tamanho possível antes de serem comparados. Devolve a TensorSpan<T> onde o valor é verdadeiro se os elementos forem iguais e falso se não forem." />
Equals<T>(ReadOnlyTensorSpan<T>, T)

Compara os elementos de dois ReadOnlyTensorSpan<T> para igualdade. Se as formas não forem iguais, os tensores são transmitidos para o menor tamanho possível antes de serem comparados. Devolve a TensorSpan<T> onde o valor é verdadeiro se os elementos forem iguais e falso se não forem." />
EqualsAll<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

Compara os elementos de dois ReadOnlyTensorSpan<T> para ver se todos os elementos de x são iguais a y. Se as formas não forem iguais, os tensores são transmitidos para o menor tamanho possível antes de serem comparados. Devolve a Boolean onde o valor é verdadeiro se todos os elementos em x forem equivalentes a y.
EqualsAll<T>(ReadOnlyTensorSpan<T>, T)

Compara os elementos de dois ReadOnlyTensorSpan<T> para ver se todos os elementos de x são iguais a y. Se as formas não forem iguais, os tensores são transmitidos para o menor tamanho possível antes de serem comparados. Devolve a Boolean onde o valor é verdadeiro se todos os elementos em x forem equivalentes a y.
EqualsAny<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

Compara os elementos de dois ReadOnlyTensorSpan<T> para ver se algum elemento de x é igual a y. Se as formas não forem iguais, os tensores são transmitidos para o menor tamanho possível antes de serem comparados. Devolve a Boolean onde o valor é verdadeiro se quaisquer elementos em x forem iguais a y.
EqualsAny<T>(ReadOnlyTensorSpan<T>, T)

Compara os elementos de dois ReadOnlyTensorSpan<T> para ver se algum elemento de x é igual a y. Se as formas não forem iguais, os tensores são transmitidos para o menor tamanho possível antes de serem comparados. Devolve a Boolean onde o valor é verdadeiro se quaisquer elementos em x forem iguais a y.
Exp<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Calcula o resultado elemento a elemento de elevar e para as potências de ponto flutuante de precisão simples no tensor especificado.
Exp<T>(ReadOnlyTensorSpan<T>)

Calcula o resultado elemento a elemento de elevar e para as potências de ponto flutuante de precisão simples no tensor especificado.
Exp10<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Calcula o resultado elemento a elemento de elevar 10 para as potências numéricas no tensor especificado.
Exp10<T>(ReadOnlyTensorSpan<T>)

Calcula o resultado elemento a elemento de elevar 10 para as potências numéricas no tensor especificado.
Exp10M1<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Calcula o resultado elemento a elemento de elevar 10 para as potências numéricas no tensor especificado, menos um.
Exp10M1<T>(ReadOnlyTensorSpan<T>)

Calcula o resultado elemento a elemento de elevar 10 para as potências numéricas no tensor especificado, menos um.
Exp2<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Calcula o resultado elemento a elemento de elevar 2 para as potências numéricas no tensor especificado.
Exp2<T>(ReadOnlyTensorSpan<T>)

Calcula o resultado elemento a elemento de elevar 2 para as potências numéricas no tensor especificado.
Exp2M1<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Calcula o resultado elemento a elemento de elevar 2 para as potências numéricas no tensor especificado, menos um.
Exp2M1<T>(ReadOnlyTensorSpan<T>)

Calcula o resultado elemento a elemento de elevar 2 para as potências numéricas no tensor especificado, menos um.
ExpM1<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Calcula o resultado elemento a elemento de elevar e para as potências numéricas no tensor especificado, menos 1.
ExpM1<T>(ReadOnlyTensorSpan<T>)

Calcula o resultado elemento a elemento de elevar e para as potências numéricas no tensor especificado, menos 1.
FillGaussianNormalDistribution<T>(TensorSpan<T>, Random)

Preenche o dado TensorSpan<T> com dados aleatórios numa distribuição normal gaussiana. Random pode ser fornecida opcionalmente para a sementeira.
FillUniformDistribution<T>(TensorSpan<T>, Random)

Preenche o dado TensorSpan<T> com dados aleatórios numa distribuição uniforme. Random pode ser fornecida opcionalmente para a sementeira.
FilteredUpdate<T>(TensorSpan<T>, ReadOnlyTensorSpan<Boolean>, ReadOnlyTensorSpan<T>)

Atualiza o tensor tensor com onde values é verdadeiro filter . Se as dimensões não forem iguais, é lançada uma exceção.
FilteredUpdate<T>(TensorSpan<T>, ReadOnlyTensorSpan<Boolean>, T)

Atualiza o tensor tensor com onde value é verdadeiro filter .
Floor<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Calcula o piso elemento a elemento dos números no tensor especificado.
Floor<T>(ReadOnlyTensorSpan<T>)

Calcula o piso elemento a elemento dos números no tensor especificado.
GreaterThan<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<Boolean>)

Compara os elementos de dois ReadOnlyTensorSpan<T> para ver quais os elementos de x que são maiores que y. Se as formas não forem iguais, os tensores são transmitidos para o menor tamanho possível antes de serem comparados. Devolve a Tensor<T> onde o valor é verdadeiro se os elementos em x forem maiores que y e falso se não forem." />
GreaterThan<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

Compara os elementos de dois ReadOnlyTensorSpan<T> para ver quais os elementos de x que são maiores que y. Se as formas não forem iguais, os tensores são transmitidos para o menor tamanho possível antes de serem comparados. Devolve a Tensor<T> onde o valor é verdadeiro se os elementos em x forem maiores que y e falso se não forem." />
GreaterThan<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<Boolean>)

Compara os elementos de a ReadOnlyTensorSpan<T> para ver quais são maiores que y. Devolve a Tensor<T> onde o valor é verdadeiro se os elementos em x forem maiores que y e falso se não forem." />
GreaterThan<T>(ReadOnlyTensorSpan<T>, T)

Compara os elementos de a ReadOnlyTensorSpan<T> para ver quais são maiores que y. Devolve a Tensor<T> onde o valor é verdadeiro se os elementos em x forem maiores que y e falso se não forem." />
GreaterThan<T>(T, ReadOnlyTensorSpan<T>, TensorSpan<Boolean>)

Compara x para ver quais os elementos que são maiores que y. Devolve a Tensor<T> onde o valor é verdadeiro se os elementos em x forem maiores que y e falso se não forem." />
GreaterThan<T>(T, ReadOnlyTensorSpan<T>)

Compara x para ver quais os elementos que são maiores que y. Devolve a Tensor<T> onde o valor é verdadeiro se os elementos em x forem maiores que y e falso se não forem." />
GreaterThanAll<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

Compara os elementos de dois ReadOnlyTensorSpan<T> para ver se todos os elementos de x são maiores que y. Se as formas não forem iguais, os tensores são transmitidos para o menor tamanho possível antes de serem comparados. Devolve a Boolean onde o valor é verdadeiro se todos os elementos em x forem maiores que y.
GreaterThanAll<T>(ReadOnlyTensorSpan<T>, T)

Compara os elementos de dois ReadOnlyTensorSpan<T> para ver se todos os elementos de x são maiores que y. Se as formas não forem iguais, os tensores são transmitidos para o menor tamanho possível antes de serem comparados. Devolve a Boolean onde o valor é verdadeiro se todos os elementos em x forem maiores que y.
GreaterThanAll<T>(T, ReadOnlyTensorSpan<T>)

Compara os elementos de dois ReadOnlyTensorSpan<T> para ver se todos os elementos de y são maiores que y. Se as formas não forem iguais, os tensores são transmitidos para o menor tamanho possível antes de serem comparados. Devolve a Boolean onde o valor é verdadeiro se todos os elementos em y forem maiores que y.
GreaterThanAny<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

Compara os elementos de dois ReadOnlyTensorSpan<T> para ver se algum elemento de x é maior que y. Se as formas não forem iguais, os tensores são transmitidos para o menor tamanho possível antes de serem comparados. Devolve a Boolean onde o valor é verdadeiro se quaisquer elementos em x forem maiores que y.
GreaterThanAny<T>(ReadOnlyTensorSpan<T>, T)

Compara os elementos de dois ReadOnlyTensorSpan<T> para ver se algum elemento de x é maior que y. Se as formas não forem iguais, os tensores são transmitidos para o menor tamanho possível antes de serem comparados. Devolve a Boolean onde o valor é verdadeiro se quaisquer elementos em x forem maiores que y.
GreaterThanAny<T>(T, ReadOnlyTensorSpan<T>)

Compara os elementos de dois ReadOnlyTensorSpan<T> para ver se algum elemento de y é maior que x. Se as formas não forem iguais, os tensores são transmitidos para o menor tamanho possível antes de serem comparados. Devolve a Boolean onde o valor é verdadeiro se quaisquer elementos em y forem maiores que x.
GreaterThanOrEqual<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<Boolean>)

Compara os elementos de dois ReadOnlyTensorSpan<T> para ver quais os elementos de x que são maiores ou iguais a y. Se as formas não forem iguais, os tensores são transmitidos para o menor tamanho possível antes de serem comparados. Devolve a Tensor<T> onde o valor é verdadeiro se os elementos em x forem maiores que y e falso se não forem." />
GreaterThanOrEqual<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

Compara os elementos de dois ReadOnlyTensorSpan<T> para ver quais os elementos de x que são maiores ou iguais a y. Se as formas não forem iguais, os tensores são transmitidos para o menor tamanho possível antes de serem comparados. Devolve a Tensor<T> onde o valor é verdadeiro se os elementos em x forem maiores que y e falso se não forem." />
GreaterThanOrEqual<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<Boolean>)

Compara os elementos de a ReadOnlyTensorSpan<T> para ver quais são maiores ou iguais a y. Devolve a Tensor<T> onde o valor é verdadeiro se os elementos em x forem maiores que y e falso se não forem." />
GreaterThanOrEqual<T>(ReadOnlyTensorSpan<T>, T)

Compara os elementos de a ReadOnlyTensorSpan<T> para ver quais são maiores ou iguais a y. Devolve a Tensor<T> onde o valor é verdadeiro se os elementos em x forem maiores que y e falso se não forem." />
GreaterThanOrEqual<T>(T, ReadOnlyTensorSpan<T>, TensorSpan<Boolean>)

Compara x para ver quais os elementos que são maiores ou iguais a y. Devolve a Tensor<T> onde o valor é verdadeiro se os elementos em x forem maiores que y e falso se não forem." />
GreaterThanOrEqual<T>(T, ReadOnlyTensorSpan<T>)

Compara x para ver quais os elementos que são maiores ou iguais a y. Devolve a Tensor<T> onde o valor é verdadeiro se os elementos em x forem maiores que y e falso se não forem." />
GreaterThanOrEqualAll<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

Compara os elementos de dois ReadOnlyTensorSpan<T> para ver se todos os elementos de x são maiores que y. Se as formas não forem iguais, os tensores são transmitidos para o menor tamanho possível antes de serem comparados. Devolve a Boolean onde o valor é verdadeiro se todos os elementos em x forem maiores que y.
GreaterThanOrEqualAll<T>(ReadOnlyTensorSpan<T>, T)

Compara os elementos de dois ReadOnlyTensorSpan<T> para ver se todos os elementos de x são maiores que y. Se as formas não forem iguais, os tensores são transmitidos para o menor tamanho possível antes de serem comparados. Devolve a Boolean onde o valor é verdadeiro se todos os elementos em x forem maiores que y.
GreaterThanOrEqualAll<T>(T, ReadOnlyTensorSpan<T>)

Compara os elementos de dois ReadOnlyTensorSpan<T> para ver se todos os elementos de y são maiores que y. Se as formas não forem iguais, os tensores são transmitidos para o menor tamanho possível antes de serem comparados. Devolve a Boolean onde o valor é verdadeiro se todos os elementos em y forem maiores que y.
GreaterThanOrEqualAny<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

Compara os elementos de dois ReadOnlyTensorSpan<T> para ver se algum elemento de x é maior que y. Se as formas não forem iguais, os tensores são transmitidos para o menor tamanho possível antes de serem comparados. Devolve a Boolean onde o valor é verdadeiro se quaisquer elementos em x forem maiores que y.
GreaterThanOrEqualAny<T>(ReadOnlyTensorSpan<T>, T)

Compara os elementos de dois ReadOnlyTensorSpan<T> para ver se algum elemento de x é maior que y. Se as formas não forem iguais, os tensores são transmitidos para o menor tamanho possível antes de serem comparados. Devolve a Boolean onde o valor é verdadeiro se quaisquer elementos em x forem maiores que y.
GreaterThanOrEqualAny<T>(T, ReadOnlyTensorSpan<T>)

Compara os elementos de dois ReadOnlyTensorSpan<T> para ver se algum elemento de y é maior que x. Se as formas não forem iguais, os tensores são transmitidos para o menor tamanho possível antes de serem comparados. Devolve a Boolean onde o valor é verdadeiro se quaisquer elementos em y forem maiores que x.
Hypot<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)

Calcula a hipotenusa elemento a elemento dados a partir de dois tensores que representam os comprimentos dos lados mais curtos num triângulo retângulo. Se as formas não forem iguais, são transmitidas para a forma mais pequena e compatível.
Hypot<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

Calcula a hipotenusa elemento a elemento dados a partir de dois tensores que representam os comprimentos dos lados mais curtos num triângulo retângulo. Se as formas não forem iguais, são transmitidas para a forma mais pequena e compatível.
Ieee754Remainder<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)

Calcula o restante elemento a elemento dos números nos tensores especificados.
Ieee754Remainder<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

Calcula o restante elemento a elemento dos números nos tensores especificados.
Ieee754Remainder<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<T>)

Calcula o restante elemento a elemento dos números nos tensores especificados.
Ieee754Remainder<T>(ReadOnlyTensorSpan<T>, T)

Calcula o restante elemento a elemento dos números nos tensores especificados.
Ieee754Remainder<T>(T, ReadOnlyTensorSpan<T>, TensorSpan<T>)

Calcula o restante elemento a elemento dos números nos tensores especificados.
Ieee754Remainder<T>(T, ReadOnlyTensorSpan<T>)

Calcula o restante elemento a elemento dos números nos tensores especificados.
ILogB<T>(ReadOnlyTensorSpan<T>, TensorSpan<Int32>)

Calcula o logaritmo inteiro elemento a elemento dos números no tensor especificado.
ILogB<T>(ReadOnlyTensorSpan<T>)

Calcula o logaritmo inteiro elemento a elemento dos números no tensor especificado.
Increment<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Faz um incremento num tensor.
Increment<T>(ReadOnlyTensorSpan<T>)

Faz um incremento num tensor.
IndexOfMax<T>(ReadOnlyTensorSpan<T>)

Pesquisa pelo índice do maior número no tensor especificado.
IndexOfMaxMagnitude<T>(ReadOnlyTensorSpan<T>)

Procura o índice do número com a maior magnitude no tensor especificado.
IndexOfMin<T>(ReadOnlyTensorSpan<T>)

Procura o índice do menor número no tensor especificado.
IndexOfMinMagnitude<T>(ReadOnlyTensorSpan<T>)

Procura o índice do número com a menor magnitude no tensor especificado.
LeadingZeroCount<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Calcula a contagem de zero à esquerda elemento dos números no tensor especificado.
LeadingZeroCount<T>(ReadOnlyTensorSpan<T>)

Calcula a contagem de zero à esquerda elemento dos números no tensor especificado.
LessThan<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<Boolean>)

Compara os elementos de dois ReadOnlyTensorSpan<T> para ver quais os elementos de x que são menores que y. Se as formas não forem iguais, os tensores são transmitidos para o menor tamanho possível antes de serem comparados. Devolve a Tensor<T> onde o valor é verdadeiro se os elementos em x forem menores que y e falso se não forem." />
LessThan<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

Compara os elementos de dois ReadOnlyTensorSpan<T> para ver quais os elementos de x que são menores que y. Se as formas não forem iguais, os tensores são transmitidos para o menor tamanho possível antes de serem comparados. Devolve a Tensor<T> onde o valor é verdadeiro se os elementos em x forem menores que y e falso se não forem." />
LessThan<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<Boolean>)

Compara os elementos de a Tensor<T> para ver quais são menores que y. Devolve a Tensor<T> onde o valor é verdadeiro se os elementos em x forem menores que y e falso se não forem." />
LessThan<T>(ReadOnlyTensorSpan<T>, T)

Compara os elementos de a Tensor<T> para ver quais são menores que y. Devolve a Tensor<T> onde o valor é verdadeiro se os elementos em x forem menores que y e falso se não forem." />
LessThan<T>(T, ReadOnlyTensorSpan<T>, TensorSpan<Boolean>)

Compara os elementos de a Tensor<T> para ver quais são menores que y. Devolve a Tensor<T> onde o valor é verdadeiro se os elementos em x forem menores que y e falso se não forem." />
LessThan<T>(T, ReadOnlyTensorSpan<T>)

Compara os elementos de a Tensor<T> para ver quais são menores que y. Devolve a Tensor<T> onde o valor é verdadeiro se os elementos em x forem menores que y e falso se não forem." />
LessThanAll<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

Compara os elementos de dois ReadOnlyTensorSpan<T> para ver se todos os elementos de x são menores que y. Se as formas não forem iguais, os tensores são transmitidos para o menor tamanho possível antes de serem comparados. Devolve a Boolean onde o valor é verdadeiro se todos os elementos em x forem menores que y.
LessThanAll<T>(ReadOnlyTensorSpan<T>, T)

Compara os elementos de dois ReadOnlyTensorSpan<T> para ver se todos os elementos de x são menores que y. Se as formas não forem iguais, os tensores são transmitidos para o menor tamanho possível antes de serem comparados. Devolve a Boolean onde o valor é verdadeiro se todos os elementos em x forem menores que y.
LessThanAll<T>(T, ReadOnlyTensorSpan<T>)

Compara os elementos de dois ReadOnlyTensorSpan<T> para ver se todos os elementos de y são menores que x. Se as formas não forem iguais, os tensores são transmitidos para o menor tamanho possível antes de serem comparados. Devolve a Boolean onde o valor é verdadeiro se todos os elementos em y forem menores que x.
LessThanAny<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

Compara os elementos de dois ReadOnlyTensorSpan<T> para ver se algum elemento de x é menor que y. Se as formas não forem iguais, os tensores são transmitidos para o menor tamanho possível antes de serem comparados. Devolve a Boolean onde o valor é verdadeiro se quaisquer elementos em x forem menores que y.
LessThanAny<T>(ReadOnlyTensorSpan<T>, T)

Compara os elementos de dois ReadOnlyTensorSpan<T> para ver se algum elemento de x é menor que y. Se as formas não forem iguais, os tensores são transmitidos para o menor tamanho possível antes de serem comparados. Devolve a Boolean onde o valor é verdadeiro se quaisquer elementos em x forem menores que y.
LessThanAny<T>(T, ReadOnlyTensorSpan<T>)

Compara os elementos de dois ReadOnlyTensorSpan<T> para ver se algum elemento de y é menor que y. Se as formas não forem iguais, os tensores são transmitidos para o menor tamanho possível antes de serem comparados. Devolve a Boolean onde o valor é verdadeiro se quaisquer elementos em y forem menores que y.
LessThanOrEqual<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<Boolean>)

Compara os elementos de dois ReadOnlyTensorSpan<T> para ver quais os elementos de x que são menores que y. Se as formas não forem iguais, os tensores são transmitidos para o menor tamanho possível antes de serem comparados. Devolve a Tensor<T> onde o valor é verdadeiro se os elementos em x forem menores que y e falso se não forem." />
LessThanOrEqual<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

Compara os elementos de dois ReadOnlyTensorSpan<T> para ver quais os elementos de x que são menores que y. Se as formas não forem iguais, os tensores são transmitidos para o menor tamanho possível antes de serem comparados. Devolve a Tensor<T> onde o valor é verdadeiro se os elementos em x forem menores que y e falso se não forem." />
LessThanOrEqual<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<Boolean>)

Compara os elementos de a Tensor<T> para ver quais são menores que y. Devolve a Tensor<T> onde o valor é verdadeiro se os elementos em x forem menores que y e falso se não forem." />
LessThanOrEqual<T>(ReadOnlyTensorSpan<T>, T)

Compara os elementos de a Tensor<T> para ver quais são menores que y. Devolve a Tensor<T> onde o valor é verdadeiro se os elementos em x forem menores que y e falso se não forem." />
LessThanOrEqual<T>(T, ReadOnlyTensorSpan<T>, TensorSpan<Boolean>)

Compara os elementos de a Tensor<T> para ver quais são menores que y. Devolve a Tensor<T> onde o valor é verdadeiro se os elementos em x forem menores que y e falso se não forem." />
LessThanOrEqual<T>(T, ReadOnlyTensorSpan<T>)

Compara os elementos de a Tensor<T> para ver quais são menores que y. Devolve a Tensor<T> onde o valor é verdadeiro se os elementos em x forem menores que y e falso se não forem." />
LessThanOrEqualAll<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

Compara os elementos de dois ReadOnlyTensorSpan<T> para ver se todos os elementos de x são menores que y. Se as formas não forem iguais, os tensores são transmitidos para o menor tamanho possível antes de serem comparados. Devolve a Boolean onde o valor é verdadeiro se todos os elementos em x forem menores que y.
LessThanOrEqualAll<T>(ReadOnlyTensorSpan<T>, T)

Compara os elementos de dois ReadOnlyTensorSpan<T> para ver se todos os elementos de x são menores que y. Se as formas não forem iguais, os tensores são transmitidos para o menor tamanho possível antes de serem comparados. Devolve a Boolean onde o valor é verdadeiro se todos os elementos em x forem menores que y.
LessThanOrEqualAll<T>(T, ReadOnlyTensorSpan<T>)

Compara os elementos de dois ReadOnlyTensorSpan<T> para ver se todos os elementos de y são menores que x. Se as formas não forem iguais, os tensores são transmitidos para o menor tamanho possível antes de serem comparados. Devolve a Boolean onde o valor é verdadeiro se todos os elementos em y forem menores que x.
LessThanOrEqualAny<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

Compara os elementos de dois ReadOnlyTensorSpan<T> para ver se algum elemento de x é menor que y. Se as formas não forem iguais, os tensores são transmitidos para o menor tamanho possível antes de serem comparados. Devolve a Boolean onde o valor é verdadeiro se quaisquer elementos em x forem menores que y.
LessThanOrEqualAny<T>(ReadOnlyTensorSpan<T>, T)

Compara os elementos de dois ReadOnlyTensorSpan<T> para ver se algum elemento de x é menor que y. Se as formas não forem iguais, os tensores são transmitidos para o menor tamanho possível antes de serem comparados. Devolve a Boolean onde o valor é verdadeiro se quaisquer elementos em x forem menores que y.
LessThanOrEqualAny<T>(T, ReadOnlyTensorSpan<T>)

Compara os elementos de dois ReadOnlyTensorSpan<T> para ver se algum elemento de y é menor que y. Se as formas não forem iguais, os tensores são transmitidos para o menor tamanho possível antes de serem comparados. Devolve a Boolean onde o valor é verdadeiro se quaisquer elementos em y forem menores que y.
Log<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)

Calcula o logaritmo elemento a elemento dos números num tensor especificado para a base especificada noutro tensor especificado.
Log<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

Calcula o logaritmo elemento a elemento dos números num tensor especificado para a base especificada noutro tensor especificado.
Log<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<T>)

Calcula o logaritmo elemento a elemento dos números num tensor especificado para a base especificada noutro tensor especificado.
Log<T>(ReadOnlyTensorSpan<T>, T)

Calcula o logaritmo elemento a elemento dos números num tensor especificado para a base especificada noutro tensor especificado.
Log<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Toma o logaritmo natural de cada elemento do ReadOnlyTensorSpan<T> e devolve um novo TensorSpan<T> com o resultado.
Log<T>(ReadOnlyTensorSpan<T>)

Toma o logaritmo natural de cada elemento do ReadOnlyTensorSpan<T> e devolve um novo Tensor<T> com o resultado.
Log10<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Toma o logaritmo base 10 de cada elemento de e ReadOnlyTensorSpan<T> retorna um novo TensorSpan<T> com o resultado.
Log10<T>(ReadOnlyTensorSpan<T>)

Toma o logaritmo base 10 de cada elemento de e ReadOnlyTensorSpan<T> retorna um novo Tensor<T> com o resultado.
Log10P1<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Toma o logaritmo base 10 mais 1 de cada elemento do ReadOnlyTensorSpan<T> e devolve um novo TensorSpan<T> com o resultado.
Log10P1<T>(ReadOnlyTensorSpan<T>)

Toma o logaritmo base 10 mais 1 de cada elemento do ReadOnlyTensorSpan<T> e devolve um novo Tensor<T> com o resultado.
Log2<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Toma o logaritmo base 2 de cada elemento do ReadOnlyTensorSpan<T> e devolve um novo TensorSpan<T> com o resultado.
Log2<T>(ReadOnlyTensorSpan<T>)

Toma o logaritmo base 2 de cada elemento do ReadOnlyTensorSpan<T> e devolve um novo Tensor<T> com o resultado.
Log2P1<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Toma o logaritmo base 2 mais 1 de cada elemento do ReadOnlyTensorSpan<T> e devolve um novo TensorSpan<T> com o resultado.
Log2P1<T>(ReadOnlyTensorSpan<T>)

Toma o logaritmo base 2 mais 1 de cada elemento do ReadOnlyTensorSpan<T> e devolve um novo Tensor<T> com o resultado.
LogP1<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Toma o logaritmo natural mais 1 de cada elemento do ReadOnlyTensorSpan<T> e retorna um novo TensorSpan<T> com o resultado.
LogP1<T>(ReadOnlyTensorSpan<T>)

Toma o logaritmo natural mais 1 de cada elemento do ReadOnlyTensorSpan<T> e retorna um novo Tensor<T> com o resultado.
Max<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)

Calcula o máximo elemento a elemento dos números nos tensores especificados.
Max<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

Calcula o máximo elemento a elemento dos números nos tensores especificados.
Max<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<T>)

Calcula o máximo elemento a elemento dos números nos tensores especificados.
Max<T>(ReadOnlyTensorSpan<T>, T)

Calcula o máximo elemento a elemento dos números nos tensores especificados.
Max<T>(ReadOnlyTensorSpan<T>)

Procura o maior número no tensor especificado.
MaxMagnitude<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)

Calcula o número elemento a elemento com a maior magnitude nos tensores especificados.
MaxMagnitude<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

Calcula o número elemento a elemento com a maior magnitude nos tensores especificados.
MaxMagnitude<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<T>)

Calcula o número elemento a elemento com a maior magnitude nos tensores especificados.
MaxMagnitude<T>(ReadOnlyTensorSpan<T>, T)

Calcula o número elemento a elemento com a maior magnitude nos tensores especificados.
MaxMagnitude<T>(ReadOnlyTensorSpan<T>)

Procura o número com a maior magnitude no tensor especificado.
MaxMagnitudeNumber<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)

Calcula o número elemento a elemento com a maior magnitude nos tensores especificados.
MaxMagnitudeNumber<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

Calcula o número elemento a elemento com a maior magnitude nos tensores especificados.
MaxMagnitudeNumber<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<T>)

Calcula o número elemento a elemento com a maior magnitude nos tensores especificados.
MaxMagnitudeNumber<T>(ReadOnlyTensorSpan<T>, T)

Calcula o número elemento a elemento com a maior magnitude nos tensores especificados.
MaxMagnitudeNumber<T>(ReadOnlyTensorSpan<T>)

Procura o número com a maior magnitude no tensor especificado.
MaxNumber<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)

Calcula o máximo elemento a elemento dos números nos tensores especificados.
MaxNumber<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

Calcula o máximo elemento a elemento dos números nos tensores especificados.
MaxNumber<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<T>)

Calcula o máximo elemento a elemento dos números nos tensores especificados.
MaxNumber<T>(ReadOnlyTensorSpan<T>, T)

Calcula o máximo elemento a elemento dos números nos tensores especificados.
MaxNumber<T>(ReadOnlyTensorSpan<T>)

Procura o maior número no tensor especificado.
Min<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)

Calcula o mínimo elemento a elemento dos números nos tensores especificados.
Min<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

Calcula o mínimo elemento a elemento dos números nos tensores especificados.
Min<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<T>)

Calcula o mínimo elemento a elemento dos números nos tensores especificados.
Min<T>(ReadOnlyTensorSpan<T>, T)

Calcula o mínimo elemento a elemento dos números nos tensores especificados.
Min<T>(ReadOnlyTensorSpan<T>)

Procura o menor número no tensor especificado.
MinMagnitude<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)

Calcula o número elemento a elemento com a menor magnitude nos tensores especificados.
MinMagnitude<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

Calcula o número elemento a elemento com a menor magnitude nos tensores especificados.
MinMagnitude<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<T>)

Calcula o número elemento a elemento com a menor magnitude nos tensores especificados.
MinMagnitude<T>(ReadOnlyTensorSpan<T>, T)

Calcula o número elemento a elemento com a menor magnitude nos tensores especificados.
MinMagnitude<T>(ReadOnlyTensorSpan<T>)

Procura o número com a menor magnitude no tensor especificado.
MinMagnitudeNumber<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)

Calcula o número elemento a elemento com a menor magnitude nos tensores especificados.
MinMagnitudeNumber<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

Calcula o número elemento a elemento com a menor magnitude nos tensores especificados.
MinMagnitudeNumber<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<T>)

Calcula o número elemento a elemento com a menor magnitude nos tensores especificados.
MinMagnitudeNumber<T>(ReadOnlyTensorSpan<T>, T)

Calcula o número elemento a elemento com a menor magnitude nos tensores especificados.
MinMagnitudeNumber<T>(ReadOnlyTensorSpan<T>)

Procura o número com a menor magnitude no tensor especificado.
MinNumber<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)

Calcula o mínimo elemento a elemento dos números nos tensores especificados.
MinNumber<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

Calcula o mínimo elemento a elemento dos números nos tensores especificados.
MinNumber<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<T>)

Calcula o mínimo elemento a elemento dos números nos tensores especificados.
MinNumber<T>(ReadOnlyTensorSpan<T>, T)

Calcula o mínimo elemento a elemento dos números nos tensores especificados.
MinNumber<T>(ReadOnlyTensorSpan<T>)

Procura o menor número no tensor especificado.
Multiply<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)

Realiza multiplicação elemento a elemento entre dois tensores.
Multiply<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

Realiza multiplicação elemento a elemento entre dois tensores.
Multiply<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<T>)

Realiza a multiplicação elemento a elemento entre um tensor e um escalar.
Multiply<T>(ReadOnlyTensorSpan<T>, T)

Realiza a multiplicação elemento a elemento entre um tensor e um escalar.
Negate<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Realiza uma negação unária elemento a elemento sobre um tensor.
Negate<T>(ReadOnlyTensorSpan<T>)

Realiza uma negação unária elemento a elemento sobre um tensor.
Norm<T>(ReadOnlyTensorSpan<T>)

Toma a norma do ReadOnlyTensorSpan<T> e devolve o resultado.
OnesComplement<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Faz o complemento de um um tensor.
OnesComplement<T>(ReadOnlyTensorSpan<T>)

Faz o complemento de um um tensor.
PermuteDimensions<T>(Tensor<T>, ReadOnlySpan<Int32>)

Troca as dimensões do tensor tensor de acordo com o dimensions parâmetro. Se tensor for um tensor 1D, devolverá tensor. Caso contrário, cria uma nova Tensor<T> com a nova ordem dos eixos ao alocar nova memória.
PopCount<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Calcula a contagem elemental da população dos números no tensor especificado.
PopCount<T>(ReadOnlyTensorSpan<T>)

Calcula a contagem elemental da população dos números no tensor especificado.
Pow<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)

Calcula a potência elemento a elemento de um número num tensor especificado elevado para um número noutro tensor especificado.
Pow<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

Calcula a potência elemento a elemento de um número num tensor especificado elevado para um número noutro tensor especificado.
Pow<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<T>)

Calcula a potência elemento a elemento de um número num tensor especificado elevado para um número noutro tensor especificado.
Pow<T>(ReadOnlyTensorSpan<T>, T)

Calcula a potência elemento a elemento de um número num tensor especificado elevado para um número noutro tensor especificado.
Pow<T>(T, ReadOnlyTensorSpan<T>, TensorSpan<T>)

Calcula a potência elemento a elemento de um número num tensor especificado elevado para um número noutro tensor especificado.
Pow<T>(T, ReadOnlyTensorSpan<T>)

Calcula a potência elemento a elemento de um número num tensor especificado elevado para um número noutro tensor especificado.
Product<T>(ReadOnlyTensorSpan<T>)

Calcula o produto de todos os elementos no tensor não vazio especificado de números.
RadiansToDegrees<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Calcula a conversão elemento a elemento de cada número de radianos no tensor especificado em graus.
RadiansToDegrees<T>(ReadOnlyTensorSpan<T>)

Calcula a conversão elemento a elemento de cada número de radianos no tensor especificado em graus.
Reciprocal<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Calcula o recíproco elemento a elemento dos números no tensor especificado.
Reciprocal<T>(ReadOnlyTensorSpan<T>)

Calcula o recíproco elemento a elemento dos números no tensor especificado.
Reshape<T>(ReadOnlyTensorSpan<T>, ReadOnlySpan<IntPtr>)

Remodela o tensor tensor para o especificado lengths. Se um dos comprimentos for -1, será calculado automaticamente. Não altera o comprimento da memória subjacente nem aloca nova memória. Se a nova forma não for compatível com a antiga, é feita uma exceção.
Reshape<T>(Tensor<T>, ReadOnlySpan<IntPtr>)

Remodela o tensor tensor para o especificado lengths. Se um dos comprimentos for -1, será calculado automaticamente. Não altera o comprimento da memória subjacente nem aloca nova memória. Se a nova forma não for compatível com a antiga, é feita uma exceção.
Reshape<T>(TensorSpan<T>, ReadOnlySpan<IntPtr>)

Remodela o tensor tensor para o especificado lengths. Se um dos comprimentos for -1, será calculado automaticamente. Não altera o comprimento da memória subjacente nem aloca nova memória. Se a nova forma não for compatível com a antiga, é feita uma exceção.
Resize<T>(Tensor<T>, ReadOnlySpan<IntPtr>)

Cria uma nova Tensor<T>, aloca nova memória e copia os dados de tensor. Se a forma final for menor, todos os dados posteriores a esse ponto são ignorados.
ResizeTo<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Copia os dados de tensor. Se a forma final for menor, todos os dados posteriores a esse ponto são ignorados. Se a forma final for maior, é preenchida com zeros.
ResizeTo<T>(Tensor<T>, TensorSpan<T>)

Copia os dados de tensor. Se a forma final for menor, todos os dados posteriores a esse ponto são ignorados. Se a forma final for maior, é preenchida com zeros.
ResizeTo<T>(TensorSpan<T>, TensorSpan<T>)

Copia os dados de tensor. Se a forma final for menor, todos os dados posteriores a esse ponto são ignorados. Se a forma final for maior, é preenchida com zeros.
Reverse<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Inverta a ordem dos elementos no tensor. A forma do tensor é preservada, mas os elementos são reordenados.
Reverse<T>(ReadOnlyTensorSpan<T>)

Inverta a ordem dos elementos no tensor. A forma do tensor é preservada, mas os elementos são reordenados.
ReverseDimension<T>(ReadOnlyTensorSpan<T>, Int32)

Inverta a ordem dos elementos em ao tensor longo da dimensão dada. A forma do tensor é preservada, mas os elementos são reordenados. dimension por defeito é -1 quando não é fornecido, o que inverte todo o tensor.
ReverseDimension<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>, Int32)

Inverta a ordem dos elementos ao tensor longo do eixo dado. A forma do tensor é preservada, mas os elementos são reordenados. dimension por defeito é -1 quando não é fornecido, o que inverte todo o intervalo.
RootN<T>(ReadOnlyTensorSpan<T>, Int32, TensorSpan<T>)

Calcula a raiz n-ésima elemental dos valores no tensor especificado.
RootN<T>(ReadOnlyTensorSpan<T>, Int32)

Calcula a raiz n-ésima elemental dos valores no tensor especificado.
RotateLeft<T>(ReadOnlyTensorSpan<T>, Int32, TensorSpan<T>)

Calcula a rotação elemento a elemento à esquerda dos números no tensor especificado pela quantidade de rotação especificada.
RotateLeft<T>(ReadOnlyTensorSpan<T>, Int32)

Calcula a rotação elemento a elemento à esquerda dos números no tensor especificado pela quantidade de rotação especificada.
RotateRight<T>(ReadOnlyTensorSpan<T>, Int32, TensorSpan<T>)

Calcula o direito de rotação elemento a elemento dos números no tensor especificado pela quantidade de rotação especificada.
RotateRight<T>(ReadOnlyTensorSpan<T>, Int32)

Calcula o direito de rotação elemento a elemento dos números no tensor especificado pela quantidade de rotação especificada.
Round<T>(ReadOnlyTensorSpan<T>, Int32, MidpointRounding, TensorSpan<T>)

Calcula o arredondamento elemento a elemento dos números no tensor especificado
Round<T>(ReadOnlyTensorSpan<T>, Int32, MidpointRounding)

Calcula o arredondamento elemento a elemento dos números no tensor especificado
Round<T>(ReadOnlyTensorSpan<T>, Int32, TensorSpan<T>)

Calcula o arredondamento elemento a elemento dos números no tensor especificado
Round<T>(ReadOnlyTensorSpan<T>, Int32)

Calcula o arredondamento elemento a elemento dos números no tensor especificado
Round<T>(ReadOnlyTensorSpan<T>, MidpointRounding, TensorSpan<T>)

Calcula o arredondamento elemento a elemento dos números no tensor especificado
Round<T>(ReadOnlyTensorSpan<T>, MidpointRounding)

Calcula o arredondamento elemento a elemento dos números no tensor especificado
Round<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Calcula o arredondamento elemento a elemento dos números no tensor especificado
Round<T>(ReadOnlyTensorSpan<T>)

Calcula o arredondamento elemento a elemento dos números no tensor especificado
SequenceEqual<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

Determina se duas sequências são iguais comparando os elementos usando IEquatable{T}. É igual a T.
SequenceEqual<T>(TensorSpan<T>, ReadOnlyTensorSpan<T>)

Determina se duas sequências são iguais comparando os elementos usando IEquatable{T}. É igual a T.
SetSlice<T>(Tensor<T>, ReadOnlyTensorSpan<T>, ReadOnlySpan<NRange>)

Define uma fatia do dado tensor com o fornecido values para o dado ranges
SetSlice<T>(TensorSpan<T>, ReadOnlyTensorSpan<T>, ReadOnlySpan<NRange>)

Define uma fatia do dado tensor com o fornecido values para o dado ranges
ShiftLeft<T>(ReadOnlyTensorSpan<T>, Int32, TensorSpan<T>)

Executa um deslocamento elemental à esquerda num tensor.
ShiftLeft<T>(ReadOnlyTensorSpan<T>, Int32)

Executa um deslocamento elemental à esquerda num tensor.
ShiftRightArithmetic<T>(ReadOnlyTensorSpan<T>, Int32, TensorSpan<T>)

Realiza um deslocamento aritmético à direita elemento a elemento num tensor.
ShiftRightArithmetic<T>(ReadOnlyTensorSpan<T>, Int32)

Realiza um deslocamento aritmético à direita elemento a elemento num tensor.
ShiftRightLogical<T>(ReadOnlyTensorSpan<T>, Int32, TensorSpan<T>)

Realiza um deslocamento lógico para a direita elemento a elemento num tensor.
ShiftRightLogical<T>(ReadOnlyTensorSpan<T>, Int32)

Realiza um deslocamento lógico para a direita elemento a elemento num tensor.
Sigmoid<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Calcula a função sigmoide elemento a elemento no tensor não vazio de números especificado.
Sigmoid<T>(ReadOnlyTensorSpan<T>)

Calcula a função sigmoide elemento a elemento no tensor não vazio de números especificado.
Sin<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Toma o pecado de cada elemento de e ReadOnlyTensorSpan<T> devolve um novo TensorSpan<T> com o resultado.
Sin<T>(ReadOnlyTensorSpan<T>)

Toma o pecado de cada elemento de e ReadOnlyTensorSpan<T> devolve um novo Tensor<T> com o resultado.
Sinh<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Calcula o seno hiperbólico elemento a elemento de cada ângulo de radiano no tensor especificado.
Sinh<T>(ReadOnlyTensorSpan<T>)

Calcula o seno hiperbólico elemento a elemento de cada ângulo de radiano no tensor especificado.
SinPi<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Calcula o seno elemento a elemento do valor no tensor especificado que foi multiplicado por Pi.
SinPi<T>(ReadOnlyTensorSpan<T>)

Calcula o seno elemento a elemento do valor no tensor especificado que foi multiplicado por Pi.
SoftMax<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Calcula a função softmax sobre o tensor não vazio especificado de números.
SoftMax<T>(ReadOnlyTensorSpan<T>)

Calcula a função softmax sobre o tensor não vazio especificado de números.
Split<T>(ReadOnlyTensorSpan<T>, Int32, IntPtr)

Divida a Tensor<T> em splitCount ao longo do dado dimension. Se o tensor não puder ser dividido igualmente no dado dimension é lançado uma exceção.
Sqrt<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Toma a raiz quadrada de cada elemento de e x devolve uma nova TensorSpan<T> com o resultado.
Sqrt<T>(ReadOnlyTensorSpan<T>)

Toma a raiz quadrada de cada elemento de e ReadOnlyTensorSpan<T> devolve uma nova Tensor<T> com o resultado.
Squeeze<T>(ReadOnlyTensorSpan<T>)

Remove todas as dimensões de comprimento um do tensor.
Squeeze<T>(Tensor<T>)

Remove todas as dimensões de comprimento um do tensor.
Squeeze<T>(TensorSpan<T>)

Remove todas as dimensões de comprimento um do tensor.
SqueezeDimension<T>(ReadOnlyTensorSpan<T>, Int32)

Remove o eixo de comprimento um do tensor para o dado dimension. Se a dimensão não for de comprimento um, lançará uma exceção.
SqueezeDimension<T>(Tensor<T>, Int32)

Remove o eixo de comprimento um do tensor para o dado dimension. Se a dimensão não for de comprimento um, lançará uma exceção.
SqueezeDimension<T>(TensorSpan<T>, Int32)

Remove o eixo de comprimento um do tensor para o dado dimension. Se a dimensão não for de comprimento um, lançará uma exceção.
Stack<T>(ReadOnlySpan<Tensor<T>>, TensorSpan<T>)

Juntar múltiplos Tensor<T> ao longo de uma nova dimensão que é adicionada na posição 0. Todos os tensores devem ter a mesma forma.
Stack<T>(ReadOnlySpan<Tensor<T>>)

Juntar múltiplos Tensor<T> ao longo de uma nova dimensão que é adicionada na posição 0. Todos os tensores devem ter a mesma forma.
StackAlongDimension<T>(Int32, ReadOnlySpan<Tensor<T>>)

Junta vários Tensor<T> numa nova dimensão. O parâmetro do eixo especifica o índice da nova dimensão. Todos os tensores devem ter a mesma forma.
StackAlongDimension<T>(ReadOnlySpan<Tensor<T>>, TensorSpan<T>, Int32)

Junta vários Tensor<T> numa nova dimensão. O parâmetro do eixo especifica o índice da nova dimensão. Todos os tensores devem ter a mesma forma.
StdDev<T>(ReadOnlyTensorSpan<T>)

Devolve o desvio padrão dos elementos no x tensor.
Subtract<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)

Realiza subtração elemento a elemento entre dois tensores.
Subtract<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

Realiza subtração elemento a elemento entre dois tensores.
Subtract<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<T>)

Realiza a subtração elemento a elemento entre um tensor e um escalar.
Subtract<T>(ReadOnlyTensorSpan<T>, T)

Realiza a subtração elemento a elemento entre um tensor e um escalar.
Subtract<T>(T, ReadOnlyTensorSpan<T>, TensorSpan<T>)

Realiza a subtração elemento a elemento entre um tensor e um escalar.
Subtract<T>(T, ReadOnlyTensorSpan<T>)

Realiza a subtração elemento a elemento entre um tensor e um escalar.
Sum<T>(ReadOnlyTensorSpan<T>)

Soma os elementos do tensor especificado.
Tan<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Calcula a tangente elemento a elemento do valor no tensor especificado.
Tan<T>(ReadOnlyTensorSpan<T>)

Calcula a tangente elemento a elemento do valor no tensor especificado.
Tanh<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Calcula a tangente hiperbólica elemento a elemento de cada ângulo radiano no tensor especificado.
Tanh<T>(ReadOnlyTensorSpan<T>)

Calcula a tangente hiperbólica elemento a elemento de cada ângulo radiano no tensor especificado.
TanPi<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Calcula a tangente elemento a elemento do valor no tensor especificado que foi multiplicado por Pi.
TanPi<T>(ReadOnlyTensorSpan<T>)

Calcula a tangente elemento a elemento do valor no tensor especificado que foi multiplicado por Pi.
TrailingZeroCount<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Calcula a contagem de zeros finais elemento a elemento dos números no tensor especificado.
TrailingZeroCount<T>(ReadOnlyTensorSpan<T>)

Calcula a contagem de zeros finais elemento a elemento dos números no tensor especificado.
Transpose<T>(Tensor<T>)

Troca as duas últimas dimensões do tensor tensor.
Truncate<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Calcula o truncamento elemento a elemento dos números no tensor especificado.
Truncate<T>(ReadOnlyTensorSpan<T>)

Calcula o truncamento elemento a elemento dos números no tensor especificado.
TryBroadcastTo<T>(ReadOnlyTensorSpan<T>, TensorSpan<T>)

Transmite os dados para tensor a forma mais pequena compatível e destination armazena-os em destination Se as formas não forem compatíveis, o false é devolvido.
TryBroadcastTo<T>(Tensor<T>, TensorSpan<T>)

Transmite os dados para tensor a forma mais pequena compatível e destination armazena-os em destination Se as formas não forem compatíveis, o false é devolvido.
TryBroadcastTo<T>(TensorSpan<T>, TensorSpan<T>)

Transmite os dados para tensor a forma mais pequena compatível e destination armazena-os em destination Se as formas não forem compatíveis, o false é devolvido.
Unsqueeze<T>(ReadOnlyTensorSpan<T>, Int32)

Insira uma nova dimensão de comprimento 1 que aparecerá na posição da dimensão.
Unsqueeze<T>(Tensor<T>, Int32)

Insira uma nova dimensão de comprimento 1 que aparecerá na posição da dimensão.
Unsqueeze<T>(TensorSpan<T>, Int32)

Insira uma nova dimensão de comprimento 1 que aparecerá na posição da dimensão.
Xor<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>, TensorSpan<T>)

Executa o ou exclusivo entre dois tensores.
Xor<T>(ReadOnlyTensorSpan<T>, ReadOnlyTensorSpan<T>)

Executa o ou exclusivo entre dois tensores.
Xor<T>(ReadOnlyTensorSpan<T>, T, TensorSpan<T>)

Executa o exclusivo-ou entre um tensor e um escalar.
Xor<T>(ReadOnlyTensorSpan<T>, T)

Executa o exclusivo-ou entre um tensor e um escalar.

Operadores

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

Realiza a adição elemento a elemento entre dois tensores.
Addition(ReadOnlyTensorSpan<TScalar>, TScalar)

Realiza adição elemento a elemento entre um tensor e um escalar.
Addition(Tensor<TScalar>, Tensor<TScalar>)

Realiza a adição elemento a elemento entre dois tensores.
Addition(Tensor<TScalar>, TScalar)

Realiza adição elemento a elemento entre um tensor e um escalar.
Addition(TensorSpan<TScalar>, TensorSpan<TScalar>)

Realiza a adição elemento a elemento entre dois tensores.
Addition(TensorSpan<TScalar>, TScalar)

Realiza adição elemento a elemento entre um tensor e um escalar.
Addition(TScalar, ReadOnlyTensorSpan<TScalar>)

Realiza adição elemento a elemento entre um tensor e um escalar.
Addition(TScalar, Tensor<TScalar>)

Realiza adição elemento a elemento entre um tensor e um escalar.
Addition(TScalar, TensorSpan<TScalar>)

Realiza adição elemento a elemento entre um tensor e um escalar.
Addition<TScalar>(ReadOnlyTensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)

Realiza a adição elemento a elemento entre dois tensores.
Addition<TScalar>(ReadOnlyTensorSpan<TScalar>, TScalar)

Realiza adição elemento a elemento entre um tensor e um escalar.
Addition<TScalar>(Tensor<TScalar>, Tensor<TScalar>)

Realiza a adição elemento a elemento entre dois tensores.
Addition<TScalar>(Tensor<TScalar>, TScalar)

Realiza adição elemento a elemento entre um tensor e um escalar.
Addition<TScalar>(TensorSpan<TScalar>, TensorSpan<TScalar>)

Realiza a adição elemento a elemento entre dois tensores.
Addition<TScalar>(TensorSpan<TScalar>, TScalar)

Realiza adição elemento a elemento entre um tensor e um escalar.
Addition<TScalar>(TScalar, ReadOnlyTensorSpan<TScalar>)

Realiza adição elemento a elemento entre um tensor e um escalar.
Addition<TScalar>(TScalar, Tensor<TScalar>)

Realiza adição elemento a elemento entre um tensor e um escalar.
Addition<TScalar>(TScalar, TensorSpan<TScalar>)

Realiza adição elemento a elemento entre um tensor e um escalar.
AdditionAssignment(ReadOnlyTensorSpan<TScalar>)

Realiza a adição elemento a elemento no local entre dois tensores.
AdditionAssignment(ReadOnlyTensorSpan<TScalar>)

Realiza a adição elemento a elemento no local entre dois tensores.
AdditionAssignment(TScalar)

Realiza a adição elemento a elemento no local entre um tensor e um escalar.
AdditionAssignment(TScalar)

Realiza a adição elemento a elemento no local entre um tensor e um escalar.
AdditionAssignment<TScalar>(Tensor<TScalar>, ReadOnlyTensorSpan<TScalar>)

Realiza a adição elemento a elemento no local entre dois tensores.
AdditionAssignment<TScalar>(Tensor<TScalar>, TScalar)

Realiza a adição elemento a elemento no local entre um tensor e um escalar.
AdditionAssignment<TScalar>(TensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)

Realiza a adição elemento a elemento no local entre dois tensores.
AdditionAssignment<TScalar>(TensorSpan<TScalar>, TScalar)

Realiza a adição elemento a elemento no local entre um tensor e um escalar.
BitwiseAnd(ReadOnlyTensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)

Executa bit a bit e entre dois tensores.
BitwiseAnd(ReadOnlyTensorSpan<TScalar>, TScalar)

Executa bit a bit e entre um tensor e um escalar.
BitwiseAnd(Tensor<TScalar>, Tensor<TScalar>)

Executa bit a bit e entre dois tensores.
BitwiseAnd(Tensor<TScalar>, TScalar)

Executa bit a bit e entre um tensor e um escalar.
BitwiseAnd(TensorSpan<TScalar>, TensorSpan<TScalar>)

Executa bit a bit e entre dois tensores.
BitwiseAnd(TensorSpan<TScalar>, TScalar)

Executa bit a bit e entre um tensor e um escalar.
BitwiseAnd(TScalar, ReadOnlyTensorSpan<TScalar>)

Executa bit a bit e entre um tensor e um escalar.
BitwiseAnd(TScalar, Tensor<TScalar>)

Executa bit a bit e entre um tensor e um escalar.
BitwiseAnd(TScalar, TensorSpan<TScalar>)

Executa bit a bit e entre um tensor e um escalar.
BitwiseAnd<TScalar>(ReadOnlyTensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)

Executa bit a bit e entre dois tensores.
BitwiseAnd<TScalar>(ReadOnlyTensorSpan<TScalar>, TScalar)

Executa bit a bit e entre um tensor e um escalar.
BitwiseAnd<TScalar>(Tensor<TScalar>, Tensor<TScalar>)

Executa bit a bit e entre dois tensores.
BitwiseAnd<TScalar>(Tensor<TScalar>, TScalar)

Executa bit a bit e entre um tensor e um escalar.
BitwiseAnd<TScalar>(TensorSpan<TScalar>, TensorSpan<TScalar>)

Executa bit a bit e entre dois tensores.
BitwiseAnd<TScalar>(TensorSpan<TScalar>, TScalar)

Executa bit a bit e entre um tensor e um escalar.
BitwiseAnd<TScalar>(TScalar, ReadOnlyTensorSpan<TScalar>)

Executa bit a bit e entre um tensor e um escalar.
BitwiseAnd<TScalar>(TScalar, Tensor<TScalar>)

Executa bit a bit e entre um tensor e um escalar.
BitwiseAnd<TScalar>(TScalar, TensorSpan<TScalar>)

Executa bit a bit e entre um tensor e um escalar.
BitwiseAndAssignment(ReadOnlyTensorSpan<TScalar>)

Executa no local bit a bit e entre dois tensores.
BitwiseAndAssignment(ReadOnlyTensorSpan<TScalar>)

Executa no local bit a bit e entre dois tensores.
BitwiseAndAssignment(TScalar)

Executa no local bit a bit e entre um tensor e um escalar.
BitwiseAndAssignment(TScalar)

Executa no local bit a bit e entre um tensor e um escalar.
BitwiseAndAssignment<TScalar>(Tensor<TScalar>, ReadOnlyTensorSpan<TScalar>)

Executa no local bit a bit e entre dois tensores.
BitwiseAndAssignment<TScalar>(Tensor<TScalar>, TScalar)

Executa no local bit a bit e entre um tensor e um escalar.
BitwiseAndAssignment<TScalar>(TensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)

Executa no local bit a bit e entre dois tensores.
BitwiseAndAssignment<TScalar>(TensorSpan<TScalar>, TScalar)

Executa no local bit a bit e entre um tensor e um escalar.
BitwiseOr(ReadOnlyTensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)

Executa bitwise-or entre dois tensores.
BitwiseOr(ReadOnlyTensorSpan<TScalar>, TScalar)

Executa bits a bits—ou entre um tensor e um escalar.
BitwiseOr(Tensor<TScalar>, Tensor<TScalar>)

Executa bitwise-or entre dois tensores.
BitwiseOr(Tensor<TScalar>, TScalar)

Executa bits a bits—ou entre um tensor e um escalar.
BitwiseOr(TensorSpan<TScalar>, TensorSpan<TScalar>)

Executa bitwise-or entre dois tensores.
BitwiseOr(TensorSpan<TScalar>, TScalar)

Executa bits a bits—ou entre um tensor e um escalar.
BitwiseOr(TScalar, ReadOnlyTensorSpan<TScalar>)

Executa bits a bits—ou entre um tensor e um escalar.
BitwiseOr(TScalar, Tensor<TScalar>)

Executa bits a bits—ou entre um tensor e um escalar.
BitwiseOr(TScalar, TensorSpan<TScalar>)

Executa bits a bits—ou entre um tensor e um escalar.
BitwiseOr<TScalar>(ReadOnlyTensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)

Executa bitwise-or entre dois tensores.
BitwiseOr<TScalar>(ReadOnlyTensorSpan<TScalar>, TScalar)

Executa bits a bits—ou entre um tensor e um escalar.
BitwiseOr<TScalar>(Tensor<TScalar>, Tensor<TScalar>)

Executa bitwise-or entre dois tensores.
BitwiseOr<TScalar>(Tensor<TScalar>, TScalar)

Executa bits a bits—ou entre um tensor e um escalar.
BitwiseOr<TScalar>(TensorSpan<TScalar>, TensorSpan<TScalar>)

Executa bitwise-or entre dois tensores.
BitwiseOr<TScalar>(TensorSpan<TScalar>, TScalar)

Executa bits a bits—ou entre um tensor e um escalar.
BitwiseOr<TScalar>(TScalar, ReadOnlyTensorSpan<TScalar>)

Executa bits a bits—ou entre um tensor e um escalar.
BitwiseOr<TScalar>(TScalar, Tensor<TScalar>)

Executa bits a bits—ou entre um tensor e um escalar.
BitwiseOr<TScalar>(TScalar, TensorSpan<TScalar>)

Executa bits a bits—ou entre um tensor e um escalar.
BitwiseOrAssignment(ReadOnlyTensorSpan<TScalar>)

Executa bits-à-bit no local ou entre dois tensores.
BitwiseOrAssignment(ReadOnlyTensorSpan<TScalar>)

Executa bits-à-bit no local ou entre dois tensores.
BitwiseOrAssignment(TScalar)

Executa no local bit a bit—ou entre um tensor e um escalar.
BitwiseOrAssignment(TScalar)

Executa no local bit a bit—ou entre um tensor e um escalar.
BitwiseOrAssignment<TScalar>(Tensor<TScalar>, ReadOnlyTensorSpan<TScalar>)

Executa bits-à-bit no local ou entre dois tensores.
BitwiseOrAssignment<TScalar>(Tensor<TScalar>, TScalar)

Executa no local bit a bit—ou entre um tensor e um escalar.
BitwiseOrAssignment<TScalar>(TensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)

Executa bits-à-bit no local ou entre dois tensores.
BitwiseOrAssignment<TScalar>(TensorSpan<TScalar>, TScalar)

Executa no local bit a bit—ou entre um tensor e um escalar.
DecrementAssignment

Realiza decremento no local num tensor.
DecrementAssignment

Realiza decremento no local num tensor.
DecrementAssignment<TScalar>(Tensor<TScalar>)

Realiza decremento no local num tensor.
DecrementAssignment<TScalar>(TensorSpan<TScalar>)

Realiza decremento no local num tensor.
Division(ReadOnlyTensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)

Realiza divisão elemento a elemento entre dois tensores.
Division(ReadOnlyTensorSpan<TScalar>, TScalar)

Realiza a divisão elemento a elemento entre um tensor e um escalar.
Division(Tensor<TScalar>, Tensor<TScalar>)

Realiza divisão elemento a elemento entre dois tensores.
Division(Tensor<TScalar>, TScalar)

Realiza a divisão elemento a elemento entre um tensor e um escalar.
Division(TensorSpan<TScalar>, TensorSpan<TScalar>)

Realiza divisão elemento a elemento entre dois tensores.
Division(TensorSpan<TScalar>, TScalar)

Realiza a divisão elemento a elemento entre um tensor e um escalar.
Division(TScalar, ReadOnlyTensorSpan<TScalar>)

Realiza a divisão elemento a elemento entre um tensor e um escalar.
Division(TScalar, Tensor<TScalar>)

Realiza a divisão elemento a elemento entre um tensor e um escalar.
Division(TScalar, TensorSpan<TScalar>)

Realiza a divisão elemento a elemento entre um tensor e um escalar.
Division<TScalar>(ReadOnlyTensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)

Realiza divisão elemento a elemento entre dois tensores.
Division<TScalar>(ReadOnlyTensorSpan<TScalar>, TScalar)

Realiza a divisão elemento a elemento entre um tensor e um escalar.
Division<TScalar>(Tensor<TScalar>, Tensor<TScalar>)

Realiza divisão elemento a elemento entre dois tensores.
Division<TScalar>(Tensor<TScalar>, TScalar)

Realiza a divisão elemento a elemento entre um tensor e um escalar.
Division<TScalar>(TensorSpan<TScalar>, TensorSpan<TScalar>)

Realiza divisão elemento a elemento entre dois tensores.
Division<TScalar>(TensorSpan<TScalar>, TScalar)

Realiza a divisão elemento a elemento entre um tensor e um escalar.
Division<TScalar>(TScalar, ReadOnlyTensorSpan<TScalar>)

Realiza a divisão elemento a elemento entre um tensor e um escalar.
Division<TScalar>(TScalar, Tensor<TScalar>)

Realiza a divisão elemento a elemento entre um tensor e um escalar.
Division<TScalar>(TScalar, TensorSpan<TScalar>)

Realiza a divisão elemento a elemento entre um tensor e um escalar.
DivisionAssignment(ReadOnlyTensorSpan<TScalar>)

Realiza divisão elemento a elemento no local entre dois tensores.
DivisionAssignment(ReadOnlyTensorSpan<TScalar>)

Realiza divisão elemento a elemento no local entre dois tensores.
DivisionAssignment(TScalar)

Realiza a divisão elemento a elemento entre um tensor e um escalar.
DivisionAssignment(TScalar)

Realiza a divisão elemento a elemento entre um tensor e um escalar.
DivisionAssignment<TScalar>(Tensor<TScalar>, ReadOnlyTensorSpan<TScalar>)

Realiza divisão elemento a elemento no local entre dois tensores.
DivisionAssignment<TScalar>(Tensor<TScalar>, TScalar)

Realiza a divisão elemento a elemento entre um tensor e um escalar.
DivisionAssignment<TScalar>(TensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)

Realiza divisão elemento a elemento no local entre dois tensores.
DivisionAssignment<TScalar>(TensorSpan<TScalar>, TScalar)

Realiza a divisão elemento a elemento entre um tensor e um escalar.
ExclusiveOr(ReadOnlyTensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)

Executa o ou exclusivo entre dois tensores.
ExclusiveOr(ReadOnlyTensorSpan<TScalar>, TScalar)

Executa o exclusivo-ou entre um tensor e um escalar.
ExclusiveOr(Tensor<TScalar>, Tensor<TScalar>)

Executa o ou exclusivo entre dois tensores.
ExclusiveOr(Tensor<TScalar>, TScalar)

Executa o exclusivo-ou entre um tensor e um escalar.
ExclusiveOr(TensorSpan<TScalar>, TensorSpan<TScalar>)

Executa o ou exclusivo entre dois tensores.
ExclusiveOr(TensorSpan<TScalar>, TScalar)

Executa o exclusivo-ou entre um tensor e um escalar.
ExclusiveOr(TScalar, ReadOnlyTensorSpan<TScalar>)

Executa o exclusivo-ou entre um tensor e um escalar.
ExclusiveOr(TScalar, Tensor<TScalar>)

Executa o exclusivo-ou entre um tensor e um escalar.
ExclusiveOr(TScalar, TensorSpan<TScalar>)

Executa o exclusivo-ou entre um tensor e um escalar.
ExclusiveOr<TScalar>(ReadOnlyTensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)

Executa o ou exclusivo entre dois tensores.
ExclusiveOr<TScalar>(ReadOnlyTensorSpan<TScalar>, TScalar)

Executa o exclusivo-ou entre um tensor e um escalar.
ExclusiveOr<TScalar>(Tensor<TScalar>, Tensor<TScalar>)

Executa o ou exclusivo entre dois tensores.
ExclusiveOr<TScalar>(Tensor<TScalar>, TScalar)

Executa o exclusivo-ou entre um tensor e um escalar.
ExclusiveOr<TScalar>(TensorSpan<TScalar>, TensorSpan<TScalar>)

Executa o ou exclusivo entre dois tensores.
ExclusiveOr<TScalar>(TensorSpan<TScalar>, TScalar)

Executa o exclusivo-ou entre um tensor e um escalar.
ExclusiveOr<TScalar>(TScalar, ReadOnlyTensorSpan<TScalar>)

Executa o exclusivo-ou entre um tensor e um escalar.
ExclusiveOr<TScalar>(TScalar, Tensor<TScalar>)

Executa o exclusivo-ou entre um tensor e um escalar.
ExclusiveOr<TScalar>(TScalar, TensorSpan<TScalar>)

Executa o exclusivo-ou entre um tensor e um escalar.
ExclusiveOrAssignment(ReadOnlyTensorSpan<TScalar>)

Executa o ou exclusivo no local entre dois tensores.
ExclusiveOrAssignment(ReadOnlyTensorSpan<TScalar>)

Executa o ou exclusivo no local entre dois tensores.
ExclusiveOrAssignment(TScalar)

Executa exclusivamente no local — ou entre um tensor e um escalar.
ExclusiveOrAssignment(TScalar)

Executa exclusivamente no local — ou entre um tensor e um escalar.
ExclusiveOrAssignment<TScalar>(Tensor<TScalar>, ReadOnlyTensorSpan<TScalar>)

Executa o ou exclusivo no local entre dois tensores.
ExclusiveOrAssignment<TScalar>(Tensor<TScalar>, TScalar)

Executa exclusivamente no local — ou entre um tensor e um escalar.
ExclusiveOrAssignment<TScalar>(TensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)

Executa o ou exclusivo no local entre dois tensores.
ExclusiveOrAssignment<TScalar>(TensorSpan<TScalar>, TScalar)

Executa exclusivamente no local — ou entre um tensor e um escalar.
IncrementAssignment

Realiza incrementos no local num tensor.
IncrementAssignment

Realiza incrementos no local num tensor.
IncrementAssignment<TScalar>(Tensor<TScalar>)

Realiza incrementos no local num tensor.
IncrementAssignment<TScalar>(TensorSpan<TScalar>)

Realiza incrementos no local num tensor.
LeftShift(ReadOnlyTensorSpan<TScalar>, Int32)

Executa um deslocamento elemental à esquerda num tensor.
LeftShift(Tensor<TScalar>, Int32)

Executa um deslocamento elemental à esquerda num tensor.
LeftShift(TensorSpan<TScalar>, Int32)

Executa um deslocamento elemental à esquerda num tensor.
LeftShift<TScalar>(ReadOnlyTensorSpan<TScalar>, Int32)

Executa um deslocamento elemental à esquerda num tensor.
LeftShift<TScalar>(Tensor<TScalar>, Int32)

Executa um deslocamento elemental à esquerda num tensor.
LeftShift<TScalar>(TensorSpan<TScalar>, Int32)

Executa um deslocamento elemental à esquerda num tensor.
LeftShiftAssignment(Int32)

Executa um deslocamento para a esquerda elemento a elemento num tensor.
LeftShiftAssignment(Int32)

Executa um deslocamento para a esquerda elemento a elemento num tensor.
LeftShiftAssignment<TScalar>(Tensor<TScalar>, Int32)

Executa um deslocamento para a esquerda elemento a elemento num tensor.
LeftShiftAssignment<TScalar>(TensorSpan<TScalar>, Int32)

Executa um deslocamento para a esquerda elemento a elemento num tensor.
MultiplicationAssignment(ReadOnlyTensorSpan<TScalar>)

Realiza multiplicação elemento a elemento no local entre dois tensores.
MultiplicationAssignment(ReadOnlyTensorSpan<TScalar>)

Realiza multiplicação elemento a elemento no local entre dois tensores.
MultiplicationAssignment(TScalar)

Realiza a multiplicação elemento a elemento no local entre um tensor e um escalar.
MultiplicationAssignment(TScalar)

Realiza a multiplicação elemento a elemento no local entre um tensor e um escalar.
MultiplicationAssignment<TScalar>(Tensor<TScalar>, ReadOnlyTensorSpan<TScalar>)

Realiza multiplicação elemento a elemento no local entre dois tensores.
MultiplicationAssignment<TScalar>(Tensor<TScalar>, TScalar)

Realiza a multiplicação elemento a elemento no local entre um tensor e um escalar.
MultiplicationAssignment<TScalar>(TensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)

Realiza multiplicação elemento a elemento no local entre dois tensores.
MultiplicationAssignment<TScalar>(TensorSpan<TScalar>, TScalar)

Realiza a multiplicação elemento a elemento no local entre um tensor e um escalar.
Multiply(ReadOnlyTensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)

Realiza multiplicação elemento a elemento entre dois tensores.
Multiply(ReadOnlyTensorSpan<TScalar>, TScalar)

Realiza a multiplicação elemento a elemento entre um tensor e um escalar.
Multiply(Tensor<TScalar>, Tensor<TScalar>)

Realiza multiplicação elemento a elemento entre dois tensores.
Multiply(Tensor<TScalar>, TScalar)

Realiza a multiplicação elemento a elemento entre um tensor e um escalar.
Multiply(TensorSpan<TScalar>, TensorSpan<TScalar>)

Realiza multiplicação elemento a elemento entre dois tensores.
Multiply(TensorSpan<TScalar>, TScalar)

Realiza a multiplicação elemento a elemento entre um tensor e um escalar.
Multiply(TScalar, ReadOnlyTensorSpan<TScalar>)

Realiza a multiplicação elemento a elemento entre um tensor e um escalar.
Multiply(TScalar, Tensor<TScalar>)

Realiza a multiplicação elemento a elemento entre um tensor e um escalar.
Multiply(TScalar, TensorSpan<TScalar>)

Realiza a multiplicação elemento a elemento entre um tensor e um escalar.
Multiply<TScalar>(ReadOnlyTensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)

Realiza multiplicação elemento a elemento entre dois tensores.
Multiply<TScalar>(ReadOnlyTensorSpan<TScalar>, TScalar)

Realiza a multiplicação elemento a elemento entre um tensor e um escalar.
Multiply<TScalar>(Tensor<TScalar>, Tensor<TScalar>)

Realiza multiplicação elemento a elemento entre dois tensores.
Multiply<TScalar>(Tensor<TScalar>, TScalar)

Realiza a multiplicação elemento a elemento entre um tensor e um escalar.
Multiply<TScalar>(TensorSpan<TScalar>, TensorSpan<TScalar>)

Realiza multiplicação elemento a elemento entre dois tensores.
Multiply<TScalar>(TensorSpan<TScalar>, TScalar)

Realiza a multiplicação elemento a elemento entre um tensor e um escalar.
Multiply<TScalar>(TScalar, ReadOnlyTensorSpan<TScalar>)

Realiza a multiplicação elemento a elemento entre um tensor e um escalar.
Multiply<TScalar>(TScalar, Tensor<TScalar>)

Realiza a multiplicação elemento a elemento entre um tensor e um escalar.
Multiply<TScalar>(TScalar, TensorSpan<TScalar>)

Realiza a multiplicação elemento a elemento entre um tensor e um escalar.
OnesComplement(ReadOnlyTensorSpan<TScalar>)

Faz o complemento de um um tensor.
OnesComplement(Tensor<TScalar>)

Faz o complemento de um um tensor.
OnesComplement(TensorSpan<TScalar>)

Faz o complemento de um um tensor.
OnesComplement<TScalar>(ReadOnlyTensorSpan<TScalar>)

Faz o complemento de um um tensor.
OnesComplement<TScalar>(Tensor<TScalar>)

Faz o complemento de um um tensor.
OnesComplement<TScalar>(TensorSpan<TScalar>)

Faz o complemento de um um tensor.
RightShift(ReadOnlyTensorSpan<TScalar>, Int32)

Realiza um deslocamento aritmético à direita elemento a elemento num tensor.
RightShift(Tensor<TScalar>, Int32)

Realiza um deslocamento aritmético à direita elemento a elemento num tensor.
RightShift(TensorSpan<TScalar>, Int32)

Realiza um deslocamento aritmético à direita elemento a elemento num tensor.
RightShift<TScalar>(ReadOnlyTensorSpan<TScalar>, Int32)

Realiza um deslocamento aritmético à direita elemento a elemento num tensor.
RightShift<TScalar>(Tensor<TScalar>, Int32)

Realiza um deslocamento aritmético à direita elemento a elemento num tensor.
RightShift<TScalar>(TensorSpan<TScalar>, Int32)

Realiza um deslocamento aritmético à direita elemento a elemento num tensor.
RightShiftAssignment(Int32)

Executa o deslocamento aritmético à direita elemento a elemento num tensor.
RightShiftAssignment(Int32)

Executa o deslocamento aritmético à direita elemento a elemento num tensor.
RightShiftAssignment<TScalar>(Tensor<TScalar>, Int32)

Executa o deslocamento aritmético à direita elemento a elemento num tensor.
RightShiftAssignment<TScalar>(TensorSpan<TScalar>, Int32)

Executa o deslocamento aritmético à direita elemento a elemento num tensor.
Subtraction(ReadOnlyTensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)

Realiza subtração elemento a elemento entre dois tensores.
Subtraction(ReadOnlyTensorSpan<TScalar>, TScalar)

Realiza a subtração elemento a elemento entre um tensor e um escalar.
Subtraction(Tensor<TScalar>, Tensor<TScalar>)

Realiza subtração elemento a elemento entre dois tensores.
Subtraction(Tensor<TScalar>, TScalar)

Realiza a subtração elemento a elemento entre um tensor e um escalar.
Subtraction(TensorSpan<TScalar>, TensorSpan<TScalar>)

Realiza subtração elemento a elemento entre dois tensores.
Subtraction(TensorSpan<TScalar>, TScalar)

Realiza a subtração elemento a elemento entre um tensor e um escalar.
Subtraction(TScalar, ReadOnlyTensorSpan<TScalar>)

Realiza a subtração elemento a elemento entre um tensor e um escalar.
Subtraction(TScalar, Tensor<TScalar>)

Realiza a subtração elemento a elemento entre um tensor e um escalar.
Subtraction(TScalar, TensorSpan<TScalar>)

Realiza a subtração elemento a elemento entre um tensor e um escalar.
Subtraction<TScalar>(ReadOnlyTensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)

Realiza subtração elemento a elemento entre dois tensores.
Subtraction<TScalar>(ReadOnlyTensorSpan<TScalar>, TScalar)

Realiza a subtração elemento a elemento entre um tensor e um escalar.
Subtraction<TScalar>(Tensor<TScalar>, Tensor<TScalar>)

Realiza subtração elemento a elemento entre dois tensores.
Subtraction<TScalar>(Tensor<TScalar>, TScalar)

Realiza a subtração elemento a elemento entre um tensor e um escalar.
Subtraction<TScalar>(TensorSpan<TScalar>, TensorSpan<TScalar>)

Realiza subtração elemento a elemento entre dois tensores.
Subtraction<TScalar>(TensorSpan<TScalar>, TScalar)

Realiza a subtração elemento a elemento entre um tensor e um escalar.
Subtraction<TScalar>(TScalar, ReadOnlyTensorSpan<TScalar>)

Realiza a subtração elemento a elemento entre um tensor e um escalar.
Subtraction<TScalar>(TScalar, Tensor<TScalar>)

Realiza a subtração elemento a elemento entre um tensor e um escalar.
Subtraction<TScalar>(TScalar, TensorSpan<TScalar>)

Realiza a subtração elemento a elemento entre um tensor e um escalar.
SubtractionAssignment(ReadOnlyTensorSpan<TScalar>)

Realiza subtração elemento a elemento no local entre dois tensores.
SubtractionAssignment(ReadOnlyTensorSpan<TScalar>)

Realiza subtração elemento a elemento no local entre dois tensores.
SubtractionAssignment(TScalar)

Realiza a subtração elemento a elemento no local entre um tensor e um escalar.
SubtractionAssignment(TScalar)

Realiza a subtração elemento a elemento no local entre um tensor e um escalar.
SubtractionAssignment<TScalar>(Tensor<TScalar>, ReadOnlyTensorSpan<TScalar>)

Realiza subtração elemento a elemento no local entre dois tensores.
SubtractionAssignment<TScalar>(Tensor<TScalar>, TScalar)

Realiza a subtração elemento a elemento no local entre um tensor e um escalar.
SubtractionAssignment<TScalar>(TensorSpan<TScalar>, ReadOnlyTensorSpan<TScalar>)

Realiza subtração elemento a elemento no local entre dois tensores.
SubtractionAssignment<TScalar>(TensorSpan<TScalar>, TScalar)

Realiza a subtração elemento a elemento no local entre um tensor e um escalar.
UnaryNegation(ReadOnlyTensorSpan<TScalar>)

Realiza uma negação unária elemento a elemento sobre um tensor.
UnaryNegation(Tensor<TScalar>)

Realiza uma negação unária elemento a elemento sobre um tensor.
UnaryNegation(TensorSpan<TScalar>)

Realiza uma negação unária elemento a elemento sobre um tensor.
UnaryNegation<TScalar>(ReadOnlyTensorSpan<TScalar>)

Realiza uma negação unária elemento a elemento sobre um tensor.
UnaryNegation<TScalar>(Tensor<TScalar>)

Realiza uma negação unária elemento a elemento sobre um tensor.
UnaryNegation<TScalar>(TensorSpan<TScalar>)

Realiza uma negação unária elemento a elemento sobre um tensor.
UnaryPlus(ReadOnlyTensorSpan<TScalar>)

Apresenta um unário elemento a elemento mais num tensor.
UnaryPlus(Tensor<TScalar>)

Apresenta um unário elemento a elemento mais num tensor.
UnaryPlus(TensorSpan<TScalar>)

Apresenta um unário elemento a elemento mais num tensor.
UnaryPlus<TScalar>(ReadOnlyTensorSpan<TScalar>)

Apresenta um unário elemento a elemento mais num tensor.
UnaryPlus<TScalar>(Tensor<TScalar>)

Apresenta um unário elemento a elemento mais num tensor.
UnaryPlus<TScalar>(TensorSpan<TScalar>)

Apresenta um unário elemento a elemento mais num tensor.
UnsignedRightShift(ReadOnlyTensorSpan<TScalar>, Int32)

Realiza um deslocamento lógico para a direita elemento a elemento num tensor.
UnsignedRightShift(Tensor<TScalar>, Int32)

Realiza um deslocamento lógico para a direita elemento a elemento num tensor.
UnsignedRightShift(TensorSpan<TScalar>, Int32)

Realiza um deslocamento lógico para a direita elemento a elemento num tensor.
UnsignedRightShift<TScalar>(ReadOnlyTensorSpan<TScalar>, Int32)

Realiza um deslocamento lógico para a direita elemento a elemento num tensor.
UnsignedRightShift<TScalar>(Tensor<TScalar>, Int32)

Realiza um deslocamento lógico para a direita elemento a elemento num tensor.
UnsignedRightShift<TScalar>(TensorSpan<TScalar>, Int32)

Realiza um deslocamento lógico para a direita elemento a elemento num tensor.
UnsignedRightShiftAssignment(Int32)

Realiza um deslocamento lógico à direita elemento a elemento num tensor.
UnsignedRightShiftAssignment(Int32)

Realiza um deslocamento lógico à direita elemento a elemento num tensor.
UnsignedRightShiftAssignment<TScalar>(Tensor<TScalar>, Int32)

Realiza um deslocamento lógico à direita elemento a elemento num tensor.
UnsignedRightShiftAssignment<TScalar>(TensorSpan<TScalar>, Int32)

Realiza um deslocamento lógico à direita elemento a elemento num tensor.

Aplica-se a