【Julia】adjoint()でよくあるエラーと解決策！予期せぬ挙動を防ぐトラブルシューティング

2025-05-27

行列の共役転置 (Conjugate Transpose)

線形代数におけるadjoint()関数は、行列の**共役転置 (conjugate transpose)**を計算します。これは、行列の要素をそれぞれ複素共役に取り、その後に転置する操作です。

複素数行列 A の場合、A の共役転置は AH（エルミート転置と呼ばれることもあります）と表記され、各要素 aijが ajiとなります。
実数行列 A の場合、A の共役転置は単に転置 AT と同じになります。

Juliaでは、adjoint(A) または簡潔に A' と書くことでこの操作を行うことができます。

例

julia> A = [1+2im 3+4im; 5+6im 7+8im]
2×2 Matrix{Complex{Int64}}:
 1+2im  3+4im
 5+6im  7+8im

julia> adjoint(A)
2×2 Adjoint{Complex{Int64}, Matrix{Complex{Int64}}}:
 1-2im  5-6im
 3-4im  7-8im

julia> A' # 同じ結果
2×2 Adjoint{Complex{Int64}, Matrix{Complex{Int64}}}:
 1-2im  5-6im
 3-4im  7-8im

なぜ `Adjoint` 型が返されるのか？

adjoint()関数は、多くの場合、新しい配列を割り当てるのではなく、元の配列への**ビュー (view)**として Adjoint 型のオブジェクトを返します。これはメモリ効率を良くし、大規模な行列操作でのパフォーマンスを向上させるためです。必要に応じて、Array(A') のように Array() コンストラクタを使って明示的に配列に変換することも可能です。

機械学習や最適化の分野では、「adjoint」という用語が**自動微分 (Automatic Differentiation, AD)**の文脈で使われることがあります。この場合、随伴（または「随伴作用素」）は、関数の勾配（導関数）を効率的に計算するための概念を指します。特に、**逆モード自動微分 (reverse-mode AD)**において重要になります。

Juliaの自動微分ライブラリ（例えば、Zygote.jlなど）は、この「随伴」の概念を用いて関数の勾配を計算します。これは、線形代数の随伴とは異なる、より抽象的な数学的概念ですが、行列の共役転置が線形写像の随伴作用素の具体的な例であるため、関連性があります。

簡単に言えば、自動微分における随伴は、ある関数の出力の小さな変化が入力の各要素にどのように影響するかを追跡するためのメカニズムを提供します。これにより、多次元の入力を持つ関数の勾配を効率的に計算できます。

例 (Zygote.jlを使った自動微分)

using Zygote

# xに関する関数
f(x) = 3x^2 + 2x + 1

# f(5) の勾配を計算
julia> gradient(f, 5)
(32.0,)

この例では、gradient関数が内部的に「随伴」の考え方を用いて勾配を計算しています。直接adjoint()という関数を呼び出すことはありませんが、自動微分の根底にある重要な概念です。

Juliaにおけるadjoint()は、

行列の共役転置を計算する関数として、線形代数演算で直接使用されます（A' と書くこともできます）。
自動微分の文脈では、関数の勾配計算を効率的に行うための数学的な概念（随伴作用素）を指し、通常は直接関数として呼び出すのではなく、自動微分ライブラリの内部で利用されます。

MethodError: no method matching adjoint(...)

エラーの原因
adjoint()は線形代数の概念に基づいているため、すべてのデータ型に対して定義されているわけではありません。特に、行列や数ではない型（例: DateTimeオブジェクト、String、カスタム構造体など）に対してadjoint()を呼び出そうとすると、このエラーが発生します。

例

julia> using Dates
julia> d = DateTime(2023, 1, 1)
2023-01-01T00:00:00

julia> adjoint(d)
ERROR: MethodError: no method matching adjoint(::DateTime)

トラブルシューティング

文脈を確認する
コードのどの部分でadjoint()が暗黙的に呼ばれているかを確認します。例えば、f'(x)と書いた場合、fが関数の場合、これはadjoint(f)として解釈され、多くの場合エラーになります。関数の微分を意味する場合は、自動微分ライブラリ（Zygote.jlなど）の適切な関数を使用する必要があります。
対象の型が適切か確認する
adjoint()は行列やベクトル、スカラー値（複素数の場合は共役を返す）に対して使用されるべきです。それ以外の型に対して転置のような操作を行いたい場合は、permutedimsなどのより汎用的な関数や、データの構造に応じた手動での操作を検討してください。

Adjoint型による予期せぬ挙動とパフォーマンスの問題

エラー/問題の原因
adjoint()関数は、デフォルトで新しいメモリを割り当てることなく、元の配列の「ビュー」であるAdjoint型（またはTranspose型）を返します。これはメモリ効率が良く、ほとんどの線形代数演算では期待通りに機能しますが、以下のような場合に予期せぬ挙動やパフォーマンスの問題を引き起こすことがあります。

インデックス操作の混乱
ベクトルに'を適用すると、1xN Adjoint型になります。このオブジェクトに対して単一のインデックス（例: vec'[1]）でアクセスしようとすると、Juliaの線形インデックスのルールにより、元のベクトルと同じように振る舞うことがあります。これは、Adjointが「行ベクトル」として機能することを期待している場合に混乱を招く可能性があります。
C/Fortranライブラリとの連携
BLASなどの外部の線形代数ライブラリに配列を渡す場合、それらは連続したメモリレイアウトを期待することがあります。Adjoint型は元のデータのメモリレイアウトを保持しているため、転置された形でデータにアクセスしようとすると、キャッシュ効率が悪くなったり、パフォーマンスが低下したりすることがあります。
ミュータブルな操作
Adjoint型は通常、元のデータへの読み取り専用ビューとして扱われます。Adjointオブジェクトを直接変更しようとするとエラーになったり、意図しない挙動になることがあります。

例 (インデックス操作の混乱)

julia> v = [1, 2, 3]
3-element Vector{Int64}:
 1
 2
 3

julia> v' # 1x3 Adjoint{...}
1×3 adjoint(::Vector{Int64}) with eltype Int64:
 1  2  3

julia> v'[1] # 依然として単一の要素 (線形インデックス)
1

julia> v'[1, 1] # 1x1行列の要素としてアクセス (Cartesianインデックス)
1

トラブルシューティング

permutedimsの検討
adjointが数学的な共役転置であるのに対し、単なる次元の入れ替えを行いたい場合はpermutedimsを検討してください。これは、任意の次元数の配列に対して機能し、より汎用的な「転置」操作を提供します。
パフォーマンスのプロファイリング
Adjoint型をそのまま使用してパフォーマンスが低下しているように感じる場合、@timeや@benchmarkマクロを使用して、どこでボトルネックが発生しているかを特定します。もし、Adjointビューからのデータアクセスが原因であれば、copy()の導入を検討します。
抽象型を利用する
関数を定義する際に、具体的なMatrix型ではなく、AbstractMatrixやAbstractArrayなどの抽象型を引数として受け入れるようにすることで、Adjoint型をそのまま関数に渡せるようにし、メモリ割り当てを避けることができます。
```
function my_func(M::AbstractMatrix)
    # 処理
end
```
明示的なコピーの作成
Adjoint型ではなく、完全に独立した転置された配列が必要な場合は、copy()またはArray()を使って明示的に新しい配列を作成します。
```
A_transposed = collect(A') # または Array(A')
```
これにより、メモリの割り当ては発生しますが、データは連続したメモリに格納され、C/Fortranライブラリへの受け渡しや特定のインデックス操作で問題が解決する場合があります。

数学的な「Adjoint」と一般的な「Adjoint」の混同

エラー/問題の原因
Juliaのadjoint()は、線形代数における共役転置を指します。しかし、他の数学分野（特に古い文献や一部のソフトウェア）では、「adjoint」が**随伴行列（adjugate matrix / classical adjoint）**を指すことがあります。随伴行列は、行列式と逆行列を使って計算される異なる概念です。

例
MATLABのadjoint関数は随伴行列を計算しますが、Juliaのadjoint()は共役転置を計算します。そのため、MATLABのコードをJuliaに移植する際に、adjoint()をそのまま置き換えると異なる結果が得られることがあります。

トラブルシューティング

随伴行列の計算
Juliaで随伴行列を計算したい場合は、LinearAlgebraパッケージに直接的な関数はありませんが、det(A) * inv(A)で計算できます（ただし、行列が特異行列の場合はエラーになります）。より堅牢な方法としては、コファクター（余因子）行列を計算し、それを転置する方法などがあります。
定義の確認
使用している「adjoint」が線形代数の共役転置（AH）なのか、それとも随伴行列（adj(A)）なのかを明確にします。

エラー/問題の原因
自動微分（Automatic Differentiation）の文脈で「adjoint」が使われる場合、それは通常、逆モード自動微分（reverse-mode AD）における随伴変数や随伴状態を指します。これは、adjoint()関数を直接呼び出すこととは異なります。自動微分ライブラリ（Zygote.jlなど）は、内部でこの概念を用いて勾配を計算します。

もし、f'(x)のような構文を関数の微分として期待して使用し、MethodErrorが出た場合、それはJuliaがf'をadjoint(f)と解釈したためです。関数fにはadjointが定義されていないためエラーになります。

概念の区別
線形代数のadjoint()（共役転置）と自動微分の文脈で使われる「adjoint」（随伴）は、関連性はあるものの、プログラミング上の直接的な機能としては異なるものであることを理解します。
適切な自動微分関数の使用
関数の微分を計算したい場合は、使用している自動微分ライブラリの正しい関数を使用します。例えばZygote.jlではgradient(f, x)を使います。

スカラー値に対する adjoint()

スカラー値（単一の数値）に対してadjoint()を使用すると、複素数の場合はその複素共役を返します。実数の場合は、その数値自体を返します。

# 実数
x_real = 5.0
println("実数 ", x_real, " の adjoint: ", adjoint(x_real))
println("実数 ", x_real, " の ': ", x_real') # 同じ結果

# 複素数
x_complex = 3 + 4im
println("複素数 ", x_complex, " の adjoint: ", adjoint(x_complex))
println("複素数 ", x_complex, " の ': ", x_complex') # 同じ結果

x_complex_neg = 3 - 4im
println("複素数 ", x_complex_neg, " の adjoint: ", adjoint(x_complex_neg))
println("複素数 ", x_complex_neg, " の ': ", x_complex_neg') # 同じ結果

出力例

実数 5.0 の adjoint: 5.0
実数 5.0 の ': 5.0
複素数 3 + 4im の adjoint: 3 - 4im
複素数 3 + 4im の ': 3 - 4im
複素数 3 - 4im の adjoint: 3 + 4im
複素数 3 - 4im の ': 3 + 4im

ベクトルに対する adjoint()

ベクトルに対してadjoint()を使用すると、行ベクトル（共役転置されたベクトル）を返します。結果はAdjoint型（またはTranspose型）のビューになります。

# 実数ベクトル
v_real = [1, 2, 3]
println("実数ベクトル v: ", v_real)
println("v の adjoint: ", adjoint(v_real))
println("v の ': ", v_real') # 同じ結果
println("結果の型: ", typeof(v_real'))

# 複素数ベクトル
v_complex = [1+1im, 2-2im, 3+3im]
println("\n複素数ベクトル v_c: ", v_complex)
println("v_c の adjoint: ", adjoint(v_complex))
println("v_c の ': ", v_complex') # 同じ結果
println("結果の型: ", typeof(v_complex'))

# Adjoint型をArrayに変換する
v_real_array = Array(v_real')
println("\nArrayに変換された v': ", v_real_array)
println("変換後の型: ", typeof(v_real_array))

出力例

実数ベクトル v: [1, 2, 3]
v の adjoint: [1 2 3]
v の ': [1 2 3]
結果の型: Adjoint{Int64, Vector{Int64}}

複素数ベクトル v_c: Complex{Int64}[1+1im, 2-2im, 3+3im]
v_c の adjoint: Complex{Int64}[1-1im 2+2im 3-3im]
v_c の ': Complex{Int64}[1-1im 2+2im 3-3im]
結果の型: Adjoint{Complex{Int64}, Vector{Complex{Int64}}}

Arrayに変換された v': [1 2 3]
変換後の型: Matrix{Int64}

ポイント

Array()やcollect()を使って明示的にMatrix型に変換することができます。
Adjoint{T, Vector{T}}という型は、元のベクトルへのビューであり、新しいメモリは割り当てられません。

行列に対する adjoint()

行列に対してadjoint()を使用すると、その行列の共役転置を返します。これもビューとして返されます。

# 実数行列
M_real = [1 2; 3 4]
println("実数行列 M: \n", M_real)
println("M の adjoint: \n", adjoint(M_real))
println("M の ': \n", M_real') # 同じ結果
println("結果の型: ", typeof(M_real'))

# 複素数行列
M_complex = [1+1im 2+2im; 3-3im 4-4im]
println("\n複素数行列 M_c: \n", M_complex)
println("M_c の adjoint: \n", adjoint(M_complex))
println("M_c の ': \n", M_complex') # 同じ結果
println("結果の型: ", typeof(M_complex'))

出力例

実数行列 M: 
[1 2; 3 4]
M の adjoint: 
[1 3; 2 4]
M の ': 
[1 3; 2 4]
結果の型: Transpose{Int64, Matrix{Int64}}

複素数行列 M_c: 
[1+1im 2+2im; 3-3im 4-4im]
M_c の adjoint: 
[1-1im 3+3im; 2-2im 4+4im]
M_c の ': 
[1-1im 3+3im; 2-2im 4+4im]
結果の型: Adjoint{Complex{Int64}, Matrix{Complex{Int64}}}

ポイント

これらは両方とも元の行列のビューであり、実際のデータはコピーされません。
実数行列の場合はTranspose型、複素数行列の場合はAdjoint型が返されます。

adjoint() と線形代数演算

A = [1 2; 3 4]
B = [5 6; 7 8]

# A' * B は (Aの転置) * B を意味する
result_1 = A' * B
println("A' * B: \n", result_1)

# A * B' は A * (Bの転置) を意味する
result_2 = A * B'
println("\nA * B': \n", result_2)

# ベクトル内積 (v' * v)
v = [1+im, 2-im]
dot_product = v' * v
println("\nv の内積 (v' * v): ", dot_product)
println("結果の型: ", typeof(dot_product)) # Scalar result

出力例

A' * B: 
[26 32; 38 46]

A * B': 
[17 23; 39 53]

v の内積 (v' * v): (7.0 + 0.0im)
結果の型: ComplexF64

adjoint()は、ジェネリックな線形代数アルゴリズムを記述する際に、入力がAdjoint型であっても適切に処理されるようにするために役立ちます。

function my_matrix_multiply(M1::AbstractMatrix, M2::AbstractMatrix)
    # M1とM2がどんな種類の行列（通常のMatrix、Adjoint、Transposeなど）
    # であっても、適切に動作するように設計できる
    return M1 * M2
end

A = [1 2; 3 4]
B_transposed = [5 7; 6 8] # B' の結果をシミュレート

# Aを通常のMatrixとして、B_transposedをTranspose/Adjointとして渡せる
result_func = my_matrix_multiply(A, B_transposed)
println("\nmy_matrix_multiply(A, B_transposed):\n", result_func)

# 実際には A' を直接渡すことも可能
result_func_actual_adjoint = my_matrix_multiply(A', B)
println("\nmy_matrix_multiply(A', B):\n", result_func_actual_adjoint)

出力例

my_matrix_multiply(A, B_transposed):
[17 23; 39 53]

my_matrix_multiply(A', B):
[26 32; 38 46]

関数引数の型をAbstractMatrixのように抽象的に宣言することで、Matrix、Adjoint、Transposeなどの異なる具象型を受け入れることができます。これにより、コードの柔軟性が向上します。

copy() または collect() を使って明示的に新しい配列を作成する

adjoint()は通常、元の配列のビュー（Adjoint型やTranspose型）を返します。これはメモリ効率が良い反面、新しい、独立した、連続したメモリを持つ配列が必要な場合には不向きです。

目的
adjoint()の結果がビューではなく、新しい配列としてメモリにコピーされるようにする。

方法
Array()、copy()、または collect() を使用します。

M = [1+1im 2+2im; 3-3im 4-4im]
M_adjoint_view = M' # ビュー
println("M_adjoint_view の型: ", typeof(M_adjoint_view))
println("M_adjoint_view: \n", M_adjoint_view)

# 方法1: Array() を使う
M_adjoint_copied_array = Array(M')
println("\nArray(M') の型: ", typeof(M_adjoint_copied_array))
println("Array(M'): \n", M_adjoint_copied_array)

# 方法2: copy() を使う
M_adjoint_copied_copy = copy(M')
println("\ncopy(M') の型: ", typeof(M_adjoint_copied_copy))
println("copy(M'): \n", M_adjoint_copied_copy)

# 方法3: collect() を使う (Arrayと同じ効果)
M_adjoint_copied_collect = collect(M')
println("\ncollect(M') の型: ", typeof(M_adjoint_copied_collect))
println("collect(M'): \n", M_adjoint_copied_collect)

# 元の行列とビューの比較
M[1,1] = 99 + 99im
println("\n元の行列を変更後、ビューは変化: \n", M_adjoint_view)
println("元の行列を変更後、コピーは変化しない: \n", M_adjoint_copied_array)

なぜこれが必要か？

メモリの独立性
元の配列の変更が転置された配列に影響を与えないようにしたい場合。
外部ライブラリとの連携
C/Fortranベースのライブラリ（BLASなど）は、しばしば連続したメモリレイアウトを持つ配列を期待します。ビューは元の配列のメモリレイアウトを保持するため、パフォーマンス上の問題を引き起こす可能性があります。
ミュータブルな操作
M' のようなビューは直接変更できません。M_adjoint_copied_array[1,1] = ... のように変更したい場合は、コピーが必要です。

permutedims() を使って次元を並べ替える

adjoint()は共役転置（複素共役を取ってから転置）ですが、単に配列の次元を入れ替えたいだけで、要素の複素共役は必要ない場合（特に実数配列の場合）は、permutedims()を使用できます。

目的
配列の次元を任意に並べ替える。

方法
permutedims(A, perm) を使用します。ここで perm は新しい次元の順序を指定するタプルまたはベクトルです。

A = [1 2; 3 4]
println("元の行列 A: \n", A)

# adjoint(A) または A' (実数行列の場合は転置と同じ)
A_adjoint = A'
println("\nA' (adjoint(A)): \n", A_adjoint)

# permutedims を使って転置
A_permuted = permutedims(A, (2, 1)) # 1列目と2列目を入れ替える
println("\npermutedims(A, (2, 1)): \n", A_permuted)

# 3次元配列の例
B = rand(2, 3, 4)
println("\n3次元配列 B のサイズ: ", size(B))

# 次元を (3, 1, 2) の順に並べ替える
B_permuted_3d = permutedims(B, (3, 1, 2))
println("permutedims(B, (3, 1, 2)) のサイズ: ", size(B_permuted_3d))

なぜこれが必要か？

明確な意図
共役転置ではなく、純粋な次元の入れ替えであることをコード上で明示したい場合。
汎用性
permutedims()は任意の次元数の配列に対して機能し、次元の並びを自由に指定できます。

ループやComprehensionを使って手動で転置・共役転置を実装する

非常に特殊なケースや、教育目的でadjoint()の動作を理解するために、手動で転置や共役転置を実装することも可能です。ただし、これは通常、組み込みのadjoint()やpermutedims()よりも低速で、推奨されません。

目的
adjoint()の動作の基礎を理解する、または非常に特殊な要件がある場合。

方法
ループとインデックス操作、または配列内包表記を使用します。

M_complex = [1+1im 2+2im; 3-3im 4-4im]
rows, cols = size(M_complex)

# 手動で共役転置 (Comprehensionを使用)
M_adjoint_manual = [conj(M_complex[j, i]) for i in 1:cols, j in 1:rows]
println("手動で計算した M_adjoint: \n", M_adjoint_manual)

# 組み込みの adjoint() と比較
println("\n組み込みの M' (adjoint): \n", M_complex')

# 手動で転置 (実数行列の場合)
M_real = [1 2; 3 4]
rows_r, cols_r = size(M_real)
M_transpose_manual = [M_real[j, i] for i in 1:cols_r, j in 1:rows_r]
println("\n手動で計算した M_transpose (実数): \n", M_transpose_manual)

なぜこれが必要か？

特殊な要件
例えば、転置しながら特定のフィルタリングを行いたいなど、単なる転置以上の複雑なロジックを同時に適用したい場合。ただし、ほとんどの場合、既存の関数を組み合わせて使う方が効率的です。
学習目的
adjoint()やpermutedims()の内部的な仕組みを理解するため。

これはadjoint()関数とは数学的に異なる概念ですが、混同されることがあるため、代替方法として説明します。Juliaのadjoint()は「共役転置 (conjugate transpose)」を意味しますが、数学で「adjugate matrix (classical adjoint)」を指すことがあります。

目的
行列の随伴行列を計算する。

方法
行列式と逆行列を使ってdet(A) * inv(A)で計算できます。ただし、行列が特異行列の場合はエラーになります。

using LinearAlgebra

A = [1 2; 3 4]

# A の随伴行列 (adjugate matrix) を計算
# adj(A) = det(A) * inv(A)
try
    A_adjugate = det(A) * inv(A)
    println("\nA の随伴行列 (adjugate matrix): \n", A_adjugate)
catch e
    println("\n随伴行列の計算エラー: ", e)
end

# Juliaの adjoint() は共役転置
println("\nJulia の A' (共役転置): \n", A')

定義の混乱を避ける
MATLABなどの他のソフトウェアや一部の数学の文献で「adjoint」が随伴行列を指す場合があるため、互換性のために計算する必要がある場合。

Juliaで双曲線余割を計算する：Math.csch()関数の詳細ガイド

双曲線余割関数は、次のように定義されます。$$ \operatorname{csch}(x) = \frac{1}{\sinh(x)} = \frac{2}{e^x - e^{-x}} $$ここで、e は自然対数の底（約2. 71828）です。

Juliaの三角関数：Math.sec()関数の詳細と実践例

正割（セカント）は三角関数の一つで、余弦（コサイン）の逆数として定義されます。つまり、角度 x の正割は以下のように表されます。sec(x)=cos(x)1Math. sec()関数の使い方JuliaでMath. sec()関数を使うには、Mathモジュールをインポートする必要はありません。標準で利用可能です。

【Julia】adjoint()でよくあるエラーと解決策！予期せぬ挙動を防ぐトラブルシューティング

線形代数におけるadjoint()関数は、行列の**共役転置 (conjugate transpose)**を計算します。これは、行列の要素をそれぞれ複素共役に取り、その後に転置する操作です。複素数行列 A の場合、A の共役転置は AH（エルミート転置と呼ばれることもあります）と表記され、各要素 aijが ajiとなります。

Julia cis()関数の代替手段：exp(im*x)など比較解説

Juliaにおけるcis()関数は、複素数の世界で非常に便利な機能を果たします。簡単に言うと、角度（ラジアン）を与えると、対応する単位円上の複素数を返す関数です。数学的には、オイラーの公式 eix=cos(x)+isin(x) に基づいています。cis(x) はこの右辺、つまり cos(x)+isin(x) を計算するのと同義です。

Juliaプログラミングで困った時に！kron()関数のよくあるエラーと解決策

Julia プログラミング言語における kron() 関数は、クロネッカー積 (Kronecker product) を計算するために使用されます。クロネッカー積は、2つの行列（またはベクトル）から新しい大きな行列を作成する演算です。行列 A が m×n 行列、行列 B が p×q 行列である場合、それらのクロネッカー積 A⊗B は mp×nq 行列になります。

Juliaプログラミング：`kron!()`の破壊的挙動とベストプラクティス

Julia プログラミング言語における kron!() は、通常、クロネッカー積を計算する関数 kron() を指していると考えられますが、感嘆符 ! が付いているため、破壊的（in-place）な操作を示唆している可能性があります。Juliaでは、関数名の最後に ! を付ける慣例があり、これはその関数が引数として渡されたオブジェクトを直接変更する（破壊的な操作を行う）ことを示します。もし kron! のような関数が存在する場合、それはおそらく、計算結果を新しい配列として返すのではなく、既存の配列（おそらく引数として渡されたものの一つ）を上書きしてクロネッカー積の結果を格納する、という意味合いになります。

【Julia】adjoint()でよくあるエラーと解決策！予期せぬ挙動を防ぐトラブルシューティング

行列の共役転置 (Conjugate Transpose)

なぜ Adjoint 型が返されるのか？

MethodError: no method matching adjoint(...)

Adjoint型による予期せぬ挙動とパフォーマンスの問題

数学的な「Adjoint」と一般的な「Adjoint」の混同

スカラー値に対する adjoint()

ベクトルに対する adjoint()

行列に対する adjoint()

adjoint() と線形代数演算

copy() または collect() を使って明示的に新しい配列を作成する

permutedims() を使って次元を並べ替える

ループやComprehensionを使って手動で転置・共役転置を実装する

なぜ `Adjoint` 型が返されるのか？