Dialetto 'chlo'

Client HLO Ops

Questo dialetto contiene operazioni che si allineano strettamente all'area di superficie dell'API XlaBuilder C++, in cui queste operazioni hanno una semantica che va oltre ciò che esiste nei dialetti di livello inferiore (come stablehlo). Essenzialmente, ogni volta che la libreria client utilizza zucchero sintattico o composizione di più operazioni per una chiamata API, questo dialetto tenta di modellare la chiamata API e fornire pattern di conversione per materializzarsi completamente in dialetti di livello inferiore.

Operazioni

chlo._asin_acos_kernel (chlo::AsinAcosKernelOp)

Operatore AsinAcosKernel

Sintassi:

operation ::= `chlo._asin_acos_kernel` $operand attr-dict `:` type($operand) `->` type($result)

Restituisce AsinAcosKernel(operand) elemento per elemento.

If
  w = _asin_acos_kernel(z)
  w' = _asin_acos_kernel(I * z)
Then
  asin(z) = complex(atan2(z.real, w.real), sign(z.imag) * w.imag)
  acos(z) = complex(atan2(w.real, z.real), -sign(z.imag) * w.imag)
  asinh(z) = complex(sign(z.real) * w'.imag, atan2(z.imag, w'.real))
  acosh(z) = complex(w.imag, sign(z.imag) * atan2(w.real, z.real))

Questa operazione viene utilizzata come valore intermedio nelle scomposizioni e non deve mai essere costruita direttamente dai framework o utilizzata dai backend.

Tratti: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

Interfacce: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

chlo.acos (chlo::AcosOp)

Operatore acos

Sintassi:

operation ::= `chlo.acos` $operand attr-dict `:` type($operand) `->` type($result)

Restituisce Acos(operand) elemento per elemento.

\[ \acos(x) = 2 * \atan(\sqrt(1 - x^2) / (1 + x)) if x != -1 = pi if x == -1 \]

Tratti: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

Interfacce: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

chlo.acosh (chlo::AcoshOp)

Operazione Acosh

Sintassi:

operation ::= `chlo.acosh` $operand attr-dict `:` type($operand) `->` type($result)

Restituisce Acosh(operand) elemento per elemento.

\[ \acosh(x) = log(x + sqrt(x^2 - 1)) if x >= -1 \acosh(x) = nan if x < -1 \]

Tratti: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

Interfacce: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

chlo.asin (chlo::AsinOp)

Operatore ASIN

Sintassi:

operation ::= `chlo.asin` $operand attr-dict `:` type($operand) `->` type($result)

Restituisce Asin(operand) elemento per elemento.

\[ \asin(x) = 2 * atan(x / (1 + sqrt(1 - x^2))) \]

Tratti: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

Interfacce: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

chlo.asinh (chlo::AsinhOp)

Operazione Asinh

Sintassi:

operation ::= `chlo.asinh` $operand attr-dict `:` type($operand) `->` type($result)

Restituisce Asinh(operand) elemento per elemento.

\[ \asinh(x) = log(x + sqrt(x^2 + 1)) \]

Tratti: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

Interfacce: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

chlo.atan (chlo::AtanOp)

Operatore atan

Sintassi:

operation ::= `chlo.atan` $operand attr-dict `:` type($operand) `->` type($result)

Restituisce Atan(operand) elemento per elemento.

\[ \atan(x) = \atan2(x, 1) \]

Tratti: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

Interfacce: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

chlo.atanh (chlo::AtanhOp)

Operatore atanh

Sintassi:

operation ::= `chlo.atanh` $operand attr-dict `:` type($operand) `->` type($result)

Restituisce Atanh(operand) elemento per elemento.

\[ \atanh(x) = 0.5 * log((1 + x) / (1 - x)) if abs(x) <= 1 = nan otherwise \]

Tratti: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

Interfacce: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

chlo.bessel_i1e (chlo::BesselI1eOp)

Funzione di Bessel di ordine 1

Sintassi:

operation ::= `chlo.bessel_i1e` $operand attr-dict `:` type($operand) `->` type($result)

Restituisce bessel_i1e(operand) elemento per elemento.

Tratti: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

Interfacce: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

chlo.broadcast_add (chlo::BroadcastAddOp)

Operatore di addizione (con trasmissione facoltativa)

Sintassi:

operation ::= `chlo.broadcast_add` $lhs `,` $rhs attr-dict `:`
              `(` type($lhs) `,` type($rhs) `)` `->` type(results)

Restituisce lhs + rhs elemento per elemento.

Vedi https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations

Tratti: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, Commutative, HLO_BroadcastingElementwise, HLO_CompatibleOperandsAndResultElementType, InferTensorType

Interfacce: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effetti: MemoryEffects::Effect{}

Attributi:

Operandi:

Risultati:

chlo.broadcast_and (chlo::BroadcastAndOp)

Operatore logico AND (con trasmissione facoltativa)

Sintassi:

operation ::= `chlo.broadcast_and` $lhs `,` $rhs attr-dict `:`
              `(` type($lhs) `,` type($rhs) `)` `->` type(results)

Restituisce logical_and(lhs, rhs) elemento per elemento.

Vedi https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations

Tratti: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, Commutative, HLO_BroadcastingElementwise, InferTensorType

Interfacce: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effetti: MemoryEffects::Effect{}

Attributi:

Operandi:

Risultati:

chlo.broadcast_atan2 (chlo::BroadcastAtan2Op)

Operatore Atan2 (con trasmissione facoltativa)

Sintassi:

operation ::= `chlo.broadcast_atan2` $lhs `,` $rhs attr-dict `:`
              `(` type($lhs) `,` type($rhs) `)` `->` type(results)

Restituisce atan2(lhs/rhs) elemento per elemento.

Vedi https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations

Tratti: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

Interfacce: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effetti: MemoryEffects::Effect{}

Attributi:

Operandi:

Risultati:

chlo.broadcast_compare (chlo::BroadcastCompareOp)

Operatore di confronto (con trasmissione facoltativa)

Sintassi:

operation ::= `chlo.broadcast_compare` $lhs `,` $rhs attr-dict `:`
              `(` type($lhs) `,` type($rhs) `)` `->` type(results)

Confronta lhs e rhs elemento per elemento in base a comparison_direction e compare_type. Se non specificato, compare_type è FLOAT per i tipi di elementi float, SIGNED per i tipi di elementi con segno e UNSIGNED per i tipi di elementi senza segno.

Vedi https://www.tensorflow.org/xla/operation_semantics#element-wise_comparison_operations

Tratti: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType

Interfacce: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effetti: MemoryEffects::Effect{}

Attributi:

Operandi:

Risultati:

chlo.broadcast_complex (chlo::BroadcastComplexOp)

Operatore complesso (con trasmissione facoltativa)

Sintassi:

operation ::= `chlo.broadcast_complex` $lhs `,` $rhs attr-dict `:`
              `(` type($lhs) `,` type($rhs) `)` `->` type(results)

Esegue la conversione elemento per elemento di una coppia di valori reali e immaginari in un valore complesso.

Tratti: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType

Interfacce: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effetti: MemoryEffects::Effect{}

Attributi:

Operandi:

Risultati:

chlo.broadcast_divide (chlo::BroadcastDivOp)

Operatore di divisione (con trasmissione facoltativa)

Sintassi:

operation ::= `chlo.broadcast_divide` $lhs `,` $rhs attr-dict `:`
              `(` type($lhs) `,` type($rhs) `)` `->` type(results)

Restituisce lhs / rhs elemento per elemento.

Vedi https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations

Tratti: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

Interfacce: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effetti: MemoryEffects::Effect{}

Attributi:

Operandi:

Risultati:

chlo.broadcast_maximum (chlo::BroadcastMaxOp)

Operatore massimo (con trasmissione facoltativa)

Sintassi:

operation ::= `chlo.broadcast_maximum` $lhs `,` $rhs attr-dict `:`
              `(` type($lhs) `,` type($rhs) `)` `->` type(results)

Restituisce max(lhs, rhs) elemento per elemento.

Vedi https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations

Tratti: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, Commutative, HLO_BroadcastingElementwise, HLO_CompatibleOperandsAndResultElementType, InferTensorType

Interfacce: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effetti: MemoryEffects::Effect{}

Attributi:

Operandi:

Risultati:

chlo.broadcast_minimum (chlo::BroadcastMinOp)

Operatore minimo (con trasmissione facoltativa)

Sintassi:

operation ::= `chlo.broadcast_minimum` $lhs `,` $rhs attr-dict `:`
              `(` type($lhs) `,` type($rhs) `)` `->` type(results)

Restituisce min(lhs, rhs) elemento per elemento.

Vedi https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations

Tratti: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, Commutative, HLO_BroadcastingElementwise, HLO_CompatibleOperandsAndResultElementType, InferTensorType

Interfacce: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effetti: MemoryEffects::Effect{}

Attributi:

Operandi:

Risultati:

chlo.broadcast_multiply (chlo::BroadcastMulOp)

Operatore di moltiplicazione (con trasmissione facoltativa)

Sintassi:

operation ::= `chlo.broadcast_multiply` $lhs `,` $rhs attr-dict `:`
              `(` type($lhs) `,` type($rhs) `)` `->` type(results)

Restituisce lhs * rhs elemento per elemento.

Vedi https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations

Tratti: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, Commutative, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

Interfacce: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effetti: MemoryEffects::Effect{}

Attributi:

Operandi:

Risultati:

chlo.broadcast_next_after (chlo::BroadcastNextAfterOp)

Operatore Std::nextafter (con trasmissione facoltativa)

Sintassi:

operation ::= `chlo.broadcast_next_after` $lhs `,` $rhs attr-dict `:`
              `(` type($lhs) `,` type($rhs) `)` `->` type(results)

Restituisce il successivo valore rappresentabile di lhs nella direzione di rhs, elemento per elemento. Può anche restituire un numero subnormale.

Equivalente alla funzione std::nextafter di C++.

Tratti: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

Interfacce: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effetti: MemoryEffects::Effect{}

Attributi:

Operandi:

Risultati:

chlo.broadcast_or (chlo::BroadcastOrOp)

Operatore logico OR (con trasmissione facoltativa)

Sintassi:

operation ::= `chlo.broadcast_or` $lhs `,` $rhs attr-dict `:`
              `(` type($lhs) `,` type($rhs) `)` `->` type(results)

Restituisce logical_or(lhs, rhs) elemento per elemento.

Vedi https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations

Tratti: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, Commutative, HLO_BroadcastingElementwise, InferTensorType

Interfacce: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effetti: MemoryEffects::Effect{}

Attributi:

Operandi:

Risultati:

chlo.broadcast_polygamma (chlo::BroadcastPolygammaOp)

Funzione poligamma (con trasmissione facoltativa)

Sintassi:

operation ::= `chlo.broadcast_polygamma` $lhs `,` $rhs attr-dict `:`
              `(` type($lhs) `,` type($rhs) `)` `->` type(results)

Restituisce Polygamma(operand, operand) elemento per elemento.

Tratti: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

Interfacce: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effetti: MemoryEffects::Effect{}

Attributi:

Operandi:

Risultati:

chlo.broadcast_power (chlo::BroadcastPowOp)

Operatore di alimentazione (con trasmissione facoltativa)

Sintassi:

operation ::= `chlo.broadcast_power` $lhs `,` $rhs attr-dict `:`
              `(` type($lhs) `,` type($rhs) `)` `->` type(results)

Restituisce lhs ^ rhs elemento per elemento.

Vedi https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations

Tratti: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

Interfacce: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effetti: MemoryEffects::Effect{}

Attributi:

Operandi:

Risultati:

chlo.broadcast_remainder (chlo::BroadcastRemOp)

Operatore resto (con trasmissione facoltativa)

Sintassi:

operation ::= `chlo.broadcast_remainder` $lhs `,` $rhs attr-dict `:`
              `(` type($lhs) `,` type($rhs) `)` `->` type(results)

Restituisce lhs % rhs elemento per elemento.

Vedi https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations

Tratti: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

Interfacce: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effetti: MemoryEffects::Effect{}

Attributi:

Operandi:

Risultati:

chlo.broadcast_select (chlo::BroadcastSelectOp)

Seleziona l'operatore (con trasmissione facoltativa in stile NumPy)

Sintassi:

operation ::= `chlo.broadcast_select` $pred `,` $on_true `,` $on_false attr-dict `:`
              `(` type($pred) `,` type($on_true) `,` type($on_false) `)` `->` type(results)

Costruisce un array di output dagli elementi di due array di input, in base ai valori di un array di predicati.

Vedi https://www.tensorflow.org/xla/operation_semantics#select

Tratti: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType

Interfacce: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

chlo.broadcast_shift_left (chlo::BroadcastShiftLeftOp)

Operatore di spostamento a sinistra (con trasmissione facoltativa)

Sintassi:

operation ::= `chlo.broadcast_shift_left` $lhs `,` $rhs attr-dict `:`
              `(` type($lhs) `,` type($rhs) `)` `->` type(results)

Restituisce lhs << rhs elemento per elemento.

Vedi https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations

Tratti: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

Interfacce: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effetti: MemoryEffects::Effect{}

Attributi:

Operandi:

Risultati:

chlo.broadcast_shift_right_arithmetic (chlo::BroadcastShiftRightArithmeticOp)

Operatore aritmetico di spostamento a destra (con trasmissione facoltativa)

Sintassi:

operation ::= `chlo.broadcast_shift_right_arithmetic` $lhs `,` $rhs attr-dict `:`
              `(` type($lhs) `,` type($rhs) `)` `->` type(results)

Restituisce lhs >> rhs elemento per elemento.

Vedi https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations

Tratti: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

Interfacce: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effetti: MemoryEffects::Effect{}

Attributi:

Operandi:

Risultati:

chlo.broadcast_shift_right_logical (chlo::BroadcastShiftRightLogicalOp)

Operatore logico di spostamento a destra (con trasmissione facoltativa)

Sintassi:

operation ::= `chlo.broadcast_shift_right_logical` $lhs `,` $rhs attr-dict `:`
              `(` type($lhs) `,` type($rhs) `)` `->` type(results)

Restituisce lhs >> rhs elemento per elemento.

Vedi https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations

Tratti: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

Interfacce: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effetti: MemoryEffects::Effect{}

Attributi:

Operandi:

Risultati:

chlo.broadcast_subtract (chlo::BroadcastSubOp)

Operatore di sottrazione (con trasmissione facoltativa)

Sintassi:

operation ::= `chlo.broadcast_subtract` $lhs `,` $rhs attr-dict `:`
              `(` type($lhs) `,` type($rhs) `)` `->` type(results)

Restituisce lhs - rhs elemento per elemento.

Vedi https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations

Tratti: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

Interfacce: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effetti: MemoryEffects::Effect{}

Attributi:

Operandi:

Risultati:

chlo.broadcast_xor (chlo::BroadcastXorOp)

Operatore XOR logico (con trasmissione facoltativa)

Sintassi:

operation ::= `chlo.broadcast_xor` $lhs `,` $rhs attr-dict `:`
              `(` type($lhs) `,` type($rhs) `)` `->` type(results)

Restituisce logical_xor(lhs, rhs) elemento per elemento.

Vedi https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations

Tratti: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, Commutative, HLO_BroadcastingElementwise, InferTensorType

Interfacce: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effetti: MemoryEffects::Effect{}

Attributi:

Operandi:

Risultati:

chlo.broadcast_zeta (chlo::BroadcastZetaOp)

Funzione zeta di Hurwitz

Sintassi:

operation ::= `chlo.broadcast_zeta` $lhs `,` $rhs attr-dict `:`
              `(` type($lhs) `,` type($rhs) `)` `->` type(results)

Restituisce Zeta(operand, operand) elemento per elemento.

\[ \(\zeta(x, q) = \sum_{n=0}^{\infty} (q + n)^{-x}\) \]

Tratti: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

Interfacce: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effetti: MemoryEffects::Effect{}

Attributi:

Operandi:

Risultati:

chlo.conj (chlo::ConjOp)

Operatore di congiunzione

Sintassi:

operation ::= `chlo.conj` $operand attr-dict `:` type($operand) `->` type($result)

Restituisce Conj(operand) elemento per elemento.

\[ \conj(x) = (\real(x), \neg(\imag(x))) \]

Tratti: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

Interfacce: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

chlo.constant (chlo::ConstantOp)

Operatore costante

Sintassi:

operation ::= `chlo.constant` attr-dict $value

Rappresenta un valore costante.

Tratti: AlwaysSpeculatableImplTrait, ConstantLike

Interfacce: ConditionallySpeculatable, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effetti: MemoryEffects::Effect{}

Attributi:

Risultati:

chlo.constant_like (chlo::ConstantLikeOp)

Operatore di costante Like

Restituisce una costante splat della stessa forma dell'operando.

Tratti: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultShape

Interfacce: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effetti: MemoryEffects::Effect{}

Attributi:

Operandi:

Risultati:

chlo.cosh (chlo::CoshOp)

Operatore cosh

Sintassi:

operation ::= `chlo.cosh` $operand attr-dict `:` type($operand) `->` type($result)

Restituisce Cosh(operand) elemento per elemento.

\[ \cosh(x) = (e^x + e^-x) / 2 \]

Tratti: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

Interfacce: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

chlo.digamma (chlo::DigammaOp)

Funzione digamma

Sintassi:

operation ::= `chlo.digamma` $operand attr-dict `:` type($operand) `->` type($result)

Restituisce Digamma(operand) elemento per elemento.

Tratti: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

Interfacce: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

chlo.erf (chlo::ErfOp)

Operatore Erfc

Sintassi:

operation ::= `chlo.erf` $operand attr-dict `:` type($operand) `->` type($result)

Calcola la funzione di errore di Gauss di x elemento per elemento.

erf(x) = erf_impl(x) if |x| < 1 = 1 - erfc_impl(x) otherwise

Tratti: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

Interfacce: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

chlo.erf_inv (chlo::ErfInvOp)

Inverse Erf

Sintassi:

operation ::= `chlo.erf_inv` $operand attr-dict `:` type($operand) `->` type($result)

Restituisce ErfInv(operand) elemento per elemento.

Tratti: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

Interfacce: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

chlo.erfc (chlo::ErfcOp)

Operatore Erfc

Sintassi:

operation ::= `chlo.erfc` $operand attr-dict `:` type($operand) `->` type($result)

Calcola un'approssimazione del complemento della funzione di errore (1 - erf(x)).

erfc(x) = erfc_impl(x) if |x| > 1 = 1 - erf_impl(x) otherwise

Tratti: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

Interfacce: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

chlo.is_inf (chlo::IsInfOp)

Predicato IsInf

Sintassi:

operation ::= `chlo.is_inf` $operand attr-dict `:` type($operand) `->` type($result)

Restituisce se un valore è +/-inf elemento per elemento.

Tratti: AlwaysSpeculatableImplTrait, Elementwise, SameOperandsAndResultShape

Interfacce: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

chlo.is_neg_inf (chlo::IsNegInfOp)

Predicato IsNegInf

Sintassi:

operation ::= `chlo.is_neg_inf` $operand attr-dict `:` type($operand) `->` type($result)

Restituisce true se un valore è -inf elemento per elemento.

Tratti: AlwaysSpeculatableImplTrait, Elementwise, SameOperandsAndResultShape

Interfacce: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

chlo.is_pos_inf (chlo::IsPosInfOp)

IsPosInf predicate

Sintassi:

operation ::= `chlo.is_pos_inf` $operand attr-dict `:` type($operand) `->` type($result)

Restituisce true se un valore è +inf elemento per elemento.

Tratti: AlwaysSpeculatableImplTrait, Elementwise, SameOperandsAndResultShape

Interfacce: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

chlo.lgamma (chlo::LgammaOp)

Funzione Lgamma

Sintassi:

operation ::= `chlo.lgamma` $operand attr-dict `:` type($operand) `->` type($result)

Restituisce Lgamma(operand) elemento per elemento.

Tratti: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

Interfacce: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

chlo.next_after (chlo::NextAfterOp)

Operatore Std::nextafter

Sintassi:

operation ::= `chlo.next_after` $x `,` $y attr-dict `:` type($x) `,` type($y) `->` type(results)

Restituisce il successivo valore rappresentabile di x nella direzione di y, elemento per elemento. Può anche restituire un numero subnormale.

Equivalente alla funzione std::nextafter di C++.

Tratti: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType

Interfacce: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

chlo.polygamma (chlo::PolygammaOp)

Funzione poligamma

Sintassi:

operation ::= `chlo.polygamma` $n `,` $x attr-dict `:` type($n) `,` type($x) `->` type(results)

Restituisce Polygamma(operand, operand) elemento per elemento.

Tratti: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType

Interfacce: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

chlo.ragged_dot (chlo::RaggedDotOp)

Calcola un matmul su una singola dimensione irregolare

Questa operazione accetta tre argomenti tensore: lhs, rhs e group_sizes, nonché un attributo "ragged_dot_dimension_numbers". Come dot_general, lhs e rhs consentono dimensioni di batch e contrazione arbitrarie. Inoltre, il lato sinistro deve avere una dimensione irregolare e il lato destro può avere al massimo una dimensione di gruppo. L'operazione ha tre modalità, a seconda del tipo di dimensione irregolare LHS.

Nella modalità 1, la firma della forma è [b,m,k], [g,b,k,n], [b,g] -> [b,m,n]. In questo caso, la dimensione irregolare è una dimensione non contrattante a sinistra (m). Le dimensioni b e k rappresentano rispettivamente le dimensioni batch e contrattanti. Il lato destro deve avere una dimensione di gruppo (g).

Nella modalità 2, la firma della forma è [b,m,k], [b,k,n], [b,g] -> [g,b,m,n]. In questo caso, la dimensione irregolare è una dimensione di contrazione sinistra/destra (k).

Nella modalità 3, la firma della forma è [b,m,k], [b,k,n], [g] -> [b,m,n]. In questo caso, la dimensione irregolare è una dimensione batch a sinistra/destra (b).

Tratti: AlwaysSpeculatableImplTrait

Interfacce: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effetti: MemoryEffects::Effect{}

Attributi:

Operandi:

Risultati:

chlo.scan (chlo::ScanOp)

Operazione di scansione

Applica una funzione di riduzione body a inputs e inits lungo dimension e produce results (composto da outputs e carries).

Se is_reverse è true, la scansione viene eseguita in ordine inverso. is_associative indica se la funzione di riduzione è associativa.

Consulta: https://www.tensorflow.org/xla/operation_semantics#scan

Al momento ScanOp non ha una decomposizione in StableHLO.

Tratti: AttrSizedOperandSegments, AttrSizedResultSegments, InferTensorType, IsolatedFromAbove, RecursiveMemoryEffects

Interfacce: InferShapedTypeOpInterface, InferTypeOpInterface, OpAsmOpInterface

Attributi:

Operandi:

Risultati:

chlo.sinh (chlo::SinhOp)

Operazione Sinh

Sintassi:

operation ::= `chlo.sinh` $operand attr-dict `:` type($operand) `->` type($result)

Restituisce Sinh(operand) elemento per elemento.

\[ \sinh(x) = (e^x - e^-x) / 2 if |x| < 1 = e^(x + log(1/2)) - e^(-x + log(1/2)) otherwise. \]

Tratti: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

Interfacce: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

chlo.square (chlo::SquareOp)

Operazione quadrata

Sintassi:

operation ::= `chlo.square` $operand attr-dict `:` type($operand) `->` type($result)

Restituisce Square(operand) elemento per elemento.

\[ \square(x) = complex((x.real - x.imag) * (x.real + x.imag), x.real * x.imag * 2) if x is a complex number = x * x otherwise \]

Tratti: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

Interfacce: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

chlo.tan (chlo::TanOp)

Operazione Tan

Sintassi:

operation ::= `chlo.tan` $operand attr-dict `:` type($operand) `->` type($result)

Restituisce Tan(operand) elemento per elemento.

\[ \tan(x) = \sin(x) / \cos(x) \]

Tratti: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

Interfacce: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

chlo.top_k (chlo::TopKOp)

Trova i valori e gli indici dei k elementi più grandi per l'ultima dimensione

Sintassi:

operation ::= `chlo.top_k` `(`$operand `,` `k` `=` $k`)` attr-dict `:`
              type($operand) `->` `(`type($values)`,` type($indices)`)`

Se l'input è un vettore (di rango 1), trova le k voci più grandi nel vettore e restituisce i relativi valori e indici come vettori. Pertanto, values[j] è la j-esima voce più grande in input e il suo indice è indices[j].

Per le matrici (risp. input di rango superiore), calcola le prime k voci in ogni riga (risp. vettore lungo l'ultima dimensione). Pertanto,

values.shape = indices.shape = input.shape[:-1] + [k]

Se due elementi sono uguali, viene visualizzato per primo l'elemento con indice inferiore.

Tratti: AlwaysSpeculatableImplTrait, InferTensorType

Interfacce: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effetti: MemoryEffects::Effect{}

Attributi:

Operandi:

Risultati:

chlo.zeta (chlo::ZetaOp)

Funzione zeta di Hurwitz

Sintassi:

operation ::= `chlo.zeta` $x `,` $q attr-dict `:` type($x) `,` type($q) `->` type(results)

Restituisce Zeta(operand, operand) elemento per elemento.

\[ \(\zeta(x, q) = \sum_{n=0}^{\infty} (q + n)^{-x}\) \]

Tratti: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType

Interfacce: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

Attributi

ComparisonDirectionAttr

Quale operazione di confronto eseguire.

Sintassi:

#chlo.comparison_direction<
  ::mlir::chlo::ComparisonDirection   # value
>

Parametri:

ComparisonTypeAttr

Quale tipo di confronto utilizzare.

Sintassi:

#chlo.comparison_type<
  ::mlir::chlo::ComparisonType   # value
>

Parametri:

PrecisionAttr

Precisione XLA per un operando. Ha un significato specifico per il backend.

Sintassi:

#chlo.precision<
  ::mlir::chlo::Precision   # value
>

Parametri:

RaggedDotDimensionNumbersAttr

Attributo che modella le informazioni sulle dimensioni per il punto irregolare.

Parametri:

Enum

ComparisonDirection

Quale operazione di confronto eseguire.

Custodie:

ComparisonType

Quale tipo di confronto utilizzare.

Custodie:

Precisione

Precisione XLA per un operando. Ha un significato specifico per il backend.

Custodie: