Andreas는 #19344에서 Aᵀ (아마도 Aᴴ )를 시도했지만 그다지 좋은 반응을 얻지 못했습니다. A^T 가 전치되도록 특수 지수 유형 T (아마도 H )을 사용하여 ^ 를 유사하게 말장난할 수 있지만, 그것도 다소 모호합니다. 여전히 수학 표기법처럼 보이는 다른 많은 좋은 옵션이 있는지 확실하지 않습니다.

t(A) 가 최고일 수도 있다고 생각하지만, 다른 한 글자 이름을 "도용"하는 것은 유감스러운 일입니다.

내 의견을 다른 문제에서 옮기기(아무것도 해결하지는 않지만...):

.' 이외의 것을 사용하는 경우 +1 .

명확하지 않은 ⍉ 를 사용하는 APL 과 *X (Julia에게는 혼란스러울 수 있음)를 사용하는 Python을 제외하고 전치에 대한 특수 구문이 있는 언어를 찾을 수 없습니다. 여러 언어는 transpose(X) 를 사용합니다. R은 t(X) 를 사용합니다. 예쁘지는 않지만 .' 보다 나쁘지는 않습니다. 적어도 ' 를 .' 와 혼동하여 사용하려는 유혹이 덜합니다. 이 작업은 매우 다른 작업임이 분명합니다.

Rosetta 코드를 참조하십시오. (BTW, Julia 예제는 실제로 켤레 전치를 보여줍니다 ...)

다른 틱 중 하나를 사용할 수 있습니까? ` 또는 "

-100 to 변경 adjoint, Julia 코드 작성을 수학 작성만큼 명확하게 만드는 멋진 것 중 하나에 플러스 켤레 전치 일반적으로 원하는 것이므로 축약된 구문을 사용하는 것이 좋습니다.

켤레 전치에 대한 멋진 구문이 있는 한 일반 전치에 대한 후위 연산자는 대부분 불필요해 보이므로 일반 함수 호출로 사용하는 것이 나에게는 괜찮아 보입니다. transpose 는 이미 작동합니다. 그냥 사용하면 안되나요? t(x) R-ism이 불행하다고 생각합니다. 이름에서 실제로 무엇을 해야 하는지 명확하지 않기 때문입니다.

다른 눈금을 사용하면 좀 이상할 것입니다. 예를 들어 A` 는 글꼴에 따라 A' 처럼 보일 수 있고 A" 는 A'' 처럼 보입니다. .

#20978에서 변경하면 접미사 전치가 실제로 지금보다 더 유용합니다. 예를 들어 x 및 y 두 벡터가 있고 $ f 를 쌍으로 적용하려는 경우 $ f.(x, y.') ... with #20978 , 이것은 임의 유형의 배열에 적용할 수 있습니다.

솔직히 말해서, 우리의 최선의 선택은 여전히 ​​그것을 그대로 두는 것이라고 생각합니다. 어떤 제안도 나에게 명확한 개선으로 보이지 않습니다. .' 는 Matlab의 친숙함이라는 장점이 있습니다. . 는 실제로 f.(x, y.') 와 같은 예에서 점 호출 구문과 다소 일치하며 전치 "퓨즈"( RowVector 덕분에 임시 사본을 생성하지 않음)를 제안합니다(다소 정확하게).

사실, 우리는 더 나아가 f.(x, g.(y).') 융합 작업을 할 수도 있습니다. 즉, .' 전치를 비재귀적 ala #20978 로 변경하고 다른 중첩된 점 호출과의 융합을 포함하도록 의미 체계를 확장합니다. (비융합 버전을 원하면 transpose 을 호출합니다.)

나는 그 계획이 아주 마음에 든다, @stevengj.

한 가지 주름: 아마도 @. 매크로는 y' 를 y.' 로 바꾸지 않을 것입니다(잘못된 것이기 때문에). 그러나 y' 를 일종의 융합된 adjoint 연산으로 바꿀 수 있습니다.

주요 문제는 f.(x, g.(y).') 에 융합 의미 체계를 갖도록 하는 깔끔한 방법을 찾는 것입니다. 한 가지 가능성은 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 fallback을 정의할 필요가 없었기 때문입니다.

그러나 폴백이 있는 것은 끔찍하지 않지만 여전히 비재귀적입니다.

두 가지 의견을 추가하겠습니다.

• 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.') )에 대해 함수를 브로드캐스트하기 위해 두 벡터를 서로 직교하도록 만드는 가장 간단한 방법입니다.

데이터 포인트: 어제 나는 접미사 "broadcast-adjoint" 연산자와 그것이 조옮김처럼 작동하는 이유에 의해 혼란스러워하는 당사자를 만났습니다. 최상의!

FWIW, 나는 우리가 .' 구문을 제거해야 한다고 강하게 느낍니다. Matlab보다 Julia에 더 친숙한 사람으로서 나는 그것이 벡터화된 adjoint를 의미할 것이라고 예상했고 그렇지 않을 때 정말 걸려 넘어졌습니다. Julia는 Matlab이 아니며 Matlab의 규칙에 구속되어서는 안 됩니다. Julia에서 점이 인접 함수의 벡터화를 의미하는 경우 이는 언어 전반에 걸쳐 일관되어야 하고 .' 이라는 끔찍한 예외가 무작위로 있어서는 안 됩니다. ' 와 공식적으로 관련이 없습니다.

특별한 "틱" 표기 없이 transpose 만 있어도 괜찮다고 생각합니다. 대부분의 경우 실수 행렬에서 호출되므로 ' 는 다음과 같을 것입니다. 정말 타이핑을 저장하고 싶습니다. 전치의 융합 버전을 만들고 싶다면 .' 가 올바른 구문이라고 생각하지 않습니다.

그건 좋은 지적이야. 틀림없이 adjoint에만 초소형 구문이 필요합니다.

이것을 transpose 라고 부르고 .' $ 를 사용하지 않도록 합시다. 미래에 우리는 .' 를 pointwise adjoint로 원하는지 아니면 Matlab 사용자를 가두는 것을 피하기 위해 영구 사용되지 않는 상태로 두기를 원하는지 고려할 수 있습니다.

방금 등록된 패키지를 검색하고 .' 의 600개 이상의 사용법을 찾았으므로 그리 드문 일이 아닙니다. 그리고 점 호출 / broadcast (0.6에서만 숫자가 아닌 데이터를 완전히 처리하기 시작함)을 사용하면 숫자가 아닌 배열을 느리게 전치 하려는 욕구(adjoint가 덜 의미가 있는 경우)가 훨씬 더 일반적이 될 것입니다. 간결한 구문에 대한 주장이 다소 강화되었습니다.

그런 다음 더 많은 코드가 잘못된 사용 패턴에 갇히기 전에 가능한 한 빨리 .' 를 사용하지 않는 것이 좋습니다.

왜 나쁜가요?

문제는 .' 가 이제 점 연산자로 의미하는 바를 의미하지 않는다는 것입니다.

위에서 말했듯이 . 는 벡터화를 의미하는 일반적인 패턴을 위반하기 때문에 벡터화된 adjoint를 의미하는 것처럼 보입니다(특히 Matlab에 익숙하지 않은 사람에게).

나는 @stevengj 가 좋은 지적을 한다고 생각합니다. 이것은 단순한 비재귀 전치에 대한 욕구와 관련이 있습니다.

나는 그것이 인기가 없다는 것을 알고 있지만 ᵀ 에 Andreas의 #19344를 선호하기 시작했습니다. 이 시점에서 나는 _all_ 위 첨자를 식별자로 사용하지 않는 것을 선호하고 _any_ 후행 위 첨자를 후위 연산자로 해석합니다. 이것은 또한 위 첨자 숫자를 사용하여 literal_pow 주변의 약간의 어색함을 해결하는 경로를 제공합니다. 네, χ² 와 같은 변수 이름을 잃는 것은 슬픈 일이지만 단점보다 이점이 더 크다고 생각합니다.

이 시점에서 나는 _all_ 위 첨자를 식별자로 사용하지 않는 것을 선호하고 _any_ 후행 위 첨자를 후위 연산자로 해석합니다.

내 코드 추출

이 시점에서 모든 위 첨자를 식별자로 사용하지 않는 것이 좋습니다.

우리가 단지 T 를 원하고 미래에 몇 가지 다른 것을 원할 때 그것이 필요하다고 생각하지 않습니다.

어리석은 일관성…

예, 전치에 .' 를 사용하는 것은 약간 일관성이 없지만 지금까지 제안된 모든 대안은 더 나쁜 것 같습니다. " .' 는 전치, 점 연산자에 대한 일반적인 규칙의 예외"라고 말하는 것이 세상에서 가장 나쁜 것은 아닙니다. 이것을 배우고 계속 진행합니다.

.' 가 점 브로드캐스트가 아닌 것에 대한 잠재적인 혼동에 도움이 될 수 있는 한 가지 유의할 점은 접두사 브로드캐스팅이 op. 이고 중위가 .op 인 반면 접미사 연산자라는 것입니다. 따라서 우리는 . 가 접미사일 때 브로드캐스트를 의미하지 않는다고 말할 수 있습니다. 접미사 . 의 다른 용도는 필드 조회이며 getfield(x, ') 는 의미가 없으므로 다른 의미와 구별됩니다.

(즉, 나는 $ .' transpose(x) 를 선호합니다.)

@stevengj 위에서 언급한 등록된 패키지에서 .' 의 600개 이상의 사용 중 많은 (아마도 대부분) 가독성에 대한 비용 없이 ' 로 대체될 수 있으며 코드 계속 일할 것입니다.

인기가 없을 수도 있지만 여전히 접미사 " 및 ` 가 있을 수 있습니까?

'의 용도 위에서 언급한 등록된 패키지에서 가독성에 대한 비용 없이 '로 대체될 수 있으며 코드는 계속 작동합니다.

#23424 가 도착하면 문자열 배열 등에 transpose 를 사용할 수 있지만 adjoint 는 사용할 수 없습니다. x.' 의 선형 대수 사용에 대한 모범 사례는 아마도 conj(x') 와 같이 될 것입니다(이것이 게으른, 즉 무료임). 간결함을 위해 .' 을 사용하는 것을 좋아하지만 이를 제거하면 선형 대수학 사용자가 올바른 것을 사용하고 데이터 배열 사용자가 철자법 transpose 을 사용하도록 강제할 수 있습니다.

여전히 접미사 "와 `?

transpose() 에 대한 새 구문은 다소 시기상조입니다. IMHO 필요에 따라 conj(x') 및 transpose 로 제안한 대로 .' 를 더 이상 사용하지 않는 것이 좋습니다.

나는 .' 이 matlab에서 매우 유용하다는 느낌을 받습니다. 주로 "모든 것이 행렬이다"라는 matlab의 주장과 다양한 위치에 무작위 전치를 삽입해야 하는 일관된 슬라이싱 규칙이 없기 때문입니다. 일을 시작하십시오.

여기에서 주장을 요약하면 다음과 같습니다.

1. .' 는 이제 "점으로 구분되지 않은 연산자를 요소별로 적용"을 의미하지 않는 점 연산자로서 유일하게 눈에 띕니다. Matlab에서 오지 않는 새로운 사용자는 이것이 놀라운 함정임을 알게 됩니다.

2. .' 는 이제 사실상 모호합니다. transpose 를 의미했습니까 아니면 conj(x') 를 의미했습니까? 원칙적으로 .' 의 모든 레거시 사용은 2차원 배열의 인덱스를 치환하는지 또는 "비공액 adjoint"를 수행하는지 여부를 확인하기 위해 조사되어야 합니다.

첫 번째 문제는 문제가 있지만 그 자체로 치명적이지는 않습니다. 두 번째 문제는 정말 나쁜 문제입니다. 이것은 더 이상 하나의 일관된 작업이 아니라 두 개의 별도 의미로 분할됩니다.

방금 .' 를 "요소별 adjoint"로 변경했다면 conj(x') 는 대략 x'.' 와 같고 conj(x)' 는 대략 x.'' 가 됩니다. x.' 😬에 너무 가깝습니다.

인기가 없을 수도 있지만 여전히 접미사 "와 `?

코드를 Slack에 복사하여 붙여넣고 구문 강조 표시를 없애는 것을 보는 것은...

무엇이든 조옮김할 수 있다는 것은 디스패치 메커니즘 및 이와 같은 기타 짧고 간결한 사용 사례를 통해 "교차 제품"을 쉽게 만들 수 있기 때문에 좋습니다. 이런 종류의 항목에 대한 쉬운 폴백이 없는 문제는 항상 우리가 보게 될 해킹이 transpose(x) = x 폴백(또는 기본 유형에서 패키지의 유형 불법 복제)을 정의하여 이것을 만드는 것입니다. 쉽게 작동하는 종류. Complex 가 이상한 것이 아닌 이유는 무엇입니까? 대부분의 숫자의 adjoint는 자체이므로 complex의 adjoint는 전문화할 수 있는 것입니다. 숫자를 넘어 확장될 수 없습니까?

여기에서 매우 관련된 두 가지를 볼 수 있습니다.

1) x' 는 숫자가 아닌 유형에는 작동하지 않으므로 다른 데이터에 대해 쉽게 수행할 수 있는 방법을 원합니다.
2) transpose(x) 는 x.' 만큼 간단하지 않습니다. 복잡한 행렬을 전치하는 사용 사례가 훨씬 더 드물기 때문에 이것은 주로 (1)의 경우입니다.

그러나 아래로 내려가는 대신 (2), (1)에 대해 합리적인 수정을 시도하고 시도하지 않는 이유는 무엇입니까?

아마도 합리적인 수정은 ' 가 adjoint 대신 전치를 의미하는 매크로일 수 있습니까?

그러나 아래로 내려가는 대신 (2), (1)에 대해 합리적인 수정을 시도하고 시도하지 않는 이유는 무엇입니까?

우리는 이미 그 경로와 그 경로에 인접해 있습니다. 다른 누군가가 추출할 수 있는 결과에 대한 많은 토론이 있었지만 요약하면 잘 되지 않습니다. 기본적으로 수학적 adjoint 연산은 숫자가 아닌 경우에는 의미가 없습니다. 간결한 구문을 좋아하기 때문에 숫자가 아닌 것에 ' 를 사용하는 것은 좋지 않습니다. 이것은 최악의 연산자 말장난이며 이러한 종류의 의미 남용으로 인해 나쁜 일이 뒤따르는 것은 놀라운 일이 아닙니다. adjoint 함수는 adjoint를 취하는 것이 타당한 것에 대해서만 정의되어야 하고 ' 는 그 의미로만 사용해야 합니다.

현재 사용되는 .' 는 기본적으로 배열 전치와 비공액 adjoint의 두 가지 다른 작업이라는 것을 기억하십시오. 재귀 전치 문제는 이러한 연산이 서로 다르므로 이를 표현하는 다른 방법이 필요하다는 사실을 강조합니다. 수학자들은 non-conjugate adjoint 연산이 (a) 중요하고 (b) 차원의 단순한 스와핑과는 다르다는 데 단호한 것 같습니다. 특히, 정확하려면 비공액 adjoint는 재귀적이어야 합니다. 반면에 일반 배열의 차원을 바꾸는 것은 분명히 재귀적이지 않아야 합니다. 따라서 이러한 작업은 다르게 작성되어야 하고 .' 의 기존 사용법은 하나의 의미 또는 다른 의미를 갖는 것으로 명확해야 합니다. .' 를 비추천하는 것은 이것을 강제하는 방법입니다.

마지막으로 permutedims(x, (2, 1)) 가 2차원 배열의 차원을 바꾸기에는 확실히 너무 불편하다고 강하게 느끼긴 하지만 transpose(x) 가 너무 불편하다는 주장은 설득력이 없습니다. 이 작업이 너무 일반적이어서 간단하고 명확한 함수 이름을 갖는 것이 너무 많습니까? 진짜? 우리가 함수 이름과 함수 호출 구문을 사용하는 언어의 다른 모든 것보다 배열의 차원을 바꾸는 것이 훨씬 더 일반적이거나 중요합니까? Householder 표기법은 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 가 위 첨자 기호인 경우에도 식별자가 됩니다.

이 예제 해킹은 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 패키지를 수행할 수 있으며 여기에서 가장 좋은 것을 찾는 데 만족합니다. 그러나 현재 이 구문 제한은 다음과 같습니다.

• 식별자의 시작 부분에 숫자 상위 인덱스를 사용하는 것은 허용되지 않습니다.
• superindex x * ᶠ in postfix(해킹에서 암시적 곱셈) (x)ᶠ 허용되지 않음

나에게 조금 너무 많은 것 같습니다. IMHO, 나는 적어도 숫자 위 첨자로 시작할 수 있는 식별자를 정의할 수 있고 싶습니다. 또는 더 일반적으로 시작 시 숫자 의미 체계가 있는 실제 숫자 문자 0-9만 허용하지 않습니다. 식별자, 그것은 굉장할 것입니다. 😄

건배!

식별자로 다른 숫자 문자에 대한 설명은 #10762를 참조하세요.

다른 문제는 #22089, 연산자 접미사와 관련이 있습니다. +ᵀ 는 이제 유효한 연산자로, 연산자가 예상될 수 있는 컨텍스트에서 결합 문자로만 구성된 식별자를 (아마도 실수로) 허용하지 않았습니다. 그것은 나에게 버그처럼 보인다. ᵀ 가 유효한 식별자이지만 -ᵀ 가 -(ᵀ) 를 수행하지 않는다는 것도 약간 이상합니다. 그러나 그것이 세상의 끝이 아니며 IMO 수정은 ᵀ 의 다른 가능한 용도를 잃을 가치가 없습니다.

.' 를 후위 전치 연산자로 사용하는 것은 여기의 표에도 없습니다(문제의 주제가 무엇을 말하더라도), 고려 사항은 실제로 .' 를 후위 연산자로 유지해야 하는지 여부입니다. 비공액 adjoint의 경우 재귀적입니다. 이것은 종종 전치와 동일하지만 일반적으로 동일한 작업은 아닙니다. 선형 대수학 사람들이 .' 가 일반 배열 전치를 의미하도록 기꺼이 허용한다면 그것은 다른 이야기이지만 내 인상은 받아들일 수 없다는 것입니다.

@Ismael-VC, 위 첨자에 대한 접미사 함수 구문으로 (x)ᵀ 를 허용하는 것을 볼 수 있습니다. 다른 의미는 무엇입니까? 나는 당신의 제안이 사람들을 잘못된 방식으로 문지르기 시작하는 곳에서 모든 식별자가 접미사 구문의 함수로 적용될 수 있도록 허용한다고 생각합니다. 나는 그것을 위첨자로 제한할 것이다.

@StefanKarpinski , 나는 합의가 정확히 .' 가 비재귀적, 비공액 배열 전치(이 연산자가 있는 경우)를 의미하는 반면 ' 는 재귀, 공액 부속작전.

저는 후위 전치 연산자에 ᵀ 를 사용하는 아이디어를 정말 정말 싫어합니다. aᵀa 또는 LᵀDL = ltdlfact(A) 와 같이 변수 이름에 위 첨자로 사용 하는 것은 너무 유용합니다. (연산자에 ᵀ 만 사용하고 다른 위 첨자는 식별에 유효하다는 사실 외에는 이상할 것입니다.)

그것은 전혀 이해가 되지 않았습니다. 저는 linalg 사람들이 a.' 를 그대로 유지하는 것을 선호한다고 생각했습니다. 즉, conj(a)' 을 의미합니다. .' 를 유지하지만 배열 전치로 의미를 변경하는 것은 상당히 다릅니다. 저는 그것에 대해 어떻게 느끼는지 잘 모르겠습니다. 후위 연산자로 ᵀ 사용하는 것이 짜증나고 일관성이 없다는 데 동의합니다. 나는 @Ismael-VC의 (a)ᵀ 제안을 좋아하지만 aᵀ 를 이름으로 사용하는 것을 막지는 않습니다.

그 토론에 대한 나의 기억은 Steven의 것과 같습니다. 재귀적이고 비공액 전치는 드물고 일반적으로 꽤 이상합니다. 여기에 적절한 요약이 있습니다: https://github.com/JuliaLang/julia/issues/20978#issuecomment -316141984.

나는 우리 모두가 접미사 ' 가 인접하고 있어야 한다는 데 동의한다고 생각합니다.
우리 모두는 접미사 .' 가 차선책이라는 데 동의한다고 생각합니다.
나는 대부분의 사람들이 비재귀적(구조적) 전치가 재귀적 전치보다 더 유용하다는 데 동의한다고 생각합니다.

자, 모두가 동의하는 요점은 다음과 같습니다.

1. adjoint(a) a' 사용
2. (non-)conjugate adjoint에 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*' — 새로운 bigraph. 일반적인 수학 표기법은 이것을 conj(A)' 로 해석할 수 있습니다. 이는 실제로 우리가 원하는 것에 매우 가깝습니다. 0.6에서는 사용할 수 있었지만 0.7에서는 * 를 사용하여 문자를 연결하는 것을 허용합니다. 그래도 여전히 작동 가능합니다.

줄 끝을 넘어 구문 분석하는 사용자 지정 문자열 리터럴로 인해 접미사 " 및 ` 를 사용할 수 있다고 생각하지 않습니다. 같은 이유로 접미사 * 자체도 사용할 수 없습니다. 접미사 소수 A′ 는 아마도 가장 일반적으로 사용되는 유니코드 식별자 중 하나이므로 Aᵀ 보다 훨씬 더 많습니다.

솔직히 제 코드를 보면 .' 를 전혀 사용하지 않기 때문에 transpose(a) 정도는 괜찮을 것 같습니다.

방금 등록된 패키지를 검색하고 .'의 600개 이상의 사용법을 찾았으므로 그다지 드문 일이 아닙니다.

' .' 가 사용되지 않았는지 확인하기 위해 이 지점을 전혀 확인했습니까? 나는 그것이 사실이 아닌 경우가 더 많다고 생각하기 시작했습니다. 그렇지 않으면, .' 의 합법적인 사용을 본 유일한 곳은 Plots.jl 레이블이 벡터를 허용하기 전이었습니다(대신 문자열의 행 벡터를 원함). 그러나 변경되었습니다. 이것이 자주 필요한 코드의 경우 T = transpose 로컬에서 시작하거나 ' 를 transpose 로 변경하는 매크로를 던집니다.

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

그 드문 경우에 나와 함께 괜찮을 것입니다.

사람들은 f.(v, w')를 사용하여 벡터의 데카르트 곱을 통해 f를 브로드캐스트하는 데 사용하려고 할 것입니다. 그리고 사람들은 그것을 사용하여 문자열 벡터를 테이블과 같은 구조에 대한 헤더의 행 벡터로 재구성하려고 할 것입니다. 그래서 우리가 그들을 지시할 수 있는 간단하고 사용하기 쉬운 교체품이 있다는 것이 제게는 매력적입니다.

명령문에 한 번만 나타나면 transpose 만 사용하면 되지 않습니까?

conjugate-adjoint에 대한 a*' 구문은 꽤 훌륭하지만 실제로 더 나은 구문이 필요한 작업은 아닌 것 같습니다. &a 는 곧 사용할 수 있으며 이에 대한 기존 표기법과 상당히 다르지만 교환을 제안합니다.

밀짚 투표를 할 시간이 아닐까요?

구조적 조옮김을 어떻게 철자해야 합니까?

(대략 제안 순서대로, 여기에서는 이모티콘 이름에 대한 판단이 없습니다)

• 👍: A.' — 의미만 변경하고 구문은 동일하게 유지
• 👎: transpose(A) — 특별한 구문 없음
• 😄: t(A) 또는 tr(A) — 특별한 구문은 없지만 더 짧은 이름을 내보냅니다.
• 🎉: Aᵀ — ᵀ 와 식별자의 특수 문자로 된 하나 또는 두 개의 위 첨자 포함
• 😕: (A)ᵀ — 모든 위 첨자는 식별자와 분리되어 후위 연산자처럼 작동합니다.
• ❤️: A*' — 그 불쾌한 계곡 위에 바로 광택이 있습니다. 이는 구조적 조옮김을 의미합니다.
• &A 을 선호하는 경우 바로 위의 Stefan 게시물에 🎉를 던지십시오(이모티콘이 없습니다)

LinAlg 토론은 conj(x’) 가 비교적 드물기 때문에 .’ 를 비재귀 전치 사용에 선물하는 것에 대해 실제로 이야기했습니다. 그러나 ᵀ 는 수학적 구문이며 실제로 수학적 의미(있는 경우)를 취해야 합니다.

tr(A) 가 행렬 전치를 의미하는 것을 매우 강력하게 반대합니다. 모든 사람들은 이것이 행렬 추적을 의미한다고 생각할 것입니다: https://en.wikipedia.org/wiki/Trace_ (linear_algebra)

식별자로 위 첨자를 더 이상 사용하지 않는 경우(1.0 이전에는 심각하게 고려되어야 함) ᵀ(A) 도 가능합니다.

(A)ᵀ 제안과 관련하여 다음과 같은 언급으로 이 토론을 약간 방해한 것에 대해 사과드립니다.

저는 √ 를 단항 연산자로 사용할 수 있도록 하는 것에 대해 별로 신경을 쓰지 않았습니다. 특히 √(...) 를 하나 또는 몇 개의 문자. 게다가, 나는 항상 a² 와 √a 사이의 기능 차이가 매우 인위적이라는 것을 발견했습니다. 유니코드 클래스 등에 대해 안다면 아마도 이해가 될 것입니다. 그러나 다른 사람에게는 이것이 터무니없는 것처럼 보일 것입니다. a² 를 유효한 변수 이름으로 사용하는 것이 유용하지만 마찬가지로 √a 를 여러 개 사용해야 하는 경우 a 의 제곱근을 저장하는 데 유용한 변수 이름이 될 수 있습니다. 타임스. 또는 a²b 및 제곱근 a√b 와 같은 더 복잡한 표현식입니다. 여기서 전자는 유효한 식별자이고 후자는 그렇지 않습니다. 무엇보다 일관성이 좋아요.

따라서 일관성을 위해 괄호 (A)ᵀ , (a)² 를 유니코드 단항 연산자 √ (및 관련 항목) 제거와 함께 사용할 때 접미사 연산자를 사용하여 식별자에서도 사용할 수 있습니다(일반 함수 호출 √(a) 로 계속 액세스할 수 있음).

@Jutho의 말에 100% 동의하고 여러 번 생각했습니다. @Jutho, 이슈를 열어주시겠습니까? 제안: 식별자 이름에 √ 허용, op로 호출하려면 √(x) 필요.

다음 질문 -> 2 |> √ 는 어떻습니까?

다른 스레드에서 √ 에 대해 논의해 보겠습니다. 하지만 간단히 말해 2 |> √ 는 √(2) 를 의미합니다.

파서 변경이 필요하지 않고 입력하기 쉬운 또 다른 대안은 전치에 대한 A^T 입니다( T 를 ^ 메서드로 싱글톤 유형으로 정의). … 오, @mbauman 도 이 아이디어를 가지고 있다는 것을 알았습니다. 약간 못생겼지만 A.' 정도는 아닙니다.

나는 전문 지식이 없지만 내 작업 과정에서 행렬 표현식이 포함된 수천 줄을 입력할 가능성이 있는 사람이 누구인지에 따라 이 토론의 결과에 많은 투자를 하고 있습니다.

transpose(A) # with no special syntax 가 위의 표에서 이기고 있지만 눈과 손가락이 아프다.

파이썬에서 일반적인 사용법은 아마도 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ᵗ 인 후위 기호입니다.

개인적으로 나는 Julia v.0.6에서 작동하는 A' 에 매우 만족합니다. adjoint가 자주 사용됩니까?

다음은 표에 있는 내 의견입니다.

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.

개인적으로 나는 Julia v.0.6에서 작동하는 A' 에 매우 만족합니다. adjoint가 자주 사용됩니까?

이해할 수 없습니다. A' 는 항상 A 의 adjoint였습니다. 우리는 켤레 전치에 대해 기본 함수 ctranspose 를 호출했지만 기능의 변경 없이 동일한 용어 adjoint 로 이름을 변경했습니다.

선형 대수학을 수행하는 경우 어쨌든 켤레 전치를 원할 가능성이 훨씬 높으므로 transpose(A) A' 를 입력하게 됩니다. 비공액 전치에 대한 특수 구문을 정의하지 않는 인기는 (아마도) 부분적으로는 대부분의 선형 대수학에서 비공액 전치를 원하는 것이 일반적이지 않다는 사실에 부분적으로 기인합니다.

선형 대수학을 수행하는 경우 ...

도구가 망치라면 ... :)

... Julia가 일반 프로그래밍 언어로 성장할 가능성에 대해 생각해야 합니다.

아닐 수도 있고 선형 대수 문제로 남을 수도 있습니다. 이것은 저와 같은 프로그래머를 생각해야 하는 가능성입니다. :)

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

Julia로 문자 그대로 다음과 같이 작성됩니다.

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

또는 벡터가 NumPy 예제의 행이고 Julia의 열이라고 가정합니다.

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

그것은 그것이 얻는만큼 명확하고 수학적으로 보입니다. 데이터가 실제라면 adjoint와 transpose는 동일한 연산이며, 이것이 위의 transpose를 사용하는 이유일 수 있습니다. 그러나 수학적으로 adjoint는 올바른 연산입니다. @ararslan 이 말했듯이 X' 는 Julia(및 Matlab에서도)에서 항상 adjoint 를 의미했습니다. 이전에는 " conjugate transpose "의 줄임말로 ctranspose 라고 불렸지만 연산자의 정의 속성이

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

이것은 Hermitian adjoint 의 정의 속성이지만 A 가 복소수 행렬일 때 켤레 전치에 의해 충족됩니다. 그렇기 때문에 "adjoint"가 이 연산자에 대한 올바른 일반 용어입니다.

즉, a.' 가 구조적 전치를 의미하는 것이 좋을 것이라고 생각하기 때문에 위에서 transpose(a) 및 a.' 모두에 투표했습니다. 예상대로 작동하며 재귀적이지 않아 일부 일반 코드에서 "수학적으로 정확하지" 않더라도 예상대로 작동하는 것으로 충분해 보입니다. 그리고 사람들에게 일반 코드에서 conj(a') 를 사용하는 것을 고려하라고 말하는 것은 우리가 정말로 머리를 맞대야 할 필요가 있는 것이 아니라 교육적인 것처럼 보입니다.

@mahiki 어떤 이유로 adjoint transpose 를 코드에서 여러 번 사용해야 하는 경우 $#을 별칭으로 지정하는 @t 와 같은 더 짧은 매크로를 정의할 수 있습니다 transpose (이 솔루션이 이상적이지 않다는 것을 알고 있지만 특히 다른 사람들과 함께 코드를 작성하는 경우).

Julia가 일반 프로그래밍 언어로 성장할 수 있는 가능성을 생각해야 합니다.

@Liso77 벌써 그렇군요. 많은 예 중 하나에 불과한 Nanosoldier는 GitHub 이벤트를 수신 대기하고 요청 시 성능 벤치마크를 실행하는 웹 서버를 모두 Julia에서 실행합니다. 그러나 그것은 탈선이며 이 스레드가 주제에서 벗어나는 것을 원하지 않습니다.

숫자가 아닌 데이터로 일종의 행렬을 전치하는 경우(완전히 유효한 사용 사례임) 수학적 전치 표기법은 실제로 나쁜 말장난처럼 보입니다. 이 경우 transpose (또는 특정 요구 사항에 따라 permutedims 등)과 같이 요구하는 내용에 대해 더 명시적으로 설명하는 것이 좋습니다.

숫자가 아닌 데이터로 일종의 행렬을 전치하는 경우(완전히 유효한 사용 사례임) 수학적 전치 표기법은 실제로 나쁜 말장난처럼 보입니다.

A.' 는 일반적인 의미에서 실제로 "수학적 전치 표기법"이 아니기 때문에 이것이 찬성 또는 반대의 논거가 아니라는 것을 알 수 있습니다.

나는 @ararslan 이 기존 .' 에 반대하는 것이 아니라 위첨자-T 구문을 도입하는 것에 반대한다고 생각합니다. 나는 동의하는 경향이 있습니다. 선형 대수학의 adjoint 개념을 의미한다면 ' 를 사용해야 합니다(행렬이 실수인 경우에도). 그리고 숫자가 아닌 데이터의 행렬이 있는 경우 두 인덱스를 치환하는 것은 물론 완벽하게 합법적이지만 이 연산은 실제로 우리가 일반적으로 생각하는 "전치"가 아니며 수학적 위첨자-T 표기법을 사용하는 것은 다음과 같습니다. 명확히 하는 것보다 혼동할 가능성이 더 큽니다. 위 첨자-T 표기법이 실제로 적절한 유일한 상황은 인덱스를 치환하고 싶지만 인접 선형 연산자를 원하지 않는 숫자 행렬이 있는 경우입니다. 그러한 상황은 분명히 존재하지만 새로운 구문을 도입하는 것을 정당화하기에는 너무 드물 수 있습니다.

참조 https://github.com/JuliaLang/julia/issues/20978#issuecomment -315902532. 최상의!

... 하지만 이 작업은 실제로 우리가 일반적으로 생각하는 "조옮김"이 아닙니다. ...

이것이 매우 비정상적이라면 왜 ararslan과 다른 많은 사람들이 transpose(A) 철자법에 대해 투표 를 합니까?

@StefanKarpinski @ararslan @ttparker에게 감사드립니다. 나는 선형 대수학 텍스트로 돌아가서 adjoint를 재발견해야 했습니다. 나는 복합 분석 전에 그것을 가져 갔고 아마도 왜 그것을 눈치 채지 못했을 것입니다.

나는 이것을 할 수 있다는 것을 좋아한다
gradient = (1/m) * (X'Θ - Y) * X'

내 혼란은 참조 문서, 논문, 교과서 등에서 'transpose'(위 첨자 T로)의 광범위한 사용에서 비롯됩니다(예: Andrew Ng의 스탠포드 CS229 강의 노트 , 여기서 해당 Julia 코드는 adjoint 를 위의 @StefanKarpinski 의 깔끔한 예에서. 이것은 adjoint와 transpose가 ℝ에서 동일하기 때문입니다 (맞나요?) . 업데이트: 네

이제 내가 선호하는 전치 표기법은 논리적으로 일관성이 있는 것입니다. 분명히 .' 는 점으로 구분된 연산자 구문과의 충돌 때문이 아니며 유니코드 위 첨자를 제외하고는 정상적인 특수 구문을 사용할 수 없기 때문에 특별한 구문이 없는 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

불행히도 ' 는 식별자 이름으로 사용하기 가장 어려운 문자 중 하나입니다. 왜냐하면 식별자 자체의 우선 순위와 매우 높은 우선 순위를 갖는 다른 종류의 원자(문자)를 도입하기 때문입니다. 예를 들어, (')' 는 ' 자체에 대한 응용 프로그램입니까, 아니면 ')' 리터럴이 뒤따르는 열린 괄호입니까?

단기적으로는 실용적이지 않은 옵션 중 하나는 문자 리터럴을 ' 가치가 없는 것으로 선언하고 대신 c"_" 와 같은 문자열 매크로를 사용하는 것입니다.

' 앞에 점-콜론이 올 때 식별자로 구문 분석하여 Base.:' 가 작동하도록 하면 어떻습니까?

물론 (@__MODULE__).:'(x) = function_body 는 작성하기가 약간 번거롭지만 (x)' = function_body 는 동일하게 작동해야 합니다. 편집: 아니요, (x)' 는 Base ' 호출에 매핑되어야 하기 때문입니다. 현재 모듈에서 ' 함수를 정의하는 것은 번거롭지만 그렇게 할 이유도 없습니다.

또는 '' 가 식별자 ' 로 구문 분석되도록 하는 것은 어떻습니까? 그렇지 않으면 빈 문자 리터럴(현재 구문 분석 수준 오류임)으로 구문 분석되었을 것입니다. 마찬가지로 ''ᵃ 는 'ᵃ 등의 식별자로 구문 분석됩니다.

현재 구문 오류가 아닌 모든 것은 여전히 ​​이전과 같이 구문 분석되지만(예 2'' 는 2 에 두 번 적용된 접미사 ' 2 입니다), 2*'' 는 이제 ' 두 번 구문 분석합니다.

a'' === a 하지만 ''(a) === a' 가 있다는 것은 혼란스러운 것 같습니다. 대신 Base.apostrophe 를 이름으로 사용하는 것이 더 나은 것 같습니다(또는 이와 유사한 것).

행렬 전치와 직접적인 관련이 없는 ' 구문에 대한 것이기 때문에 이 토론을 새로운 Github 문제로 나누는 것이 더 나을까요?

문제를 자동으로 분할하는 방법이 있습니까, 아니면 단순히 새 문제를 열고 여기에서 토론으로 연결해야 합니까?

후자의

위 첨자-T 표기법이 실제로 적절한 유일한 상황은 인덱스를 치환하고 싶지만 인접 선형 연산자를 원하지 않는 숫자 행렬이 있는 경우입니다. 그러한 상황은 분명히 존재하지만 새로운 구문을 도입하는 것을 정당화하기에는 너무 드물 수 있습니다.

토론하기에는 너무 늦었다고 생각하지만 언급할 가치가 있다고 생각하는 한 가지 용도를 지적하고 싶습니다 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 를 사용하여 정의되어야 하며 adjoint를 사용해서는 안 된다는 것입니다.

나는 복잡한 단계 방법이 줄리아와 매우 관련이 있다고 생각하지 않습니다. 언어가 효율적인 내장 복소수를 지원하지만 동등한 효율적인 Dual 숫자 유형을 정의할 수 없는 경우 자동 미분을 얻는 것은 깔끔한 해킹/해결 방법이 아닙니까? 정말 멋진 자동 미분 라이브러리가 있는 julia의 경우는 그렇지 않습니다.

나는 복잡한 단계 방법 대신 이중 숫자를 사용하는 것에 동의하고 그것은 당신이 만들고 있는 매우 좋은 지적입니다(저는 개인적으로 이미 모든 복잡한 단계 방법 평가를 julia의 이중 숫자 평가로 대체했습니다). 그러나 나는 이것이 데모 목적으로 트릭을 가르치고(예를 들어, Julia Con 2018에서 복잡한 단계 방법에 대해 이야기하는 Nick Higham 참조), 이식성(즉, 내가 걱정하는 바)을 위한 유효한 사용 사례라고 생각합니다. 복소수를 사용하는 위 코드의 MATLAB 버전이 더 깨끗합니다).

실제 배열보다 복잡한 배열을 더 많이 사용하는 엔지니어와 아마도 물리학자의 세계에서 왔을 때 전치 연산자가 없다는 것은 약간의 고통입니다. (고조파 시간 종속성에 대한 복잡한 페이저 표현은 우리 분야에서 흔히 볼 수 있습니다.) 저는 개인적으로 xH 및 xT의 numpy 구문을 선호하지만 유일한 고려 사항은 간결함입니다.

Hermitian 전치에 대한 전치 연산자의 밀도는 내 코드에서 약 1:1입니다. 따라서 비공액 전치도 나에게 똑같이 중요합니다. 전치의 많은 사용은 외적을 생성하고 다른 코드와의 인터페이스 또는 행렬 곱셈을 위해 배열의 크기를 올바르게 조정하는 것입니다.

지금은 단순히 매크로나 하나의 문자 함수를 오퍼레이션에 제공하려고 합니다. 그러나 이전 기능인 transpose() 또는 permutedims()에 상응하는 적절한 것은 무엇입니까?

transpose 는 선형 대수학용으로 재귀적이며 permutedims 는 모든 유형의 데이터를 비재귀적으로 배열하기 위한 것입니다.

당신이 adjoint만큼 조옮김을 사용한다고 말하는 것이 흥미롭습니다. 나는 예전과 같았지만 대부분 내 데이터가 실제인 곳에서 실수를 하는 경향이 있었기 때문에 전치하는 경향이 있었지만 실제로 adjoint는 올바른 연산이었습니다(복잡한 경우로 일반화됨 - adjoint는 내 알고리즘에 대한 올바른 연산이었습니다). 물론 (많은) 유효한 예외가 있습니다.

전기 역학과 관련된 모든 것에서 종종 공간과 같은 벡터를 사용하고 R^n(일반적으로 n=3)에서 벡터 연산을 사용하려고 합니다. 특히 transpose 입니다. 푸리에 변환을 취했습니다. @mattcbro 가 이런 종류의 응용 프로그램에 대해 이야기하는 것 같습니다.

즉, 구문 토론을 읽을 때 개인적으로 약간 더 장황한 구문이 프로그래밍 속도나 효율성을 늦추는 것이라고는 상상할 수 없다는 생각을 자주 합니다. 알고리즘 자체와 이를 구현하는 가장 자연스럽고 효율적인 방법에 대해 생각하는 것은 훨씬 더 많은 시간이 걸립니다.

전기 역학과 관련된 모든 것에서 종종 공간과 같은 벡터를 사용하고 R^n(일반적으로 n=3)에서 벡터 연산을 사용하려고 합니다. 변환.

반드시는 아닙니다. 종종 푸리에 진폭에서 시간 평균 양을 원합니다. 이 경우 복소수 내적을 사용합니다. 예를 들어 ½ℜ[𝐄*×𝐇]은 복소 푸리에 구성요소의 시간 평균 포인팅 플럭스이고 ¼ε₀|𝐄|²는 a입니다. 시간 평균 진공 에너지 밀도. 반면에 Maxwell 연산자는 (일반적으로) 복소 대칭 연산자("역수")이므로 필드 𝐄(𝐱) 등에 대한 (무한 차원) 대수에 대해 비공액 "내적"을 사용하는 경우가 많습니다. 모든 공간.

맞습니다. 첫 문장에 단어가 자주 있었지만 분명히 제거했습니다 :-).

거기에 가고 싶다면 전자기 양은 종종 기하 대수라고 불리는 Clifford Algebraic 공식으로 훨씬 더 간결하게 작성됩니다. 이러한 대수학에는 특히 산란 문제를 고려할 때 이론의 공식화에 중요한 역할을 하는 다중 자기형성 및 반자동형성이 있습니다.

이러한 대수학은 일반적으로 간결한 행렬 표현을 가지며 이러한 형태는 종종 복잡한 전치, 에르미트 전치 및 켤레를 통해 쉽게 계산됩니다.

그럼에도 불구하고 앞서 언급했듯이 전치의 주요 용도는 종종 다른 배열, 다른 코드와 인터페이스하도록 배열을 정렬하고 평평한 배열의 올바른 차원에 대해 작동하도록 행렬 곱을 얻는 것입니다.

나는 개인적으로 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 "should"가 getproperty(x, Val(:T)) 로 낮아졌다는 것을 의미하는지 궁금합니다. 나는 그것이 가난한 컴파일러에게 무엇을 할 것인지 생각하면 몸서리를 친다.

모든 사람이 자신의 의견을 갖고 있다고 확신합니다. 하지만 나에게는 점 구문으로 일반 인터페이스를 구축하기 어렵다는 거의 특징입니다. 오해하지 마세요. 명명된 튜플과 유사한 구조 등을 정의하는 데 정말 좋은 기능이며 훌륭합니다.

(또한 Val 디스패치 레이어를 유형에 매우 쉽게 추가할 수 있습니다.)

@c42f 의 코드는 매력처럼 작동합니다. 불행히도 저는 버전 0.64 이상에서 작동하는 코드를 작성하려고 하고 있습니다. 이로 인해 전치 또는 제가 정의한 함수 T(A) = transpose(A)를 사용해야 합니다. 아마도 매크로가 조금 더 깨끗하고 약간 더 효율적이었을 것입니다.

명확히 하자면, 이 특정 getproperty 를 정의하는 것이 사용자 코드에 좋은 아이디어라고 제안하는 것은 아닙니다. 장기적으로 문제를 일으킬 가능성이 높습니다 ;-) 언젠가는 Base x.T 가 정의될 ​​수 있는 결과에 대해 충분히 느낄 수 있을 것입니다.

그러나 일반적으로 일반 인터페이스에서 "게터"를 정의하기 위한 이러한 종류의 속성 사용이 실제로 나쁜 이유가 궁금합니다. 예를 들어, 일반 필드 getter 함수는 현재 getproperty 를 현명하게 사용하면 간단히 해결되는 엄청나게 큰 네임스페이스 문제를 가지고 있습니다. MyModule.A(x) , get_my_A(x) 와 같은 더 길고 못생긴 함수 이름을 작성하거나 사용자로부터 매우 일반적인 이름 A 을 내보내는 것보다 x.A 를 작성하는 것이 훨씬 좋습니다. 기준 치수. 내가 보는 유일한 문제는 .A 가 슈퍼 유형에서 일반적으로 정의되는 것과 독립적으로 하위 유형에 대해 .B 의 의미를 재정의할 수 있는 예상되는 기능입니다. 따라서 Val 에 대한 반쯤 진지한 의견입니다.

재미있는 아이디어:

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

이 캐릭터는 T 처럼 보이지만 실제로는 그 위에 막대가 있는 ' 입니다. 심각한지는 모르겠지만...

예, GitHub에서도 그렇게 보입니다. 하지만 오버바입니다. 내 터미널 쇼에 복사하여 붙여넣기:

너무 똑똑하고 귀엽다. 나는 여전히 결합 문자를 좋아하고 'ᵀ 가 좋다고 생각합니다.

-100 to 변경 adjoint, Julia 코드 작성을 수학 작성만큼 명확하게 만드는 멋진 것 중 하나에 플러스 켤레 전치 일반적으로 원하는 것이므로 축약된 구문을 사용하는 것이 좋습니다.

이런 말에는 어느 정도 오만함이 있습니다. 유한한 비율의 개발자가 adjoint() 를 명시적으로 _원하지 않지만_ transpose() _필요합니다.

기본 ' 연산자를 모델링하기 위한 기호 계산으로 작업하는 경우와 요점은 예를 들어 의사 역 (A'*A)\(A *b) 또는 2차 형식 v'*A*v 이 잘못 반환되는 원인이 됩니다. 줄일 수 없는 길고 복잡한 결과.

솔루션은 ' 의 의미를 선언하는 일종의 컴파일러 지시문일 수 있습니다.