'chlo' Dialect

クライアント HLO Ops

この言語には、XlaBuilder C++ API の API サーフェス領域と密接に連携する op が含まれています。このような op には、下位レベルの言語（stablehlo など）に存在するものを超えるセマンティクスがあります。基本的に、クライアント ライブラリが API 呼び出しに複数の op の構文糖衣または構成を使用する場合、この言語は API 呼び出しをモデル化し、下位レベルの言語に完全に具体化するための変換パターンを提供しようとします。

運用

chlo._asin_acos_kernel（chlo::AsinAcosKernelOp）

AsinAcosKernel 演算子

構文:

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

AsinAcosKernel(operand) を要素ごとに返します。

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))

この op は分解の中間値として使用され、フレームワークによって直接構築されたり、バックエンドによって使用されたりすることはありません。

トレイト: AlwaysSpeculatableImplTrait、CompatibleOperandsAndResultType、Elementwise、SameOperandsAndResultShape

インターフェース: ConditionallySpeculatable、InferShapedTypeOpInterface、InferTypeOpInterface、NoMemoryEffect (MemoryEffectOpInterface)

効果: MemoryEffects::Effect{}

オペランド:

結果:

chlo.acos（chlo::AcosOp）

Acos 演算子

構文:

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

Acos(operand) を要素ごとに返します。

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

トレイト: AlwaysSpeculatableImplTrait、CompatibleOperandsAndResultType、Elementwise、SameOperandsAndResultShape

インターフェース: ConditionallySpeculatable、InferShapedTypeOpInterface、InferTypeOpInterface、NoMemoryEffect (MemoryEffectOpInterface)

効果: MemoryEffects::Effect{}

オペランド:

結果:

chlo.acosh（chlo::AcoshOp）

Acosh オペレーション

構文:

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

Acosh(operand) を要素ごとに返します。

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

トレイト: AlwaysSpeculatableImplTrait、CompatibleOperandsAndResultType、Elementwise、SameOperandsAndResultShape

インターフェース: ConditionallySpeculatable、InferShapedTypeOpInterface、InferTypeOpInterface、NoMemoryEffect (MemoryEffectOpInterface)

効果: MemoryEffects::Effect{}

オペランド:

結果:

chlo.asin（chlo::AsinOp）

Asin 演算子

構文:

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

Asin(operand) を要素ごとに返します。

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

トレイト: AlwaysSpeculatableImplTrait、CompatibleOperandsAndResultType、Elementwise、SameOperandsAndResultShape

インターフェース: ConditionallySpeculatable、InferShapedTypeOpInterface、InferTypeOpInterface、NoMemoryEffect (MemoryEffectOpInterface)

効果: MemoryEffects::Effect{}

オペランド:

結果:

chlo.asinh（chlo::AsinhOp）

Asinh オペレーション

構文:

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

Asinh(operand) を要素ごとに返します。

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

トレイト: AlwaysSpeculatableImplTrait、CompatibleOperandsAndResultType、Elementwise、SameOperandsAndResultShape

インターフェース: ConditionallySpeculatable、InferShapedTypeOpInterface、InferTypeOpInterface、NoMemoryEffect (MemoryEffectOpInterface)

効果: MemoryEffects::Effect{}

オペランド:

結果:

chlo.atan（chlo::AtanOp）

Atan 演算子

構文:

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

Atan(operand) を要素ごとに返します。

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

トレイト: AlwaysSpeculatableImplTrait、CompatibleOperandsAndResultType、Elementwise、SameOperandsAndResultShape

インターフェース: ConditionallySpeculatable、InferShapedTypeOpInterface、InferTypeOpInterface、NoMemoryEffect (MemoryEffectOpInterface)

効果: MemoryEffects::Effect{}

オペランド:

結果:

chlo.atanh（chlo::AtanhOp）

Atanh 演算子

構文:

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

Atanh(operand) を要素ごとに返します。

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

トレイト: AlwaysSpeculatableImplTrait、CompatibleOperandsAndResultType、Elementwise、SameOperandsAndResultShape

インターフェース: ConditionallySpeculatable、InferShapedTypeOpInterface、InferTypeOpInterface、NoMemoryEffect (MemoryEffectOpInterface)

効果: MemoryEffects::Effect{}

オペランド:

結果:

chlo.bessel_i1e（chlo::BesselI1eOp）

1 次のベッセル関数

構文:

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

bessel_i1e(operand) を要素ごとに返します。

トレイト: AlwaysSpeculatableImplTrait、CompatibleOperandsAndResultType、Elementwise、SameOperandsAndResultShape

インターフェース: ConditionallySpeculatable、InferShapedTypeOpInterface、InferTypeOpInterface、NoMemoryEffect (MemoryEffectOpInterface)

効果: MemoryEffects::Effect{}

オペランド:

結果:

chlo.broadcast_add（chlo::BroadcastAddOp）

加算演算子（ブロードキャストは省略可）

構文:

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

lhs + rhs を要素ごとに返します。

https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations をご覧ください。

トレイト: AlwaysSpeculatableImplTrait、CHLO_Broadcasting、Commutative、HLO_BroadcastingElementwise、HLO_CompatibleOperandsAndResultElementType、InferTensorType

インターフェース: ConditionallySpeculatable、InferShapedTypeOpInterface、InferTypeOpInterface、NoMemoryEffect (MemoryEffectOpInterface)

効果: MemoryEffects::Effect{}

属性:

オペランド:

結果:

chlo.broadcast_and（chlo::BroadcastAndOp）

論理積演算子（ブロードキャストは省略可）

構文:

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

logical_and(lhs, rhs) を要素ごとに返します。

https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations をご覧ください。

トレイト: AlwaysSpeculatableImplTrait、CHLO_Broadcasting、Commutative、HLO_BroadcastingElementwise、InferTensorType

インターフェース: ConditionallySpeculatable、InferShapedTypeOpInterface、InferTypeOpInterface、NoMemoryEffect (MemoryEffectOpInterface)

効果: MemoryEffects::Effect{}

属性:

オペランド:

結果:

chlo.broadcast_atan2（chlo::BroadcastAtan2Op）

Atan2 演算子（ブロードキャストは省略可）

構文:

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

atan2(lhs/rhs) を要素ごとに返します。

https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations をご覧ください。

トレイト: AlwaysSpeculatableImplTrait、CHLO_Broadcasting、HLO_BroadcastingElementwise、InferTensorType、SameOperandsAndResultElementType

インターフェース: ConditionallySpeculatable、InferShapedTypeOpInterface、InferTypeOpInterface、NoMemoryEffect (MemoryEffectOpInterface)

効果: MemoryEffects::Effect{}

属性:

オペランド:

結果:

chlo.broadcast_compare（chlo::BroadcastCompareOp）

比較演算子（ブロードキャストは省略可）

構文:

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

comparison_direction と compare_type に従って、lhs と rhs を要素ごとに比較します。指定しない場合、compare_type は浮動小数点要素型の場合は FLOAT、符号付き要素型の場合は SIGNED、符号なし要素型の場合は UNSIGNED になります。

https://www.tensorflow.org/xla/operation_semantics#element-wise_comparison_operations をご覧ください。

トレイト: AlwaysSpeculatableImplTrait、CHLO_Broadcasting、HLO_BroadcastingElementwise、InferTensorType

インターフェース: ConditionallySpeculatable、InferShapedTypeOpInterface、InferTypeOpInterface、NoMemoryEffect (MemoryEffectOpInterface)

効果: MemoryEffects::Effect{}

属性:

オペランド:

結果:

chlo.broadcast_complex（chlo::BroadcastComplexOp）

複合演算子（ブロードキャストは省略可）

構文:

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

実数値と虚数値のペアを要素ごとに複素数値に変換します。

トレイト: AlwaysSpeculatableImplTrait、CHLO_Broadcasting、HLO_BroadcastingElementwise、InferTensorType

インターフェース: ConditionallySpeculatable、InferShapedTypeOpInterface、InferTypeOpInterface、NoMemoryEffect (MemoryEffectOpInterface)

効果: MemoryEffects::Effect{}

属性:

オペランド:

結果:

chlo.broadcast_divide（chlo::BroadcastDivOp）

除算演算子（ブロードキャストは省略可）

構文:

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

lhs / rhs を要素ごとに返します。

https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations をご覧ください。

トレイト: AlwaysSpeculatableImplTrait、CHLO_Broadcasting、HLO_BroadcastingElementwise、InferTensorType、SameOperandsAndResultElementType

インターフェース: ConditionallySpeculatable、InferShapedTypeOpInterface、InferTypeOpInterface、NoMemoryEffect (MemoryEffectOpInterface)

効果: MemoryEffects::Effect{}

属性:

オペランド:

結果:

chlo.broadcast_maximum（chlo::BroadcastMaxOp）

最大オペレーター（ブロードキャストは任意）

構文:

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

max(lhs, rhs) を要素ごとに返します。

https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations をご覧ください。

トレイト: AlwaysSpeculatableImplTrait、CHLO_Broadcasting、Commutative、HLO_BroadcastingElementwise、HLO_CompatibleOperandsAndResultElementType、InferTensorType

インターフェース: ConditionallySpeculatable、InferShapedTypeOpInterface、InferTypeOpInterface、NoMemoryEffect (MemoryEffectOpInterface)

効果: MemoryEffects::Effect{}

属性:

オペランド:

結果:

chlo.broadcast_minimum（chlo::BroadcastMinOp）

最小演算子（ブロードキャストは省略可）

構文:

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

min(lhs, rhs) を要素ごとに返します。

https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations をご覧ください。

トレイト: AlwaysSpeculatableImplTrait、CHLO_Broadcasting、Commutative、HLO_BroadcastingElementwise、HLO_CompatibleOperandsAndResultElementType、InferTensorType

インターフェース: ConditionallySpeculatable、InferShapedTypeOpInterface、InferTypeOpInterface、NoMemoryEffect (MemoryEffectOpInterface)

効果: MemoryEffects::Effect{}

属性:

オペランド:

結果:

chlo.broadcast_multiply（chlo::BroadcastMulOp）

乗算演算子（ブロードキャストは省略可）

構文:

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

lhs * rhs を要素ごとに返します。

https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations をご覧ください。

トレイト: AlwaysSpeculatableImplTrait、CHLO_Broadcasting、Commutative、HLO_BroadcastingElementwise、InferTensorType、SameOperandsAndResultElementType

インターフェース: ConditionallySpeculatable、InferShapedTypeOpInterface、InferTypeOpInterface、NoMemoryEffect (MemoryEffectOpInterface)

効果: MemoryEffects::Effect{}

属性:

オペランド:

結果:

chlo.broadcast_next_after（chlo::BroadcastNextAfterOp）

Std::nextafter 演算子（ブロードキャストは省略可）

構文:

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

rhs の方向に lhs の次に表現可能な値を要素ごとに返します。非正規化数を返すこともあります。

C++ の std::nextafter 関数と同等です。

トレイト: AlwaysSpeculatableImplTrait、CHLO_Broadcasting、HLO_BroadcastingElementwise、InferTensorType、SameOperandsAndResultElementType

インターフェース: ConditionallySpeculatable、InferShapedTypeOpInterface、InferTypeOpInterface、NoMemoryEffect (MemoryEffectOpInterface)

効果: MemoryEffects::Effect{}

属性:

オペランド:

結果:

chlo.broadcast_or（chlo::BroadcastOrOp）

論理 OR 演算子（ブロードキャストは省略可）

構文:

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

logical_or(lhs, rhs) を要素ごとに返します。

https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations をご覧ください。

トレイト: AlwaysSpeculatableImplTrait、CHLO_Broadcasting、Commutative、HLO_BroadcastingElementwise、InferTensorType

インターフェース: ConditionallySpeculatable、InferShapedTypeOpInterface、InferTypeOpInterface、NoMemoryEffect (MemoryEffectOpInterface)

効果: MemoryEffects::Effect{}

属性:

オペランド:

結果:

chlo.broadcast_polygamma（chlo::BroadcastPolygammaOp）

ポリガンマ関数（ブロードキャストは省略可）

構文:

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

Polygamma(operand, operand) を要素ごとに返します。

トレイト: AlwaysSpeculatableImplTrait、CHLO_Broadcasting、HLO_BroadcastingElementwise、InferTensorType、SameOperandsAndResultElementType

インターフェース: ConditionallySpeculatable、InferShapedTypeOpInterface、InferTypeOpInterface、NoMemoryEffect (MemoryEffectOpInterface)

効果: MemoryEffects::Effect{}

属性:

オペランド:

結果:

chlo.broadcast_power（chlo::BroadcastPowOp）

べき乗演算子（ブロードキャストは省略可）

構文:

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

lhs ^ rhs を要素ごとに返します。

https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations をご覧ください。

トレイト: AlwaysSpeculatableImplTrait、CHLO_Broadcasting、HLO_BroadcastingElementwise、InferTensorType、SameOperandsAndResultElementType

インターフェース: ConditionallySpeculatable、InferShapedTypeOpInterface、InferTypeOpInterface、NoMemoryEffect (MemoryEffectOpInterface)

効果: MemoryEffects::Effect{}

属性:

オペランド:

結果:

chlo.broadcast_remainder（chlo::BroadcastRemOp）

剰余演算子（ブロードキャストは省略可）

構文:

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

lhs % rhs を要素ごとに返します。

https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations をご覧ください。

トレイト: AlwaysSpeculatableImplTrait、CHLO_Broadcasting、HLO_BroadcastingElementwise、InferTensorType、SameOperandsAndResultElementType

インターフェース: ConditionallySpeculatable、InferShapedTypeOpInterface、InferTypeOpInterface、NoMemoryEffect (MemoryEffectOpInterface)

効果: MemoryEffects::Effect{}

属性:

オペランド:

結果:

chlo.broadcast_select（chlo::BroadcastSelectOp）

演算子を選択（numpy スタイルのブロードキャストは省略可）

構文:

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

述語配列の値に基づいて、2 つの入力配列の要素から出力配列を作成します。

https://www.tensorflow.org/xla/operation_semantics#select をご覧ください。

トレイト: AlwaysSpeculatableImplTrait、CHLO_Broadcasting、HLO_BroadcastingElementwise、InferTensorType

インターフェース: ConditionallySpeculatable、InferShapedTypeOpInterface、InferTypeOpInterface、NoMemoryEffect (MemoryEffectOpInterface)

効果: MemoryEffects::Effect{}

オペランド:

結果:

chlo.broadcast_shift_left（chlo::BroadcastShiftLeftOp）

左シフト演算子（ブロードキャストは省略可）

構文:

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

lhs << rhs を要素ごとに返します。

https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations をご覧ください。

トレイト: AlwaysSpeculatableImplTrait、CHLO_Broadcasting、HLO_BroadcastingElementwise、InferTensorType、SameOperandsAndResultElementType

インターフェース: ConditionallySpeculatable、InferShapedTypeOpInterface、InferTypeOpInterface、NoMemoryEffect (MemoryEffectOpInterface)

効果: MemoryEffects::Effect{}

属性:

オペランド:

結果:

chlo.broadcast_shift_right_arithmetic（chlo::BroadcastShiftRightArithmeticOp）

右シフト算術演算子（ブロードキャストは省略可）

構文:

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

lhs >> rhs を要素ごとに返します。

https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations をご覧ください。

トレイト: AlwaysSpeculatableImplTrait、CHLO_Broadcasting、HLO_BroadcastingElementwise、InferTensorType、SameOperandsAndResultElementType

インターフェース: ConditionallySpeculatable、InferShapedTypeOpInterface、InferTypeOpInterface、NoMemoryEffect (MemoryEffectOpInterface)

効果: MemoryEffects::Effect{}

属性:

オペランド:

結果:

chlo.broadcast_shift_right_logical（chlo::BroadcastShiftRightLogicalOp）

右シフト論理演算子（ブロードキャストは省略可）

構文:

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

lhs >> rhs を要素ごとに返します。

https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations をご覧ください。

トレイト: AlwaysSpeculatableImplTrait、CHLO_Broadcasting、HLO_BroadcastingElementwise、InferTensorType、SameOperandsAndResultElementType

インターフェース: ConditionallySpeculatable、InferShapedTypeOpInterface、InferTypeOpInterface、NoMemoryEffect (MemoryEffectOpInterface)

効果: MemoryEffects::Effect{}

属性:

オペランド:

結果:

chlo.broadcast_subtract（chlo::BroadcastSubOp）

減算演算子（ブロードキャストは省略可）

構文:

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

lhs - rhs を要素ごとに返します。

https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations をご覧ください。

トレイト: AlwaysSpeculatableImplTrait、CHLO_Broadcasting、HLO_BroadcastingElementwise、InferTensorType、SameOperandsAndResultElementType

インターフェース: ConditionallySpeculatable、InferShapedTypeOpInterface、InferTypeOpInterface、NoMemoryEffect (MemoryEffectOpInterface)

効果: MemoryEffects::Effect{}

属性:

オペランド:

結果:

chlo.broadcast_xor（chlo::BroadcastXorOp）

論理 XOR 演算子（ブロードキャストは省略可）

構文:

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

logical_xor(lhs, rhs) を要素ごとに返します。

https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations をご覧ください。

トレイト: AlwaysSpeculatableImplTrait、CHLO_Broadcasting、Commutative、HLO_BroadcastingElementwise、InferTensorType

インターフェース: ConditionallySpeculatable、InferShapedTypeOpInterface、InferTypeOpInterface、NoMemoryEffect (MemoryEffectOpInterface)

効果: MemoryEffects::Effect{}

属性:

オペランド:

結果:

chlo.broadcast_zeta（chlo::BroadcastZetaOp）

Hurwitz zeta function

構文:

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

Zeta(operand, operand) を要素ごとに返します。

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

トレイト: AlwaysSpeculatableImplTrait、CHLO_Broadcasting、HLO_BroadcastingElementwise、InferTensorType、SameOperandsAndResultElementType

インターフェース: ConditionallySpeculatable、InferShapedTypeOpInterface、InferTypeOpInterface、NoMemoryEffect (MemoryEffectOpInterface)

効果: MemoryEffects::Effect{}

属性:

オペランド:

結果:

chlo.conj（chlo::ConjOp）

Conj 演算子

構文:

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

Conj(operand) を要素ごとに返します。

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

トレイト: AlwaysSpeculatableImplTrait、CompatibleOperandsAndResultType、Elementwise、SameOperandsAndResultShape

インターフェース: ConditionallySpeculatable、InferShapedTypeOpInterface、InferTypeOpInterface、NoMemoryEffect (MemoryEffectOpInterface)

効果: MemoryEffects::Effect{}

オペランド:

結果:

chlo.constant（chlo::ConstantOp）

定数演算子

構文:

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

定数値を表します。

特性: AlwaysSpeculatableImplTrait、ConstantLike

インターフェース: ConditionallySpeculatable、InferTypeOpInterface、NoMemoryEffect (MemoryEffectOpInterface)

効果: MemoryEffects::Effect{}

属性:

結果:

chlo.constant_like（chlo::ConstantLikeOp）

定数類似演算子

オペランドと同じ形状のスプラット定数を返します。

トレイト: AlwaysSpeculatableImplTrait、CHLO_Broadcasting、HLO_BroadcastingElementwise、InferTensorType、SameOperandsAndResultShape

インターフェース: ConditionallySpeculatable、InferShapedTypeOpInterface、InferTypeOpInterface、NoMemoryEffect (MemoryEffectOpInterface)

効果: MemoryEffects::Effect{}

属性:

オペランド:

結果:

chlo.cosh（chlo::CoshOp）

Cosh 演算子

構文:

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

Cosh(operand) を要素ごとに返します。

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

トレイト: AlwaysSpeculatableImplTrait、CompatibleOperandsAndResultType、Elementwise、SameOperandsAndResultShape

インターフェース: ConditionallySpeculatable、InferShapedTypeOpInterface、InferTypeOpInterface、NoMemoryEffect (MemoryEffectOpInterface)

効果: MemoryEffects::Effect{}

オペランド:

結果:

chlo.digamma（chlo::DigammaOp）

Digamma 関数

構文:

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

Digamma(operand) を要素ごとに返します。

トレイト: AlwaysSpeculatableImplTrait、CompatibleOperandsAndResultType、Elementwise、SameOperandsAndResultShape

インターフェース: ConditionallySpeculatable、InferShapedTypeOpInterface、InferTypeOpInterface、NoMemoryEffect (MemoryEffectOpInterface)

効果: MemoryEffects::Effect{}

オペランド:

結果:

chlo.erf（chlo::ErfOp）

Erfc 演算子

構文:

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

x のガウスの誤差関数を要素ごとに計算します。

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

トレイト: AlwaysSpeculatableImplTrait、CompatibleOperandsAndResultType、Elementwise、SameOperandsAndResultShape

インターフェース: ConditionallySpeculatable、InferShapedTypeOpInterface、InferTypeOpInterface、NoMemoryEffect (MemoryEffectOpInterface)

効果: MemoryEffects::Effect{}

オペランド:

結果:

chlo.erf_inv（chlo::ErfInvOp）

逆誤差関数

構文:

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

ErfInv(operand) を要素ごとに返します。

トレイト: AlwaysSpeculatableImplTrait、CompatibleOperandsAndResultType、Elementwise、SameOperandsAndResultShape

インターフェース: ConditionallySpeculatable、InferShapedTypeOpInterface、InferTypeOpInterface、NoMemoryEffect (MemoryEffectOpInterface)

効果: MemoryEffects::Effect{}

オペランド:

結果:

chlo.erfc（chlo::ErfcOp）

Erfc 演算子

構文:

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

誤差関数補完（1 - erf(x)）の近似値を計算します。

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

トレイト: AlwaysSpeculatableImplTrait、CompatibleOperandsAndResultType、Elementwise、SameOperandsAndResultShape

インターフェース: ConditionallySpeculatable、InferShapedTypeOpInterface、InferTypeOpInterface、NoMemoryEffect (MemoryEffectOpInterface)

効果: MemoryEffects::Effect{}

オペランド:

結果:

chlo.is_inf（chlo::IsInfOp）

IsInf 述語

構文:

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

値が +/-inf であるかどうかを要素ごとに返します。

トレイト: AlwaysSpeculatableImplTrait、Elementwise、SameOperandsAndResultShape

インターフェース: ConditionallySpeculatable、InferShapedTypeOpInterface、InferTypeOpInterface、NoMemoryEffect (MemoryEffectOpInterface)

効果: MemoryEffects::Effect{}

オペランド:

結果:

chlo.is_neg_inf（chlo::IsNegInfOp）

IsNegInf 述語

構文:

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

値が -inf かどうかを要素ごとに返します。

トレイト: AlwaysSpeculatableImplTrait、Elementwise、SameOperandsAndResultShape

インターフェース: ConditionallySpeculatable、InferShapedTypeOpInterface、InferTypeOpInterface、NoMemoryEffect (MemoryEffectOpInterface)

効果: MemoryEffects::Effect{}

オペランド:

結果:

chlo.is_pos_inf（chlo::IsPosInfOp）

IsPosInf 述語

構文:

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

値が +inf かどうかを要素ごとに返します。

トレイト: AlwaysSpeculatableImplTrait、Elementwise、SameOperandsAndResultShape

インターフェース: ConditionallySpeculatable、InferShapedTypeOpInterface、InferTypeOpInterface、NoMemoryEffect (MemoryEffectOpInterface)

効果: MemoryEffects::Effect{}

オペランド:

結果:

chlo.lgamma（chlo::LgammaOp）

Lgamma 関数

構文:

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

Lgamma(operand) を要素ごとに返します。

トレイト: AlwaysSpeculatableImplTrait、CompatibleOperandsAndResultType、Elementwise、SameOperandsAndResultShape

インターフェース: ConditionallySpeculatable、InferShapedTypeOpInterface、InferTypeOpInterface、NoMemoryEffect (MemoryEffectOpInterface)

効果: MemoryEffects::Effect{}

オペランド:

結果:

chlo.next_after（chlo::NextAfterOp）

Std::nextafter 演算子

構文:

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

y の方向に x の次に表現可能な値を要素ごとに返します。非正規化数を返すこともあります。

C++ の std::nextafter 関数と同等です。

特性: AlwaysSpeculatableImplTrait、CompatibleOperandsAndResultType

インターフェース: ConditionallySpeculatable、InferShapedTypeOpInterface、InferTypeOpInterface、NoMemoryEffect (MemoryEffectOpInterface)

効果: MemoryEffects::Effect{}

オペランド:

結果:

chlo.polygamma（chlo::PolygammaOp）

ポリガンマ関数

構文:

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

Polygamma(operand, operand) を要素ごとに返します。

特性: AlwaysSpeculatableImplTrait、CompatibleOperandsAndResultType

インターフェース: ConditionallySpeculatable、InferShapedTypeOpInterface、InferTypeOpInterface、NoMemoryEffect (MemoryEffectOpInterface)

効果: MemoryEffects::Effect{}

オペランド:

結果:

chlo.ragged_dot（chlo::RaggedDotOp）

1 つのラグド ディメンションで matmul を計算します

このオペレーションは、lhs、rhs、group_sizes の 3 つのテンソル引数と、ragged_dot_dimension_numbers 属性を取ります。dot_general と同様に、lhs と rhs には任意のバッチ ディメンションと縮約ディメンションを使用できます。また、lhs には 1 つのラグド ディメンションが必要であり、rhs には最大 1 つのグループ ディメンションを含めることができます。演算は、左辺のラグド ディメンションの種類に応じて 3 つのモードがあります。

モード 1 では、シェイプ シグネチャは [b,m,k], [g,b,k,n], [b,g] -> [b,m,n] です。ここで、不揃いディメンションは左辺の非収縮ディメンション（m）です。ディメンション b と k は、それぞれバッチ ディメンションと収縮ディメンションを表します。右辺にはグループ ディメンション（g）が必要です。

モード 2 では、シェイプ シグネチャは [b,m,k], [b,k,n], [b,g] -> [g,b,m,n] です。ここで、不揃いなディメンションは左辺/右辺の縮約ディメンション（k）です。

モード 3 では、シェイプ シグネチャは [b,m,k], [b,k,n], [g] -> [b,m,n] です。ここで、ラグド ディメンションは lhs/rhs バッチ ディメンション（b）です。

特性: AlwaysSpeculatableImplTrait

インターフェース: ConditionallySpeculatable、NoMemoryEffect (MemoryEffectOpInterface)

効果: MemoryEffects::Effect{}

属性:

オペランド:

結果:

chlo.scan（chlo::ScanOp）

スキャン オペレーション

dimension に沿って inputs と inits に削減関数 body を適用し、results（outputs と carries で構成される）を生成します。

is_reverse が true の場合、スキャンは逆順で実行されます。is_associative は、削減関数が結合的かどうかを示します。

参照: https://www.tensorflow.org/xla/operation_semantics#scan

ScanOp には現在、StableHLO への分解がありません。

トレイト: AttrSizedOperandSegments、AttrSizedResultSegments、InferTensorType、IsolatedFromAbove、RecursiveMemoryEffects

インターフェース: InferShapedTypeOpInterface、InferTypeOpInterface、OpAsmOpInterface

属性:

オペランド:

結果:

chlo.sinh（chlo::SinhOp）

Sinh オペレーション

構文:

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

Sinh(operand) を要素ごとに返します。

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

トレイト: AlwaysSpeculatableImplTrait、CompatibleOperandsAndResultType、Elementwise、SameOperandsAndResultShape

インターフェース: ConditionallySpeculatable、InferShapedTypeOpInterface、InferTypeOpInterface、NoMemoryEffect (MemoryEffectOpInterface)

効果: MemoryEffects::Effect{}

オペランド:

結果:

chlo.square（chlo::SquareOp）

Square オペレーション

構文:

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

Square(operand) を要素ごとに返します。

\[ \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 \]

トレイト: AlwaysSpeculatableImplTrait、CompatibleOperandsAndResultType、Elementwise、SameOperandsAndResultShape

インターフェース: ConditionallySpeculatable、InferShapedTypeOpInterface、InferTypeOpInterface、NoMemoryEffect (MemoryEffectOpInterface)

効果: MemoryEffects::Effect{}

オペランド:

結果:

chlo.tan（chlo::TanOp）

Tan オペレーション

構文:

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

Tan(operand) を要素ごとに返します。

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

トレイト: AlwaysSpeculatableImplTrait、CompatibleOperandsAndResultType、Elementwise、SameOperandsAndResultShape

インターフェース: ConditionallySpeculatable、InferShapedTypeOpInterface、InferTypeOpInterface、NoMemoryEffect (MemoryEffectOpInterface)

効果: MemoryEffects::Effect{}

オペランド:

結果:

chlo.top_k（chlo::TopKOp）

最後の次元の k 個の最大要素の値とインデックスを検索します。

構文:

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

入力がベクトル（ランク 1）の場合、ベクトル内の k 個の最大エントリを見つけ、その値とインデックスをベクトルとして出力します。したがって、values[j] は input の j 番目に大きいエントリであり、そのインデックスは indices[j] です。

行列（または高ランクの入力）の場合、各行（または最後の次元に沿ったベクトル）の上位 k 個のエントリを計算します。つまり、

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

2 つの要素が等しい場合は、インデックスの小さい要素が先に表示されます。

特性: AlwaysSpeculatableImplTrait、InferTensorType

インターフェース: ConditionallySpeculatable、InferShapedTypeOpInterface、InferTypeOpInterface、NoMemoryEffect (MemoryEffectOpInterface)

効果: MemoryEffects::Effect{}

属性:

オペランド:

結果:

chlo.zeta（chlo::ZetaOp）

Hurwitz zeta function

構文:

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

Zeta(operand, operand) を要素ごとに返します。

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

特性: AlwaysSpeculatableImplTrait、CompatibleOperandsAndResultType

インターフェース: ConditionallySpeculatable、InferShapedTypeOpInterface、InferTypeOpInterface、NoMemoryEffect (MemoryEffectOpInterface)

効果: MemoryEffects::Effect{}

オペランド:

結果:

属性

ComparisonDirectionAttr

実行する比較オペレーション。

構文:

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

パラメータ:

ComparisonTypeAttr

使用する比較タイプ。

構文:

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

パラメータ:

PrecisionAttr

オペランドの XLA 精度。バックエンド固有の意味を持ちます。

構文:

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

パラメータ:

RaggedDotDimensionNumbersAttr

不揃いなドットのディメンション情報をモデル化する属性。

パラメータ:

列挙型

ComparisonDirection

実行する比較オペレーション。

Cases:

ComparisonType

使用する比較タイプ。

Cases:

適合率

オペランドの XLA 精度。バックエンド固有の意味を持ちます。

Cases: