アンドレアスは＃19344でAᵀ （そしておそらくAᴴ ）を試しましたが、あまり評判が良くありませんでした。 同様に、 A^Tが転置されるように、特別な指数タイプT （およびおそらくH ）を使用して^を駄洒落にすることもできますが、それもかなり怪しげです。 まだちょっと/ちょっと数学表記のように見える他の多くの良いオプションがあるかどうかはわかりません。

t(A)が最高かもしれないと思いますが、別の1文字の名前を「盗む」のは残念です。

私のコメントを他の問題から移動します（それが何かを解決するというわけではありませんが...）：

.'以外のものを使用する場合は+1。

あまり明白ではない⍉を使用するAPLと*Xを使用するPython（Juliaにとって混乱する）を除いて、転置のための特別な構文を持つ言語を見つけることができませんでした。 いくつかの言語はtranspose(X)を使用します; Rはt(X)を使用します。 それはきれいではありませんが、 .'より悪くはありません。 少なくとも、 .'と混同することで、 'を使用する傾向が少なくなります。これらが非常に異なる操作であることは明らかです。

Rosettaコードを参照してください。 （ところで、ジュリアの例は実際に共役転置を示しています...）

他のダニの1つを使用できますか？ `または"

-100を随伴作用素に変更します。これは、Juliaコードを数学を書くのと同じくらい明確にする素晴らしいもののひとつであり、さらに共役転置は通常、とにかく必要なものなので、構文を省略した方が理にかなっています。

共役転置の優れた構文がある限り、通常の転置の接尾辞演算子はほとんど不要のように思われるので、通常の関数呼び出しにするだけで問題ないように思えます。 transposeすでに機能しています。 ただそれを使うことができませんでしたか？ t(x) R-ismは、名前から実際に何をするのかが明確でないため、残念なことに思います。

別の目盛りを使用すると、ちょっと奇妙になります。たとえば、フォントによってはA`がA'のように見えたり、 A"がA''のように見えすぎたりします。 。

＃20978で変更を加えると、接尾辞の転置が実際には現在よりも便利になります。 たとえば、2つのベクトルxとyがあり、それらにfペアごとに適用する場合は、たとえばf.(x, y.') ...を＃20978で実行できます。 、これは任意のタイプの配列に適用されます。

正直なところ、私たちの最善の選択肢は、それをそのままにしておくことだと思います。 提案のどれも私には明らかな改善のようには思えません。 .'には、Matlabに精通しているという利点があります。 .は、実際にはf.(x, y.')のような例のドット呼び出し構文とある程度一致しており、転置が「融合」することを（ある程度正しく）示唆しています（ RowVectorのおかげで一時的なコピーは生成されません）

実際、それをさらに進めて、 f.(x, g.(y).')を融合操作にすることもできます。 つまり、 .'転置を非再帰的なala＃20978に変更し、そのセマンティクスを拡張して、他のネストされたドット呼び出しとの融合を含めます。 （非融合バージョンが必要な場合は、 transposeを呼び出します。）

私はその計画がとても好きです、@stevengj。

1つのしわ：おそらく@.マクロはy'をy.' $に変換しません（それは間違っているため）。 ただし、 y'をある種の融合随伴作用素に変えることができます。

主な問題は、 f.(x, g.(y).')に融合セマンティクスを持たせるためのクリーンな方法を見つけることです。 1つの可能性は、それをf.(x, g.(y.'))に変換し、したがってbroadcast(x,y -> f(x, g(y)), x, y.')に変換することです。

これが正しく機能するためには、フォールバックtranspose(x) = xメソッドを復元する必要がある場合があることに注意してください。その場合、転置を再帰的に維持することもできます。

転置を再帰的にするかどうかの決定は、ドット構文の融合に参加させるかどうかと直交していると思います。 それを非再帰的にするという選択は、それによって動機付けられていません。

@StefanKarpinski 、フォールバックtranspose(x) = xを復元すると、非再帰的に変更する動機のほとんどが失われます。

フォールバックが復元されても、転置が非再帰的である場合の問題は何ですか？

@jebej 、再帰転置は、線形演算子の数学演算として使用すると、より正確になります。 私の記憶が正しければ、非再帰的にする主な理由は、MethodErrorをスローするのではなく、 transpose(x) = xフォールバックを定義する必要がないためです。

しかし、フォールバックがあることはひどいことではありませんが、それでも再帰的ではありません。

2つのコメントを追加しましょう（私は以前の議論を調べましたが、それらに気づいていませんでした-何かを省略した場合は申し訳ありません）：

• permutedimsのドキュメントには、これは多次元配列の転置の一般化であると書かれています。 transpose関数の一般化を示唆しているので、少し誤解を招きますが、そうではありません。
• ベクトルx=["a", "b"]の転置をどのように行うことになっていますか？ 実際y=x.'が機能して新しい変数を作成しますが、 getindexは失敗します。 AFAIKを使用するには、 reshape(x, 1, :)またははるかに遅いhcat(x...)を使用する必要がありますが、 Vectorに別の構文を使用するのは不自然です（ permutedimsはここでは機能しません） ）。

文字列のベクトルを転置するためのユースケースは何ですか？

たとえば、次のシナリオを考えてみましょう。

x = ["$(j+i)" for j in 1:3, i in 1:5]
y = ["$i" for i in 5:9]

そして、 xの最後の行の後にyを追加したいと思います。 そして、最も簡単な方法は、 vcatをyの転置することです。

実際には、テキストデータをMatrix{String}に段階的に記録するときに発生します（ Vector{Vector{String}}を使用できます）が、多くの場合、マトリックスの方が便利です（または、 Vector{Vector{String}}を変換する方法についても質問があります）。連続する要素を垂直方向に連結することにより、 Matrix{String} ）。

別の使用例：転置は、デカルト積（ f.(v, w.') ）で関数をブロードキャストするために、2つのベクトルを互いに直交させる最も簡単な方法です。

データポイント：昨日、接尾辞「broadcast-adjoint」演算子と、それが転置のように動作する理由によって混乱しているパーティーに遭遇しました。 一番！

FWIW、私は.'構文を取り除くべきだと強く感じています。 MatlabよりもJuliaに精通している人として、私はそれがベクトル化された随伴作用素を意味すると思っていましたが、そうでないときは本当につまずきました。 JuliaはMatlabではないため、Matlabの規則に拘束されるべきではありません。Juliaでドットが隣接する関数のベクトル化を意味する場合、これは言語全体で一貫している必要があり、 .'という1つの恐ろしい例外がランダムに発生することはありません。 'とは無関係です。

transposeを特別な「目盛り」表記なしで使用するのは問題ないと思います。ほとんどの場合、実数の行列で呼び出されるため、 'は、次の場合と同等になります。本当にタイピングを節約したい。 転置の融合バージョンを作成したい場合、 .'が正しい構文であるとは本当に思いません。

それは良い点です。 おそらく、随伴作用素だけが超コンパクトな構文を必要とします。

これtransposeと呼び、$＃$ 1 .' ＃$を廃止してみましょう。 将来的には、 .'をポイントごとの随伴として使用するか、Matlabユーザーのトラップを回避するために永続的に非推奨のままにするかを検討できます。

登録済みのパッケージを調べたところ、600以上の.'の使用法が見つかったので、それほど珍しいことではないことに注意してください。 そして、ドット呼び出し/ broadcast （0.6でのみ非数値データを完全に処理し始めた）では、非数値配列（随伴があまり意味をなさない）を怠惰に転置したいという願望がおそらくはるかに一般的になるでしょう。コンパクトな構文の議論はやや強化されています。

次に、より多くのコードが悪い使用パターンに閉じ込められる前に、できるだけ早く.'を廃止することをお勧めします。

なぜ悪いのですか？

問題は、 .'が、点線の演算子として意味しているように見えることを意味しないことです。

上で述べたように、 .はベクトル化を意味し、ベクトル化された随伴作用素を意味するように見えるという一般的なパターンに違反しているためです（特にMatlabに精通していない人にとって）。

@stevengjは良い点だと思います—これは単純な非再帰的な転置の欲求と結びついています。

人気がなかったことは知っていますが、アンドレアスの＃19344をᵀで支持し始めています。 この時点で、識別子としての_all_上付き文字の使用を廃止し、_any_末尾の上付き文字を接尾辞演算子として解釈することをお勧めします。 これはまた、上付き文字の数字を使用して、 literal_pow周辺の不器用さの一部を解決するためのパスを提供します。 はい、変数名などのχ²を失うのは悲しいことですが、メリットはデメリットを上回っていると思います。

この時点で、識別子としての_all_上付き文字の使用を廃止し、_any_末尾の上付き文字を接尾辞演算子として解釈することをお勧めします。

コードをリッピングする

この時点で、識別子としてのすべての上付き文字の使用を廃止することをお勧めします

Tだけで、将来的には他にもいくつか必要な場合は、それが必要になるとは思いません。

愚かな一貫性…

はい、転置に.'を使用することは少し一貫性がありませんが、これまでに提案されたすべての代替案はもっと悪いようです。 「 .'は転置であり、ドット演算子に関する通常の規則の例外です」と言うのは世界で最悪のことではありません。 あなたはこれを学び、次に進みます。

.'がドットブロードキャストではないことに関する潜在的な混乱に役立つ可能性があることに注意することの1つは、プレフィックスブロードキャストがop.であり、インフィックスが.opであるのに対し、それは後置演算子であるということです。 したがって、 .は、接尾辞の場合のブロードキャストを意味するものではないと言えます。 接尾辞.の他の使用法はフィールドルックアップであり、 getfield(x, ')は意味をなさないため、他の意味とは異なります。

（とはいえ、私は.' transpose(x)を好みます。）

@stevengj上記の登録済みパッケージでの600以上の使用の多く（おそらくほとんど）は、読みやすさとコードを犠牲にすることなく、$＃ .' 'に置き換えることができると思います。動作し続けます。

おそらく人気はありませんが、接尾辞"と`がまだ存在する可能性がありますか？

の使用。 上記の登録済みパッケージでは、読みやすさを犠牲にすることなく'に置き換えることができ、コードは引き続き機能します。

＃23424が到達すると、文字列の配列などでtransposeを使用できるようになりますが、 adjointは使用できないことに注意してください。 x.'の線形代数使用のベストプラクティスは、おそらくconj(x')のようなものになります（うまくいけば、これは怠惰で、つまり無料です）。 コンパクトさのために.'を使用するのが大好きですが、おそらくそれを取り除くと、線形代数ユーザーは正しいものを使用し、データ配列ユーザーはスペルアウトされたtransposeを使用するようになります。

接尾辞"と`がまだある可能性がありますか？

transpose()の新しい構文は、かなり時期尚早のようです。 私見では、必要に応じてconj(x')とtransposeに置き換えることをお勧めしますが、 .'を廃止することをお勧めします。

.'は、主に「すべてがマトリックスである」というmatlabの主張と、さまざまな場所にランダムな転置を挿入する必要があるような一貫したスライスルールがないため、matlabで非常に役立つと感じています。物事を機能させる。

ここで議論を要約すると：

1. .'は、ドット付き演算子として唯一の傑出したものになりました。これは、「ドットなしの演算子を要素ごとに適用する」という意味ではありません。 Matlabから来ていない新しいユーザーは、これが驚くべき罠だと感じています。

2. .'は実質的にあいまいになりました： transposeを意味しましたか、それともconj(x')を意味しましたか？ 原則として、 .'のすべてのレガシー使用法は、2次元配列のインデックスを並べ替えているのか、それとも「非共役随伴」を行っているのかを判断するために精査する必要があります。

最初の問題は問題がありますが、それ自体は致命的ではありません。 2番目の問題は本当に悪い問題です。これはもはや単一の一貫した操作ではなく、2つの別々の意味に分割されます。

.'を「要素ごとの随伴」を意味するように変更した場合、 conj(x')はx'.'とほぼ同等になり、 conj(x)'はほぼx.''になります。 x.'に非常に近いです😬。

おそらく人気はありませんが、それでも接尾辞「」と「？」が存在する可能性があります。

貼り付けたコードをSlackにコピーして、構文の強調表示を破棄することを確認すると...

ディスパッチメカニズムやその他の短く簡潔なユースケースを介して「製品をクロス」するのが簡単になるため、何でも転置できるのは素晴らしいことです。 この種のものの簡単なフォールバックがない場合の問題は、常に、これを作成するためにtranspose(x) = xフォールバック（またはBaseタイプ、つまりパッケージ内のタイプ著作権侵害）を定義することです。ある種のものは簡単に動作します。 それは私に考えさせます：なぜComplexは奇妙なものではないのですか？ ほとんどの数の随伴作用素はそれ自体であるため、複雑な随伴作用素が専門になります。それを数を超えて拡張することはできませんか？

ここに2つの非常に関連するものがあります。

1） x'は数値以外のタイプでは機能しないため、他のデータでもこれを簡単に実行できる方法が必要です。
2） transpose(x)はx.'ほど単純ではありません。 複雑な行列を転置するユースケースははるかにまれであるため、これは主に（1）の場合に当てはまります。

しかし、（2）を下げる代わりに、（1）を適切に修正してみませんか？

たぶん、合理的な修正は、 'を随伴ではなく転置を意味するマクロにするだけですか？

しかし、（2）を下げる代わりに、（1）を適切に修正してみませんか？

私たちはすでにその道を進んでおり、いくつかはそれに隣接しています。 おそらく他の誰かが蒸留することができる結果として大量の議論がありましたが、要約すると、それはうまくいきません。 基本的に、数学的なadjoint演算は、数値ではないものには意味がありません。 簡潔な構文が好きであるという理由だけで非数値に'を使用することは悪いことです。これは最悪の種類の演算子のしゃれであり、この種の意味の乱用から悪いことが起こることは驚くべきことではありません。 adjoint関数は、随伴作用素を取ることが理にかなっているものにのみ定義する必要があり、 'はそれを意味するためにのみ使用する必要があります。

現在使用されている.'は、基本的に2つの異なる操作であることに注意してください。配列転置と非共役随伴です。 再帰転置問題は、これらが異なる操作であり、したがってそれらを表現するための異なる方法が必要であるという事実を浮き彫りにします。 マシーの人々は、非共役随伴作用が（a）重要であり、（b）単純な次元の交換とは異なることを断固として主張しているようです。 特に、正確には、非共役随伴作用素は再帰的である必要があります。 一方、ジェネリック配列の次元の交換は明らかに再帰的であってはなりません。 したがって、これらの操作は別の方法で記述する必要があり、 .'の既存の使用法は、いずれかの意味を持つものとして明確にする必要があります。 .'の廃止は、これを強制する方法です。

最後に、 permutedims(x, (2, 1))は2次元配列の次元を交換するには明らかに不便だと強く感じていますが、 transpose(x)は不便すぎて納得がいかないという議論を見つけました。 この操作は非常に一般的であるため、単純で明確な関数名を付けるのは多すぎますか？ 本当に？ 配列の次元を交換することは、関数名と関数呼び出し構文を使用する言語の他のすべてのものよりもはるかに一般的または重要ですか？ v'v 、 v*v' 、 v'A*vのようなものを書きたいので、ハウスホルダー表記はadjointを非常に特別なものにします。 そのため、 adjointは非常に優れた構文になります。 しかし、配列の次元を交換しますか？ 私の意見では、それはオペレーターを保証するものではありません。

強力な議論ではありませんが、たとえば、画面に同時にいくつかのベクトルのコンテンツを表示したい場合など、よりコンパクトな配列を印刷するために'演算子を使用することがよくあります（単純なコンテナーとして使用する場合）（要素を転置できないため、失敗すると必ずイライラします）。 したがって、REPLの短い構文は間違いなく便利です。 （また、これにより、特に2次元配列を使用してアルゴリズムをjuliaに移植する場合に、行を優先する配列に慣れている人々が「順序を切り替える」簡単な方法を簡単に利用できるようになりますが、確かに強力な議論ではありません）。 これは、線形代数主義者だけに役立つわけではない、簡潔で優れた構文であると言えます。

https://github.com/JuliaLang/julia/pull/19344#issuecomment -261621763でいくつかの構文のアイデアにコメントしましたが、基本的には次のとおりです。

julia> const ᵀ, ᴴ = transpose, ctranspose;

julia> for op in (ᵀ, ᴴ)
           <strong i="7">@eval</strong> Base.:*(x::AbstractArray{T}, f::typeof($op)) where {T<:Number} = f(x)
       end

julia> A = rand(2, 2)
2×2 Array{Float64,2}:
 0.919332  0.651938
 0.387085  0.16784

julia>  Aᵀ = (A)ᵀ    # variable definition and function application are both available!
2×2 Array{Float64,2}:
 0.919332  0.387085
 0.651938  0.16784

julia> Aᴴ = (A)ᴴ
2×2 Array{Float64,2}:
 0.919332  0.387085
 0.651938  0.16784

しかし、もちろんハックがなければ、ある種の「後置関数適用」があり、括弧(x)fが必要であるという考えだけで、点線のバージョンは次のようになります(x).f （ xf fが上付き記号であっても、 xfは識別子になります）。

このハックの例は、以前は0.6で機能していましたが、現在は次のようになっています。

julia> Aᵀ = (A)ᵀ               
ERROR: syntax: invalid operator

julia> Aᵀ = (A)transpose       
2×2 Array{Float64,2}:          
 0.995848  0.549117            
 0.69401   0.908227            

julia> Aᴴ = (A)ᴴ               
ERROR: syntax: invalid operator

julia> Aᴴ = (A)ctranspose      # or adjoint or whatever
2×2 Array{Float64,2}:          
 0.995848  0.549117            
 0.69401   0.908227            

悲しいことに、私はもともと権力のためにそれをやりたかったのです。

julia> square(n) = n^2; cube(n) = n^3;

julia> Base.:*(n, f::typeof(square)) = f(n)

julia> Base.:*(n, f::typeof(cube)) = f(n)

julia> const ² = square    # why?
syntax: invalid character "²"

julia> const ³ = cube    # why?
syntax: invalid character "³"

n² = (n)²やn³ = (n)³のような構文が可能になると私は素朴に思っていましたが、どんな種類の数値識別子も最初の位置に置くことは禁止されていますが、 (A)⁻¹も機能しました。 ⁻¹はconst ⁻¹ = invた。

InfixFunctions.jlにも同様のハックを実装しました。

ユーザーとして、私はPostfixFunctions.jlパッケージを実行するだけで、ここで最高のものを見つけて満足することができました。 しかし、現在、この構文上の制限は次のとおりです。

• 識別子の先頭に数値の上付き文字を使用することは許可されていません
• 接尾辞のスーパーインデックスx * ᶠ （ハックでの暗黙の乗算） (x)ᶠは許可されていません

私には少し多すぎるようですが、少なくとも数値の上付き文字で始まる識別子を定義できるようにしたいのですが、より一般的には、数値のセマンティクスで0〜9の実際の数値のみを無効にします。識別子、それは素晴らしいでしょう。 😄

乾杯！

識別子としての他の数字の説明については、＃10762を参照してください。

もう1つの問題は、＃22089、演算子のサフィックスに関連しています。 +ᵀは有効な演算子になりました。これは、演算子が期待されるコンテキストで文字を組み合わせただけで構成される識別子を（おそらく偶然に）許可しませんでした。 それは私にはバグのようです。 ᵀが有効な識別子であるのに、 -ᵀが-(ᵀ)を実行しないのも少し奇妙です。 しかし、それは世界の終わりではなく、IMOがそれを修正することは、 ᵀの他の可能な使用法を失う価値がないでしょう。

.'を接尾辞の転置演算子として使用することは、ここの表にもありません（問題の主題が何を言っているかにかかわらず）、実際には、 .'を接尾辞演算子として保持する必要があるかどうかが考慮されます。非共役随伴の場合、これは再帰的です。 これは、移調と同じであることがよくありますが、一般的に同じ操作ではありません。 線形代数の人々が.'に一般的な配列の転置を意味させることをいとわないのであれば、それは別の話ですが、私の印象は受け入れられないということです。

@ Ismael-VC、上付き文字の接尾辞関数構文として(x)ᵀを許可していることがわかります。他に何を意味するのでしょうか？ あなたの提案が人々を間違った方法で揉み始めたのは、接尾辞構文の関数として任意の識別子を適用できるようにすることだと思います。 上付き文字に限定します。

@StefanKarpinski 、コンセンサスは、 .'が非再帰的、非共役配列転置を意味することを正確に許可することであると思いました（この演算子がある場合）が、 'は再帰的で共役です随伴作用。

接尾辞の転置演算子にᵀを使用するというアイデアは本当に嫌いです。 aᵀaやLᵀDL = ltdlfact(A)のように、変数名に上付き文字を付けるのは非常に便利です。 （演算子にᵀのみを使用し、IDで他の上付き文字が有効であるという事実に加えて、奇妙なことになります。）

それは私の理解ではありませんでした– linalgの人々は、 a.'をそのまま、つまりconj(a)'を維持することに賛成だと思いました。 .'維持しますが、その意味を配列転置に変更することはまったく異なります–それについてどう思うかわかりません。 接尾辞演算子としてᵀしかないことは、煩わしく一貫性がないことに同意します。 私は@Ismael-VCの(a)ᵀ提案が好きですが、名前としてaᵀを使用することを妨げることはありません。

それらの議論の私の記憶はスティーブンのそれを反映しています。 再帰的な非共役転置はまれであり、一般的にかなり奇妙です。 ここにまともな要約： https ：//github.com/JuliaLang/julia/issues/20978#issuecomment-316141984。

接尾辞'は随伴であり、そのままにしておくべきだということに私たちは皆同意していると思います。
接尾辞.'が最適ではない構文であることに私たちは皆同意すると思います。
非再帰的（構造的）転置が再帰的転置よりも有用であることに最も同意すると思います。

さて、誰もが同意しているように見える点：

1. $ adjoint(a) $にはa'を使用します
2. （非）随伴作用素にはconj(a)'またはconj(a')を使用します。

したがって、唯一の論点は、配列転置の記述方法です。

• a.'または
• transpose(a)または
• (a)ᵀとして。

この評価は正しいですか？

はい、そう思います（「配列転置」が非再帰的である場合）。

また、私が理解しているように、 transpose(a)は間違いなく有効な構文（および非再帰的）である必要があることに誰もが同意します。不一致の唯一のポイントは、 .'および/または(a)ᵀかどうかです。

https://github.com/JuliaLang/julia/issues/20978#issuecomment -315902532からのアプローチ（1）。これはかなりのサポートを受けました（例：https：//github.com/JuliaLang/julia/issues/20978# issuecomment-316080448）、可能性は残っています。 投稿できるそのアプローチ（ flip(A)の紹介）を実現するブランチがあります。

その価値については、 .'の廃止をサポートします。 このスレッドの混乱とあいまいさは、それ自体がそうすることを強く主張しています。 一番！

接尾辞'がある限り、人々はそれを使用して、 f.(v, w')のベクトルのデカルト積でfをブロードキャストしたいと思うでしょう。 そして、人々はそれを使用して、文字列のベクトルをテーブルのような構造のヘッダーの行ベクトルに再形成したいと思うでしょう。 ですから、私たちが指示できるシンプルで使いやすい代替品を手に入れることは私にとって魅力的です。

検討していないオプションは次のとおりです。 A*' —新しいバイグラフ。 典型的な数学表記はこれをconj(A)'として解釈するかもしれませんが、これは実際には私たちが望むものにかなり近いものです。 0.6で利用可能でしたが、0.7では、 *を使用して文字を連結できます…ただし、引き続き機能します。

行末を超えて解析するカスタム文字列リテラルのため、接尾辞"と`が使用できるとは思いません。 同じ理由で、Postfix *自体も使用できません。 接尾辞の素数A′は、おそらく最も一般的に使用されるUnicode識別子の1つであるため、 Aᵀよりもさらに多くなります。

正直なところ、私のコードを見た後、私は.'をまったく使用しないので、 transpose(a)はおそらく問題ありません。

登録されたパッケージをgrepしたところ、600以上の使用法が見つかったので、それほど珍しいことではないことに注意してください。

このスポットは、 ' $が問題ない場所で$ .'が使用されていないかどうかを確認するためにまったくチェックされましたか？ 私はそれが真実かもしれないと思い始めています。 そうでなければ、 .'の合法的な使用を見た唯一の場所は、Plots.jlラベルがベクトルを許可する前でした（代わりに文字列の行ベクトルが必要でした）が、それは変更されました。 これが本当に頻繁に必要なコードの場合、ローカルでT = transposeを実行するか、マクロをスローして'をtransposeに変更すると思います。

<strong i="17">@transpose</strong> A = A'*A*B'*B*C'*C

そのまれなケースでは私には問題ないでしょう。

人々はそれを使用して、f。（v、w'）を使用したベクトルのデカルト積でfをブロードキャストしたいと思うでしょう。 そして、人々はそれを使用して、文字列のベクトルをテーブルのような構造のヘッダーの行ベクトルに再形成したいと思うでしょう。 ですから、私たちが指示できるシンプルで使いやすい代替品を手に入れることは私にとって魅力的です。

ステートメントに1回しか表示されない場合は、 transposeを使用しても大丈夫ではありませんか？

共役随伴作用素のa*'構文は非常に優れていますが、より良い構文が必要な操作ではないようです。 &aはまもなく利用可能になり、物事を交換することを提案しますが、これは従来の表記法とはかなり異なります。

多分それはわらの世論調査の時間ですか？

構造転置をどのように綴る必要がありますか？

（おおまかに提案順に、絵文字名の判断はここではありません）

• 👍： A.' —意味を変更し、構文を同じに保つ
• 👎： transpose(A) —特別な構文はありません
• 😄： t(A)またはtr(A) —特別な構文はありませんが、短い名前をエクスポートします
• 🎉： Aᵀ — ᵀと、識別子から特殊なケースに入れられた1つまたは2つの上付き文字
• 😕： (A)ᵀ —すべての上付き文字が識別子から分離されて接尾辞演算子のように動作します
• ❤️： A*' —その不気味の谷の真上に光沢があり、構造的な転置を意味します
• &Aをご希望の場合は、すぐ上のStefanの投稿に🎉を投げてください（絵文字がなくなりました）

conj(x’)は比較的まれであるため、LinAlgの議論では、非再帰的な転置使用に.’を贈ることについて実際に話していました。 ただしᵀは数学的な構文であり、実際には数学的な意味を持っている必要があります（ある場合）。

tr(A)を平均行列転置にすることに非常に強く反対します-誰もがそれが行列トレースを意味すると考えるでしょう：https： //en.wikipedia.org/wiki/Trace_ （linear_algebra）

上付き文字を識別子として非推奨にしない場合（おそらく1.0より前に真剣に検討する必要があります）、 ᵀ(A)も可能性があります。

提案(A)ᵀに関連して、次の発言でこの議論をわずかに狂わせたことをお詫びします。

単項演算子として√を使用できるようにすることは、これまであまり気にしませんでした。特に、 √(...)を、 1つまたは数文字。 さらに、私は常にa²と√aの機能の違いが非常に人工的であることを発見しました。 Unicodeクラスなどについて知っていればおそらく理にかなっていますが、他の人にとってはこれはばかげているように思われるに違いありません。 a²を有効な変数名として使用すると便利ですが、同様に、 √aは、複数の変数を使用する必要がある場合に、 aの平方根を格納するための便利な変数名になります。回数。 または、 a²bとその平方根a√bのようなより複雑な式。前者は有効な識別子であり、後者は有効な識別子ではありません。 とりわけ、私は一貫性が好きです。

したがって、一貫性を保つために、括弧(A)ᵀ 、 (a)²を使用するときに、Unicode単項演算子√ （およびその親族）を削除することと組み合わせて、接尾辞演算子を使用するという提案が好きです。識別子で使用することもできます（通常の関数呼び出し√(a)として引き続きアクセスできます）。

私は@Juthoが言ったことに100％同意し、何度もそれを考えてきました。 @Juthoさん、問題を開いていただけませんか？ 提案：識別子名に√を許可し、opとして呼び出すには√(x)が必要です。

次の質問-> 2 |> √どうですか？

別のスレッドで√について説明しましょう。ただし、簡単に言うと、 2 |> √は√(2) $を意味します。

パーサーの変更を必要とせず、入力が簡単な別の代替方法は、転置用のA^Tです（ Tを^メソッドを使用するシングルトンタイプとして定義することにより）。 …ああ、 @mbaumanもこのアイデアを持っていたようです。 少し醜いですが、 A.'以下です。

私には専門知識はありませんが、作業の過程で行列式を含む数千行を入力する可能性が高いため、このディスカッションの結果に非常に投資しています。

transpose(A) # with no special syntaxは上記の投票に勝っていますが、私の目と指には苦痛があります。

Pythonでの一般的な使用法は、おそらくnumpyと、次のように見えてそれほど悪くないものがたくさんあることです。

import numpy as np
# define matrix X of n columns, with m rows of observations
error = X.dot(Theta.T) - Y
gradient = (1 / m) * (X.dot(Theta.T) - Y).T.dot(X)

私はする必要はありません：

grad = 1/m * transpose(X * transpose(Theta) - Y)) * X

これは、転置の精神的な概念を、数学表記法が定着した慣習から完全に変更します。これは、接尾辞の記号表現であり、通常はAᵀまたはAᵗです。

個人的には、随伴作用素が使用される前のJuliav.0.6で機能するA'に非常に満足しています。 随伴作用素は非常に頻繁に使用されますか？

これが私のコメントです。

Aᵀ or Aᵗ    if the world won't accept unicode operators, let them use transpose(A)
A'          close to math notation, easy to type and *especially* easy to read
A^'         this could signal `^` not to be parsed as Exponentiation.
A.'         conflicts with dotted operator syntax, but at face value OK
A^T or A^t  these are pretty good, but what if variable `T` is meant to be an exponent? 
A.T         same as numpy, same dotted operator collision
t(A)        nesting reverses semantics, 3 keystrokes and two of them with shift key.
transpose(A) with no special syntax     # please don't do this.

個人的には、随伴作用素に取り込まれる前のJuliav.0.6で機能するA'に非常に満足しています。 随伴作用素は非常に頻繁に使用されますか？

わかりませんが、 A'は常にAの随伴作用素でした。 以前は、共役転置の基礎となる関数ctransposeを呼び出していましたが、機能を変更せずに、同等の用語adjointに名前を変更しました。

線形代数を実行している場合は、とにかく共役転置が必要になる可能性が高いため、 transpose(A) A'と入力します。 非共役転置の特別な構文を定義しないことの人気は、（おそらく）ほとんどの線形代数の使用で非共役転置が必要になることは実際にはそれほど一般的ではないという事実によるものです。

線形代数を実行している場合は...

ツールがハンマーの場合...:)

...ジュリアが一般的なプログラミング言語に成長する可能性について考える必要があります。

多分そうではないかもしれません、多分それは線形代数のアーゴットのままであるでしょう-それは私のようなプログラマーについて考えなければならない可能性です。 :)

@mahiki 、あなたはNumPyの例です：

import numpy as np
# define matrix X of n columns, with m rows of observations
error = X.dot(Theta.T) - Y
gradient = (1 / m) * (X.dot(Theta.T) - Y).T.dot(X)

ジュリアでは文字通り次のように書かれます：

error = X*Θ' - Y
gradient = (1/m) * (X*Θ' - Y)' * X

または、ベクトルがそのNumPyの例では行であり、Juliaでは列であると仮定します。

error = X'Θ - Y
gradient = (1/m) * (X'Θ - Y) * X'

これは、それが得るのと同じくらい明確で数学的なようです。 データが実際の場合、随伴と転置は同じ操作です。これが、上記の転置を使用している理由かもしれませんが、数学的には随伴が正しい操作です。 @ararslanが言ったように、 X'は、Julia（およびMatlabでも）では常にadjointを意味していました。 以前は「共役転置」の略でctransposeと呼ばれていましたが、演算子の定義プロパティが次のようになっているため、この名前は誤った名前でした。

dot(A*x, y) == dot(x, A'y)

これはエルミート随伴の定義特性ですが、 Aが複素行列の場合、共役転置によって満たされます。 そのため、「随伴」はこの演算子の正しい総称です。

とはいえ、 a.'が構造的転置を意味するのは問題ないと思うので、私はtranspose(a)とa.'の両方に投票しました。 これは期待どおりに機能します。再帰的ではないため、一部の汎用コードでは「数学的に正しく」ありませんが、期待どおりに機能することで十分なようです。 そして、ジェネリックコードでconj(a')を使用することを検討するように人々に指示することは、私たちが本当に人々を頭から殴る必要があるものではなく、教育的なことのように思えます。

@mahiki何らかの理由で、コードでadjoint transpose $を何度も使用する必要がある場合は、$＃のエイリアスであるtranspose @tのような短いマクロを定義できます。 transpose （特に、他の人とコードを書いている場合は、このソリューションが理想的ではないことはわかっていますが）。

Juliaが一般的なプログラミング言語に成長する可能性について考える必要があります。

@Liso77もうです。 多くの例の1つとして、NanosoldierはGitHubイベントをリッスンし、オンデマンドでパフォーマンスベンチマークを実行するWebサーバーをすべてJuliaで実行します。 それは余談ですが、私はこのスレッドが話題から外れることを望んでいません。

ある種の行列を数値以外のデータで転置する場合（これは完全に有効なユースケースです）、数学的な転置表記は実際には駄洒落のように見えます。 その場合は、たとえばtranspose （または特定のニーズによってはpermutedims ）など、何を求めているのかをより明確にする方がよいと思います。

ある種の行列を数値以外のデータで転置する場合（これは完全に有効なユースケースです）、数学的な転置表記は実際には駄洒落のように見えます。

A.'は、通常の意味では実際には「数学的な転置表記」ではないため、これが賛成または反対の議論であるとは思いません。

@ararslanは、既存の.'に反対しているのではなく、上付き文字-T構文の導入に反対していると思います。 私は同意する傾向があります-随伴の線形代数の概念を意味する場合は、 'を使用する必要があります（行列が実際に存在する場合でも）。 また、数値以外のデータの行列がある場合は、2つのインデックスを並べ替えることはもちろん完全に正当ですが、この操作は、通常考えられているように実際には「転置」ではなく、数学的な上付き文字を使用します-T表記はおそらく、明確にするよりも混乱する可能性が高いでしょう。 上付き文字-T表記が実際に適切である唯一の状況は、インデックスを並べ替えたい数値行列があるが、随伴線形演算子は実際には必要ない場合です。 このような状況は確かに存在しますが、新しい構文を導入することを正当化するにはまれすぎる可能性があります。

参照。 https://github.com/JuliaLang/julia/issues/20978#issuecomment-315902532 。 一番！

...しかし、この操作は、私たちが通常考えるように、実際には「転置」ではありません...

これが非常に珍しい場合、なぜararslanや他の多くの人がtranspose(A)として構造転置のスペルに投票するのですか？

ありがとう@StefanKarpinski @ ararslan@ ttparker。 線形代数のテキストに戻って、随伴作用素を再発見する必要がありました。 私は複素解析の前にそれを取りました、おそらく私がそれに気づかなかった理由。

私はこれができるのが大好きです
gradient = (1/m) * (X'Θ - Y) * X'

私の混乱は、参照ドキュメント、論文、教科書などでの「転置」（上付き文字Tとして）の広範な使用に起因します。たとえば、 Andrew NgのスタンフォードCS229講義ノートでは、対応するJuliaコードはadjointを次のように使用します。上記の@StefanKarpinskiのすっきりとした例で。 これは、随伴と転置がℝ （右？）で同等であるためです。 更新：うん

転置の私の好みの表記法は、論理的に一貫しているものです。 明らか.'は点線の演算子構文との競合によるものではなく、Unicodeの上付き文字を除いて、適切な特別な構文が利用できないように見えるため、特別な構文がないtranspose(A)に異議はありません。

transpose @tの転置をたくさん書いていることに気付いた場合は、 @ttparkerソリューションが好きです。

繰り返しますが、私は次のように誤解しました。

transpose(A) with no special syntax # please don't do this.

大学院レベルの数学の貧弱な施設にもかかわらず、私のコメントを真剣に受け止めてくれてありがとう。

（談話から。）

'をf'を'(f)にマップする修正後の演算子にしたいのですが、 Base.:'(x::AbstractMatrix) = adjoint(x)で、ユーザーは他のメソッドを自由に追加できます。随伴とは何の関係もありません。 （たとえば、 f'がdf / dtを参照することを好む人もいます。）

0.7で導入された演算子の接尾辞を使用すると、 f'ᵃが'ᵃ(f)などにマップされ、ユーザーが独自の接尾辞演算子を定義できるようになります。 これにより、 Base.:'ᵀ(x::AbstractMatrix) = transpose(x)やBase.:'⁻¹(x::Union{AbstractMatrix,Number}) = inv(x)などを使用できるようになります。

A'ᵀを書くことは、おそらくAᵀほどきれいではありませんが、 ᵀで終わる変数名を廃止する必要はありません。

一見、それは非破壊的な機能である可能性があるように見えます。 それは非常に賢い妥協です。 それはいいですね。

私には合理的なようです。 最も難しい部分は、 '関数の名前を考え出すことです。この場合、プレフィックス構文は機能しません。

最も難しい部分は、'関数の名前を考え出すことです

apostrophe ？ 文字通りすぎるかもしれません...

プレフィックス構文を機能させることは可能ですか（たとえば、明示的な(')(A)構文を使用しますか？）？ そうでない場合は、 https：//github.com/JuliaLangによって導入されたif-you-can-define-the-symbol-name-then-you-can-override-its-syntaxルールに違反するため、これは問題です。

編集：利用可能に見えます：

julia> (')(A)


ERROR: syntax: incomplete: invalid character literal

julia> (')(A) = 2


ERROR: syntax: incomplete: invalid character literal

残念ながら、 'は、非常に高い優先順位（識別子自体の優先順位と同じ）を持つ別の種類のアトム（文字）を導入するため、識別子名として使用するのが最も難しい文字の1つです。 たとえば、 (')'はそれ自体に'を適用するのですか、それともオープンパレンの後に')'リテラルが続くのですか？

短期的には実用的ではないオプションの1つは、文字リテラルを'の価値がないと宣言し、代わりにc"_"のような文字列マクロを使用することです。

$＃$ 0 $＃$の前にドットコロンが付いている場合に、 'が識別子として解析され、 Base.:'が機能する場合はどうでしょうか。

もちろん(@__MODULE__).:'(x) = function_bodyを書くのは少し面倒かもしれませんが、 (x)' = function_bodyは同じように機能するはずです。 編集：いいえ、 (x)'はBaseの'の呼び出しにマップする必要があるためです。 現在のモジュールで'関数を定義するのは面倒ですが、それを行う理由もありません。

または、 ''を識別子'として解析させるのはどうでしょうか。そうでなければ、空の文字リテラルとして解析されます（これは現在解析レベルのエラーです）。 同様に、 ''ᵃは識別子'ᵃなどとして解析されます。

現在構文エラーではないものはすべて以前と同じように解析されます（たとえば、 2''は後置'が2に2回適用されます）が、 2*''は今では'の2回として解析します。

a'' === aが''(a) === a'になるのは、紛らわしいようです。 代わりにBase.apostropheを名前として使用する方が良いようです（またはそのようなもの）。

行列の転置に直接関係しない'構文に関するものなので、この議論を新しいGithubの問題に分割する方がよいでしょうか。

問題を分割する自動化された方法はありますか、それとも単に新しいものを開いてここのディスカッションにリンクする必要がありますか？

後者

上付き文字-T表記が実際に適切である唯一の状況は、インデックスを並べ替えたい数値行列があるが、随伴線形演算子は実際には必要ない場合です。 このような状況は確かに存在しますが、新しい構文を導入することを正当化するにはまれすぎる可能性があります。

議論するには遅すぎると思いますが、言及する価値があると思う1つの使用法を指摘したいと思います。複雑なステップの微分を内部にtransposeを持つ実数値関数に適用することです。それ。 （私は、この特定の理由から、MATLABとjuliaで.'が必要であると個人的に考えました。）

transposeが複数回発生する例を示します（この方法でそれを回避できる可能性がありますか？）

using LinearAlgebra

# f : Rⁿ → R
#     x  ↦ f(x) = xᵀ * x / 2
f(x) = 0.5 * transpose(x) * x

# Fréchet derivative of f
# Df : Rⁿ → L(Rⁿ, R)
#      x  ↦ Df(x) : Rⁿ → R (linear, so expressed via multiplication)
#                   h  ↦ Df(x)(h) = Df(x) * h
Df(x) = transpose(x) 

# Complex-step method version of Df
function CSDf(x) 
    out = zeros(eltype(x), 1, length(x))
        for i = 1:length(x)
        x2 = copy(x) .+ 0im
        h = x[i] * 1e-50
        x2[i] += im * h
        out[i] = imag(f(x2)) / h
    end
    return out
end

# 2nd Fréchet derivative
# D2f : Rⁿ → L(Rⁿ ⊗ Rⁿ, R)
#       x  ↦ D2f(x) : Rⁿ ⊗ Rⁿ → R (linear, so expressed via multiplication)
#                     h₁ ⊗ h₂ ↦ D2f(x)(h₁ ⊗ h₂) = h₁ᵀ * D2f(x) * h₂
D2f(x) = Matrix{eltype(x)}(I, length(x), length(x))

# Complex-step method version of D2f
function CSD2f(x)
    out = zeros(eltype(x), length(x), length(x))
    for i = 1:length(x)
        x2 = copy(x) .+ 0im
        h = x[i] * 1e-50
        x2[i] += im * h
        out[i, :] .= transpose(imag(Df(x2)) / h)
    end
    return out
end 

# Test on random vector x of size n
n = 5
x = rand(n)
Df(x) ≈ CSDf(x)
D2f(x) ≈ CSD2f(x)

# test that the 1st derivative is correct Fréchet derivative
xϵ = √eps(norm(x))
for i = 1:10
    h = xϵ * randn(n) # random small y
    println(norm(f(x + h) - f(x) - Df(x) * h) / norm(h)) # Fréchet check
end

# test that the 2nd derivative is correct 2nd Fréchet derivative
for i = 1:10
    h₁ = randn(n) # random h₁
    h₂ = xϵ * randn(n) # random small h₂
    println(norm(Df(x + h₂) * h₁ - Df(x) * h₁ - transpose(h₁) * D2f(x) * h₂) / norm(h₂)) # Fréchet check
end
# Because f is quadratic, we can even check that f is equal to its Taylor expansion
h = rand(n)
f(x + h) ≈ f(x) + Df(x) * h + 0.5 * transpose(h) * D2f(x) * h

重要なのは、 fとDfはtransposeを使用して定義する必要があり、随伴作用素を使用してはならないということです。

複雑なステップの方法は、ジュリアにはあまり関係がないと思います。 言語が効率的な組み込みの複素数をサポートしているが、同等に効率的なDualの数値タイプを定義できない場合に、自動微分を取得するのは巧妙なハック/回避策ではありませんか？ これは、非常に優れた自動微分ライブラリを備えたジュリアには当てはまりません。

複雑なステップの方法の代わりに二重数を使用することに同意します。これは非常に良い点です（私は個人的に、ジュリアですべての複雑なステップの方法の評価を二重数の評価に置き換えました）。 ただし、これは、デモンストレーションの目的、トリックの指導（たとえば、 Julia Con2018での複雑なステップの方法について話しているNickHighamを参照）、および移植性（つまり、複素数を使用した上記のMATLABのコードのバージョンはよりクリーンです）。

実際の配列よりも複雑な配列を使用するエンジニアやおそらく物理学者の世界から来て、転置演算子がないのは少し面倒です。 （調和時間依存性の複雑なフェーザ表現は、私たちの分野ではどこにでもあります。）私の唯一の考慮事項は簡潔さですが、私は個人的にxHとxTのnumpy構文を好みます。

私のコードでは、エルミート転置に対する転置演算子の密度は約1対1です。 したがって、非共役転置も同様に重要です。 転置の多くの用途は、外積を作成し、他のコードとのインターフェースや行列の乗算のために配列のサイズを正しく設定することです。

今のところ、操作にマクロまたは1文字の関数を提供するだけですが、古い機能であるtranspose（）またはpermutedims（）に相当するものは何ですか？

transposeは線形代数を対象としており、再帰的です。 permutedimsは、あらゆるタイプのデータを非再帰的に配置するためのものです。

随伴と同じくらい転置を使用すると言うのは興味深いことです。 以前は同じでしたが、主にデータが実際の場所で間違いを犯しがちだったため、転置する傾向がありましたが、実際には随伴作用素が正しい操作でした（複雑なケースに一般化されました-随伴作用素は私のアルゴリズムにとって正しい操作でした）。 もちろん、（多くの）有効な例外があります。

電気力学に関連するすべての場合、空間のようなベクトルを使用することが多く、R ^ n（通常はn = 3）でベクトル演算を使用したい場合があります。つまり、ベクトルが複素数値であるため、特にtransposeです。フーリエ変換を行いました。 @mattcbroがこの種のアプリケーションについて話しているようです。

そうは言っても、構文の議論を読んでいるとき、私は個人的に、もう少し冗長な構文がプログラミングの速度や効率を遅くするものだとは想像できなかったとよく考えています。 アルゴリズム自体とそれを実装する最も自然で効率的な方法について考えると、はるかに時間がかかります。

電気力学に関連するすべての場合、空間のようなベクトルを使用することが多く、R ^ n（通常はn = 3）でベクトル演算を使用します。つまり、フーリエを使用したためにベクトルが複素数値であっても、特に転置します。変身。

必ずしも。 多くの場合、フーリエ振幅からの時間平均量が必要です。この場合、複素ドット積を使用します。たとえば、½ℜ[𝐄*×𝐇]は複素フーリエ成分からの時間平均ポインティングフラックスであり、¼ε₀|𝐄|²は時間平均真空エネルギー密度。 一方、マクスウェル演算子は（通常）複素対称演算子（「逆数」）であるため、フィールド𝐄（𝐱）などの（無限次元）代数に非共役の「内積」を使用することがよくあります。すべてのスペース。

それは本当です、私は最初の文にしばしばその単語を持っていました、しかしそれを明らかに削除しました:-)。

そこに行きたいのであれば、電磁量は、しばしば幾何代数と呼ばれるクリフォード代数の定式化でさらに簡潔に書かれています。 これらの代数には、特に散乱問題を考慮する場合に、理論の定式化において重要な役割を果たす複数の自己同型と反自己同型があります。

これらの代数は通常、簡潔な行列表現を持ち、これらの射は、複雑な転置、エルミート転置、および活用を介して簡単に計算されることがよくあります。

それでも、前に述べたように、転置の主な用途は、配列を他の配列や他のコードとインターフェイスするように配置し、行列の乗算をフラット化された配列の正しい次元に対して機能させることです。

私は個人的にxHとxTのnumpy構文を好みます

1.0で簡単に実装でき、効率的であるはずです。

function Base.getproperty(x::AbstractMatrix, name::Symbol)
    if name === :T
        return transpose(x) 
    #elseif name === :H # can also do this, though not sure why we'd want to overload with `'`
    #    return adjoint(x)
    else
        return getfield(x, name)
    end
end 

これは驚くほど簡単で、ちょっとすっきりしています。 欠点は、 getpropertyの直交使用が互いに構成されないことです。 したがって、特定のマトリックスタイプにgetpropertyを実装する人は、一般的な動作を手動で実装する必要があります。

getpropertyの直交使用は構成されません

うーん。 それは、xTがgetproperty(x, Val(:T))に「下げられるべきだった」ことを意味するのだろうか。 しかし、それが貧弱なコンパイラに何をもたらすかを考えると、私は震えます。

誰もが自分の意見を持っていると確信していますが、私にとっては、ドット構文から汎用インターフェイスを構築するのが難しいというのはほとんど機能です。 誤解しないでください。これは本当に素晴らしい機能であり、名前付きタプルのような構造体などを定義するのに最適です。

（ Valディスパッチレイヤーをタイプに非常に簡単に追加することも可能です）。

@c42fのコードは魅力のように機能します。 残念ながら、バージョン0.64以降で動作するコードを作成しようとしています。これにより、転置または独自に定義した関数T（A）= transpose（A）のいずれかを使用する必要があります。 おそらく、マクロはもう少しクリーンで少し効率的だったでしょう。

明確にするために、この特定のgetpropertyを定義することがユーザーコードにとって良い考えであることを示唆しているわけではありません。 長期的には問題が発生する可能性があります;-)おそらくいつの日か、 x.TをBaseで定義できるという結果を十分に感じることができるでしょう。

しかし、一般的な意味で、ジェネリックインターフェイスで「ゲッター」を定義するためのこの種のプロパティの使用が実際に悪いのはなぜだろうか。 たとえば、一般的なフィールドゲッター関数には現在、 getpropertyを適切に使用することで簡単に解決できる、非常に大きな名前空間の問題があります。 MyModule.A(x) 、 get_my_A(x)のようなもっと長い醜い関数名を書くよりも、 x.Aを書く方がはるかに良いです、またはユーザーから非常に一般的な名前Aをエクスポートするモジュール。 私が見ている唯一の問題は、スーパータイプで一般的に定義されている.Aとは関係なく、サブタイプの.Bの意味をオーバーライドする機能が期待されることです。 したがって、 Valについての半分深刻なコメント。

面白いアイデア：

julia> x'̄
ERROR: syntax: invalid character "̄"

キャラクターはTのように見えますが、実際には'の上にバーがあります。 深刻かどうかわからない...

ええ、私にもGitHubでそのように見えます。 しかし、それはオーバーバーです。 ターミナルショーにコピーして貼り付けます。

賢すぎてかわいい。 ただし、私はまだ結合文字が好きで、 'ᵀはいいと思います。

-100を随伴作用素に変更します。これは、Juliaコードを数学を書くのと同じくらい明確にする素晴らしいもののひとつであり、さらに共役転置は通常、とにかく必要なものなので、構文を省略した方が理にかなっています。

このような発言には傲慢さがあります。 開発者の一部の有限の割合が明示的にadjoint()を望んでいないが、 transpose()を必要としていることを考慮してください。

デフォルトの'演算子をモデル化するためのシンボリック計算を使用する場合のケースとポイントは、たとえば、疑似逆行列(A'*A)\(A * b）または2次形式v'*A*vが誤って返される原因になります。長くて複雑な結果を減らすことはできません。

おそらく解決策は、 'の意味を宣言するある種のコンパイラ指令です。